Premiers pas avec Gemini 3

Gemini 3 est notre famille de modèles la plus intelligente à ce jour, basée sur un raisonnement de pointe. Elle est conçue pour donner vie à toutes les idées en maîtrisant les workflows agentiques, le codage autonome et les tâches multimodales complexes.

Ce guide fournit une approche pratique et consolidée pour commencer à utiliser Gemini 3 sur Gemini Enterprise Agent Platform. Il met en évidence les principales fonctionnalités et les bonnes pratiques de Gemini 3.

Guide de démarrage rapide

Avant de commencer, vous devez vous authentifier auprès de Gemini Enterprise Agent Platform à l'aide d'une clé API ou des identifiants par défaut de l'application (ADC). Pour en savoir plus, consultez Méthodes d'authentification.

Installer le SDK Google Gen AI

Les fonctionnalités de l'API Gemini 3 nécessitent le SDK Google Gen AI pour Python en version 1.51.0 ou ultérieure.

pip install --upgrade google-genai

Définir des variables d'environnement pour utiliser le SDK Google Gen AI avec Gemini Enterprise Agent Platform

Remplacez la GOOGLE_CLOUD_PROJECT valeur par votre Google Cloud ID de projet. Le modèle Gemini 3.1 Pro gemini-3.1-pro-preview et le modèle Gemini 3 Flash gemini-3-flash-preview ne sont disponibles que sur les points de terminaison globaux :

export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

Créer votre première requête

Par défaut, les modèles Gemini 3 et Gemini 3 Flash utilisent le raisonnement dynamique pour traiter les requêtes. Pour obtenir des réponses plus rapides et à faible latence lorsque le raisonnement complexe n'est pas nécessaire, vous pouvez limiter le thinking_level du modèle. Le raisonnement faible est idéal pour les tâches à haut débit où la vitesse est primordiale.

Pour des réponses rapides et à faible latence :

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
   model="gemini-3.6-flash",
   contents="How does AI work?",
   config=types.GenerateContentConfig(
       thinking_config=types.ThinkingConfig(
           thinking_level=types.ThinkingLevel.LOW # For fast and low latency response
       )
   ),
)
print(response.text)

Essayer des tâches de raisonnement complexes

Gemini 3 excelle dans le raisonnement avancé. Pour les tâches complexes telles que la planification en plusieurs étapes, la génération de code vérifié ou l'utilisation approfondie d'outils, utilisez des niveaux de raisonnement élevés. Utilisez ces configurations pour les tâches qui nécessitaient auparavant des modèles de raisonnement spécialisés.

Pour les tâches plus lentes et à raisonnement élevé :

from google import genai
from google.genai import types

client = genai.Client()

prompt = """
You are tasked with implementing the classic Thread-Safe Double-Checked Locking (DCL) Singleton pattern in modern C++. This task is non-trivial and requires specialized concurrency knowledge to prevent memory reordering issues.

Write a complete, runnable C++ program named `dcl_singleton.cpp` that defines a class `Singleton` with a private constructor and a static `getInstance()` method.

Your solution MUST adhere to the following strict constraints:
1. The Singleton instance pointer (`static Singleton*`) must be wrapped in `std::atomic` to correctly manage memory visibility across threads.
2. The `getInstance()` method must use `std::memory_order_acquire` when reading the instance pointer in the outer check.
3. The instance creation and write-back must use `std::memory_order_release` when writing to the atomic pointer.
4. A standard `std::mutex` must be used only to protect the critical section (the actual instantiation).
5. The `main` function must demonstrate safe, concurrent access by launching at least three threads, each calling `Singleton::getInstance()`, and printing the address of the returned instance to prove all threads received the same object.
"""

response = client.models.generate_content(
  model="gemini-3.6-flash",
  contents=prompt,
  config=types.GenerateContentConfig(
      thinking_config=types.ThinkingConfig(
          thinking_level=types.ThinkingLevel.HIGH # Dynamic thinking for high reasoning tasks
      )
  ),
)
print(response.text)

Autres niveaux de raisonnement

Gemini 3 Flash introduit deux nouveaux niveaux de raisonnement : MINIMAL et MEDIUM. Vous bénéficiez ainsi d'un contrôle encore plus précis sur la façon dont le modèle gère les tâches de raisonnement complexes.

