Gemini 3 est notre famille de modèles la plus intelligente à ce jour. Elle repose sur une technologie de raisonnement à la pointe du secteur. Il est conçu pour donner vie à n'importe quelle idée en maîtrisant les workflows agentifs, le codage autonome et les tâches multimodales complexes.
Ce guide fournit un chemin pratique et consolidé pour commencer à utiliser Gemini 3 sur Vertex AI. 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 Vertex AI à 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 Gen AI pour Python version 1.51.0 ou ultérieure.
pip install --upgrade google-genai
Définir des variables d'environnement pour utiliser le SDK Gen AI avec Vertex AI
Remplacez la valeur GOOGLE_CLOUD_PROJECT par l'ID de votre projet Google Cloud .
Le modèle Gemini 3 Pro Preview gemini-3-pro-preview n'est disponible que sur les points de terminaison globaux :
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_VERTEXAI=True
Créer votre première requête
Par défaut, Gemini 3 Pro utilise la pensée dynamique pour raisonner à partir des requêtes. Pour obtenir des réponses plus rapides et à plus faible latence lorsque le raisonnement complexe n'est pas nécessaire, vous pouvez contraindre le thinking_level du modèle. La réflexion faible est idéale pour les tâches à haut débit où la rapidité est primordiale. Elle correspond à peu près au profil de latence de Gemini 2.5 Flash, tout en offrant une qualité de réponse supérieure.
Pour obtenir 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-pro-preview",
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 réflexion é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 nécessitant un raisonnement poussé :
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-pro-preview",
contents=prompt,
config=types.GenerateContentConfig(
thinking_config=types.ThinkingConfig(
thinking_level=types.ThinkingLevel.HIGH # Dynamic thinking for high reasoning tasks
)
),
)
print(response.text)
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-pro-preview |
Fiche de modèle Model Garden |
| Niveau de réflexion | Raisonnement |
| Résolution du contenu multimédia | Compréhension des images Compréhension des vidéos Compréhension audio Compréhension des documents |
| Signature de pensée | Signatures de pensée |
| Température | Documentation de référence sur l'API |
| Réponses de fonction multimodales | Appel de fonction : réponses de fonction multimodales |
| Appel de fonction de streaming | Appel de fonction : appel de fonction en streaming |
Niveau de réflexion
Le paramètre thinking_level vous permet de spécifier un budget de réflexion 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.
- Faible : minimise la latence et les coûts. Idéal pour suivre des instructions ou discuter.
- Élevée : maximise la profondeur du raisonnement. Par défaut. Pensée dynamique. Le modèle peut mettre beaucoup plus de temps à atteindre un premier jeton, mais le résultat sera plus minutieusement vérifié.
Exemple de SDK Gen AI
from google import genai
from google.genai import types
client = genai.Client()
response = client.models.generate_content(
model="gemini-3-pro-preview",
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é avec 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_effortcorrespond àthinking_level.- La valeur
mediumdereasoning_effortcorrespond à un niveau élevé dethinking_level.
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-pro-preview",
reasoning_effort="medium", # Map to thinking_level high.
messages=[{"role": "user", "content": prompt}],
)
print(response.choices[0].message.content)
Résolution du contenu multimédia
Gemini 3 introduit un contrôle précis sur le traitement multimodal de la vision à 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 de 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 frame vidéo.
Vous pouvez définir la résolution sur low, medium ou high pour chaque partie média ou globalement (à l'aide de generation_config). Si aucune résolution n'est spécifiée, le modèle utilise les valeurs par défaut optimales en fonction du type de média.
| Jetons | |||
|---|---|---|---|
| Image | Vidéo | ||
MEDIA_RESOLUTION_UNSPECIFIED (PAR DÉFAUT) |
1120 | 70 | 560 |
MEDIA_RESOLUTION_LOW |
280 | 70 | 280 |
MEDIA_RESOLUTION_MEDIUM |
560 | 70 | 560 |
MEDIA_RESOLUTION_HIGH |
1120 | 280 | 1120 |
Paramètres recommandés
| Résolution du contenu multimédia | Nombre maximal de jetons | Usage Guidance |
|---|---|---|
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 est limité à 70 jetons par frame. |
Paramètre media_resolution par pièce individuelle
Vous pouvez définir media_resolution pour chaque partie de contenu multimédia :
from google import genai
from google.genai import types
client = genai.Client()
response = client.models.generate_content(
model="gemini-3-pro-preview",
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 globalement
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-pro-preview",
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 pensée
Les signatures de pensée 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 réflexion décide d'appeler un outil externe, il met en pause son processus de raisonnement interne. La signature de pensée agit comme un "état de sauvegarde", permettant au modèle de reprendre sa chaîne de pensée de manière fluide une fois que vous avez fourni le résultat de la fonction.
Pour en savoir plus, consultez Signatures de pensée.
Pourquoi les signatures de pensée sont-elles importantes ?
Sans signatures de pensée, 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 :
- 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ù le résultat d'un outil éclaire le raisonnement pour la prochaine étape.
Où sont renvoyées les signatures de pensée ?
Gemini 3 Pro applique une validation plus stricte et une gestion mise à jour des signatures de pensée, qui ont été introduites dans Gemini 2.5. Pour vous assurer que le modèle conserve le contexte sur plusieurs tours de conversation, vous devez renvoyer les signatures de pensée dans vos requêtes ultérieures.
- Les réponses du modèle avec un appel de fonction renvoient toujours une signature de pensée.
- En cas d'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 pensée.
- Lorsqu'il y a des appels de fonction séquentiels (multiples), chaque appel de fonction aura une signature et les clients sont censés 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 pensée ?
Il existe deux principales façons de gérer les signatures de pensée : automatiquement à l'aide des SDK Gen AI ou de l'API OpenAI, ou manuellement si vous interagissez directement avec l'API.
Traitement automatisé (recommandé)
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 d'historique de chat standard ou que vous ajoutez la réponse complète du modèle, les thought_signatures sont gérés automatiquement. Vous n'avez pas besoin de modifier votre code.
Exemple d'appel de fonction manuel
Lorsque vous utilisez le SDK Gen AI, les signatures de pensée 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-pro-preview",
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="tool",
parts=[
types.Part.from_function_response(
name=function_call.name,
response=function_response_data,
)
],
)
]
response_2 = client.models.generate_content(
model="gemini-3-pro-preview",
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 d'IA générative dans l'appel de fonction automatique, les signatures de pensée 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-pro-preview",
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é avec OpenAI
Lorsque vous utilisez l'API OpenAI Chat Completions, les signatures de pensée 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": "tool",
"tool_call_id": tool_call_1.id,
"content": json.dumps(result_1),
}
)
response2 = client.chat.completions.create(
model="gemini-3-pro-preview",
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.
Manutention manuelle
Si vous interagissez directement avec l'API ou si vous gérez des charges utiles JSON brutes, vous devez gérer correctement le thought_signature inclus dans le tour du modèle.
Vous devez renvoyer cette signature exactement à l'endroit où elle a été reçue lorsque vous renvoyez l'historique des conversations.
Si les signatures appropriées ne sont pas renvoyées, Gemini 3 renverra une erreur 400 "<Function Call> dans le bloc de contenu <index of contents array> manque un 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 textuelles :
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-pro-preview",
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="tool",
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-pro-preview",
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 de 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-pro-preview",
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 la valeur par défaut du paramètre temperature, à savoir 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.
Si vous modifiez la température (en la définissant sur une valeur inférieure à 1.0), vous risquez d'obtenir un comportement inattendu, comme des boucles ou une dégradation des performances, en particulier pour les tâches complexes de mathématiques ou de raisonnement.
Fonctionnalités compatibles
Gemini 3 Pro est également compatible avec les fonctionnalités suivantes :
- Instructions système
- Sortie structurée
- Appel de fonction
- Ancrage avec la recherche Google
- Exécution de code
- Contexte de l'URL
- Raisonnement
- Mise en cache du contexte
- Compter les jetons
- Complétions de conversation
- Prédiction par lot
- Débit provisionné
- Quota partagé dynamique
Bonnes pratiques concernant les requêtes
Gemini 3 est un modèle de raisonnement, ce qui modifie la façon dont vous devez formuler vos requêtes.
- Instructions précises : soyez concis dans vos requêtes. Gemini 3 répond mieux aux instructions directes et claires. Il peut suranalyser les techniques d'ingénierie des requêtes verbeuses ou trop complexes utilisées pour les anciens modèles.
- Niveau de détail des réponses : par défaut, Gemini 3 est moins bavard et préfère fournir des réponses directes et efficaces. Si votre cas d'utilisation nécessite un persona plus conversationnel ou "bavard", vous devez orienter explicitement le modèle dans la requête (par exemple, "Explique cela comme un assistant amical et bavard").
Considérations sur la migration
Tenez compte des fonctionnalités et des contraintes suivantes lors de la migration :
- Niveau de réflexion : les modèles Gemini 3 Pro et ultérieurs utilisent le paramètre
thinking_levelpour 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 des sorties déterministes), il est recommandé de supprimer ce paramètre et d'utiliser la valeur par défaut de Gemini 3, à savoir1.0, pour éviter d'éventuels problèmes de boucle ou une dégradation des performances pour les tâches complexes. - Signatures de pensée : pour les modèles Gemini 3 Pro et ultérieurs, si une signature de pensée est attendue dans un tour, mais 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 Pro et ultérieurs utilisent une longueur de séquence variable pour la tokenisation des contenus multimédias au lieu de Pan and Scan. Ils proposent également de nouvelles résolutions et de nouveaux coûts en jetons par défaut pour les images, les PDF et les vidéos.
- Comptabilisation des jetons pour les entrées multimodales : le nombre de jetons pour les entrées multimodales (images, vidéos, audio) est une estimation basée sur le
media_resolutionchoisi. Par conséquent, le résultat de l'appel d'APIcount_tokenspeut 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 leusage_metadatade la réponse. - Consommation de jetons : la migration vers les paramètres par défaut de Gemini 3 Pro peut augmenter l'utilisation de jetons pour les images et les PDF, mais diminuer l'utilisation de jetons 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 du contenu multimédia.
- Compréhension des PDF et des documents : la résolution OCR par défaut pour les PDF a changé. Si vous vous êtes appuyé sur un comportement spécifique pour l'analyse de documents denses, testez le nouveau paramètre
media_resolution: "high"pour vous assurer de la précision continue. Pour les modèles Gemini 3 Pro et ultérieurs, le nombre de jetons PDF dansusage_metadataest indiqué sous la modalité IMAGE au lieu de DOCUMENT. - Segmentation d'image : la segmentation d'image n'est pas compatible avec Gemini 3 Pro ni les modèles ultérieurs. 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 la fonctionnalité de réflexion désactivée.
- Réponses de fonctions multimodales : pour les modèles Gemini 3 Pro et ultérieurs, vous pouvez inclure des données d'image et de PDF dans les réponses de fonctions.
Questions fréquentes
Quelle est la limite de connaissances pour Gemini 3 Pro ? La limite de connaissances de Gemini 3 est fixée à janvier 2025.
Dans quelle région
gemini-3-pro-previewest-il disponible sur Google Cloud ? MondeQuelles sont les limites de la fenêtre de contexte ? Gemini 3 Pro accepte une fenêtre de contexte d'entrée d'un million de jetons et jusqu'à 64 000 jetons de sortie.
gemini-3-pro-previewprend-il en charge la sortie d'images ? Non.gemini-3-pro-previewest-il compatible avec l'API Gemini Live ? Non.
Étapes suivantes
- En savoir plus sur Gemini 3 Pro
- Suivez le tutoriel sur les notebooks Présentation de Gemini 3 Pro.
- En savoir plus sur l'appel de fonction
- En savoir plus sur la réflexion