Présentation de l'API Gemini

L'API Gemini vous donne accès aux derniers modèles génératifs de Google. Une fois que vous vous êtes familiarisé avec les fonctionnalités générales disponibles via l'API, suivez un tutoriel pour le langage de votre choix pour commencer le développement.

Modèles

Gemini est une série de modèles d'IA générative multimodals développés par Google. Les modèles Gemini peuvent accepter du texte et des images dans les requêtes, en fonction de la variante de modèle que vous choisissez, et générer des réponses textuelles.

Pour obtenir des informations plus détaillées sur les modèles, consultez la page Modèles Genmini. Vous pouvez également utiliser la méthode list_models pour répertorier tous les modèles disponibles, puis la méthode get_model pour obtenir les métadonnées d'un modèle particulier.

Données et conception des requêtes

Certains modèles Gemini spécifiques acceptent à la fois des données textuelles et des fichiers multimédias en entrée. Cette capacité offre de nombreuses possibilités supplémentaires pour générer du contenu, analyser des données et résoudre des problèmes. Vous devez prendre en compte certaines limites et exigences, y compris la limite générale de jetons d'entrée pour le modèle que vous utilisez. Pour en savoir plus sur les limites de jetons pour des modèles spécifiques, consultez la section Modèles Geniaux.

La taille des requêtes qui utilisent l'API Gemini ne doit pas dépasser 20 Mo. L'API Gemini fournit une API File pour stocker temporairement des fichiers multimédias à utiliser dans les requêtes. Vous pouvez ainsi fournir des données de requête au-delà de la limite de 20 Mo. Pour en savoir plus sur l'utilisation de l'API Files et sur les formats de fichiers compatibles avec les invites, consultez la section Lancer une requête avec des fichiers multimédias.

Conception de requête et saisie de texte

La création de requêtes efficaces, ou ingénierie de requête, est une combinaison d'art et de science. Consultez la présentation des requêtes pour savoir comment aborder les requêtes et le guide Introduction aux requêtes pour en savoir plus sur les différentes approches possibles.

Génération de contenus

L'API Gemini vous permet d'utiliser à la fois des données de texte et d'image pour les requêtes, en fonction de la variante de modèle utilisée. Par exemple, vous pouvez générer du texte à partir de requêtes textuelles uniquement ou de requêtes multimodales à l'aide d'un modèle Gemini 1.5. Cette section fournit des exemples de code de base pour chaque méthode. Consultez la documentation de référence de l'API generateContent pour obtenir un exemple plus détaillé qui couvre tous les paramètres.

Saisie de texte et d'image

Vous pouvez envoyer une invite textuelle avec une image à un modèle Gemini 1.5 pour effectuer une tâche liée à la vision. Par exemple, vous pouvez sous-titrer une image ou identifier ce qu'elle contient.

Les exemples de code suivants illustrent l'implémentation de base d'une requête textuelle et illustrée pour chaque langage compatible:

Python

model = genai.GenerativeModel('gemini-1.5-flash')

cookie_picture = {
    'mime_type': 'image/png',
    'data': pathlib.Path('cookie.png').read_bytes()
}
prompt = "Do these look store-bought or homemade?"

response = model.generate_content(
    model="gemini-1.5-flash",
    content=[prompt, cookie_picture]
)
print(response.text)

Consultez le tutoriel Python pour voir l'extrait de code complet.

Go 

vmodel := client.GenerativeModel("gemini-1.5-flash")

data, err := os.ReadFile(filepath.Join("path-to-image", imageFile))
if err != nil {
  log.Fatal(err)
}
resp, err := vmodel.GenerateContent(ctx, genai.Text("Do these look store-bought or homemade?"), genai.ImageData("jpeg", data))
if err != nil {
  log.Fatal(err)
}

Consultez le tutoriel Go pour voir un exemple complet.

Node.js

const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });

const prompt = "Do these look store-bought or homemade?";
const image = {
  inlineData: {
    data: Buffer.from(fs.readFileSync("cookie.png")).toString("base64"),
    mimeType: "image/png",
  },
};

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

Consultez le tutoriel Node.js pour voir un exemple complet.

Web

const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });

const prompt = "Do these look store-bought or homemade?";
const image = {
  inlineData: {
    data: base64EncodedImage /* see JavaScript quickstart for details */,
    mimeType: "image/png",
  },
};

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

Consultez le tutoriel Web pour un exemple complet.

Dart (Flutter) 

final model = GenerativeModel(model: 'gemini-1.5-flash', apiKey: apiKey);
final prompt = 'Do these look store-bought or homemade?';
final imageBytes = await File('cookie.png').readAsBytes();
final content = [
  Content.multi([
    TextPart(prompt),
    DataPart('image/png', imageBytes),
  ])
];

final response = await model.generateContent(content);
print(response.text);

Consultez le tutoriel Dart (Flutter) pour obtenir un exemple complet.

Swift

let model = GenerativeModel(name: "gemini-1.5-flash", apiKey: "API_KEY")
let cookieImage = UIImage(...)
let prompt = "Do these look store-bought or homemade?"

let response = try await model.generateContent(prompt, cookieImage)

Consultez le tutoriel sur Swift pour un exemple complet.

Android

val generativeModel = GenerativeModel(
    modelName = "gemini-1.5-flash",
    apiKey = BuildConfig.apiKey
)

val cookieImage: Bitmap = // ...
val inputContent = content() {
  image(cookieImage)
  text("Do these look store-bought or homemade?")
}

val response = generativeModel.generateContent(inputContent)
print(response.text)

Consultez le tutoriel Android pour un exemple complet.

cURL

curl https://generativelanguage.googleapis.com/v1/models/gemini-1.5-flash:generateContent?key=${API_KEY} \
    -H 'Content-Type: application/json' \
    -X POST \
    -d @<(echo'{
          "contents":[
            { "parts":[
                {"text": "Do these look store-bought or homemade?"},
                { "inlineData": {
                    "mimeType": "image/png",
                    "data": "'$(base64 -w0 cookie.png)'"
                  }
                }
              ]
            }
          ]
         }')

Pour en savoir plus, consultez le tutoriel de l'API REST.

Saisie de texte uniquement

L'API Gemini ne gère que les entrées de texte. Cette fonctionnalité vous permet d'effectuer des tâches de traitement du langage naturel (TLN), telles que la complétion et la synthèse de texte.

Les exemples de code suivants illustrent l'implémentation de base d'une invite de type texte uniquement pour chaque langage compatible:

Python

model = genai.GenerativeModel('gemini-1.5-flash')

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

response = model.generate_content(prompt)

Consultez le tutoriel Python pour obtenir un exemple complet.

Go 

ctx := context.Background()
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

model := client.GenerativeModel("gemini-1.5-flash")
resp, err := model.GenerateContent(ctx, genai.Text("Write a story about a magic backpack."))
if err != nil {
  log.Fatal(err)
}

Consultez le tutoriel Go pour voir un exemple complet.

Node.js

const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });
const prompt = "Write a story about a magic backpack.";

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

Consultez le tutoriel Node.js pour voir un exemple complet.

Web

const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });
const prompt = "Write a story about a magic backpack.";

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

Consultez le tutoriel Web pour un exemple complet.

Dart (Flutter) 

final model = GenerativeModel(model: 'gemini-1.5-flash', apiKey: apiKey);
final prompt = 'Write a story about a magic backpack.';
final content = [Content.text(prompt)];
final response = await model.generateContent(content);
print(response.text);

Consultez le tutoriel Dart (Flutter) pour obtenir un exemple complet.

Swift

let model = GenerativeModel(name: "gemini-1.5-flash", apiKey: "API_KEY")
let prompt = "Write a story about a magic backpack."

