Génération de texte

Cette page vous explique comment envoyer des requêtes de chat au modèle Gemini à l'aide de la console Google Cloud, de l'API REST et des SDK compatibles.

Pour savoir comment ajouter des images et d'autres contenus multimédias à votre requête, consultez la section Compréhension des images.

Pour obtenir la liste des langues compatibles avec Gemini, consultez la page Langues acceptées.


Pour explorer les modèles d'IA générative et les API disponibles sur Vertex AI, accédez à Model Garden dans la console Google Cloud.

Accéder à la page "Jardin de modèles"


Si vous recherchez une méthode pour utiliser Gemini directement à partir de vos applications mobiles et Web, consultez les SDK Vertex AI in Firebase pour les applications Android, Swift, Web et Flutter.

Pour tester et effectuez des itérations de requêtes de chat, nous vous recommandons d'utiliser la console Google Cloud. Pour envoyer des requêtes de façon programmatique au modèle, vous pouvez utiliser l'API REST, le SDK Vertex AI pour Python, ou l'une des autres bibliothèques et SDK compatibles présentés dans les onglets suivants.

Python

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API SDK Vertex AI pour Python.

Réponses en streaming et sans streaming

Vous pouvez choisir si le modèle génère des réponses en streaming ou sans streaming. Pour les réponses en streaming, vous recevez chaque réponse dès que son jeton de sortie est généré. Pour les réponses qui ne sont pas en streaming, vous recevez toutes les réponses une fois tous les jetons de sortie sont générés.

Pour une réponse en streaming, utilisez le paramètre stream dans generate_content.

  response = model.generate_content(contents=[...], stream = True)
  

Pour une réponse sans streaming, supprimez le paramètre ou définissez-le sur False.

Exemple de code

import vertexai

from vertexai.generative_models import GenerativeModel, ChatSession

# TODO(developer): Update and un-comment below line
# PROJECT_ID = "your-project-id"
vertexai.init(project=PROJECT_ID, location="us-central1")

model = GenerativeModel("gemini-1.5-flash-002")

chat_session = model.start_chat()

def get_chat_response(chat: ChatSession, prompt: str) -> str:
    text_response = []
    responses = chat.send_message(prompt, stream=True)
    for chunk in responses:
        text_response.append(chunk.text)
    return "".join(text_response)

prompt = "Hello."
print(get_chat_response(chat_session, prompt))
# Example response:
# Hello there! How can I help you today?

prompt = "What are all the colors in a rainbow?"
print(get_chat_response(chat_session, prompt))
# Example response:
# The colors in a rainbow are often remembered using the acronym ROY G. BIV:
# * **Red**
# * **Orange** ...

prompt = "Why does it appear when it rains?"
print(get_chat_response(chat_session, prompt))
# Example response:
# It's important to note that these colors blend smoothly into each other, ...

C#

Avant d'essayer cet exemple, suivez les instructions de configuration pour C# du guide de démarrage rapide de Vertex AI. Pour en savoir plus, consultez la documentation de référence de Vertex AI en langage C#.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'ADC pour un environnement de développement local.

Réponses en streaming et sans streaming

Vous pouvez choisir si le modèle génère des réponses en streaming ou sans streaming. Pour les réponses en streaming, vous recevez chaque réponse dès que son jeton de sortie est généré. Pour les réponses qui ne sont pas en streaming, vous recevez toutes les réponses une fois tous les jetons de sortie sont générés.

Pour une réponse en streaming, utilisez la méthode StreamGenerateContent.

  public virtual PredictionServiceClient.StreamGenerateContentStream StreamGenerateContent(GenerateContentRequest request)
  

Pour une réponse non affichée progressivement, utilisez la méthode GenerateContentAsync.

  public virtual Task<GenerateContentResponse> GenerateContentAsync(GenerateContentRequest request)
  

Pour en savoir plus sur la façon dont le serveur peut diffuser des réponses, consultez la section RPC de streaming.

Exemple de code


using Google.Cloud.AIPlatform.V1;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

