Générer du contenu avec l'API Gemini

Utilisez generateContent ou streamGenerateContent pour générer du contenu avec 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…

Créer un compte Google Cloud pour commencer

Pour commencer à utiliser l'API Vertex AI pour Gemini, créez un compte Google Cloud.

Après avoir créé votre compte, utilisez ce document pour examiner le corps de la requête du modèle Gemini, les paramètres du modèle, le corps de la réponse et quelques exemples de requêtes.

Lorsque vous êtes prêt, consultez le guide de démarrage rapide de l'API Vertex AI pour Gemini pour apprendre à envoyer une requête à l'API Vertex AI Gemini à l'aide d'un SDK de langage de programmation ou de l'API REST.

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`

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 l'implémentation.

Corps de la requête

{
  "contents": [
    {
      "role": string,
      "parts": [
        {
          // Union field data can be only one of the following:
          "text": string,
          "inlineData": {
            "mimeType": string,
            "data": string
          },
          "fileData": {
            "mimeType": string,
            "fileUri": string
          },
          // End of list of possible types for union field data.

          "videoMetadata": {
            "startOffset": {
              "seconds": integer,
              "nanos": integer
            },
            "endOffset": {
              "seconds": integer,
              "nanos": integer
            }
          }
        }
      ]
    }
  ],
  "systemInstruction": {
    "role": string,
    "parts": [
      {
        "text": string
      }
    ]
  },
  "tools": [
    {
      "functionDeclarations": [
        {
          "name": string,
          "description": string,
          "parameters": {
            object (OpenAPI Object Schema)
          }
        }
      ]
    }
  ],
  "safetySettings": [
    {
      "category": enum (HarmCategory),
      "threshold": enum (HarmBlockThreshold)
    }
  ],
  "generationConfig": {
    "temperature": number,
    "topP": number,
    "topK": number,
    "candidateCount": integer,
    "maxOutputTokens": integer,
    "presencePenalty": float,
    "frequencyPenalty": float,
    "stopSequences": [
      string
    ],
    "responseMimeType": string
  }
}

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`. Disponible pour `gemini-1.5-pro` et `gemini-1.0-pro-002`. Instructions permettant au modèle de l'orienter vers de meilleures performances. Par exemple, "répondez de manière aussi concise que possible" ou "N'utilisez pas de termes techniques dans votre réponse". Les chaînes `text` sont comptabilisées dans la limite de jetons. Le champ `role` de `systemInstruction` est ignoré et n'affecte pas les performances du modèle. Remarque : Seul `text` doit être utilisé dans `parts`, et le contenu de chaque `part` doit figurer dans un paragraphe distinct.
`tools`	Facultatif. Morceau de code qui permet au système d'interagir avec des systèmes externes pour effectuer une action ou un ensemble d'actions en dehors du champ d'application et des connaissances du modèle. Consultez la section Appel de fonction.
`tool_config`	Facultatif. Consultez la section 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.
`cached_content`	Facultatif : `CachedContent`. Contenu mis en cache. Vous pouvez utiliser du contenu mis en cache dans les requêtes incluant du contenu répété.

`contents`

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

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. Pour connaître les limites concernant les entrées, telles que le nombre maximal de jetons ou d'images, consultez les spécifications du modèle sur la page Modèles Google. Pour calculer le nombre de jetons dans votre requête, consultez Obtenir le nombre de jetons.

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.

Pour connaître les limites concernant les entrées, telles que le nombre maximal de jetons ou d'images, consultez les spécifications du modèle sur la page Modèles Google.

Pour calculer le nombre de jetons dans votre requête, consultez Obtenir le nombre de jetons.

