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 (preview) gemini-1.5-flash-preview-0514
Gemini 1.5 Pro (preview) gemini-1.5-pro-preview-0514
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" \

http://${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" \
  http://${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 ressources humaines 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 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 l'invite.

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 nucleus 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 http://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 \
     "http://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 "http://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

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

model = GenerativeModel(MODEL_ID)
response = model.generate_content("Write a story about a magic backpack.")

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.0-pro-002'
) {
  // 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.generateContent(request);

  console.log(result.response.candidates[0].content.parts[0].text);
}

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 http://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 \
     "http://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 "http://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, Part

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

model = GenerativeModel(MODEL_ID)
response = 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?",
    ]
)

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-pro-preview-0409'
) {
  // 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.generateContent(request);

  console.log(result.response.candidates[0].content.parts[0].text);
}

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 http://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 \
     "http://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 "http://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.0-pro-002'
) {
  // 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érez 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 http://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 \
     "http://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 "http://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-pro-preview-0409'
) {
  // 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