Lesson 64 — Beginner

ReAct, Planning & Reflection

ReAct ka funda seedha hai: model baar baar sochta hai, act karta hai, aur observation dekhta hai — yahi cycle repeat hoti hai jab tak jawab na ban jaaye. Is lesson mein pehle framework ke bina loop khud likhoge, phir plan-first execution, reflection/self-correction aur loop protection dekhenge.

ReAct pattern kya hai

User: "Delhi office ka wifi theek karwao."
Thought: pehle device ka status dekhna padega
Action:   get_device_status(device="router-2")
Observation: router down hai, last reboot 3 din pehle
Thought: status clear hai — ticket bana kar dikhata hoon
Action:   create_ticket(device="router-2", priority="high")
Observation: ticket id T-1183 ban gaya
Thought: ab jawab de sakta hoon
Answer:   Router down mila — ticket T-1183 bana diya hai.

Practical mein Thought field alag se print karne ki zarurat nahi — model ke messages (tool calls + observations) hi uski soch ka record hain. Loop ka kaam sirf yeh hai ki observation ko agle call tak pahunchao.

Loop khud likho — pehle framework nahi

Framework se pehle ek baar loop haath se likho — tabhi tumhe har guard ka pata chalega jo framework chhupa deta hai. Yehi loop framework ke andar bhi chalta hai.

MAX_STEPS = 8

def react(goal, tools, llm):
    messages = [{"role": "user", "content": goal}]
    seen = set()  # ek hi action dobara-dobara na chale
    for step in range(MAX_STEPS):          # hard ceiling
        reply = llm(messages, tools=tools)
        if not reply.tool_calls:
            return reply.content            # model ne finish kar diya
        for call in reply.tool_calls:
            key = (call.name, sorted(call.args.items()))
            if key in seen:
                obs = "yehi call pehle ho chuki — kuch alag try karo"
            else:
                obs = run_tool(call.name, call.args)
                seen.add(key)
            messages += [reply, tool_msg(call.id, obs)]
    return "max steps khatam — budget ke andar jawab nahi bana"

Step-by-step vs plan-first

• Step-by-step: har turn par chhota sa decide. Flexible — har observation ke baad rasta badal sakta hai. Lamba task ho toh zyada calls, aur model beech ka goal bhool sakta hai.
• Plan-first: pehle poora plan banao (subtasks list), phir execute. Structure milta hai, progress dikhta hai, model ka focus baandhta hai.
• Plan revise karo, ratna nahi: koi subtask fail ho, naya constraint aaye, reality plan se alag nikle — plan update karo. Rigid plan sabse common failure hai.
• Hybrid chalta hai: plan banaya, ek-ek step execute, har step ke baad plan check — agar 2+ baar revise ho raha hai toh plan-first ka fayda hi nahi tha.

Reflection & self-correction

Reflection ka matlab: result aane ke baad usey check karna — kami mili toh dobara try karna. Action fail ho ya jawab kamzor lage, tabhi lagao — har turn par nahi, warna latency aur cost dono barhte hain.

def reflect_and_retry(messages, answer, rounds=1):
    for _ in range(rounds):
        critique = llm(messages + [{"role": "user", "content":
            "Is jawab mein kamiyaan dhoondho: kaunsa fact missing hai, kaunsa step chhoot gaya, kya galat hai?"}])
        if "koi kami nahi" in critique:
            return answer
        messages.append({"role": "user", "content":
            "Kamiyaan: " + critique + ". Sudhaar kar dobara try karo."})
        answer = llm(messages).content
    return answer  # rounds ki limit — reflection bhi budget mein

Stopping conditions, loop protection aur planning ka cost

• Max steps: har run ka hard ceiling — sabse zaroori guard, pehle hi din se daalo.
• Repetition guard: same (tool, args) dobara dikhe toh force different action ya stop — tumhare loop ka seen-set yahi kaam karta hai.
• Time/token budget: steps kam ho sakte hain par ek bada tool call bhi mehnga ho sakta hai — alag se charge karo.
• Explicit finish: model tool_calls chhod kar final answer de — wahi natural stop hai.
• Planning ka cost: har planning/reflection round ek aur LLM call — quality badhti hai par latency aur token dono. Simple task pe plan/reflect dono hi waste hain.

Exercise

Common mistakes

• Framework se shuruat karna: Abstraction ke peeche loop ke bugs chhupte hain. Pehle 20-line loop khud likho — har guard (max steps, seen-set) tumhe khud padhna hoga, wahi asli seekh hai.
• Reflection har turn par lagana: Har call ke baad critique = extra model call, extra latency, extra token. Sirf failure ya low-confidence par lagao, default par nahi.
• Repetition guard na rakhna: Model aksar ek hi ghalat tool call dohra deta hai. Seen-set ya "yehi call ho chuki" wala observation do — loop turant toot jaata hai.
• Plan ko rigid maanna: Nayi jaankari aaye toh plan update karo. Do-teen baar revise ho raha hai toh plan-first chhodo, step-by-step pe shift ho jao.

plan-first:  origin -> destination (route fixed, signpost follow karo)
step-wise:   dekha -> decide -> act -> observe -> nayi info -> naya raasta
re-plan:     traffic jam -> pura plan update -> aage badho