`parts`

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. Pour `gemini-1.0-pro-vision`, vous pouvez spécifier une image au maximum avec `inlineData`. Pour spécifier jusqu'à 16 images, utilisez `file_data`.
`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 section 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 section Appel de fonction.
`video_metadata`	Facultatif : `VideoMetadata`. Pour les entrées vidéo, le décalage de début et de fin de la vidéo sous forme de durée. Par exemple, pour spécifier un extrait de 10 secondes commençant à 1:00, définissez `"start_offset": { "seconds": 60 }` et `"end_offset": { "seconds": 70 }`. 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

Paramètres
`mime_type`	`string` Type de contenu du fichier spécifié dans les champs `data` ou `fileUri`. Les valeurs acceptées incluent les suivantes : Cliquer pour développer les types MIME `application/pdf` `audio/mpeg` `audio/mp3` `audio/wav` `image/png` `image/jpeg` `text/plain` `video/mov` `video/mpeg` `video/mp4` `video/mpg` `video/avi` `video/wmv` `video/mpegps` `video/flv` Pour `gemini-1.0-pro-vision`, la durée maximale de la vidéo est de deux minutes. Pour `Gemini 1.5 Pro` et `Gemini 1.5 Flash`, la durée maximale d'un fichier audio est de 8,4 heures et la durée maximale d'un fichier vidéo (sans audio) est d'une heure. Pour en savoir plus, consultez la section Exigences multimédias pour Gemini 1.5 Pro. Les fichiers texte doivent être encodés au format UTF-8. Le contenu du fichier texte est comptabilisé dans la limite du jeton. Aucune limite ne s'applique à la résolution d'image.
`data`	`bytes` Encodage base64 de l'image ou de la vidéo à intégrer à la requête. Lorsque vous intégrez du contenu multimédia, vous devez également spécifier le type de contenu multimédia (`mimeType`) des données. Limite de taille : 20 Mo.

mime_type

string

Type de contenu du fichier spécifié dans les champs data ou fileUri. Les valeurs acceptées incluent les suivantes :

Cliquer pour développer les types MIME

application/pdf
audio/mpeg
audio/mp3
audio/wav
image/png
image/jpeg
text/plain
video/mov
video/mpeg
video/mp4
video/mpg
video/avi
video/wmv
video/mpegps
video/flv

Pour gemini-1.0-pro-vision, la durée maximale de la vidéo est de deux minutes.

Pour Gemini 1.5 Pro et Gemini 1.5 Flash, la durée maximale d'un fichier audio est de 8,4 heures et la durée maximale d'un fichier vidéo (sans audio) est d'une heure. Pour en savoir plus, consultez la section Exigences multimédias pour Gemini 1.5 Pro.

Les fichiers texte doivent être encodés au format UTF-8. Le contenu du fichier texte est comptabilisé dans la limite du jeton.

Aucune limite ne s'applique à la résolution d'image.

data

bytes

Encodage base64 de l'image ou de la vidéo à intégrer à la requête. Lorsque vous intégrez du contenu multimédia, vous devez également spécifier le type de contenu multimédia (mimeType) des données.

Limite de taille : 20 Mo.

CachedContent

Permet d'effectuer la mise à jour lorsqu'un cache de contexte expire. Vous devez spécifier ttl ou expire_time lorsque vous mettez à jour CachedContent, mais vous ne pouvez pas spécifier les deux. Pour en savoir plus, consultez Utiliser la mise en cache de contexte.

Paramètres

Paramètres
`ttl`	`TTL` Permet de spécifier le nombre de secondes et de nanoseconds après la création ou la mise à jour d'un cache de contexte avant son expiration.
`expire_time`	`Timestamp` Code temporel indiquant l'expiration d'un cache de contexte.

ttl

TTL

Permet de spécifier le nombre de secondes et de nanoseconds après la création ou la mise à jour d'un cache de contexte avant son expiration.

expire_time

Timestamp

Code temporel indiquant l'expiration d'un cache de contexte.

TTL

Durée ou valeur TTL d'un cache de contexte après sa création ou sa mise à jour, avant son expiration.

Paramètres

Paramètres
`seconds`	`float` Composant en secondes de la durée avant l'expiration d'un cache de contexte après sa création. La valeur par défaut est de 3 600 secondes.
`nano`	Facultatif : `float`. Composant en nanosecondes de la durée avant l'expiration d'un cache de contexte après sa création.

seconds

float

Composant en secondes de la durée avant l'expiration d'un cache de contexte après sa création. La valeur par défaut est de 3 600 secondes.

nano

Facultatif : float.

Composant en nanosecondes de la durée avant l'expiration d'un cache de contexte après sa création.

FileData

Données basées sur l'URI.

Paramètres

Paramètres
mime_type	`string` Type MIME IANA des données.
file_uri	chaîne URI Cloud Storage du fichier à inclure dans la requête. L'objet bucket doit être lisible publiquement ou se trouver dans le même projet Google Cloud que celui qui envoie la requête. Vous devez également spécifier le type de contenu (`mimeType`) du fichier. La taille limite pour `gemini-1.5-pro` et `gemini-1.5-flash` est de 2 Go. Pour `gemini-1.0-pro-vision`, la taille maximale est de 20 Mo.

mime_type

string

Type MIME IANA des données.

file_uri

chaîne

URI Cloud Storage du fichier à inclure dans la requête. L'objet bucket doit être lisible publiquement ou se trouver dans le même projet Google Cloud que celui qui envoie la requête. Vous devez également spécifier le type de contenu (mimeType) du fichier.

La taille limite pour gemini-1.5-pro et gemini-1.5-flash est de 2 Go.

Pour gemini-1.0-pro-vision, la taille maximale est de 20 Mo.

`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

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 Appel de fonction.

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 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

