Lesson 102 — Advanced

Context & Knowledge Architecture

Model ke andar ki knowledge kaafi nahi — sahi waqt par sahi information kahan se aayegi, yahi knowledge architecture hai. Is lesson mein knowledge ke sources, poora context pipeline (ingestion se generation tak), hybrid retrieval aur production concerns — freshness, access control, provenance — cover honge.

Knowledge aaye kahan se — 5 sources

Ek decision table hi architecture hai: static + universal → model knowledge; current + public → tools/search; private + vast → RAG; user-specific + durable → memory. Source chunna pehle, prompt baad mein.

Poora context pipeline — ingestion se generation tak

ingestion  -> docs parse, chunk, embed, index (+ metadata, ACL tags)
retrieval  -> query se top-k candidates (vector / keyword / graph)
reranking  -> chhote model se precision order (top-k tight karo)
assembly   -> chunks + instructions + history pack (L6.2)
generation -> model jawab + source references deta hai

har stage par: log (kya aaya, kya gaya) — warna leak dikhega nahi

Har stage ka apna failure hai: ingestion mein galt parse, retrieval mein galat query, reranking mein budget, assembly mein kachra, generation mein hallucination. Stage-wise logging ke bina ye pata hi nahi chalega ki leak kahan hai.

Hybrid retrieval — vector, keyword, graph

Vector se meaning, keyword se exact match (naam, error string, code identifier), graph se relations. Ek method har query par nahi chalta — hybrid se coverage badhti hai, aur reranker precision sambhaalta hai.

def hybrid(query, k=10):
    vec = index.vector_search(query, k=k)    # meaning
    kw  = index.bm25_search(query, k=k)      # exact terms
    fused = rrf([vec, kw])                    # scores alag scale ke — rank se jodo
    return rerank(fused, query)[:5]

def rrf(rank_lists, c=60):
    scores = {}
    for lst in rank_lists:
        for i, doc in enumerate(lst, start=1):
            scores[doc] = scores.get(doc, 0) + 1 / (c + i)
    return sorted(scores, key=scores.get, reverse=True)

Freshness, access control aur scale

• Freshness: index mein har doc ka updated_at, aur re-index schedule data ki volatility se — legal docs mahine mein, tickets roz. Stale index = stale jawab.
• Access control: permission filter retrieval SE pehle lagao (metadata filter). Context mein daal kar baad mein check karna bahut der ho chuki hoti hai.
• Provenance: har chunk par source + version — galat source ka jawab trace karke fix kar sakte ho.
• Scale: badhte corpus par sharding (department/user ke hisaab se) aur incremental indexing — full re-index kabhi-kabhi hi.

Dynamic retrieve vs context mein hold

• Always in context: rules, safety, core tool defs — chhote, stable, har call chahiye (prompt caching milta hai, L9.5).
• Dynamically retrieved: docs, tickets, DB rows — demand par, use ke baad hatao. Bada corpus ho toh yahi default.
• External with recall: memory/user profile — chhota curated set, search se wapas laao (L6.4 offload).
• Rule of thumb: stable + chhota + zaroori = hold; bada + changing + rare = retrieve. Context budget (L6.1) hi final judge hai.

Exercise

Common mistakes

• ACL assembly ke baad lagana: Protected chunk context mein aa chuka hai toh leak ho chuka — validation nahi, prevention chahiye. Retrieval-time metadata filter hi sahi jagah hai.
• Sirf vector search ka bharosa: Exact terms, IDs aur error strings vector mein ghum jaate hain. Hybrid (vector + keyword) + reranker se coverage aur precision dono aati hain.
• Freshness ka plan na hona: Puraana index puraana jawab deta hai — user hi confuse. updated_at + re-index schedule likho design mein, ticket aane se pehle.

query -> index dhoondhe (vector + keyword)
     -> top 20 se top 5       (rerank)
     -> page numbers ke saath tumhare haath
# Poora shelf table pe = context blast — librarian aisa nahi karta