مین مواد پر جائیں

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:

DarjaKaise kaam karta hai?Misaal
1. ChatbotEk sawal, ek jawab. Koi tool nahiFAQ ka jawab dena
2. Workflow / ChainQadampehle se tay(tum ne likhe), LLM har qadam me
kaam karta hai
Email parho -> summarize ->
category lagao -> save karo
3. AgentLLM 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 systemKai specialist agents,managerya aapas ki baat cheetResearcher + 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:

TareeqaKaise?Kab acha?
ReAct (qadam ba qadam)Har qadam par sochna, agla qadam wahin tayAnjaan, badalta hua kaam
Plan-and-ExecutePehlepoora planbanao, phir qadam chalao (ghalti parLambe, 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:

QismKya hai?Kahan rehti hai?Misaal
Short-termMaujooda guftaguContext window (messages ki list)Abhi ke 10 messages
Working memoryKaam ke dauran ke natije aur
nota
Run ki state / scratchpadTool ke natije, plan ki halat
Long-term: factsUser ke bare me pakki
maloomat
Database / vector store"Sara Karachi me hai, Python
seekh rahi hai"
Long-term: eventsPichli baaton ka recordVector store / logs"Pichle hafte attention ka test
diya"
ProceduralKaam karne ke tareeqeInstructions, 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 qismKaamMisaalKhatra
MaloomatDhoondna/parhnaWeb search, database, RAGGhalat ya khatarnaak source
HisaabCode chalanaCalculator, Python sandboxCode se nuqsan (sandbox zaroori)
ActionDuniya me kuch karnaEmail, calendar, payment, file deleteSab se zyada: na-qabil-e-wapsi
PerceptionDekhna/sunnaImage, audio, screenGhalat tashreeh
Computer useBrowser/app chalanaForm bharna, page par clickGhalat 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​
DIAGRAM: 1)Manager-Worker(orchestrator) 2)Triage+Handoff Manager Triage agent Worker2 Worker3 Worker1 Billing Tech support Sales 3)Pipeline(ekkebaadek) 4) Writer - Critic loop draft...
DIAGRAM: 1)Manager-Worker(orchestrator) 2)Triage+Handoff Manager Triage agent Worker2 Worker3 Worker1 Billing Tech support Sales 3)Pipeline(ekkebaadek) 4) Writer - Critic loop draft...
PatternKaise kaam karta hai?Kab?
Manager-WorkerManager kaam taqseem karta, workers karte, manager nateeje
jodta
Bara kaam, kai maahir
Triage + HandoffPehla agent sawal dekh kar sahi specialist ko deta haiSupport, mukhtalif
department
PipelineEk ke baad ek (Researcher -> Writer -> Editor)Tarteeb wala kaam
Writer-Critic loopLikhna, jaanchna, sudharna, dohranaQuality 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:

KhatraKaise hota hai?Hifazat
Be-had loopAgent ek hi tool baar baar chalata haimax_turns, budget aur loop detection
KhatraKaise hota hai?Hifazat
Ghalat tool/argumentsModel ghalat function ya input chunta haiStrict schema, validation, saaf tool names
Hallucinated actionAgent kehta hai "email bhej di" jab ke nahi bhejiTool keasal natijepar bharosa, nikalne wale
jawab ki tasdeeq
Prompt injectionWeb page/email me chhupi hidayat agent ko
behkati hai ("apna data bhej do")
Bahar ka text sirf data; tools ki ijazat mehdood;
manzoori
Zyada ijazatAgent ke paas delete/pay ki taqatLeast privilege, sandbox
KharchaLambi runs, bare modelsToken/paise ki had, chhota model, caching
PrivacyNijee data logs/traces meAnonymize, 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 caseAgent kya karta hai?ToolsKhatre ka darja
Customer supportSawal samajhna, order dekhna, jawab dena,
zaroorat par insan ko dena
FAQ/RAG, order database,
ticket system
Darmiyana
Research assistantSawal par sources dhoondna, parhna, khulasa
banana
Web search, documentsKam se darmiyana
Coding agentCode likhna, test chalana, bug theek karnaFiles, terminal, testsZyada (sandbox
zaroori)
Data analysis agentData saaf karna, charts, reportPython/Pandas, SQLDarmiyana
Education tutorSawal jawab, mashq, progress yaad rakhnaQuiz bank, memory, RAGKam
Business operationsLead sort karna, invoice, schedulingCRM, email, calendarZyada (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: FastAPI ya Streamlit me 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.

HissaZarooratKahan se?
Knowledge (RAG)Syllabus aur apne notes par jawab, sources ke saathChapter 30.7-30.8
ToolsSyllabus lookup, calculator, quiz maker, study plannerChapter 32.5
MemoryStudent ka naam, kamzor topics (session + vector memory)Chapter 32.9, 33.4
GuardrailsSirf course ke sawal, nijee data par inkaarChapter 32.9
Safetymax_turns, kharche ki had, ijazat wale actions par manzooriChapter 33.7
EvaluationKam az kam 15 sawalon ka test setaur success rateChapter 33.7
Deliverables​
  1. Chalne wala code (Colab notebook ya .py) aur README (kya karta hai, kaise chalaen).

  2. Architecture ka nakshaa (tasveer): tools, memory, RAG, guardrails.

  3. Test set aur success rate ki report (kitne PASS, FAIL ki wajah).

  4. Demo: 2 se 3 minute ki screen recording.

RubricNumber
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 README15
Demo aur wazahat10
Kul100

33.10 Module 9 ka Mukhtasar​

ChapterMukhya IdeaAham Code / Tool
32: Agents SDKFunction calling, @function_tool, Runner, handoffs, sessionsAgent, Runner, function_tool
33: Agentic AIReAct, planning, memory, multi-agent, safety aur evaluationReAct loop, graphlib, vector
memory

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 KB me naya fact jodo aur policy ko ek aur qadam ke liye badlo.

  • Plan: plan me ek naya kaam "deploy_karo" jodo jo evaluate_karo par depend kare; order dekho.

  • Memory: VectorMemory me 5 aur yaadein jodo aur 3 alag sawal pooch kar recall dekho.

  • Multi-agent: reviewer me 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: tests me 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.