1. परिचय
ज़्यादातर बैकएंड सॉफ़्टवेयर को पैराग्राफ़ लिखने के लिए, एआई मॉडल की ज़रूरत नहीं होती. उन्हें किसी सवाल का तुरंत और भरोसेमंद जवाब चाहिए होता है: हां या नहीं? इस टिकट का मालिकाना हक किस सहायता टीम के पास है? यह कितना ज़रूरी है?
TypeSafe AI के Jev जैसे शुरुआती क्लासिफ़ायर ने हाल ही में, "हां/नहीं" वाले मॉडल में डेवलपर की दिलचस्पी बढ़ाई है. इसमें यह दिखाया गया है कि जब टोकन-दर-टोकन JSON जनरेट करने की धीमी प्रोसेस को छोड़ दिया जाता है और एक ही बार में क्लोज़्ड-सेट फ़ैसलों को स्कोर किया जाता है, तो क्या होता है.
Google DeepMind का Gemini Decisions API (gemini-decision-1 की मदद से काम करता है) इस सुविधा को google-genai SDK में नेटिव तौर पर उपलब्ध कराता है. इससे आपको एक बार में 1, 000 yes/no (noul), जवाबों के कई विकल्पों वाले (choice), और क्रम के हिसाब से स्केल किए गए (score) सवालों का आकलन करने की सुविधा मिलती है. इसमें, कैलिब्रेट की गई संभावनाओं, ज़ीरो आउटपुट टोकन, और टेक्स्ट, फ़ोटो, ऑडियो, वीडियो, और PDF में पहले से मौजूद मल्टीमोडल सहायता की सुविधा मिलती है.
आपको क्या करना होगा
- लोकल Python एनवायरमेंट सेट अप करें और Google AI Studio के एपीआई पासकोड का इस्तेमाल करके,
gemini-decision-1से कनेक्ट करें. - टिकट रूट करने, सुरक्षा के नियमों, और मल्टीमोडल डेटा के आधार पर फ़ैसला लेने जैसे सैंपल प्रोग्राम चलाएं. इससे आपको Gemini Decisions API को समझने में मदद मिलेगी.
आपको क्या सीखने को मिलेगा
- चैट एलएलएम को JSON के लिए प्रॉम्प्ट देने से, रूटिंग के आसान फ़ैसलों में इंतज़ार का समय, लागत, पार्स करने, और कॉन्फ़िडेंस से जुड़ी समस्याएं क्यों आती हैं.
noul(हां/नहीं),choice(एक विकल्प चुनें), औरscore(क्रम से लगाया गया स्केल), ये तीनों तरह के सवाल एक हीclient.decisions.createकॉल में कैसे काम करते हैं.resolutionका इस्तेमाल करके, मल्टीमोडल टोकन के खर्च को कंट्रोल करने औरinput_tokens_by_modalityका इस्तेमाल करके, खर्च की जांच करने का तरीका.
आपको इन चीज़ों की ज़रूरत होगी
- आपकी मशीन (या Google Cloud Shell) पर Python 3.11+ और
gitइंस्टॉल होना चाहिए. - Google AI Studio से मिला Gemini API पासकोड (इस कोडलैब के लिए, Google Cloud प्रोजेक्ट सेटअप करने की ज़रूरत नहीं है).
2. Gemini Decisions API के बारे में जानकारी
चैट एलएलएम से JSON फ़ॉर्मैट में जवाब देने के लिए कहने पर, बैकएंड की स्पीड कम क्यों हो जाती है
चैट एलएलएम को लोगों के साथ बातचीत करने के लिए बनाया गया था. जब किसी असिस्टेंट से ईमेल लिखने या किसी गड़बड़ी के बारे में बताने के लिए कहा जाता है, तो स्क्रीन पर शब्दों के दिखने में कुछ सेकंड लगते हैं. यह इंतज़ार करना बिलकुल सामान्य लगता है.
समस्याएं तब शुरू होती हैं, जब बैकएंड सेवाएं उसी चैट वर्कफ़्लो का इस्तेमाल करके, रूटिंग का तुरंत फ़ैसला लेती हैं. जैसे, यह तय करना कि "मेरा ऑर्डर #19028 कहां है?" को कहां भेजना है या उसे अपने-आप पूरा करना सुरक्षित है या नहीं.
इन कामों के लिए चैट मॉडल का इस्तेमाल करने पर, जवाब मिलने में बहुत ज़्यादा समय लगता है. साथ ही, यह तरीका महंगा और सबसे अहम बात यह है कि कम भरोसेमंद होता है. इस वजह से, एजेंट को कोई कार्रवाई करने या किसी खास दिशा में आगे बढ़ने के लिए, भरोसेमंद जानकारी नहीं मिल पाती.
gemini-decision-1 के काम करने का तरीका
gemini-decision-1, टेक्स्ट को टोकन-दर-टोकन जनरेट करने के बजाय, आपके इनपुट को एक बार में पढ़ता है और आपके सभी सवालों को एक ही बार में स्कोर करता है. इससे, सीधे तौर पर कैलिब्रेट की गई संभावनाओं का पता चलता है.

