Générer du texte à l'aide de l'API Gemini

L'API Gemini peut générer une sortie textuelle lorsqu'elle reçoit du texte, des images, des vidéos et des contenus audio en entrée.

Ce guide vous explique comment générer du texte à l'aide des méthodes generateContent et streamGenerateContent. Pour en savoir plus sur l'utilisation des fonctionnalités de vision et audio de Gemini, consultez les guides Vision et Audio.

Avant de commencer: configurer votre projet et votre clé API

Avant d'appeler l'API Gemini, vous devez configurer votre projet et votre clé API.

Générer du texte à partir d'une entrée textuelle

Le moyen le plus simple de générer du texte à l'aide de l'API Gemini consiste à fournir au modèle une seule entrée textuelle, comme illustré dans cet exemple :

// Make sure to include these imports:
// import { GoogleGenerativeAI } from "@google/generative-ai";
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });

const prompt = "Write a story about a magic backpack.";

const result = await model.generateContent(prompt);
console.log(result.response.text());
text_generation.js

Dans ce cas, la requête ("Écrire une histoire sur un sac à dos magique") n'inclut pas d'exemples de sortie, d'instructions système ni d'informations de mise en forme. Il s'agit d'une approche sans objectif. Dans certains cas d'utilisation, une invite one-shot ou few-shot peut produire un résultat plus conforme aux attentes des utilisateurs. Dans certains cas, vous pouvez également fournir des instructions système pour aider le modèle à comprendre la tâche ou à suivre des consignes spécifiques.

Générer du texte à partir d'une entrée texte-image

L'API Gemini accepte les entrées multimodales qui combinent du texte et des fichiers multimédias. L'exemple suivant montre comment générer du texte à partir d'une entrée texte et image :

// Make sure to include these imports:
// import { GoogleGenerativeAI } from "@google/generative-ai";
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });

function fileToGenerativePart(path, mimeType) {
  return {
    inlineData: {
      data: Buffer.from(fs.readFileSync(path)).toString("base64"),
      mimeType,
    },
  };
}

const prompt = "Describe how this product might be manufactured.";
// Note: The only accepted mime types are some image types, image/*.
const imagePart = fileToGenerativePart(
  `${mediaPath}/jetpack.jpg`,
  "image/jpeg",
);

const result = await model.generateContent([prompt, imagePart]);
console.log(result.response.text());
text_generation.js

Comme pour les requêtes textuelles, les requêtes multimodales peuvent impliquer différentes approches et améliorations. En fonction du résultat de cet exemple, vous pouvez ajouter des étapes à l'invite ou être plus spécifique dans vos instructions. Pour en savoir plus, consultez la section Stratégies d'invite de fichier.

Générer un flux de texte

Par défaut, le modèle renvoie une réponse une fois le processus de génération de texte terminé. Vous pouvez obtenir des interactions plus rapides en n'attendant pas l'intégralité du résultat et en utilisant plutôt le traitement par flux pour gérer les résultats partiels.

L'exemple suivant montre comment implémenter le streaming à l'aide de la méthode streamGenerateContent pour générer du texte à partir d'une invite de saisie en texte brut.

// Make sure to include these imports:
// import { GoogleGenerativeAI } from "@google/generative-ai";
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });

const prompt = "Write a story about a magic backpack.";

const result = await model.generateContentStream(prompt);

// Print text as it comes in.
for await (const chunk of result.stream) {
  const chunkText = chunk.text();
  process.stdout.write(chunkText);
}
text_generation.js

Créer un chat interactif

Vous pouvez utiliser l'API Gemini pour créer des expériences de chat interactives pour vos utilisateurs. L'utilisation de la fonctionnalité de chat de l'API vous permet de collecter plusieurs séries de questions et de réponses, ce qui permet aux utilisateurs d'obtenir des réponses par étapes ou de l'aide pour résoudre des problèmes en plusieurs parties. Cette fonctionnalité est idéale pour les applications qui nécessitent une communication continue, telles que les chatbots, les tuteurs interactifs ou les assistants du service client.

L'exemple de code suivant illustre une implémentation de chat de base:

