La plupart des files de soutien fonctionnent sur de petits jugements. Est ce une demande de remboursement. Quelle équipe la possède. À quel point est ce grave. Les équipes paient souvent un modèle de clavardage pour répondre à chaque jugement en prose, puis paient de nouveau pour analyser la prose en une valeur que le code peut utiliser. Google a livré un outil plus étroit pour ce travail le 11 novembre 2026. L’API Gemini Decisions, alimentée par le modèle Gemini Decision 1, ne génère aucun texte du tout. Elle note les options que vous lui donnez et retourne des chiffres.
Ce tutoriel construit un vérificateur en lot sur cette API. Une demande transporte un billet de soutien et quatre questions à son sujet. Les réponses reviennent comme des probabilités avec des pointages de confiance, et un court bloc d’acheminement envoie les cas sûrs plus loin et garde les cas incertains pour une personne. Les étapes suivent la documentation publiée et les exemples de code dans le guide officiel. Aucune exécution réelle avec une vraie clé n’est prétendue ici. La section Vérification vous dit comment prouver que le vérificateur fonctionne dans votre propre compte.
Ce que vous allez construire ou apprendre
Vous terminerez avec un petit script Python qui envoie un billet à l’API Decisions et reçoit quatre jugements en un appel. Le script demande si le billet demande un remboursement, quel département doit le traiter, quelle est la gravité du problème et si une personne doit l’examiner avant que quiconque agisse. Il affiche ensuite chaque réponse avec sa confiance et achemine le billet selon des règles que vous contrôlez.
Vous apprendrez aussi les trois types de questions et les limites qui façonnent toute conception de lot. Une question oui ou non est de type noul dans l’API. Un choix dans un ensemble fixe est de type choice. Une note sur une échelle ordonnée est de type score. Chaque question est jugée seule par rapport à l’entrée partagée. Ajouter une question ne change pas les réponses aux autres, et l’entrée partagée peut mélanger du texte avec des images, de l’audio, de la vidéo et des fichiers PDF.
Une entrée qui entre, beaucoup de jugements qui sortent. La machine trie. Votre code décide ce que chaque pile signifie. Illustration : Dirty Static
Avant de commencer
Décidez quels jugements dans votre file sont vraiment bornés. L’API convient aux questions avec un ensemble fixe de réponses, comme l’acheminement, les vérifications de politique, la sélection d’outils et la notation par rapport à une grille. Elle ne peut pas expliquer une décision, tirer une valeur d’un document ni raisonner à travers une chaîne d’étapes. Si un billet a besoin d’une réponse écrite ou d’une chaîne de pensée, cette partie appartient encore à un modèle de clavardage ou à une personne.
Le prix façonne la conception, alors notez le avant de construire. Google facture 0,10 $ par million de jetons d’entrée sur le niveau payant, et la sortie n’est jamais facturée parce que le modèle produit zéro jeton de sortie. L’entrée partagée est facturée une fois par demande, peu importe le nombre de questions qu’elle transporte. Il n’y a aucun cache de contexte et aucune prise en charge de l’API Batch, alors une demande que vous répétez facture son entrée au complet chaque fois. Google signale des temps de demande complets d’environ 150 à 250 millisecondes, presque plats de 1 à 100 questions sur des entrées jusqu’à 16K jetons. Ce sont des chiffres de Google. Mesurez les sur vos propres billets avant de concevoir autour d’eux.
Étape 1 : obtenir une clé et installer le SDK
Action : ouvrez Google AI Studio, créez une clé API et rangez la dans une variable d’environnement avec un nom d’espace réservé dans vos notes. Installez ensuite le SDK en version 3.2 ou plus récente. Les versions plus vieilles ne portent pas du tout l’espace de noms decisions.
export GEMINI_API_KEY="YOUR_API_KEY"
pip install -U google-genai
Résultat attendu : la variable est réglée pour votre session shell et l’installation signale google-genai en version 3.2 ou plus récente. Vous pouvez aussi essayer des questions sans code dans le Decisions Playground dans AI Studio, qui exporte du code exécutable quand vous êtes prêt.
Étape 2 : poser une question oui ou non
Action : commencez avec le plus petit appel que le guide donne. Le client doit nommer la version d’API v1beta, ou l’espace de noms decisions n’apparaît pas. Cet exemple utilise le texte de la tasse endommagée tiré du guide officiel.
from google import genai
client = genai.Client(http_options={"api_version": "v1beta"})
result = client.decisions.create(
model="gemini-decision-1",
input="The blue mug I ordered on Monday arrived cracked on Wednesday.",
questions={
"is_damaged": {
"type": "noul",
"instructions": "Did the item arrive damaged?",
},
},
)
answer = result.answers["is_damaged"]
print(f"P(yes)={answer.noul:.2f} confidence={answer.confidence:.2f}")
Résultat attendu : l’appel retourne une carte de réponses sous la même clé que vous avez envoyée, plus un bloc d’usage où les jetons de sortie lisent zéro. Le guide montre une valeur noul de 0.99 avec une confiance de 0.99 pour ce texte. Le champ noul est la probabilité que la réponse soit oui, et il tombe toujours entre 0.01 et 0.99. La confiance pour ce type est la plus grande valeur entre la valeur et un moins la valeur, alors une valeur de 0.03 porte une confiance de 0.97 que la réponse est non. Le même appel par REST va à POST https://generativelanguage.googleapis.com/v1beta/decisions avec votre clé dans l’en tête x-goog-api-key. Notez le chemin. Ce modèle ne répond pas sur le chemin generateContent que les autres modèles Gemini utilisent.
Étape 3 : transformer un appel en vérification en lot
Action : gardez le même client et faites grandir la carte des questions. Ce lot exécute quatre vérifications sur un billet. Il mélange les trois types, et il ajoute une vérification de portée qui demande si le message concerne une commande du tout. Cette vérification de portée compte à l’étape 5.
ticket = "I was charged twice for my order and the export page crashes in Safari."
result = client.decisions.create(
model="gemini-decision-1",
input=ticket,
questions={
"about_order": {
"type": "noul",
"instructions": "Is this message about an order, a payment or a delivery?",
},
"is_refund": {
"type": "noul",
"instructions": "Does the customer ask for a refund or a charge reversal?",
},
"department": {
"type": "choice",
"instructions": "Which department should handle this request?",
"criteria": {
"billing": "Payments, invoices, and refunds.",
"technical": "Problems using the product.",
"shipping": "Delivery and tracking.",
"other": "Anything outside these categories.",
},
},
"severity": {
"type": "score",
"instructions": "How severe is this issue for the user?",
"criteria": [
"Cosmetic: appearance only, no lost functionality.",
"Workaround available: a task fails, but another way works.",
"Fully blocked: a task fails with no workaround.",
],
},
},
)
Résultat attendu : une réponse garde quatre réponses, une par clé. La réponse choice nomme la meilleure option et donne une probabilité pour chaque option. La réponse score donne une moyenne pondérée entre les niveaux, alors elle peut atterrir entre les niveaux, et elle porte une probabilité pour chaque niveau plus une légende qui relie les numéros de niveau à votre texte de niveau. Trois faits de la documentation façonnent la façon dont vous écrivez ces questions. Le modèle ne voit jamais vos clés de question, alors la question complète doit vivre dans le texte des instructions. Les clés doivent aller de 1 à 64 caractères tirés de lettres, de chiffres, de traits de soulignement et de traits d’union. L’API trie les options de choix par clé avant de les noter, et une égalité sur une probabilité exacte va à l’option dont la clé se trie en premier. Nommez votre option de filet de sécurité other, comme dans cet exemple. Un nom comme none_of_the_above se trie avant les vraies options et peut gagner des égalités qu’il devrait perdre.
Étape 4 : ajouter une photo ou un PDF à la même entrée
Action : quand une vérification a besoin de plus que le texte du billet, envoyez l’entrée comme une liste de blocs au lieu d’une chaîne. Les blocs peuvent être du texte, une image, de l’audio, de la vidéo ou un document, et document signifie PDF seulement. Réglez le vrai type de média sur chaque bloc, parce que l’API rejette application/octet-stream. Les données en ligne sont plafonnées à 100 MB par demande, et à 50 MB pour les fichiers PDF. Les fichiers à des URL externes sont plafonnés à 15 MB chacun, et les liens YouTube et les adresses gs:// ne sont pas pris en charge. Utilisez l’API Files, une adresse HTTPS publique ou signée, ou des octets en ligne à la place.
import base64
with open("photo.jpg", "rb") as f:
image_b64 = base64.b64encode(f.read()).decode("utf-8")
result = client.decisions.create(
model="gemini-decision-1",
input=[
{"type": "text", "text": "Customer photo for return 8821.\n"},
{"type": "image", "data": image_b64, "mime_type": "image/jpeg", "resolution": "low"},
],
questions={
"visible_damage": {
"type": "noul",
"instructions": "Does the photo show physical damage to the item? Ignore the packaging.",
},
},
)
Résultat attendu : la photo rejoint le texte comme une entrée partagée, et chaque question dans la même demande peut juger les deux. Le réglage resolution échange le détail visuel contre des jetons, avec les valeurs low, medium, high et ultra_high, et la dernière de celles ci sert les images seulement. Un lot peut grandir jusqu’à 1 000 questions par demande, dans une limite totale de 262 144 jetons partagés par l’entrée et les questions.
Étape 5 : acheminer selon la probabilité et la confiance
Action : lisez la valeur pour choisir une action et lisez la confiance pour décider si l’action peut fonctionner seule. Les chiffres ci dessous sont des points de départ tirés des exemples du guide. Remplacez les par des seuils que vous gagnez à l’étape 6.
a = result.answers
dept = a["department"]
if a["about_order"].noul < 0.5:
route_to("general_intake")
elif dept.confidence >= 0.7 and dept.choice != "other":
route_to(dept.choice)
elif dept.confidence >= 0.4:
route_to_fallback_model(ticket)
else:
route_to("human_review")
Résultat attendu : les cas sûrs avancent, les cas moyens reçoivent un deuxième regard d’un modèle plus grand qui peut raisonner, et les cas faibles attendent une personne. Deux règles de la documentation protègent ce bloc. Une question choice divise toujours sa probabilité entre les options que vous lui avez données, même quand aucune ne convient, ce qui explique pourquoi la vérification de portée fonctionne d’abord dans ce code. Une valeur score est une moyenne, pas un niveau. Quand vous avez besoin d’un niveau, prenez le niveau avec la probabilité la plus élevée et lisez son texte dans la légende, comme ce court bloc le fait.
sev = result.answers["severity"]
level = max(sev.probabilities, key=sev.probabilities.get)
print(sev.legend[level])
Étape 6 : tester avec vos propres billets étiquetés
Action : construisez un petit ensemble de billets passés où une personne a déjà enregistré le bon département, la bonne gravité et l’appel de remboursement. Lancez le lot sur chacun et comparez les meilleures réponses avec les étiquettes. Comptez à quelle fréquence chaque bande de confiance se révèle juste, puis réglez vos seuils d’acheminement à partir de ces comptes. Google conseille exactement cela. Les seuils devraient venir d’exemples étiquetés de votre propre trafic, et le même ensemble vous dit si les probabilités signifient ce qu’elles prétendent sur vos données.
Résultat attendu : vous tenez un seuil mesuré pour chaque voie, plus une liste de billets que le lot se trompe et que vous pouvez étudier. Gardez l’ensemble et relancez le après toute modification aux instructions ou aux critères. Un bloc de sécurité a aussi besoin de soin dans cette étape. Quand le filtre d’entrée bloque une demande, l’API retourne HTTP 400 avec un code d’erreur comme safety ou prohibited_content et aucune réponse du tout. Enregistrez ce résultat comme aucune décision et envoyez le billet à une personne. Un billet bloqué est souvent celui qui a le plus besoin d’yeux humains.
La pile qui attend une personne est une fonction de la conception, pas un échec d’elle. Illustration : Dirty Static
Vérification
Faites ces vérifications et enregistrez les résultats. Le script envoie une demande pour un seul billet et le bloc d’usage signale zéro jeton de sortie. La carte des réponses garde chaque clé que vous avez envoyée, et chaque réponse porte une confiance entre 0 et 1. Le texte de la tasse de l’étape 2 retourne une valeur noul élevée, et un billet sans contenu de commande s’achemine vers l’accueil général par la vérification de portée. Votre ensemble étiqueté de l’étape 6 passe au taux que vos seuils supposent, et une entrée bloquée atterrit en examen humain plutôt que dans une file.
Terminez avec la vérification des coûts. Calculez le prix d’une demande à la main à partir de son nombre de jetons d’entrée à 0,10 $ par million de jetons, puis comparez ce chiffre avec le coût des mêmes vérifications envoyées comme des appels de clavardage séparés qui renvoient le billet chaque fois. L’écart entre ces deux chiffres est toute la raison pour laquelle ce point de terminaison existe.
Dépannage
| Problème | Cause probable | Correctif |
|---|---|---|
| L’espace de noms decisions n’apparaît pas sur le client | Le SDK se trouve sous la version 3.2, ou le client n’a pas le réglage v1beta | Installez google-genai à 3.2 ou plus récent et créez le client avec la version d’API v1beta, comme à l’étape 2 |
| Un appel REST retourne 404 ou une erreur de modèle | L’appel est allé au chemin generateContent ou à la version v1 | Envoyez la demande à POST /v1beta/decisions avec le modèle gemini-decision-1, comme à l’étape 2 |
| Une règle de seuil ne se déclenche jamais | Le seuil se trouve au dessus de 0.99 ou en dessous de 0.01, et les valeurs noul ne quittent jamais cette plage | Gardez les seuils oui ou non entre 0.01 et 0.99 et réglez les à partir de votre ensemble étiqueté |
| La réponse de département choisit une option quand aucune ne convient | Une question choice doit répartir la probabilité entre les options qu’on lui a données | Lancez d’abord une vérification de portée de type noul, comme aux étapes 3 et 5, et acheminez les échecs ailleurs avant de faire confiance au choix |
| Un pointage s’affiche comme une fraction et semble faux | Le champ score est une moyenne pondérée entre les niveaux, pas un indice de niveau | Lisez le niveau avec la probabilité la plus élevée et affichez son texte de légende, comme à l’étape 5 |
| Toute la demande retourne HTTP 400 sans réponses | Un filtre de sécurité a bloqué l’entrée, et le code d’erreur nomme le blocage | Traitez le résultat comme aucune décision et envoyez l’article à l’examen humain. Ne lisez jamais un blocage comme un non à chaque question |
| Les coûts montent sur les exécutions répétées de la même entrée | L’API n’offre aucun cache de contexte, alors chaque demande facture l’entrée partagée au complet | Mettez plus de questions en lot dans chaque demande et coupez les appels répétés sur des entrées qui n’ont pas changé |
Prochaines étapes
Faites grandir le lot là où la forme convient. Un contrat ou une capture d’écran peut faire face à des dizaines de règles de politique en une demande. Un routeur peut demander quel outil convient à une tâche et quel niveau de modèle doit la prendre, le même schéma de flux de contrôle que notre guide des sessions d’agents en bac à sable garde de l’autre côté. Gardez chaque nouvelle question indépendante, ajoutez la d’abord à l’ensemble étiqueté et laissez ses réponses gagner la confiance à faibles enjeux avant qu’elles déplacent de l’argent ou ferment des billets.
L’habitude qui vaut la peine d’être gardée est la division que cette API force. Les appels de jugement qui se terminent en un ensemble fixe de réponses vont au lot. Le travail qui a besoin de mots, de raisons ou d’une chaîne d’étapes va ailleurs. Les files deviennent plus rapides quand chaque genre de travail fonctionne sur l’outil qui a été construit pour lui.
Faits vérifiés par rapport à la documentation et aux exemples du guide de l’API Gemini Decisions le 12 novembre 2026. Les prix, les limites et les chiffres de latence sont des valeurs publiées par Google et peuvent changer, alors confirmez les dans la documentation avant un déploiement plus large. Cette procédure a été vérifiée par rapport à ces documents et n’est pas présentée comme un essai personnel.
Sources
- Google, Gemini Decisions API documentation and guide, checked November 12, 2026: https://aistudio.google.com/docs/decisions-api
- Google, Gemini Decisions API announcement, November 11, 2026, via Google Blog
- Apidog, How to Use the Gemini Decisions API, November 2026: https://apidog.com/blog/how-to-use-gemini-decisions-api/
- TeamoRouter, Gemini Decision API: Price, the Three Question Types and How to Call It, November 12, 2026: https://teamorouter.com/blogs/gemini-decision-api
- ImportStatic, Gemini Decisions API in Go: a REST client and its traps, November 12, 2026: https://importstatic.com/ai/gemini-decisions-api-go
- Hero, sorter and review images: Dirty Static illustrations
FIN DE LA TRANSMISSION
Restez curieux. Remettez tout en question.
