Python में स्क्रैच से एक AI एजेंट का निर्माण कैसे करें और यह इसके लायक क्यों है

मेटा विवरण: जानें कि एक AI एजेंट क्या है और स्पष्ट चरणों, व्यावहारिक सीमाओं और सामान्य गलतियों के साथ Anthropic API का उपयोग करके सादे Python में स्क्रैच से निर्माण करें।

टैगः AI एजेंट, Python , Anthropic API, LLM आवेदन

विशेष रुप से प्रदर्शित छवि: एक Python स्क्रिप्ट और जुड़े नोड्स का अमूर्त चित्रण जो AI एजेंट वर्कफ़्लो, दोस्ताना शैली, कोई वास्तविक लोग, कोई लोगो, कोई पाठ नहीं दर्शाता है।

डेवलपर्स जो सरल chatbot कॉल से आगे बढ़ना चाहते हैं, वे सादे Python का उपयोग करके स्क्रैच से एक AI एजेंट बना सकते हैं। Anthropic API मूल विचार छोटा हैः एक एजेंट लक्ष्य लेता है, अगले चरण के लिए एक मॉडल पूछता है, परिणाम की जांच करता है, और जब तक वह जवाब या रोक नहीं सकता तब तक दोहराता है। यह गाइड बताता है कि एक AI एजेन्ट क्या है, न्यूनतम लूप की आवश्यकता है और प्रोजेक्ट को बड़े प्लेटफॉर्म में बदलने के बिना मेमोरी और सुरक्षित स्टॉपिंग स्थितियों को कैसे जोड़ें।

एक AI एजेंट क्या है और क्यों छोटे से शुरू करें

एक AI एजेंट software है जो क्रियाओं को चुनने के लिए भाषा मॉडल का उपयोग करता है, न कि JUST उत्तर लिखता है। chatbot आमतौर पर संदेश प्राप्त करता है और इसे किसी मॉडल में भेजता है और जवाब देता है। एक एजेंट लूप जोड़ता है. यह पिछले चरणों को संग्रहीत कर सकता है, वर्तमान कार्य का निरीक्षण कर सकते हैं, टूल को बुला सकते हैं , आउटपुट का मूल्यांकन कर सकते है और जारी रखने या नहीं करने का निर्णय ले सकते हैं। मॉडल तर्क इंजन हो सकता है जबकि Python राज्य, त्रुटियों, उपकरण कॉल और रोक नियम संभालती है।

छोटे से शुरू करना महत्वपूर्ण है क्योंकि एजेंट लूप महंगे और डिबग करने के लिए कठिन हो सकते हैं। एक न्यूनतम एजेंट को फ्रेमवर्क, vector database , या बड़ी टूल लाइब्रेरी की आवश्यकता नहीं होती है। इसे चार भागों की आवश्यकता होती हैः एक स्पष्ट लक्ष्य, संदेश इतिहास, मॉडल कॉल और रोकने का नियम। एक बार जब यह लूप काम करता है, तो डेवलपर्स एक समय में खोज, फ़ाइल रीडिंग, कैलकुलेटर या एप्लिकेशन-विशिष्ट फ़ंक्शंस जोड़ सकते हैं.

Anthropic API इस पैटर्न का समर्थन कर सकता है क्योंकि यह एक मॉडल इंटरफ़ेस प्रदान करता है जो निर्देशों, वार्तालाप संदर्भ और सिस्टम मार्गदर्शन को स्वीकार करता है। सटीक मॉडल विकल्प, दर सीमाओं और मूल्य निर्धारण की जांच प्रदाता दस्तावेज में की जानी चाहिए क्योंकि वे विवरण बदल सकते हैं। शुरुआती के लिए, व्यावहारिक प्रश्न यह नहीं है कि मॉडल कितना शक्तिशाली है। सवाल यह है कि क्या लूप एजेंट को केंद्रित रखता है, जरूरत पड़ने पर बंद हो जाता है, और एक उपयोगी परिणाम देता है।

एजेंट चरण-दर-चरण बनाएँ

