LLM एजेंट्स में मास्टर करें: LangGraph और CrewAI के साथ जटिल वर्कफ़्लो स्वचालित करें - ओपन सोर्स हैंडबुक

कभी महसूस होता है कि आपके AI टूल थोड़े... निष्क्रिय हैं? जैसे वे बस वहां बैठे हैं, आपके अगले कमांड का इंतजार कर रहे हैं? कल्पना करें कि वे पहल कर सकें, बड़ी समस्याओं को तोड़ सकें, और यहां तक कि चीजों को पूरा करने के लिए मिलकर काम कर सकें।

यही LLM एजेंट्स टेबल पर लाते हैं। वे बदल रहे हैं कि हम जटिल कार्यों को कैसे स्वचालित करते हैं, और वे हमारे AI विचारों को एक बिल्कुल नए तरीके से जीवन में लाने में मदद कर सकते हैं।

इस लेख में, हम पता लगाएंगे कि LLM एजेंट्स क्या हैं, वे कैसे काम करते हैं, और आप भयानक ओपन-सोर्स फ्रेमवर्क का उपयोग करके अपना खुद का निर्माण कैसे कर सकते हैं।

हम क्या कवर करेंगे:

1. LLM एजेंट्स की वर्तमान स्थिति

   • चैटबॉट्स से स्वायत्त एजेंट्स तक

   • आज एजेंट्स क्या कर सकते हैं?

   • निर्माण के लिए क्या उपलब्ध है?

   • अब सीखने का सबसे अच्छा समय क्यों है

2. LLM एजेंट्स क्या हैं और वे बड़ी बात क्यों हैं?

   • LLM क्या है?

   • तो, LLM एजेंट क्या है?

   • यह क्यों मायने रखता है?

3. ओपन-सोर्स एजेंट फ्रेमवर्क का उदय

   • लोकप्रिय ओपन-सोर्स एजेंट फ्रेमवर्क

   • ये टूल क्या सक्षम करते हैं

   • स्क्रैच से निर्माण के बजाय फ्रेमवर्क का उपयोग क्यों करें?

4. एजेंट डिजाइन के पीछे मुख्य अवधारणाएं

   • एजेंट लूप

   • एजेंट के प्रमुख घटक

   • बहु-एजेंट सहयोग

5. प्रोजेक्ट: ईमेल से अपने दैनिक शेड्यूल को स्वचालित करें

   • हम क्या स्वचालित कर रहे हैं

   • चरण 1: आवश्यक टूल इंस्टॉल करें

   • चरण 2: कार्य को परिभाषित करें

   • चरण 3: LangGraph के साथ वर्कफ़्लो बनाएं

6. CrewAI के साथ बहु-एजेंट सहयोग

   • CrewAI क्या है?

   • ईमेल सारांश कार्य के लिए नमूना भूमिकाएं

   • नमूना CrewAI कोड

7. निष्पादन के दौरान वास्तव में क्या होता है?

8. क्या LLM एजेंट्स सुरक्षित हैं? सुरक्षा और गोपनीयता के बारे में क्या जानना है

9. समस्या निवारण और टिप्स

10. अधिक दैनिक स्वचालन का अन्वेषण करें

11. एजेंट तकनीक में आगे क्या है?

12. अंतिम सारांश

LLM एजेंट्स की वर्तमान स्थिति

LLM एजेंट्स अभी AI में सबसे रोमांचक विकासों में से एक हैं। वे पहले से ही वास्तविक कार्यों को स्वचालित करने में मदद कर रहे हैं लेकिन वे अभी भी विकसित हो रहे हैं। तो आज हम कहां हैं?

चैटबॉट्स से स्वायत्त एजेंट्स तक

GPT-4, Claude, Gemini, और LLaMA जैसे बड़े भाषा मॉडल (LLMs) सरल चैटबॉट्स से आश्चर्यजनक रूप से सक्षम रीजनिंग इंजन में विकसित हुए हैं। वे सामान्य ज्ञान के सवालों के जवाब देने और निबंध उत्पन्न करने से लेकर जटिल तर्क करने, बहु-चरण निर्देशों का पालन करने, और वेब खोज और कोड इंटरप्रेटर जैसे टूल के साथ बातचीत करने तक चले गए हैं।

लेकिन यहाँ पकड़ है: ये मॉडल प्रतिक्रियाशील हैं। वे इनपुट की प्रतीक्षा करते हैं और आउटपुट देते हैं। वे कार्यों के बीच मेमोरी बरकरार नहीं रखते, आगे की योजना नहीं बनाते, या अपने दम पर लक्ष्यों का पीछा नहीं करते। यहीं LLM एजेंट्स आते हैं - वे संरचना, मेमोरी और स्वायत्तता जोड़कर इस अंतर को पाटते हैं।

आज एजेंट्स क्या कर सकते हैं?

अभी, LLM एजेंट्स पहले से ही उपयोग किए जा रहे हैं:

• ईमेल या दस्तावेज़ सारांशित करना

• दैनिक शेड्यूल योजना बनाना

• DevOps स्क्रिप्ट चलाना

• उत्तरों के लिए API या टूल खोजना

• जटिल कार्यों को पूरा करने के लिए छोटी "टीमों" में सहयोग करना

लेकिन वे अभी तक पूर्ण नहीं हैं। एजेंट्स अभी भी कर सकते हैं:

• लूप में फंस जाना

• लक्ष्यों को गलत समझना

• विस्तृत संकेत और गार्डरेल्स की आवश्यकता होना

ऐसा इसलिए है क्योंकि यह तकनीक अभी प्रारंभिक चरण में है। फ्रेमवर्क तेजी से बेहतर हो रहे हैं, लेकिन विश्वसनीयता और मेमोरी अभी भी प्रगति पर हैं। इसलिए प्रयोग करते समय इसे ध्यान में रखें।

अब सीखने का सबसे अच्छा समय क्यों है

सच्चाई यह है: हम अभी भी शुरुआत में हैं। लेकिन बहुत शुरुआत में नहीं।

एजेंट्स के साथ प्रयोग शुरू करने का यह सही समय है:

• टूलिंग वास्तविक प्रोजेक्ट बनाने के लिए पर्याप्त परिपक्व है

• समुदाय तेजी से बढ़ रहा है

• और आपको AI विशेषज्ञ होने की आवश्यकता नहीं है, बस Python के साथ सहज होना चाहिए

LLM एजेंट्स क्या हैं और वे बड़ी बात क्यों हैं?

इससे पहले कि हम एजेंट्स की रोमांचक दुनिया में गोता लगाएं, आइए बुनियादी बातों पर थोड़ा और चर्चा करें।

LLM क्या है?

