Wywoływanie funkcji ułatwia uzyskiwanie uporządkowanych danych wyjściowych z modeli generatywnych. Następnie możesz użyć tych danych wyjściowych, aby wywoływać inne interfejsy API i zwracać odpowiednie dane odpowiedzi do modelu. Inaczej mówiąc, wywołania funkcji pomagają połączyć modele generatywne z systemami zewnętrznymi, aby generowane treści zawierały aktualne i dokładne informacje.
Modelom Gemini możesz podawać opisy funkcji. Są to funkcje, które piszesz w języku swojej aplikacji (nie należą one do Google Cloud Functions). Model może poprosić Cię o wywołanie funkcji i odesłanie wyniku, aby model mógł lepiej obsłużyć zapytanie.
Więcej informacji znajdziesz w wprowadzeniu do wywoływania funkcji.
Konfigurowanie projektu
Zanim wywołasz interfejs Gemini API, musisz skonfigurować projekt, który obejmuje skonfigurowanie klucza interfejsu API, dodanie pakietu SDK do zależności wydawcy i zainicjowanie modelu.
Konfigurowanie wywołania funkcji
W tym samouczku model będzie wchodzić w interakcje z hipotetycznym interfejsem API wymiany walut, który obsługuje te parametry:
Parametr | Typ | Wymagane | Opis |
---|---|---|---|
currencyDate
|
string, | tak | Data pobrania kursu wymiany dla (musi zawsze mieć format RRRR-MM-DD lub wartość latest , jeśli nie określono przedziału czasu) |
currencyFrom |
string, | tak | Waluta, z której chcesz przeliczyć |
currencyTo |
string, | nie | Waluta do przeliczenia |
Przykładowe żądanie do interfejsu API
{
"currencyDate": "2024-04-17",
"currencyFrom": "USD",
"currencyTo": "SEK"
}
Przykładowa odpowiedź interfejsu API
{
"base": "USD",
"date": "2024-04-17",
"rates": {"SEK": 0.091}
}
Krok 1. Utwórz funkcję, która wysyła żądanie do interfejsu API
Zacznij od utworzenia funkcji, która wysyła żądanie do interfejsu API.
Na potrzeby demonstracji w tym samouczku zamiast wysyłania rzeczywistego żądania do interfejsu API będziesz zwracać wartości zakodowane na stałe w tym samym formacie, w jakim jest zwrócony interfejs API.
Future<Map<String, Object?>> findExchangeRate(
Map<String, Object?> arguments,
) async =>
// This hypothetical API returns a JSON such as:
// {"base":"USD","date":"2024-04-17","rates":{"SEK": 0.091}}
{
'date': arguments['currencyDate'],
'base': arguments['currencyFrom'],
'rates': <String, Object?>{arguments['currencyTo'] as String: 0.091}
};
Krok 2. Utwórz deklarację funkcji
Utwórz deklarację funkcji, którą przekażesz do modelu generatywnego (następny krok tego samouczka).
W opisach funkcji i parametrów podaj jak najwięcej szczegółów. Model generatywny wykorzystuje te informacje do określenia, którą funkcję wybrać i jak podać wartości parametrów w jej wywołaniu.
final exchangeRateTool = FunctionDeclaration(
'findExchangeRate',
'Returns the exchange rate between currencies on given date.',
Schema(SchemaType.object, properties: {
'currencyDate': Schema(SchemaType.string,
description: 'A date in YYYY-MM-DD format or '
'the exact value "latest" if a time period is not specified.'),
'currencyFrom': Schema(SchemaType.string,
description: 'The currency code of the currency to convert from, '
'such as "USD".'),
'currencyTo': Schema(SchemaType.string,
description: 'The currency code of the currency to convert to, '
'such as "USD".')
}, requiredProperties: [
'currencyDate',
'currencyFrom'
]));
Krok 3. Określ deklarację funkcji podczas inicjowania modelu
Podczas inicjowania modelu generatywnego określ deklarację funkcji, przekazując ją do parametru tools
modelu:
final model = GenerativeModel(
// Use a model that supports function calling, like a Gemini 1.5 model
model: 'gemini-1.5-flash',
apiKey: apiKey,
// Specify the function declaration.
tools: [
Tool(functionDeclarations: [exchangeRateTool])
],
);
Krok 4. Wygeneruj wywołanie funkcji
Teraz możesz wywołać dla modelu zdefiniowaną funkcję.
Zalecanym sposobem korzystania z wywołań funkcji jest korzystanie z interfejsu czatu, ponieważ wywołania funkcji dobrze pasują do wieloetapowej struktury czatu.
final chat = model.startChat();
final prompt = 'How much is 50 US dollars worth in Swedish krona?';
// Send the message to the generative model.
var response = await chat.sendMessage(Content.text(prompt));
final functionCalls = response.functionCalls.toList();
// When the model response with a function call, invoke the function.
if (functionCalls.isNotEmpty) {
final functionCall = functionCalls.first;
final result = switch (functionCall.name) {
// Forward arguments to the hypothetical API.
'findExchangeRate' => await findExchangeRate(functionCall.args),
// Throw an exception if the model attempted to call a function that was
// not declared.
_ => throw UnimplementedError(
'Function not implemented: ${functionCall.name}')
};
// Send the response to the model so that it can use the result to generate
// text for the user.
response = await chat
.sendMessage(Content.functionResponse(functionCall.name, result));
}
// When the model responds with non-null text content, print it.
if (response.text case final text?) {
print(text);
}