- आउटपुट टोकन के लिए कोई शुल्क नहीं (10 लाख इनपुट टोकन के लिए 0.10 डॉलर, आउटपुट टोकन के लिए 0 डॉलर): यह मॉडल कभी भी टेक्स्ट या थिंकिंग टोकन जनरेट नहीं करता. इसलिए,
total_output_tokensहमेशा0होता है. शेयर किए गएinputके लिए, हर कॉल के हिसाब से एक बार बिल भेजा जाता है. इससे कोई फ़र्क़ नहीं पड़ता कि आपने कितने सवाल अटैच किए हैं. - 50 से 100 मि॰से॰ में मॉडल कंप्यूट: एक-एक करके टोकन जनरेट करने की ज़रूरत नहीं होती. इसलिए, एक ही अनुरोध में 10, 50 या 100 सवाल पूछने पर भी मॉडल कंप्यूट तेज़ी से और अनुमान के मुताबिक काम करता है.
- मल्टीमोडल आउट ऑफ़ द बॉक्स: यह 2,62,144-टोकन वाली कॉन्टेक्स्ट विंडो में टेक्स्ट, इमेज, ऑडियो, वीडियो, और PDF दस्तावेज़ों का एक साथ आकलन करता है. इसमें इमेज और वीडियो पर
resolutionसेटिंग (low,medium,high,ultra_high) होती है, ताकि टोकन के खर्च को कंट्रोल किया जा सके.
तीन तरह के सवाल (noul, choice, score)
client.decisions.create को किए जाने वाले हर कॉल में, questions डिक्शनरी का इस्तेमाल किया जाता है. इसमें हर सवाल के लिए, इन तीन टाइप में से किसी एक का इस्तेमाल किया जाता है:
समस्या | इसका इस्तेमाल कब करना चाहिए | कौनसा डेटा वापस लाया जाता है |
noul (Yes / No) | यह जांचना कि कोई स्टेटमेंट सही है या नहीं ("क्या यह प्रॉम्प्ट इंजेक्शन है?") | noul ('हां' की संभावना [0.01, 0.99] में है) और कॉन्फ़िडेंस |
choice (2–255 options) | किसी तय डिक्शनरी से एक विजेता चुनना ("यह किस टीम का है?") | विकल्प (जीतने वाली कुंजी), संभावनाओं का मैप, और कॉन्फ़िडेंस |
स्कोर (2 से 255 लेवल) | किसी क्रम वाली सूची (0 से K - 1) में, ज़रूरी होने, गंभीरता या क्वालिटी के हिसाब से रेटिंग देना | स्कोर (वेटेड एवरेज), लेजेंड, संभावनाएं, और कॉन्फ़िडेंस |
आसान अंग्रेज़ी में सिलसिलेवार तरीके से निर्देश
मान लें कि कोई ग्राहक यह मैसेज भेजता है: "मेरा ऑर्डर #19028 कहां है? क्या मुझे बता सकते हो कि यह कब आएगा?" यहां बताया गया है कि एक ही एपीआई कॉल में, उस मैसेज पर हर तरह का सवाल कैसे काम करता है:
- **
noul** (हां / नहीं) — "क्या हम किसी व्यक्ति की मदद के बिना, अपने-आप इसका जवाब दे सकते हैं?": आपने 'हां' या 'नहीं' में जवाब देने वाला सवाल भेजा हो. इसके बाद,noul = 0.98औरconfidence = 0.98मिलता है. इसका मतलब है कि 98% संभावना है कि जवाब "हां" हो. (अगर जवाब साफ़ तौर पर "नहीं" होता, तो आपकोnoul = 0.02औरconfidence = 0.98दिखता.) - **
choice** (कोई एक विकल्प चुनें) — "इस मैसेज को किस टीम को हैंडल करना चाहिए?": आपको विकल्पों की एक तय सूची भेजनी होगी. जैसे,order_status,billing_refund,account_access, औरother. इसके बाद, आपको विजेता कुंजी (choice = "order_status"), उसका कॉन्फ़िडेंस (0.9995), और हर विकल्प के लिए संभावना का ब्रेकडाउन मिलता है. इन सभी का कुल योग1.0होता है. - **
score** (Ordered Scale) — "How urgent is this message?": सबसे कम (0) से लेकर सबसे ज़्यादा (3) तक का क्रम वाला स्केल भेजा जाता है, जैसे कि["Low", "Medium", "High", "Critical"]. इसके बाद,0और3के बीच की संभावना के हिसाब से औसत वैल्यू मिलती है. रूटीन ट्रैकिंग से जुड़े सवाल के लिए यह वैल्यूscore = 0.15होती है, जबकि लाइव आउटेज के लिए यह वैल्यू2.98के करीब होती है.
3. शुरू करने से पहले
1. Gemini API पासकोड पाना
अपने ब्राउज़र में Google AI Studio API Keys खोलें. इसके बाद, अपने Google खाते से साइन इन करें और कोई एपीआई पासकोड बनाएं या कॉपी करें.
2. सैंपल रिपॉज़िटरी को क्लोन करना और Python सेट अप करना
टर्मिनल खोलें, कंपैनियन रिपॉज़िटरी gcp-gemini-decisions-hybrid-gateway का क्लोन बनाएं, वर्चुअल एनवायरमेंट बनाएं, और डिपेंडेंसी इंस्टॉल करें:
git clone https://github.com/rominirani/gcp-gemini-decisions-hybrid-gateway.git
cd gcp-gemini-decisions-hybrid-gateway
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
उसी टर्मिनल सेशन में अपना GEMINI_API_KEY एक्सपोर्ट करें:
export GEMINI_API_KEY="YOUR_GEMINI_API_KEY"
4. उदाहरण 1: सहायता टिकट को सही टीम को भेजना
इस पहले उदाहरण में, हम scripts/quickstart_decisions.py की जांच करेंगे और उसे चलाएंगे. यह एक ही एपीआई कॉल में, तीनों तरह के सवाल पूछता है—department (choice), can_auto_resolve (noul), और urgency (score).
कोड की जांच करना
scripts/quickstart_decisions.py में मौजूद मुख्य client.decisions.create कॉल यहां दिया गया है:
from google import genai
client = genai.Client(api_key=api_key, http_options={"api_version": "v1beta"})
result = client.decisions.create(
model="gemini-decision-1",
input=query_text,
questions={
"department": {
"type": "choice",
"instructions": "Which operational queue should handle this customer message?",
"criteria": {
"order_status": "Order tracking, delivery dates, or shipment status.",
"billing_refund": "Duplicate charges, invoices, credits, or refund requests.",
"subscription_cancel": "Canceling or pausing a recurring subscription.",
"account_access": "Password resets, expired 2FA/MFA codes, or login lockouts.",
"complex_incident": "Production outages, HTTP 500 errors, or legal questions.",
"other": "Anything outside these specific categories.",
},
},
"can_auto_resolve": {
"type": "noul",
"instructions": "Can this request be fulfilled deterministically by an automated "
"backend lookup or webhook without custom investigation?",
"criteria": {
"true_description": "Routine single-intent request such as checking tracking.",
"false_description": "Outage, legal question, or ambiguous billing dispute.",
},
},
"urgency": {
"type": "score",
"instructions": "Rate the operational urgency and severity of this message.",
"criteria": [
"Low: Routine informational or tracking question.",
"Medium: Standard account, subscription, or billing request.",
"High: Time-sensitive customer impact or repeated billing failure.",
"Critical: Production-halting outage, data loss risk, or security incident.",
],
},
},
)
dept = result.answers["department"]
auto = result.answers["can_auto_resolve"]
urg = result.answers["urgency"]
# The API returns raw probabilities; our script sets the cutoff for auto-handling (80%):
auto_decision = auto.noul >= 0.80
ध्यान दें कि आखिरी लाइन (auto.noul >= 0.80) में, Decisions API कभी भी कटऑफ़ को हार्डकोड नहीं करता है. यह रॉ noul प्रॉबेबिलिटी (0.01 से 0.99) दिखाता है. साथ ही, आपका Python कोड यह तय करता है कि थ्रेशोल्ड कितना सख्त होना चाहिए.
रन 1A: ऑर्डर ट्रैक करने से जुड़ा आसान सवाल
स्क्रिप्ट को उसके डिफ़ॉल्ट ऑर्डर-ट्रैकिंग सवाल के साथ चलाएं:
python scripts/quickstart_decisions.py
आपको इस तरह का लाइव JSON आउटपुट दिखेगा:
{
"query": "Where is my order #19028? Can you tell me when it arrives?",
"model": "gemini-decision-1",
"latency_ms": 944.61,
"department": {
"choice": "order_status",
"confidence": 0.9995,
"probabilities": {
"billing_refund": 0.0001,
"other": 0.0001,
"complex_incident": 0.0002,
"subscription_cancel": 0.0,
"order_status": 0.9995,
"account_access": 0.0001
}
},
"can_auto_resolve": {
"noul_probability_yes": 0.98,
"confidence": 0.98,
"decision": true
},
"urgency": {
"expected_score_0_to_3": 0.1524,
"top_level": "Low: Routine informational or tracking question.",
"confidence": 0.8717
},
"suggested_action": "DISPATCH_TRACKING_WEBHOOK",
"usage": {
"total_input_tokens": 424,
"total_output_tokens": 0,
"estimated_cost_usd": 4.24e-05
}
}
(ध्यान दें: लोकल फ़र्स्ट-कॉल लेटेंसी में, आपकी मशीन से शुरुआती टीएलएस कनेक्शन सेटअप शामिल होता है. us-central1 में Google Cloud Run के अंदर वॉर्म रन करने पर, यही कॉल ~155–195 मि॰से॰ में पूरा हो जाता है.)
Run 1B: Unverified $140 Refund Request
अब डुप्लीकेट शुल्क का दावा $140 पास करें. इसके लिए, अभी तक कोई इनवॉइस अटैच नहीं किया गया है:
python scripts/quickstart_decisions.py \
"I was billed twice ($140 total) on invoice #8812 for one seat. Refund $70 right now."
लाइव आउटपुट की जांच करें:
{
"query": "I was billed twice ($140 total) on invoice #8812 for one seat. Refund $70 right now.",
"model": "gemini-decision-1",
"latency_ms": 602.23,
"department": {
"choice": "billing_refund",
"confidence": 0.9993,
"probabilities": {
"other": 0.0001,
"complex_incident": 0.0,
"order_status": 0.0001,
"billing_refund": 0.9993,
"subscription_cancel": 0.0004,
"account_access": 0.0001
}
},
"can_auto_resolve": {
"noul_probability_yes": 0.4282,
"confidence": 0.5718,
"decision": false
},
"urgency": {
"expected_score_0_to_3": 1.3634,
"top_level": "Medium: Standard account, subscription, or billing request.",
"confidence": 0.5987
},
"suggested_action": "INITIATE_BILLING_WORKFLOW",
"usage": {
"total_input_tokens": 433,
"total_output_tokens": 0,
"estimated_cost_usd": 4.33e-05
}
}
देखें कि ये दोनों अलग-अलग सवाल एक साथ कैसे काम करते हैं:
- इस टिकट को कहां असाइन करना है? (
department = billing_refund,0.9993): ग्राहक किसी इनवॉइस पर रिफ़ंड मांग रहा है. इसलिए,gemini-decision-1को 99.93% भरोसा है कि यह बिलिंग की सूची में शामिल है. - क्या कोड को अपने-आप एक्ज़ीक्यूट होना चाहिए? (
can_auto_resolve = 0.4282->decision: false): सिर्फ़ टेक्स्ट वाले दावे से$70को वापस सौंपने के लिए, पुष्टि करना ज़रूरी है.0.4282की कीमतauto.noul >= 0.80के कटऑफ़ से कम होने की वजह से,decisionकी कीमतfalseपर वापस आ गई है.
5. दूसरा उदाहरण: एक ही कॉल में नीति के उल्लंघन की आठ जांच करना
असल बैकएंड ऐप्लिकेशन में, आने वाले मैसेज की आम तौर पर एक से ज़्यादा बार जांच करनी पड़ती है. इसके बाद ही, आपका कोड किसी डेटाबेस को ऐक्सेस करता है या किसी टूल को ट्रिगर करता है. चैट एलएलएम के साथ, आठ अलग-अलग कॉल करने से इंतज़ार का समय बढ़ जाता है और आपके इनपुट टेक्स्ट के लिए आठ बार बिल जनरेट होता है. वहीं, एक बड़े JSON प्रॉम्प्ट में आठ नियम शामिल करने से, मॉडल कुछ मामलों को अनदेखा कर देता है.
आइए, scripts/parallel_guardrails.py की जांच करें. यह एक decisions.create कॉल में, आठ अलग-अलग जांच (प्रॉम्प्ट इंजेक्शन, रॉ व्यक्तिगत पहचान से जुड़ी जानकारी/सीक्रेट, तुरंत रिफ़ंड पाने की ज़रूरी शर्तें, चार्जबैक के खतरे, टारगेट सूची, टूल का विकल्प, सदस्यता छोड़ने का जोखिम, और गलत इस्तेमाल का लेवल) करता है.
स्क्रिप्ट कैसे काम करती है
पहला चरण: इवेंट के मेटाडेटा और टेक्स्ट को एक साथ इनपुट के तौर पर पास करना
input के तौर पर सीरियलाइज़ की गई JSON डिक्शनरी को पास करने से, gemini-decision-1 को फ़्री-फ़ॉर्म ग्राहक मैसेज के साथ-साथ स्ट्रक्चर्ड फ़ील्ड (जैसे, amount_usd और order_age_days) की जांच करने की सुविधा मिलती है. इससे, शेयर किए गए पेलोड के लिए सिर्फ़ एक बार बिलिंग की जाती है:
event = {
"event_id": "evt-03-clean-refund",
"customer_tier": "PREMIUM",
"order_age_days": 6,
"amount_usd": 34.0,
"message": "Order #77102 arrived yesterday with a cracked mug handle. Could I get a $34 refund?",
}
दूसरा चरण: सभी आठ सवालों के सही जवाब एक बार में देना
हम EIGHT_PARALLEL_QUESTIONS में चार noul सवाल, दो choice सवाल, और दो score सवाल तय करते हैं. इसके बाद, उन्हें एक कॉल में पास करते हैं:
EIGHT_PARALLEL_QUESTIONS = {
"prompt_injection_attempt": { "type": "noul", "instructions": "...", "criteria": {...} },
"contains_raw_pii_or_secrets": { "type": "noul", "instructions": "...", "criteria": {...} },
"eligible_for_instant_refund": {
"type": "noul",
"instructions": "Does this request qualify for instant automated refund under policy "
"(amount <= $50, order_age_days <= 30, clear defect or duplicate)?",
"criteria": {...},
},
"threatens_chargeback_or_legal": { "type": "noul", ... },
"target_queue": { "type": "choice", ... },
"selected_mcp_tool": { "type": "choice", ... },
"churn_risk": { "type": "score", ... }, # 0..3 (Low -> Severe)
"abuse_toxicity": { "type": "score", ... }, # 0..2 (Benign -> Hostile)
}
result = client.decisions.create(
model="gemini-decision-1",
input=json.dumps(event), # Shared input — billed once
questions=EIGHT_PARALLEL_QUESTIONS, # All 8 questions scored in parallel
)
a = result.answers
तीसरा चरण: Python में, प्राथमिकता के नियमों के साथ जवाबों को जोड़ना
result.answers में हर सवाल का अपना अलग स्कोर होता है. इसलिए, हमारा Python कोड, अपने-आप रिफ़ंड की अनुमति देने से पहले, सुरक्षा से जुड़े जोखिमों (प्रॉम्प्ट इंजेक्शन और लीक हुए सीक्रेट) की जांच करता है:
if a["prompt_injection_attempt"].noul >= 0.70:
gate_verdict = "QUARANTINE_ADVERSARIAL_INPUT"
elif a["contains_raw_pii_or_secrets"].noul >= 0.75:
gate_verdict = "REDACT_PII_BEFORE_STORAGE"
elif a["threatens_chargeback_or_legal"].noul >= 0.75 or a["churn_risk"].score >= 2.3:
gate_verdict = "ROUTE_TO_VIP_RETENTION_SPECIALIST"
elif a["eligible_for_instant_refund"].noul >= 0.85 and a["selected_mcp_tool"].confidence >= 0.80:
gate_verdict = "AUTO_EXECUTE_INSTANT_REFUND"
else:
gate_verdict = f"DISPATCH_{a['selected_mcp_tool'].choice.upper()}"
स्क्रिप्ट चलाना
तीन सैंपल मैसेज की जांच करने के लिए, scripts/parallel_guardrails.py को एक्ज़ीक्यूट करें: प्रॉम्प्ट-इंजेक्शन की कोशिश, गलती से चिपकाया गया sk_live_... एपीआई पासकोड, और टूटे हुए मग के लिए रिफ़ंड का $34 मैसेज:
python scripts/parallel_guardrails.py
तीनों टेस्ट इवेंट के लाइव आउटपुट की समीक्षा करें:
[
{
"event_id": "evt-01-injection",
"gate_verdict": "QUARANTINE_ADVERSARIAL_INPUT",
"questions_evaluated_in_parallel": 8,
"latency_ms": 626.34,
"signals": {
"prompt_injection_prob": 0.9766,
"raw_pii_prob": 0.0426,
"instant_refund_prob": 0.0275,
"target_queue": "security_trust",
"selected_mcp_tool": "quarantine_security_event"
},
"usage": { "total_input_tokens": 977, "total_output_tokens": 0, "estimated_cost_usd": 9.77e-05 }
},
{
"event_id": "evt-02-pii-leak",
"gate_verdict": "REDACT_PII_BEFORE_STORAGE",
"questions_evaluated_in_parallel": 8,
"latency_ms": 724.48,
"signals": {
"prompt_injection_prob": 0.0548,
"raw_pii_prob": 0.9755,
"instant_refund_prob": 0.0292,
"target_queue": "security_trust",
"selected_mcp_tool": "quarantine_security_event"
},
"usage": { "total_input_tokens": 999, "total_output_tokens": 0, "estimated_cost_usd": 9.99e-05 }
},
{
"event_id": "evt-03-clean-refund",
"gate_verdict": "AUTO_EXECUTE_INSTANT_REFUND",
"questions_evaluated_in_parallel": 8,
"latency_ms": 625.68,
"signals": {
"prompt_injection_prob": 0.0133,
"raw_pii_prob": 0.01,
"instant_refund_prob": 0.9676,
"target_queue": "billing_ops",
"selected_mcp_tool": "issue_instant_credit"
},
"usage": { "total_input_tokens": 987, "total_output_tokens": 0, "estimated_cost_usd": 9.87e-05 }
}
]
सभी आठ जांचों को एक साथ करने पर, हर इवेंट के लिए करीब 0.000099 डॉलर खर्च होते हैं. इसमें 0 आउटपुट टोकन इस्तेमाल होते हैं.
6. तीसरा उदाहरण: ओसीआर के बिना फ़ोटो और PDF की जांच करना
आम तौर पर, जब कोई उपयोगकर्ता अटैचमेंट के साथ दावा सबमिट करता है, तो आपके बैकएंड को पहले एक अलग ओसीआर या विज़न पाइपलाइन चलानी पड़ती है. जैसे, सुविधा की जांच की फ़ोटो या PDF इनवॉइस. ऐसा इसलिए किया जाता है, ताकि रूटिंग के नियम लागू होने से पहले टेक्स्ट को निकाला जा सके. gemini-decision-1 नेटिव तौर पर मल्टीमॉडल है. इसलिए, हम एक ही decisions.create कॉल में, लिखित दावा और रॉ अटैचमेंट, दोनों को एक साथ भेज सकते हैं.
हम क्या टेस्ट करने वाले हैं
scripts/multimodal_triage.py दो स्थितियों की जांच करता है. इनमें से हर एक में, कम शब्दों में किए गए दावे के साथ एक अटैचमेंट जोड़ा जाता है:
पहला उदाहरण: फ़ैसिलिटी इंस्पेक्शन की फ़ोटो (कम रिज़ॉल्यूशन बनाम हाई रिज़ॉल्यूशन)
- उपयोगकर्ता का लिखित दावा: "सुबह 9 बजे क्लाइंट के साथ मीटिंग से पहले, ब्रेक रूम काउंटर की जांच करें. पोंछने के कपड़े के बगल में, कॉफ़ी के कुछ छींटे दिख रहे हैं."
अटैच की गई फ़ोटो (03-multimodal-triage/spill.jpg): इसमें हल्के रंग के काउंटर पर गहरे रंग की कॉफ़ी गिरी हुई दिख रही है. इसके बगल में, पैटर्न वाला कपड़ा रखा हुआ है:

