Part 2: LangChain के साथ अपना पहला AI Agent बनाएं: एक Practical Guide

AI agent ka hype bilkul sach hai. Har koi autonomous systems ke baare mein baat kar raha hai jo soch sakte hain, plan kar sakte hain aur tasks execute kar sakte hain. Lekin ek baat jo koi aapko nahi batata: zyadatar tutorials aapko sirf "happy path" (sab kuch sahi chalne wala raasta) dikhate hain aur un hisson ko skip kar dete hain jahan cheezein toot jaati hain.

Pichle hafte, maine do din lagakar zero se ek AI agent banaya. Koi khilona (toy example) nahi — ek asli agent jo blog platform manage karta hai, users create karta hai, posts likhta hai, aur waqayi mein kaam karta hai. Main aapko bilkul wahi dikhane wala hoon jo maine kiya, un hisson samet jo pehli baar mein kaam nahi kiye.

Full code: github.com/giftedunicorn/my-ai-agent

Hum Asal Mein Kya Bana Rahe Hain

Abstract examples ko bhool jao. Hum ek aisa agent bana rahe hain jo:

• PostgreSQL database mein users create aur manage karta hai
• Demand par blog posts generate karta hai
• Tools ka use karte hue baat-cheet (conversation) karta hai
• Conversation history yaad rakhta hai
• Asal mein deploy hota hai (sirf localhost demo nahi)

Tech Stack: Next.js, tRPC, Drizzle ORM, LangChain, aur Google's Gemini. Isliye nahi ki ye trendy hai — balki isliye ki ye type-safe hai, fast hai, aur production mein waqayi kaam karta hai.

Architecture (Aapki Soch Se Zyada Simple)

Mujhe jis baat ne hairan kiya wo ye thi: AI agents utne complicated nahi hain. Apne core mein, wo bas ye hain:

1. Ek LLM jo functions call kar sakta hai
2. Tools ka ek set jo LLM use kar sakta hai
3. Ek loop jo un tools ko execute karta hai
4. Memory jo context maintain karti hai

Bas yahi hai. Complexity tab aati hai jab in tukdon ko bharosemand tareeke se ek saath kaam karwana hota hai.

Database Schema

Sabse pehle, foundation. Humein users, posts, aur messages ke liye tables chahiye:

export const User = pgTable("user", (t) => ({
  id: t.integer().primaryKey().generatedAlwaysAsIdentity(),
  name: t.varchar({ length: 255 }).notNull(),
  email: t.varchar({ length: 255 }).notNull().unique(),
  bio: t.text(),
  createdAt: t.timestamp().defaultNow().notNull(),
  updatedAt: t.timestamp().defaultNow().notNull(),
}));

export const Post = pgTable("post", (t) => ({
  id: t.integer().primaryKey().generatedAlwaysAsIdentity(),
  userId: t
    .integer()
    .notNull()
    .references(() => User.id, { onDelete: "cascade" }),
  title: t.varchar({ length: 500 }).notNull(),
  content: t.text().notNull(),
  published: t.boolean().default(false).notNull(),
  createdAt: t.timestamp().defaultNow().notNull(),
  updatedAt: t.timestamp().defaultNow().notNull(),
}));

Kuch fancy nahi. Bas PostgreSQL ke saath clean, relational data. Message table conversation history store karti hai — jo requests ke beech context maintain karne ke liye crucial hai.

Tools Banana (Jahan Asli Jaadoo Hota Hai)

Yahi wo jagah hai jahan zyadatar tutorials gol-mol ho jate hain. Wo kehte hain, "Bas kuch tools bana lo." Ruko, main aapko dikhata hoon ki ye asal mein kaisa dikhta hai.

Tools wo functions hain jinhe aapka AI call kar sakta hai. LangChain ke DynamicStructuredTool ke saath, aap define karte hain:

1. Tool kya karta hai (description)
2. Ise kin inputs ki zaroorat hai (Zod ke saath schema)
3. Ye asal mein kya execute karta hai (function)

