Lesson 33 — Beginner

Multi-step LLM Workflows

Prompt → model → answer ek hi call hai — asli duniya mein kaam chain hota hai: extract karo, classify karo, route karo, render karo. Is lesson mein hum sequential, routing aur fan-out patterns, task split ka decision rule, haath se banakar composition mein dobara banana, aur workflow vs agent ka farq dekhenge.

⏱ 10 min• Beginner• Designing Good Tools

Workflow kya hai

WHAT

Workflow = ek fixed sequence jisme kayi LLM calls, tools aur plain transformations ek doosre ka input hain. Control flow tumhara code decide karta hai — model sirf ek step hai usme.

WHEN

Jab ek prompt mushkil ya unreliable ho — multi-stage extraction, classification ke baad drafting, ya parallel research. Har stage chhoti = behtar quality aur debuggable.

WHERE

Document processing, content pipelines (extract → summarize → format), report generation, enrichment + routing systems — jahan steps pehle se known hon.

Funda: workflow ka graph tumhare code mein likha hota hai. Kaunsa step kab chalega, kahan branch hai — sab tum decide karte ho, model sirf step ke andar apna kaam karta hai.

Sequential, routing aur fan-out patterns

# 1) SEQUENTIAL — ek ke baad ek, dependency hai
def pipeline(doc):
    facts = llm("Facts nikalo:\n" + doc)            # call 1
    summary = llm("2 bullet summary:\n" + facts)    # call 2
    return render(summary)

# 2) ROUTING — chhote model se decision, phir alag branch
def route(ticket):
    label = llm("BILLING ya TECHNICAL? Sirf label: " + ticket)
    if label.strip() == "BILLING":
        return billing_chain.invoke(ticket)          # branch A
    return tech_chain.invoke(ticket)                 # branch B

# 3) FAN-OUT / FAN-IN — parallel subtasks, phir jodo
def research(topic):
    parts = parallel_map(llm, [
        f"{topic} ke facts", f"{topic} ke risks", f"{topic} ke examples"])
    return llm("In teeno ko mila kar ek paragraph banao:\n" + "\n".join(parts))

Sequential — har step ka output agle ka input. Dependency hai, order fix hai.
Routing — pehle chhote/saste model se category nikaalo, phir us category ka alag chain chalao. Branch ka prompt alag ho sakta hai.
Fan-out/fan-in — independent subtasks parallel chalao, merge step mein jodo. Latency bachti hai.
Conditional branches aur loops chal sakte hain — lekin har branch ka apna test case hona chahiye, warna wo raat mein trigger hota hai.
Beech ke sabhi results log karo — tabhi pata chalega ki kaunsa step galat bol raha hai.

Rule: Routing ke liye chhota model kaafi aksar — uska kaam sirf label dena hai, lamba sochna nahi. Yeh cost aur latency dono bachata hai.

Task ko split kab karna hai

Split karo jab: beech ke result par rok kar check karna ho, har stage ka prompt apna domain ho, format alag-alag ho, ya galti par sirf wahi stage retry honi chahiye.
Mat todo jab: ek hi instruction se kaam ho raha ho — splitting se serial calls badhti hain, latency aur tokens dono kharche.
Round trips ka khayal rakho: 4 sequential calls ≈ 4 guna waiting time — independent steps parallel karo.
Ek bada prompt mein 10 instructions dene se model unme se 4 bhool jaata hai; chhote calls mein har instruction focus mein rehta hai.

Decision rule: Agar beech ka result tumhe chahiye (validate, display, store) toh split karo. Agar beech ka kuch lena-dena hi nahi toh ek bada prompt hi kaafi — layers sirf control ke liye hain, magic ke liye nahi.

Haath se banao, phir compose karo — aur workflow vs agent

from langchain_core.runnables import RunnableLambda

# Wahi do-step pipeline composition mein
chain = (
    ChatPromptTemplate.from_template("Facts nikalo:\n{doc}")
    | ChatOpenAI(model="gpt-4o-mini")
    | StrOutputParser()
    | RunnableLambda(lambda facts: {"facts": facts})
    | ChatPromptTemplate.from_template("2 bullet summary:\n{facts}")
    | ChatOpenAI(model="gpt-4o-mini")
    | StrOutputParser()
)
chain.invoke({"doc": text})

Pehle haath se likho — plain functions mein control flow saaf dikhta hai: kaun kis ka input hai, kahan branch hai.
Phir composition primitives mein convert karo — reuse, streaming, batch sab ek interface se milte hain.
Workflow vs agent: workflow mein tumhara code decide karta hai agla kadam; agent model ko decide karne dete hain kaunsa tool/step agla hai.
Workflow = predictable, testable, kam adaptable. Agent = flexible, zyada autonomous, kam predictable. Dono ke failure modes alag hain.

Interview line: Workflow ka control flow code mein likha hota hai — model usse badal nahi sakta. Agent mein control flow model ke haathon mein hota hai. Yahi asli farq hai, baaki sab marketing terminology hai.

Exercise

Question: Ek ke baad ek dependent LLM calls wale pattern ko kya kehte hain?

Question: Chhoti categories ke hisaab se alag branch par bhejne wale pattern ka naam?

Question: Independent subtasks parallel chala kar ek jagah jodne ko kya kehte hain? (do words, hyphen ke saath)

Question: Workflow ya agent — agla step kaun decide karta hai workflow mein?

Common mistakes

Har chhote kaam ko alag call mein tod dena: — serial round trips se latency aur cost badhti hai. Beech ka result chahiye nahi toh ek hi prompt kaafi hai.
Bade prompt se sab kuch ek saath maang lena: — mixed instructions, mushkil validation, bekaar debugging. Stages karo: alag prompt, alag output, alag check.
Workflow ko agent samajh lena: — fixed pipeline hai jismein control code mein hai. Poocho: agla step kaun decide kar raha hai — answer se approach clear ho jaayegi.
Beech ke results na log karna: — kaunsa step galat bol raha hai pata hi nahi chalega. Har stage ka input/output log mein rakho.

Desi example: Biryani ki assembly line

Ek bada order aaye toh kitchen line lagti hai — har worker ek kaam karta hai. Supervisor category dekh kar alag kadhai bhejta hai (routing), aur do worker parallel kaam kar ke ek plate mein jodte hain (fan-out):

chop -> marinate -> cook -> plate              (sequential)
supervisor: veg ya non-veg? -> alag kadhai     (routing)
chop (ek banda) || rice boil (doosra banda)    (fan-out)
dono -> ek plate                               (fan-in)

Ek banda sab kare = dheere. Roti ke liye poori line lagana = bekaar (over-split).

Interview angle — yahan se sawaal aate hain

Q: Sequential, routing aur fan-out mein farq? — Sequential = dependent steps; routing = category se branch; fan-out = independent calls parallel + merge.
Q: Task ko split kab karna chahiye? — Jab stage-wise validation, alag prompts ya isolated retry chahiye; warna ek bada prompt kaafi.
Q: Workflow aur agent ka farq? — Workflow mein control code mein (fixed graph); agent model khud decide karta hai agla step.
Q: Split karne ki cost kya hai? — Zyada round trips = latency aur tokens badhte hain; independent steps ko parallel karo.

Lesson complete?

Workflows ke patterns clear. Agla lesson — Async, Concurrency & Batching — mein dekhenge ek saath kayi requests kaise chalate hain.