दूसरा विकल्प: डुप्लीकेट बिल वाला PDF इनवॉइस (रॉ PDF बाइट, ज़ीरो ओसीआर)
- उपयोगकर्ता का लिखित दावा: "मुझसे इनवॉइस INV-8812 पर, 45 डॉलर का शुल्क दो बार (कुल 90 डॉलर) लिया गया. मैंने PDF फ़ॉर्मैट में इनवॉइस अटैच किया है."
- अटैच की गई PDF (
03-multimodal-triage/sample_invoice_8812.pdf): एक पेज का इनवॉइस, जिसमेंLine 1: Pro Plan Monthly Subscription ... $45.00औरLine 2: Pro Plan Monthly Subscription [DUPLICATE] $45.00(कुल$90.00) की जानकारी दी गई है.
हमें क्या उम्मीद है
- स्पिल फ़ोटो (कम बनाम ज़्यादा रिज़ॉल्यूशन): दोनों रन में, काउंटर पर मौजूद छोटे स्पिल का पता लगाना चाहिए और एक जैसा जवाब देना चाहिए. हालांकि,
lowरिज़ॉल्यूशन में इमेज टोकन का इस्तेमाल बहुत कम किया जाता है. - PDF इनवॉइस (कोई ओसीआर नहीं):
sample_invoice_8812.pdfअटैच करने से यह साबित होता है कि खरीदार से वाकई दो बार शुल्क लिया गया था. इसलिए, मॉडल को सीधे PDF को पढ़ना चाहिए और रिफ़ंड को मंज़ूरी देनी चाहिए.
कोड को समझना
input को एक स्ट्रिंग पास करने के बजाय, scripts/multimodal_triage.py कॉन्टेंट ब्लॉक की सूची पास करता है. यह सूची text ब्लॉक से शुरू होती है और \n पर खत्म होती है. इसके बाद, image ब्लॉक या document (application/pdf) ब्लॉक होता है:
# For Run 1a & 1b: Pass an image URL and set resolution ("low" vs. "high")
image_block = {
"type": "image",
"uri": "https://storage.googleapis.com/generativeai-downloads/images/spill.jpg",
"mime_type": "image/jpeg",
"resolution": "low", # or "high" in Run 1b
}
# For Run 2: Read raw PDF bytes from disk and base64-encode them as a "document" block
# (Note: PDF document blocks do not take a "resolution" setting)
pdf_block = {
"type": "document",
"data": base64.b64encode(pdf_bytes).decode("ascii"),
"mime_type": "application/pdf",
}
result = client.decisions.create(
model="gemini-decision-1",
input=[
{"type": "text", "text": f"Claim Statement: {claim_text}\nAttached Evidence:\n"},
media_block, # either image_block or pdf_block
],
questions=MULTIMODAL_QUESTIONS,
)
resolution="low" और resolution="high" के बीच टोकन के इस्तेमाल की तुलना करने के लिए, स्क्रिप्ट result.usage.input_tokens_by_modality को भी पढ़ती है. इससे इनपुट टोकन, "text" और "image" में बंट जाते हैं.
स्क्रिप्ट चलाना और नतीजे देखना
python scripts/multimodal_triage.py
तीनों रन में लाइव JSON आउटपुट की जांच करें:
[
{
"experiment": "1a_photo_resolution_low",
"resolution": "low",
"evidence_supports_claim_prob": 0.9532,
"disposition": "local_cleanup_or_self_service",
"disposition_confidence": 0.9863,
"severity_expected_0_to_3": 1.0319,
"tokens_by_modality": { "text": 441, "image": 266 },
"total_input_tokens": 707,
"total_output_tokens": 0,
"estimated_cost_usd": 7.07e-05
},
{
"experiment": "1b_photo_resolution_high",
"resolution": "high",
"evidence_supports_claim_prob": 0.9154,
"disposition": "local_cleanup_or_self_service",
"disposition_confidence": 0.9825,
"severity_expected_0_to_3": 1.0471,
"tokens_by_modality": { "text": 441, "image": 1064 },
"total_input_tokens": 1505,
"total_output_tokens": 0,
"estimated_cost_usd": 0.0001505
},
{
"experiment": "2_pdf_duplicate_invoice_zero_ocr",
"resolution": null,
"latency_ms": 676.98,
"evidence_supports_claim_prob": 0.9578,
"disposition": "automated_credit_or_replacement",
"disposition_confidence": 0.9367,
"severity_expected_0_to_3": 1.9849,
"tokens_by_modality": { "text": 587, "image": 520 },
"total_input_tokens": 1107,
"total_output_tokens": 0,
"estimated_cost_usd": 0.0001107
}
]
आउटपुट से मिलने वाली दो अहम बातें:
lowरिज़ॉल्यूशन में चार गुना कम इमेज टोकन इस्तेमाल किए गए (1,064 के मुकाबले 266): दोनों रन में एक जैसा जवाब मिला (98% से ज़्यादा कॉन्फ़िडेंस के साथlocal_cleanup_or_self_service). छोटे टेक्स्ट या फ़ाइन प्रिंट के लिए,"high"या"ultra_high"सेव करें.- PDF इनवॉइस में, ओसीआर के बिना रिफ़ंड को मंज़ूरी दी गई:
sample_invoice_8812.pdfअटैच होने पर,evidence_supports_claim_probने0.9578पर नए शॉट पर स्विच करने की सुविधा दी और मॉडल ने करीब 677 मिलीसेकंड मेंautomated_credit_or_replacementको चुना.
7. बधाई हो
बधाई हो! आपने Gemini Decisions API ( का इस्तेमाल किया है
gemini-decision-1
) का इस्तेमाल करके, सहायता टिकटों को सही संभावनाओं के साथ रूट किया जा सकता है. साथ ही, एक ही बार में सुरक्षा और नीति से जुड़े आठ अलग-अलग गार्डरेल चलाए जा सकते हैं. इसके अलावा, ओसीआर के अलग चरण के बिना फ़ोटो और PDF इनवॉइस की पुष्टि की जा सकती है. यह सब बिना किसी आउटपुट टोकन के किया जा सकता है.
जब आप आगे बढ़ने के लिए तैयार हों, तो कंपैनियन रिपॉज़िटरी में मौजूद अन्य फ़ोल्डर देखें. इनमें 02-hybrid-gateway/ (एक तेज़ Cloud Run सेवा को डिप्लॉय करना, जो जटिल टिकटों को gemini-3.8-flash को सौंपती है) और 06-adk-workflows/ (Decisions API को Google ADK 2.0 वर्कफ़्लो के साथ जोड़ना) शामिल हैं.
रेफ़रंस दस्तावेज़
- लॉन्च की आधिकारिक पोस्ट: Gemini Decisions API की मदद से, सीमित विकल्पों में से तुरंत फ़ैसला लेना
- डेवलपर के लिए दस्तावेज़: Gemini Decisions API Guide (Google AI for Developers)
- इंटरैक्टिव प्लेग्राउंड: Google AI Studio में Gemini Decision 1 को आज़माएं
- सैंपल कोड रिपॉज़िटरी: https://github.com/rominirani/gcp-gemini-decisions-hybrid-gateway