public class MultiTurnChatSample
{
    public async Task<string> GenerateContent(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.5-flash-001"
    )
    {
        // Create a chat session to keep track of the context
        ChatSession chatSession = new ChatSession($"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}", location);

        string prompt = "Hello.";
        Console.WriteLine($"\nUser: {prompt}");

        string response = await chatSession.SendMessageAsync(prompt);
        Console.WriteLine($"Response: {response}");

        prompt = "What are all the colors in a rainbow?";
        Console.WriteLine($"\nUser: {prompt}");

        response = await chatSession.SendMessageAsync(prompt);
        Console.WriteLine($"Response: {response}");

        prompt = "Why does it appear when it rains?";
        Console.WriteLine($"\nUser: {prompt}");

        response = await chatSession.SendMessageAsync(prompt);
        Console.WriteLine($"Response: {response}");

        return response;
    }

    private class ChatSession
    {
        private readonly string _modelPath;
        private readonly PredictionServiceClient _predictionServiceClient;

        private readonly List<Content> _contents;

        public ChatSession(string modelPath, string location)
        {
            _modelPath = modelPath;

            _predictionServiceClient = new PredictionServiceClientBuilder
            {
                Endpoint = $"{location}-aiplatform.googleapis.com"
            }.Build();

            // Initialize contents to send over in every request.
            _contents = new List<Content>();
        }

        public async Task<string> SendMessageAsync(string prompt)
        {
            var content = new Content
            {
                Role = "USER",
                Parts =
                {
                    new Part { Text = prompt }
                }
            };
            _contents.Add(content);

            var generateContentRequest = new GenerateContentRequest
            {
                Model = _modelPath,
                GenerationConfig = new GenerationConfig
                {
                    Temperature = 0.9f,
                    TopP = 1,
                    TopK = 32,
                    CandidateCount = 1,
                    MaxOutputTokens = 2048
                }
            };
            generateContentRequest.Contents.AddRange(_contents);

            GenerateContentResponse response = await _predictionServiceClient.GenerateContentAsync(generateContentRequest);

            _contents.Add(response.Candidates[0].Content);

            return response.Candidates[0].Content.Parts[0].Text;
        }
    }
}

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js du guide de démarrage rapide de l'IA générative à l'aide du SDK Node.js. Pour en savoir plus, consultez la documentation de référence du SDK Node.js pour Gemini.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'ADC pour un environnement de développement local.

Réponses en streaming et sans streaming

Vous pouvez choisir si le modèle génère des réponses en streaming ou sans streaming. Pour les réponses en streaming, vous recevez chaque réponse dès que son jeton de sortie est généré. Pour les réponses qui ne sont pas en streaming, vous recevez toutes les réponses une fois tous les jetons de sortie sont générés.

Pour une réponse en streaming, utilisez la méthode generateContentStream.

  const streamingResp = await generativeModel.generateContentStream(request);
  

Pour une réponse non affichée progressivement, utilisez la méthode generateContent.

  const streamingResp = await generativeModel.generateContent(request);
  

Exemple de code

const {VertexAI} = require('@google-cloud/vertexai');

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function createStreamChat(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.5-flash-001'
) {
  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

  // Instantiate the model
  const generativeModel = vertexAI.getGenerativeModel({
    model: model,
  });

  const chat = generativeModel.startChat({});
  const chatInput1 = 'How can I learn more about that?';

  console.log(`User: ${chatInput1}`);

  const result1 = await chat.sendMessageStream(chatInput1);
  for await (const item of result1.stream) {
    console.log(item.candidates[0].content.parts[0].text);
  }
}

Java

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java du guide de démarrage rapide de Vertex AI. Pour en savoir plus, consultez la documentation de référence du SDK Vertex AI pour Java pour Gemini.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'ADC pour un environnement de développement local.

Réponses en streaming et sans streaming

Vous pouvez choisir si le modèle génère des réponses en streaming ou sans streaming. Pour les réponses en streaming, vous recevez chaque réponse dès que son jeton de sortie est généré. Pour les réponses qui ne sont pas en streaming, vous recevez toutes les réponses une fois tous les jetons de sortie sont générés.

Pour une réponse en streaming, utilisez la méthode generateContentStream.

  public ResponseStream<GenerateContentResponse> generateContentStream(Content content)
  