LLM, या लार्ज लैंग्वेज मॉडल, मूल रूप से एक AI है जिसने इंटरनेट से भारी मात्रा में टेक्स्ट से सीखा है - किताबें, लेख, कोड, और बहुत कुछ। आप इसे एक सुपर-स्मार्ट ऑटोकंप्लीट इंजन के रूप में चित्रित कर सकते हैं। लेकिन यह सिर्फ आपके वाक्यों को पूरा करने से कहीं अधिक करता है। यह भी कर सकता है:

• पेचीदा सवालों के जवाब देना

• लंबे लेख या दस्तावेज़ सारांशित करना

• कोड, ईमेल, या रचनात्मक कहानियां लिखना

• भाषाओं का तुरंत अनुवाद करना

• यहां तक कि तर्क पहेलियों को हल करना और आकर्षक बातचीत करना

संभावना है कि आपने ChatGPT के बारे में सुना होगा, जो OpenAI के GPT मॉडल द्वारा संचालित है। अन्य लोकप्रिय LLMs जिनसे आप मिल सकते हैं उनमें Claude (Anthropic से), LLaMA (Meta द्वारा), Mistral, और Gemini (Google से) शामिल हैं।

ये मॉडल केवल संदर्भ के आधार पर एक वाक्य में अगले शब्द की भविष्यवाणी करके काम करते हैं। जबकि यह सीधा लगता है, जब अरबों शब्दों पर प्रशिक्षित किया जाता है, तो LLMs आश्चर्यजनक रूप से बुद्धिमान व्यवहार करने में सक्षम हो जाते हैं, आपके निर्देशों को समझते हैं, चरण-दर-चरण तर्क का पालन करते हैं, और लगभग किसी भी विषय पर सुसंगत प्रतिक्रियाएं उत्पन्न करते हैं जिसकी आप कल्पना कर सकते हैं।

तो, LLM एजेंट क्या है?

जबकि LLMs सुपर शक्तिशाली हैं, वे आमतौर पर सिर्फ प्रतिक्रिया करते हैं - वे केवल तभी प्रतिक्रिया देते हैं जब आप उनसे कुछ पूछते हैं। दूसरी ओर, एक LLM एजेंट, सक्रिय है।

LLM एजेंट्स कर सकते हैं:

• बड़े, जटिल कार्यों को छोटे, प्रबंधनीय चरणों में तोड़ना

• स्मार्ट निर्णय लेना और यह पता लगाना कि आगे क्या करना है

• वेब खोज, कैलकुलेटर, या यहां तक कि अन्य ऐप्स जैसे "टूल्स" का उपयोग करना

• एक लक्ष्य की दिशा में काम करना, भले ही इसमें कई चरण या प्रयास लगें

• साझा उद्देश्यों को पूरा करने के लिए अन्य एजेंट्स के साथ टीम बनाना

संक्षेप में, LLM एजेंट्स सोच सकते हैं, योजना बना सकते हैं, कार्य कर सकते हैं, और अनुकूलित कर सकते हैं।

LLM एजेंट को अपने सुपर-कुशल नए सहायक की तरह समझें: आप इसे एक लक्ष्य देते हैं, और यह अपने दम पर इसे हासिल करने का तरीका ढूंढ लेता है।

यह क्यों मायने रखता है?

सिर्फ प्रतिक्रिया देने से सक्रिय रूप से लक्ष्यों का पीछा करने की यह पारी एक टन रोमांचक संभावनाएं खोलती है:

• उबाऊ IT या DevOps कार्यों को स्वचालित करना

• कच्चे डेटा से विस्तृत रिपोर्ट उत्पन्न करना

• बहु-चरण अनुसंधान परियोजनाओं में आपकी मदद करना

• आपके दैनिक ईमेल पढ़ना और मुख्य जानकारी हाइलाइट करना

• वास्तविक दुनिया की कार्रवाई करने के लिए अपने आंतरिक टूल चलाना

पुराने, नियम-आधारित बॉट्स के विपरीत, LLM एजेंट्स तर्क कर सकते हैं, प्रतिबिंबित कर सकते हैं, और अपने प्रयासों से सीख सकते हैं। यह उन्हें वास्तविक दुनिया के कार्यों के लिए बेहतर बनाता है जो गन्दे हैं, लचीलेपन की आवश्यकता होती है, और संदर्भ को समझने पर निर्भर करते हैं।

ओपन-सोर्स एजेंट फ्रेमवर्क का उदय

बहुत समय पहले नहीं, यदि आप एक AI सिस्टम बनाना चाहते थे जो स्वायत्त रूप से कार्य कर सके, तो इसका मतलब था बहुत सारा कस्टम कोड लिखना, मेमोरी को सावधानीपूर्वक प्रबंधित करना, और दर्जनों घटकों को एक साथ जोड़ने की कोशिश करना। यह एक जटिल, नाजुक और अत्यधिक विशिष्ट काम था।

लेकिन अनुमान लगाएं क्या? अब ऐसा नहीं है।

2024 में, शानदार ओपन-सोर्स फ्रेमवर्क की एक लहर आई। इन टूल्स ने शक्तिशाली LLM एजेंट्स बनाना नाटकीय रूप से आसान बना दिया है, बिना आपको हर बार पहिया का पुनर्निर्माण किए।

लोकप्रिय ओपन-सोर्स एजेंट फ्रेमवर्क

ये टूल क्या सक्षम करते हैं

ये फ्रेमवर्क आपको एजेंट्स बनाने के मुश्किल हिस्सों को संभालने के लिए रेडी-मेड बिल्डिंग ब्लॉक्स देते हैं:

• योजना - एजेंट्स को उनका अगला कदम तय करने देना

• टूल उपयोग - एजेंट्स को फाइल सिस्टम, वेब ब्राउज़र, API, या डेटाबेस जैसी चीजों से आसानी से जोड़ना

• मेमोरी - दीर्घकालिक संदर्भ के लिए पिछली जानकारी या मध्यवर्ती परिणामों को संग्रहीत और पुनर्प्राप्त करना

• बहु-एजेंट सहयोग - साझा लक्ष्यों पर एक साथ काम करने वाली एजेंट्स की टीम सेट करना

स्क्रैच से निर्माण के बजाय फ्रेमवर्क का उपयोग क्यों करें?

जबकि आप कर सकते हैं एक कस्टम एजेंट को जमीन से बनाएं, एक फ्रेमवर्क का उपयोग करने से आपका बहुत सारा समय और मेहनत बच जाएगी। ओपन-सोर्स एजेंट लाइब्रेरी के साथ आती हैं:

• LLMs को ऑर्केस्ट्रेट करने के लिए बिल्ट-इन सपोर्ट

• कार्य योजना, ट्रैक रखने और फीडबैक प्राप्त करने के लिए सिद्ध पैटर्न

