1. מבוא
רוב תוכנות הקצה העורפי לא באמת צריכות מודל AI כדי לכתוב פסקאות, הן רק צריכות תשובה מהירה ומהימנה לשאלה מוגבלת: כן או לא? איזה צוות תמיכה מטפל בפנייה הזו? עד כמה זה דחוף?
מסווגים ייעודיים מוקדמים כמו Jev של TypeSafe AI עוררו לאחרונה עניין בקרב מפתחים במודלים של "כן/לא", בכך שהראו מה קורה כשמוותרים על יצירת JSON איטית, טוקן אחר טוקן, ומדרגים החלטות של קבוצות סגורות במעבר אחד.
Gemini Decisions API של Google DeepMind (שמבוסס על gemini-decision-1) מוסיף את היכולת הזו באופן מובנה ל-SDK של google-genai, ומאפשר להעריך עד 1,000 שאלות מסוג yes/no (noul), שאלות אמריקאיות (choice) ושאלות עם סולם דירוג (score) בסבב אחד עם הסתברויות מכוילות, אפס טוקנים של פלט ותמיכה מובנית במגוון פורמטים: טקסט, תמונות, אודיו, וידאו וקובצי PDF.
הפעולות שתבצעו
- מגדירים סביבת Python מקומית ומתחברים אל
gemini-decision-1באמצעות מפתח API של Google AI Studio. - להריץ תוכניות לדוגמה, החל מניתוב כרטיסים, כללי בטיחות וקבלת החלטות על סמך נתונים ממודלים שונים, שיעזרו לכם להבין את Gemini Decisions API.
מה תלמדו
- למה הנחיה של מודל LLM בצ'אט להחזיר פלט בפורמט JSON יוצרת בעיות של זמן אחזור, עלות, ניתוח ורמת סמך בהחלטות ניתוב פשוטות.
- איך שלושת סוגי השאלות:
noul(כן/לא),choice(בחירת אפשרות אחת) ו-score(סולם מסודר), פועלים יחד בקריאה אחת ל-client.decisions.create. - איך לשלוט בהוצאות על טוקנים מולטי-מודאליים באמצעות
resolutionולבדוק את השימוש באמצעותinput_tokens_by_modality.
מה תצטרכו
- Python 3.11+ ו-
gitמותקנים במחשב (או ב-Google Cloud Shell). - מפתח Gemini API מ-Google AI Studio (ב-Codelab הזה לא צריך להגדיר פרויקט ב-Google Cloud).
2. הסבר על Gemini Decisions API
Why Asking a Chat LLM for JSON Slows Down Backends
מודלי LLM לצ'אט נועדו לנהל שיחות עם אנשים. כשמבקשים מעוזר אישי לכתוב אימייל או להסביר באג, זה מרגיש טבעי לחלוטין לחכות כמה שניות בזמן שהמילים מופיעות על המסך.
הבעיות מתחילות כששירותים לקצה העורפי משתמשים באותו תהליך עבודה של צ'אט רק כדי לקבל החלטת ניתוב מהירה, כמו להחליט לאן לשלוח את "איפה ההזמנה שלי, מספר 19028?" או אם בטוח למלא אותה באופן אוטומטי.
אם משתמשים במודלים של צ'אט בתרחישים לדוגמה האלה, התשובות מתקבלות לאט מדי, העלות גבוהה והכי חשוב – התשובות לא יציבות, ולכן הסוכנים לא יכולים לסמוך עליהן כשהם צריכים לבצע פעולה מסוימת או להמשיך בכיוון ספציפי.
איך gemini-decision-1 פועל
במקום ליצור טקסט דינמי מבוסס-AI אסימון אחר אסימון, המודל gemini-decision-1 קורא את הקלט פעם אחת ומדרג את כל השאלות במעבר אחד – ומחזיר ישירות הסתברויות מכוילות.

