Tutoriel: Appeler une fonction avec l'API Gemini

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

Les appels de fonctions vous permettent d'obtenir plus facilement des sorties de données structurées à partir de modèles génératifs. Vous pouvez ensuite utiliser ces sorties pour appeler d'autres API et renvoyer les données de réponse pertinentes au modèle. En d'autres termes, l'appel de fonction vous aide à connecter des modèles génératifs à des systèmes externes afin que le contenu généré inclue les informations les plus récentes et les plus précises.

Vous pouvez fournir aux modèles Gemini des descriptions de fonctions. Il s'agit de fonctions que vous écrivez dans le langage de votre application (il ne s'agit pas de fonctions Google Cloud). Le modèle peut vous demander d'appeler une fonction et de renvoyer le résultat pour l'aider à gérer votre requête.

Si vous ne l'avez pas déjà fait, consultez l'article Présentation des appels de fonctions pour en savoir plus.

Configurer votre projet

Avant d'appeler l'API Gemini, vous devez configurer votre projet, ce qui comprend la configuration de votre clé API, l'installation du package SDK et l'initialisation du modèle.

npm install @google/generative-ai

const { GoogleGenerativeAI } = require("@google/generative-ai");

// Access your API key as an environment variable (see "Set up your API key" above)
const genAI = new GoogleGenerativeAI(process.env.API_KEY);

// ...

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

// ...

Configurer un appel de fonction

Dans ce tutoriel, le modèle interagira avec une API d'échange de devises fictive qui accepte les paramètres suivants:

Exemple de requête API

{
  "currencyFrom": "USD",
  "currencyTo": "SEK"
}

Exemple de réponse de l'API

{
  "base": "USD",
  "rates": {"SEK": 0.091}
}

Étape 1: Créez la fonction qui envoie la requête API

Si vous ne l'avez pas déjà fait, commencez par créer la fonction qui envoie une requête API.

À des fins de démonstration dans ce tutoriel, au lieu d'envoyer une requête API réelle, vous renvoyez des valeurs codées en dur au même format que celui renvoyé par une API réelle.

async function makeApiRequest(currencyFrom, currencyTo) {
  // This hypothetical API returns a JSON such as:
  // {"base":"USD","rates":{"SEK": 0.091}}
  return {
    base: currencyFrom,
    rates: { [currencyTo]: 0.091 },
  };
}

Étape 2: Créez une déclaration de fonction

Créez la déclaration de fonction que vous transmettrez au modèle génératif (étape suivante de ce tutoriel).

Fournissez autant de détails que possible dans les descriptions des fonctions et des paramètres. Le modèle génératif utilise ces informations pour déterminer la fonction à sélectionner et comment fournir des valeurs pour les paramètres dans l'appel de fonction.

// Function declaration, to pass to the model.
const getExchangeRateFunctionDeclaration = {
  name: "getExchangeRate",
  parameters: {
    type: "OBJECT",
    description: "Get the exchange rate for currencies between countries",
    properties: {
      currencyFrom: {
        type: "STRING",
        description: "The currency to convert from.",
      },
      currencyTo: {
        type: "STRING",
        description: "The currency to convert to.",
      },
    },
    required: ["currencyTo", "currencyFrom"],
  },
};

// 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 = {
  getExchangeRate: ({ currencyFrom, currencyTo }) => {
    return makeApiRequest( currencyFrom, currencyTo)
  }
};

Étape 3: Spécifiez la déclaration de la fonction lors de l'initialisation du modèle

Spécifiez la déclaration de la fonction lors de l'initialisation du modèle génératif en définissant le paramètre tools du modèle:

const { GoogleGenerativeAI } = require("@google/generative-ai");

// Access your API key as an environment variable (see "Set up your API key" above)
const genAI = new GoogleGenerativeAI(process.env.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: [getExchangeRateFunctionDeclaration],
  },
});

Étape 4: Générez un appel de fonction

Vous pouvez maintenant envoyer une requête au modèle avec la fonction définie.

La méthode recommandée pour utiliser les appels de fonction consiste à passer par l'interface de chat, car les appels de fonction s'intègrent parfaitement à la structure multitours du chat.

const chat = generativeModel.startChat();
const prompt = "How much is 50 US dollars worth in Swedish krona?";

// 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 result2 = await chat.sendMessage([{functionResponse: {
    name: 'getExchangeRate',
    response: apiResponse
  }}]);

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