API Inference

Utilisez l'API Inference pour générer des requêtes Gemini.

La famille de modèles Gemini inclut des modèles qui fonctionnent avec des requêtes multimodales. Le terme multimodal indique que vous pouvez utiliser plusieurs modalités (ou types d'entrée) dans une requête. Les modèles qui ne sont pas multimodaux n'acceptent que des requêtes textuelles. Les modalités peuvent inclure du texte, de l'audio, de la vidéo, etc…

Pour en savoir plus, consultez les pages suivantes :

Modèles compatibles :

Modèle Version
Gemini 1.5 Flash gemini-1.5-flash-001
Gemini 1.5 Pro gemini-1.5-pro-001
Gemini 1.0 Pro Vision gemini-1.0-pro-001
gemini-1.0-pro-vision-001
Gemini 1.0 Pro gemini-1.0-pro
gemini-1.0-pro-001
gemini-1.0-pro-002

Limites :

Si vous fournissez beaucoup d'images, la latence peut être élevée.

Exemple de syntaxe

Syntaxe permettant de générer une réponse du modèle.

Sans streaming

curl

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \

https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models/${MODEL_ID}:generateContent \
-d '{
  "contents": [{
    ...
  }],
  "generation_config": {
    ...
  },
  "safety_settings": {
    ...
  }
  ...
}'

Python

gemini_model = GenerativeModel(MODEL_ID)
generation_config = GenerationConfig(...)

model_response = gemini_model.generate_content([...], generation_config, safety_settings={...})

Flux

curl

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models/${MODEL_ID}:streamGenerateContent \
  -d '{
    "contents": [{
      ...
    }],
    "generation_config": {
      ...
    },
    "safety_settings": {
      ...
    }
    ...
  }'

Python

gemini_model = GenerativeModel(MODEL_ID)
model_response = gemini_model.generate_content([...], generation_config, safety_settings={...}, stream=True)

Liste des paramètres

Consultez des exemples pour en savoir plus sur la mise en œuvre.

Corps de la requête

Le corps de la requête contient des données avec les paramètres suivants :

Paramètres

contents

Requis : Content

Contenu de la conversation en cours avec le modèle.

Pour les requêtes à un seul tour, il s'agit d'une instance unique. Pour les requêtes multitours, il s'agit d'un champ répété contenant l'historique de la conversation et la dernière requête.

system_instruction

Facultatif : Content.

Instructions système fournies par l'utilisateur pour le modèle.

Remarque : Seul text doit être utilisé dans parts, et le contenu de chaque part doit figurer dans un paragraphe distinct.

tools

Facultatif. Consultez la page API d'appel de fonction.

tool_config

Facultatif. Consultez la page API d'appel de fonction.

safety_settings

Facultatif : SafetySetting.

Paramètres de requête définis pour le blocage du contenu non sécurisé.

Appliqué le GenerateContentResponse.candidates.

generation_config

Facultatif : GenerationConfig.

Paramètres de configuration de génération.

Contenus

Type de données structurées de base comportant un contenu en plusieurs parties d'un message.

Cette classe comprend deux propriétés principales : role et parts. La propriété role indique l'individu qui produit le contenu, tandis que la propriété parts contient plusieurs éléments, chacun représentant un segment de données au sein d'un message.

Paramètres

role

Facultatif : string.

Identité de l'entité qui crée le message. Les valeurs suivantes sont acceptées :

  • user : indique que le message est envoyé par une personne réelle, généralement un message généré par un utilisateur.
  • model : indique que le message est généré par le modèle.

La valeur model permet d'insérer des messages du modèle dans la conversation lors de conversations multitours.

Pour les conversations non multitours, ce champ peut être vide ou non défini.

parts

Part

Une liste de parties ordonnées qui composent un seul message. Chaque partie peut avoir des types MIME IANA différents.

Part

Type de données contenant du contenu multimédia faisant partie d'un message Content en plusieurs parties.

Paramètres

text

Facultatif : string.

Requête de texte ou extrait de code.

inline_data

Facultatif : Blob.

Données intégrées dans des octets bruts.

file_data

Facultatif : FileData.

Données stockées dans un fichier.

function_call

Facultatif : FunctionCall.

Il contient une chaîne représentant le champ FunctionDeclaration.name et un objet JSON structuré contenant tous les paramètres de l'appel de fonction prédit par le modèle.

Consultez la page API d'appel de fonction.

function_response

Facultatif : FunctionResponse.

