מודלי החלטה בידיים: בונים נתב פניות עם Jev, Laya ו-Ollaya

מודל החלטה הוא מודל AI שמקבל טקסט ושאלה עם תשובות סגורות, ומחזיר בחירה אחת עם הסתברות, במעבר אחד, בלי לכתוב אף מילה. מאז ש-TypeSafe השיקה את Jev ב-15 בספטמבר, הקטגוריה הזו התפוצצה: ספרייה בקוד פתוח בשם Laya עברה 33 אלף כוכבים ב-GitHub בפחות מחודש, Cloudflare שחררה את Clef עם משקלים פתוחים, ו-Ollaya נותנת לנו להריץ את כל זה על המחשב שלנו כמו Ollama. על התחרות בין Jev ל-OpenAI כבר כתבנו בסיקור של DevDay. הפעם אנחנו מפשילים שרוולים ובונים.

התרגיל שילווה אותנו לאורך כל הכתבה: חנות אונליין קטנה, עם תיבת פניות שמקבלת כמה מאות הודעות ביום. אנחנו רוצים שכל הודעה תנותב אוטומטית לאחד מארבעה סלים: חיוב (billing), משלוח (shipping), תקלה טכנית (technical) או ספאם (spam), ובנוסף נדע אם היא דחופה. נבנה את אותו נתב בדיוק בשלוש דרכים: דרך ה-API של TypeSafe, עם Laya על המחשב, ועם Ollaya כשרת מקומי. ובסוף נשווה מהירות, מחיר, ומה קורה כשההודעה מגיעה בעברית.

מה זה בכלל מודל החלטה, ולמה עכשיו

בואו נפרק את זה. מודל שפה רגיל, LLM, כותב תשובה טוקן אחרי טוקן (טוקן הוא חתיכת מילה, היחידה שהמודל קורא וכותב). כדי לסווג הודעה, הוא בעצם "מקליד" את המילה billing, אות אחרי אות, ואנחנו צריכים לפענח את הטקסט שיצא, לקוות שהוא לא הוסיף הסבר מנומס, ולטפל במקרים שבהם הוא החזיר משהו שלא ביקשנו.

מודל החלטה עובד אחרת. ב-TypeSafe קוראים לזה System One, על שם "מערכת 1" מהספר "לחשוב מהר, לחשוב לאט" של דניאל כהנמן: המחשבה המהירה והאינטואיטיבית, לעומת "מערכת 2" האיטית והמחושבת. המודל קורא את כל הקלט פעם אחת, ומחזיר מיד התפלגות הסתברויות על התשובות שאנחנו הגדרנו מראש, כך שהוא פשוט לא יכול להחזיר תשובה מחוץ לרשימה. תחשבו על זה כמו ההבדל בין לבקש מעובד לכתוב לנו מייל עם ההמלצה שלו, לבין לתת לו טופס עם ארבע תיבות סימון.

יש שלושה סוגי שאלות, ומסתבר שכל הכלים בכתבה הזו מדברים באותם שמות:

• שאלת Choice - בחירה מתוך רשימה, למשל לאיזה סל שייכת ההודעה.
• שאלת Score - ציון על סולם מדורג, למשל כמה הלקוח כועס.
• שאלת Noul - הסתברות ש"כן", מ-0 עד 1, למשל האם ההודעה דחופה.

ולמה זה מעניין אותנו? כי הרבה מאוד מהעבודה של AI במוצר אמיתי היא בדיוק כזו: ניתוב, סיווג, סינון ספאם, ושומרי סף (guardrails, בדיקות שעוצרות קלט או פלט מסוכן לפני שהוא ממשיך הלאה). לפי TypeSafe, ל-Jev לוקח בין 70 ל-500 מילישניות מקצה לקצה, והמחיר הוא 0.042 דולר למיליון טוקנים של קלט, כשהפלט חינם לגמרי.

המכשול: למה לא פשוט לשאול LLM

השאלה ההוגנת היא למה לא להמשיך עם מה שעובד. מודל שפה טוב יסווג את ההודעות שלנו מצוין, ובעזרת פלט מובנה (structured output) אפשר גם לכפות עליו להחזיר JSON תקין. זו גישה אחרת לגמרי לגיטימית, ובמקרים רבים היא מספיקה.

אבל בנתב יש שלוש בעיות שמצטברות. הראשונה היא זמן: כל הודעה היא קריאה למודל שמייצר טקסט, ובאפליקציה שמנתבת כל בקשה זה מורגש. השנייה היא כסף: אנחנו משלמים על טוקני פלט, שבדרך כלל יקרים בהרבה מטוקני קלט. והשלישית, הכי חשובה בעיניי, היא הביטחון. מודל שפה אומר לנו "billing" באותו טון בדיוק כשהוא בטוח לגמרי וכשהוא מנחש. אין לנו מספר אחד שאפשר להגיד עליו: "מתחת לזה, תעביר לבן אדם".