Ye raha users create karne ka tool:

const createUserTool = new DynamicStructuredTool({
  name: "create_user",
  description:
    "Create a new user in the database. Use this when asked to add, create, or register a user.",
  schema: z.object({
    name: z.string().describe("The user's full name"),
    email: z.string().email().describe("The user's email address"),
    bio: z.string().optional().describe("Optional biography"),
  }),
  func: async (input) => {
    const { name, email, bio } = input as {
      name: string;
      email: string;
      bio?: string;
    };
    const user = await caller.user.create({ name, email, bio });
    return `Successfully created user: ${user.name} (ID: ${user.id}, Email: ${user.email})`;
  },
});

Description aapki soch se kahin zyada matter karta hai. LLM iska use ye decide karne ke liye karta hai ki is tool ko kab call karna hai. Ise kab use karna hai, is baare mein specific rahein.

Aur return value? Ye wo hai jo LLM dekhta hai. Main structured text return karta hoon jisme saari relevant details hoti hain — IDs, names, confirmation. Isse LLM ko users ko behtar jawaab dene mein madad milti hai.

The Agent: Sab Kuch Ek Saath Jodna

Yahan cheezein interesting ho jati hain. Nayi LangChain API (v1.2+) ne sab kuch simplify kar diya hai:

const agent = createAgent({
  model: new ChatGoogleGenerativeAI({
    apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY,
    model: "gemini-2.0-flash-exp",
    temperature: 0.7,
  }),
  tools: [...createUserTools(caller), ...createPostTools(caller)],
  systemPrompt: AGENT_SYSTEM_PROMPT,
});

const result = await agent.invoke({
  messages: conversationMessages,
});

Bas itna hi. Koi ChatPromptTemplate nahi, koi AgentExecutor nahi, koi complex chains nahi. Sirf createAgent aur invoke.

System Prompt (Aapke Agent Ki Personality)

Ye wo jagah hai jahan aap apne agent ko sikhate hain ki kaise behave karna hai:

const AGENT_SYSTEM_PROMPT = `You are an AI assistant that helps manage a blog platform.

You have access to tools for:
- User management (create, read, list, count)
- Post management (create, list)

When users ask you to perform actions:
1. Use the appropriate tools to complete the task
2. Be conversational and friendly
3. Provide clear confirmation with specific details
4. When creating mock data, use realistic names and content

Always confirm successful operations with relevant details.`;

Maine ye thokar kha kar seekha: explicit raho. Agent ko bilkul saaf batao ki kya karna hai, kaise respond karna hai, aur kaunsi details include karni hain. Vague prompts ka nateeja vague behavior hota hai.

Conversation History Handle Karna

Zyadatar examples ise skip kar dete hain, lekin ek achhe user experience ke liye ye critical hai. Main ise aise handle karta hoon:

// Get last 10 messages from database
const history = await ctx.db
  .select()
  .from(Message)
  .orderBy(desc(Message.createdAt))
  .limit(10);

// Convert to LangChain format
const conversationMessages = [
  ...history.reverse().map((msg) => ({
    role: msg.role === "user" ? "user" : "assistant",
    content: msg.content,
  })),
  { role: "user", content: input.message },
];

Simple, lekin asardaar. Agent ab pichle 10 exchanges yaad rakhta hai. Context ke liye kaafi hai, lekin itna bhi nahi ki wo confuse ho jaye ya mehenga pad jaye.

Mushkil Hisse (Jo Asal Mein Toot Gaye)

Circular Dependencies: Mera pehla attempt fail ho gaya kyunki agent.ts ne appRouter ko import kiya, jisne agentRouter ko import kiya, jisse circular dependency ban gayi. Solution? Sirf tools ke liye zaroori routers ke saath inline ek temporary router banao.

