Chapter 33: Agentic AI ka Overview: Autonomous Agents, Planning, Memory aur Multi-Agent Systems
MODULE 9 | WEEK 33
Chapter 33: Agentic AI ka Overview: Autonomous Agents, Planning, Memory aur Multi-Agent Systems
Pichle chapter me tumne ek agent banaya. Is chapter me bari tasveer dekhte hain: Agentic AI kya hai, agents sochte (plan) kaise hain, yaad (memory) kaise rakhte hain, kaise kai agents mil kar kaam karte hain, aur sab se ahem: unhein mehfooz aur bharosemand kaise banaya jaye. Yeh Module 9 ka aakhri chapter hai, is liye aakhir me ek mini project aur Module ka khulasa bhi hai. Sab concepts ko pehle chhote Python code se samjhenge (asli outputs ke saath), jo baad me asli LLM ke saath jorna asaan hoga.
33.1 Agentic AI kya hai?
Agentic AI ka matlab hai aise AI systems jo sirf jawab nahi dete, balke maqsad (goal) mil jane par khud faisle karte, tools chalate aur kai qadam me kaam mukammal karte hain, kam se kam insani rehnumai ke saath. "Kitni azaadi " di jaye, is ke hisaab se systems ki ek line hai:
| Darja | Kaise kaam karta hai? | Misaal |
|---|---|---|
| 1. Chatbot | Ek sawal, ek jawab. Koi tool nahi | FAQ ka jawab dena |
| 2. Workflow / Chain | Qadampehle se tay(tum ne likhe), LLM har qadam me kaam karta hai | Email parho -> summarize -> category lagao -> save karo |
| 3. Agent | LLM khud tay karta haike agla qadam kya ho aur kaun sa tool chale (loop) | Research assistant jo khud search kare aur nateeja likhe |
| 4. Multi-agent system | Kai specialist agents,managerya aapas ki baat cheet | Researcher + Writer + Reviewer ki team |
33.2 Agent ka dil: Perceive - Think - Act aur ReAct
Agent ka bunyadi chakkar (jo Chapter 32 ki tasveer me dekha):
Goal -> [ Perceive (halat dekho) -> Think (soch/faisla) -> Act (tool chalao) ]
-> Observe (natija dekho) -> dohrao
Is chakkar ka mashhoor tareeqa ReAct (Reason + Act) hai: model har qadam par Thought (soch), Action (tool) likhta hai, aur tool ke Observation (natija) dekh kar agla qadam tay karta hai. Neeche LLM ki jagah ek scripted policy se ReAct ka dhancha bana kar dekhte hain (asli LLM me sirf policy() badalti hai):
import ast, operator
KB = {"total_weeks": "49", "modules6_9_weeks": "5"} # course ka maloomat ka zakheera
OPS = {ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul, ast.Div: operator.truediv}
def _ev(n):
if isinstance(n, ast.Constant):
return n.value
if isinstance(n, ast.BinOp) and type(n.op) in OPS:
return OPS[type(n.op)](_ev(n.left), _ev(n.right)) raise ValueError("ijazat nahi")
def tool_lookup(key):
return KB.get(key, "nahi mila")
def tool_calc(expr):
return str(round(_ev(ast.parse(expr, mode="eval").body), 2))
TOOLS = {"lookup": tool_lookup, "calc": tool_calc}
def policy(question, history):
"""LLM ki jagah: dekho ab tak kya pata chala aur agla qadam batao."""
obs = [o for _, _, o in history]
if len(obs) == 0:
return "Pehle Modules 6 aur 9 ke kul hafte chahiye.", ("lookup", "modules6_9_weeks")
if len(obs) == 1:
return "Ab poore course ke hafte chahiye.", ("lookup", "total_weeks")
if len(obs) == 2:
return "Ab percent nikalta hoon.", ("calc", f"{obs[0]} / {obs[1]} * 100")
return "Mere paas jawab hai.", None
def react(question, max_steps=6):
history = []
for step in range(1, max_steps + 1):
thought, action = policy(question, history)
print(f"Thought {step}: {thought}")
if action is None:
print(f"Final Answer: Modules 6 aur 9 mil kar poore course ka {history[-1][2]}% hain.")
return
name, arg = action
obs = TOOLS[name](arg)
print(f"Action {step}: {name}[{arg}]")
print(f"Observ. {step}: {obs}")
history.append((thought, action, obs))
print("max_steps khatam, jawab nahi mila")
react("Modules 6 aur 9 mil kar course ka kitna percent hain?")
OUTPUT Thought 1: Pehle Modules 6 aur 9 ke kul hafte chahiye. Action 1: lookup[modules6_9_weeks] Observ. 1: 5 Thought 2: Ab poore course ke hafte chahiye. Action 2: lookup[total_weeks]
Observ. 2: 49
Thought 3: Ab percent nikalta hoon.
Action 3: calc[5 / 49 * 100]
Observ. 3: 10.2
Thought 4: Mere paas jawab hai.
Final Answer: Modules 6 aur 9 mil kar poore course ka 10.2% hain.
33.3 Planning: Task Decomposition aur Reflection
Bare kaam ko chhote qadam (sub-tasks) me torna planning hai. Do aam tareeqe:
| Tareeqa | Kaise? | Kab acha? |
|---|---|---|
| ReAct (qadam ba qadam) | Har qadam par sochna, agla qadam wahin tay | Anjaan, badalta hua kaam |
| Plan-and-Execute | Pehlepoora planbanao, phir qadam chalao (ghalti par | Lambe, bade, tarteeb wale kaam |
| dobara plan) | ||
| Reflection (khud jaanch) | Agent apna jawabkhud parakhkar sudharta hai (critic) | Jahan quality ahem ho |
Qadmon me aksar tarteeb ki shartein hoti hain ("pehle data saaf, phir model"). Isay dependency graph kehte hain aur Python ka graphlib iska sahi order khud nikal deta hai. Saath hi dekhte hain ke ek qadam fail ho to agent plan badalta hai:
from graphlib import TopologicalSorter
# har kaam:
us se pehle kin kaamon ka hona zaroori hai
plan = { "data_jama_karo": [], "data_saaf_karo": ["data_jama_karo"], "chart_banao": ["data_saaf_karo"], "model_train_karo": ["data_saaf_karo"], "evaluate_karo": ["model_train_karo"], "report_likho": ["evaluate_karo", "chart_banao"], }
order = list(TopologicalSorter(plan).static_order())
print("Plan ki tarteeb:")
for i, step in enumerate(order, 1):
print(f" {i}. {step}")
def execute(step, attempt=1):
if step == "model_train_karo" and attempt == 1:
return False, "GPU memory khatam" # pehli koshish me nakami
return True, "ho gaya"
print()
for step in order:
ok, msg = execute(step)
if not ok:
print(f"[FAIL] {step}: {msg} -> REPLAN: chhota model chuno")
ok, msg = execute(step, attempt=2)
print(f"[{'OK' if ok else 'FAIL'}] {step}")
OUTPUT Plan ki tarteeb: 1. data_jama_karo
2. data_saaf_karo
3. chart_banao
4. model_train_karo
5. evaluate_karo
6. report_likho
[OK] data_jama_karo
[OK] data_saaf_karo
[OK] chart_banao
[FAIL] model_train_karo: GPU memory khatam -> REPLAN: chhota model chuno
[OK] model_train_karo
[OK] evaluate_karo
[OK] report_likho
Reflection ka matlab hai jawab likhne ke baad doosra qadam : "kya ye jawab sahi aur mukammal hai? kya sudhaar chahiye?" Is me aksar writer aur critic do alag prompts (ya agents) hote hain (33.6 me is ka code hai).
33.4 Memory: Agent kaise yaad rakhta hai?
LLM ki apni koi yaaddasht nahi hoti (Chapter 31). Agent ko yaad tumhara system deta hai. Memory ki qismein:
| Qism | Kya hai? | Kahan rehti hai? | Misaal |
|---|---|---|---|
| Short-term | Maujooda guftagu | Context window (messages ki list) | Abhi ke 10 messages |
| Working memory | Kaam ke dauran ke natije aur nota | Run ki state / scratchpad | Tool ke natije, plan ki halat |
| Long-term: facts | User ke bare me pakki maloomat | Database / vector store | "Sara Karachi me hai, Python seekh rahi hai" |
| Long-term: events | Pichli baaton ka record | Vector store / logs | "Pichle hafte attention ka test diya" |
| Procedural | Kaam karne ke tareeqe | Instructions, skills files | "Hamesha pehle calculator chalao" |
Short-term: window aur summary
Context window bhar jaye to purani baatein summary me badal dete hain aur taaza messages poore rakhte hain:
class ConversationMemory:
def __init__(self, max_recent=3):
self.max_recent = max_recent
self.messages, self.summary = [], ""
def add(self, role, text):
self.messages.append((role, text))
while len(self.messages) > self.max_recent:
old_role, old_text = self.messages.pop(0) # sab se purana
# asli system me yahan LLM summary banata hai hum chhota nota jodte hain
self.summary += f"{old_role}: {old_text[:20]}...; "
def context(self):
recent = "\n".join(f"{r}: {t}" for r, t in self.messages)
return f"[Ab tak ka khulasa] {self.summary or 'koi nahi'}\n{recent}"
mem = ConversationMemory(max_recent=3)
for role, text in [("user", "Mera naam Sara hai"),
("assistant", "Khushi hui Sara!"),
("user", "Mujhe attention samjhao"),
("assistant", "Attention ek soft lookup hai"),
("user", "Aur multi-head?")]:
mem.add(role, text)
print(mem.context())
OUTPUT [Ab tak ka khulasa] user: Mera naam Sara hai...; assistant: Khushi hui Sara!...; user: Mujhe attention samjhao assistant: Attention ek soft lookup hai user: Aur multi-head?
Long-term: vector memory
Lambi muddat ki yaaddasht me har baat vector bana kar rakhte hain aur zaroorat par sab se milti julti yaadein dhoond lete hain (Chapter 30.7 jaisa). Yahan TF-IDF se chhota version:
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
class VectorMemory:
def __init__(self):
self.items = []
def remember(self, text):
self.items.append(text)
def recall(self, query, k=2):
vec = TfidfVectorizer().fit(self.items + [query])
sims = cosine_similarity(vec.transform([query]), vec.transform(self.items))[0]
top = sims.argsort()[::-1][:k]
return [(round(float(sims[i]), 2), self.items[i]) for i in top]
memory = VectorMemory()
for fact in ["Sara ka shehar Karachi hai", "Sara Python seekh rahi hai aur test me attention topic kamzor tha", "Sara ko subah ki class pasand hai", "Sara ka project idea cricket data par tha"]:
memory.remember(fact)
for s, text in memory.recall("attention ka test kaisa tha"):
print(s, "|", text)
OUTPUT 0.32 | Sara Python seekh rahi hai aur test me attention topic kamzor tha 0.2 | Sara ka project idea cricket data par tha
SUNEHRA USOOL
-
Sirf zaroori cheez yaad rakho aur user ko dekhne aur mitane ka haq do (privacy).
-
Memory ghalat ya purani ho sakti hai; tareekh ke saath rakho aur update karo.
-
Memory ke andar chhupi hidayat (prompt injection) bhi aa sakti hai; yaad ki hui baatein data hain, hukm nahi.
33.5 Tools, Environment aur MCP
| Tool ki qism | Kaam | Misaal | Khatra |
|---|---|---|---|
| Maloomat | Dhoondna/parhna | Web search, database, RAG | Ghalat ya khatarnaak source |
| Hisaab | Code chalana | Calculator, Python sandbox | Code se nuqsan (sandbox zaroori) |
| Action | Duniya me kuch karna | Email, calendar, payment, file delete | Sab se zyada: na-qabil-e-wapsi |
| Perception | Dekhna/sunna | Image, audio, screen | Ghalat tashreeh |
| Computer use | Browser/app chalana | Form bharna, page par click | Ghalat jagah click, nijee data |
MCP (Model Context Protocol) ek khula mayar (open standard) hai jo AI applications ko tools aur data se jorne ka ek hi tareeqa deta hai. Har tool ke liye alag jugaar likhne ki bajaye MCP server ek bar banta hai aur koi bhi MCP-supporting app (kai SDKs, jin me OpenAI Agents SDK shamil hai) usay istemal kar sakti hai. Is ki misaal USB hai: ek hi port se printer, mouse, keyboard sab lagte hain.
AI app / Agent (MCP client) <--- MCP ---> MCP server
|--> Files / GitHub / Database / Calendar
SUNEHRA USOOL
-
Kam az kam ijazat (least privilege): agent ko sirf wo tools do jin ki zaroorat hai, aur jahan mumkin ho sirf parhne ki ijazat.
-
Na-qabil-e-wapsi kaam (paise bhejna, email, delete) se pehle insani manzoori lo.
-
Sandbox: code chalane wale tool ko alag, mehfooz mahol me chalao.
-
Had lagao: har tool par timeout, rate limit aur kharche ki had.
33.6 Multi-Agent Systems
Kai agents kyun? Har agent ko chhota, saaf kaam milta hai (behtar instructions, kam tools, chhota context), kaam parallel ho sakta hai, aur ek agent doosre ka kaam jaanch sakta hai. Nuqsan: zyada kharcha, zyada complexity, aur ek agent ki ghalti agle tak phail sakti hai. Mashhoor patterns:
DIAGRAM