מודל החלטה מחזיר את המספר הזה בדיוק. ב-TypeSafe אומרים שהמודל אומן כך שההסתברויות יהיו מכוילות (calibrated): אם הוא אומר 80% על אלף הודעות, בערך 800 מהן אמורות להיות נכונות. הם גם מזהירים בעצמם שזה נמדד על קבוצות גדולות, ולא מבטיח שתשובה בודדת נכונה.

דרך ראשונה: Jev דרך ה-API

הדרך הכי מהירה להתחיל היא ה-SDK הרשמי של TypeSafe לפייתון. מתקינים עם pip install typesafe-sdk, שמים מפתח API במשתנה הסביבה TYPESAFE_API_KEY, ושולחים לנקודת הקצה POST /v1/systemone את ההודעה (שנקראת state, "המצב") יחד עם השאלות. הנה הנתב של החנות שלנו, על בסיס הדוגמה מהתיעוד הרשמי:

# pip install typesafe-sdk   (Python 3.10+)
# export TYPESAFE_API_KEY="your-api-key"
from typesafe_sdk import Choice, Noul, TypeSafeClient

QUESTIONS = {
    "intent": Choice(
        instructions="What does the sender want?",
        criteria={
            "billing": "Invoices, payments, refunds",
            "shipping": "Delivery, tracking, late orders",
            "technical": "Bugs, login problems, site errors",
            "spam": "Ads, scams, phishing, unrelated promotions",
        },
    ),
    "is_urgent": Noul(instructions="The sender needs an answer today"),
}

inbox = [
    "Hi, you charged my card twice for order 4471. Please refund the duplicate today.",
    "Where is my package? Tracking hasn't moved in five days.",
    "Congratulations! You won a free iPhone, click here to claim your prize.",
]

with TypeSafeClient(model="jev-latest") as client:  # reads TYPESAFE_API_KEY
    for msg in inbox:
        response = client.system_one(state=msg, questions=QUESTIONS)
        intent = response.choices["intent"]
        urgent = response.nouls["is_urgent"].noul
        if intent.confidence < 0.3:
            print("-> human review:", msg[:40])  # not sure, don't guess
        else:
            print(intent.choice, f"urgent={urgent:.2f}")

שימו לב לשורה של confidence. זה הלב של כל העניין: אם המודל לא בטוח באיזה סל ההודעה, אנחנו לא מנחשים, אלא מעבירים אותה לבן אדם. וגם שתי השאלות, הסל והדחיפות, נשאלות באותה קריאה אחת, על אותה הודעה. כדאי לדעת: בתיעוד של TypeSafe כתוב במפורש שאנגלית היא שפת האימון הראשית, ושעם שפות אחרות המודל מתמודד "אבל לא באותה רמה". כלומר, לפני שאנחנו סומכים עליו עם פניות בעברית, חובה לבדוק אותו על הדאטה שלנו.

דרך שנייה: Laya על המחשב, בחינם

עכשיו בואו נוציא את הנתב מהענן. הספרייה Laya היא מודל החלטה בקוד פתוח, תחת רישיון Apache 2.0, שבנה החוקר Nandakishor M מ-ConvAI Innovations. המאגר נפתח ב-18 בספטמבר, שלושה ימים אחרי Jev, והיום יש לו מעל 33 אלף כוכבים. מתחת למכסה הוא מקודד (encoder) קטן: לא מודל שכותב טקסט, אלא מודל שרק קורא ומבין, בדומה ל-BERT המוכר. הגרסה האנגלית שוקלת 421 מיליון פרמטרים, והגרסה הרב-לשונית 322 מיליון, ותומכת ביותר מ-100 שפות.

ההתקנה היא שורה אחת, python -m pip install laya, וזה אותו נתב בדיוק, הפעם בלי מפתח ובלי חשבון:

# python -m pip install laya   (Python 3.10+, runs on CPU or GPU)
from laya import Router

router = Router()  # downloads a checkpoint on first use

questions = {
    "intent": {"type": "choice", "instructions": "What does the sender want?",
               "criteria": {"billing": "invoices, payments, refunds",
                            "shipping": "delivery, tracking, late orders",
                            "technical": "bugs, login problems, site errors",
                            "spam": "ads, scams, phishing, unrelated promotions"}},
    "is_urgent": {"type": "noul", "instructions": "Does the sender need an answer today?"},
}