let response = try await model.generateContent(prompt)

Consultez le tutoriel sur Swift pour un exemple complet.

Android

val generativeModel = GenerativeModel(
    modelName = "gemini-1.5-flash",
    apiKey = BuildConfig.apiKey
)

val prompt = "Write a story about a magic backpack."
val response = generativeModel.generateContent(prompt)
print(response.text)

Consultez le tutoriel Android pour un exemple complet.

cURL

curl https://generativelanguage.googleapis.com/v1/models/gemini-1.5-flash:generateContent?key=$API_KEY \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{ "contents":[
      { "parts":[{"text": "Write a story about a magic backpack"}]}
    ]
}'

Pour en savoir plus, consultez le tutoriel de l'API REST.

Conversations multitours (chat)

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

Les exemples de code suivants illustrent une implémentation de base de l'interaction de chat pour chaque langage compatible:

Python

  model = genai.GenerativeModel('gemini-1.5-flash')
  chat = model.start_chat(history=[])

  response = chat.send_message(
      "Pretend you\'re a snowman and stay in character for each response.")
  print(response.text)

  response = chat.send_message(
      "What\'s your favorite season of the year?")
  print(response.text)

Consultez la démonstration du chat dans le tutoriel Python pour un exemple complet.

Go 

model := client.GenerativeModel("gemini-1.5-flash")
cs := model.StartChat()
cs.History = []*genai.Content{
  &genai.Content{
    Parts: []genai.Part{
      genai.Text("Pretend you're a snowman and stay in character for each response."),
    },
    Role: "user",
  },
  &genai.Content{
    Parts: []genai.Part{
      genai.Text("Hello! It's cold! Isn't that great?"),
    },
    Role: "model",
  },
}

resp, err := cs.SendMessage(ctx, genai.Text("What's your favorite season of the year?"))
if err != nil {
  log.Fatal(err)
}

Consultez la démonstration du chat dans le tutoriel Go pour obtenir un exemple complet.

Node.js

const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash"});

const chat = model.startChat({
  history: [
    {
      role: "user",
      parts: "Pretend you're a snowman and stay in character for each response.",
    },
    {
      role: "model",
      parts: "Hello! It's cold! Isn't that great?",
    },
  ],
  generationConfig: {
    maxOutputTokens: 100,
  },
});

const msg = "What's your favorite season of the year?";
const result = await chat.sendMessage(msg);
console.log(result.response.text());

Pour obtenir un exemple complet, consultez la démonstration du chat dans le tutoriel Node.js.

Web

const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash"});

const chat = model.startChat({
  history: [
    {
      role: "user",
      parts: "Pretend you're a snowman and stay in character for each response.",
    },
    {
      role: "model",
      parts: "Hello! It's so cold! Isn't that great?",
    },
  ],
  generationConfig: {
    maxOutputTokens: 100,
  },
});

const msg = "What's your favorite season of the year?";
const result = await chat.sendMessage(msg);
console.log(result.response.text());

Consultez la démonstration du chat dans le tutoriel Web pour un exemple complet.

Dart (Flutter) 

final model = GenerativeModel(model: 'gemini-1.5-flash', apiKey: apiKey);
final chat = model.startChat(history: [
  Content.text(
      "Pretend you're a snowman and stay in character for each response."),
  Content.model([TextPart("Hello! It's cold! Isn't that great?")]),
]);
final content = Content.text("What's your favorite season of the year?");
final response = await chat.sendMessage(content);
print(response.text);

Consultez la démonstration du chat dans le tutoriel Dart (Flutter) pour voir un exemple complet.

Swift

let model = GenerativeModel(name: "gemini-1.5-flash", apiKey: "API_KEY")
let chat = model.startChat()

var message = "Pretend you're a snowman and stay in character for each response."
var response = try await chat.sendMessage(message)

message = "What\'s your favorite season of the year?"
response = try await chat.sendMessage(message)

