Lesson 61 — Intermediate

RAG with Frameworks

Ab tumne RAG khud likha hai — ab framework ka code padhne mein maza aayega. Is lesson mein hum LlamaIndex/LangChain style abstractions (indexes, retrievers, query engines, rerankers), rerank aur query transforms framework se, aur framework vs hand-built ka farq dekhenge.

Framework kya deta hai

Framework ka asli faayda connectors aur integration hai — naya data source (Notion, DB, web) jodna ek class change. Logic (fusion, thresholds) tumhara apna — framework sirf plumbing deta hai.

Hand-built pipeline ka framework rebuild

# LlamaIndex style (naam representative; API framework versions ke saath badalti hai)
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

docs = SimpleDirectoryReader("data").load_data()   # M4.1 ka loader
index = VectorStoreIndex.from_documents(docs)      # chunk + embed + store
engine = index.as_query_engine(similarity_top_k=5) # retrieve + prompt + LLM
print(engine.query("Refund policy kaise hoti hai?"))

# LangChain style: retriever + chain
# retriever = store.as_retriever(search_kwargs={"k": 5})
# chain = prompt | retriever | llm
# answer = chain.invoke("Refund policy kaise hoti hai?")

• Loader → splitter → index: tumhara extract-chunk-embed, framework ke ingestion ke andar.
• Query engine: retrieve + assemble + generate ka ek call — tumhara rag(query).
• Source nodes: answer ke saath retrieved chunks wapas aate hain — tumhare hits jaise.
• Import paths framework versions ke saath badalte rehte hain — docs dekh ke likho, rat ke nahi.

Indexes, retrievers, rerankers, transforms

# Framework components = tumhare hand-built steps
qengine = index.as_query_engine(
    similarity_top_k=20,                  # wide recall (M4.5)
    node_postprocessors=[rerank(top_k=4)],  # M4.10 ka rerank stage
)

# query transforms bhi components hain:
# query_transform = multi_query(3)       # M4.11 ka rewriting
# fusion = rrf_fusion(...)               # M4.6 ka fusion
# sab ek hi pipeline mein plug-in

• Retriever interface: dense, sparse, hybrid — sab ek interface ke peeche; switch karna aasaan.
• Node postprocessors: rerank, metadata filter, dedupe — retrieve ke baad wale steps yahan hote hain.
• Query transforms: rewrite, multi-query, HyDE — retrieve se pehle wala step.
• Citation: source nodes se answer ke claims map hote hain — tumhara cited_ids wala parser framework ke andar bhi chahiye.

Framework vs hand-built

• Speed: framework se pehla working demo ghanton mein; hand-built mein din (par seekhna bhi milta hai).
• Control: fusion logic, custom scoring, thresholds — hand-built mein sab tumhare haath mein; framework ke abstraction ke andar kabhi kabhi force karna padta hai.
• Debugging: framework ke andar kya hua kabhi kabhi leak nahi hota; hand-built mein har step print kar sakte ho.
• Complexity: framework ka dependency tree, version upgrades, breaking changes — ek aur maintenance surface.
• Rule: learning/one-off → hand-built pehle; production timeline + connectors → framework, apne logic ke saath.

Exercise

Common mistakes

• Framework ke peeche mechanics bhool jaana: Black box pe bharosa — jab kuch bigde toh debug hi nahi hoga. Fix: hand-built pipeline tha hi isliye; framework ke nodes ko print karke map karo.
• Rat ke API likhna: Import paths versions ke saath badalte hain — purana example chalega hi nahi. Fix: concept yaad rakho (retriever, postprocessor), exact API docs se lo.
• Apna logic framework mein force karna: Custom fusion framework ke abstraction se takra raha hai — hours jaate hain. Fix: apna logic framework ke bahar rakho, framework se sirf components lo.

cycle  (hand-built): retrieve + assemble + rag sab tumhara
car    (framework) : loader + index + query engine ready
tumhara edge: clutch-gear samajh = mechanics pata hai
failover: car kharab? -> cycle pipeline abhi bhi chalti hai