Pour une réponse non affichée progressivement, utilisez la méthode generateContent.

  public GenerateContentResponse generateContent(Content content)
  

Exemple de code

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.ChatSession;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.io.IOException;

public class ChatDiscussion {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-google-cloud-project-id";
    String location = "us-central1";
    String modelName = "gemini-1.5-flash-001";

    chatDiscussion(projectId, location, modelName);
  }

  // Ask interrelated questions in a row using a ChatSession object.
  public static void chatDiscussion(String projectId, String location, String modelName)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs
    // to be created once, and can be reused for multiple requests.
    try (VertexAI vertexAI = new VertexAI(projectId, location)) {
      GenerateContentResponse response;

      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      // Create a chat session to be used for interactive conversation.
      ChatSession chatSession = new ChatSession(model);

      response = chatSession.sendMessage("Hello.");
      System.out.println(ResponseHandler.getText(response));

      response = chatSession.sendMessage("What are all the colors in a rainbow?");
      System.out.println(ResponseHandler.getText(response));

      response = chatSession.sendMessage("Why does it appear when it rains?");
      System.out.println(ResponseHandler.getText(response));
      System.out.println("Chat Ended.");
    }
  }
}

Go

Avant d'essayer cet exemple, suivez les instructions de configuration pour Go du guide de démarrage rapide de Vertex AI. Pour en savoir plus, consultez la documentation de référence du SDK Vertex AI pour Go pour Gemini.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'ADC pour un environnement de développement local.

Réponses en streaming et sans streaming

Vous pouvez choisir si le modèle génère des réponses en streaming ou sans streaming. Pour les réponses en streaming, vous recevez chaque réponse dès que son jeton de sortie est généré. Pour les réponses qui ne sont pas en streaming, vous recevez toutes les réponses une fois tous les jetons de sortie sont générés.

Pour une réponse en streaming, utilisez la méthode GenerateContentStream.

  iter := model.GenerateContentStream(ctx, genai.Text("Tell me a story about a lumberjack and his giant ox. Keep it very short."))
  

Pour une réponse non affichée progressivement, utilisez la méthode GenerateContent.

  resp, err := model.GenerateContent(ctx, genai.Text("What is the average size of a swallow?"))
  

Exemple de code

import (
	"context"
	"encoding/json"
	"fmt"
	"io"

	"cloud.google.com/go/vertexai/genai"
)

func makeChatRequests(ctx context.Context, w io.Writer, projectID, region, modelName string) error {
	client, err := genai.NewClient(ctx, projectID, region)

	if err != nil {
		return fmt.Errorf("error creating client: %w", err)
	}
	defer client.Close()

	gemini := client.GenerativeModel(modelName)
	chat := gemini.StartChat()

	send := func(message string) error {
		r, err := chat.SendMessage(ctx, genai.Text(message))
		if err != nil {
			return err
		}
		rb, err := json.MarshalIndent(r, "", "  ")
		if err != nil {
			return err
		}
		fmt.Fprintln(w, string(rb))
		return nil
	}

	if err := send("Hello"); err != nil {
		return err
	}
	if err := send("What are all the colors in a rainbow?"); err != nil {
		return err
	}
	return send("Why does it appear when it rains?")
}

REST

