पाठ्यक्रम 250 में से पाठ 175 · Agents बनाना (tool-use और ReAct)
Agents बनाना (tool-use और ReAct)

agent memory और स्थिति जमा करना

आपने जो ReAct loop बनाया उसकी याददाश्त नहीं है: हर क़दम एक tool बुलाता है और भूल जाता है। एक असली agent को जो सीखा वह आगे ले जाना होता है - ढूँढे तथ्य, tools के लौटाए नतीजे - ताकि बाद का क़दम उन्हें इस्तेमाल कर सके। वह चलती नोटबुक agent की memory है (लोग इसे scratchpad या working context भी कहते हैं)। यह आपके कोड की है; मॉडल की कभी नहीं।

पर संदर्भ मुफ़्त नहीं है। memory में सब कुछ अगले क़दम पर prompt में वापस ठूँसा जाता है, और मॉडल की tokens में मापी एक तय context window होती है। memory को हमेशा बढ़ने दें और आख़िरकार window उफ़न जाती है (और साथ में हर token का भुगतान)। इसलिए memory के दो आधे चाहिए: चलते-चलते नए तथ्य जमा करें, और बहुत बड़ा होने पर बजट तक काटें।

इसका आकार

स्थिति एक dict है: एक स्थायी system नोट (agent के स्थायी निर्देश, जिन्हें आप कभी नहीं फेंकते) और उसके इकट्ठा किए facts की एक सूची:

state = {"system": "You are a research agent.", "facts": []}

हर observation एक तथ्य पंक्ति बनता है। tool चलने के बाद आप जो हुआ उसका पढ़ने लायक record जोड़ते हैं:

state["facts"].append(f"{tool}({args}) -> {observation}")

token बजट तक काटना

असली tokenizers सीखे हुए और subword-आधारित होते हैं; हम यहाँ एक नहीं चला सकते, इसलिए हम एक token को एक ख़ाली-जगह शब्द (len(text.split())) मानते हैं - LLM मॉड्यूल वाली ही तरकीब। (production में आप API के usage field से असली subword गिनती, या len(text) / 4 अक्षर वाला मोटा नियम इस्तेमाल करेंगे; ख़ाली-जगह अनुमान बस इस अभ्यास को निश्चित रखता है।) काटने का नियम वही है जो production agents असल में करते हैं: system नोट हमेशा रखें, फिर बजट के बचे हिस्से में जितने सबसे हाल के तथ्य आएँ रखें। हाल वाला जीतता है क्योंकि ताज़ा नतीजे आमतौर पर वही हैं जिनकी अगले क़दम को ज़रूरत है।

budget = max_tokens - est_tokens(state["system"])
# walk facts newest-first, keep while they fit, then stop

तथ्यों पर सबसे नए से सबसे पुराने तक चलें, हर एक की token लागत जोड़ते हुए जब तक अगला तथ्य बजट न उड़ा दे, फिर रुकें। वापस उलटें ताकि रखे तथ्य अपने मूल क्रम में रहें। अगर बजट बहुत छोटा है तो आप शून्य तथ्य रख सकते हैं, पर system नोट हमेशा बचता है।

एक live agent में मॉडल हर क़दम की शुरुआत में render(state) पढ़ता और हर tool call के बाद वही जमा-फिर-काटो चक्र चलता, इसलिए window कभी नहीं उफ़नती। on-device ट्यूटर यह loop चला सकता है, पर ग्रेडिंग सिर्फ़ निश्चित स्थिति जाँचती है। एक छोटी प्रतिलिपि जमा करने और तंग बजट में सबसे पुराने तथ्यों को गिरते देखने के लिए Run दबाएँ।

आपकी बारी

agent की memory बनाएँ। new_state(system_note) -> {"system": note, "facts": []} लिखें; record(state, tool, args, observation) जो तथ्य पंक्ति "<tool>(<args>) -> <observation>" जोड़े और स्थिति लौटाए; est_tokens(text) -> ख़ाली-जगह token गिनती; और trim(state, max_tokens) जो system नोट और वे सबसे हाल के तथ्य रखे जिनके tokens (system नोट बजट में गिना जाता है) max_tokens में आएँ। फिर accumulate(system_note, transcript, max_tokens) लिखें: एक नई स्थिति शुरू करें, हर (tool, args, observation) क़दम क्रम से record करें, आख़िर में एक बार trim करें, और कटी स्थिति लौटाएँ।

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

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

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