[ טוען... ]

RAG אימות תשובות: ציטוטים ואימות טענות נגד הזיות בצ'אטבוט

תאריך: 25.10.2026
זמן קריאה: 17 דקות
לידור כהן
מייסד, לידור דיגיטל

שיתוף:

הירשמו לניוזלטר - תובנות על אוטומציה ו-AI, בלי ספאם

איור של בועת צ'אטבוט המפורקת לטענות המחוברות למסמכים, וטענה אחת מנותקת שמסומנת כלא נתמכת

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

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

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

למה RAG עדיין נותן תשובות שגויות בביטחון מלא

כדי להבין מאיפה מגיעות הזיות ב-LLM גם כשיש RAG, צריך להפריד בין שני רכיבים: מנוע האחזור (Retrieval) ומודל היצירה (Generation). Braintrust ממליצים להעריך את שניהם בנפרד, כך שאות כללי של ״האיכות נמוכה״ יהפוך לאבחנה מדויקת של הרכיב שדורש עבודה.

כשל אחזור: המודל לא קיבל את הראיה

Boolean & Beyond מזהים שני שורשים עיקריים לבעיה. הראשון הוא כשל אחזור: המסמך הרלוונטי לא נשלף, ולכן המודל נופל חזרה לידע הפרמטרי שלו, כלומר למה שלמד באימון.

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

כשל ציות: הראיה הייתה שם, והמודל חרג ממנה

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

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

למה ״אל תמציא״ בפרומפט לא מספיק

התגובה הראשונה של רוב הצוותים היא להוסיף לפרומפט שורה כמו ״אל תזה״. לפי PrompTessor, שורה כזו היא העדפה, לא מנגנון אכיפה.

אותו מקור מציין גם שפלט מובנה (Structured Output) אוכף תחביר אבל לא הופך ערכים שגויים לנכונים, ושהגדלת מאמץ החשיבה (Reasoning Effort) לא מתקנת באופן אוטומטי ראיות חסרות או גרועות.

המסקנה: צריך שכבות הגנה שמתייחסות לכל אחד משני מקורות הכשל, ובראשן אימות שמתבצע אחרי היצירה, בקוד, ולא רק בבקשה מנומסת מהמודל.

שלב 1: לתקן קודם את האחזור

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

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

חיפוש היברידי: וקטורים ומילות מפתח

מסד נתונים וקטורי טוב בתפיסת משמעות, אבל לפעמים מפספס התאמות מדויקות כמו מק״ט, שם מוצר או מספר סעיף. חיפוש היברידי משלב חיפוש סמנטי עם חיפוש מילולי (כמו BM25).

לפי Deepchecks, חברה שמפתחת כלי הערכה, חיפוש היברידי הניב בערך 10-15% שיפור בדיוק האחזור ובערך 10-20% שיפור באיכות התשובה. אלה ניתוחים מוקדמים של ספק, והתוצאות משתנות בין מאגרי נתונים, ולכן כדאי להתייחס אליהם כאל כיוון ולא כאל תוצאה צפויה.

Reranking: לשלוף רחב, לסנן צר

דפוס נפוץ הוא Retrieve-then-Rerank: שולפים מועמדים רבים בחיפוש מהיר, ואז מדרגים אותם מחדש במודל מדויק יותר.

Boolean & Beyond מתארים שליפה של 20 התוצאות המובילות ב-ANN ודירוג מחדש ל-5, עם שיפור טיפוסי של 15-30% ב-Context Precision. גם זו טענה של ספק ללא מתודולוגיה מפורטת, ולכן כדאי לראות בה כיוון ולא הבטחה.

למה רעש בהקשר מזיק

Braintrust נותנים דוגמה ל-Context Precision: אם נשלפו 10 מסמכים ורק 3 מהם רלוונטיים, 7 האחרים מוסיפים רעש.

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