Paramètres
`name`	`string` Nom de la fonction à appeler.
`response`	`Struct` Réponse de la fonction au format d'objet JSON.

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

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

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`. Catégorie de sécurité pour laquelle configurer un seuil. Les valeurs acceptées incluent les suivantes : Cliquer pour développer les catégories de sécurité `HARM_CATEGORY_SEXUALLY_EXPLICIT` `HARM_CATEGORY_HATE_SPEECH` `HARM_CATEGORY_HARASSMENT` `HARM_CATEGORY_DANGEROUS_CONTENT`
`threshold`	Facultatif : `HarmBlockThreshold`. Seuil de blocage des réponses susceptibles d'appartenir à la catégorie de sécurité spécifiée en fonction de la probabilité. BLOCK_NONE BLOCK_LOW_AND_ABOVE BLOCK_MED_AND_ABOVE BLOCK_ONLY_HIGH
`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`. 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. Plage pour gemini-1.5-pro: `0.0 - 2.0` (par défaut: `1.0`) Plage pour gemini-1.0-pro-vision: `0.0 - 1.0` (par défaut: `0.4`) Plage pour gemini-1.0-pro-002: `0.0 - 2.0` (par défaut: `1.0`) Plage pour gemini-1.0-pro-001: `0.0 - 1.0` (par défaut: `0.9`)
`top_p`	Facultatif : `float`. Si spécifié, l'échantillonnage du noyau est utilisé. Top-P modifie la façon dont le modèle sélectionne les jetons pour la sortie. Les jetons sont sélectionnés en partant de la probabilité la plus forte (voir top-K) à la plus basse, jusqu'à ce que la somme de leurs probabilités soit égale à la valeur top-P. Par exemple, si les jetons A, B et C ont une probabilité de 0,3, 0,2 et 0,1 et que la valeur de top-P est `0.5`, le modèle sélectionne A ou B comme jeton suivant à l'aide de la température et exclut le jeton C comme candidat. Spécifiez une valeur inférieure pour obtenir des réponses moins aléatoires et une valeur supérieure pour des réponses plus aléatoires. Plage : `0.0 - 1.0` gemini-1.5-pro : `0.94` Valeur par défaut pour gemini-1.0-pro : `1` Valeur par défaut pour gemini-1.0-pro-vision : `1`
`top_k`	Facultatif : Top-K modifie la façon dont le modèle sélectionne les jetons pour la sortie. Un 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 gourmand), tandis qu'un 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 des jetons, les jetons top-K ayant les plus fortes probabilités sont échantillonnés. Les jetons sont ensuite filtrés en fonction du top-P, puis le jeton final est sélectionné à l'aide de l'échantillonnage de température. Spécifiez une valeur inférieure pour obtenir des réponses moins aléatoires et une valeur supérieure pour des réponses plus aléatoires. Plage : `1-40` gemini-1.0-pro et gemini-1.5-pro ne sont pas compatibles avec `topK` Valeur par défaut pour gemini-1.0-pro-vision : `32`
`candidate_count`	Facultatif : `int`. Nombre de variantes de réponse à renvoyer. Cette valeur doit être 1.
`max_output_tokens`	Facultatif : int 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.
`stop_sequences`	Facultatif : `List[string]`. Spécifie une liste de chaînes qui indiquent au modèle d'arrêter de générer du texte si l'une des chaînes est détectée dans la réponse. Si une chaîne apparaît plusieurs fois dans la réponse, celle-ci effectue une troncation lors de la première rencontre. Les chaînes sont sensibles à la casse. Par exemple, si la réponse suivante est renvoyée lorsque `stopSequences` n'est pas spécifié : `public static string reverse(string myString)` La réponse renvoyée avec `stopSequences` défini sur `["Str", "reverse"]` est alors la suivante : `public static string` La liste ne peut pas contenir plus de cinq éléments.
`presence_penalty`	Facultatif : `float`. Pénalités positives. Les valeurs positives pénalisent les jetons qui apparaissent déjà dans le texte généré, ce qui augmente la probabilité de générer un contenu plus diversifié. La valeur maximale de `presencePenalty` est inférieure à `2.0`. Sa valeur minimale est `-2.0`.
`frequency_penalty`	Facultatif : `float`. Les valeurs positives pénalisent les jetons qui apparaissent de manière répétée dans le texte généré, ce qui réduit la probabilité de répétition du contenu. Cette valeur maximale pour `frequencyPenalty` est inférieure à `2.0`. Sa valeur minimale est `-2.0`.
`response_mime_type`	Facultatif : `string (enum)`. Disponible pour `gemini-1.5-pro` Type MIME de la réponse de sortie du texte candidat généré. Types MIME acceptés : `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.