Consultez la démonstration du chat dans le tutoriel sur Swift pour un exemple complet.

Android

val generativeModel = GenerativeModel(
    modelName = "gemini-1.5-flash",
    apiKey = BuildConfig.apiKey
)

val chat = generativeModel.startChat()
val response = chat.sendMessage("Pretend you're a snowman and stay in
        character for each response.")
print(response.text)

Consultez le tutoriel Android pour un exemple complet.

cURL

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=$API_KEY \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [
        {"role":"user",
         "parts":[{
           "text": "Pretend you're a snowman and stay in character for each
        {"role": "model",
            response."}]},
         "parts":[{
           "text": "Hello! It's so cold! Isn't that great?"}]},
        {"role": "user",
         "parts":[{
           "text": "What\'s your favorite season of the year?"}]},
       ]
    }' 2> /dev/null | grep "text"
# response example:
"text": "Winter, of course!"

Pour en savoir plus, consultez le tutoriel de l'API REST.

Réponses dynamiques

L'API Gemini offre un moyen supplémentaire de recevoir des réponses des modèles d'IA générative: en tant que flux de données. Une réponse en flux continu renvoie des données incrémentielles à votre application au fur et à mesure qu'elles sont générées par le modèle. Cette fonctionnalité vous permet de répondre rapidement à la demande d'un utilisateur pour afficher la progression et créer une expérience plus interactive.

Les réponses diffusées en continu constituent une option pour les requêtes de forme libre et les chats avec les modèles Gemini. Les exemples de code suivants montrent comment demander une réponse en streaming à une requête pour chaque langage compatible:

Python

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

response = genai.stream_generate_content(
    model="models/gemini-1.5-flash",
    prompt=prompt
)

Consultez le tutoriel Python pour voir l'extrait de code complet.

Go 

ctx := context.Background()
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

model := client.GenerativeModel("gemini-1.5-flash")

iter := model.GenerateContentStream(ctx, genai.Text("Write a story about a magic backpack."))
for {
  resp, err := iter.Next()
  if err == iterator.Done {
    break
  }
  if err != nil {
    log.Fatal(err)
  }

  // print resp
}

Consultez le tutoriel Go pour voir un exemple complet.

Node.js

const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });
const prompt = "Write a story about a magic backpack.";

const result = await model.generateContentStream([prompt]);
// print text as it comes in
for await (const chunk of result.stream) {
  const chunkText = chunk.text();
  console.log(chunkText);
}

Consultez le tutoriel Node.js pour voir un exemple complet.

Web

const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });
const prompt = "Write a story about a magic backpack.";

const result = await model.generateContentStream([prompt]);
// print text as it comes in
for await (const chunk of result.stream) {
  const chunkText = chunk.text();
  console.log(chunkText);
}

Consultez le tutoriel Web pour un exemple complet.

Dart (Flutter) 

final model = GenerativeModel(model: 'gemini-1.5-flash', apiKey: apiKey);
final prompt = 'Write a story about a magic backpack.';
final content = [Content.text(prompt)];
final response = model.generateContentStream(content);
await for (final chunk in response) {
  print(chunk.text);
}

Consultez le tutoriel Dart (Flutter) pour obtenir un exemple complet.

Swift

let model = GenerativeModel(name: "gemini-1.5-flash", apiKey: "API_KEY")
let prompt = "Write a story about a magic backpack."

let stream = model.generateContentStream(prompt)
for try await chunk in stream {
  print(chunk.text ?? "No content")
}

Consultez le tutoriel sur Swift pour un exemple complet.

Android

val generativeModel = GenerativeModel(
    modelName = "gemini-1.5-flash",
    apiKey = BuildConfig.apiKey
)

val inputContent = content {
  text("Write a story about a magic backpack.")
}

var fullResponse = ""
generativeModel.generateContentStream(inputContent).collect { chunk ->
  print(chunk.text)
  fullResponse += chunk.text
}