• OpenAI जैसे लोकप्रिय मॉडल के साथ आसान एकीकरण, या यहां तक कि स्थानीय रूप से चलने वाले मॉडल

• एक सहायक एजेंट से लेकर एजेंट्स की पूरी टीम तक बढ़ने की लचीलापन

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

एजेंट डिजाइन के पीछे मुख्य अवधारणाएं

यह समझने के लिए कि LLM एजेंट्स कैसे काम करते हैं, यह सोचने में मदद करता है कि वे लक्ष्य-संचालित सिस्टम हैं जो लगातार अवलोकन, तर्क और कार्य करने के माध्यम से चक्र करते हैं। यह निरंतर लूप उन्हें सरल प्रश्नों और उत्तरों से परे कार्यों से निपटने की अनुमति देता है, वास्तविक स्वचालन, टूल उपयोग, और फ्लाई पर अनुकूलन में आगे बढ़ता है।

एजेंट लूप

अधिकांश LLM एजेंट एजेंट लूप नामक एक मानसिक मॉडल पर आधारित कार्य करते हैं, एक चरण-दर-चरण चक्र जो तब तक दोहराता है जब तक काम पूरा नहीं हो जाता। यहां बताया गया है कि यह आमतौर पर कैसे काम करता है:

• 인지 करें (Perceive): एजेंट अपने वातावरण में कुछ नोटिस करके या नई जानकारी प्राप्त करके शुरू करता है। यह आपका प्रॉम्प्ट, डेटा का एक टुकड़ा, या सिस्टम की वर्तमान स्थिति हो सकती है।

• योजना बनाएं (Plan): जो यह देखता है और इसके समग्र लक्ष्य के आधार पर, एजेंट तय करता है कि आगे क्या करना है। यह कार्य को छोटे उप-लक्ष्यों में तोड़ सकता है या नौकरी के लिए सबसे अच्छा टूल ढूंढ सकता है।

• कार्य करें (Act): एजेंट फिर कार्य करता है। इसका मतलब एक फ़ंक्शन चलाना, API कॉल करना, वेब खोजना, डेटाबेस के साथ बातचीत करना, या यहां तक कि किसी अन्य एजेंट से मदद मांगना हो सकता है।

• प्रतिबिंबित करें (Reflect): कार्य करने के बाद, एजेंट परिणाम को देखता है: क्या यह काम किया? क्या परिणाम उपयोगी था? क्या इसे एक अलग दृष्टिकोण आजमाना चाहिए? इसके आधार पर, यह अपनी योजना को अपडेट करता है और तब तक चलता रहता है जब तक कार्य पूरा नहीं हो जाता।

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

एजेंट के प्रमुख घटक

अपना काम प्रभावी ढंग से करने के लिए, एजेंट्स कई महत्वपूर्ण भागों के आसपास बनाए जाते हैं:

• टूल्स हैं कि एक एजेंट वास्तविक (या डिजिटल) दुनिया के साथ कैसे बातचीत करता है। ये खोज इंजन, कोड निष्पादन वातावरण, फ़ाइल रीडर, या API क्लाइंट, से लेकर सरल कैलकुलेटर या कमांड-लाइन स्क्रिप्ट तक कुछ भी हो सकते हैं।

• मेमोरी एजेंट्स को याद रखने देती है कि उन्होंने अलग-अलग चरणों में क्या किया या देखा है। इसमें आपके द्वारा पहले कही गई चीजें, अस्थायी परिणाम, या प्रमुख निर्णय शामिल हो सकते हैं। कुछ फ्रेमवर्क शॉर्ट-टर्म मेमोरी (सिर्फ एक सत्र के लिए) प्रदान करते हैं, जबकि अन्य लॉन्ग-टर्म मेमोरी का समर्थन करते हैं जो कई सत्रों या लक्ष्यों तक फैल सकती है।

• पर्यावरण (Environment) बाहरी डेटा या सिस्टम संदर्भ को संदर्भित करता है जिसमें एजेंट संचालित होता है - API, दस्तावेज़, डेटाबेस, फाइलें, या सेंसर इनपुट। जितनी अधिक जानकारी और पहुंच एक एजेंट के पास अपने पर्यावरण के लिए होती है, उतने ही सार्थक कार्य यह कर सकता है।

• लक्ष्य (Goal) एजेंट का अंतिम उद्देश्य है: जो वह हासिल करने की कोशिश कर रहा है। लक्ष्य विशिष्ट और स्पष्ट होने चाहिए, उदाहरण के लिए, "दैनिक शेड्यूल उत्पन्न करें," "इस दस्तावेज़ को सारांशित करें," या "ईमेल से कार्य निकालें।"

बहु-एजेंट सहयोग

अधिक उन्नत सिस्टम के लिए, आप कई एजेंट्स को एक साझा लक्ष्य को हिट करने के लिए एक साथ काम करवा सकते हैं। प्रत्येक एजेंट को एक विशिष्ट भूमिका दी जा सकती है जो इसकी विशेषता को उजागर करती है - ठीक वैसे ही जैसे लोग एक टीम पर काम करते हैं।

उदाहरण के लिए:

• एक शोधकर्ता एजेंट को जानकारी इकट्ठा करने का काम सौंपा जा सकता है।

• एक कोडर एजेंट पायथन स्क्रिप्ट या ऑटोमेशन रूटीन लिख सकता है।

• एक समीक्षक एजेंट परिणामों की जांच कर सकता है और सुनिश्चित कर सकता है कि सब कुछ ठीक है।

ये एजेंट एक-दूसरे के साथ चैट कर सकते हैं, जानकारी साझा कर सकते हैं, और यहां तक कि निर्णयों पर बहस या वोट कर सकते हैं। इस तरह का टीमवर्क AI सिस्टम को बड़ी, अधिक जटिल समस्याओं से निपटने की अनुमति देता है जबकि चीजों को व्यवस्थित और मॉड्यूलर रखता है।

प्रोजेक्ट: ईमेल से अपने दैनिक शेड्यूल को स्वचालित करें

हम क्या स्वचालित कर रहे हैं

अपनी विशिष्ट सुबह की दिनचर्या के बारे में सोचें:

• आप अपना इनबॉक्स खोलते हैं।

• आप ईमेल के एक गुच्छा को जल्दी से स्कैन करते हैं।

• आप मीटिंग्स, कार्यों, और महत्वपूर्ण रिमाइंडर को स्पॉट करने की कोशिश करते हैं।

• फिर, आप मैन्युअल रूप से एक टू-डू लिस्ट लिखते हैं या चीजों को अपने कैलेंडर में जोड़ते हैं।

आइए इस प्रक्रिया को सहज बनाने के लिए एक LLM एजेंट का उपयोग करें। हमारा एजेंट करेगा:

