Guide du développeur pour Gemini 4 Argon

Gemini 4 Argon est le modèle de pointe de Google. Il excelle dans les tâches complexes et concrètes dans différents domaines, y compris le codage, la finance, le droit, la cybersécurité et les sciences. Il s'agit du premier modèle de la gamme Gemini 4.

Ce document présente les nouveautés de 4 Argon, les conventions d'API qu'il applique, comment migrer vers ce modèle et un guide de démarrage rapide. Pour obtenir une présentation de la gamme Gemini 4, consultez Premiers pas avec Gemini 4.

Nouveautés de Gemini 4 Argon

  • Fenêtre de contexte : la fenêtre de contexte de 1 048 576 jetons est partagée entre les jetons d'entrée, de réflexion et de sortie.
  • Longues décodes jusqu'à 1 048 576 jetons : étend la génération au-delà de la limite de sortie d'une seule requête (65 536 jetons pour les requêtes de streaming ou 32 768 jetons pour les requêtes HTTP directes non diffusées en streaming) jusqu'à 1 048 576 jetons sur GenerateContent. Le SDK Google Gen AI gère automatiquement continuation_token dans les requêtes, mais vous pouvez également gérer continuation_token dans votre propre boucle de continuation.
  • Niveaux de réflexion : LOW, MEDIUM (par défaut sur gemini-4-argon) et HIGH (par défaut sur gemini-4-argon-cyber-permissive).
  • Mise en cache implicite avec mise en cache durable : la mise en cache implicite s'applique automatiquement aux préfixes de prompt partagés de 6 144 jetons ou plus, avec la mise en cache durable activée par défaut. La mise en cache explicite du contexte n'est pas prise en charge.
  • Compréhension agentique des vidéos : disponibilité générale et désactivée par défaut.

Guide de démarrage rapide

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

Dans les blocs de code suivants, remplacez PROJECT_ID par l'ID de votre projet.

Installation

Passez à la dernière version du SDK Google Gen AI (google-genai >= 2.30.1 pour Python, @google/genai >= 2.29.1 pour JavaScript, >= 1.74.0 pour Go, >= 1.77.0 pour Java, >= 1.26.0 pour .NET ou >= 1.6.0 pour Kotlin) :

pip install --upgrade "google-genai>=2.30.1"

Requête de base

Python (GenerateContent)

from google import genai

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

response = client.models.generate_content(
  model="gemini-4-argon",
  contents="How does AI work?",
)
print(response.text)

Python (API Interactions)

from google import genai

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

turn1 = client.interactions.create(
    model="gemini-4-argon",
    input="Design a lock-free ring buffer in Rust for multi-producer, single-consumer telemetry ingestion.",
    store=True,
)
print(turn1.output_text)

turn2 = client.interactions.create(
    model="gemini-4-argon",
    input="Add a bounded backpressure policy and unit tests for concurrent writers.",
    previous_interaction_id=turn1.id,
)
print(turn2.output_text)

REST

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-4-argon:generateContent \
-d '{
  "contents": {
    "role": "USER",
    "parts": { "text": "Why is the sky blue?" }
  }
}'

Sortie structurée

from pydantic import BaseModel, Field
from google import genai
from google.genai import types

class ArchitectureReview(BaseModel):
    component: str = Field(description="Service or module name")
    bottlenecks: list[str] = Field(description="Throughput or latency bottlenecks")
    recommended_changes: list[str] = Field(description="Concrete refactoring steps")

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

response = client.models.generate_content(
    model="gemini-4-argon",
    contents="Review a synchronous order-processing pipeline backed by a single primary database at 15,000 writes/sec.",
    config=types.GenerateContentConfig(
        response_mime_type="application/json",
        response_schema=ArchitectureReview,
        thinking_config=types.ThinkingConfig(thinking_level="HIGH"),
    ),
)
print(response.text)

Longues décodes