רשימת בדיקה מעשית לשלב האחזור:

  • לבנות סט של 30-50 שאלות אמיתיות של לקוחות, ולסמן לכל שאלה את המסמך הנכון.
  • למדוד כמה פעמים המסמך הנכון מופיע ב-top-k, לפני שנוגעים במודל השפה.
  • לבדוק חיתוך (Chunking): פסקה שנחתכה באמצע טבלת מחירים היא מקור קבוע לטעויות.
  • להוסיף מטא-דאטה (תאריך עדכון, סוג מסמך) כדי לסנן גרסאות ישנות.
  • לשקול חיפוש היברידי ו-Reranking אם המסמך הנכון מופיע אבל לא בראש הרשימה.

שלב 2: פרומפט מבוסס הקשר בלבד עם מסלול הימנעות

אחרי שהאחזור סביר, הצעד הבא הוא לצמצם את החופש של המודל. Boolean & Beyond מציעים System Prompt שמגביל את המודל להקשר בלבד, עם נוסח מפורש של ״אין לי מספיק מידע״.

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

דוגמה ל-System Prompt בעברית

אתה נציג שירות של החברה. ענה אך ורק על סמך המסמכים המופיעים בין התגיות <context>.

כללים:
1. כל משפט עובדתי חייב לכלול ציון מקור בפורמט [מקור: doc-ID],
   ממוקם בסוף המשפט אבל לפני סימן הפיסוק הסוגר. לדוגמה:
   דמי המשלוח הם 49 ש״ח [מקור: doc-31].
2. אם המידע הנדרש לא מופיע במסמכים, השב בדיוק:
   ״אין לי מספיק מידע על כך במסמכים הזמינים. אפשר להעביר את השאלה לנציג.״
3. אל תשתמש בידע כללי, אל תשער מחירים, תאריכים או תנאים.
4. הפרד בין עובדה מהמסמך לבין המלצה או הסקה, וסמן הסקה במפורש.
5. ענה בקצרה, עד 3 משפטים.

<context>
[doc-14] ...
[doc-22] ...
</context>

המיקום של תגית המקור לפני הנקודה אינו עניין סגנוני. בדיקת הציטוטים בשלב 3 מפצלת את התשובה למשפטים לפי סימני פיסוק, ותגית שמופיעה אחרי הנקודה עלולה ״ליפול״ למשפט הבא.

ציטוטים מחמירים מול שרשרת מחשבה

מחקר שבחן RAG רפואי על שישה מודלים ומאגר MedQA (MDPI Applied Sciences) מצא שפרומפט מסוג StrictCitations נתן את רמת העיגון הניתנת לאימות הגבוהה ביותר. המודלים שנבדקו היו Command R 35B, Gemma 2 בגרסאות 9B ו-27B, Llama 3.1 8B, Mistral Nemo 12B ו-Qwen 2.5 14B.

לעומת זאת, פרומפט של שרשרת מחשבה בסגנון מומחה (Expert-CoT) העלה את יחס המשפטים הלא נתמכים (Unsupported Sentence Ratio) ל-95-100%.

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

אורך התשובה כסימן אזהרה

אותו מחקר מצא שתשובות ארוכות יותר שימשו כאינדיקציה לאי-ודאות של המודל ולדליפה של ידע פרמטרי, באופן הבולט ביותר ב-Llama 3.1 וב-Gemma 2.

מבחינה מעשית, הגבלת אורך התשובה היא לא רק עניין של חוויית משתמש, אלא גם דרך לצמצם את הפתח להזיות.

שלב 3: ציטוט מקורות ב-RAG ובדיקה שה-ID קיים

ציטוט מקורות ב-RAG משרת שתי מטרות: הוא מאפשר למשתמש לבדוק, והוא מאפשר למערכת לבדוק את עצמה.

Boolean & Beyond מציעים [לחייב תגיות Source: document_id] בתוך הטקסט, ואז לבדוק בקוד שכל מזהה אכן מופיע ברשימת המסמכים שנשלפו. ציטוט למזהה שלא נשלף הוא אות חזק להזיה.