Tool Response Extraction: LangChain ka response format v1.2 mein badal gaya. Result ab result.messages[result.messages.length - 1].content mein hai, result.output mein nahi. Ise figure out karne mein mujhe ek ghanta lag gaya.

Type Safety: Tool ke func parameter ko explicit typing ki zaroorat hoti hai. Aap bas destructure nahi kar sakte — aapko pehle input ko cast karna hoga. TypeScript yahan aapki madad nahi karega.

Apna Khud Ka Setup Karna

Aapko asal mein in cheezon ki zaroorat hai:

1. Dependencies install karein:

pnpm add @langchain/core @langchain/google-genai langchain drizzle-orm

2. Environment variables:

POSTGRES_URL="your-database-url"  # Vercel Postgres, Supabase, ya local PostgreSQL try karein
GOOGLE_GENERATIVE_AI_API_KEY="your-gemini-key"  # Yahan se lein: https://aistudio.google.com/app/apikey

3. Database setup:

pnpm db:push  # Schema se tables create karta hai

4. Banana shuru karein:

• Apna database schema define karein
• CRUD operations ke liye tRPC procedures banayein
• LangChain tools banayein jo un procedures ko wrap karein
• Apne tools ke saath agent create karein
• Ise apne frontend se connect karein

Main Kya Alag Karta

Agar main kal phir se shuru karoon:

Kam tools ke saath shuruat. Maine shuru mein 7 tools banaye the. Pehle sirf 3-4 core tools par tike raho. Unhe perfectly kaam karne do, phir expand karo.

Tools ko alag se test karo. Agent banne ka intezaar mat karo apne tools test karne ke liye. Pehle test data ke saath unhe seedha call karo.

Tool usage monitor karo. Maine logging add ki ye dekhne ke liye ki agent kaunse tools call karta hai aur kyun. Isse pata chala ki mere tool descriptions mein sudhaar ki zaroorat thi.

Streaming use karo. Abhi, users poore response ka intezaar karte hain. Streaming se ye tez mehsoos hoga, bhale hi utna hi waqt lage.

Reality Check

AI agents banana koi jaadoo nahi hai, lekin ye mamooli bhi nahi hai. Aap zyada waqt in cheezon par bitayenge:

• Tool design (har tool ko kya karna chahiye?)
• Prompt engineering (main agent ko sahi behave kaise karaoon?)
• Error handling (agar database down ho to kya? agar LLM hallucinate kare to kya?)
• Type safety (dynamic LLM responses ke saath TypeScript ko khush rakhna)

Bajaaye actual AI part ke.

Khud Try Karein

Is tutorial ka code asli hai — maine ise likhte waqt hi banaya tha. Aap kar sakte hain:

• Test karein: "create 3 mock users"
• Try karein: "create 2 blog posts for user 1"
• Puchein: "how many users do we have?"

Agent in sabko handle karta hai ye decide karke ki kaunse tools call karne hain, unhe execute karke, aur conversationally jawaab dekar.

Aage Kya Hai

Ye sirf foundation hai. Yahan se, aap ye kar sakte hain:

• Authentication add karein (kaun kya create kar sakta hai?)
• Streaming responses implement karein
• Aur complex tools add karein (search, analytics, integrations)
• Feedback loop banayein (kya tool call safal raha?)
• Rate limiting add karein (users ko 10,000 posts create karne mat do)

Lekin shuruat simple rakho. Das mediocre tools add karne se pehle ek tool ko achhe se kaam karne do.

Sabse achhi baat? Ek baar jab aap ye pattern samajh jate hain — tools + LLM + memory — to aap kisi bhi cheez ke liye agents bana sakte hain. Database management, customer support, content generation, kuch bhi.

Mushkil part code nahi hai. Mushkil part wo tools design karna hai jo waqayi mein real problems solve karein.

---

Resources:

• Full source code: github.com/giftedunicorn/my-ai-agent
• Built with Create T3 Turbo
• LangChain Docs: js.langchain.com
• Get Gemini API key: aistudio.google.com