inbox = [
    "Hi, you charged my card twice for order 4471. Please refund the duplicate today.",
    "Where is my package? Tracking hasn't moved in five days.",
    "Congratulations! You won a free iPhone, click here to claim your prize.",
]

for msg in inbox:
    r = router.predict(msg, questions)
    a = r["answers"]
    print(r["routing"]["model"], a["intent"]["choice"], round(a["is_urgent"]["noul"], 2))

# Same router as a Jev-compatible HTTP server on port 8000:
#   pip install "laya[serve]" && laya-serve

הקטע המדליק הוא ה-Router: הוא מזהה לבד את השפה של ההודעה ושולח הודעה באנגלית למודל האנגלי, והודעה בעברית למודל הרב-לשוני. לפי ה-README של הפרויקט, שאלה אחת לוקחת בסביבות 33 מילישניות על כרטיס T4 (כרטיס מסך ותיק ונפוץ בענן). ויש עוד יתרון: הפקודה laya-serve מרימה שרת שמדבר באותו פורמט בדיוק כמו ה-API של Jev, כך שקוד שכתבנו ל-Jev עובד מולו כמעט בלי שינוי.

דרך שלישית: Ollaya, ומה מסתתר מתחת למכסה

אם Laya היא ספרייה, אז Ollaya היא הכלי שהופך את כל הקטגוריה לחוויה של Ollama. פרויקט Ollaya הוא שרת מקומי בקוד פתוח שמוריד מודלי החלטה לפי שם ומריץ אותם על המחשב שלנו, עבור מפתחים שרוצים ניתוב וסיווג בלי לשלוח מידע החוצה. הוא תומך ב-Laya, ב-Clef של Cloudflare ובעוד יותר מעשרים מודלים פתוחים, ומדבר בפורמט של TypeSafe. המשמעות המעשית: את הקוד מהדרך הראשונה אפשר להפנות למחשב שלנו על ידי שינוי משתנה סביבה אחד:

המודל שהפרויקט ממליץ עליו הוא winnow:e4b, כוונון של Gemma 4 בגודל של כ-4 מיליארד פרמטרים. לפי ה-README, הוא מגיע ל-0.722 דיוק בבנצ'מרק של החלטות מוקלדות (Jev מגיע שם ל-0.738), ועונה על חמש שאלות ב-89 מילישניות על RTX 4090. והם כותבים בגלוי: בלי כרטיס NVIDIA, עדיף להתחיל עם laya, שעונה בשבריר שנייה גם על מעבד רגיל.

ומה קורה מתחת למכסה? פוסט שנקרא "Jev in 25 Lines of Python" הסתובב בספטמבר בכל מקום, והכותב שלו, Duarte O. Carmo, מגדיר אותו בעצמו כפרודיה. אבל הוא מראה משהו אמיתי: לוקחים מודל שפה קטן (Qwen3-0.6B) דרך llama.cpp, מציגים לו את האפשרויות כ-A, B ו-C, ובמקום לתת לו לכתוב, קוראים את ה-logits, הציונים הגולמיים שהמודל נותן לכל טוקן אפשרי, רק עבור שלוש האותיות. ממירים אותם להסתברויות, וזהו. על מייל שמבקש סיסמה בדף כניסה מזויף, הוא קיבל 0.885 לפישינג. ההבדל בין הטריק הזה לבין Jev או Laya הוא לא הרעיון, אלא האימון: מודלי ההחלטה אומנו במיוחד כדי שההסתברויות שלהם יהיו מכוילות.

ההשוואה: מהירות, מחיר, ועברית

הנה החלק שבשבילו בנינו את הנתב שלוש פעמים. ב-Cloudflare פרסמו, בבלוג של השקת Clef, מדידה אחת שמשווה את כולם באותו מבחן. זמן התגובה החציוני (median, הזמן שחצי מהבקשות מהירות ממנו):

בבלוג של Cloudflare, Jev עמד על 524 מילישניות, Clef הגדול על 209, Kev-9B על 51, Clef-flash על 39, ו-Laya על 6 מילישניות בלבד. הם גם מסייגים בעצמם: המודל Laya מאוד מהיר, אבל מוותר על איכות בבנצ'מרקים. ושימו לב שזו מדידה של מתחרה, ושהמספרים תלויים בחומרה, ברשת ובמספר השאלות. ב-README של Laya, למשל, מצוטטות מדידות עצמאיות שבהן Jev ענה ב-236 עד 276 מילישניות.

