🎓 מפתחי בינה מלאכותית - GenAI Engineers

RAG - Retrieval Augmented Generation

RAG הוא דפוס הנדסי שמחבר מודל שפה עם שכבת שליפה (Retrieval) ממאגר ידע, כך שהתשובה "נשענת" על מקורות אמיתיים במקום להסתמך על זיכרון המודל בלבד.

1) התמונה הגדולה: איפה RAG יושב בארכיטקטורה

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

2) Chunking - האמנות שמחליטה אם RAG עובד

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

3) Retrieval - וקטורים, היברידי, וריראנק

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

• Vector search: טוב למשמעות, פרפרזות, ושאלות "רכות".
• Lexical (BM25): טוב למונחים מדויקים, קודים, שמות, מספרים.
• Reranker: מודל קטן (cross-encoder) שמדרג מחדש את top-k לפי התאמה מדויקת לשאלה.

4) Prompt Assembly - איך "מכניסים" את המקורות למודל

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

System:
You are a helpful assistant. Answer ONLY from the provided sources.
If the answer is not in the sources, say "I don't know".

User:
Question: {question}

Sources:
[1] {chunk_1_text}
[2] {chunk_2_text}
...

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

5) RAG ב-FastAPI - Endpoint לדוגמה

הדוגמה הבאה מראה שירות מינימלי: מקבלים שאלה, מבצעים retrieval, מרכיבים prompt, ושולחים ל-LLM. בפועל תחליף את הפונקציות placeholder למימוש אמיתי (FAISS/pgvector + ספק מודל).

from fastapi import FastAPI
from pydantic import BaseModel, Field

app = FastAPI(title="RAG API", version="1.0")

class AskRequest(BaseModel):
    question: str = Field(min_length=5, max_length=2000)
    top_k: int = Field(default=5, ge=1, le=20)

class Source(BaseModel):
    id: str
    text: str
    title: str | None = None
    page: int | None = None

class AskResponse(BaseModel):
    answer: str
    sources: list[Source]

def embed_text(text: str) -> list[float]:
    # TODO: use embedding model (local or API)
    raise NotImplementedError

def retrieve(query_vec: list[float], top_k: int) -> list[Source]:
    # TODO: vector search + metadata filters + optional rerank
    raise NotImplementedError

def call_llm(prompt: str) -> str:
    # TODO: call your LLM provider
    raise NotImplementedError

@app.post("/api/v1/ask", response_model=AskResponse)
def ask(payload: AskRequest):
    qvec = embed_text(payload.question)
    sources = retrieve(qvec, payload.top_k)

    sources_block = "\n".join(
        [f"[{i+1}] {s.text}" for i, s in enumerate(sources)]
    )
    prompt = f\"\"\"You are a helpful assistant. Answer ONLY from the provided sources.
If the answer is not in the sources, say: I don't know.

Question: {payload.question}

Sources:
{sources_block}
\"\"\"
    answer = call_llm(prompt)
    return AskResponse(answer=answer, sources=sources)

6) מדידה והערכה - איך יודעים שזה עובד

RAG נופל בדרך כלל על "שליפה". לכן ההערכה מתחלקת לשניים:

תרגול

POST /api/v1/ask
{
  "question": "string",
  "top_k": 5
}

Response:
{
  "answer": "string",
  "sources": [{"id":"...", "title":"...", "page":1, "text":"..."}]
}

curl -X POST http://localhost:8000/api/v1/ask \
  -H "Content-Type: application/json" \
  -d '{"question":"מה זה RAG ולמה הוא שימושי?","top_k":5}'

from fastapi.testclient import TestClient
from rag_api import app

client = TestClient(app)

def test_ask_returns_sources():
    r = client.post("/api/v1/ask", json={"question":"define RAG", "top_k":3})
    assert r.status_code == 200
    data = r.json()
    assert "answer" in data
    assert "sources" in data
    assert isinstance(data["sources"], list)

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