पाठ्यक्रम 250 में से पाठ 231 · प्रोजेक्ट: tool इस्तेमाल करने वाला research agent
प्रोजेक्ट: tool इस्तेमाल करने वाला research agent

agent का ReAct loop जोड़ें

अब प्रोजेक्ट का दिल: ReAct loop (सोचो -> करो -> देखो), लगभग हर agent framework के पीछे का control loop। मॉडल एक बार में जवाब नहीं देता। वह एक क़दम सोचता है, एक tool चुनता है, उसे चलाता है, नतीजा पढ़ता है, और तभी तय करता है कि आगे क्या करना है। आपका काम वह loop नक़ली tools पर सादे Python में लिखना है, ताकि आप LangChain को काला डिब्बा मानने के बजाय मशीनरी समझें।

एक असली deployment में "सोचो" क़दम एक LLM कॉल है। यहाँ हम मॉडल को एक छोटी निश्चित नीति से बदलते हैं ताकि पूरी चीज़ offline टेस्ट हो सके (कोई network नहीं, कोई API नहीं)। नीति काम और अब तक इकट्ठा observations देखती है, और अगला काम लौटाती है। वह अलगाव ही असली सबक है: loop सामान्य है; सिर्फ़ नीति समझदार है।

एक काम एक छोटा spec है जिसे नीति पढ़ती है:

task = {"need": ["team size", "office floors"], "op": "*"}
# "look up these facts, then combine them with this operator"

आप run_agent(task, tools, max_steps=8) बनाएँगे। यह एक trace लौटाता है: (thought, tool, args, observation) tuples की क्रमबद्ध सूची, हर क़दम का एक। वह trace agent का पूरा सोच इतिहास है, और ठीक वही है जिसे आप लॉग करते, दोबारा चलाते, और (अगले पाठ) परखते हैं।

loop जो सोच दर्ज करता है, हर दौर:

  • अगर कोई ज़रूरी तथ्य अब भी अज्ञात है, तो अगला काम पहले ग़ायब वाले के लिए search है। observation दर्ज करें और तथ्य याद रखें।
  • जब सारे तथ्य इकट्ठा हो जाएँ और काम में एक op हो, तो अगला काम दोनों तथ्यों को मिलाने के लिए calc है। नतीजा याद रखें।
  • जब करने को कुछ न बचे, तो एक आख़िरी finish काम दें जिसका observation जवाब हो, और रुकें।
def run_agent(task, tools, max_steps=8):
    trace, facts = [], {}
    for _ in range(max_steps):
        missing = [k for k in task["need"] if k not in facts]
        if missing:
            key = missing[0]
            obs = tools["search"]({"query": key})   # ACT + OBSERVE
            facts[key] = obs
            trace.append(("need " + key, "search", {"query": key}, obs))
            continue
        ...   # compute if there is an op, else finish

tools dict भावना में पाठ 1 वाली आपकी registry है: search(args) एक तथ्य सुलझाता है, calc(args) a और b पर op लगाता है। आख़िरी जवाब op होने पर calc का नतीजा है, या न होने पर अकेला ढूँढा तथ्य। ग्रेडर क़दम दर क़दम (tool, args, observation) क्रम और आख़िरी जवाब जाँचता है, इसलिए loop को सचमुच सही route करना होगा, अंदाज़ा नहीं। यह एक दूसरा, अलग काम भी चलाता है, इसलिए hardcode किया trace पास नहीं हो सकता। दो-तथ्य वाले काम को सोचते हुए जवाब तक पहुँचते देखने के लिए Run दबाएँ।

आपकी बारी

make_tools() लिखें जो search(args) (शुरुआती कोड में दी FACTS तालिका के सामने args["query"] सुलझाएँ; न हो तो "not found") और calc(args) (+ - * / के लिए args["a"], args["b"] पर args["op"] लगाएँ) वाली dict लौटाए। फिर सोचो-करो-देखो loop लागू करने वाला run_agent(task, tools, max_steps=8) लिखें: task["need"] की हर अब भी ग़ायब कुंजी search करें (पहली ग़ायब पहले), फिर task["op"] सेट हो तो calc, फिर एक आख़िरी finish क़दम (thought, "finish", {"answer": answer}, answer) के रूप में लिखा। (thought, tool, args, observation) tuples की क्रमबद्ध सूची लौटाएँ; आख़िरी जवाब calc नतीजा है, या op न होने पर अकेला तथ्य।

इस पाठ में कोई समस्या दिखी? बताएँ · इस पाठ के बारे में पूछें

यह अभ्यास जल्द खुलेगा

इससे पहले वाला पाठ पूरा करें और यह खुल जाएगा। पूरा कोर्स मुफ़्त है, कोई खाता नहीं चाहिए, और आप यह पाठ अभी पढ़ सकते हैं।