Tutorial sulla chiamata di funzione

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

La chiamata di funzione semplifica l'ottenimento di output di dati strutturati da modelli generativi. Puoi quindi utilizzare questi output per chiamare altre API e restituire i dati di risposta pertinenti al modello. In altre parole, le chiamate di funzione consentono di collegare modelli generativi a sistemi esterni, in modo che i contenuti generati includano le informazioni più aggiornate e accurate.

Puoi fornire ai modelli Gemini descrizioni delle funzioni. Si tratta delle funzioni che scrivi nella lingua della tua app (ovvero non sono Google Cloud Functions). Il modello potrebbe chiederti di richiamare una funzione e restituire il risultato per aiutare il modello a gestire la query.

Se non lo hai già fatto, consulta Introduzione alle chiamate di funzione per saperne di più.

API di esempio per il controllo dell'illuminazione

Immagina di avere un sistema di base per il controllo dell'illuminazione con un'interfaccia di programmazione di un'applicazione (API) e di voler consentire agli utenti di controllare le luci tramite semplici richieste di testo. Puoi utilizzare la funzionalità di chiamata di funzione per interpretare le richieste di modifica dell'illuminazione da parte degli utenti e tradurle in chiamate API per impostare i valori dell'illuminazione. Questo ipotetico sistema di controllo dell'illuminazione consente di controllare la luminosità della luce e la sua temperatura di colore, definita come due parametri separati:

Per semplicità, questo sistema di illuminazione immaginario ha una sola illuminazione, quindi l'utente non deve specificare una stanza o un luogo. Ecco un esempio di richiesta JSON che potresti inviare all'API di controllo della luce per modificare il livello della luce al 50% utilizzando la temperatura di colore della luce diurna:

{
  "brightness": "50",
  "colorTemperature": "daylight"
}

Questo tutorial mostra come configurare una chiamata di funzione per l'API Gemini per interpretare le richieste di illuminazione degli utenti e mapparle alle impostazioni dell'API per controllare i valori di luminosità e temperatura di colore di una luce.

Prima di iniziare: configura il progetto e la chiave API

Prima di chiamare l'API Gemini, devi impostare il progetto e configurare la chiave API.

Definisci una funzione API

Creare una funzione che invia una richiesta API. Questa funzione dovrebbe essere definita all'interno del codice dell'applicazione, ma potrebbe chiamare servizi o API al di fuori dell'applicazione. L'API Gemini non chiama direttamente questa funzione, quindi puoi controllare come e quando questa funzione viene eseguita tramite il codice della tua applicazione. A scopo dimostrativo, questo tutorial definisce una funzione API simulata che restituisce semplicemente i valori di illuminazione richiesti:

func setLightValues(brightness int, colorTemp string) map[string]any {
    // This mock API returns the requested lighting values
    return map[string]any{
        "brightness":       brightness,
        "colorTemperature": colorTemp}
}

crea una dichiarazione di funzione

Crea la dichiarazione di funzione che passerai al modello generativo. Quando dichiari una funzione per l'utilizzo da parte del modello, devi includere il maggior numero possibile di dettagli nelle descrizioni delle funzioni e dei parametri. Il modello generativo utilizza queste informazioni per determinare quale funzione selezionare e come fornire valori per i parametri nella chiamata di funzione. Il seguente codice mostra come dichiarare la funzione di controllo dell'illuminazione:

lightControlTool := &genai.Tool{
    FunctionDeclarations: []*genai.FunctionDeclaration{{
        Name:        "controlLight",
        Description: "Set the brightness and color temperature of a room light.",
        Parameters: &genai.Schema{
            Type: genai.TypeObject,
            Properties: map[string]*genai.Schema{
                "brightness": {
                    Type:        genai.TypeString,
                    Description: "Light level from 0 to 100. Zero is off and"+
                        " 100 is full brightness.",
                },
                "colorTemperature": {
                    Type:        genai.TypeString,
                    Description: "Color temperature of the light fixture which" +
                        " can be `daylight`, `cool` or `warm`.",
                },
            },
            Required: []string{"currencyDate", "currencyFrom"},
        },
    }},
}

Dichiara le funzioni durante l'inizializzazione del modello

Se vuoi utilizzare le chiamate di funzione con un modello, devi fornire le dichiarazioni di funzione al momento dell'inizializzazione dell'oggetto di modello. Dichiari le funzioni impostando il parametro Tools del modello:

// ...

lightControlTool := &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{lightControlTool}

Genera una chiamata di funzione

Dopo aver inizializzato il modello con le dichiarazioni di funzione, puoi inviare un prompt al modello con la funzione definita. Dovresti usare le chiamate di funzione tramite i prompt di chat (SendMessage()), poiché in genere le chiamate di funzione traggono vantaggio dal contesto dei prompt e delle risposte precedenti.

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

prompt := "Dim the lights so the room feels cozy and warm."

// 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, lightControlTool.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{
    "brightness":  "30",
    "colorTemperature":  "warm" }

// 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:     lightControlTool.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)
}