Lesson 60 — Intermediate

RAG Variants & Advanced Patterns

Baseline RAG har jagah nahi chalta — multi-hop sawaal, weak retrieval, global questions isse pare hain. Is lesson mein hum naive se advanced se adaptive tak ka progression, Self-RAG, CRAG, Adaptive, Iterative, Multi-hop, Graph RAG dekhenge — aur sabse zaroori: failure mode dekh ke architecture kaise choose karte hain.

Naive se Advanced se Adaptive tak

Progression ka matlab upgrade nahi kiya jaata — layer add hoti hai. Baseline phir bhi backbone hai; adaptive patterns uske upar guards aur loops hain. Har layer apni latency aur cost laati hai.

Self-RAG, CRAG aur Adaptive RAG

def adaptive_step(query, ctx, draft=None):
    grade = llm(GRADE_PROMPT.format(query=query, context=ctx))
    if grade == "NO_QUERY":          # Adaptive: retrieval hi nahi chahiye
        return {"action": "answer_directly"}
    if grade == "BAD_CONTEXT":       # CRAG: corrective re-retrieve
        return {"action": "retrieve_again", "rewrite": rewrite(query)}
    if grade == "MISSING_HOP":       # Self-RAG: ek aur fact chahiye
        return {"action": "retrieve_more", "subquery": next_hop(query, draft)}
    return {"action": "keep"}

• Self-RAG: model khud decide karta hai retrieval karni hai ya nahi, aur phir apne jawab ko evidence pe reflect karta hai — critique tokens se.
• CRAG (Corrective RAG): retrieved context grade hota hai; weak ho toh corrective retrieval + rewrite — retrieval ke baad guard.
• Adaptive RAG: query ke type pe decide — direct answer, retrieval, ya re-retrieve. Router jaisa behaviour.
• Teeno mein extra LLM calls hain — grading, reflection, rewriting. Har step latency bill laata hai.

Iterative aur Multi-hop RAG

def iterative_rag(query, max_hops=4):
    evidence, sub_q = [], query
    for _ in range(max_hops):
        hits = hybrid_search(sub_q, k=5)
        evidence.extend(hits)
        if enough(evidence, query):
            break
        sub_q = next_subquery(query, evidence)   # multi-hop ka agla sawaal
    return synthesize(query, dedupe(evidence))

# multi-hop example:
# Q: "Acme ne X kab acquire kiya, uske baad policy kya hui?"
# hop1: Acme-X acquisition date -> doc A
# hop2: "uske baad" wali policy  -> doc B (date filter ke saath)

• Iterative: retrieve → synthesize → check → aur retrieve, jab tak evidence enough na ho (max hops zaroori — warna loop infinite).
• Multi-hop: ek hi sawaal 2+ steps maangta hai — pehle hop ka jawab doosre hop ka query banta hai.
• Next subquery LLM se banwao: "ab kya jaanna hai jo abhi evidence mein nahi hai?" — yehi plan-out hai.
• Evidence dedupe karo aur hop ka budget fix — 2-4 hops mein aksar sab cover ho jaata hai.

Graph RAG

Graph RAG mein knowledge ko entities aur unke relationships ke graph mein store karte hain — vector similarity ke saath saath traversal. Seed entity se neighbourhood expand karke jawab banta hai, aur community-level summarization se global sawaal hote hain.

• Kya represent karta hai: entities (log, orgs, products) aur unke relations (acquired, reports_to, uses) — adjacency mein.
• Kab useful: highly connected knowledge, cross-document relationships, entity-centric queries, "sabse bade... kaun" wale global sawaal.
• Kharcha: entity/relation extraction (LLM calls), graph store alag, maintenance — ingestion complex ho jaata hai.
• Vector search + graph traversal ko hybrid kiya ja sakta hai — dono ek doosre ko complement karte hain.

Failure mode se architecture choose karna

• Weak retrieval: chunking/hybrid/rewrite sudharo — CRAG ka grading tab kaam aata hai jab weak results pehle se aa rahe hon.
• Multi-step questions: iterative/multi-hop — loop ke saath, max-hops budget ke saath.
• Entity-relationship questions: Graph RAG — par sirf jab ye failure class dominant ho.
• Comparison parameters: quality gain, complexity, latency, cost, aur jo failure solve ho raha hai — ye 5 cheezein table mein likho.
• Sabse common galti: "advanced = better" maan ke Graph/Adaptive shuru kar dena — baseline strong ho toh complexity hi milegi.

Exercise

Common mistakes

• Har project mein Graph RAG shuru kar dena: Banane ka kharcha sabse zyada, maintenance bhi. Fix: pehle hybrid+rerank exhaust karo; graph sirf jab relationships hi failure ho.
• Self-correcting loop bina max-iterations ke: Loop ghoomta rehta hai, LLM calls badhti jaati hain, bill explode. Fix: max-hops/max-retries hamesha fix karo, log mein hops count.
• Advanced pattern bina failure diagnose kiye: Kya toot raha hai pata hi nahi, pattern laga diya. Fix: pehle retrieval vs generation failure alag karo (M4.8), phir pattern choose.

lead mili -> kaafi hai?      (Adaptive: skip vs proceed)
kaafi nahi? -> grade karo    (CRAG: re-retrieve + rewrite)
abhi bhi missing? -> agla subquery (multi-hop, max 4)
network case? -> entity graph trace (Graph RAG)
budget hamesha: max hops + max LLM calls