Lesson 163 — Advanced

Multi-Agent Research Report System

Ek agent se report banwana tab tak chalta hai jab tak kaam chhota ho. Yeh project orchestration dikhata hai: alag roles (plan, research, write, review) ek fixed graph mein chalte hain aur ek shared state pass karte hain.

Project kya hai

Pehla sawaal hamesha yeh ho: kya sach mein multi-agent chahiye? Ek agent + tools + good prompts aksar kaafi hota hai (L5.10). Multi-agent tab justified hai jab parallelism, context isolation ya hard quality gates chahiye.

Roles aur shared state

• Planner: topic → outline[] with per-section research questions (structured output!).
• Researcher (parallel, ek per section): questions → findings[] with sources + confidence.
• Writer: outline + findings → draft markdown (sources inline).
• Critic: draft vs outline + findings → pass ya specific revision notes.
• State: topic, outline, findings (per section), draft, critique, revision_count — ek hi structured object.

Graph — LangGraph skeleton

from typing import TypedDict, Annotated
from langgraph.graph import StateGraph, END
import operator

class ReportState(TypedDict):
    topic: str
    outline: list[dict]
    findings: Annotated[list[dict], operator.add]   # parallel researchers append
    draft: str
    critique: str
    revisions: int

def planner(state):   # topic -> outline
    ...
def researcher(state): # ek section ka kaam (parallel map)
    ...
def writer(state):     # outline + findings -> draft
    ...
def critic(state):     # draft -> critique / pass
    ...

g = StateGraph(ReportState)
g.add_node("plan", planner)
g.add_node("research", researcher)     # fan-out: outline ke har section par
g.add_node("write", writer)
g.add_node("critique", critic)
# routing: plan -> research -> write -> critique -> (pass | write again, max 2)

Kab single agent, kab multi

Interview mein yahi sawaal aata hai — isliye yeh decision table yaad rakho:

• Single agent: chhota task, sab context ek jagah fit, latency sensitive, cost sensitive — default yahi chuno.
• Multi-agent: sections parallel research hone hain (time bachta hai); researcher ko writer ka context chahiye hi nahi (isolation); critic ek hard gate hai jo bina bias ke pass/fail de sakta hai.
• Do NOT multi-agent: just because "agents" trend mein hain — har extra node = extra latency + extra tokens + extra failure modes.

Failure recovery

• Per-node retry limit (1–2) + exponential backoff — unlimited retries ek timeout ko ghanton mein badal dete hain.
• Researcher ka output validate karo: findings empty ya sources bina = section marked incomplete (writer ko incomplete flag ke saath jao).
• Writer ko sirf findings do — context inflation se draft hallucination badhta hai.
• Final report ke end mein limitations section: kya research nahi ho paya. Yeh honesty interview mein bhi point hai.

Exercise

Common mistakes

• Har chhoti cheez ko agent dena: Summarize karne ke liye alag agent, format karne ke liye alag — orchestration overhead kaam se zyada ho jaata hai. Node tab banao jab context/parallel/gate ho.
• Unbounded revision loop: Critic hamesha "improve karo" bole toh writer ghanton tak dohregaa. Revision cap + specific criteria (kya check hua) rakho.
• State bina schema: Dict mein kuch bhi daal dete ho toh agla node todta hai. TypedDict/Pydantic se state lock karo — yahi debugging bachati hai.

plan -> research (parallel, per section) -> draft -> critique
         |                                  ^
         +--- findings (sources ke saath) --+
Yeh arrows hi graph hain — chat mein andhere mein nahi, framework mein chalao.