Lesson 29 — Beginner

LangChain Fundamentals

Do provider SDK, paanch prompt versions, parsing, retries — code jaldi faila hota hai. LangChain ek orchestration layer hai jo in sabko ek pipeline mein jodta hai. Is lesson mein hum chat models, prompt templates, output parsers, runnables dekhenge aur raw SDK ke saath side-by-side compare karenge.

LangChain kya hai — layer, model nahi

Mental model: LangChain = waiter, model = kitchen. Waiter order le jaata hai, dish laata hai, plate set karta hai — khaana kitchen banata hai. Waiter badalne se khana nahi badalta, bas service badalti hai.

Chat models, prompt templates aur output parsers

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.2)

prompt = ChatPromptTemplate.from_messages([
    ("system", "Tum ek ticket classifier ho. Sirf ek label do: BILLING ya TECHNICAL."),
    ("user", "Ticket: {ticket}"),
])

parser = StrOutputParser()          # AIMessage se seedha string

chain = prompt | llm | parser
print(chain.invoke({"ticket": "App crash ho raha hai login ke baad"}))

# Model configuration ek jagah set ho jaati hai — har call par nahi
llm = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0,
    max_tokens=500,
    timeout=20,
    max_retries=2,      # SDK-level retry — app-level retry alag (M2.9)
)

• ChatModel provider SDK ko wrap karta hai — .invoke() se ek message, .stream() se chunks, .batch() se kayi inputs ek saath.
• PromptTemplate — {ticket} jaisi jagah chhod do, values baad mein do. Prompt ek hi jagah rehta hai, typo ek hi jagah pakda jaata hai.
• OutputParser — model AIMessage deta hai; StrOutputParser plain string bana deta hai. JSON aur schema ke liye structured parsers (M2.4).
• Har message ka role wahi rehta hai jo raw API mein tha — LangChain sirf construction aasan karta hai.

Runnable composition — pipe se pipeline

chain = prompt | llm | parser           # | ka matlab: sequence (LCEL)

chain.invoke({"ticket": "..."})                     # ek input -> ek output
list(chain.stream({"ticket": "..."}))               # streaming wahi chain
chain.batch([{"ticket": "A"}, {"ticket": "B"}])     # do inputs ek saath

# Apna Python function bich mein daalo
from langchain_core.runnables import RunnableLambda

def add_tag(text):
    return text.strip().upper()

pipeline = prompt | llm | parser | RunnableLambda(add_tag)

• Har step ek Runnable hai — same .invoke / .stream / .batch interface har jagah. Isliye chain todna ya jodna aasan hota hai.
• | operator sirf RunnableSequence ko chhupa deta hai — upar se padhna aasan, andar wahi kaam chalta hai.
• RunnableLambda se app logic (validate, format, DB write) pipeline mein hi baith jaata hai — lekin debugging mein yahi chhupa logic sabse zyada paresaan karta hai.
• Chhota pipeline pehle plain Python functions se banao, phir LCEL mein convert karo — dono versions ka control flow samajh aana chahiye.

Raw SDK vs LangChain — same kaam, do tareeke

# RAW SDK
resp = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "system", "content": SYS}, {"role": "user", "content": ticket}],
    temperature=0,
)
label = resp.choices[0].message.content.strip()

# LANGCHAIN
prompt = ChatPromptTemplate.from_messages([("system", SYS), ("user", "{ticket}")])
label = (prompt | ChatOpenAI(model="gpt-4o-mini", temperature=0) | StrOutputParser()) \
    .invoke({"ticket": ticket})

• Raw SDK: control poori, dependencies kam, provider-specific. Ek provider aur chhota app ho toh raw best.
• LangChain: templates, provider switching, uniform streaming/batch interface, ready integrations. Chain lambi ho toh aasan padta hai.
• Overhead: har step ka apna object model hai — stack trace padhna mushkil, version upgrades break karte hain. Convenience ki ye keemat hai.
• Interview mein sahi line: "LangChain ek abstraction layer hai — niche wahi HTTP call hoti hai jo raw SDK karti hai."

Exercise

Common mistakes

• LangChain ko model samajh lena: — model provider ka hota hai, LangChain sirf orchestrate karta hai. Debug karne par kabhi-kabhi raw HTTP call print karke dekho, confusion door ho jaayegi.
• Control flow samjhe bina framework mein code likh dena: — "|" pipeline mein kaun kya karta hai pata na ho toh error aane par nahi niklega. Pehle plain functions, phir composition.
• Har step ko equally reliable maanna: — parser ya template fail hua toh chain ka output garbage ban jaata hai. Steps ka apna validation rakho, khaskar JSON output par.
• Framework ke bina kaam nahi chalega sochna: — chhote scripts ke liye ek SDK call kaafi hai. LangChain tabhi jabho jab steps, reuse aur switching wakai zarurat hon.

Raw SDK   : stand pe khud bolo -> seedha driver, poora control
LangChain : app se book karo   -> uniform interface, swap aasaan
Neeche    : dono mein gaadi wahi engine chal rahi hai (HTTP call)

App band ho toh auto nahi rukta — layer hatane par bhi API zinda hai.