• आपके ईमेल संदेशों की सूची पढ़ें

• मीटिंग्स या डेडलाइन जैसे समय-संवेदनशील आइटम निकालें

• सब कुछ एक अच्छे, साफ दैनिक शेड्यूल में सारांशित करें

चरण 1: आवश्यक टूल इंस्टॉल करें

शुरू करने के लिए, आपको तीन मुख्य टूल की आवश्यकता होगी: Python, VSCode, और एक OpenAI API कुंजी।

1. Python 3.9 या उच्चतर इंस्टॉल करें

आधिकारिक वेबसाइट से Python 3.9+ का नवीनतम संस्करण प्राप्त करें: https://www.python.org/downloads/

एक बार इंस्टॉल हो जाने पर, अपने टर्मिनल में python --version चलाकर दोबारा जांचें।

यह कमांड केवल आपके सिस्टम से वर्तमान में इंस्टॉल किए गए Python संस्करण को रिपोर्ट करने के लिए कहता है। आप संगतता सुनिश्चित करने के लिए Python 3.9.x या उच्चतर देखना चाहेंगे।

2. VSCode इंस्टॉल करें (वैकल्पिक लेकिन अनुशंसित)

VSCode एक शानदार, उपयोगकर्ता-अनुकूल कोड एडिटर है जो Python के साथ पूरी तरह से काम करता है। आप इसे यहीं डाउनलोड कर सकते हैं: https://code.visualstudio.com/.

3. अपनी OpenAI API कुंजी प्राप्त करें

यहां जाएं: https://platform.openai.com

साइन इन करें या एक नया अकाउंट बनाएं। अपने API Keys पेज पर जाएं। "Create new secret key" पर क्लिक करें और उस कुंजी को बाद के लिए कहीं सुरक्षित कॉपी करना सुनिश्चित करें।

4. Python लाइब्रेरी इंस्टॉल करें

अपना टर्मिनल या कमांड प्रॉम्प्ट खोलें और इन आवश्यक पैकेज को इंस्टॉल करें:

pip install langgraph langchain openai 

यह कमांड pip, Python के पैकेज मैनेजर, का उपयोग हमारे एजेंट के लिए तीन महत्वपूर्ण लाइब्रेरी डाउनलोड और इंस्टॉल करने के लिए करता है:

• langgraph: वह कोर फ्रेमवर्क जिसका उपयोग हम अपने एजेंट के वर्कफ़्लो को बनाने के लिए करेंगे।

• langchain: लार्ज लैंग्वेज मॉडल के साथ काम करने के लिए एक आधारभूत लाइब्रेरी, जिस पर LangGraph बनाया गया है।

• openai: OpenAI के शक्तिशाली AI मॉडल से जुड़ने के लिए आधिकारिक Python लाइब्रेरी।

यदि आप बहु-एजेंट सेटअप आज़माने के लिए उत्साहित हैं (जिसे हम चरण 5 में कवर करेंगे), तो CrewAI भी इंस्टॉल करें:

pip install crewai 

यह कमांड CrewAI इंस्टॉल करता है, एक विशेष फ्रेमवर्क जो कई AI एजेंट्स को एक टीम के रूप में एक साथ काम करने के लिए ऑर्केस्ट्रेट करना आसान बनाता है।

5. अपनी OpenAI API कुंजी सेट करें

आपको यह सुनिश्चित करने की आवश्यकता है कि आपका Python कोड आपकी OpenAI API कुंजी को ढूंढ और उपयोग कर सके। यह आमतौर पर इसे एक पर्यावरण चर के रूप में सेट करके किया जाता है।

macOS/Linux पर, अपने टर्मिनल में यह चलाएं ( "your-api-key" को अपनी वास्तविक कुंजी से बदलें):

export OPENAI_API_KEY="your-api-key" 

यह कमांड OPENAI_API_KEY नामक एक पर्यावरण चर सेट करता है। पर्यावरण चर संवेदनशील जानकारी तक पहुंचने के लिए एप्लिकेशन (जैसे आपका Python स्क्रिप्ट) के लिए एक सुरक्षित तरीका है, बिना इसे सीधे कोड में हार्डकोड किए।

Windows पर (कमांड प्रॉम्प्ट का उपयोग करके), यह करें:

set OPENAI_API_KEY="your-api-key" 

यह OPENAI_API_KEY पर्यावरण चर को सेट करने के लिए Windows समकक्ष कमांड है।

अब, आपका Python कोड OpenAI मॉडल से बात करने के लिए पूरी तरह तैयार है!

चरण 2: कार्य को परिभाषित करें

हमने इस खंड की शुरुआत में इसे संक्षेप में चर्चा की थी। लेकिन दोहराने के लिए, यह वही है जो हम अपने एजेंट से करवाना चाहेंगे:

• मीटिंग्स, घटनाओं, और महत्वपूर्ण कार्यों के लिए स्कैन करें।

• उन्हें एक नोटबुक या ऐप में जल्दी से लिखें।

• अपने दिन के लिए एक मोटा मानसिक प्लान बनाएं।

इस दिनचर्या में समय और मानसिक ऊर्जा लगती है। इसलिए हमारे लिए इसे करने वाला एक एजेंट सुपर सहायक होगा।

चरण 3: LangGraph के साथ वर्कफ़्लो बनाएं

LangGraph क्या है?

LangGraph एक शानदार फ्रेमवर्क है जो आपको "ग्राफ-आधारित" वर्कफ़्लो का उपयोग करके एजेंट्स बनाने में मदद करता है, एक फ्लोचार्ट बनाने की तरह। यह LangChain द्वारा संचालित है और आपको इस पर बहुत अधिक नियंत्रण देता है कि आपके एजेंट की प्रक्रिया में प्रत्येक चरण कैसे सामने आता है।

इस ग्राफ में प्रत्येक "नोड" एक निर्णय बिंदु या एक फ़ंक्शन का प्रतिनिधित्व करता है जो:

• कुछ इनपुट लेता है (इसकी वर्तमान "स्टेट")।

• कुछ तर्क करता है या एक्शन लेता है (अक्सर LLM और इसके टूल्स को शामिल करते हुए)।

• एक अपडेटेड आउटपुट लौटाता है (एक नई "स्टेट")।

आप इन नोड्स के बीच कनेक्शन बनाते हैं, और LangGraph फिर इसे एक स्मार्ट, स्वचालित स्टेट मशीन की तरह निष्पादित करता है।

LangGraph क्यों उपयोग करें?

• आप निष्पादन के सटीक क्रम को नियंत्रित करते हैं।

• यह कई चरणों वाले या यहां तक कि अलग-अलग रास्तों में शाखा वाले वर्कफ़्लो बनाने के लिए शानदार है।