Résultat d'une FunctionCall contenant une chaîne représentant le champ FunctionDeclaration.name et un objet JSON structuré contenant tout résultat de l'appel de fonction. Il sert de contexte au modèle.

Consultez la page API d'appel de fonction.

video_metadata

Facultatif : VideoMetadata.

Métadonnées de vidéo. Vous ne devez spécifier les métadonnées que lorsque les données vidéo sont présentées dans inline_data ou file_data.

Blob

Blob de contenu. Si possible, envoyez le message sous forme de texte plutôt que d'octets bruts.

Paramètres

mime_type

string

Type MIME IANA des données.

data

bytes

Octets bruts

FileData

Données basées sur l'URI.

Paramètres

mime_type

string

Type MIME IANA des données.

file_uri

chaîne

URI Cloud Storage du fichier stockant les données

FunctionCall

Une valeur FunctionCall prédite renvoyée par le modèle et qui contient une chaîne représentant le FunctionDeclaration.name et un objet JSON structuré contenant les paramètres et leurs valeurs.

Paramètres

name

string

Nom de la fonction à appeler.

args

Struct

Paramètres et valeurs de la fonction au format d'objet JSON.

Pour en savoir plus sur les paramètres, consultez la page API d'appel de fonction.

FunctionResponse

Résultat d'une transformation FunctionCall contenant une chaîne représentant le FunctionDeclaration.name. Contient également un objet JSON structuré avec la sortie de la fonction (et l'utilise comme contexte pour le modèle). Doit contenir le résultat d'une opération FunctionCall effectuée en fonction de la prédiction du modèle.

Paramètres

name

string

Nom de la fonction à appeler.

response

Struct

Réponse de la fonction au format d'objet JSON.

VideoMetadata

Métadonnées décrivant le contenu vidéo d'entrée.

Paramètres

start_offset

Facultatif : google.protobuf.Duration.

Décalage de début de la vidéo

end_offset

Facultatif : google.protobuf.Duration.

Décalage de fin de la vidéo

SafetySetting

Paramètres de sécurité

Paramètres

category

Facultatif : HarmCategory.

La catégorie de préjudice.

threshold

Facultatif : HarmBlockThreshold.

Seuil de blocage de préjudice.

max_influential_terms

Facultatif : int.

Nombre maximal de termes influents qui contribuent le plus aux scores de sécurité, ce qui peut entraîner un blocage potentiel.

method

Facultatif : HarmBlockMethod.

Indiquez si le seuil est utilisé pour le score de probabilité ou de gravité. Si cette valeur n'est pas spécifiée, le seuil est utilisé pour le score de probabilité.

HarmCategory

Catégories de préjudice qui bloquent le contenu.

Paramètres

HARM_CATEGORY_UNSPECIFIED

La catégorie de préjudice n'est pas spécifiée.

HARM_CATEGORY_HATE_SPEECH

La catégorie de préjudice est l'incitation à la haine.

HARM_CATEGORY_DANGEROUS_CONTENT

La catégorie de préjudice est le contenu dangereux.

HARM_CATEGORY_HARASSMENT

La catégorie de préjudice est le harcèlement.

HARM_CATEGORY_SEXUALLY_EXPLICIT

La catégorie de préjudice est le contenu à caractère sexuel explicite.

HarmBlockThreshold

Niveaux de seuil de probabilité utilisés pour bloquer une réponse.

Paramètres

HARM_BLOCK_THRESHOLD_UNSPECIFIED

Seuil de blocage de préjudice non spécifié.

BLOCK_LOW_AND_ABOVE

Bloquer les seuils faibles et supérieurs (augmenter le nombre de blocages).

BLOCK_MEDIUM_AND_ABOVE

Bloquer les seuils moyens et supérieurs.

BLOCK_ONLY_HIGH

Bloquer uniquement les seuils élevés (réduire le nombre de blocage).

BLOCK_NONE

Ne rien bloquer.

HarmBlockMethod

Seuil de probabilité qui bloque une réponse en fonction d'une combinaison de probabilité et de gravité.

Paramètres

HARM_BLOCK_METHOD_UNSPECIFIED

La méthode de blocage de préjudice n'est pas spécifiée.

SEVERITY

La méthode de blocage de préjudice utilise à la fois des scores de probabilité et de gravité.

PROBABILITY

La méthode de blocage de préjudice utilise le score de probabilité.

GenerationConfig

Paramètres de configuration utilisés lors de la génération de la requête.

Paramètres

temperature

Facultatif : float.

Contrôle le caractère aléatoire des prédictions.

top_p

Facultatif : float.