בדיקת קיום בקוד

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

import re

CITATION_PATTERN = re.compile(r'\[מקור:\s*(doc-\d+)\]')
TRAILING_TAG = re.compile(r'([.!?])\s*(\[מקור:\s*doc-\d+\])')

def normalize_tags(answer: str) -> str:
    # תגית שהופיעה אחרי סימן הפיסוק עוברת אל לפניו,
    # כדי שלא תשויך בטעות למשפט הבא. הלולאה מטפלת בכמה תגיות ברצף.
    previous = None
    while previous != answer:
        previous = answer
        answer = TRAILING_TAG.sub(r' \2\1', answer)
    return answer

def check_citations(answer: str, retrieved_ids: set[str]) -> dict:
    answer = normalize_tags(answer)
    cited = CITATION_PATTERN.findall(answer)
    missing = [c for c in cited if c not in retrieved_ids]
    sentences = [s for s in re.split(r'(?<=[.!?])\s+', answer) if s.strip()]
    uncited = [s for s in sentences if not CITATION_PATTERN.search(s)]
    return {
        'cited_ids': cited,
        'hallucinated_ids': missing,      # מזהים שלא נשלפו בכלל
        'uncited_sentences': uncited,     # משפטים בלי מקור
        'passed': not missing and not uncited,
    }

במערכת אמיתית כדאי להחריג מבדיקת ״משפט בלי מקור״ את הודעת ההימנעות הקבועה ומשפטי נימוס, אחרת כל ״תודה שפנית״ ייספר ככשל.

ציטוט קיים עדיין לא מוכיח דבר

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

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

  1. קיום: המזהה נמצא ברשימת המסמכים שנשלפו (הבדיקה בקוד שלמעלה, לפי ההצעה של Boolean & Beyond).
  2. תמיכה: הקטע המצוטט אכן מוביל לוגית לטענה (השלב הבא, אימות ברמת הטענה).

ציטוט פנימי מול התאמה בדיעבד

מאמר VeriCite (arXiv) מתאר שתי גישות עיקריות לייחוס מקורות, ולצידן אפשר למקם את גישת הפרומפט בלבד:

גישה

יתרונות

חסרונות

ייחוס פנימי (Intrinsic): המודל מייצר ציטוטים תוך כדי היצירה

ציטוטים במעבר אחד; אפשר לאמן או להנחות ישירות

Fine-tuning דורש תיוג ומשאבי חישוב כבדים; In-context learning רגיש לדוגמאות ומתקשה להכליל

ייחוס חיצוני (Extrinsic): התאמה בדיעבד של קטעים לטענות

לא דורש Fine-tuning; אפשר להוסיף לצנרת קיימת

מתקשה עם ציטוטים מרובים; לרוב תוצאות לא אופטימליות

עיגון בפרומפט בלבד: הוראות הקשר-בלבד וציטוטים מחייבים

זול ומהיר; StrictCitations נתן את העיגון הגבוה ביותר במחקר הרפואי; נותן מסלול ״לא יודע״

העדפה ולא אכיפה; לא מאמת שציטוט תומך במשפט; מודלים חלשים מצייתים פחות

מקורות לטבלה: VeriCite, PrompTessor, MDPI.

שלבים 4 ו-5: RAG אימות תשובות ברמת הטענה והחלטה על כל טענה

זה לב המדריך, והוא מורכב משני שלבים צמודים: קודם מאמתים כל טענה (שלב 4), ואז מחליטים מה לעשות עם התוצאה (שלב 5).

אימות ברמת הטענה (Claim-level Verification) פירושו לפרק את התשובה לטענות בודדות ולבדוק כל אחת מהן מול הראיות שנשלפו. במקום לשאול ״האם התשובה טובה?״, שואלים עשר שאלות קטנות: ״האם הטענה הזו נתמכת בקטע הזה?״.