MINIMAL offre des options de budget de raisonnement quasi nulles pour les tâches optimisées pour le débit plutôt que pour le raisonnement. MEDIUM permet d'équilibrer la vitesse et le raisonnement, ce qui permet une certaine capacité de raisonnement tout en privilégiant les opérations à faible latence.

Nouvelles fonctionnalités de l'API

Gemini 3 introduit de puissantes améliorations de l'API et de nouveaux paramètres conçus pour offrir aux développeurs un contrôle précis sur les performances (latence, coût), le comportement du modèle et la fidélité multimodale.

Ce tableau récapitule les principales nouvelles fonctionnalités et les nouveaux paramètres disponibles, ainsi que des liens directs vers leur documentation détaillée :

Nouvelle fonctionnalité/modification de l'API Documentation
Modèle : gemini-3.1-pro-preview Fiche de modèle
Model Garden
Niveau de raisonnement Raisonnement
Résolution des contenus multimédias Compréhension d'images
Compréhension vidéo
Compréhension audio
Compréhension des documents
Signature de réflexion Signatures de réflexion
Température Documentation de référence de l'API
Réponses de fonction multimodales Appel de fonction : réponses de fonction multimodales
Appel de fonction en streaming Appel de fonction : appel de fonction en streaming

Niveau de raisonnement

Le paramètre thinking_level vous permet de spécifier un budget de raisonnement pour la génération de la réponse du modèle. En sélectionnant l'un des deux états, vous pouvez équilibrer explicitement les compromis entre la qualité de la réponse et la complexité du raisonnement, ainsi qu'entre la latence et le coût.

  • MINIMAL: (Gemini 3 Flash et Gemini 3.1 Flash-Lite uniquement) limite le modèle à utiliser le moins de jetons possible pour le raisonnement. Il est préférable de l'utiliser pour les tâches peu complexes qui ne bénéficieraient pas d'un raisonnement approfondi. MINIMAL est aussi proche que possible d'un budget de raisonnement nul, mais nécessite toujours des signatures de réflexion.
  • LOW: limite le modèle à utiliser moins de jetons pour le raisonnement. Il convient aux tâches plus simples qui ne nécessitent pas de raisonnement approfondi. LOW est idéal pour les tâches à haut débit où la vitesse est essentielle.
  • MEDIUM: (Gemini 3 Flash, Gemini 3.1 Pro et Gemini 3.1 Flash-Lite uniquement) offre une approche équilibrée adaptée aux tâches de complexité modérée qui bénéficient d'un raisonnement, mais qui ne nécessitent pas de planification approfondie en plusieurs étapes. Il offre une plus grande capacité de raisonnement que LOW, tout en maintenant une latence inférieure à HIGH.
  • HIGH: permet au modèle d'utiliser plus de jetons pour le raisonnement. Il convient aux requêtes complexes nécessitant un raisonnement approfondi, telles que la planification en plusieurs étapes, la génération de code vérifié ou les scénarios d'appel de fonction avancés. Il s'agit du niveau par défaut pour les modèles Gemini 3 et Gemini 3 Flash. Utilisez cette configuration lorsque vous remplacez des tâches pour lesquelles vous vous appuyiez auparavant sur des modèles de raisonnement spécialisés.

Exemple de SDK Google Gen AI

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
   model="gemini-3.6-flash",
   contents="Find the race condition in this multi-threaded C++ snippet: [code here]",
   config=types.GenerateContentConfig(
       thinking_config=types.ThinkingConfig(
           thinking_level=types.ThinkingLevel.HIGH # Default, dynamic thinking
       )
   ),
)
print(response.text)

Exemple de compatibilité OpenAI

Pour les utilisateurs qui utilisent la couche de compatibilité OpenAI, les paramètres standards sont automatiquement mappés sur les équivalents Gemini 3 :

  • reasoning_effort est mappé sur thinking_level.
  • none est mappé sur thinking_level minimal (Gemini 3 Flash uniquement).
  • medium est mappé sur thinking_level moyen pour tous les modèles Gemini 3.
import openai
from google.auth import default
from google.auth.transport.requests import Request

credentials, _ = default(scopes=["https://www.googleapis.com/auth/cloud-platform"])

client = openai.OpenAI(
    base_url=f"https://aiplatform.googleapis.com/v1/projects/{PROJECT_ID}/locations/global/endpoints/openapi",
    api_key=credentials.token,
)

prompt = """
Write a bash script that takes a matrix represented as a string with
format '[1,2],[3,4],[5,6]' and prints the transpose in the same format.
"""