Si spécifié, l'échantillonnage du noyau est utilisé.

top_k

Facultatif : si spécifié, l'échantillonnage top-k est utilisé.

candidate_count

Facultatif : int.

Nombre de candidats à générer.

max_output_tokens

Facultatif : int

Nombre maximal de jetons de sortie à générer par message.

stop_sequences

Facultatif : List[string].

Arrêter les séquences.

presence_penalty

Facultatif : float.

Pénalités positives.

frequency_penalty

Facultatif : float.

Pénalité de fréquence.

response_mime_type

Facultatif : string (enum).

Type MIME de la réponse de sortie du texte candidat généré.

Type MIME pris en charge :

  • text/plain : (par défaut) sortie textuelle.
  • application/json : réponse JSON dans les candidats.
  • Le modèle doit être invité à générer le type de réponse approprié, sans quoi le comportement n'est pas défini.

Il s'agit d'une fonctionnalité en preview.

Examples

Réponse textuelle sans streaming

Générer une réponse de modèle sans streaming à partir d'une entrée de texte.

REST

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

  • PROJECT_ID : l'ID de votre projet.
  • LOCATION : région dans laquelle traiter la requête.
  • TEXT : instructions textuelles à inclure dans la requête.

Méthode HTTP et URL : 

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:generateContent

Corps JSON de la requête : 

{
  "contents": [{
    "role": "user",
    "parts": [{
      "text": "TEXT"
    }]
  }]
}'

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, puis exécutez la commande suivante :

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:generateContent"

PowerShell

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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:generateContent" | Select-Object -Expand Content

Python 

import vertexai
from vertexai.generative_models import GenerativeModel

# TODO(developer): Update and un-comment below line
# project_id = "PROJECT_ID"

vertexai.init(project=project_id, location="us-central1")

model = GenerativeModel(model_name="gemini-1.0-pro-002")

response = model.generate_content(
    "What's a good name for a flower shop that specializes in selling bouquets of dried flowers?"
)

print(response.text)

NodeJS 

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

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function generate_from_text_input(projectId = 'PROJECT_ID') {
  const vertexAI = new VertexAI({project: projectId, location: 'us-central1'});

  const generativeModel = vertexAI.getGenerativeModel({
    model: 'gemini-1.5-flash-001',
  });

  const prompt =
    "What's a good name for a flower shop that specializes in selling bouquets of dried flowers?";

  const resp = await generativeModel.generateContent(prompt);
  const contentResponse = await resp.response;
  console.log(JSON.stringify(contentResponse));
}

Java 

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

public class TextInput {

  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.0-pro-002";
    String textPrompt =
        "What's a good name for a flower shop that specializes in selling bouquets of"
            + " dried flowers?";

    String output = textInput(projectId, location, modelName, textPrompt);
    System.out.println(output);
  }

  // Passes the provided text input to the Gemini model and returns the text-only response.
  // For the specified textPrompt, the model returns a list of possible store names.
  public static String textInput(
      String projectId, String location, String modelName, String textPrompt) 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)) {
      GenerativeModel model = new GenerativeModel(modelName, vertexAI);

      GenerateContentResponse response = model.generateContent(textPrompt);
      String output = ResponseHandler.getText(response);
      return output;
    }
  }
}

Go 

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

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

func generateContentFromText(w io.Writer, projectID string) error {
	location := "us-central1"
	modelName := "gemini-1.0-pro-vision-001"

	ctx := context.Background()
	client, err := genai.NewClient(ctx, projectID, location)
	if err != nil {
		return fmt.Errorf("error creating client: %w", err)
	}
	gemini := client.GenerativeModel(modelName)
	prompt := genai.Text(
		"What's a good name for a flower shop that specializes in selling bouquets of dried flowers?")

	resp, err := gemini.GenerateContent(ctx, prompt)
	if err != nil {
		return fmt.Errorf("error generating content: %w", err)
	}
	// See the JSON response in
	// https://pkg.go.dev/cloud.google.com/go/vertexai/genai#GenerateContentResponse.
	rb, err := json.MarshalIndent(resp, "", "  ")
	if err != nil {
		return fmt.Errorf("json.MarshalIndent: %w", err)
	}
	fmt.Fprintln(w, string(rb))
	return nil
}

C#


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

public class TextInputSample
{
    public async Task<string> TextInput(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.5-flash-001")
    {

        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();
        string prompt = @"What's a good name for a flower shop that specializes in selling bouquets of dried flowers?";

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = prompt }
                    }
                }
            }
        };

        GenerateContentResponse response = await predictionServiceClient.GenerateContentAsync(generateContentRequest);

        string responseText = response.Candidates[0].Content.Parts[0].Text;
        Console.WriteLine(responseText);

        return responseText;
    }
}

