Construire avec CometAPIBesoin d'une seule API pour plusieurs modèles ?Testez le workflow dans Playground, puis créez une clé API lorsque le modèle et le coût correspondent à votre cas d'usage.
Comment utiliser l'API Gemini 4 Carbon ? Guide complet pour les développeurs
Configurer l’API Gemini 4 Carbon avec CometAPI. Suivre les exemples Python et REST, valider les réponses, analyser des PDF et des images, et gérer le streaming.
Deon GoodwinÉquipe de recherche sur les modèles IA et API
Utilisez l’API Gemini 4 Carbon dans CometAPI pour ajouter du raisonnement et de l’analyse de documents à votre application via l’interface native GenerateContent de Gemini. Commencez par une requête texte courte, vérifiez que la génération s’est terminée, puis enregistrez la réponse avant d’ajouter un PDF, des images, le streaming ou du JSON structuré. Ce guide fournit la configuration et le code de gestion de réponse pour chaque étape.
Key Takeaways
ID du modèle : gemini-4-carbon. Pas de palier gratuit — nécessite l’API Gemini payante / Cloud Billing.
Fenêtre unifiée de 1M de jetons (entrée + raisonnement + sortie). Sortie max par défaut ~65K ; la longue décodification s’étend jusqu’à près de 1M.
Niveaux de raisonnement : (rapide/économique), (par défaut, équilibré), (raisonnement approfondi).
Revu pour la clarté, l'attribution des sources et la terminologie API actuelle.
low
medium
high
Prix de lancement jusqu’au 30 novembre 2026 : 2 $ / 10 $ par 1M de jetons (entrée mise en cache 0,10 $). Double le 1er décembre.
Excellent pour le codage agentique long terme, le raisonnement scientifique, le travail de connaissance et les tâches de cybersécurité.
SDK officiels (google-genai) + points de terminaison compatibles OpenAI disponibles.
CometAPI offre l’accès en production le plus simple avec une clé unique, des tarifs compétitifs et un basculement fluide entre Gemini 4 Carbon, Claude et 500+ autres modèles.
Visuel de lancement de Gemini 4 Carbon. Image : Google. Œuvre originale.
What Is Gemini 4 Carbon API?
Gemini 4 Carbon est le modèle de raisonnement de pointe de Google pour des workflows agentiques à long horizon, l’ingénierie logicielle complexe, la cybersécurité et la recherche scientifique. Construit sur Gemini 4 Argon, il utilise un raisonnement plus profond et des boucles de vérification étendues pour traiter des tâches multi-étapes nécessitant une résolution de problèmes soutenue plutôt qu’une réponse unique. Comparé à Argon, Carbon est conçu pour des charges plus exigeantes où la précision et l’achèvement des tâches priment sur la minimisation des jetons. Google a annoncé l’accès développeur payant le 10 novembre 2026. Sa prise en charge d’entrées multimodales vous permet de combiner texte, supports visuels et autres médias ; la sortie générée est du texte. CometAPI propose un accès API à tarif réduit.
Pour une intégration API, commencez par une tâche dont vous pouvez vérifier le résultat : résumer un document, extraire des champs d’une note d’incident ou passer en revue une capture d’écran. Un workflow agent plus large peut s’appuyer sur cette requête fonctionnelle une fois que vous avez vérifié les outils pris en charge et le comportement de réponse de l’itinéraire.
Other Ways to Use It
Google AI Studio Playground : sélectionnez le modèle et testez les invites de manière interactive (accès payant requis pour Carbon).
Gemini app / AI Mode / Antigravity : disponible si vous avez Google AI Ultra (sélectionnez le modèle lorsque proposé).
Entreprise / Cloud : utilisez via Gemini Enterprise Agent Platform ou des points de terminaison de type Vertex avec le même ID de modèle (configuration projet + région).
Les scientifiques/chercheurs peuvent demander un accès gratuit limité dans certains cas.
What Are the Gemini 4 Carbon API Specifications ?
Les spécifications officielles du modèle distinguent le budget de contexte partagé de la limite de sortie de chaque segment de premier plan. Ce sont des limites au niveau du modèle ; votre passerelle peut également appliquer des limites de taille de requête et des restrictions de fonctionnalités.
Limitations and API Considerations
Avant d’étendre votre intégration, vérifiez comment Carbon gère le contexte, les paramètres de génération, la mise en cache et l’accès. Le tableau associe chaque contrainte à une action pratique afin d’éviter des requêtes invalides, des résultats incomplets et des coûts inattendus.
Zone
Limitation ou exigence
Implication pour les développeurs
Budget de jetons unifié
L’entrée et la sortie partagent 1,048,576 jetons, y compris le raisonnement et les appels de fonctions.
Réservez de l’espace de sortie avant d’ajouter l’historique de conversation ou des fichiers.
Décodage long
Un segment de premier plan autorise jusqu’à 65,536 jetons de sortie en streaming, ou 32,768 sans streaming ;
une génération plus longue nécessite une continuation.
Niveaux de raisonnement
Low, Medium, High ; Medium est la valeur par défaut
Pour GenerateContent, envoyez LOW, MEDIUM ou HIGH ; MINIMAL est rejeté.
Thinking budget
Le paramètre legacy thinking_budget est rejeté
Supprimez thinking_budget des générateurs de requêtes et utilisez thinking_config.thinking_level en Python, ou thinkingConfig.thinkingLevel en REST JSON.
Échantillonnage
Les valeurs personnalisées de temperature, top_p et top_k sont ignorées
Utilisez thinking_level pour sélectionner la profondeur de raisonnement et response_schema pour la sortie structurée.
Mise en cache du contexte
La mise en cache implicite est prise en charge ; la création explicite de cache ne l’est pas.
Placez le contexte réutilisable en premier et la question changeante en dernier. Supprimez les appels de création de cache explicite et les références cached_content.
Coût API
Les jetons de raisonnement sont facturés comme de la sortie
Comptez le raisonnement ainsi que la sortie visible.
Accès cybersécurité
L’accès cyber spécialisé est restreint
Vérifiez l’éligibilité à l’accès spécialisé Fairwind. L’accès Carbon standard n’accorde pas à lui seul l’accès à la variante cyber-permissive.
Le guide développeur Carbon de Google documente les règles de l’API ; sa fiche modèle décrit la fiabilité et les limitations d’accès spécialisé. Confirmez les fonctionnalités correspondantes sur votre route CometAPI avant de les activer en production.
Thinking Levels: How to Choose the Right Setting
Commencez par MEDIUM, puis ajustez le niveau à la tâche et à la qualité requise.
LOW : utilisez-le pour l’extraction, la classification et les résumés simples lorsque le temps de réponse et le coût sont prioritaires. Testez-le pour des tâches comme l’étiquetage de tickets de support, et vérifiez qu’il respecte toujours votre cible de précision.
MEDIUM : point de départ par défaut pour le codage quotidien, l’analyse de documents et le raisonnement de routine. C’est une base pratique pour évaluer si un autre niveau améliore votre application.
HIGH : utilisez-le pour le débogage complexe, la recherche multi-étapes et le raisonnement scientifique qui bénéficient d’une investigation plus approfondie. Prévoyez des jetons de raisonnement supplémentaires, et conservez-le uniquement lorsque le gain de qualité justifie le coût et le temps additionnels.
Des niveaux de raisonnement plus élevés ne garantissent pas automatiquement de meilleurs résultats pour chaque tâche. Évaluez vos propres charges et comparez la qualité d’exécution, la latence et l’utilisation totale de jetons avant de modifier les valeurs par défaut en production.
How Does Gemini 4 Carbon Perform on AI Benchmarks?
Selected Benchmark Results
Benchmark
Gemini 4 Carbon
Gemini 4 Argon
GPT-6 Astra
Claude Opus 5.5
Artificial Analysis Intelligence Index v5.0
59
50
57
58
SWE-sweep
9.60%
4.30%
9.50%
3.60%
FrontierSWE 2
61.20%
55.00%
65.50%
62.30%
Terminal-Bench 4.0
65.20%
57.10%
59.10%
59.60%
Agents' Last Exam v1.1
77.40%
69.00%
73.10%
71.60%
OSWorld-2.1
81.50%
74.70%
80.90%
87.20%
AutomationBench
53.90%
51.30%
41.40%
42.50%
Chartography
72.50%
71.60%
71.00%
66.30%
GraphWalks (256K–1M)
96.20%
84.20%
71.80%
66.80%
Les pages Artificial Analysis Carbon (High) et Argon (High) affichent l’instantané suivant, consulté le 12 novembre 2026. Il s’agit de résultats de benchmarks, et non de mesures de latence CometAPI.
Metric
Carbon (High)
Argon (High)
Intelligence Index
60
50
Output speed
80 tokens/s
65 tokens/s
Time to first answer token
67.83 s
37.64 s
Time per Intelligence Index task
25.5 min
30.0 min
Output tokens across the evaluation
205M
113M
Cost per Intelligence Index task
$7.76
$9.95
Les totaux de jetons de sortie couvrent l’évaluation, pas une seule requête. Le coût par tâche utilise les hypothèses de tarification d’Artificial Analysis plutôt que la remise actuelle de CometAPI. Carbon attend plus longtemps avant son premier jeton de réponse, mais termine la tâche de benchmark plus vite et à un coût déclaré inférieur ; le volume de jetons seul ne détermine pas la valeur.
Utilisez Carbon lorsque sa vérification approfondie améliore les revues de code difficiles, la recherche ou tout autre travail où l’erreur coûte cher. Testez Argon pour le codage et les tâches de connaissance de routine, mais confirmez les économies sur votre propre charge. Exécutez des invites identiques et comparez la dépense totale divisée par les résultats acceptés, ainsi que le temps d’achèvement et le taux d’échec.
How Do You start with the Gemini 4 Carbon API in CometAPI?
Vous aurez besoin d’un compte CometAPI avec accès au modèle et un crédit suffisant, d’un environnement Python et d’une familiarité de base avec l’exécution de scripts. Utilisez un répertoire de projet pour les fichiers ci-dessous afin que chaque exemple puisse importer la même configuration client.
Why Use Gemini 4 Carbon API Through CometAPI?
CometAPI est utile lorsque vous souhaitez évaluer Carbon aux côtés d’autres modèles tout en gérant l’accès et la facturation via un seul fournisseur. Sa route Carbon propose à la fois l’interface native GenerateContent de Gemini et une interface Chat compatible OpenAI, afin que vous puissiez choisir le format de requête adapté à votre application.
Pour ce guide, la route native vous permet de réutiliser le SDK Google Gen AI avec une clé et une base URL CometAPI. Les prix actuels du groupe par défaut sont 20 % inférieurs aux tarifs de lancement de Google. Conservez l’ID du modèle dans la configuration afin de comparer Carbon et Argon sans réécrire votre application, et vérifiez la prise en charge spécifique de la route avant d’ajouter des outils, des téléchargements de fichiers ou des continuations longues.
Step 1: Create Your Account and Set Your API Key
Connectez-vous à CometAPI, créez ou ouvrez votre clé API, et stockez-la comme variable d’environnement. Évitez de mettre des clés directement dans le code source ou de les valider dans un dépôt.
Utilisez la commande appropriée à votre shell. Définissez les variables dans le même terminal que celui utilisé pour exécuter Python ; remplacez l’espace réservé par votre propre clé.
Step 2: Install the SDK and Configure the Endpoint
Installez le SDK dans l’environnement de votre projet. L’utilisation de python -m pip associe l’installateur à l’interpréteur qui exécutera l’exemple.
Installer ou mettre à jour le SDK Google Gen AI.
python -m pip install --upgrade google-genai
CometAPI documente un point de terminaison natif Gemini avec une base URL personnalisée pour le SDK. Utilisez votre clé CometAPI pour ce point de terminaison. Les paramètres ci-dessous s’appliquent aux requêtes GenerateContent.
Paramètre
Valeur
SDK
google-genai
Base URL
https://api.cometapi.com
Version d’API
v1beta
En-tête d’authentification REST
x-goog-api-key
Variable d’env. de la clé
COMETAPI_KEY
Variable d’env. du modèle
COMETAPI_MODEL
ID du modèle
gemini-4-carbon
Step 3: Create a Reusable Client and Validate Responses
Enregistrez cette configuration sous carbon_client.py. Elle définit le client une fois et fournit completed_text pour les réponses texte utilisées dans ce guide. Le helper vérifie le motif de fin du candidat avant de renvoyer le texte de réponse, afin qu’un résultat vide ou tronqué ne soit pas silencieusement traité comme un succès.
Créez carbon_client.py avec le client CometAPI et un validateur de réponse texte.
import os
from google import genai
from google.genai import types
client = genai.Client(
api_key=os.environ["COMETAPI_KEY"],
http_options={
"api_version": "v1beta",
"base_url": "https://api.cometapi.com",
},
)
model = os.getenv("COMETAPI_MODEL", "gemini-4-carbon")
def completed_text(response):
if not response.candidates:
raise RuntimeError("No candidate returned; inspect prompt feedback.")
candidate = response.candidates[0]
reason = getattr(candidate.finish_reason, "value", candidate.finish_reason)
if reason != "STOP":
raise RuntimeError(f"Generation did not finish normally: {reason}")
parts = candidate.content.parts if candidate.content else []
text = "".join(
part.text or "" for part in (parts or []) if not part.thought
)
if not text.strip():
raise RuntimeError("The completed candidate contains no answer text.")
return text
Step 4: Send Your First Request and Check the Result
Créez first_request.py à côté de carbon_client.py et ajoutez le code ci-dessous. Il envoie une invite de liste de contrôle courte en utilisant MEDIUM pour le raisonnement et un budget de sortie de 4 096 jetons, vérifie l’achèvement avec completed_text(response), et enregistre la réponse dans answer.txt en UTF-8. Exécutez python first_request.py depuis votre répertoire de projet, puis ouvrez answer.txt et confirmez que les cinq points de revue sont pertinents et exploitables. Vérifiez les métadonnées d’utilisation imprimées pour la consommation de jetons, y compris le raisonnement ; une fin normale n’établit pas la qualité de la réponse. Si la requête échoue ou renvoie une sortie incomplète, utilisez la section de dépannage pour vérifier les identifiants, les détails d’erreur et le motif de fin avant de réessayer.
from pathlib import Path
from carbon_client import client, model, types, completed_text
response = client.models.generate_content(
model=model,
contents="Give me a five-point checklist for reviewing a Python API client.",
config=types.GenerateContentConfig(
max_output_tokens=4096,
thinking_config=types.ThinkingConfig(thinking_level="MEDIUM"),
),
)
answer = completed_text(response)
Path("answer.txt").write_text(answer, encoding="utf-8")
print(answer)
print("Saved answer.txt")
if response.usage_metadata:
print(response.usage_metadata.model_dump(exclude_none=True))
python first_request.py
## How Can Gemini 4 Carbon API Analyze Files?
Exécutez ces exemples depuis le même répertoire que carbon_client.py. Ils chargent des fichiers locaux en parties de contenu inline, gardant le workflow initial indépendant d’un service d’upload de fichiers séparé.
La compréhension de PDF inclut le contenu visuel : Gemini peut interpréter ensemble le texte, les tableaux, les graphiques et les images. Le [guide de traitement de documents de Google](https://ai.google.dev/gemini-api/docs/document-processing) décrit la prise en charge de PDF jusqu’à 1 000 pages, sous réserve des limites de taille de fichier et de contexte. Le nombre de pages est un plafond, pas une garantie que chaque document tiendra dans une requête de passerelle.
Utilisez l’entrée inline pour des PDF petits et temporaires. Pour des fichiers plus volumineux ou des questions multi-tours répétées, Google recommande l’API Files afin d’éviter de renvoyer le fichier complet. Avant d’utiliser ce workflow via CometAPI, vérifiez son point de terminaison d’upload et la prise en charge des références de fichiers ; l’exemple inline ci-dessous reste un point de départ pratique.
### Summarize a local PDF
Google documente l’[entrée PDF inline](https://ai.google.dev/gemini-api/docs/document-processing) pour GenerateContent. Placez un report.pdf petit et non sensible dans le répertoire du projet, puis enregistrez ce qui suit sous analyze_pdf.py et exécutez python analyze_pdf.py.
Envoyer un PDF local et enregistrer son résumé complété.
from pathlib import Path
from carbon_client import client, model, types, completed_text
response = client.models.generate_content(
model=model,
contents=[
types.Part.from_bytes(
data=Path("report.pdf").read_bytes(),
mime_type="application/pdf",
),
"Summarize this report in five bullets. Do not invent missing figures.",
],
config=types.GenerateContentConfig(max_output_tokens=4096),
)
Comparez le résumé au fichier avant de passer à des documents plus volumineux. Les limites de taille de requête et la prise en charge des références de fichiers dépendent de la passerelle. La prise en charge par Google des formats Office ou des références Cloud Storage n’établit pas en soi la prise en charge de ces entrées via votre route CometAPI.
### Review a local screenshot
Pour l’[entrée image inline](https://ai.google.dev/gemini-api/docs/image-understanding), faites correspondre le type MIME au fichier. Placez une capture d’écran PNG nommée screen.png à côté du script. Enregistrez cet exemple sous analyze_image.py et exécutez python analyze_image.py pour passer en revue le texte et la mise en page visibles.
Analyser une capture d’écran PNG sans s’appuyer sur une URL d’image publique.
from pathlib import Path
from carbon_client import client, model, types, completed_text
response = client.models.generate_content(
model=model,
contents=[
types.Part.from_bytes(
data=Path("screen.png").read_bytes(),
mime_type="image/png",
),
"Review this screenshot for unreadable text and overlapping elements. "
"Describe only visible issues and identify their locations.",
],
config=types.GenerateContentConfig(max_output_tokens=4096),
)
print(completed_text(response))
Comparez chaque problème signalé avec la capture d’écran. Si vous envoyez un JPEG à la place, changez à la fois le nom de fichier et le type MIME pour correspondre ; changer uniquement l’extension ne convertit pas l’image.
## How Do You Stream Gemini 4 Carbon Responses ?
### Display streamed text and check completion
Le streaming renvoie des fragments de réponse sous forme d’événements envoyés par le serveur (SSE), permettant à une application d’afficher une sortie partielle pendant que la génération se poursuit.
Le SDK expose la [génération de texte en streaming](https://ai.google.dev/gemini-api/docs/text-generation) via generate_content_stream. Pour les requêtes HTTP directes, CometAPI utilise streamGenerateContent avec alt=sse.
Enregistrez ce qui suit sous stream_response.py et exécutez python stream_response.py. Il affiche le texte au fur et à mesure de son arrivée, puis vérifie que le flux s’est terminé avec un motif de fin normal. Une exception laisse le texte affiché comme résultat partiel, et non comme réponse acceptée.
Lire le texte en streaming et exiger une fin normale avant de l’accepter.
from carbon_client import client, model, types
finish_reason = None
received_text = False
for chunk in client.models.generate_content_stream(
model=model,
contents="Write a concise checklist for investigating intermittent API timeouts.",
config=types.GenerateContentConfig(max_output_tokens=4096),
):
if not chunk.candidates:
continue
candidate = chunk.candidates[0]
if candidate.finish_reason is not None:
finish_reason = getattr(candidate.finish_reason, "value", candidate.finish_reason)
parts = candidate.content.parts if candidate.content else []
for part in parts or []:
if part.text and not part.thought:
received_text = True
print(part.text, end="", flush=True)
print()
if finish_reason != "STOP" or not received_text:
raise RuntimeError(f"Stream not accepted as complete: {finish_reason}")
### Extract structured JSON
Pour une [sortie contrainte par schéma](https://ai.google.dev/gemini-api/docs/structured-output), demandez application/json et définissez les champs attendus par votre application. Cet exemple extrait deux champs d’une note d’incident courte, puis vérifie leur type avant d’imprimer le résultat.
Enregistrez cet exemple sous structured_output.py et exécutez python structured_output.py. Il réutilise le validateur de réponse avant d’analyser le JSON.
Extraire des champs d’incident, vérifier l’achèvement et valider leur type.
import json
from carbon_client import client, model, types, completed_text
response = client.models.generate_content(
model=model,
contents=(
"Extract the service and impact from this incident note: "
"The checkout API returned errors for ten minutes during a database restart."
),
config=types.GenerateContentConfig(
max_output_tokens=4096,
response_mime_type="application/json",
response_schema={
"type": "OBJECT",
"properties": {
"service": {"type": "STRING"},
"impact": {"type": "STRING"},
},
"required": ["service", "impact"],
},
),
)
data = json.loads(completed_text(response))
if not isinstance(data, dict) or not all(
isinstance(data.get(field), str) for field in ("service", "impact")
):
raise ValueError("The response does not match the expected field types.")
print(json.dumps(data, indent=2))
Vous devriez recevoir un objet contenant service et impact. La conformité au schéma n’établit pas l’exactitude factuelle : comparez les valeurs extraites avec l’entrée, et appliquez vos règles métier avant de stocker ou d’agir sur le résultat.
## Gemini 4 Carbon API Price
La [tarification de lancement de Google](https://blog.google/innovation-and-ai/models/gemini-models/gemini-4-carbon-now-available/) court jusqu’au 30 novembre 2026 ; ses tarifs standards entrent en vigueur le 1er décembre. Vérifiez les tarifs actuels de votre compte avant de budgéter des requêtes ultérieures.
Les deux modèles appartiennent à la famille Gemini 4, mais ciblent des charges différentes.
| Palier de tarification API | Entrée / 1M de jetons | Sortie / 1M de jetons |
| -------------------------- | --------------------- | --------------------- |
| Standard (jusqu’au 30 nov.) | $2.00 | $10.00 |
| Standard (à partir du 1er déc.) | $4.00 | $20.00 |
| Batch (jusqu’au 30 nov.) | $1.00 | $5.00 |
| Batch (à partir du 1er déc.) | $2.00 | $10.00 |
| Flex (jusqu’au 30 nov.) | $1.00 | $5.00 |
| Priority (jusqu’au 30 nov.) | $3.60 | $18.00 |
Détails tarifaires supplémentaires :
* Entrée mise en cache : 0,10 $ par million de jetons jusqu’au 30 novembre, passant à 0,20 $ à partir du 1er décembre.
* Batch et Flex offrent un traitement à moindre coût pour des charges qui peuvent tolérer leurs caractéristiques de service.
* Les jetons de raisonnement sont facturés en tant que jetons de sortie.
* Les jetons consommés par les instructions d’outils internes et les déclarations de fonctions peuvent également être facturables.
Google recommande explicitement Argon pour la plupart des travaux d’ingénierie logicielle et de connaissance, en réservant Carbon aux tâches nécessitant un raisonnement plus profond et une vérification étendue.
Recommandation pratique : choisissez Carbon lorsque le coût d’un résultat incorrect est élevé ou lorsqu’une tâche nécessite une exploration et une vérification substantielles. Choisissez Argon lorsque vous avez besoin d’un raisonnement solide avec un budget de jetons plus efficace.
### CometAPI Price
Au 12 novembre 2026, le [barème du groupe par défaut de CometAPI](https://www.cometapi.com/models/google/gemini-4-carbon/) indique 1,60 $ par million de jetons d’entrée, 8,00 $ par million de jetons de sortie incluant le raisonnement, et 0,08 $ par million de jetons d’entrée mis en cache en cas de hit. Ces tarifs sont 20 % inférieurs aux tarifs de lancement correspondants de Google.
La tarification CometAPI peut évoluer à mesure que les tarifs officiels de Google changent. Comparez le tarif officiel actuel avec la remise appliquée à votre compte plutôt que de considérer le prix en dollars d’aujourd’hui comme permanent. Si la même remise de 20 % est maintenue après un changement de tarif, votre tarif est le nouveau tarif officiel × 0,80 ; confirmez le tarif CometAPI effectif avant de budgéter. D’autres groupes de compte peuvent avoir des remises différentes.
Pour une requête avec 100 000 jetons d’entrée non mis en cache et 10 000 jetons de sortie, raisonnement inclus, le coût des seuls jetons est de 0,24 $ au tarif CometAPI affiché : 0,16 $ pour l’entrée plus 0,08 $ pour la sortie. Les mêmes quantités coûtent 0,30 $ aux tarifs de lancement de Google ou 0,60 $ à ses tarifs de décembre. Les 110 000 jetons combinés tiennent dans le budget partagé du modèle.
Cette estimation exclut les outils, les relances et tout ajustement tarifaire spécifique au compte. Le coût de la sortie inclut les jetons de raisonnement, donc un niveau de raisonnement plus élevé peut augmenter la facture même si la réponse visible est courte.
### How to Optimize Gemini 4 Carbon API Costs?
Optimisez pour le coût d’un résultat correct et exploitable. Une requête moins chère a peu de valeur si vous devez la répéter ou corriger manuellement la réponse.
1. Choisissez le raisonnement de manière délibérée. Commencez à MEDIUM, testez LOW pour les travaux simples, et utilisez HIGH lorsqu’il améliore suffisamment l’acceptation pour justifier le temps et les jetons supplémentaires.
2. Réutilisez le contexte stable via la mise en cache implicite. Les workflows [Argon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-argon) et [Carbon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-carbon) ne prennent pas en charge la création explicite de cache de contexte ; ils prennent en charge la mise en cache implicite. Placez les instructions et documents réutilisables en premier, suivis de la question changeante. Google documente l’éligibilité pour des préfixes partagés d’au moins 4 096 jetons. Vérifiez les hits de cache effectifs et les frais sur votre route CometAPI ; la répétition ne garantit pas une remise.
3. Réduisez le travail inutile. Envoyez les pages ou extraits pertinents, demandez uniquement les champs de sortie nécessaires, et définissez un budget de sortie suffisant. Le raisonnement compte dans l’utilisation de sortie, donc un plafond trop faible peut entraîner des troncatures et des relances.
4. Mesurez l’ensemble du workflow. Incluez le raisonnement, l’utilisation d’outils, les relances et les réponses rejetées dans la dépense totale. Enregistrez les réponses valides afin que les échecs en aval du stockage ne déclenchent pas une nouvelle génération.
5. Orientez-vous selon la valeur démontrée. Comparez Carbon et Argon sur des tâches identiques. Envisagez Batch ou Flex uniquement lorsque votre fournisseur les prend en charge et que la charge peut tolérer leurs caractéristiques de traitement.
Suivez le coût par résultat accepté = dépense totale du workflow ÷ résultats acceptés. Examinez-le avec la latence et la qualité après avoir modifié un modèle, une invite ou un niveau de raisonnement.
## Which API Format Should You Use for Gemini 4 Carbon?
Les développeurs peuvent accéder à l’[API Gemini 4 Carbon dans CometAPI](https://www.cometapi.com/models/google/gemini-4-carbon/) via l’API native Gemini et une API Chat compatible OpenAI. Utilisez l’interface qui correspond au format de requête de votre application et aux exigences de fonctionnalités documentées.
| Interface | Quand c’est adapté | Vérification d’intégration |
| ----------------------------- | -------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
| Gemini-native GenerateContent | Les exemples Python et REST de ce guide ; applications utilisant déjà contents et generationConfig | Utilisez la base URL Gemini et les noms de champs montrés ci-dessus |
| OpenAI-compatible Chat API | Une application existante organisée autour de messages de chat | Vérifiez le point de terminaison, les champs et les fonctionnalités prises en charge par la route Carbon avant d’adapter le code |
La compatibilité s’applique à un point de terminaison et à une forme de requête particuliers. N’envoyez pas de champs OpenAI Responses vers le point de terminaison natif Gemini, et ne supposez pas qu’une route compatible Chat implémente également Responses. Une application avec outils a besoin d’un aller-retour vérifié entre un appel de fonction et son résultat correspondant, pas seulement d’une invite texte réussie.
## How to Migrate from Gemini 4 Argon to Gemini 4 Carbon API?
Si votre application Argon utilise déjà la route native Gemini GenerateContent de CometAPI, commencez par basculer le modèle configuré vers gemini-4-carbon. Conservez la clé, la base URL, l’invite et la logique de validation inchangées pour la première comparaison. [Argon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-argon) et [Carbon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-carbon) partagent de nombreuses conventions de requêtes Gemini 4 ; le nettoyage des paramètres legacy n’est nécessaire que si ces champs restent dans votre application.
### 1. Change the model and run a controlled comparison
Dans la configuration utilisée dans ce guide, changez COMETAPI_MODEL de gemini-4-argon à gemini-4-carbon, puis redémarrez le processus Python afin qu’il recharge la variable. Utilisez la même invite représentative et le même niveau de raisonnement pour les deux modèles. L’exemple autonome suivant réutilise carbon_client.py et sélectionne explicitement Carbon :
from carbon_client import client, types, completed_text
response = client.models.generate_content(
model="gemini-4-carbon",
contents="Review this function for correctness: def add(a, b): return a + b",
config=types.GenerateContentConfig(
max_output_tokens=4096,
thinking_config=types.ThinkingConfig(thinking_level="MEDIUM"),
),
)
print(completed_text(response))
### 2. Check request settings and conversation history
Conservez LOW, MEDIUM ou HIGH sur GenerateContent. Supprimez tout reste de thinking_budget, MINIMAL, ou d’utilisation explicite de cached_content. Ne comptez pas sur temperature, top_p ou top_k pour contrôler le résultat. Supprimez les valeurs de frequency_penalty, presence_penalty, et candidate_count supérieures à 1. Si vous appelez des outils, préservez les IDs d’appel de fonction, les noms et l’ordre de réponse correspondants. Ce sont des vérifications de compatibilité, pas des fonctionnalités nouvellement supprimées d’Argon.
### 3. Validate quality, cost, and latency before rollout
Exécutez le même jeu de tests sur les deux modèles. Vérifiez la réussite des tâches, la validation JSON, l’exécution des outils, l’achèvement complet, les jetons facturés et le temps écoulé. Conservez la configuration Argon disponible, dirigez une petite portion du trafic vers Carbon, et n’étendez que s’il respecte vos objectifs d’acceptation et de budget.
### 4. Keep long-output support separate from the model switch
Commencez par des requêtes qui se terminent en un seul segment de premier plan. Si vous avez besoin de continuation, confirmez d’abord que CometAPI prend en charge le point de terminaison et les champs de réponse requis. Un simple changement de nom de modèle n’active pas à lui seul le workflow de continuation v1beta1 de Google sur la passerelle v1beta de ce guide. Conservez la sortie partielle incomplète jusqu’à ce que la génération se termine normalement.
## Conclusion
Utilisez la première requête réussie comme point de départ pour un test d’intégration. Ajoutez uniquement les types d’entrée et formats de réponse dont votre application a besoin, puis vérifiez les sorties complètes, la gestion des erreurs et le coût sur des tâches représentatives. Dirigez une petite part du trafic via la nouvelle intégration avant de l’étendre, et conservez une configuration fonctionnelle connue si les résultats changent.
## Gemini 4 Carbon FAQ
### How large is Gemini 4 Carbon's context window?
Gemini 4 Carbon prend en charge une limite de contexte unifiée entrée-et-sortie de 1,048,576 jetons. Ce budget inclut l’entrée, le raisonnement, les appels de fonctions et la sortie générée.
### What are Gemini 4 Carbon's strongest benchmarks?
Ses meilleurs résultats déclarés incluent 88,2 % sur SEC-bench Pro, 54,8 % sur ExploitGym, 71,0 % sur CWE-bench, et 96,2 % sur GraphWalks. Ces résultats mettent en avant ses capacités en cybersécurité, long contexte et raisonnement agentique.
### How does Gemini 4 Carbon compare with Gemini 4 Argon?
Carbon s’améliore sensiblement par rapport à Argon sur plusieurs benchmarks rapportés, notamment Artificial Analysis Intelligence Index (59 vs 50), SWE-sweep (9,6 % vs 4,3 %), et SEC-bench Pro (88,2 % vs 83,4 %). Sa distinction principale est une meilleure performance en raisonnement étendu et sur des tâches agentiques complexes.
### Is Gemini 4 Carbon better than Claude Opus 5.5?
Aucun modèle ne mène tous les benchmarks. Carbon obtient de meilleurs scores sur Artificial Analysis Intelligence Index, Terminal-Bench 4.0, GraphWalks, et des évaluations de cybersécurité, tandis que Claude Opus 5.5 mène sur OSWorld-2.1 et FrontierSWE 2 dans la comparaison publiée par Google.
### What thinking levels does Gemini 4 Carbon support?
Gemini 4 Carbon prend en charge les niveaux LOW, MEDIUM et HIGH, avec MEDIUM par défaut. Les développeurs peuvent utiliser ces réglages pour équilibrer la profondeur de raisonnement, la latence et la consommation de jetons.
### Can Gemini 4 Carbon process images, audio, and video?
Oui. Sa fiche modèle liste le texte, les images, l’audio et la vidéo comme modalités d’entrée prises en charge. Sa modalité de sortie documentée est le texte.
### What is Gemini 4 Carbon's knowledge cutoff?
La fiche modèle de novembre 2026 de Google indique mars 2026 comme date de coupure des connaissances. Le modèle peut donc manquer d’informations sur les événements et développements postérieurs, sauf s’ils sont fournis via des outils externes ou un contexte utilisateur.
Fiabilité
Des hallucinations, des timeouts occasionnels et une utilisation de jetons plus élevée peuvent survenir
Validez les faits, le code et les champs extraits.