response = client.chat.completions.create(
    model="gemini-3.6-flash",
    reasoning_effort="medium", # Map to thinking_level high.
    messages=[{"role": "user", "content": prompt}],
)

print(response.choices[0].message.content)

Résolution des contenus multimédias

Gemini 3 introduit un contrôle précis sur le traitement de la vision multimodale à l'aide du paramètre media_resolution. Les résolutions plus élevées améliorent la capacité du modèle à lire du texte fin ou à identifier de petits détails, mais augmentent l'utilisation des jetons et la latence. Le paramètre media_resolution détermine le nombre maximal de jetons alloués par image d'entrée, page PDF ou image vidéo.

Vous pouvez définir la résolution sur low, medium ou high de manière globale (à l'aide de generation_config) ou pour des parties multimédias individuelles. La résolution ultra_high ne peut être définie que pour des parties multimédias individuelles. Si aucune valeur n'est spécifiée, le modèle utilise les valeurs par défaut optimales en fonction du type de média.

Nombre de jetons

Ce tableau récapitule le nombre approximatif de jetons pour chaque valeur media_resolution et type de média.

Résolution des contenus multimédias Image Vidéo PDF
UNSPECIFIED (par défaut) 1120 70 560
LOW 280 70 280 + Texte
MEDIUM 560 70 560 + Texte
HIGH 1120 280 1120 + Texte
ULTRA_HIGH 2240 N/A N/A
Résolution des contenus multimédias Nombre maximal de jetons Usage Guidance
ultra_high 2240 Tâches nécessitant l'analyse de détails précis dans les images, comme le traitement d'images fixes d'enregistrement d'écran ou de photos haute résolution.
high 1120 Tâches d'analyse d'images pour garantir une qualité maximale.
medium 560
low Image : 280 Vidéo : 70 Suffisant pour la plupart des tâches. Remarque : Pour la vidéo, low correspond à un maximum de 70 jetons par image.

Définir media_resolution par partie individuelle

Vous pouvez définir media_resolution par partie de contenu multimédia individuelle :

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
  model="gemini-3.6-flash",
  contents=[
      types.Part(
          file_data=types.FileData(
              file_uri="gs://cloud-samples-data/generative-ai/image/a-man-and-a-dog.png",
              mime_type="image/jpeg",
          ),
          media_resolution=types.PartMediaResolution(
              level=types.PartMediaResolutionLevel.MEDIA_RESOLUTION_HIGH # High resolution
          ),
      ),
      Part(
          file_data=types.FileData(
             file_uri="gs://cloud-samples-data/generative-ai/video/behind_the_scenes_pixel.mp4",
            mime_type="video/mp4",
          ),
          media_resolution=types.PartMediaResolution(
              level=types.PartMediaResolutionLevel.MEDIA_RESOLUTION_LOW # Low resolution
          ),
      ),
      "When does the image appear in the video? What is the context?",
  ],
)
print(response.text)

Définir media_resolution de manière globale

Vous pouvez également définir media_resolution de manière globale (à l'aide de GenerateContentConfig) :

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
  model="gemini-3.6-flash",
  contents=[
      types.Part(
          file_data=types.FileData(
              file_uri="gs://cloud-samples-data/generative-ai/image/a-man-and-a-dog.png",
              mime_type="image/jpeg",
          ),
      ),
      "What is in the image?",
  ],
  config=types.GenerateContentConfig(
      media_resolution=types.MediaResolution.MEDIA_RESOLUTION_LOW, # Global setting
  ),
)
print(response.text)

Signatures de réflexion

Les signatures de réflexion sont des jetons chiffrés qui préservent l'état de raisonnement du modèle lors de conversations multitours, en particulier lors de l'utilisation de l'appel de fonction.

Lorsqu'un modèle de raisonnement décide d'appeler un outil externe, il met en pause son processus de raisonnement interne. La signature de réflexion fait office d'"état d'enregistrement", ce qui permet au modèle de reprendre sa chaîne de pensée de manière transparente une fois que vous avez fourni le résultat de la fonction.

Pour en savoir plus, consultez Signatures de réflexion.

Pourquoi les signatures de réflexion sont-elles importantes ?