• यह क्लाउड-आधारित मॉडल (जैसे OpenAI) और स्थानीय रूप से चलने वाले मॉडल दोनों के साथ अच्छा काम करता है।

ठीक है - अब कोड लिखते हैं।

1. ईमेल इनपुट का अनुकरण करें

एक वास्तविक एप्लिकेशन में, आपका एजेंट शायद आपके वास्तविक ईमेल लाने के लिए Gmail या Outlook से जुड़ेगा। इस उदाहरण के लिए, हालांकि, हम चीजों को सरल रखने के लिए कुछ नमूना संदेशों को हार्डकोड करेंगे:

Python emails = """
1. Subject: Standup Call at 10 AM
2. Subject: Client Review due by 5 PM
3. Subject: Lunch with Sarah at noon
4. Subject: AWS Budget Warning – 80% usage
5. Subject: Dentist Appointment - 4 PM
""" 

यह मल्टीलाइन Python स्ट्रिंग, emails, वास्तविक ईमेल सामग्री के लिए हमारा स्टैंड-इन है। हम एजेंट द्वारा टेक्स्ट को कैसे संसाधित किया जाएगा, यह प्रदर्शित करने के लिए ईमेल विषयों की एक सरल, संरचित सूची प्रदान कर रहे हैं।

2. एजेंट लॉजिक को परिभाषित करें

अब, हम OpenAI के GPT मॉडल को बताएंगे कि इस ईमेल टेक्स्ट को कैसे संसाधित किया जाए और इसे सारांश में बदलें।

from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated, List
import operator

# हमारे ग्राफ के लिए स्टेट परिभाषित करें
class AgentState(TypedDict):
    emails: str
    result: str

llm = ChatOpenAI(temperature=0, model="gpt-4o") # बेहतर प्रदर्शन के लिए gpt-4o का उपयोग

def calendar_summary_agent(state: AgentState) -> AgentState:
    emails = state["emails"]
    prompt = f"Summarize today's schedule based on these emails, listing time-sensitive items first and then other important notes. Be concise and use bullet points:\n{emails}"
    summary = llm.invoke(prompt).content
    return {"result": summary, "emails": emails} # सुनिश्चित करें कि emails भी वापस किया जाए

यहां क्या हो रहा है:

• आयात: हम आवश्यक घटक लाते हैं:

  • ChatOpenAI LLM से जुड़ने के लिए,

  • StateGraph और END langgraph.graph से हमारे एजेंट वर्कफ़्लो को बनाने के लिए,

  • TypedDict, Annotated, और List typing से टाइप चेकिंग और संरचना के लिए,

  • operator (हालांकि इस स्निपेट में उपयोग नहीं किया गया, यह तुलना या तर्क में मदद कर सकता है)।

• AgentState: यह TypedDict उस डेटा के आकार को परिभाषित करता है जिसके साथ हमारा एजेंट काम करेगा। इसमें शामिल हैं:

  • emails: कच्चे इनपुट संदेश।

  • result: अंतिम आउटपुट (दैनिक सारांश)।

• llm = ChatOpenAI(...): भाषा मॉडल को इनिशियलाइज़ करता है। हम GPT-4o का उपयोग temperature=0 के साथ कर रहे हैं ताकि संरचित सारांश कार्यों के लिए सुसंगत, अनुमानित आउटपुट सुनिश्चित हो सके।

• calendar_summary_agent(state: AgentState): यह फ़ंक्शन हमारे एजेंट का "दिमाग" है। यह:

  • वर्तमान स्टेट लेता है, जिसमें ईमेल की सूची शामिल है।

  • उस स्टेट से ईमेल निकालता है।

  • एक प्रॉम्प्ट बनाता है जो मॉडल को बुलेट पॉइंट्स का उपयोग करके एक संक्षिप्त दैनिक शेड्यूल सारांश उत्पन्न करने के लिए कहता है, समय-संवेदनशील आइटम को प्राथमिकता देता है।

  • llm.invoke(prompt).content के साथ इस प्रॉम्प्ट को मॉडल पर भेजता है, जो LLM की प्रतिक्रिया को सादे टेक्स्ट के रूप में लौटाता है।

  • एक नया AgentState डिक्शनरी लौटाता है जिसमें:

    • result: उत्पन्न सारांश,

    • emails: संरक्षित यदि हमें इसकी आवश्यकता है डाउनस्ट्रीम।

3. ग्राफ बनाएं और चलाएं

अब, आइए अपने एकल-एजेंट कार्य के प्रवाह को मैप करने के लिए LangGraph का उपयोग करें और फिर इसे चलाएं।

builder = StateGraph(AgentState)
builder.add_node("calendar", calendar_summary_agent)
builder.set_entry_point("calendar")
builder.set_finish_point("calendar") # END निहित है यदि स्पष्ट रूप से सेट नहीं किया गया
graph = builder.compile()

# अपने अनुकरणीय ईमेल डेटा का उपयोग करके ग्राफ चलाएं
result = graph.invoke({"emails": emails})
print(result["result"])

यहां क्या हो रहा है:

• builder = StateGraph(AgentState): हम एक StateGraph ऑब्जेक्ट आरंभ कर रहे हैं। AgentState पास करके, हम LangGraph को इसकी आंतरिक स्टेट के लिए अपेक्षित डेटा संरचना बता रहे हैं।

• builder.add_node("calendar", calendar_summary_agent): यह लाइन हमारे ग्राफ में एक नामित "नोड" जोड़ती है। हम इसे "calendar" कह रहे हैं, और इसे हमारे calendar_summary_agent फ़ंक्शन से जोड़ रहे हैं, जिसका अर्थ है कि जब यह नोड सक्रिय होगा तो वह फ़ंक्शन निष्पादित होगा।

• builder.set_entry_point("calendar"): यह "calendar" को हमारे वर्कफ़्लो में पहला चरण सेट करता है। जब हम ग्राफ शुरू करते हैं, तो निष्पादन यहां से शुरू होगा।

• builder.set_finish_point("calendar"): यह LangGraph को बताता है कि एक बार "calendar" नोड अपना काम पूरा कर ले, तो पूरी ग्राफ प्रक्रिया पूरी हो गई है।

• graph = builder.compile(): यह कमांड हमारे परिभाषित ग्राफ ब्लूप्रिंट को लेता है और इसे एक निष्पादन योग्य वर्कफ़्लो में "कंपाइल" करता है।

• result = graph.invoke({"emails": emails}): यहीं जादू होता है! हम अपने ग्राफ को चलाना शुरू करने के लिए कह रहे हैं। हम इसे एक प्रारंभिक स्टेट पास करते हैं जिसमें हमारा ईमेल डेटा होता है। ग्राफ तब इस डेटा को अपने नोड्स के माध्यम से तब तक प्रोसेस करेगा जब तक यह एक अंत बिंदु तक नहीं पहुंच जाता, अंतिम स्टेट लौटाता है।

