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-Paket installieren und das Modell initialisieren.

go get github.com/google/generative-ai-go

import "github.com/google/generative-ai-go/genai"
import "google.golang.org/api/option"

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

// Use a model that supports function calling, like a Gemini 1.5 model
model := client.GenerativeModel("gemini-1.5-flash")

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.

func exchangeRate(currencyDate string,
    currencyFrom string, currencyTo string) map[string]any {
    // This hypothetical API returns a JSON such as:
    // {"base":"USD","date":"2024-04-17","rates":{"SEK": 0.091}}
    return map[string]any{
        "base":  currencyFrom,
        "date":  currencyDate,
        "rates": map[string]any{currencyTo: 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.

currencyExchangeTool := &genai.Tool{
    FunctionDeclarations: []*genai.FunctionDeclaration{{
        Name:        "exchangeRate",
        Description: "Lookup currency exchange rates by date",
        Parameters: &genai.Schema{
            Type: genai.TypeObject,
            Properties: map[string]*genai.Schema{
                "currencyDate": {
                    Type:        genai.TypeString,
                    Description: "A date that must always be in YYYY-MM-DD format" +
                        " or the value 'latest' if a time period is not specified",
                },
                "currencyFrom": {
                    Type:        genai.TypeString,
                    Description: "Currency to convert from",
                },
                "currencyTo": {
                    Type:        genai.TypeString,
                    Description: "Currency to convert to",
                },
            },
            Required: []string{"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:

// ...

currencyExchangeTool := &genai.Tool{
  // ...
}

// Use a model that supports function calling, like a Gemini 1.5 model
model := client.GenerativeModel("gemini-1.5-flash")

// Specify the function declaration.
model.Tools = []*genai.Tool{currencyExchangeTool}

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.

// Start new chat session.
session := model.StartChat()

prompt := "How much is 50 US dollars worth in Swedish krona?"

// Send the message to the generative model.
resp, err := session.SendMessage(ctx, genai.Text(prompt))
if err != nil {
    log.Fatalf("Error sending message: %v\n", err)
}

// Check that you got the expected function call back.
part := resp.Candidates[0].Content.Parts[0]
funcall, ok := part.(genai.FunctionCall)
if !ok {
    log.Fatalf("Expected type FunctionCall, got %T", part)
}
if g, e := funcall.Name, currencyExchangeTool.FunctionDeclarations[0].Name; g != e {
    log.Fatalf("Expected FunctionCall.Name %q, got %q", e, g)
}
fmt.Printf("Received function call response:\n%q\n\n", part)

apiResult := map[string]any{
    "base":  "USD",
    "date":  "2024-04-17",
    "rates": map[string]any{"SEK": 0.091}}

// Send the hypothetical API result back to the generative model.
fmt.Printf("Sending API result:\n%q\n\n", apiResult)
resp, err = session.SendMessage(ctx, genai.FunctionResponse{
    Name:     currencyExchangeTool.FunctionDeclarations[0].Name,
    Response: apiResult,
})
if err != nil {
    log.Fatalf("Error sending message: %v\n", err)
}

// Show the model's response, which is expected to be text.
for _, part := range resp.Candidates[0].Content.Parts {
    fmt.Printf("%v\n", part)
}