Consultez le tutoriel Android pour un exemple complet.

cURL

curl https://generativelanguage.googleapis.com/v1/models/gemini-1.5-flash:streamGenerateContent?key=${API_KEY} \
    -H 'Content-Type: application/json' \
    --no-buffer \
    -d '{ "contents":[
            {"role": "user",
              "parts":[{"text": "Write a story about a magic backpack."}]
            }
          ]
        }' > response.json

Pour en savoir plus, consultez le tutoriel de l'API REST.

Réponses au format JSON

En fonction de votre application, vous pouvez souhaiter que la réponse à une invite soit renvoyée dans un format de données structurées, en particulier si vous utilisez ces réponses pour renseigner des interfaces de programmation. L'API Gemini fournit un paramètre de configuration pour demander une réponse au format JSON.

Pour obtenir le fichier JSON de sortie du modèle, définissez l'option de configuration response_mime_type sur application/json, puis décrivez le format JSON souhaité dans l'invite:

Python

model = genai.GenerativeModel('gemini-1.5-flash',
                              generation_config={"response_mime_type": "application/json"})

prompt = """
  List 5 popular cookie recipes.

  Using this JSON schema:

    Recipe = {"recipe_name": str}

  Return a `list[Recipe]`
  """

response = model.generate_content(prompt)
print(response.text)

cURL

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=$API_KEY \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [
        {
          "parts": [
            {
              "text": "\nList 5 popular cookie recipes.\n\nUsing this JSON schema:\n\n  Recipe = {\"recipe_name\": str}\n\nReturn a `list[Recipe]`\n      "
            }
          ]
        }
      ]
      "generationConfig": {
            "response_mime_type": "application/json",
      }
    }'

Alors que les modèles Flash Gemini 1.5 n'acceptent qu'une description textuelle du schéma JSON que vous souhaitez obtenir, les modèles Gemini 1.5 Pro vous permettent de transmettre un objet de schéma (ou un équivalent de type Python). La sortie du modèle suivra strictement ce schéma. Ceci est également connu sous le nom de génération contrôlée ou décodage restreint.

Par exemple, pour obtenir la liste des objets Recipe, transmettez list[Recipe] au champ response_schema de l'argument generation_config:

Python

import typing_extensions as typing

class Recipe(typing.TypedDict):
  recipe_name: str

model = genai.GenerativeModel(model_name="models/gemini-1.5-pro")

result = model.generate_content(
  "List 5 popular cookie recipes",
  generation_config=genai.GenerationConfig(response_mime_type="application/json",
                                           response_schema = list[Recipe]))

print(result.text)

cURL

  curl https://generativelanguage.googleapis.com/v1beta/models/models/gemini-1.5-pro:generateContent?
      -H 'Content-Type: application/json'
      -X POST \
      -d '{
        "contents": [
          {
            "parts": [
              {
                "text": "List 5 popular cookie recipes"
              }
            ]
          }
        ],
        "generationConfig": {
          "responseMimeType": "application/json",
          "responseSchema": {
            "type": "ARRAY",
            "items": {
              "type": "OBJECT",
              "properties": {
                "recipe_name": {
                  "type": "STRING"
                }
              }
            }
          }
        }
      }'
  ```

Pour en savoir plus, consultez le guide de démarrage rapide du mode JSON dans le livre de recettes sur l'API Gemini.

Représentations vectorielles continues

Le service de représentation vectorielle continue de l'API Gemini génère des représentations vectorielles continues de pointe pour les mots, les expressions et les phrases. Les représentations vectorielles continues résultantes peuvent ensuite être utilisées pour des tâches de TLN, telles que la recherche sémantique, la classification de texte et le clustering, entre autres. Consultez le guide des représentations vectorielles continues pour découvrir en quoi consistent les représentations vectorielles continues et consultez certains cas d'utilisation clés du service de représentation vectorielle continue pour vous aider à démarrer.

Étapes suivantes