Une fois que vous avez configuré votre environnement, vous pouvez utiliser REST pour tester une requête textuelle. L'exemple suivant envoie une requête au point de terminaison du modèle de l'éditeur.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • GENERATE_RESPONSE_METHOD : type de réponse que le modèle doit générer. Choisissez une méthode qui génère le mode de renvoi de la réponse du modèle :
    • streamGenerateContent : la réponse est affichée progressivement à mesure qu'elle est générée afin de réduire la perception de la latence auprès d'un public humain.
    • generateContent : la réponse est renvoyée une fois qu'elle a été entièrement générée.
  • LOCATION : région dans laquelle traiter la requête. Les options disponibles sont les suivantes :

    Cliquer pour développer une liste partielle des régions disponibles

    • us-central1
    • us-west4
    • northamerica-northeast1
    • us-east4
    • us-west1
    • asia-northeast3
    • asia-southeast1
    • asia-northeast1
  • PROJECT_ID : l'ID de votre projet.
  • MODEL_ID : ID du modèle multimodal que vous souhaitez utiliser. Voici quelques options possibles :
    • gemini-1.0-pro-002
    • gemini-1.0-pro-vision-001
    • gemini-1.5-pro-002
    • gemini-1.5-flash
  • TEXT1
    Instructions textuelles à inclure dans la première requête de la conversation multitours. Par exemple, What are all the colors in a rainbow?.
  • TEXT2
    Instructions textuelles à inclure dans la requête. Par exemple, Why does it appear when it rains?.
  • TEMPERATURE : La température est utilisée pour l'échantillonnage pendant la génération des réponses, qui se produit lorsque topP et topK sont appliqués. La température permet de contrôler le degré de hasard dans la sélection des jetons. Les températures inférieures sont idéales pour les requêtes qui nécessitent une réponse moins ouverte ou créative, tandis que des températures plus élevées peuvent conduire à des résultats plus diversifiés ou créatifs. Une température de 0 signifie que les jetons de probabilité les plus élevés sont toujours sélectionnés. Dans ce cas, les réponses pour une requête donnée sont principalement déterministes, mais une petite quantité de variation est toujours possible.

    Si le modèle renvoie une réponse trop générique ou trop courte, ou s'il renvoie une réponse de remplacement, essayez d'augmenter la température.

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé request.json. Exécutez la commande suivante dans le terminal pour créer ou écraser ce fichier dans le répertoire actuel :

cat > request.json << 'EOF'
{
  "contents": [
    {
      "role": "user",
      "parts": { "text": "TEXT1" }
    },
    {
      "role": "model",
      "parts": { "text": "What a great question!" }
    },
    {
      "role": "user",
      "parts": { "text": "TEXT2" }
    }
  ],
  "generation_config": {
    "temperature": TEMPERATURE
  }
}
EOF

Exécutez ensuite la commande suivante pour envoyer votre requête REST :

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
"https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:GENERATE_RESPONSE_METHOD"

PowerShell

Enregistrez le corps de la requête dans un fichier nommé request.json. Exécutez la commande suivante dans le terminal pour créer ou écraser ce fichier dans le répertoire actuel :