Par défaut, une seule requête API génère jusqu'à 65 536 jetons de réflexion et de sortie (ou 32 768 jetons pour les requêtes HTTP directes non diffusées en streaming). Pour générer des achèvements jusqu'à 1 048 576 jetons sur GenerateContent (v1beta1), définissez max_output_tokens sur une valeur supérieure à 65 536 (jusqu'à 1 048 576). Le SDK Google Gen AI suit automatiquement continuation_token dans les requêtes lorsque finish_reason est CONTINUATION (définissez automatic_continuation=False dans GenerateContentConfig pour désactiver la continuation automatique), ou vous pouvez transmettre continuation_token dans une boucle personnalisée.

Python (SDK – Recommandé)

from google import genai
from google.genai import types

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

# Automatic continuation is enabled by default in google-genai >= 2.30.1.
# Chunks across all continuation requests are yielded as a single stream.
for chunk in client.models.generate_content_stream(
    model="gemini-4-argon",
    contents="Write a complete formal proof of the prime number theorem.",
    config=types.GenerateContentConfig(
        max_output_tokens=256000,
        thinking_config=types.ThinkingConfig(thinking_level="HIGH"),
    ),
):
    print(chunk.text, end="")

# Set automatic_continuation=False to disable automatic continuation
# and stop at a single request.
single_request_response = client.models.generate_content(
    model="gemini-4-argon",
    contents="Write a complete formal proof of the prime number theorem.",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(thinking_level="HIGH"),
        automatic_continuation=False,
    ),
)
print(single_request_response.text)

REST (boucle de continuation personnalisée)

# Request 1: Initial request with maxOutputTokens > 32,768
curl -s -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "Content-Type: application/json" \
  "https://aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-4-argon:generateContent" \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [{"text": "Write a complete formal proof of the prime number theorem."}]
    }],
    "generationConfig": {
      "maxOutputTokens": 131072,
      "thinkingConfig": {"thinkingLevel": "HIGH"}
    }
  }'

# Request 2: Resend the original request with top-level continuationToken
# from Request 1 (candidates[0].continuationToken)
curl -s -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "Content-Type: application/json" \
  "https://aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-4-argon:generateContent" \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [{"text": "Write a complete formal proof of the prime number theorem."}]
    }],
    "continuationToken": "CONTINUATION_TOKEN_FROM_REQUEST_1",
    "generationConfig": {
      "maxOutputTokens": 131072,
      "thinkingConfig": {"thinkingLevel": "HIGH"}
    }
  }'

Règles d'API et conventions de comportement obligatoires

