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, commencez le développement en suivant le tutoriel correspondant au langage de votre choix.

Modèles

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

Pour en savoir plus sur ces modèles, consultez la page Modèles Gemini. 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 de la requête

Certains modèles Gemini acceptent à la fois les données textuelles et les fichiers multimédias en entrée. Cette fonctionnalité crée de nombreuses possibilités supplémentaires pour générer du contenu, analyser des données et résoudre des problèmes. Il existe certaines limites et conditions à prendre en compte, 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 page Modèles Gemini.

La taille des requêtes utilisant l'API Gemini ne peut pas dépasser 20 Mo. L'API Gemini fournit une API File pour stocker temporairement les fichiers multimédias à utiliser dans les requêtes, ce qui vous permet de 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 requêtes, consultez Exécuter des requêtes avec des fichiers multimédias.

Conception de requêtes et saisie de texte

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

Génération de contenus

L'API Gemini vous permet d'utiliser à la fois des données textuelles et des données d'images pour vos requêtes, selon la variante de modèle que vous utilisez. 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 chacun d'eux. Reportez-vous à la documentation de référence de l'API generateContent pour obtenir un exemple plus détaillé couvrant tous les paramètres.

Saisie de texte et d'image

Vous pouvez envoyer une requête textuelle avec une image à un modèle Gemini 1.5 pour effectuer une tâche liée à la vision. Il peut s'agir, par exemple, de légender une image ou d'identifier son contenu.

Les exemples de code suivants illustrent l'implémentation de base d'une requête textuelle et illustrée pour chaque langue 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)
}

Pour un exemple complet, consultez le tutoriel Go.

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

Pour obtenir un exemple complet, consultez le tutoriel sur Node.js.

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

Pour obtenir un exemple complet, consultez le tutoriel Dart (Flutter).

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 de Swift pour obtenir 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 obtenir 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 sur l'API REST.

Saisie de texte uniquement

L'API Gemini peut également gérer la saisie de texte uniquement. Cette fonctionnalité vous permet d'effectuer des tâches de traitement du langage naturel (TLN), telles que la saisie semi-automatique et la synthèse de texte.

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

Python

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

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

response = model.generate_content(prompt)

Pour obtenir un exemple complet, consultez le tutoriel Python.

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

Pour un exemple complet, consultez le tutoriel Go.

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

Pour obtenir un exemple complet, consultez le tutoriel sur Node.js.

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

Pour obtenir un exemple complet, consultez le tutoriel Dart (Flutter).

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 de Swift pour obtenir 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 obtenir 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 sur l'API REST.

Conversations multitours (chat)

Vous pouvez utiliser l'API Gemini pour créer des expériences de discussion interactives pour vos utilisateurs. 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'obtenir progressivement 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 du service client.

Les exemples de code suivants illustrent une implémentation de base des interactions par chat pour chaque langue 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)

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

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 voir 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());

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

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

Pour un exemple complet, consultez la démonstration du chat dans le tutoriel Dart (Flutter).

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 Swift pour obtenir 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 obtenir 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 sur 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: sous forme de flux de données. Une réponse diffusée en continu renvoie des données incrémentales à 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 permettent d'envoyer des requêtes au format libre et de discuter avec les modèles Gemini. Les exemples de code suivants montrent comment demander une réponse diffusée en continu pour une requête pour chaque langue 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
}

Pour un exemple complet, consultez le tutoriel Go.

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

Pour obtenir un exemple complet, consultez le tutoriel sur Node.js.

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

Pour obtenir un exemple complet, consultez le tutoriel Dart (Flutter).

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 de Swift pour obtenir 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 obtenir 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 sur l'API REST.

Réponses au format JSON

En fonction de votre application, vous souhaiterez peut-être que la réponse à une invite soit renvoyée dans un format de données structurées, en particulier si vous utilisez les 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.

Vous pouvez obtenir la sortie JSON du modèle en définissant l'option de configuration response_mime_type sur application/json et en décrivant le format JSON que vous souhaitez obtenir dans la réponse 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",
      }
    }'

Bien que les modèles Flash de Gemini 1.5 n'acceptent qu'une description textuelle du schéma JSON que vous souhaitez renvoyer, les modèles Gemini 1.5 Pro vous permettent de transmettre un objet de schéma (ou un équivalent de type Python), et la sortie du modèle suivra strictement ce schéma. Ce processus est également appelé génération contrôlée ou décodage contraint.

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 de l'API Gemini.

Embeddings

Le service de représentation vectorielle continue de l'API Gemini génère des représentations vectorielles continues de pointe pour des mots, des expressions et des phrases. Les représentations vectorielles continues obtenues 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 sur les représentations vectorielles continues pour découvrir ce que sont les représentations vectorielles continues et découvrir quelques cas d'utilisation clés du service de représentations vectorielles continues qui vous aideront à démarrer.

Étapes suivantes