• print(result["result"]): अंत में, हम परिणाम से सारांशित शेड्यूल लेते हैं (हमारे ग्राफ की अंतिम स्टेट) और इसे कंसोल पर प्रिंट करते हैं।

उदाहरण आउटपुट

आपका शेड्यूल:
- 10:00 AM – Standup Call
- 12:00 PM – Lunch with Sarah
- 4:00 PM – Dentist Appointment
- क्लाइंट रिपोर्ट 5:00 PM तक जमा करें
- AWS Budget Warning – उपयोग जांचें

बूम! आपने अभी एक AI एजेंट बनाया है जो आपके ईमेल पढ़ सकता है और आपका दैनिक शेड्यूल बना सकता है। बहुत अच्छा, है ना? यह केवल कुछ लाइनों के कोड के साथ LLM एजेंट्स क्या कर सकते हैं, इसकी एक सरल लेकिन शक्तिशाली झलक है।

CrewAI के साथ बहु-एजेंट सहयोग

CrewAI क्या है?

CrewAI एक रोमांचक ओपन-सोर्स फ्रेमवर्क है जो आपको एजेंट्स की टीम बनाने देता है जो एक वास्तविक-विश्व प्रोजेक्ट टीम की तरह निर्बाध रूप से एक साथ काम करते हैं! CrewAI सेटअप में प्रत्येक एजेंट:

• एक विशिष्ट, विशेष भूमिका रखता है।

• अपने साथियों के साथ संवाद और जानकारी साझा कर सकता है।

• एक साझा लक्ष्य प्राप्त करने के लिए सहयोग करता है।

यह बहु-एजेंट दृष्टिकोण सुपर उपयोगी है जब आपका कार्य सिर्फ एक एजेंट के लिए बहुत बड़ा या बहुत जटिल है, या जब इसे विशेष भागों में तोड़ना इसे स्पष्ट और अधिक कुशल बनाता है।

ईमेल सारांश कार्य के लिए नमूना भूमिकाएं

आइए कल्पना करें कि हमारा ईमेल सारांश कार्य एजेंट्स की एक छोटी टीम द्वारा नियंत्रित किया जा रहा है:

नमूना CrewAI कोड

from crewai import Agent, Crew, Task, Process
from langchain_openai import ChatOpenAI
import os

# पर्यावरण चर से अपनी OpenAI API कुंजी सेट करें
# os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"
# सुनिश्चित करें कि यह सेट है, या सीधे परिभाषित किया गया है

# LLM इनिशियलाइज़ करें (बेहतर प्रदर्शन के लिए gpt-4o का उपयोग)
llm = ChatOpenAI(temperature=0, model="gpt-4o")

# विशिष्ट भूमिकाओं और लक्ष्यों के साथ एजेंट्स को परिभाषित करें
extractor = Agent(
    role="Email Scanner",
    goal="दिए गए ईमेल से सभी मीटिंग्स, रिमाइंडर्स, और कार्यों को ढूंढें, समय, तारीख, और विषय जैसे विवरण सटीक रूप से निकालते हुए।",
    backstory="आप ईमेल को मुख्य जानकारी के लिए स्कैन करने में विशेषज्ञ हैं। आप हर प्रासंगिक विवरण को सावधानीपूर्वक निकालते हैं।",
    verbose=True,
    allow_delegation=False,
    llm=llm
)

prioritizer = Agent(
    role="Schedule Optimizer",
    goal="निकाले गए आइटम को तात्कालिकता और समय के अनुसार क्रमबद्ध करें, उन्हें दैनिक एजेंडा के लिए तैयार करें।",
    backstory="आप समय प्रबंधन के मास्टर हैं, हमेशा यह जानते हुए कि पहले क्या करने की आवश्यकता है। आप कार्यों को तार्किक रूप से व्यवस्थित करते हैं।",
    verbose=True,
    allow_delegation=False,
    llm=llm
)

formatter = Agent(
    role="Output Generator",
    goal="बुलेट-पॉइंट प्रारूप में एक साफ, पॉलिश्ड, और संक्षिप्त दैनिक एजेंडा उत्पन्न करें, सभी शेड्यूल आइटम को स्पष्ट रूप से सूचीबद्ध करते हुए।",
    backstory="आप एक पेशेवर सचिव हैं, यह सुनिश्चित करते हुए कि सभी आउटपुट पूरी तरह से फॉर्मेटेड और पढ़ने में आसान हैं। आप स्पष्टता को प्राथमिकता देते हैं।",
    verbose=True,
    allow_delegation=False,
    llm=llm
)

# ईमेल इनपुट का अनुकरण करें
emails = """
1. Subject: Standup Call at 10 AM
2. Subject: Client Review due by 5 PM
3. Subject: Lunch with Sarah at noon
4. Subject: AWS Budget Warning – 80% usage
5. Subject: Dentist Appointment - 4 PM
"""

# प्रत्येक एजेंट के लिए कार्यों को परिभाषित करें
extract_task = Task(
    description=f"इन ईमेल से सभी प्रासंगिक घटनाओं, मीटिंग्स, और कार्यों को निकालें: {emails}. सटीक विवरण पर ध्यान केंद्रित करें।",
    agent=extractor,
    expected_output="विवरण के साथ निकाले गए आइटम की एक सूची (उदाहरण, '- Standup Call at 10 AM', '- Client Review due by 5 PM')।"
)

prioritize_task = Task(
    description="निकाले गए आइटम को समय और तात्कालिकता के अनुसार प्राथमिकता दें। मीटिंग्स पहले, फिर डेडलाइन्स, फिर अन्य नोट्स।",
    agent=prioritizer,
    context=[extract_task], # extract_task का आउटपुट यहां इनपुट है
    expected_output="शेड्यूल आइटम की एक प्राथमिकता वाली सूची।"
)

format_task = Task(
    description="प्राथमिकता वाले शेड्यूल को बुलेट पॉइंट्स का उपयोग करके एक साफ, पढ़ने में आसान दैनिक एजेंडा में फॉर्मेट करें। संक्षिप्त भाषा सुनिश्चित करें।",
    agent=formatter,
    context=[prioritize_task], # prioritize_task का आउटपुट यहां इनपुट है
    expected_output="बुलेट पॉइंट्स के साथ एक अच्छी तरह से फॉर्मेटेड दैनिक एजेंडा।"
)