| Pattern | Kaise kaam karta hai? | Kab? |
|---|---|---|
| Manager-Worker | Manager kaam taqseem karta, workers karte, manager nateeje jodta | Bara kaam, kai maahir |
| Triage + Handoff | Pehla agent sawal dekh kar sahi specialist ko deta hai | Support, mukhtalif department |
| Pipeline | Ek ke baad ek (Researcher -> Writer -> Editor) | Tarteeb wala kaam |
| Writer-Critic loop | Likhna, jaanchna, sudharna, dohrana | Quality ahem ho |
Chapter 32.8 me handoffs aur agents-as-tools SDK se dekhe. Ab pure Python me Researcher -> Writer -> Reviewer ki team, jisme reviewer ke aitraaz par writer sudhaar karta hai :
FACTS = {"attention": ["har token sab ko dekhta hai", "weights softmax se bante hain"]}
def researcher(topic):
return FACTS.get(topic, [])
def writer(topic, facts, feedback=None):
text = f"{topic.title()} ke bare me: " + "; ".join(facts) + "."
if feedback == "misaal chahiye":
text += " Misaal: 'wo' ka dhyan 'Sara' par."
return text
def reviewer(draft):
if "Misaal" not in draft:
return False, "misaal chahiye"
return True, "theek hai"
def team(topic, max_rounds=3):
facts = researcher(topic)
print("Researcher ne dhoonda:", facts)
feedback = None
for round_no in range(1, max_rounds + 1):
draft = writer(topic, facts, feedback)
approved, feedback = reviewer(draft)
verdict = "MANZOOR"
if approved
else "aitraaz: " + feedback
print(f"Round {round_no}: reviewer -> {verdict}")
if approved:
return draft
return draft
print()
print(team("attention").replace(" Misaal", "\nMisaal"))
OUTPUT
Researcher ne dhoonda: ['har token sab ko dekhta hai', 'weights softmax se bante hain']
Round 1: reviewer -> aitraaz: misaal chahiye
Round 2: reviewer -> MANZOOR
Attention ke bare me: har token sab ko dekhta hai; weights softmax se bante hain.
Misaal: 'wo' ka dhyan 'Sara' par.
Asli system me researcher, writer, reviewer teeno LLM agents hote hain (Agents SDK me teen Agent aur ek manager jo unhein as_tool ya handoff se chalata hai). max_rounds wahi hifazati had hai jo chakkar ko hamesha khatam hone ki zamanat deti hai.
33.7 Safety, Reliability aur Evaluation
Agents ko banana aasan , bharosemand banana mushkil hai. Pehle dekho ke ghalti kaise phailti hai : agar har qadam sahi hone ki probability p hai to n qadam ke baad poore kaam ke theek hone ki probability p^n hoti hai:
print("qadam | p=0.99 p=0.95 p=0.90")
for n in [1, 5, 10, 20]:
row = " ".join(f"{p ** n:6.2f}" for p in [0.99, 0.95, 0.90])
print(f"{n:5d} | {row}")
OUTPUT qadam | p=0.99 p=0.95 p=0.90 1 | 0.99 0.95 0.90 5 | 0.95 0.77 0.59 10 | 0.90 0.60 0.35 20 | 0.82 0.36 0.12
Dekho: har qadam 95% sahi ho tab bhi 20 qadam ke baad poora kaam sirf ~36% theek hota hai. Is liye lambe agents ko chhote qadam, jaanch aur wapsi ka raasta chahiye. Aham khatre aur unka ilaaj:
| Khatra | Kaise hota hai? | Hifazat |
|---|---|---|
| Be-had loop | Agent ek hi tool baar baar chalata hai | max_turns, budget aur loop detection |
| Khatra | Kaise hota hai? | Hifazat |
|---|---|---|
| Ghalat tool/arguments | Model ghalat function ya input chunta hai | Strict schema, validation, saaf tool names |
| Hallucinated action | Agent kehta hai "email bhej di" jab ke nahi bheji | Tool keasal natijepar bharosa, nikalne wale jawab ki tasdeeq |
| Prompt injection | Web page/email me chhupi hidayat agent ko behkati hai ("apna data bhej do") | Bahar ka text sirf data; tools ki ijazat mehdood; manzoori |
| Zyada ijazat | Agent ke paas delete/pay ki taqat | Least privilege, sandbox |
| Kharcha | Lambi runs, bare models | Token/paise ki had, chhota model, caching |
| Privacy | Nijee data logs/traces me | Anonymize, retention ki had |
Human-in-the-loop: manzoori
Khatarnaak actions chalne se pehle insan se ijazat maangna sab se asaan aur mehfooz hifazat hai:
RISKY = {"send_email", "delete_file", "make_payment"}
def run_action(tool, args, approve):
if tool in RISKY and not approve(tool, args):
return f"ROKA GAYA: {tool} ke liye insani ijazat nahi mili"
return f"{tool}({args}) chal gaya"
always_no = lambda tool, args:
False
always_yes = lambda tool, args:
True
print(run_action("search_web", {"q": "attention"}, always_no)) # mehfooz: seedha
print(run_action("send_email", {"to": "sir@example.com"}, always_no))
print(run_action("send_email", {"to": "sir@example.com"}, always_yes))
OUTPUT search_web({'q': 'attention'}) chal gaya ROKA GAYA: send_email ke liye insani ijazat nahi mili send_email({'to': 'sir@example.com'}) chal gaya
Evaluation: agent ko parakhna
Agent ko "chal gaya" kehna kaafi nahi. Test set (10-50 sawal jin ka sahi jawab pehle se pata ho) banao aur har tabdeeli (prompt, tool, model) ke baad dobara chalao (regression test). Parakhne ke paimane: kaam ki kamyabi (success rate) , sahi tool ka chunao , kitne qadam , kharcha , waqt , aur mehfooz rehna :
def mini_agent(question):
"""Chhota nakal agent: keyword dekh kar tool chalata hai."""
q = question.lower()
if "week" in q and "29" in q:
return "Transformers aur Attention Mechanism"
if "week" in q and "32" in q:
return "OpenAI Agent SDK aur Function Calling"
if "percent" in q:
return "10.2"
return "mujhe maloom nahi"
tests = [
("Week 29 me kya hai?", "attention"),
("Week 32 me kya hai?", "function calling"),
("49 me se 5 kitne percent?", "10.2"),
("Week 30 me kya hai?", "llm"), # agent ye nahi jaanta
("Biryani ki recipe?", "maloom nahi"), # sahi inkaar karna bhi kamyabi
]
passed = 0
for q, expected in tests:
answer = mini_agent(q)
ok = expected in answer.lower() passed += ok
print(f"{'PASS' if ok else 'FAIL'} | {q:28s} -> {answer}")
print(f"\nSuccess rate: {passed}/{len(tests)} = {100 * passed / len(tests):.0f}%")
OUTPUT
PASS | Week 29 me kya hai? -> Transformers aur Attention Mechanism
PASS | Week 32 me kya hai? -> OpenAI Agent SDK aur Function Calling
PASS | 49 me se 5 kitne percent? -> 10.2
FAIL | Week 30 me kya hai? -> mujhe maloom nahi
PASS | Biryani ki recipe? -> mujhe maloom nahi
Success rate: 4/5 = 80%
FAIL wali line sab se qeemti hai: usi se pata chalta hai ke agent me kahan tool ya maloomat ki kami hai. Test set ko time ke saath barhao aur asli users ke ghalat jawabon ko usme jodte jao.
ETHICS / ZIMMEDARI
-
Shaffafiyat: user ko batao ke wo AI se baat kar raha hai , aur agent ne kaun si action ki.
-
Ahem faislon me insan: naukri, qarz, sehat, qanooni maamlat me AI sirf madadgar , aakhri faisla insan ka.
-
Taassub (bias) aur insaaf: alag zabanon/tabqon par agent ki kaarkardagi alag tolo.
-
Nijee data: sirf zaroori data lo, mehfooz rakho, mitane ka haq do.
-
Jawabdehi: ghalti par kaun zimmedar hai pehle se tay karo, aur logs rakho.
-
Ghalat istemal: deepfake, dhoka, spam ke liye agents banane se door raho.
33.8 Asli Duniya ke Use Cases aur Career
| Use case | Agent kya karta hai? | Tools | Khatre ka darja |
|---|---|---|---|
| Customer support | Sawal samajhna, order dekhna, jawab dena, zaroorat par insan ko dena | FAQ/RAG, order database, ticket system | Darmiyana |
| Research assistant | Sawal par sources dhoondna, parhna, khulasa banana | Web search, documents | Kam se darmiyana |
| Coding agent | Code likhna, test chalana, bug theek karna | Files, terminal, tests | Zyada (sandbox zaroori) |
| Data analysis agent | Data saaf karna, charts, report | Python/Pandas, SQL | Darmiyana |
| Education tutor | Sawal jawab, mashq, progress yaad rakhna | Quiz bank, memory, RAG | Kam |
| Business operations | Lead sort karna, invoice, scheduling | CRM, email, calendar | Zyada (na-qabil-e- wapsi actions) |
Pakistan me mauqay: Urdu/Roman Urdu me customer support (online dukaan, WhatsApp), university ya institute ka FAQ agent , freelancers ke liye proposal aur report madadgar, chhote karobar ke liye sales/data ka tajziya , aur taleem me tutor . In sab me sahi zabaan, tehzeeb aur data ki hifazat asli farq paida karti hai.
Seekhne ka raasta (is module ke baad)
-
Python + APIs + async par pakri: (Module 1 se 6 ka nichor).
-
Prompts, RAG aur Structured Output ko apni files par chalana.
-
Evaluation ki aadat: har project ka test set.
-
Deployment:
FastAPIyaStreamlitme app, Docker, aur logging (Module 7 ke MLOps me). -
Portfolio: 3-4 achhe projects, saaf README aur demo video GitHub/LinkedIn par.
33.9 Mini Project: Course Assistant Agent
Maqsad: ek Course Assistant banana jo is AI aur Data Science course ke students ke sawalon ke jawab de, hisaab kare, mashq de, aur guftagu yaad rakhe. Ye Chapters 32 aur 33 ka nichor hai aur Chapter 30 ke RAG concepts bhi istemal karta hai.
| Hissa | Zaroorat | Kahan se? |
|---|---|---|
| Knowledge (RAG) | Syllabus aur apne notes par jawab, sources ke saath | Chapter 30.7-30.8 |
| Tools | Syllabus lookup, calculator, quiz maker, study planner | Chapter 32.5 |
| Memory | Student ka naam, kamzor topics (session + vector memory) | Chapter 32.9, 33.4 |
| Guardrails | Sirf course ke sawal, nijee data par inkaar | Chapter 32.9 |
| Safety | max_turns, kharche ki had, ijazat wale actions par manzoori | Chapter 33.7 |
| Evaluation | Kam az kam 15 sawalon ka test setaur success rate | Chapter 33.7 |
Deliverables
-
Chalne wala code (Colab notebook ya
.py) aur README (kya karta hai, kaise chalaen). -
Architecture ka nakshaa (tasveer): tools, memory, RAG, guardrails.
-
Test set aur success rate ki report (kitne PASS, FAIL ki wajah).
-
Demo: 2 se 3 minute ki screen recording.
| Rubric | Number |
|---|---|
| Agent sahi kaam karta hai (tools, RAG, memory) | 35 |
| Safety aur guardrails (hadood, manzoori, kharche ki had) | 20 |
| Evaluation (test set, nateeja, tajziya) | 20 |
| Code ki saafi aur README | 15 |
| Demo aur wazahat | 10 |
| Kul | 100 |
|---|
33.10 Module 9 ka Mukhtasar
| Chapter | Mukhya Idea | Aham Code / Tool |
|---|---|---|
| 32: Agents SDK | Function calling, @function_tool, Runner, handoffs, sessions | Agent, Runner, function_tool |
| 33: Agentic AI | ReAct, planning, memory, multi-agent, safety aur evaluation | ReAct loop, graphlib, vectormemory |
Agla qadam: Module 7 (Weeks 34 se 40) me tum MLOps seekhogi: model ko API (FastAPI), Docker, MLflow, CI/CD aur logging ke saath asli duniya tak pohanchana. Ab tumhare paas Python se le kar Generative aur Agentic AI tak poora toolbox hai.
33.11 Aam Galtiyan aur Hands-on
AAM GALTIYAN
-
Har masle ke liye agent banana, jab simple workflow kaafi ho.
-
Agent ko khula chhor dena (na hadood, na manzoori, na budget).
-
Evaluation na karna , aur "mere example me chal gaya" par bharosa.
-
Lambe, kai-qadam wale kaam bina jaanch aur wapsi ke raaste ke (p^n ka asar).
-
Memory me sab kuch rakhna (privacy aur purani/ghalat maloomat).
-
Bahar ke text (web, email) ko hukm samajhna (prompt injection).
-
Multi-agent me bagair zaroorat ke bohat se agents (kharcha aur confusion).
Hands-on
-
ReAct: 33.2 me
KBme naya fact jodo aurpolicyko ek aur qadam ke liye badlo. -
Plan:
planme ek naya kaam "deploy_karo" jodo joevaluate_karopar depend kare; order dekho. -
Memory:
VectorMemoryme 5 aur yaadein jodo aur 3 alag sawal pooch kar recall dekho. -
Multi-agent:
reviewerme ek aur shart jodo (maslan jumle ki had) aur dekho kitne rounds lage. -
Reliability: p^n table ko p = 0.98 aur n = 50 tak badhao; kya natija nikla?
-
Evaluation:
testsme 5 aur sawal jodo aur success rate dekho; FAIL ki wajah likho.
KEY TAKEAWAYS
-
Agentic AI me LLM goal le kar khud qadam tay karta, tools chalata aur kai qadam me kaam mukammal karta hai.
-
Chatbot -> Workflow -> Agent -> Multi-agent: azaadi barhti hai to kharcha aur khatra bhi; pehle saada hal.
-
ReAct: Thought -> Action -> Observation ka chakkar; planning (plan-and-execute) aur reflection (critic).
-
Memory: short-term (context), working, long-term (facts/events, vector memory ). Privacy aur ghalat yaad ka khayal.
-
MCP tools/data se jorne ka khula mayar; least privilege aur insani manzoori zaroori.
-
Multi-agent patterns: manager-worker, triage + handoff, pipeline, writer-critic.
-
Reliability: p^n ka asar; max_turns, budget, guardrails, tracing, evaluation (test set) sab zaroori hain.
-
Zimmedari: shaffafiyat, nijee data, bias, jawabdehi aur ghalat istemal se parhez.