Samouczek: wywoływanie funkcji za pomocą interfejsu Gemini API

Python Node.js Go Dart (Flutter) Android Swift Internet

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.

dart pub add google_generative_ai

flutter pub add google_generative_ai

import 'package:google_generative_ai/google_generative_ai.dart';

// Access your API key as an environment variable (see "Set up your API key" above)
final apiKey = Platform.environment['API_KEY'];
if (apiKey == null) {
  print('No \$API_KEY environment variable');
  exit(1);
}

// Use a model that supports function calling, like Gemini 1.0 Pro.
// See "Supported models" in the "Introduction to function calling" page.
final model = GenerativeModel(model: 'MODEL_NAME', apiKey: apiKey);

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:

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 Gemini 1.0 Pro
  // See "Supported models" in the "Introduction to function calling" page.
  model: 'gemini-1.0-pro',
  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);
}