Gemini 4 Argon applique les conventions suivantes :

  • Fenêtre de contexte et limites de sortie d'une seule requête:
    • La fenêtre de contexte de 1 048 576 jetons est partagée entre les jetons d'entrée, de réflexion et de sortie. Définir max_output_tokens sur une valeur supérieure à 1,048,576 renvoie une erreur HTTP 400.
    • Pour éviter les achèvements longs involontaires, la limite de sortie par défaut d'une seule requête (réflexion + réponse du modèle) est de 65 536 jetons (ou 32 768 jetons pour les requêtes HTTP directes non diffusées en streaming).

  • Longues décodes:

    • Fonctionnement du décodage long : le décodage long divise une génération jusqu'à 1 048 576 jetons sur plusieurs GenerateContent inférences. Lorsqu'une requête atteint sa limite de sortie par requête avant de se terminer, l'API renvoie finish_reason=CONTINUATION et un continuation_token chiffré contenant un hachage du prompt d'origine et de l'état de la génération jusqu'à ce point. Incluez continuation_token dans les requêtes suivantes avec le prompt d'origine jusqu'à ce que continuation_token ne soit plus émis et que finish_reason=STOP. (Dans Agent Studio, définir la limite de jetons de sortie sur une valeur supérieure à 65 536 et jusqu'à 1 048 576 gère automatiquement les jetons de continuation.)
    • Quand utiliser le décodage long : la plupart des requêtes se terminent dans la limite par requête (65 536 jetons ou 32 768 jetons pour les appels REST non diffusés en streaming). Le décodage long donne plus de marge au modèle pour raisonner, mais il n'allonge pas les réponses (utilisez thinking_level pour contrôler la profondeur du raisonnement).
    Charge de travail Utiliser le décodage long ? Pourquoi
    Mathématiques complexes, sciences, recherche et preuves formelles Oui Le modèle peut utiliser plus de 65 536 jetons pour explorer et vérifier son raisonnement.
    Les tâches de codage et agentiques les plus difficiles Oui Certaines tâches nécessitent plus de 65 536 jetons de réflexion et de code dans une seule réponse. La plupart des tâches de codage et agentiques se terminent avec moins de 65 536 jetons.
    Outils d'évaluation qui s'arrêtent à la limite de sortie Oui Le décodage long empêche les réponses tronquées lorsque le modèle utilise une requête complète de 65 536 ou 32 768 jetons pour la réflexion.
    Chat, questions-réponses, synthèse, classification et extraction Non Ces tâches se terminent avec moins de 32 768 jetons.
    Requêtes de longueur fixe, telles que "écrire un livre de 700 000 mots" Non Le modèle ne respecte pas les objectifs de longueur.
    Agents qui appellent des outils en plusieurs tours courts Non Chaque tour est court. Les sorties volumineuses à chaque tour remplissent rapidement la fenêtre d'entrée et de sortie partagée de 1 048 576 jetons.
    Prompts proches de la limite d'entrée de 1 048 576 jetons Non La sortie ne peut utiliser que 1 048 576 jetons moins votre entrée.
    Requêtes sensibles à la latence Non Le décodage long peut s'exécuter pendant plusieurs minutes.
    • Choisir une option de continuation : toutes les options atteignent la même limite de 1 048 576 jetons sur gemini-4-argon et gemini-4-argon-cyber-permissive.
    Dimension Option 1 : SDK Google Gen AI (recommandé) Option 2 : Votre propre boucle de streaming (streamGenerateContent) Option 2 : Votre propre boucle non diffusée en streaming (generateContent)
    Qui démarre chaque segment Le SDK (automatic_continuation=True par défaut). Définissez max_output_tokens sur une valeur supérieure à 65 536 (jusqu'à 1 048 576) pour les sorties de plus de 65 536 jetons. Votre code, à chaque point de contrôle ou après un flux abandonné Votre code, tous les 32 768 jetons
    Jetons par requête Jusqu'à 65 536 par segment 65 536 par flux 32 768 par requête
    Délai par requête 20 minutes 20 minutes 20 minutes
    Stockage et ZDR Aucun stockage sur le serveur (conforme à la ZDR) Aucun stockage sur le serveur (conforme à la ZDR) Aucun stockage sur le serveur (conforme à la ZDR)
    Application idéale La plupart des applications Appelants REST et outils personnalisés qui diffusent en streaming Outils d'évaluation simples
    • Règles et limites d'implémentation:
      • v1beta1 Exigence de l'API (problème connu) : le décodage long (continuation_token) sur GenerateContent (generateContent et streamGenerateContent) n'est compatible qu'avec l'API v1beta1 (et non v1). Le SDK Google Gen AI utilise v1beta1 par défaut, sauf si api_version='v1' est spécifié dans http_options. Pour les appels REST directs, utilisez le chemin du point de terminaison v1beta1. Le décodage long n'est pas compatible avec l'API Interactions.
      • Versions du SDK et compatibilité avec OpenAI : passez à la dernière version du SDK Google Gen AI (google-genai >= 2.30.1 pour Python, @google/genai >= 2.29.1 pour JavaScript, >= 1.74.0 pour Go, >= 1.77.0 pour Java, >= 1.26.0 pour .NET ou >= 1.6.0 pour Kotlin). Les anciennes versions du SDK et la couche de compatibilité OpenAI ne peuvent pas récupérer les achèvements longs à l'aide de jetons de continuation. Pour les implémentations de clients personnalisés, consultez l'implémentation de référence du SDK Google Gen AI.
      • Renvoyez la requête d'origine avec continuation_token : dans une boucle personnalisée, définissez max_output_tokens sur une valeur supérieure à 65 536 (streaming) ou 32 768 (unaire) jusqu'à 1 048 576, et renvoyez les contents, system_instruction et tools d'origine sur chaque requête de continuation avec le dernier continuation_token (champ de premier niveau sur GenerateContentRequest dans REST ou dans GenerateContentConfig dans le SDK Google Gen AI). N'ajoutez pas de sortie de modèle partielle dans contents et n'envoyez pas de prompt de suivi demandant au modèle de continuer.
      • Continuez via des requêtes de réflexion uniquement : bouclez tant que finish_reason est CONTINUATION et que continuation_token est présent, même si une requête a utilisé les 32 768 ou 65 536 jetons pour la réflexion (parts: [{"text": ""}]). Si finish_reason est MAX_TOKENS lorsque continuation_token est présent, la génération a atteint le plafond max_output_tokens demandé. Augmentez max_output_tokens dans la requête. Combinez les parties accumulées en un seul tour model pour l'historique multitour uniquement après STOP.
      • Comptage des jetons, compression et remise de 95% sur le cache implicite:
        • Dans le SDK Google Gen AI pour Python (generate_content et generate_content_stream), le usage_metadata de la réponse finale ou du bloc accumule le nombre total de jetons facturés dans les requêtes de continuation. Étant donné que chaque requête de continuation préremplit à nouveau les achèvements partiels précédents en tant que jetons d'entrée, prompt_token_count augmente de manière cumulative dans les requêtes de continuation. N'utilisez pas prompt_token_count pour déclencher la compression du contexte dans les outils d'agent. Lisez plutôt initial_prompt_token_count (sur GenerateContentResponse ou usage_metadata), et attendez que GenerateContent se termine (aucun continuation_token présent) avant de compresser.
        • Dans les boucles REST personnalisées, usage_metadata est cumulatif dans chaque requête. Additionnez les prompt_token_count, cached_content_token_count, candidates_token_count et thoughts_token_count finaux dans les requêtes.
        • Chaque requête de continuation préremplit à nouveau le prompt ainsi que les jetons décodés précédents et reçoit automatiquement la remise de 95% sur la mise en cache implicite du contexte (6 144 jetons minimum) lorsque les requêtes s'exécutent consécutivement dans le TTL du cache de 15 à 20 minutes.
        • streamGenerateContent et generateContent renvoient continuation_token et usage_metadata à la fin de chaque requête (65 536 en streaming / 32 768 en unaire), et la facturation a lieu à la fin de la requête.

  • Paramètres d'échantillonnage ignorés (temperature, top_k, top_p) : le backend ignore les valeurs personnalisées. Contrôlez la profondeur du raisonnement avec thinking_level et le format de sortie avec response_schema.

  • Paramètres non compatibles (frequency_penalty, presence_penalty, candidate_count) : ils renvoient une erreur HTTP 400. Supprimez-les de vos requêtes.

  • Cache de contexte : le cache de contexte explicite n'est pas pris en charge. La mise en cache implicite (avec la mise en cache durable activée par défaut) s'applique automatiquement aux préfixes de prompt partagés de 6 144 jetons ou plus. Placez donc le contenu statique au début de votre prompt.

  • Vidéo agentique : les vidéos importées sont définies par défaut sur media_processing="static". Définissez media_processing="agentic" pour activer le traitement vidéo agentique.

  • Comptage des jetons et facturation : chaque jeton traité par le modèle est comptabilisé et facturé, y compris les jetons de réflexion, les instructions internes du système d'outils et les déclarations de fonction lors de l'utilisation de l'ancrage. L'ancrage avec la recherche Google reste également facturé par requête.

  • Appel de fonction :

    • Symétrie des tours : chaque FunctionResponse doit correspondre à l'id, au name, et à l'ordre du FunctionCall précédent.
    • Exécution séquentielle : préférez les tours d'exécution séquentielle des outils dans les boucles d'outils en plusieurs étapes.
    • Mise en forme avant l'outil : séparez les instructions intégrées avec \n\n et évitez le texte non structuré avant les appels d'outils.

  • Validation de la séquence de chat :

    • Les charges utiles de l'historique ne peuvent pas se terminer par un tour de rôle model.
    • Les tours de modèle préremplis ne sont pas compatibles.

Migrer vers 4 Argon depuis 3.1 Pro

Le comportement suivant est différent de gemini-3.1-pro-preview :

  • La fenêtre de contexte est une fenêtre de 1 048 576 jetons partagée par l'entrée, la réflexion et la sortie, au lieu de limites d'entrée et de sortie distinctes. La sortie d'une seule requête est limitée à 65 536 jetons (ou 32 768 jetons pour les requêtes HTTP directes non diffusées en streaming) et peut être étendue jusqu'à 1 048 576 jetons à l'aide de longues décodes sur GenerateContent (gérées automatiquement dans le SDK Google Gen AI ou à l'aide de continuation_token dans des boucles personnalisées).
  • thinking_budget renvoie une erreur HTTP 400 au lieu d'être mappé à un niveau de réflexion. MINIMAL renvoie également une erreur.
  • La mise en cache explicite du contexte n'est pas prise en charge.
  • Chaque jeton traité par le modèle est facturé, y compris les instructions internes du système d'outils et les déclarations de fonction lors de l'utilisation de l'ancrage.

Pour une comparaison côte à côte, consultez Migrer depuis Gemini 3.1 Pro.

Pour migrer depuis gemini-3.1-pro-preview, procédez comme suit :

  1. Mettez à jour l'ID du modèle sur gemini-4-argon (ou gemini-4-argon-cyber-permissive pour les charges de travail de cybersécurité approuvées par Fairwind).
  2. Passez à la dernière version du SDK Google Gen AI et tenez compte de la fenêtre de contexte partagée : passez à google-genai >= 2.30.1 (Python) ou à la dernière version équivalente du SDK Google Gen AI. Les jetons d'entrée, de réflexion et de sortie partagent la fenêtre de contexte de 1 048 576 jetons. Pour les sorties dépassant 65 536 jetons (jusqu'à 1 048 576 jetons) sur GenerateContent, définissez max_output_tokens sur une valeur supérieure à 65 536 afin que le SDK Google Gen AI continue automatiquement dans les requêtes (ou gérez continuation_token dans votre propre boucle REST).
  3. Remplacez le paramètre de budget de raisonnement : remplacez thinking_budget et MINIMAL par thinking_level défini sur l'une des valeurs suivantes :
    • HIGH : valeur par défaut sur gemini-4-argon-cyber-permissive. Ingénierie logicielle multifichier, preuves formelles, conception d'architecture et découverte de failles.
    • MEDIUM : valeur par défaut sur gemini-4-argon. Codage général, utilisation d'outils, questions-réponses sur les documents et compréhension des vidéos.
    • LOW : classification, synthèse et extraction de métadonnées.
  4. Supprimez la mise en cache explicite et chargez le contenu statique du prompt (6 144 jetons ou plus) pour la mise en cache implicite automatique.
  5. Supprimez les paramètres qui n'ont aucun effet ou qui ne sont pas compatibles :
    • Supprimez temperature, top_p et top_k, qui sont ignorés.
    • Supprimez candidate_count, frequency_penalty et presence_penalty.
    • Supprimez tous les tours de modèle préremplis des historiques de conversation.

Check-list récapitulative pour les développeurs

Problèmes connus

  • Les longues décodes sur GenerateContent nécessitent v1beta1 : le décodage long (continuation_token) sur l'API GenerateContent (generateContent et streamGenerateContent) n'est compatible qu'avec l'API v1beta1 (et non v1). Le SDK Google Gen AI utilise v1beta1 par défaut, sauf si api_version='v1' est défini dans http_options. Pour les appels REST directs, utilisez le chemin du point de terminaison v1beta1 .

Autres ressources