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

  • Limite unifiée de jetons d'entrée et de sortie : 4 Argon dispose d'une limite unifiée de 1 048 576 jetons, qui inclut les jetons d'entrée et de sortie (où la sortie inclut la réflexion, les appels de fonction et la réponse finale ).
  • Longues décodifications 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 ou 32 768 jetons pour les requêtes HTTP directes sans diffusion en flux continu) jusqu'à 1 048 576 jetons (moins vos jetons d'entrée) sur GenerateContent. Le SDK Google Gen AI gère automatiquement continuation_token dans les requêtes, ou vous pouvez 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 requête 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.

Essayer dans Agent Studio

Pour tester les requêtes et configurer gemini-4-argon dans l' interface utilisateur d'Agent Studio :

  1. Ouvrez Agent Studio dans votre Cloud de Confiance by S3NS projet et sélectionnez gemini-4-argon sous le groupe Gemini.
  2. Dans Paramètres du modèle, configurez les éléments suivants :
    • Niveau de réflexion : choisissez Low, Medium (par défaut) ou High.
    • Région : sélectionnez Global, us, ou eu.
    • Limite de jetons de sortie : définissez une valeur comprise entre 32,768 et 1,048,576 (1,048,576 par défaut). Agent Studio gère automatiquement les jetons de continuation pour les réponses dépassant la limite d'une seule requête.

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
from google.genai import types

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

response = client.models.generate_content(
    model="gemini-4-argon",
    contents="Design a lock-free ring buffer in Rust for multi-producer, single-consumer telemetry ingestion.",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(
            thinking_level="MEDIUM",  # Default: "MEDIUM" (Valid: "LOW", "MEDIUM", "HIGH")
        ),
    ),
)
print(response.text)

Python (API Interactions)

from google import genai

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

# Turn 1: Initial request (stored server-side by default)
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)

# Turn 2: Continue the conversation using previous_interaction_id
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 application-default 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": "Provide an architectural review of this Go interface."
        }
      ]
    }
  ],
  "generationConfig": {
    "thinkingConfig": {
      "thinkingLevel": "MEDIUM"
    }
  }
}'

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écodifications