איך VeriCite עושה את זה

VeriCite מציע תהליך בשלושה שלבים:

  1. תשובה ראשונית: המודל מייצר תשובה, והטענות בה מאומתות באמצעות מודל NLI (Natural Language Inference).
  2. בחירת ראיות תומכות: המערכת בוחרת את הקטעים שבאמת תומכים בכל טענה.
  3. שכתוב סופי: התשובה מעודכנת על בסיס הטענות שאומתו והראיות שנבחרו.

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

מה זה NLI ולמה הוא מתאים

מודל NLI מקבל שני טקסטים, הנחה (Premise) והשערה (Hypothesis), ומסווג את היחס ביניהם: נגזרת (Entailment), סתירה (Contradiction) או ניטרלי. בהקשר של RAG, הקטע שנשלף הוא ההנחה והטענה מהתשובה היא ההשערה.

Boolean & Beyond מונים בדיקת נאמנות מבוססת NLI בין טכניקות אימות הפלט.

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

מימוש בסיסי

הקוד הבא הוא שלד שמדגים את הזרימה. הפונקציות extract_claims ו-judge_support הן נקודות חיבור למודל שבוחרים, NLI או LLM:

from dataclasses import dataclass

@dataclass
class ClaimResult:
    claim: str
    original_id: str | None   # המזהה שהמודל ציטט
    final_id: str | None      # המזהה שנמצא תומך בפועל
    verdict: str              # 'supported' | 'contradicted' | 'not_enough_info'

def extract_claims(answer: str) -> list[dict]:
    # מפרק את התשובה לטענות אטומיות, כל אחת עם מזהה המקור שצוטט
    # אפשר לממש עם LLM שמחזיר JSON: [{'claim': ..., 'cited_id': ...}]
    ...

def judge_support(premise: str, hypothesis: str) -> str:
    # מחזיר 'supported' / 'contradicted' / 'not_enough_info'
    # מימוש עם מודל NLI או עם LLM Judge
    ...

def verify_answer(answer: str, docs: dict[str, str]) -> list[ClaimResult]:
    results = []
    for item in extract_claims(answer):
        claim = item['claim']
        original_id = item.get('cited_id')
        final_id, verdict = None, 'not_enough_info'

        # 1. בודקים את המקור שצוטט, אם הוא בכלל נמצא בין המסמכים שנשלפו
        if original_id in docs:
            final_id = original_id
            verdict = judge_support(docs[original_id], claim)

        # 2. מקור חסר, מומצא או לא תומך: מחפשים תמיכה בשאר המסמכים שנשלפו
        if verdict != 'supported':
            for other_id, text in docs.items():
                if other_id == original_id:
                    continue
                if judge_support(text, claim) == 'supported':
                    final_id, verdict = other_id, 'supported'
                    break

        results.append(ClaimResult(claim, original_id, final_id, verdict))
    return results

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

שנית, העלות. בכל טענה שלא נתמכה במקור המצוטט, חיפוש הגיבוי יכול להוסיף עד k קריאות למודל האימות. עם k=5 זה סביר; עם k=20 כדאי לשקול לאמת רק טענות קריטיות, או להשתמש במודל NLI קל לסינון ראשוני.

שלב 5: לתקן, לסייג, להסיר או להימנע

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

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

אחרי ההחלטה, התשובה נבנית מחדש רק מהטענות ששרדו. אפשר לעשות זאת בקריאה נוספת למודל עם הוראה מפורשת להשתמש בטענות המאומתות בלבד, בדומה לשלב השכתוב הסופי של VeriCite.

ההחלטה מתי להימנע לגמרי היא החלטה עסקית. בשאלה על שעות פתיחה, טענה אחת לא נתמכת אפשר פשוט להסיר. בשאלה על מחיר, תנאי אחריות או נושא משפטי, עדיף להימנע לגמרי מאשר לשלוח תשובה חלקית שנשמעת שלמה.

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