Corps de la réponse

{
  "candidates": [
    {
      "content": {
        "parts": [
          {
            "text": string
          }
        ]
      },
      "finishReason": enum (FinishReason),
      "safetyRatings": [
        {
          "category": enum (HarmCategory),
          "probability": enum (HarmProbability),
          "blocked": boolean
        }
      ],
      "citationMetadata": {
        "citations": [
          {
            "startIndex": integer,
            "endIndex": integer,
            "uri": string,
            "title": string,
            "license": string,
            "publicationDate": {
              "year": integer,
              "month": integer,
              "day": integer
            }
          }
        ]
      }
    }
  ],
  "usageMetadata": {
    "promptTokenCount": integer,
    "candidatesTokenCount": integer,
    "totalTokenCount": integer
  }
}

Élément de réponse	Description
`text`	Texte généré.
`finishReason`	Raison pour laquelle le modèle a cessé de générer des jetons. Si ce champ est vide, le modèle n'a pas cessé de générer les jetons. Étant donné que la réponse utilise la requête pour le contexte, il n'est pas possible de modifier le comportement de la manière dont le modèle cesse de générer des jetons. `FINISH_REASON_UNSPECIFIED` Le motif de fin n'est pas spécifié. `FINISH_REASON_STOP` Point d'arrêt naturel du modèle ou séquence d'arrêt fournie. `FINISH_REASON_MAX_TOKENS` Le nombre maximal de jetons spécifié dans la requête a été atteint. `FINISH_REASON_SAFETY` La génération de jeton a été interrompue, car la réponse a été signalée pour des raisons de sécurité. Notez que `Candidate.content` est vide si les filtres de contenu bloquent la sortie. `FINISH_REASON_RECITATION` La génération du jeton a été interrompue, car la réponse a été signalée pour des citations non autorisées. `FINISH_REASON_OTHER` Toutes les autres raisons qui ont interrompu le jeton
`category`	Catégorie de sécurité pour laquelle configurer un seuil. Les valeurs acceptées incluent les suivantes : Cliquer pour développer les catégories de sécurité `HARM_CATEGORY_SEXUALLY_EXPLICIT` `HARM_CATEGORY_HATE_SPEECH` `HARM_CATEGORY_HARASSMENT` `HARM_CATEGORY_DANGEROUS_CONTENT`
`probability`	Niveaux de probabilité de préjudice dans le contenu. `HARM_PROBABILITY_UNSPECIFIED` `NEGLIGIBLE` `LOW` `MEDIUM` `HIGH`
`blocked`	Une option booléenne associée à un attribut de sécurité qui indique si l'entrée ou la sortie du modèle a été bloquée.
`startIndex`	Entier qui spécifie l'emplacement du début de la citation dans le fichier `content`.
`endIndex`	Entier qui spécifie l'emplacement de la fin de la citation dans le fichier `content`.
`url`	URL de la source d'une citation. Une source d'URL peut être un site Web d'actualités ou un dépôt GitHub.
`title`	Titre de la source d'une citation. Il peut s'agir, par exemple, du titre d'un article d'actualité ou d'un livre.
`license`	Licence associée à une citation.
`publicationDate`	Date à laquelle une citation a été publiée. Ses formats valides sont `YYYY`, `YYYY-MM` et `YYYY-MM-DD`.
`promptTokenCount`	Nombre de jetons dans la requête.
`candidatesTokenCount`	Nombre de jetons dans la ou les réponses.
`totalTokenCount`	Nombre de jetons dans la requête et la ou les réponses.

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

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

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

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

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.5-flash-001")

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;