Sans signatures de réflexion, le modèle "oublie" ses étapes de raisonnement spécifiques lors de la phase d'exécution de l'outil. Le renvoi de la signature garantit les points suivants :

  • Continuité du contexte : le modèle conserve la raison pour laquelle l'outil a été appelé.
  • Raisonnement complexe : permet d'effectuer des tâches en plusieurs étapes où la sortie d'un outil informe le raisonnement du suivant.

Où les signatures de réflexion sont-elles renvoyées ?

Les modèles Gemini 3 et Gemini 3 Flash appliquent une validation plus stricte et une gestion mise à jour des signatures de réflexion, qui ont été introduites à l'origine dans Gemini 2.5. Pour vous assurer que le modèle conserve le contexte sur plusieurs tours d'une conversation, vous devez renvoyer les signatures de réflexion dans vos requêtes suivantes.

  • Les réponses du modèle avec un appel de fonction renvoient toujours une signature de réflexion, même lorsque vous utilisez le niveau de raisonnement MINIMAL.
  • Lorsqu'il existe des appels de fonction parallèles, la première partie d'appel de fonction renvoyée par la réponse du modèle comporte une signature de réflexion.
  • Lorsqu'il existe des appels de fonction séquentiels (en plusieurs étapes), chaque appel de fonction comporte une signature et les clients doivent renvoyer la signature.
  • Les réponses du modèle sans appel de fonction renvoient une signature de réflexion dans la dernière partie renvoyée par le modèle.

Comment gérer les signatures de réflexion ?

Il existe deux façons principales de gérer les signatures de réflexion : automatiquement à l'aide des SDK Google Gen AI ou de l'API OpenAI, ou manuellement si vous interagissez directement avec l'API.

Gestion automatisée (recommandée)

Si vous utilisez les SDK Google Gen AI (Python, Node.js, Go, Java) ou l'API OpenAI Chat Completions, et que vous utilisez les fonctionnalités standards d'historique des discussions ou que vous ajoutez la réponse complète du modèle, les thought_signatures sont gérées automatiquement. Vous n'avez pas besoin de modifier votre code.

Exemple d'appel de fonction manuel

Lorsque vous utilisez le SDK Google Gen AI, les signatures de réflexion sont gérées automatiquement en ajoutant la réponse complète du modèle dans les requêtes de modèle séquentielles :

from google import genai
from google.genai import types

client = genai.Client()

# 1. Define your tool
get_weather_declaration = types.FunctionDeclaration(
   name="get_weather",
   description="Gets the current weather temperature for a given location.",
   parameters={
       "type": "object",
       "properties": {"location": {"type": "string"}},
       "required": ["location"],
   },
)
get_weather_tool = types.Tool(function_declarations=[get_weather_declaration])

# 2. Send a message that triggers the tool
prompt = "What's the weather like in London?"
response = client.models.generate_content(
   model="gemini-3.6-flash",
   contents=prompt,
   config=types.GenerateContentConfig(
       tools=[get_weather_tool],
       thinking_config=types.ThinkingConfig(include_thoughts=True)
   ),
)

# 4. Handle the function call
function_call = response.function_calls[0]
location = function_call.args["location"]
print(f"Model wants to call: {function_call.name}")

# Execute your tool (e.g., call an API)
# (This is a mock response for the example)
print(f"Calling external tool for: {location}")
function_response_data = {
   "location": location,
   "temperature": "30C",
}

# 5. Send the tool's result back
# Append this turn's messages to history for a final response.
# The `content` object automatically attaches the required thought_signature behind the scenes.
history = [
    types.Content(role="user", parts=[types.Part(text=prompt)]),
    response.candidates[0].content, # Signature preserved here
    types.Content(
        role="user",
        parts=[
            types.Part.from_function_response(
                name=function_call.name,
                response=function_response_data,
            )
        ],
    )
]

response_2 = client.models.generate_content(
   model="gemini-3.6-flash",
   contents=history,
   config=types.GenerateContentConfig(
        tools=[get_weather_tool],
        thinking_config=types.ThinkingConfig(include_thoughts=True)
   ),
)

# 6. Get the final, natural-language answer
print(f"\nFinal model response: {response_2.text}")
Exemple d'appel de fonction automatique

Lorsque vous utilisez le SDK Google Gen AI dans l'appel de fonction automatique, les signatures de réflexion sont gérées automatiquement :


from google import genai
from google.genai import types