// Make sure to include these imports:
// import { GoogleGenerativeAI } from "@google/generative-ai";
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });
const chat = model.startChat({
  history: [
    {
      role: "user",
      parts: [{ text: "Hello" }],
    },
    {
      role: "model",
      parts: [{ text: "Great to meet you. What would you like to know?" }],
    },
  ],
});
let result = await chat.sendMessage("I have 2 dogs in my house.");
console.log(result.response.text());
result = await chat.sendMessage("How many paws are in my house?");
console.log(result.response.text());
chat.js

Activer le streaming du chat

Vous pouvez également utiliser le streaming avec le chat, comme illustré dans l'exemple suivant:

// Make sure to include these imports:
// import { GoogleGenerativeAI } from "@google/generative-ai";
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });
const chat = model.startChat({
  history: [
    {
      role: "user",
      parts: [{ text: "Hello" }],
    },
    {
      role: "model",
      parts: [{ text: "Great to meet you. What would you like to know?" }],
    },
  ],
});
let result = await chat.sendMessageStream("I have 2 dogs in my house.");
for await (const chunk of result.stream) {
  const chunkText = chunk.text();
  process.stdout.write(chunkText);
}
result = await chat.sendMessageStream("How many paws are in my house?");
for await (const chunk of result.stream) {
  const chunkText = chunk.text();
  process.stdout.write(chunkText);
}
chat.js

Configurer la génération de texte

Chaque requête que vous envoyez au modèle inclut des paramètres qui contrôlent la manière dont le modèle génère des réponses. Vous pouvez utiliser GenerationConfig pour configurer ces paramètres. Si vous ne configurez pas les paramètres, le modèle utilise des options par défaut, qui peuvent varier selon le modèle.

L'exemple suivant montre comment configurer plusieurs des options disponibles.

// Make sure to include these imports:
// import { GoogleGenerativeAI } from "@google/generative-ai";
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
const model = genAI.getGenerativeModel({
  model: "gemini-1.5-flash",
  generationConfig: {
    candidateCount: 1,
    stopSequences: ["x"],
    maxOutputTokens: 20,
    temperature: 1.0,
  },
});

const result = await model.generateContent(
  "Tell me a story about a magic backpack.",
);
console.log(result.response.text());
model_configuration.js

candidateCount spécifie le nombre de réponses générées à renvoyer. Actuellement, cette valeur ne peut être définie que sur 1. Si cette valeur n'est pas définie, elle est définie par défaut sur 1.

stopSequences spécifie l'ensemble de séquences de caractères (jusqu'à cinq) qui met fin à la génération de sortie. Si elle est spécifiée, l'API s'arrête à la première apparition d'une séquence d'arrêts. La séquence d'arrêt ne sera pas incluse dans la réponse.

maxOutputTokens définit le nombre maximal de jetons à inclure dans un candidat.

temperature contrôle le caractère aléatoire de la sortie. Utilisez des valeurs plus élevées pour des réponses plus créatives et des valeurs inférieures pour des réponses plus déterministes. Les valeurs peuvent être comprises entre [0,0 et 2,0].

Vous pouvez également configurer des appels individuels à generateContent:

const result = await model.generateContent({
  contents: [
    {
      role: 'user',
      parts: [
        {
          text: prompt,
        }
      ],
    }
  ],
  generationConfig: {
    maxOutputTokens: 1000,
    temperature: 0.1,
  },
});
console.log(result.response.text());

Toutes les valeurs définies sur l'appel individuel remplacent les valeurs du constructeur du modèle.

Étape suivante

Maintenant que vous avez découvert les principes de base de l'API Gemini, vous pouvez essayer les éléments suivants:

  • Analyse visuelle: découvrez comment utiliser l'analyse visuelle native de Gemini pour traiter des images et des vidéos.
  • Instructions système : les instructions système vous permettent d'orienter le comportement du modèle en fonction de vos besoins et de vos cas d'utilisation spécifiques.
  • Compréhension audio: découvrez comment utiliser la compréhension audio native de Gemini pour traiter des fichiers audio.