public class QuestionAnswer {

  public static void main(String[] args) throws Exception {
    // 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";

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

  // Asks a question to the specified Vertex AI Gemini model and returns the generated answer.
  public static String simpleQuestion(String projectId, String location, String modelName)
      throws Exception {
    // 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 output;
      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      // Send the question to the model for processing.
      GenerateContentResponse response = model.generateContent("Why is the sky blue?");
      // Extract the generated text from the model's response.
      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.5-flash-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;
    }
}

REST (OpenAI)

Vous pouvez appeler l'API Inference à l'aide de la bibliothèque OpenAI. Pour en savoir plus, consultez la section Appeler Gemini à l'aide de la bibliothèque OpenAI.

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.
MODEL_ID : nom du modèle à utiliser.

Méthode HTTP et URL :

POST https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions

Corps JSON de la requête :

{
  "model": "google/MODEL_ID",
  "messages": [{
    "role": "user",
    "content": "Write a story about a magic backpack."
  }]
}

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/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions"

PowerShell

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

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/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions" | Select-Object -Expand Content

Python (OpenAI)

Vous pouvez appeler l'API Inference à l'aide de la bibliothèque OpenAI. Pour en savoir plus, consultez la section Appeler Gemini à l'aide de la bibliothèque OpenAI.

import vertexai
import openai

from google.auth import default, transport

# TODO(developer): Update and un-comment below lines
# project_id = "PROJECT_ID"
# location = "us-central1"

vertexai.init(project=project_id, location=location)

# Programmatically get an access token
credentials, _ = default(scopes=["https://www.googleapis.com/auth/cloud-platform"])
auth_request = transport.requests.Request()
credentials.refresh(auth_request)

# # OpenAI Client
client = openai.OpenAI(
    base_url=f"https://{location}-aiplatform.googleapis.com/v1beta1/projects/{project_id}/locations/{location}/endpoints/openapi",
    api_key=credentials.token,
)

response = client.chat.completions.create(
    model="google/gemini-1.5-flash-001",
    messages=[{"role": "user", "content": "Why is the sky blue?"}],
)

print(response)

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

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

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.5-flash-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.5-flash-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 com.google.cloud.vertexai.generativeai.ResponseHandler;

public class Multimodal {
  public static void main(String[] args) throws Exception {
    // 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";

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

  // Ask a simple question and get the response.
  public static String nonStreamingMultimodal(String projectId, String location, String modelName)
      throws Exception {
    // 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);

      String videoUri = "gs://cloud-samples-data/video/animals.mp4";
      String imgUri = "gs://cloud-samples-data/generative-ai/image/character.jpg";

      // Get the response from the model.
      GenerateContentResponse response = model.generateContent(
          ContentMaker.fromMultiModalData(
              PartMaker.fromMimeTypeAndData("video/mp4", videoUri),
              PartMaker.fromMimeTypeAndData("image/jpeg", imgUri),
              "Are this video and image correlated?"
          ));

      // Extract the generated text from the model's response.
      String output = ResponseHandler.getText(response);
      return output;
    }
  }
}

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.5-flash-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.5-flash-001"
    )
    {
        // 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();
    }
}