Par défaut, une seule requête API génère jusqu'à 65 536 jetons de sortie (ou 32 768 jetons pour les requêtes HTTP directes sans diffusion en flux continu), où la sortie inclut la réflexion, les appels de fonction et la réponse finale. 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 pour les requêtes de diffusion en flux continu ou supérieure à 32 768 pour les requêtes sans diffusion en flux continu (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.
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(
        thinking_config=types.ThinkingConfig(thinking_level="HIGH"),
        automatic_continuation=False,
    ),
):
    print(chunk.text, end="")

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 :

  • Niveaux de réflexion : 4 Argon est compatible avec trois thinking_level valeurs (thinking_budget et MINIMAL renvoient une erreur de validation HTTP 400) :

    Niveau de réflexion Charges de travail recommandées
    HIGH (par défaut sur gemini-4-argon-cyber-permissive) Ingénierie logicielle multi-fichiers, preuves formelles, conception d'architecture et découverte de failles.
    MEDIUM (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.

  • Limite unifiée de jetons d'entrée et de sortie et limites de sortie d'une seule requête :

    • 1,048,576 est la limite globale de jetons du modèle et inclut les jetons d'entrée et de sortie (où la sortie inclut la réflexion, les appels de fonction et la réponse finale). max_output_tokens contrôle la limite de jetons de sortie pour la génération (jusqu'à 1,048,576 moins vos jetons d'entrée). 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 sans diffusion en flux continu).

  • Longues décodifications:

    • Fonctionnement du décodage long : le décodage long divise une génération jusqu'à 1 048 576 jetons sur plusieurs GenerateContent inférences. Par exemple, si une tâche nécessite 256 000 jetons de sortie (y compris les réflexions, les appels de fonction et la réponse finale), la première requête de diffusion en flux continu génère jusqu'à 65 536 jetons de sortie et émet finish_reason=CONTINUATION avec un continuation_token chiffré contenant un hachage de la requête d'origine et l'état de la génération jusqu'à ce point. L'inclusion de continuation_token dans les requêtes suivantes avec la requête d'origine poursuit la génération là où elle s'est arrêtée 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 sans diffusion en flux continu). N'utilisez le décodage long que lorsqu'une réponse nécessite plus de sortie. Le décodage long donne plus de marge au modèle pour raisonner. 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.
    Exploitations 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 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 suit 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 limite unifiée de 1 048 576 jetons d'entrée et de sortie.
    Requêtes 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 : choisissez l'une des deux options. La plupart des développeurs utilisent l'option 1. 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 diffusion en flux continu (streamGenerateContent) Option 2 : Votre propre boucle sans diffusion en flux continu (generateContent)
    Qui démarre chaque segment ? SDK Google Gen AI : Python (google-genai) 2.30.1, JavaScript (@google/genai) 2.29.1, Go 1.74.0, Java 1.77.0, .NET 1.26.0 et Kotlin 1.6.0. Vous définissez max_output_tokens. 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, avec un point de contrôle tous les 5 000 jetons après 32 768 32 768 par requête
    Limite de temps par requête 20 minutes 20 minutes 20 minutes
    Stockage 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 exploitations personnalisées qui diffusent en flux continu Exploitations 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 les implémentations de référence du SDK Google Gen AI en Python et JavaScript/TypeScript.
      • Renvoyer 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 (diffusion en flux continu) ou 32 768 (unaire) et jusqu'à 1 048 576, puis renvoyez les contents, system_instruction et tools d'origine dans chaque requête de continuation, ainsi que 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 requête de suivi demandant au modèle de continuer.
      • Continuer 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 la limite max_output_tokens demandée. Augmentez max_output_tokens dans la requête. Ne combinez les parties accumulées en un seul tour model pour l'historique multitour qu'après STOP.
      • Comptage des jetons, compaction et remise de 95% sur le cache implicite:
        • Dans le SDK Google Gen AI pour Python (generate_content et generate_content_stream), la réponse finale ou les usage_metadata du bloc accumulent le nombre total de jetons facturés dans les requêtes de continuation. Étant donné que chaque requête de continuation préremplit 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 compaction du contexte dans les exploitations 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 compacter.
        • 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 la requête, 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 (minimum de 6 144 jetons) lorsque les requêtes s'exécutent consécutivement dans la valeur TTL du cache de 15 à 20 minutes.
        • streamGenerateContent et generateContent renvoient usage_metadata à la fin de chaque requête (65 536 en flux continu/32 768 unaires), 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 requête partagés de 6 144 jetons ou plus. Placez donc le contenu statique au début de votre requête.

  • 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 et facturation des jetons : 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. Pour enregistrer l'état intermédiaire avant un appel d'outil, utilisez une déclaration de fonction dédiée :

      {
  "name": "update",
  "description": "Update working notes before tool execution",
  "parameters": {
    "type": "OBJECT",
    "properties": {
      "previous_step": {"type": "STRING"},
      "plan": {"type": "STRING"},
      "next_step": {"type": "STRING"}
    },
    "required": ["previous_step", "plan", "next_step"]
  }
}

  • 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 pris en charge.

Migrer vers 4 Argon depuis 3.1 Pro

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

  • 4 Argon dispose d'une limite unifiée de 1 048 576 jetons pour l'entrée et la sortie (où la sortie inclut la réflexion, les appels de fonction et la réponse finale), 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 sans diffusion en flux continu) et peut être étendue jusqu'à 1 048 576 jetons à l'aide de longues décodifications 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.

 client = genai.Client(
     enterprise=True,
     project="PROJECT_ID",
     location="global", # Supports "global", "us", and "eu"
 )

 response = client.models.generate_content(
-    model="gemini-3.1-pro-preview",
+    model="gemini-4-argon",
     contents=prompt,
     config=types.GenerateContentConfig(
-        temperature=0.0,
-        cached_content="projects/.../cachedContents/...", # Explicit caching unsupported
         thinking_config=types.ThinkingConfig(
-            thinking_budget=16384, # Returns HTTP 400 instead of mapping silently
-            thinking_level="MINIMAL", # MINIMAL unsupported on Gemini 4 Argon
+            thinking_level="MEDIUM", # Valid: "LOW", "MEDIUM" (default), "HIGH"
         ),
     ),
 )

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 limite unifiée de jetons d'entrée et de sortie : passez à google-genai >= 2.30.1 (Python), @google/genai >= 2.29.1 (JavaScript) ou à la dernière version équivalente du SDK Google Gen AI. Les jetons d'entrée et de sortie (y compris la réflexion et les appels de fonction) partagent la limite unifiée 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 LOW, MEDIUM (par défaut sur gemini-4-argon) ou HIGH (par défaut sur gemini-4-argon-cyber-permissive).
  4. Supprimez la mise en cache explicite et chargez le contenu statique de la requête (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écapitulatif pour les développeurs

Problèmes connus

  • Les longues décodifications 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