1. एक API कुंजी बनाएँ और इसे सुरक्षित रूप से संग्रहीत करें. कुंजी को source code के बाहर रखें, अधिमानतः पर्यावरण चर में। यदि कोड साझा किया गया है, तो स्थानीय कॉन्फ़िगरेशन फ़ाइल से कुंजी लोड करें जिसे संस्करण नियंत्रण द्वारा अनदेखा कर दिया जाता है। लॉग्स में कभी भी कुंजी प्रिंट न करें.

1. कार्य और रुकने की स्थिति को परिभाषित करें। एक वाक्य लिखें जो वर्णन करता है कि एजेंट को क्या हासिल करना चाहिए, जैसे आपूर्ति किए गए पाठ का उपयोग करके किसी प्रश्न का उत्तर देना। फिर यह तय करें कि इसे कब रोकना चाहिए: जब उसके पास पर्याप्त जानकारी हो, जब वह अधिकतम संख्या में कदमों तक पहुंच जाए, या जब वह अंतिम उत्तर उत्पन्न करे। स्टॉप शर्त के बिना, एक एजेंट बार-बार कॉल कर सकता है और समय या बजट बर्बाद कर सकते हैं।

1. वार्तालाप स्थिति को संग्रहीत करें. एक साधारण एजेंट संदेशों की सूची रख सकता है। प्रत्येक संदेश के लिए सिस्टम, उपयोगकर्ता, सहायक या टूल परिणाम और सामग्री जैसी भूमिकाओं की आवश्यकता होती है। सिस्टम संदेश व्यवहार सेट करता है, उपयोगकर्ता संदेश कार्य देता है, और सहायक संदेश मॉडल प्रतिक्रिया रिकॉर्ड करता है। सादे Python में, पहले प्रोटोटाइप के लिए शब्दकोशों की एक सूची पर्याप्त है।

1. राज्य को भेजें Anthropic API। अनुरोध में चयनित मॉडल, सिस्टम निर्देश, संदेश इतिहास और एक उचित अधिकतम प्रतिक्रिया आकार शामिल होना चाहिए। उत्तर सावधानी से पार्स किया जाना चाहिए। यदि API त्रुटि देता है, तो एजेंट को इसे पुनः प्रयास करके, विफलता की रिपोर्ट करके या रोककर संभालना चाहिए। यह न मानें कि हर अनुरोध सफल होगा।

1. मॉडल आउटपुट को निर्णय के रूप में व्याख्या करें. आउटपुट सादा पाठ हो सकता है, लेकिन जब मॉडल एक संरचित निर्देश देता है तो एजेंट बेहतर काम करता है। शुरुआत करने वाले के लिए, एक साधारण टेक्स्ट कन्वेंशन पर्याप्त होता है, जैसे कि मॉडल से अपना उत्तर एक्शनः या अंतिम जवाब के साथ शुरू करने के लिए पूछना: बाद का संस्करण JSON मांग सकता है , लेकिन सख्त पार्सिंग रक्षात्मक होना चाहिए और खराब आउटपुट पर दुर्घटनाग्रस्त नहीं होना चाहिए।

1. टूल या उत्तर चरण चलाएँ. यदि मॉडल एक क्रिया चुनता है, तो Python मिलान फ़ंक्शन निष्पादित करता है. यह फ़ंक्शंस फ़ाइल पढ़ सकता है, स्थानीय सूची में खोज कर सकते हैं, किसी आंतरिक सेवा को बुला सकते हैं या गणना कर सकता है। उपकरण का परिणाम तब संदेश इतिहास में अवलोकन के रूप में जोड़ा जाता है। अगर मॉडल अंतिम उत्तर देता है, लूप समाप्त होता है.

1. परिणाम लौटाएं और ट्रेस को लॉग करें. विकास के लिए, लक्ष्य, प्रत्येक चरण, उपकरण नाम, उपकरण आउटपुट लंबाई और अंतिम उत्तर सहेजें. एक ट्रेस डिबगिंग को बहुत आसान बनाता है क्योंकि कई एजेंट विफलताएँ मॉडल विफलताओं नहीं हैं। वे अनुपस्थित संदर्भ, गलत उपकरण चयन, अप्रबंधित अपवाद या रोक की स्थिति जो बहुत ढीली है।