REST (OpenAI)

Vous pouvez appeler l'API Inference à l'aide de la bibliothèque OpenAI. Pour en savoir plus, consultez la section Appeler Gemini à l'aide de la bibliothèque OpenAI.

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.
MODEL_ID : nom du modèle à utiliser.

Méthode HTTP et URL :

POST https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions

Corps JSON de la requête :

{
  "model": "google/MODEL_ID",
  "messages": [{
    "role": "user",
    "content": [
       {
          "type": "text",
          "text": "Describe the following image:"
       },
       {
          "type": "image_url",
          "image_url": {
             "url": "gs://generativeai-downloads/images/character.jpg"
          }
       }
     ]
  }]
}

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/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions"

PowerShell

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

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/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions" | Select-Object -Expand Content

Python (OpenAI)

Vous pouvez appeler l'API Inference à l'aide de la bibliothèque OpenAI. Pour en savoir plus, consultez la section Appeler Gemini à l'aide de la bibliothèque OpenAI.

import vertexai
import openai

from google.auth import default, transport

# TODO(developer): Update and un-comment below lines
# project_id = "PROJECT_ID"
# location = "us-central1"

vertexai.init(project=project_id, location=location)

# Programmatically get an access token
credentials, _ = default(scopes=["https://www.googleapis.com/auth/cloud-platform"])
auth_request = transport.requests.Request()
credentials.refresh(auth_request)

# OpenAI Client
client = openai.OpenAI(
    base_url=f"https://{location}-aiplatform.googleapis.com/v1beta1/projects/{project_id}/locations/{location}/endpoints/openapi",
    api_key=credentials.token,
)

response = client.chat.completions.create(
    model="google/gemini-1.5-flash-001",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe the following image:"},
                {
                    "type": "image_url",
                    "image_url": "gs://cloud-samples-data/generative-ai/image/scones.jpg",
                },
            ],
        }
    ],
)

print(response)

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

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

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);
  }
}

Java

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.generativeai.GenerativeModel;

public class StreamingQuestionAnswer {

  public static void main(String[] args) throws Exception {
    // 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";

    streamingQuestion(projectId, location, modelName);
  }

  // Ask a simple question and get the response via streaming.
  public static void streamingQuestion(String projectId, String location, String modelName)
      throws Exception {
    // 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);

      // Stream the result.
      model.generateContentStream("Why is the sky blue?")
          .stream()
          .forEach(System.out::println);

      System.out.println("Streaming complete.");
    }
  }
}