התאמה לעברית ולבוטים בוואטסאפ

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

מורפולוגיה עברית והשפעתה על האחזור

בעברית מילים מקבלות תחיליות (ה, ב, ל, ו, וגם ש ו-מ) ונטיות. ״למשלוח״, ״והמשלוח״ ו״משלוחים״ הן מילים שונות עבור חיפוש מילולי פשוט.

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

איכות מודלי Embedding ו-NLI בעברית

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

לפני שמשתמשים במודל NLI או ב-LLM Judge על טענות בעברית, יש לבנות סט קטן של זוגות טענה-קטע בעברית עם תיוג ידני ולמדוד עליו את דיוק המודל. אם הדיוק נמוך, יש שתי אפשרויות עיקריות:

  • LLM Judge עם תמיכה טובה בעברית, שנבדק על אותו סט.
  • תרגום הטענה והקטע לאנגלית לצורך האימות בלבד, תוך מודעות לכך שהתרגום עצמו מוסיף שכבת שגיאה.

תשובות קצרות בוואטסאפ

הודעות וואטסאפ קצרות מטבען, ולכן סביר שיתאימו להן תשובות של משפט עד שלושה עם הפניה למקור. ציטוט בפורמט [doc-14] לא אומר כלום ללקוח; עדיף להמיר אותו בשלב האחרון לשם מסמך קריא (״לפי מדיניות ההחזרות״) או לקישור.

מי שבונה בוט כזה מאפס יכול להיעזר במדריך על הקמת צ'אטבוט בוואטסאפ לעסק, ולהוסיף מעליו את שכבת האימות שתוארה כאן. מבנה מומלץ לתשובה בוואטסאפ:

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

זמן תגובה

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

מדידה ומגבלות: איך יודעים שהאימות עובד ומתי לערב אדם

בדיקת דיוק תשובות AI לא יכולה להישען על תחושת בטן או על כמה שיחות ניסיון. צריך מדדים, צריך להבין מה כל מדד מודד, וצריך להכיר את הגבולות של השרשרת כולה.

המדדים המרכזיים

  • Faithfulness / Groundedness: לפי Kinde, זהו מדד ישיר להזיה. נאמנות נמוכה פירושה שהמודל ממציא מידע.
  • Answer Relevancy: האם התשובה עונה על השאלה שנשאלה. מדד נפרד מנאמנות; תשובה יכולה להיות נאמנה לחלוטין למסמכים ועדיין לא רלוונטית.
  • Context Precision: איזה חלק מהמסמכים שנשלפו רלוונטי בפועל.
  • Context Recall: האם כל המידע הנדרש לתשובה נשלף.
  • Citation Accuracy: שיעור הציטוטים שגם קיימים וגם תומכים בטענה.
  • התנהגות הימנעות: האם הבוט נמנע כשצריך, ולא נמנע כשהתשובה קיימת במסמכים.

כלים כמו RAGAS ו-DeepEval מספקים מדדים כמו faithfulness, context precision ו-answer relevancy. עם זאת, Panos Alexopoulos מזהיר שהמדדים האלה קלים לחישוב אבל גם קלים להבנה שגויה וליישום לא נכון.

ציון faithfulness גבוה לא אומר שהתשובה נכונה, אלא רק שהיא נאמנה למה שנשלף. אם נשלף מסמך מיושן, תשובה נאמנה לו תהיה שגויה.

מספרים להקשר, עם הסתייגות

Boolean & Beyond טוענים ששיעור ההזיה יורד מ-15-25% ב-RAG נאיבי לפחות מ-3% במערכת מהונדסת היטב. זו טענה של ספק, בלי מתודולוגיה מפורסמת, וכך גם נתוני השיפור של Reranking ושל חיפוש היברידי שהוזכרו בשלב 1.

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

להפוך כשלים לבדיקות רגרסיה

