תחילת העבודה עם Gemini Decisions API

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 קורא את הקלט פעם אחת ומדרג את כל השאלות במעבר אחד – ומחזיר ישירות הסתברויות מכוילות.

24a8561b90232d7f.jpeg

  • אפס טוקנים של פלט (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): כתם קטן וכהה של קפה על משטח בהיר, ולידו מטלית ניגוב עם דוגמה:

3012ce039ce45cd5.jpeg

תרחיש 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).

מסמכי עזר