@'
{
  "contents": [
    {
      "role": "user",
      "parts": { "text": "TEXT1" }
    },
    {
      "role": "model",
      "parts": { "text": "What a great question!" }
    },
    {
      "role": "user",
      "parts": { "text": "TEXT2" }
    }
  ],
  "generation_config": {
    "temperature": TEMPERATURE
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

Exécutez ensuite la commande suivante pour envoyer votre requête REST :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:GENERATE_RESPONSE_METHOD" | Select-Object -Expand Content

Vous devriez recevoir une réponse JSON semblable à la suivante.

Notez les points suivants dans l'URL de cet exemple :
  • Utilisez la méthode generateContent pour demander que la réponse soit renvoyée une fois qu'elle a été entièrement générée. Pour réduire la perception de la latence auprès d'un public humain, affichez la réponse progressivement à mesure qu'elle est générée à l'aide de la méthode streamGenerateContent.
  • L'ID du modèle multimodal se trouve à la fin de l'URL avant la méthode (par exemple, gemini-1.5-flash ou gemini-1.0-pro-vision). Cet exemple peut également s'appliquer à d'autres modèles.

Console

Pour tester une requête de chat dans la console Google Cloud à l'aide de Generative AI Studio, procédez comme suit :

  1. Dans la section "Vertex AI" de la console Google Cloud, accédez à la page Vertex AI Studio.

    Accéder à Vertex AI Studio

  2. Dans Démarrer une conversation, cliquez sur Chat textuel.
  3. Facultatif : Configurez le modèle et les paramètres :

    • Modèle : sélectionnez Gemini Pro.
    • Région : sélectionnez la région que vous souhaitez utiliser.
    • Température : utilisez le curseur ou la zone de texte pour saisir une valeur de température.

      La température est utilisée pour l'échantillonnage pendant la génération des réponses, qui se produit lorsque topP et topK sont appliqués. La température permet de contrôler le degré de hasard dans la sélection des jetons. Les températures inférieures sont idéales pour les requêtes qui nécessitent une réponse moins ouverte ou créative, tandis que des températures plus élevées peuvent conduire à des résultats plus diversifiés ou créatifs. Une température de 0 signifie que les jetons de probabilité les plus élevés sont toujours sélectionnés. Dans ce cas, les réponses pour une requête donnée sont principalement déterministes, mais une petite quantité de variation est toujours possible.

      Si le modèle renvoie une réponse trop générique ou trop courte, ou s'il renvoie une réponse de remplacement, essayez d'augmenter la température.

    • Limite de jeton : utilisez le curseur ou la zone de texte pour saisir une valeur correspondant à la limite maximale de sortie.

      Nombre maximal de jetons pouvant être générés dans la réponse. Un jeton correspond environ à quatre caractères. 100 jetons correspondent à environ 60-80 mots.

      Spécifiez une valeur inférieure pour obtenir des réponses plus courtes et une valeur supérieure pour des réponses potentiellement plus longues.

    • Ajouter une séquence d'arrêt : facultatif. Saisissez une séquence d'arrêt, qui est une série de caractères incluant des espaces. Si le modèle rencontre une séquence d'arrêt, la génération de réponse s'arrête. La séquence d'arrêt n'est pas incluse dans la réponse, et vous pouvez ajouter jusqu'à cinq séquences d'arrêt.
  4. Facultatif : pour configurer les paramètres avancés, cliquez sur Avancé, puis configurez les paramètres comme suit :

    Cliquez pour développer les configurations avancées

    • Top-K : saisissez une valeur pour le top-K à l'aide du curseur ou de la zone de texte.

      Top K modifie la façon dont le modèle sélectionne les jetons pour la sortie. Une valeur top-K de 1 signifie que le prochain jeton sélectionné est le plus probable parmi tous les jetons du vocabulaire du modèle (également appelé décodage glouton), tandis qu'une valeur top-K de 3 signifie que le jeton suivant est sélectionné parmi les trois jetons les plus probables en utilisant la température.

      Pour chaque étape de sélection du jeton, les jetons top-K avec les probabilités les plus élevées sont échantillonnés. Les jetons sont ensuite filtrés en fonction du top-P avec le jeton final sélectionné à l'aide de l'échantillonnage de température.

      Spécifiez une valeur inférieure pour les réponses moins aléatoires et une valeur plus élevée pour les réponses plus aléatoires.

    • Top-P: utilisez le curseur ou la zone de texte pour saisir une valeur. Les jetons sont sélectionnés du plus probable au moins probable, jusqu'à ce que la somme de leurs probabilités soit égale à la valeur de top-P. Pour obtenir les résultats les moins variables, définissez "top-P" sur 0.
    • Activer l'ancrage : ajoutez une source d'ancrage et un chemin pour personnaliser cette fonctionnalité.
  5. Saisissez votre requête textuelle dans le volet Requête. Le modèle utilise les messages précédents comme contexte pour les nouvelles réponses.
  6. Facultatif : Pour afficher le nombre de jetons de texte, cliquez sur Afficher les jetons. Vous pouvez afficher les jetons ou les ID de jetons de votre requête de texte.
    • Pour afficher les jetons dans la requête de texte, qui sont surlignés avec différentes couleurs pour marquer la limite de chaque ID de jeton, cliquez sur ID de jeton en texte. Les jetons multimédias ne sont pas acceptés.
    • Pour afficher les ID de jeton, cliquez sur ID de jeton.

      Pour fermer le volet de l'outil de tokenisation, cliquez sur X ou en dehors du volet.

  7. Cliquez sur Envoyer.
  8. Facultatif : pour enregistrer votre requête dans Mes requêtes, cliquez sur Enregistrer.
  9. Facultatif : pour obtenir le code Python ou la commande curl de votre requête, cliquez sur  Obtenir le code.
  10. Facultatif : pour effacer tous les messages précédents, cliquez sur  Effacer la conversation.

Vous pouvez utiliser des instructions système pour orienter le comportement du modèle en fonction d'un besoin ou d'un cas d'utilisation spécifique. Par exemple, vous pouvez définir un persona ou un rôle pour un chatbot qui répond aux demandes du service client. Pour en savoir plus, consultez les exemples de code d'instructions système.

Étape suivante