def get_current_temperature(location: str) -> dict:
    """Gets the current temperature for a given location.

    Args:
        location: The city and state, for example San Francisco, CA

    Returns:
        A dictionary containing the temperature and unit.
    """
    # ... (implementation) ...
    return {"temperature": 25, "unit": "Celsius"}

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3.6-flash",
    contents="What's the temperature in Boston?",
    config=types.GenerateContentConfig(
            tools=[get_current_temperature],
    )
)

print(response.text) # The SDK handles the function call and thought signature, and returns the final text
Exemple de compatibilité OpenAI

Lorsque vous utilisez l'API OpenAI Chat Completions, les signatures de réflexion sont gérées automatiquement en ajoutant la réponse complète du modèle dans les requêtes de modèle séquentielles :

...
# Append user prompt and assistant response including thought signatures
messages.append(response1.choices[0].message)

# Execute the tool
tool_call_1 = response1.choices[0].message.tool_calls[0]
result_1 = get_current_temperature(**json.loads(tool_call_1.function.arguments))

# Append tool response to messages
messages.append(
    {
        "role": "user",
        "tool_call_id": tool_call_1.id,
        "content": json.dumps(result_1),
    }
)

response2 = client.chat.completions.create(
    model="gemini-3.6-flash",
    messages=messages,
    tools=tools,
    extra_body={
        "extra_body": {
            "google": {
                "thinking_config": {
                    "include_thoughts": True,
                },
            },
        },
    },
)

print(response2.choices[0].message.tool_calls)

Consultez l'exemple de code complet.

Gestion manuelle

Si vous interagissez directement avec l'API ou si vous gérez des charges utiles JSON brutes, vous devez gérer correctement la thought_signature incluse dans le tour du modèle.

Vous devez renvoyer cette signature dans la partie exacte où elle a été reçue lors du renvoi de l'historique des conversations.

Si les signatures appropriées ne sont pas renvoyées, Gemini 3 renvoie une erreur 400 "<Function Call> in the <index of contents array> content block is missing a thought_signature".

Réponses de fonction multimodales

L'appel de fonction multimodal permet aux utilisateurs d'obtenir des réponses de fonction contenant des objets multimodaux, ce qui améliore l'utilisation des capacités d'appel de fonction du modèle. L'appel de fonction standard n'accepte que les réponses de fonction basées sur du texte :

from google import genai
from google.genai import types

client = genai.Client()

# This is a manual, two turn multimodal function calling workflow:

# 1. Define the function tool
get_image_declaration = types.FunctionDeclaration(
   name="get_image",
   description="Retrieves the image file reference for a specific order item.",
   parameters={
       "type": "object",
       "properties": {
            "item_name": {
                "type": "string",
                "description": "The name or description of the item ordered (e.g., 'green shirt')."
            }
       },
       "required": ["item_name"],
   },
)
tool_config = types.Tool(function_declarations=[get_image_declaration])

# 2. Send a message that triggers the tool
prompt = "Show me the green shirt I ordered last month."
response_1 = client.models.generate_content(
    model="gemini-3.6-flash",
    contents=[prompt],
    config=types.GenerateContentConfig(
        tools=[tool_config],
    )
)

# 3. Handle the function call
function_call = response_1.function_calls[0]
requested_item = function_call.args["item_name"]
print(f"Model wants to call: {function_call.name}")

# Execute your tool (e.g., call an API)
# (This is a mock response for the example)
print(f"Calling external tool for: {requested_item}")

function_response_data = {
  "image_ref": {"$ref": "dress.jpg"},
}

function_response_multimodal_data = types.FunctionResponsePart(
   file_data=types.FunctionResponseFileData(
      mime_type="image/png",
      display_name="dress.jpg",
      file_uri="gs://cloud-samples-data/generative-ai/image/dress.jpg",
   )
)

# 4. Send the tool's result back
# Append this turn's messages to history for a final response.
history = [
  types.Content(role="user", parts=[types.Part(text=prompt)]),
  response_1.candidates[0].content,
  types.Content(
    role="user",
    parts=[
        types.Part.from_function_response(
            name=function_call.name,
            response=function_response_data,
            parts=[function_response_multimodal_data]
        )
    ],
  )
]

response_2 = client.models.generate_content(
  model="gemini-3.6-flash",
  contents=history,
  config=types.GenerateContentConfig(
      tools=[tool_config],
      thinking_config=types.ThinkingConfig(include_thoughts=True)
  ),
)

print(f"\nFinal model response: {response_2.text}")