ओवरबिल्डिंग के बिना स्मृति और उपकरण उपयोग जोड़ें

स्मृति एक-बंद संकेत और एजेंट के बीच का अंतर है जो किसी कार्य को आगे बढ़ा सकता है। सबसे छोटी उपयोगी मेमोरी हालिया संदेशों की रोलिंग विंडो है। लंबी अवधि की स्मृति पिछले रन से तथ्यों को संग्रहीत कर सकती है, लेकिन इसे केवल तभी जोड़ा जाना चाहिए जब कार्य इसकी आवश्यकता हो। कई छोटे एजेंटों में context window पर्याप्त है।

उपकरण उपयोग एक ही सिद्धांत का पालन करना चाहिए. एक उपकरण और एक स्पष्ट विफलता पथ के साथ शुरू करें। एक उपकरण को सरल इनपुट स्वीकार करना चाहिए, संरचित आउटपुट लौटाएं, और कभी भी रहस्यों को उजागर न करें। यदि कोई टूल डेटा बदल सकता है, तो पुष्टि की आवश्यकता हो सकती है या इसे सैंडबॉक्स वातावरण तक सीमित कर सकते हैं। अगर कोई उपकरण बाहरी सामग्री पढ़ता है तो उस सामग्री को अविश्वसनीय इनपुट के रूप में मानें। एजेंट को सुरक्षा जांच के बिना पुनर्प्राप्त पाठ में पाए गए निर्देशों को निष्पादित नहीं करना चाहिए।

एक उपयोगी पैटर्न यह है कि मॉडल को कोई कार्रवाई प्रस्तावित करने दें और Python इसे मान्य करे। मॉडल कह सकता है कि कौन सा टूल चलाना चाहिए और किन तर्कों की आवश्यकता है, लेकिन Python तय करता है कि उपकरण मौजूद है या नहीं, क्या तर्क अनुमति दिए जाते हैं, और क्या कार्रवाई सुरक्षित है। इससे सिस्टम लचीला रहता है बिना मॉडल को अनचेक कंट्रोल दिया जाए।

आगे क्या देखना है

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

डेवलपर्स को API सीमाओं, प्रतिक्रिया प्रारूप परिवर्तनों और टूल आउटपुट लंबाई पर भी ध्यान देना चाहिए। लंबे लॉग context window भर सकते हैं और एजेंट को मूल लक्ष्य भूल सकता है। पुराने चरणों का सारांश या केवल प्रमुख तथ्यों को संग्रहीत करने से मदद मिल सकती है। उत्पादन उपयोग के लिए, दर सीमित करना, पुनः प्रयास, निगरानी जोड़ें, और उपयोगकर्ता-सामना त्रुटि संदेश स्पष्ट करें। Because API विवरण बदल सकते हैं, विशिष्ट मापदंडों, मॉडल नामों, सीमाओं या मूल्य निर्धारण पर भरोसा करने से पहले Anthropic API प्रलेखन की जांच करें।

आम गलतियाँ

• रोक की स्थिति को परिभाषित करने से पहले एक एजेंट का निर्माण करना।
• रक्षात्मक पार्सिंग के बिना गारंटीकृत मान्य JSON के रूप में मॉडल आउटपुट का इलाज करना।
• बहुत जल्दी कई उपकरण जोड़ना, जो डिबगिंग को कठिन बनाता है.
• असीमित लूप की अनुमति देकर लागत और विलंबता को अनदेखा करना।
• Storing API source code में कुंजी या उन्हें लॉग्स में प्रिंट करना।
• डेटा के बजाय निर्देशों के रूप में पुनर्प्राप्त सामग्री पर भरोसा करना।
• एक ट्रेस लॉग को छोड़ना, जो विफलताओं को पुनः पेश करना कठिन बनाता है.