# क्रू को इंस्टेंटिएट करें
crew = Crew(
    agents=[extractor, prioritizer, formatter],
    tasks=[extract_task, prioritize_task, format_task],
    process=Process.sequential, # कार्य tasks सूची में परिभाषित क्रम में क्रमिक रूप से निष्पादित होते हैं
    verbose=2 # निष्पादन के दौरान अधिक विवरण दिखाता है
)

# क्रू चलाएं
result = crew.kickoff()
print("\n########################")
print("## अंतिम दैनिक एजेंडा ##")
print("########################\n")
print(result)

यहां क्या हो रहा है:

• आयात: हम CrewAI से प्रमुख कक्षाएं लाते हैं: Agent, Crew, Task, और Process। हम अपने भाषा मॉडल के लिए ChatOpenAI और पर्यावरण चर को संभालने के लिए os भी आयात करते हैं।

• llm = ChatOpenAI(...): LangGraph उदाहरण की तरह, यह हमारे OpenAI भाषा मॉडल को सेट करता है, यह सुनिश्चित करते हुए कि इसकी प्रतिक्रियाएं सीधी हैं (temperature=0) और gpt-4o मॉडल का उपयोग कर रहे हैं।

• एजेंट परिभाषाएं (extractor, prioritizer, formatter):

  • इनमें से प्रत्येक चर एक Agent इंस्टेंस बनाता है। एक एजेंट को इसकी भूमिका (यह क्या करता है), एक विशिष्ट लक्ष्य जिसे वह हासिल करने की कोशिश कर रहा है, और एक बैकस्टोरी (एक तरह का व्यक्तित्व या विशेषज्ञता जो LLM को इसके उद्देश्य को बेहतर ढंग से समझने में मदद करती है) द्वारा परिभाषित किया जाता है।

  • verbose=True डिबगिंग के लिए सुपर सहायक है, क्योंकि यह एजेंट्स को उनके "विचारों" को प्रिंट करता है जैसे वे काम करते हैं।

  • allow_delegation=False का मतलब है कि ये एजेंट अपने सौंपे गए कार्यों को अन्य एजेंट्स को नहीं सौंपेंगे (हालांकि इसे अधिक जटिल प्रतिनिधिमंडल परिदृश्यों के लिए True पर सेट किया जा सकता है)।

  • llm=llm प्रत्येक एजेंट को हमारे OpenAI भाषा मॉडल से जोड़ता है।

• अनुकरणीय ईमेल: हम इस उदाहरण के लिए समान नमूना ईमेल डेटा का पुन: उपयोग करते हैं।

• कार्य परिभाषाएं (extract_task, prioritize_task, format_task):

  • प्रत्येक Task एक विशिष्ट कार्य को परिभाषित करता है जिसे एक एजेंट को करने की आवश्यकता होती है।

  • description एजेंट को स्पष्ट रूप से बताता है कि कार्य में क्या शामिल है।

  • agent इस कार्य को हमारे परिभाषित एजेंट्स में से एक को सौंपता है (उदाहरण के लिए, extract_task के लिए extractor)।

  • context=[...] CrewAI के सहयोग का एक महत्वपूर्ण हिस्सा है। यह एक कार्य को पिछले कार्य के आउटपुट को इसके इनपुट के रूप में उपयोग करने के लिए कहता है। उदाहरण के लिए, prioritize_task अपने context के रूप में extract_task के आउटपुट को लेता है।

  • expected_output एजेंट को एक विचार देता है कि उसका परिणाम कैसा दिखना चाहिए, LLM को मार्गदर्शन करने में मदद करता है।

• crew = Crew(...):

  • यह वह जगह है जहां हम अपनी टीम को असेंबल करते हैं! हम एजेंट्स और कार्यों की अपनी सूची देकर एक Crew इंस्टेंस बनाते हैं।

  • process=Process.sequential क्रू को कार्यों को एक के बाद एक उस क्रम में निष्पादित करने के लिए कहता है जिस क्रम में वे tasks सूची में परिभाषित हैं। CrewAI अधिक उन्नत प्रक्रियाओं जैसे पदानुक्रमित का भी समर्थन करता है।

  • verbose=2 आपको क्रू के आंतरिक कामकाज और संचार का बहुत विस्तृत लॉग दिखाएगा।

• result = crew.kickoff(): यह कमांड आधिकारिक तौर पर पूरे बहु-एजेंट वर्कफ़्लो को शुरू करता है। एजेंट्स सहयोग करना शुरू कर देंगे, जानकारी पास करेंगे, और अपने सौंपे गए कार्यों को क्रम में पूरा करेंगे।

• print(result): अंततः, पूरे क्रू के सहयोगात्मक प्रयास से समेकित आउटपुट आपके कंसोल पर प्रिंट किया जाता है।

CrewAI चतुराई से एजेंट्स के बीच सभी संचार को संभालता है, पता लगाता है कि किसे क्या और कब काम करने की आवश्यकता है, और आउटपुट को एक एजेंट से अगले तक आसानी से पास करता है - यह एक मिनी AI असेंबली लाइन की तरह है!

निष्पादन के दौरान वास्तव में क्या होता है?

तो, चाहे आप LangGraph या CrewAI का उपयोग कर रहे हों, जब एक एजेंट चलता है तो पर्दे के पीछे वास्तव में क्या हो रहा है? आइए निष्पादन प्रक्रिया को तोड़ें:

• सिस्टम को एक इनपुट स्टेट मिलता है (उदाहरण के लिए, आपके ईमेल)।

• पहला एजेंट या ग्राफ नोड इस इनपुट को पढ़ता है और इसका अर्थ निकालने के लिए एक लार्ज लैंग्वेज मॉडल (LLM) का उपयोग करता है।

• अपनी समझ के आधार पर, एजेंट एक एक्शन पर निर्णय लेता है जैसे प्रमुख घटनाओं को निकालना या एक विशिष्ट टूल कॉल करना।

• यदि आवश्यक हो, तो एजेंट अधिक संदर्भ प्राप्त करने या बाहरी संचालन करने के लिए टूल्स को इनवोक कर सकता है (जैसे वेब खोज या फ़ाइल रीडर)।

• उस एक्शन का परिणाम तब टीम में अगले एजेंट को पास किया जाता है (यदि यह बहु-एजेंट सेटअप है) या सीधे आपको वापस कर दिया जाता है।

निष्पादन तब तक चलता रहता है जब तक:

• कार्य पूरी तरह से पूरा हो जाता है।

• सभी एजेंट्स ने अपनी सौंपी गई भूमिकाएं पूरी कर ली हैं।

• एक रोकने की शर्त या वर्कफ़्लो में एक नामित "END" बिंदु पहुंच जाता है।

इसे एक सुपर-स्मार्ट वर्कफ़्लो इंजन के रूप में सोचें जहां हर एक चरण में तर्क, निर्णय लेना, और पिछली बातचीत को याद रखना शामिल है।

