Tutorial sulla chiamata di funzione

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

La chiamata di funzioni semplifica l'ottenimento di output di dati strutturati dai modelli generativi. Puoi quindi utilizzare questi output per chiamare altre API e restituire al modello i dati di risposta pertinenti. In altre parole, le chiamate di funzione ti aiutano a collegare i 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 di funzioni che scrivi nel linguaggio della tua app (ovvero non sono funzioni Google Cloud). Il modello potrebbe chiederti di chiamare una funzione e di inviare nuovamente il risultato per aiutarlo a gestire la tua query.

Se non l'hai ancora fatto, consulta la sezione Introduzione alle chiamate di funzione per saperne di più.

API di esempio per il controllo dell'illuminazione

Immagina di avere un sistema di controllo dell'illuminazione di base con un'API (Application Programming Interface) 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 di illuminazione. Questo ipotetico sistema di controllo dell'illuminazione ti consente di regolare la luminosità della luce e la sua temperatura di colore, definite come due parametri distinti:

Per semplicità, questo sistema di illuminazione immaginario ha una sola luce, quindi l'utente non deve specificare una stanza o una posizione. Ecco un esempio di richiesta JSON che puoi inviare all'API di controllo dell'illuminazione per impostare il livello di illuminazione 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 configurare il progetto e la chiave API.

Definire una funzione API

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

async function setLightValues(brightness, colorTemp) {
  // This mock API returns the requested lighting values
  return {
    brightness: brightness,
    colorTemperature: colorTemp
  };
}

Crea dichiarazioni di funzione

Crea la dichiarazione di funzione da passare al modello generativo. Quando dichiari una funzione da utilizzare dal modello, devi includere il maggior numero possibile di dettagli nelle descrizioni della funzione 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 codice seguente mostra come dichiarare la funzione di controllo dell'illuminazione:

// Function declaration, to pass to the model.
const controlLightFunctionDeclaration = {
  name: "controlLight",
  parameters: {
    type: "OBJECT",
    description: "Set the brightness and color temperature of a room light.",
    properties: {
      brightness: {
        type: "NUMBER",
        description: "Light level from 0 to 100. Zero is off and 100 is full brightness.",
      },
      colorTemperature: {
        type: "STRING",
        description: "Color temperature of the light fixture which can be `daylight`, `cool` or `warm`.",
      },
    },
    required: ["brightness", "colorTemperature"],
  },
};

// Executable function code. Put it in a map keyed by the function name
// so that you can call it once you get the name string from the model.
const functions = {
  controlLight: ({ brightness, colorTemp }) => {
    return setLightValues( brightness, colorTemp)
  }
};

Dichiarare le funzioni durante l'inizializzazione del modello

Quando vuoi utilizzare la chiamata di funzioni con un modello, devi fornire le dichiarazioni di funzione quando inizili l'oggetto modello. Dichiari le funzioni impostando il parametro tools del modello:

<html>
  <body>
    <!-- ... Your HTML and CSS -->

    <script type="importmap">
      {
        "imports": {
          "@google/generative-ai": "https://esm.run/@google/generative-ai"
        }
      }
    </script>
    <script type="module">
      import { GoogleGenerativeAI } from "@google/generative-ai";

      // Fetch your API_KEY
      const API_KEY = "...";

      // Access your API key (see "Set up your API key" above)
      const genAI = new GoogleGenerativeAI(API_KEY);

      // ...

      const generativeModel = genAI.getGenerativeModel({
        // Use a model that supports function calling, like a Gemini 1.5 model
        model: "gemini-1.5-flash",

        // Specify the function declaration.
        tools: {
          functionDeclarations: [controlLightFunctionDeclaration],
        },
      });
    </script>
  </body>
</html>

Generare una chiamata di funzione

Dopo aver inizializzato il modello con le dichiarazioni delle funzioni, puoi chiedere al modello di eseguire la funzione definita. Ti consigliamo di utilizzare le chiamate di funzione con i prompt di chat (sendMessage()), poiché in genere le chiamate di funzione traggono vantaggio dal contesto dei prompt e delle risposte precedenti.

const chat = generativeModel.startChat();
const prompt = "Dim the lights so the room feels cozy and warm.";

// Send the message to the model.
const result = await chat.sendMessage(prompt);

// For simplicity, this uses the first function call found.
const call = result.response.functionCalls()[0];

if (call) {
  // Call the executable function named in the function call
  // with the arguments specified in the function call and
  // let it call the hypothetical API.
  const apiResponse = await functions[call.name](call.args);

  // Send the API response back to the model so it can generate
  // a text response that can be displayed to the user.
  const result = await chat.sendMessage([{functionResponse: {
    name: 'controlLight',
    response: apiResponse
  }}]);

  // Log the text response.
  console.log(result.response.text());
}