📖 धडा 07 — RAG ची जोडणी: पुस्तक उघडून परीक्षा, आपल्या page-finder सह

📍 तुम्ही इथे आहात: 8 पैकी धडा 07 · मागे: lesson-06-chunking-metadata · पुढे: lesson-08-landscape

📦 या ब्रँचमध्ये काय आहे

धडे 01–06, आणि मोबदला: vector DB ला RAG pipeline मध्ये जोडणे (AI शाळा L10 ची open-book परीक्षा) — जिथे आता प्रत्येक टप्पा तुम्ही बनवलेली किंवा वाचू शकणारी गोष्ट आहे.

🧒 5 वर्षांच्या मुलाला समजावल्यासारखे

AI शाळेची open-book परीक्षा आठवा 📖: योग्य पाने विद्यार्थिनीच्या बाकावर ठेवा आणि उत्तरे grounded आणि पुराव्यासह सांगता येण्याजोगी होतात. कमी पडणारी यंत्रणा होती page-finder — आणि आता तो तुमच्याकडे आहे:

Index च्या वेळी (एकदा, आणि प्रत्येक doc बदलल्यावर):

✂️ handbook चे cards मध्ये तुकडे करा (धडा 06),
🔢 प्रत्येक card ला जागा द्या (embed — धडा 02; प्रत्यक्षात: एक model),
🗄️ जागा + text + stickers साठवा (db.add — धडा 05).

प्रश्नाच्या वेळी (प्रत्येक query ला): 4. 🔢 प्रश्नाला त्याच embedder ने जागा द्या (त्याच model चा नियम!), 5. 🏃 सर्वात जवळची cards (db.search, कदाचित room="3A" ने filter केलेली — धडे 03/04/06), 6. 🪑 सर्वोत्तम cards model च्या बाकावर ठेवा, सूचनेसह "फक्त यांवरूनच उत्तर द्या, card ids सांगा" (AI L08), 7. ✅ grounded उत्तर, source stickers मधून मिळालेल्या पावत्यांसह. 🧾

त्या आकृतीतला प्रत्येक बाण आता तुम्ही वाचलेली code ची ओळ आहे. "जादुई AI search product" म्हणजे सात प्रामाणिक पायऱ्या.

नावाने माहीत असाव्यात अशा दोन प्रौढ सुधारणा: reranking (स्वस्तात top-50 retrieve करा, मग एक हुशार model पुन्हा गुण देऊन नेमके top-5 बनवते — दुसरी, जास्त चोखंदळ ग्रंथपाल) आणि long-context चा प्रश्न ("1M-token चे बाक असताना retrieve तरी कशाला?" — खर्च, latency, आणि lost-in-the-middle सांगतात: retrieval टिकते; बाक मोठा झाला, अमर्याद नाही).

🗺️ आकृती

flowchart LR
    subgraph idx["🗂️ index time - once"]
        d["📚 docs"] --> cut["✂️ chunk"] --> em1["🔢 embed"] --> store["🗄️ MiniVectorDB.add<br/>+ stickers 🏷️"]
    end
    subgraph qt["❓ question time - every query"]
        q["question"] --> em2["🔢 embed - SAME model"] --> s["🏃 db.search k=4<br/>(+ filters)"]
        s --> desk["🪑 desk: cards + 'answer ONLY<br/>from these, cite ids'"]
        desk --> a["✅ grounded answer 🧾"]
    end
    store -.-> s
    rr["🧐 optional: rerank top-50 → top-5"] -.-> s

❓ काय

दोन घड्याळे: index time (batch, बदल झाल्यावर — ArgoCD ची सहजप्रवृत्ती: आज रात्री re-index, उद्या "माहीत") विरुद्ध query time (milliseconds, प्रत्येक प्रश्नाला). वेगळे scaling, वेगळी अपयशे.
अपयश कोणाचे ते ठरवणे (debugging ची कवायत): उत्तर वाईट? model ला दोष देण्याआधी (generation bug → AI L09) आधी कोणती cards परत आली ते तपासा (retrieval bug → धडे 02/06). Cards print करा. नेहमी cards print करा.
k हा एक नॉब आहे: खूप कमी cards → संदर्भ कमी पडतो; खूप जास्त → बाकावर पूर येतो आणि मधला भाग वरवर वाचला जातो. 3–8 ही नेहमीची पट्टी; rerankers मुळे k छोटा आणि नेमका ठेवता येतो.
Agent सारखे eval करा (Agents L06): golden questions → योग्य card ids परत येतात हे assert करा (retrieval recall) आणि उत्तर त्यांचा उल्लेख करते हेही. दोन आकडे, प्रत्येक chunking/embedder बदलावर चालवलेले.

🤔 का

RAG ही industry मध्ये सर्वात जास्त बनवली जाणारी AI system आहे, आणि या धड्यात ती blog वरची आकृती राहत नाही: प्रत्येक box या repo मधला code आहे. कामावर तुमची RAG चुकीचे वागली तर तुम्ही ती टप्प्याटप्प्याने debug कराल — cards → बाक → उत्तर — पुन्हा पुन्हा prompt करून प्रार्थना करण्याऐवजी. 🙏

🧪 करून पाहा — संपूर्ण pipeline एका file मध्ये

python3 - <<'EOF'
import sys; sys.path.insert(0,'vectordb')
from vectordb import MiniVectorDB
db = MiniVectorDB()
for i,(t,meta) in enumerate([
  ("Library books must be returned within two weeks.", {"source":"handbook-p4"}),
  ("The picnic requires one pizza per three students, round up.", {"source":"handbook-p9"}),
  ("Class 3A has twelve students.", {"source":"roster-3A"}),
  ("Class 3B has eleven students.", {"source":"roster-3B"})]):
    db.add(f"card-{i}", t, **meta)