Appel de fonction en streaming

Vous pouvez utiliser des arguments d'appel de fonction partiels en streaming pour améliorer l'expérience de streaming lors de l'utilisation d'outils. Vous pouvez activer cette fonctionnalité en définissant explicitement stream_function_call_arguments sur true :

from google import genai
from google.genai import types

client = genai.Client()

get_weather_declaration = types.FunctionDeclaration(
  name="get_weather",
  description="Gets the current weather temperature for a given location.",
  parameters={
      "type": "object",
      "properties": {"location": {"type": "string"}},
      "required": ["location"],
  },
)
get_weather_tool = types.Tool(function_declarations=[get_weather_declaration])


for chunk in client.models.generate_content_stream(
   model="gemini-3.6-flash",
   contents="What's the weather in London and New York?",
   config=types.GenerateContentConfig(
       tools=[get_weather_tool],
       tool_config = types.ToolConfig(
           function_calling_config=types.FunctionCallingConfig(
               mode=types.FunctionCallingConfigMode.AUTO,
               stream_function_call_arguments=True,
           )
       ),
   ),
):
   function_call = chunk.function_calls[0]
   if function_call and function_call.name:
       print(f"{function_call.name}")
       print(f"will_continue={function_call.will_continue}")

Exemple de réponse du modèle :

{
  "candidates": [
    {
      "content": {
        "role": "model",
        "parts": [
          {
            "functionCall": {
              "name": "get_weather",
              "willContinue": true
            }
          }
        ]
      }
    }
  ]
}

Température

  • Range for Gemini 3: 0.0 - 2.0 (default: 1.0)

Pour Gemini 3, il est fortement recommandé de conserver le paramètre temperature sur sa valeur par défaut de 1.0.

Alors que les modèles précédents bénéficiaient souvent d'un réglage de la température pour contrôler la créativité par rapport au déterminisme, les capacités de raisonnement de Gemini 3 sont optimisées pour le paramètre par défaut.

La modification de la température (définie sur une valeur inférieure à 1.0) peut entraîner un comportement inattendu, tel qu'une boucle ou une dégradation des performances, en particulier dans les tâches mathématiques ou de raisonnement complexes.

Fonctionnalités compatibles

Les modèles Gemini 3 sont également compatibles avec les fonctionnalités suivantes :

Bonnes pratiques concernant les prompts

Gemini 3 est un modèle de raisonnement, ce qui modifie la façon dont vous devez le solliciter.

  • Instructions précises : soyez concis dans vos requêtes d'entrée. Gemini 3 répond mieux aux instructions directes et claires. Il peut suranalyser les techniques de prompt engineering verbeuses ou trop complexes utilisées pour les anciens modèles.
  • Verbosité de la sortie : par défaut, Gemini 3 est moins verbeux et préfère fournir des réponses directes et efficaces. Si votre cas d'utilisation nécessite une personnalité plus conversationnelle ou "bavarde", vous devez explicitement orienter le modèle dans la requête (par exemple, "Expliquez cela comme un assistant amical et bavard").
  • Ancrage : pour les cas d'utilisation d'ancrage, nous vous recommandons d'utiliser les instructions de développement suivantes : You are a strictly grounded assistant limited to the information provided in the User Context. In your answers, rely **only** on the facts that are directly mentioned in that context. You must **not** access or utilize your own knowledge or common sense to answer. Do not assume or infer from the provided facts; simply report them exactly as they appear. Your answer must be factual and fully truthful to the provided text, leaving absolutely no room for speculation or interpretation. Treat the provided context as the absolute limit of truth; any facts or details that are not directly mentioned in the context must be considered **completely untruthful** and **completely unsupported**. If the exact answer is not explicitly written in the context, you must state that the information is not available.
  • Utilisation de l'outil de recherche Google : lorsque vous utilisez l'outil de recherche Google, Gemini 3 Flash peut parfois confondre la date / l'heure actuelles avec des événements de 2024. Le modèle peut alors formuler des requêtes de recherche pour la mauvaise année. Pour vous assurer que le modèle utilise la période correcte, renforcez explicitement la date actuelle dans les system instructions : For time-sensitive user queries that require up-to-date information, you MUST follow the provided current time (date and year) when formulating search queries in tool calls. Remember it is 2025 this year.
  • Date limite de connaissances : pour certaines requêtes, il est utile de préciser explicitement à Gemini 3 Flash sa date limite de connaissances. C'est le cas lorsque l'outil de recherche Google est désactivé et que la requête exige explicitement que le modèle soit en mesure d'identifier les données limites dans les connaissances paramétriques. Recommandation : ajoutez la clause suivante à system instructions: Your knowledge cutoff date is January 2025.
  • Utilisation de media_resolution : utilisez le paramètre media_resolution pour contrôler le nombre maximal de jetons que le modèle utilise pour représenter une image ou des images dans des vidéos. Une résolution élevée permet au modèle de capturer les détails d'une image et peut utiliser plus de jetons par image, tandis qu'une résolution inférieure permet d'optimiser les coûts et la latence pour les images avec moins de détails visuels.
  • Améliorer l'analyse vidéo : utilisez un taux d'échantillonnage d'images par seconde (FPS) plus élevé pour les vidéos nécessitant une analyse temporelle précise, comme la compréhension d'actions rapides ou le suivi du mouvement à grande vitesse.