Réponse multimodale en streaming

Générez une réponse de modèle non en streaming à partir d'une entrée multimodale, telle qu'un texte et une image.

REST

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

  • PROJECT_ID : l'ID de votre projet.
  • LOCATION : région dans laquelle traiter la requête.
  • TEXT : instructions textuelles à inclure dans la requête.
  • FILE_URI : URI Cloud Storage du fichier stockant les données
  • MIME_TYPE : type MIME TIANA des données.

Méthode HTTP et URL : 

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:generateContent

Corps JSON de la requête : 

{
"contents": [{
  "role": "user",
  "parts": [
    {
      "text": "TEXT"
    },
    {
      "file_data": {"file_uri": "FILE_URI", "MIME_TYPE"}
    },
    {
      "file_data": {"file_uri": "FILE_URI", "MIME_TYPE"}
    }
  ]
}]
}

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, puis exécutez la commande suivante :

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:generateContent"

PowerShell

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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:generateContent" | Select-Object -Expand Content

Python 

# Copyright 2023 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


def generate_text(project_id: str) -> str:
    import vertexai

    from vertexai.generative_models import GenerativeModel, Part

    # TODO(developer): Update and un-comment below line
    # project_id = "PROJECT_ID"

    vertexai.init(project=project_id, location="us-central1")

    model = GenerativeModel(model_name="gemini-1.0-pro-vision-001")

    response = model.generate_content(
        [
            Part.from_uri(
                "gs://cloud-samples-data/generative-ai/image/scones.jpg",
                mime_type="image/jpeg",
            ),
            "What is shown in this image?",
        ]
    )

    print(response.text)

    return response.text

NodeJS 

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

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function createNonStreamingMultipartContent(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.0-pro-vision-001',
  image = 'gs://generativeai-downloads/images/scones.jpg',
  mimeType = 'image/jpeg'
) {
  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

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

  // For images, the SDK supports both Google Cloud Storage URI and base64 strings
  const filePart = {
    fileData: {
      fileUri: image,
      mimeType: mimeType,
    },
  };

  const textPart = {
    text: 'what is shown in this image?',
  };

  const request = {
    contents: [{role: 'user', parts: [filePart, textPart]}],
  };

  console.log('Prompt Text:');
  console.log(request.contents[0].parts[1].text);

  console.log('Non-Streaming Response Text:');
  // Create the response stream
  const responseStream =
    await generativeVisionModel.generateContentStream(request);

  // Wait for the response stream to complete
  const aggregatedResponse = await responseStream.response;

  // Select the text from the response
  const fullTextResponse =
    aggregatedResponse.candidates[0].content.parts[0].text;

  console.log(fullTextResponse);
}

Java 

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import java.io.IOException;

public class Quickstart {

  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.0-pro-vision-001";

    String output = quickstart(projectId, location, modelName);
    System.out.println(output);
  }

  // Analyzes the provided Multimodal input.
  public static String quickstart(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)) {
      String imageUri = "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark1.png";

      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      GenerateContentResponse response = model.generateContent(ContentMaker.fromMultiModalData(
          PartMaker.fromMimeTypeAndData("image/png", imageUri),
          "What's in this photo"
      ));

      return response.toString();
    }
  }
}

Go 

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

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

func tryGemini(w io.Writer, projectID string, location string, modelName string) error {
	// location := "us-central1"
	// modelName := "gemini-1.0-pro-vision-001"

	ctx := context.Background()
	client, err := genai.NewClient(ctx, projectID, location)
	if err != nil {
		return fmt.Errorf("error creating client: %w", err)
	}
	gemini := client.GenerativeModel(modelName)

	img := genai.FileData{
		MIMEType: "image/jpeg",
		FileURI:  "gs://generativeai-downloads/images/scones.jpg",
	}
	prompt := genai.Text("What is in this image?")

	resp, err := gemini.GenerateContent(ctx, img, prompt)
	if err != nil {
		return fmt.Errorf("error generating content: %w", err)
	}
	rb, err := json.MarshalIndent(resp, "", "  ")
	if err != nil {
		return fmt.Errorf("json.MarshalIndent: %w", err)
	}
	fmt.Fprintln(w, string(rb))
	return nil
}

C#