- אפס טוקנים של פלט (0.10$ למיליון טוקנים של קלט, 0$ לטוקנים של פלט): המודל אף פעם לא יוצר טקסט דינמי מבוסס-AI או טוקנים של חשיבה, לכן
total_output_tokensתמיד שווה ל-0. החיוב עלinputהמשותף מתבצע פעם אחת לכל קריאה, לא משנה כמה שאלות מצורפות. - עיבוד מודל של 50-100 אלפיות השנייה: בלי יצירת טוקנים, עיבוד המודל נשאר מהיר וצפוי גם כששואלים 10, 50 או 100 שאלות בבקשה אחת.
- מולטי-מודאליות מוכנה לשימוש: הערכה של טקסט, תמונות, אודיו, וידאו ומסמכי PDF ביחד בחלון הקשר של 262,144 טוקנים, עם הגדרה של
resolution(low,medium,high,ultra_high) בתמונות ובסרטונים כדי לשלוט בהוצאות על טוקנים.
שלושת סוגי השאלות (noul, choice, score)
כל קריאה ל-client.decisions.create מקבלת מילון questions שבו כל שאלה משתמשת באחד משלושה סוגים:
סוג | מתי כדאי להשתמש בשיטה הזו | מה חוזר |
noul (כן / לא) | לבדוק אם טענה מסוימת נכונה ("האם זו החדרת פרומפטים?") | noul (הסתברות ל"כן" בטווח [0.01, 0.99]) ומהימנות |
בחירה (2-255 אפשרויות) | בחירת זוכה אחד מתוך מילון קבוע ("איזה צוות אחראי לזה?") | בחירה (המפתח הזוכה), מפת הסתברויות ורמת סמך |
ציון (2-255 רמות) | דירוג הדחיפות, החומרה או האיכות ברשימה מסודרת (0 עד K - 1) | ציון (ממוצע משוקלל), מקרא, הסתברויות ורמת סמך |
הסבר קצר ופשוט
נניח שלקוח שולח את ההודעה הבאה: "איפה הזמנה מספר 19028? Can you tell me when it arrives?" (תוכלי להגיד לי כשהוא יגיע?) כך כל סוג שאלה פועל בהודעה הזו בקריאה אחת ל-API:
- **
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** (סולם מסודר) – "עד כמה ההודעה הזו דחופה?": אתם שולחים סולם מסודר מהערך הנמוך ביותר (0) לערך הגבוה ביותר (3), למשל["Low", "Medium", "High", "Critical"]. התוצאה שמתקבלת היא ממוצע משוקלל של הסתברות בין0ל-3(score = 0.15לשאלה שגרתית של מעקב לעומת קרוב ל-2.98להפסקה זמנית בשירות בזמן אמת).
3. לפני שמתחילים
1. קבלת מפתח Gemini API
פותחים את מפתחות ה-API של Google AI Studio בדפדפן, נכנסים באמצעות חשבון Google ויוצרים או מעתיקים מפתח API.
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) – בקריאה אחת ל-API.
בדיקת הקוד
הנה הקריאה העיקרית ל-client.decisions.create בתוך scripts/quickstart_decisions.py:
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
}
}
(הערה: זמן האחזור המקומי של הקריאה הראשונה כולל את הגדרת החיבור הראשונית של TLS מהמכונה שלכם. כשמפעילים את הקריאה הזו ב-Google Cloud Run ב-us-central1, היא מסתיימת תוך כ-155 עד 195 אלפיות השנייה.)
הרצה 1B: בקשה לא מאומתת להחזר כספי בסך 140$
עכשיו צריך להעביר $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. דוגמה 2: הפעלת 8 בדיקות מדיניות בקריאה אחת
באפליקציות אמיתיות של בקאנד, הודעה נכנסת בדרך כלל צריכה לעבור יותר מבדיקה אחת לפני שהקוד שלכם ניגש למסד נתונים או מפעיל כלי. במודלים של LLM לצ'אט, אם מבצעים 8 קריאות נפרדות, זמן האחזור מוכפל וטקסט הקלט מחויב 8 פעמים. לעומת זאת, אם דוחסים 8 כללים להנחיית JSON ענקית אחת, המודל עלול לפספס מקרי קצה.
בואו נבחן את scripts/parallel_guardrails.py, שמעריך 8 בדיקות עצמאיות (החדרת פרומפטים, פרטים אישיים מזהים/סודות גולמיים, זכאות להחזר כספי מיידי, איומים של החזר כספי בעקבות ביטול עסקה, תור יעד, בחירת כלים, סיכון לנטישת לקוחות ורמת ניצול לרעה) בקריאה אחת של decisions.create.
איך הסקריפט פועל
שלב 1: מעבירים את המטא-נתונים של האירוע והטקסט ביחד כקלט
העברת מילון JSON שעבר סריאליזציה בתור input מאפשרת ל-gemini-decision-1 לבדוק שדות מובְנים (כמו amount_usd ו-order_age_days) לצד ההודעה של הלקוח בפריסה גמישה, ולחייב על המטען הייעודי (payload) המשותף רק פעם אחת:
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?",
}
שלב 2: מדרגים את כל 8 השאלות בסבב אחד
אנחנו מגדירים 4 שאלות noul, 2 שאלות choice ו-2 שאלות score ב-EIGHT_PARALLEL_QUESTIONS ומעבירים אותן בקריאה אחת:
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
שלב 3: שילוב התשובות עם כללי העדיפות ב-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 כדי לבדוק שלוש הודעות לדוגמה: ניסיון להחדרת הנחיות, מפתח API של 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 }
}
]
הערכת כל 8 הבדיקות יחד עולה בערך 0.000099$ לכל אירוע עם 0 טוקנים של פלט.
6. דוגמה 3: בדיקת תמונות וקובצי PDF בלי OCR
בדרך כלל, כשמשתמש שולח תביעה עם קובץ מצורף – כמו תמונה של בדיקת מתקן או חשבונית בפורמט PDF – קודם צריך להפעיל ב-backend צינור עיבוד נתונים נפרד של OCR או של ראייה ממוחשבת כדי לחלץ את הטקסט, ורק אז אפשר להפעיל את כללי הניתוב. מכיוון ש-gemini-decision-1 הוא מודל מולטי-מודאלי, אנחנו יכולים לשלוח גם את התביעה הכתובה וגם את הקובץ המצורף הגולמי ביחד בקריאה אחת ל-decisions.create.
מה אנחנו הולכים לבדוק
scripts/multimodal_triage.py בודק שני תרחישים – בכל אחד מהם יש טענה קצרה בכתב וקובץ מצורף:
תרחיש 1: תמונה של בדיקת מתקן (רזולוציה נמוכה לעומת רזולוציה גבוהה)
- הטענה בכתב של המשתמש: "בדיקת הדלפק בחדר המנוחה לפני פגישה עם לקוח ב-9:00. נשפך קצת קפה ליד מטלית הניגוב".
תמונה מצורפת (03-multimodal-triage/spill.jpg): כתם קטן וכהה של קפה על משטח בהיר, ולידו מטלית ניגוב עם דוגמה:

תרחיש 2: חשבונית PDF שחויבה פעמיים (בייטים גולמיים של PDF, ללא OCR)
- הטענה של המשתמש בכתב: "חויבתי פעמיים בסכום של 45$ (90$ בסך הכול) בחשבונית INV-8812. מצורפת החשבונית שלי בפורמט 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 (ללא OCR): צירוף של
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ברזולוציה השתמשנו בפי 4 פחות טוקנים של תמונות (266 לעומת 1,064): שתי ההרצות נתנו בדיוק את אותה תשובה (local_cleanup_or_self_serviceברמת סמך של יותר מ-98%). שמרו את"high"או"ultra_high"לטקסט קטן או לאותיות קטנות.- החשבונית ב-PDF אישרה את ההחזר הכספי עם אפס OCR: עם
sample_invoice_8812.pdfמצורף,evidence_supports_claim_probהמשך בסרטון הבא ל-0.9578והמודל בחר ב-automated_credit_or_replacementתוך כ-677 אלפיות השנייה.
7. מזל טוב
מעולה! השתמשתם ב-Gemini Decisions API (
gemini-decision-1
) ב-Python כדי לנתב כרטיסי תמיכה עם הסתברויות מכוילות, להריץ 8 מעקות בטיחות ומדיניות עצמאיים במעבר אחד, ולאמת תמונות וחשבוניות PDF בלי שלב OCR נפרד, והכול עם אפס טוקנים של פלט.
כשתהיו מוכנים להמשיך, תוכלו לעיין בתיקיות הנוספות במאגר הנלווה – כולל 02-hybrid-gateway/ (פריסת שירות Cloud Run מהיר שמעביר פניות מורכבות אל gemini-3.8-flash) ו-06-adk-workflows/ (שילוב של Decisions API עם תהליכי עבודה של Google ADK 2.0).
מסמכי עזר
- הפוסט הרשמי על ההשקה: Making quick work of bounded choices with the Gemini Decisions API
- מאמרי עזרה למפתחים: מדריך ל-Gemini Decisions API (Google AI for Developers)
- סביבת פיתוח אינטראקטיבית: נסו את Gemini Decision 1 ב-Google AI Studio
- מאגר המקורות של הקוד לדוגמה: https://github.com/rominirani/gcp-gemini-decisions-hybrid-gateway