q = "how many pizzas do we need for 3A and 3B together?"
cards = db.search(q, k=3)
print("🪑 THE DESK (what you'd paste to the model):\n")
print(f"Answer ONLY from these cards, cite sources:\n")
for s,i,t,m in cards:
    print(f"  [{m['source']}] {t}")
print(f"\nQuestion: {q}")
print("\n→ paste that block into ANY chatbot: grounded answer, real citations 🧾")
EOF

⏭️ पुढे

शेवटचा भाग: प्रत्यक्ष products — pgvector, Pinecone, Chroma, FAISS आणि मंडळी — आणि bake-off शिवाय निवड कशी करायची: landscape.

git checkout lesson-08-landscape

📖 Lesson 07 — RAG wiring: the open-book exam, with OUR page-finder

📍 You are here: Lesson 07 of 8 · Previous: lesson-06-chunking-metadata · Next: lesson-08-landscape

📦 What's in this branch

Lessons 01–06, plus the payoff: wiring the vector DB into the RAG pipeline (AI school L10's open-book exam) — with every stage now a thing you've built or can read.

🧒 Explain like I'm 5

Remember the AI school's open-book exam 📖: put the right pages on the student's desk and answers become grounded and citable. The missing machinery was the page-finder — and you now own one:

Index time (once, and on every doc change):

✂️ cut the handbook into cards (lesson 06),
🔢 seat each card (embed — lesson 02; real life: a model),
🗄️ store seat + text + stickers (db.add — lesson 05).

Question time (every query): 4. 🔢 seat the QUESTION with the same embedder (the same-model rule!), 5. 🏃 nearest cards (db.search, maybe filtered room="3A" — lessons 03/04/06), 6. 🪑 paste the top cards onto the model's desk with the instruction "answer ONLY from these, cite the card ids" (AI L08), 7. ✅ grounded answer, with receipts from the source stickers. 🧾

Every arrow in that diagram is now a line of code you've read. The "magical AI search product" is seven honest steps.

Two grown-up refinements worth knowing by name: reranking (retrieve top-50 cheaply, then a smarter model re-scores to a sharp top-5 — a second, pickier librarian) and the long-context question ("with 1M-token desks, why retrieve at all?" — cost, latency, and lost-in-the-middle say: retrieval survives; the desk got bigger, not infinite).

🗺️ Diagram

flowchart LR
    subgraph idx["🗂️ index time - once"]
        d["📚 docs"] --> cut["✂️ chunk"] --> em1["🔢 embed"] --> store["🗄️ MiniVectorDB.add<br/>+ stickers 🏷️"]
    end
    subgraph qt["❓ question time - every query"]
        q["question"] --> em2["🔢 embed - SAME model"] --> s["🏃 db.search k=4<br/>(+ filters)"]
        s --> desk["🪑 desk: cards + 'answer ONLY<br/>from these, cite ids'"]
        desk --> a["✅ grounded answer 🧾"]
    end
    store -.-> s
    rr["🧐 optional: rerank top-50 → top-5"] -.-> s

❓ What

The two clocks: index time (batch, on change — the ArgoCD instinct: re-index tonight, "knows" it tomorrow) vs query time (milliseconds, per question). Different scaling, different failures.
Failure attribution (the debugging drill): bad answer? FIRST check what cards came back (retrieval bug → lessons 02/06) before blaming the model (generation bug → AI L09). Print the cards. Always print the cards.
k is a dial: too few cards → missing context; too many → desk floods and the middle gets skimmed. 3–8 is the usual band; rerankers let you keep k small and sharp.
Eval it like an agent (Agents L06): golden questions → assert the right card ids come back (retrieval recall) AND the answer cites them. Two numbers, run on every chunking/embedder change.

🤔 Why

RAG is the most-built AI system in industry, and this lesson is the moment it stops being a diagram from a blog: every box is code in THIS repo. When yours misbehaves at work, you'll debug it by stage — cards → desk → answer — instead of re-prompting and praying. 🙏

🧪 Try it — the whole pipeline in one file

python3 - <<'EOF'
import sys; sys.path.insert(0,'vectordb')
from vectordb import MiniVectorDB
db = MiniVectorDB()
for i,(t,meta) in enumerate([
  ("Library books must be returned within two weeks.", {"source":"handbook-p4"}),
  ("The picnic requires one pizza per three students, round up.", {"source":"handbook-p9"}),
  ("Class 3A has twelve students.", {"source":"roster-3A"}),
  ("Class 3B has eleven students.", {"source":"roster-3B"})]):
    db.add(f"card-{i}", t, **meta)

q = "how many pizzas do we need for 3A and 3B together?"
cards = db.search(q, k=3)
print("🪑 THE DESK (what you'd paste to the model):\n")
print(f"Answer ONLY from these cards, cite sources:\n")
for s,i,t,m in cards:
    print(f"  [{m['source']}] {t}")
print(f"\nQuestion: {q}")
print("\n→ paste that block into ANY chatbot: grounded answer, real citations 🧾")
EOF

⏭️ Next

The finale: the actual products — pgvector, Pinecone, Chroma, FAISS & friends — and how to pick without a bake-off: the landscape.

git checkout lesson-08-landscape

← Previouschunking metadata Next →landscape

This page is the lesson's README from the lesson-07-rag-wiring branch, shown here so the whole School stays on one site. Code files open on GitHub at the same branch.