using Google.Api.Gax.Grpc;
using Google.Cloud.AIPlatform.V1;
using System.Text;
using System.Threading.Tasks;

public class GeminiQuickstart
{
    public async Task<string> GenerateContent(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.0-pro-vision"
    )
    {
        // Create client
        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();

        // Initialize content request
        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            GenerationConfig = new GenerationConfig
            {
                Temperature = 0.4f,
                TopP = 1,
                TopK = 32,
                MaxOutputTokens = 2048
            },
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = "What's in this photo?" },
                        new Part { FileData = new() { MimeType = "image/png", FileUri = "gs://generativeai-downloads/images/scones.jpg" } }
                    }
                }
            }
        };

        // Make the request, returning a streaming response
        using PredictionServiceClient.StreamGenerateContentStream response = predictionServiceClient.StreamGenerateContent(generateContentRequest);

        StringBuilder fullText = new();

        // Read streaming responses from server until complete
        AsyncResponseStream<GenerateContentResponse> responseStream = response.GetResponseStream();
        await foreach (GenerateContentResponse responseItem in responseStream)
        {
            fullText.Append(responseItem.Candidates[0].Content.Parts[0].Text);
        }

        return fullText.ToString();
    }
}

Réponse de texte en streaming

Générer une réponse de modèle en streaming à partir d'une entrée de texte.

REST

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

  • PROJECT_ID : l'ID de votre projet.
  • LOCATION : région dans laquelle traiter la requête.
  • TEXT : instructions textuelles à inclure dans la requête.

Méthode HTTP et URL : 

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:streamGenerateContent

Corps JSON de la requête : 

{
  "contents": [{
    "role": "user",
    "parts": [{
      "text": "TEXT"
    }]
  }]
}'

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, puis exécutez la commande suivante :

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:streamGenerateContent"

PowerShell

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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:streamGenerateContent" | Select-Object -Expand Content

Python 

import vertexai

from vertexai.generative_models import GenerativeModel

vertexai.init(project=PROJECT_ID, location="us-central1")

model = GenerativeModel(MODEL_ID)
responses = model.generate_content(
    "Write a story about a magic backpack.", stream=True
)

for response in responses:
    print(response)

NodeJS 

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

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function generateContent(
  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 request = {
    contents: [
      {
        role: 'user',
        parts: [
          {
            text: 'Write a story about a magic backpack.',
          },
        ],
      },
    ],
  };

  console.log(JSON.stringify(request));

  const result = await generativeModel.generateContentStream(request);
  for await (const item of result.stream) {
    console.log(item.candidates[0].content.parts[0].text);
  }
}

Réponse multimodale en streaming

Générer une réponse de modèle en streaming à partir d'une entrée multimodale, telle qu'un texte et une image.

REST

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

  • PROJECT_ID : l'ID de votre projet.
  • LOCATION : région dans laquelle traiter la requête.
  • TEXT : instructions textuelles à inclure dans la requête.

Méthode HTTP et URL : 

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:streamGenerateContent

Corps JSON de la requête : 

{
  "contents": [{
    "role": "user",
    "parts": [{
      "text": "TEXT"
    }]
  }]
}'

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, puis exécutez la commande suivante :

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:streamGenerateContent"

PowerShell

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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:streamGenerateContent" | Select-Object -Expand Content

Python 

import vertexai

from vertexai.generative_models import GenerativeModel, Part

vertexai.init(project=PROJECT_ID, location="us-central1")

model = GenerativeModel(MODEL_ID)
responses = model.generate_content(
    [
        Part.from_uri(
            "gs://cloud-samples-data/generative-ai/video/animals.mp4", "video/mp4"
        ),
        Part.from_uri(
            "gs://cloud-samples-data/generative-ai/image/character.jpg",
            "image/jpeg",
        ),
        "Are these video and image correlated?",
    ],
    stream=True,
)

for response in responses:
    print(response)

NodeJS 

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

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

  const request = {
    contents: [
      {
        role: 'user',
        parts: [
          {
            file_data: {
              file_uri: 'gs://cloud-samples-data/video/animals.mp4',
              mime_type: 'video/mp4',
            },
          },
          {
            file_data: {
              file_uri:
                'gs://cloud-samples-data/generative-ai/image/character.jpg',
              mime_type: 'image/jpeg',
            },
          },
          {text: 'Are this video and image correlated?'},
        ],
      },
    ],
  };

  const result = await generativeModel.generateContentStream(request);

  for await (const item of result.stream) {
    console.log(item.candidates[0].content.parts[0].text);
  }
}

Étapes suivantes