ההמלצה המעשית ביותר של PrompTessor היא להפוך כשלים חשובים לבדיקות רגרסיה. כל פעם שהבוט נתפס בתשובה שגויה, השאלה, המסמכים הצפויים והתשובה הנכונה (או ההימנעות הנכונה) נכנסים לסט קבוע שרץ לפני כל שינוי בפרומפט, במודל או בחיתוך המסמכים.

REGRESSION_CASES = [
    {
        'question': 'כמה עולה משלוח לאילת?',
        'expected_docs': ['doc-31'],
        'must_contain': ['49'],
        'must_abstain': False,
    },
    {
        'question': 'אפשר לקבל החזר אחרי 60 יום?',
        'expected_docs': ['doc-07'],
        'must_abstain': False,
        'must_not_contain': ['כן, אפשר'],
    },
    {
        'question': 'מה דעתכם על המתחרים?',
        'expected_docs': [],
        'must_abstain': True,
    },
]

הערכים בדוגמה הם להמחשה בלבד. החשוב הוא המבנה: כל מקרה בודק גם את האחזור (expected_docs), גם את התוכן וגם את ההחלטה להימנע.

המגבלות של השרשרת כולה

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

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

מתי להעביר לנציג אנושי

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

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

שאלות נפוצות

למה RAG עדיין נותן תשובות שגויות בביטחון?

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

האם מספיק לכתוב למודל ״אל תמציא״?

לא. זו העדפה ולא מנגנון אכיפה. צריך גבולות ברורים לראיות, כללי הימנעות, ציטוטים ואימות אחרי היצירה (PrompTessor).

האם ציטוט מקור מוכיח שהתשובה נכונה?

לא. ציטוט לא יכול להוכיח שהמקור תומך במשפט שלידו (PrompTessor). לכן הבדיקה כוללת שני חלקים: בדיקה בקוד שהמזהה המצוטט נמצא ברשימת המסמכים שנשלפו, כפי שמציעים Boolean & Beyond, ובדיקה שהקטע אכן תומך בטענה, למשל באמצעות NLI.

מה זה אימות ברמת הטענה?

פירוק התשובה לטענות בודדות ובדיקה של כל אחת מול הראיות שנשלפו. VeriCite מאמת טענות עם מודל NLI; טענות נתמכות נשמרות, ולא נתמכות מתוקנות, מסויגות או מוסרות (VeriCite).

איך למנוע הזיות בצ'אטבוט כשאין מספיק מידע במסמכים?

להגדיר הודעת הימנעות קבועה, כמו ״אין לי מספיק מידע על כך במסמכים הזמינים״, ולתת למודל אישור מפורש להשתמש בה. אם מסמכים רלוונטיים קיימים אבל לא נשלפים, יש לתקן קודם את האחזור (Boolean & Beyond).

איך מודדים שהאימות עובד?

עוקבים אחרי faithfulness, context precision ו-recall, דיוק ציטוטים והתנהגות הימנעות על סט שאלות מייצג, והופכים כל כשל חשוב לבדיקת רגרסיה (PrompTessor). נתוני שיפור שמפרסמים ספקים יכולים לשמש כיוון, אבל לא תחליף למדידה על הנתונים של העסק.

סיכום

RAG לא מבטל הזיות; הוא רק משנה את מקורן. כשל אחזור גורם למודל לנחש, וכשל ציות גורם לו לחרוג ממה שקיבל. RAG אימות תשובות מטפל בשניהם בחמישה שלבים: מתקנים את האחזור באמצעות חיפוש היברידי, Reranking וחיתוך נכון; מגבילים את המודל להקשר בלבד ונותנים לו מסלול לגיטימי לומר ״לא יודע״; מחייבים ציטוטים ובודקים בקוד שהם קיימים; מפרקים את התשובה לטענות ומאמתים כל אחת מול הראיות עם NLI או LLM Judge; ולבסוף מחליטים לגבי כל טענה אם לשמור, לתקן, לסייג, להסיר או להימנע.

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

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

מקורות

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

וואטסאפ