क्या LLM एजेंट्स सुरक्षित हैं? सुरक्षा और गोपनीयता के बारे में क्या जानना है

LLM एजेंट्स जितने कूल हैं, वे एक महत्वपूर्ण सवाल उठाते हैं: क्या आप वास्तव में अपने वर्कफ़्लो के कुछ हिस्सों को चलाने या अपने डेटा के साथ बातचीत करने के लिए AI पर भरोसा कर सकते हैं? यह निर्भर करता है। यदि आप OpenAI या Anthropic जैसी सेवाओं का उपयोग कर रहे हैं, तो आपका डेटा ट्रांजिट में एन्क्रिप्टेड है और (अभी तक) प्रशिक्षण के लिए उपयोग नहीं किया जाता है।

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

अनामित इनपुट का उपयोग करें, पूर्ण डेटासेट उजागर करने से बचें, और यदि पूर्ण नियंत्रण आपके लिए मायने रखता है तो LLaMA या Mistral जैसे ओपन-सोर्स मॉडल का उपयोग करके एजेंट्स को स्थानीय रूप से चलाने पर विचार करें।

आप अपने एजेंट्स के लिए स्पष्ट सीमाएं भी निर्धारित कर सकते हैं ताकि वे ओवरस्टेप न करें। इसे एक नए इंटर्न के ऑनबोर्डिंग की तरह समझें: आप उन्हें पहले दिन हर चीज तक पहुंच नहीं देंगे।

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

जैसे-जैसे यह तकनीक बढ़ती है, अधिक सुरक्षा सुविधाएं आ रही हैं जैसे बेहतर सैंडबॉक्सिंग, मेमोरी सीमाएं, और भूमिका-आधारित पहुंच। लेकिन अभी के लिए, अपने एजेंट्स को शक्तिशाली सहायकों की तरह मानना स्मार्ट है जिन्हें अभी भी कुछ मानवीय पर्यवेक्षण की आवश्यकता है।

समस्या निवारण और टिप्स

कभी-कभी, एजेंट्स थोड़े विचित्र हो सकते हैं! यहां कुछ सामान्य समस्याएं हैं जिनका आप सामना कर सकते हैं और उन्हें कैसे ठीक करें:

एक आसान टिप: आप अपने एजेंट फ़ंक्शन के अंदर print() स्टेटमेंट या लॉगिंग संदेश भी जोड़ सकते हैं ताकि आप देख सकें कि प्रत्येक चरण में क्या हो रहा है और स्टेट ट्रांजिशन को डीबग कर सकें।

अधिक दैनिक स्वचालन का अन्वेषण करें

एक बार जब आपने एक एजेंट-आधारित कार्य बना लिया, तो आप उसी पैटर्न को अन्य स्वचालन के लिए अनुकूलित करना अविश्वसनीय रूप से आसान पाएंगे। यहां कुछ कूल आइडिया हैं जो आपकी रचनात्मकता को जगाने के लिए हैं:

इनमें से प्रत्येक को उन्हीं सिद्धांतों और फ्रेमवर्क का उपयोग करके बनाया जा सकता है जिन पर हमने चर्चा की - चाहे वह LangGraph हो या CrewAI।

एजेंट तकनीक में आगे क्या है?

LLM एजेंट्स बिजली की गति से विकसित हो रहे हैं, और नवाचार की अगली लहर पहले से ही यहां है:

• स्मार्ट मेमोरी सिस्टम: एजेंट्स से बेहतर दीर्घकालिक मेमोरी की अपेक्षा करें, जिससे वे विस्तारित अवधि में सीख सकें और पिछली बातचीत और कार्यों को याद रख सकें।

• मल्टी-मोडल एजेंट्स: एजेंट्स केवल टेक्स्ट को ही नहीं संभालेंगे! वे इमेज, ऑडियो, और वीडियो को संसाधित और समझने में सक्षम होंगे, जिससे वे अधिक बहुमुखी बनेंगे।

• उन्नत योजना फ्रेमवर्क: ReAct, Toolformer, और AutoGen जैसी तकनीकें लगातार एजेंट्स की तर्क, योजना बनाने और उन pesky "hallucinations" को कम करने की क्षमता में सुधार कर रही हैं।

• एज डिप्लॉयमेंट: LLaMA 3 या Mistral जैसे हल्के मॉडल का उपयोग करके अपने स्थानीय कंप्यूटर या डिवाइस पर पूरी तरह से ऑफ़लाइन चलने वाले एजेंट्स की कल्पना करें।

बहुत निकट भविष्य में, आप एजेंट्स को इसमें निर्बाध रूप से एकीकृत देखेंगे:

• आपके DevOps पाइपलाइन्स

• बड़े एंटरप्राइज वर्कफ़्लो

• रोजमर्रा के उत्पादकता टूल्स

• मोबाइल ऐप्स और स्मार्ट डिवाइस

• गेम्स, सिमुलेशन, और शैक्षिक प्लेटफॉर्म

अंतिम सारांश

ठीक है, आइए जल्दी से उन सभी अच्छी चीजों का पुनर्कथन करें जो आपने अभी सीखी और हासिल की हैं:

• आपको LLM एजेंट्स क्या हैं और वे इतने शक्तिशाली क्यों हैं, इसकी ठोस समझ मिली है।

• आपने देखा कि LangGraph और CrewAI जैसे ओपन-सोर्स फ्रेमवर्क एजेंट्स बनाना कितना आसान बनाते हैं।

• आपने LangGraph का उपयोग करके एक वास्तविक LLM एजेंट बनाया जो एक सामान्य दैनिक कार्य को स्वचालित करता है: अपने इनबॉक्स को सारांशित करना!

• आपने CrewAI के साथ बहु-एजेंट सहयोग की दुनिया का पता लगाया, यह समझते हुए कि AI की टीमें कैसे एक साथ काम कर सकती हैं।

• आपने सीखा कि इन सिद्धांतों को लेकर अनगिनत अन्य कार्यों को स्वचालित करने के लिए कैसे स्केल किया जाए।

तो, अगली बार जब आप खुद को कुछ दोहराव करते हुए पाएं, तो बस अपने आप से पूछें: "अरे, क्या मैं इसके लिए एक एजेंट बना सकता हूं?" जवाब शायद हां है!

संसाधन पुनर्कथन

यदि आप LLM एजेंट्स बनाने में गहराई से जाना चाहते हैं तो यहां कुछ उपयोगी संसाधन हैं:

मुफ्त में कोड करना सीखें। freeCodeCamp के ओपन सोर्स पाठ्यक्रम ने 40,000 से अधिक लोगों को डेवलपर्स के रूप में नौकरी पाने में मदद की है। शुरू करें