במחיר, הסדר מתהפך קצת. בואו נחשב על החנות שלנו: בדוגמה הרשמית של TypeSafe, הודעה עם שלוש שאלות צרכה 428 טוקנים של קלט. נעגל ל-400, ונניח 10,000 הודעות בחודש, כלומר 4 מיליון טוקנים. ב-Jev זה יוצא כ-17 סנט לחודש. ב-Clef-flash, שעולה 0.038 דולר למיליון טוקנים ב-Workers AI, כ-15 סנט. ב-Clef הגדול, שעולה 0.24 דולר, כ-96 סנט. וב-Laya או Ollaya על המחשב שלנו, אפס דולר, חוץ מהחשמל והחומרה. בקנה מידה של חנות קטנה, המחיר כמעט לא משנה: מה שבאמת מכריע הוא המהירות, הפרטיות, והאם המודל מבין עברית.

ועל עברית צריך לדבר בכנות. ב-Laya פרסמו מדידה על 51 שפות, במשימת זיהוי כוונה עם 20 אפשרויות, שבה ניחוש אקראי מקבל 5%. המודל הרב-לשוני הגיע בעברית ל-37% דיוק. זה פי שבעה מניחוש, אבל רחוק מאוד מלהיות משהו שאפשר לשים בפרודקשן בלי בדיקה. ובנתב שלנו יש רק ארבעה סלים, כך שהמשימה קלה יותר, אבל הכלל לא משתנה: מודדים על ההודעות האמיתיות שלנו לפני שסומכים.

בעיניי: מתי כן, ומתי לא

בעיניי, מודלי ההחלטה הם אחד הכלים הכי שימושיים שיצאו השנה לבוני מוצר, דווקא כי הם צנועים. הם לא מחליפים את מודל השפה. הם יושבים לפניו, ומחליטים מהר וזול לאן כל בקשה הולכת: לקוד רגיל, למודל שפה יקר, או לבן אדם. זה בדיוק הדפוס ש-TypeSafe עצמם ממליצים עליו בתיעוד, ניתוב לפי רמת ביטחון.

אז איזו מהדרכים לבחור? אם אנחנו רוצים להתחיל היום ולא לנהל שרתים, Jev דרך ה-API. אם המידע רגיש, או שאנחנו רוצים אפס עלות שולית, Laya או Ollaya על המחשב שלנו. ואם אנחנו כבר בתוך Cloudflare Workers, יש שם את Clef במרחק קריאה אחת. והקטע היפה הוא שכולם מדברים באותו פורמט, אז המעבר ביניהם הוא כמעט רק שינוי של כתובת.

וחשוב להגיד את המגבלות. לפי התיעוד של TypeSafe, Jev מקבל רק טקסט, ובסיקור של DevDay כבר כתבנו שהוא מתקשה בחשבון, בספירה ובהשוואת תאריכים, ושחוקרי Check Point הראו שאפשר להזריק לו פקודות זדוניות בתוך הקלט, בדיוק כמו למודל שפה. גם Laya מודה בגלוי שהוא חלש כשיש יותר מ-20 אפשרויות: על מבחן בנקאות עם 77 תוויות, Jev הגיע ל-0.870 ו-Laya רק ל-0.425. וההבטחה ש"המודל לא יכול להזות" פירושה שהוא לא יחזיר תשובה מחוץ לרשימה, לא שהוא תמיד צודק. מודל החלטה יכול לטעות בביטחון מלא, ולכן סף הביטחון שלנו חייב להיבדק על הדאטה שלנו, ולא להיות מועתק מדוגמה.

אז איזו החלטה אחת במוצר שלכם עוברת היום דרך מודל שפה שלם, ויכלה להיות תיבת סימון של 40 מילישניות?

רוצים ללכת עם זה רחוק יותר?

את הדפוס של נתב מהיר שמחליט מתי לקרוא למודל גדול, ואיך להכניס אותו לפרויקט אמיתי יחד עם סוכן קוד, אני מפרק לעומק בקורס Claude Code Mastery. ומי שרוצה לבנות אוטומציות, סוכנים וחיבורי MCP עם Claude, בעברית ובלי לכתוב הרבה קוד, ימצא את זה בקורס Practical AI with Claude. ואם הרעיון של להריץ הכל על המחשב, בלי שהמידע יוצא החוצה, מדבר אליכם, יש גם את הקורס מודלים מקומיים מקצה לקצה.

את הדמואים האלה, כולל הנתב שבנינו כאן, אני מעלה ל-YouTube ול-LinkedIn, ועדכונים קצרים ב-X, ב-Instagram וב-TikTok. הקוד שלי נמצא ב-GitHub.