Considérations sur la migration

Tenez compte des fonctionnalités et des contraintes suivantes lors de la migration :

  • Niveau de raisonnement : les modèles Gemini 3 utilisent le thinking_level paramètre pour contrôler la quantité de raisonnement interne effectuée par le modèle (faible ou élevée) et pour équilibrer la qualité de la réponse, la complexité du raisonnement, la latence et le coût.
  • Paramètres de température : si votre code existant définit explicitement temperature (en particulier sur des valeurs faibles pour les sorties déterministes), il est recommandé de supprimer ce paramètre et d'utiliser la valeur par défaut de Gemini 3, 1.0, pour éviter d'éventuels problèmes de boucle ou une dégradation des performances sur les tâches complexes.
  • Signatures de réflexion : pour les modèles Gemini 3, si une signature de réflexion est attendue dans un tour, mais qu'elle n'est pas fournie, le modèle renvoie une erreur au lieu d'un avertissement.
  • Résolution des contenus multimédias et tokenisation : les modèles Gemini 3 utilisent une longueur de séquence variable pour la tokenisation des contenus multimédias au lieu de Pan and Scan, et disposent de nouvelles résolutions par défaut et de nouveaux coûts de jetons pour les images, les PDF et les vidéos.
  • Comptage des jetons pour l'entrée multimodale : le nombre de jetons pour les entrées multimodales (images, vidéos, audio) est une estimation basée sur la media_resolution choisie. Par conséquent, le résultat de l'appel d'API count_tokens peut ne pas correspondre aux jetons consommés finaux. L'utilisation précise pour la facturation n'est disponible qu'après l'exécution dans le usage_metadata de la réponse.
  • Consommation de jetons : la migration vers les valeurs par défaut de Gemini 3 peut augmenter l'utilisation des jetons pour les images et les PDF, mais la diminuer pour les vidéos. Si les requêtes dépassent désormais la fenêtre de contexte en raison de résolutions par défaut plus élevées, il est recommandé de réduire explicitement la résolution des contenus multimédias.
  • Compréhension des PDF et des documents : la résolution OCR par défaut pour les PDF a changé. Si vous vous appuyez sur un comportement spécifique pour l'analyse de documents denses, testez le nouveau media_resolution: "high" paramètre pour garantir une précision continue. Pour les modèles Gemini 3, le nombre de jetons PDF dans usage_metadata est indiqué sous la modalité IMAGE au lieu de DOCUMENT.
  • Segmentation d'image : la segmentation d'image n'est pas prise en charge par les modèles Gemini 3. Pour les charges de travail nécessitant une segmentation d'image intégrée, il est recommandé de continuer à utiliser Gemini 2.5 Flash avec le raisonnement désactivé.
  • Réponses de fonction multimodales : pour les modèles Gemini 3, vous pouvez inclure des données d'image et de PDF dans les réponses de fonction.

Questions fréquentes

  1. Dans quelle région gemini-3.1-pro-preview est-il disponible sur Google Cloud ? Mondial.

  2. Quelles sont les limites de la fenêtre de contexte ? Les modèles Gemini 3 sont compatibles avec une fenêtre de contexte d'entrée d'un million de jetons et jusqu'à 64 000 jetons de sortie.

  3. gemini-3.1-pro-preview est-il compatible avec la sortie d'image ? Non.

  4. gemini-3.1-pro-preview est-il compatible avec l'API Gemini Live ? Non.

Étape suivante