Go

import (
	"context"
	"errors"
	"fmt"
	"io"

	"cloud.google.com/go/vertexai/genai"
	"google.golang.org/api/iterator"
)

// generateContent shows how to	send a basic streaming text prompt, writing
// the response to the provided io.Writer.
func generateContent(w io.Writer, projectID, modelName string) error {
	ctx := context.Background()

	client, err := genai.NewClient(ctx, projectID, "us-central1")
	if err != nil {
		return fmt.Errorf("unable to create client: %w", err)
	}
	defer client.Close()

	model := client.GenerativeModel(modelName)

	iter := model.GenerateContentStream(
		ctx,
		genai.Text("Write a story about a magic backpack."),
	)
	for {
		resp, err := iter.Next()
		if err == iterator.Done {
			return nil
		}
		if len(resp.Candidates) == 0 || len(resp.Candidates[0].Content.Parts) == 0 {
			return errors.New("empty response from model")
		}
		if err != nil {
			return err
		}
		fmt.Fprint(w, "generated response: ")
		for _, c := range resp.Candidates {
			for _, p := range c.Content.Parts {
				fmt.Fprintf(w, "%s ", p)
			}
		}
	}
}

REST (OpenAI)

Vous pouvez appeler l'API Inference à l'aide de la bibliothèque OpenAI. Pour en savoir plus, consultez la section Appeler Gemini à l'aide de la bibliothèque OpenAI.

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.
MODEL_ID : nom du modèle à utiliser.

Méthode HTTP et URL :

POST https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions

Corps JSON de la requête :

{
  "model": "google/MODEL_ID",
  "stream": true,
  "messages": [{
    "role": "user",
    "content": "Write a story about a magic backpack."
  }]
}

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/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions"

PowerShell

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

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/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions" | Select-Object -Expand Content

Python (OpenAI)

Vous pouvez appeler l'API Inference à l'aide de la bibliothèque OpenAI. Pour en savoir plus, consultez la section Appeler Gemini à l'aide de la bibliothèque OpenAI.

import vertexai
import openai

from google.auth import default, transport

# TODO(developer): Update and un-comment below lines
# project_id = "PROJECT_ID"
# location = "us-central1"

vertexai.init(project=project_id, location=location)

# Programmatically get an access token
credentials, _ = default(scopes=["https://www.googleapis.com/auth/cloud-platform"])
auth_request = transport.requests.Request()
credentials.refresh(auth_request)

# OpenAI Client
client = openai.OpenAI(
    base_url=f"https://{location}-aiplatform.googleapis.com/v1beta1/projects/{project_id}/locations/{location}/endpoints/openapi",
    api_key=credentials.token,
)

response = client.chat.completions.create(
    model="google/gemini-1.5-flash-001",
    messages=[{"role": "user", "content": "Why is the sky blue?"}],
    stream=True,
)
for chunk in response:
    print(chunk)

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

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

PowerShell

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

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);
  }
}

Java

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.generativeai.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;

public class StreamingMultimodal {
  public static void main(String[] args) throws Exception {
    // 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";

    streamingMultimodal(projectId, location, modelName);
  }

  // Ask a simple question and get the response via streaming.
  public static void streamingMultimodal(String projectId, String location, String modelName)
      throws Exception {
    // 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);

      String videoUri = "gs://cloud-samples-data/video/animals.mp4";
      String imgUri = "gs://cloud-samples-data/generative-ai/image/character.jpg";

      // Stream the result.
      model.generateContentStream(
          ContentMaker.fromMultiModalData(
              PartMaker.fromMimeTypeAndData("video/mp4", videoUri),
              PartMaker.fromMimeTypeAndData("image/jpeg", imgUri),
              "Are this video and image correlated?"
          ))
          .stream()
          .forEach(System.out::println);
    }
  }
}

Go

