Anleitung: Funktionsaufruf mit der Gemini API

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

Funktionsaufrufe erleichtern Ihnen die Ausgabe strukturierter Daten aus generativen Modellen. Sie können diese Ausgaben dann verwenden, um andere APIs aufzurufen und die relevanten Antwortdaten an das Modell zurückzugeben. Mit anderen Worten: Funktionsaufrufe helfen Ihnen, generative Modelle mit externen Systemen zu verbinden, damit der generierte Inhalt die aktuellsten und genauesten Informationen enthält.

Sie können Gemini-Modelle mit Funktionsbeschreibungen bereitstellen. Dies sind Funktionen, die Sie in der Sprache Ihrer Anwendung schreiben (d. h. sie sind nicht Google Cloud Functions). Möglicherweise fordert das Modell Sie auf, eine Funktion aufzurufen und das Ergebnis zurückzusenden, um das Modell bei der Verarbeitung Ihrer Abfrage zu unterstützen.

Weitere Informationen finden Sie unter Einführung in Funktionsaufrufe.

Projekt einrichten

Bevor Sie die Gemini API aufrufen, müssen Sie Ihr Projekt einrichten. Dazu müssen Sie Ihren API-Schlüssel einrichten, das SDK den Pub-Abhängigkeiten hinzufügen und das Modell initialisieren.

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 a Gemini 1.5 model
final model = GenerativeModel(model: 'gemini-1.5-flash', apiKey: apiKey);

Funktionsaufruf einrichten

Im Rahmen dieser Anleitung interagiert das Modell mit einer hypothetischen Währungstausch-API, die die folgenden Parameter unterstützt:

Beispiel für eine API-Anfrage

{
  "currencyDate": "2024-04-17",
  "currencyFrom": "USD",
  "currencyTo": "SEK"
}

Beispiel für eine API-Antwort

{
  "base": "USD",
  "date": "2024-04-17",
  "rates": {"SEK": 0.091}
}

Schritt 1: Funktion erstellen, die die API-Anfrage stellt

Erstellen Sie zuerst die Funktion, die eine API-Anfrage stellt, falls noch nicht geschehen.

Zu Demonstrationszwecken werden in dieser Anleitung statt einer API-Anfrage hartcodierte Werte in demselben Format zurückgegeben, das eine echte API zurückgeben würde.

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}
    };

Schritt 2: Funktionsdeklaration erstellen

Erstellen Sie die Funktionsdeklaration, die Sie an das generative Modell übergeben (nächster Schritt dieser Anleitung).

Geben Sie so viele Details wie möglich in die Funktions- und Parameterbeschreibung ein. Das generative Modell verwendet diese Informationen, um zu bestimmen, welche Funktion ausgewählt werden soll und wie Werte für die Parameter im Funktionsaufruf bereitgestellt werden.

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'
    ]));

Schritt 3: Funktionsdeklaration bei der Modellinitialisierung angeben

Geben Sie die Funktionsdeklaration beim Initialisieren des generativen Modells an, indem Sie sie an den Parameter tools des Modells übergeben:

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])
  ],
);

Schritt 4: Funktionsaufruf generieren

Jetzt können Sie das Modell mit der definierten Funktion abfragen.

Die empfohlene Methode zum Verwenden von Funktionsaufrufen erfolgt über die Chat-Oberfläche, da Funktionsaufrufe gut in die Multi-Turn-Struktur eines Chats passen.

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);
}