import (
	"context"
	"errors"
	"fmt"
	"io"

	"cloud.google.com/go/vertexai/genai"
	"google.golang.org/api/iterator"
)

func generateContent(w io.Writer, projectID, modelName string) error {
	ctx := context.Background()

	client, err := genai.NewClient(ctx, projectID, "us-central1")
	if err != nil {
		return fmt.Errorf("unable to create client: %w", err)
	}
	defer client.Close()

	model := client.GenerativeModel(modelName)
	iter := model.GenerateContentStream(
		ctx,
		genai.FileData{
			MIMEType: "video/mp4",
			FileURI:  "gs://cloud-samples-data/generative-ai/video/animals.mp4",
		},
		genai.FileData{
			MIMEType: "video/jpeg",
			FileURI:  "gs://cloud-samples-data/generative-ai/image/character.jpg",
		},
		genai.Text("Are these video and image correlated?"),
	)
	for {
		resp, err := iter.Next()
		if err == iterator.Done {
			return nil
		}
		if len(resp.Candidates) == 0 || len(resp.Candidates[0].Content.Parts) == 0 {
			return errors.New("empty response from model")
		}
		if err != nil {
			return err
		}

		fmt.Fprint(w, "generated response: ")
		for _, c := range resp.Candidates {
			for _, p := range c.Content.Parts {
				fmt.Fprintf(w, "%s ", p)
			}
		}
		fmt.Fprint(w, "\n")
	}
}

REST (OpenAI)

Vous pouvez appeler l'API Inference à l'aide de la bibliothèque OpenAI. Pour en savoir plus, consultez la section Appeler Gemini à l'aide de la bibliothèque OpenAI.

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.
MODEL_ID : nom du modèle à utiliser.

Méthode HTTP et URL :

POST https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions

Corps JSON de la requête :

{
  "model": "google/MODEL_ID",
  "stream": true,
  "messages": [{
    "role": "user",
    "content": [
       {
          "type": "text",
          "text": "Describe the following image:"
       },
       {
          "type": "image_url",
          "image_url": {
             "url": "gs://generativeai-downloads/images/character.jpg"
          }
       }
     ]
  }]
}

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/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions"

PowerShell

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

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/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions" | Select-Object -Expand Content

Python (OpenAI)

Vous pouvez appeler l'API Inference à l'aide de la bibliothèque OpenAI. Pour en savoir plus, consultez la section Appeler Gemini à l'aide de la bibliothèque OpenAI.

import vertexai
import openai

from google.auth import default, transport

# TODO(developer): Update and un-comment below lines
# project_id = "PROJECT_ID"
# location = "us-central1"

vertexai.init(project=project_id, location=location)

# Programmatically get an access token
credentials, _ = default(scopes=["https://www.googleapis.com/auth/cloud-platform"])
auth_request = transport.requests.Request()
credentials.refresh(auth_request)

# OpenAI Client
client = openai.OpenAI(
    base_url=f"https://{location}-aiplatform.googleapis.com/v1beta1/projects/{project_id}/locations/{location}/endpoints/openapi",
    api_key=credentials.token,
)

response = client.chat.completions.create(
    model="google/gemini-1.5-flash-001",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe the following image:"},
                {
                    "type": "image_url",
                    "image_url": "gs://cloud-samples-data/generative-ai/image/scones.jpg",
                },
            ],
        }
    ],
    stream=True,
)
for chunk in response:
    print(chunk)

Versions de modèle

Pour utiliser la version mise à jour automatiquement, spécifiez le nom du modèle sans le numéro de version final, par exemple gemini-1.0-pro au lieu de gemini-1.0-pro-001.

Pour en savoir plus, consultez la page Versions et cycle de vie des modèles Gemini.

Étape suivante

Apprenez-en plus sur l'API Gemini.
Apprenez-en plus sur les Appels de fonctions.
Apprenez-en plus sur les Réponses ancrées pour les modèles Gemini.