CrewAI बनाम LangGraph बनाम AutoGen: सही मल्टी-एजेंट AI फ्रेमवर्क कैसे चुनें

इस ट्यूटोरियल में, मैं आपको तीन अग्रणी मल्टी-एजेंट AI फ्रेमवर्क—CrewAI, LangGraph, और AutoGen—की विस्तृत तुलना कराऊँगा। पिछले वर्ष में मल्टी-एजेंट सिस्टम्स पर चर्चा तेज़ी से बढ़ी है, और वाजिब भी है। जैसे-जैसे AI परिपक्व होता जा रहा है, केवल एक बुद्धिमान एजेंट से एप्लिकेशन बनाना अक्सर पर्याप्त नहीं रहता। डेवलपर्स समझ रहे हैं कि विशिष्ट भूमिकाओं और जिम्मेदारियों वाले कई एजेंट्स का समन्वय अधिक अनुकूलनशील और भरोसेमंद समाधान देता है।

इस तुलना का महत्व इस बात में है कि हर फ्रेमवर्क मल्टी-एजेंट समन्वय की चुनौती को कैसे हल करता है। CrewAI वास्तविक संगठनात्मक संरचनाओं से प्रेरित भूमिका-आधारित मॉडल अपनाता है, LangGraph ग्राफ-आधारित वर्कफ़्लो अप्रोच अपनाता है, और AutoGen संवादात्मक सहयोग पर केंद्रित है। प्रत्येक फ्रेमवर्क अपनी विशिष्ट डिज़ाइन फिलॉसफी, खूबियाँ और समझौते पेश करता है। 

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

यदि आप AI एप्लिकेशंस में नए हैं, तो हमारे किसी कोर्स पर विचार करें, जैसे AI Fundamentals, Developing AI Applications, या Retrieval Augmented Generation (RAG) with LangChain. 

AI एजेंट क्या है?

फ्रेमवर्क्स में जाने से पहले, इस संदर्भ में एजेंट का अर्थ स्पष्ट कर लेते हैं। मल्टी-एजेंट AI फ्रेमवर्क्स में, एजेंट केवल बड़े भाषा मॉडल के चारों ओर बना एक प्रॉम्प्ट रैपर नहीं होता। यह एक स्वायत्त इकाई होती है जिसकी परिभाषित भूमिका होती है, उपयोग के उपकरण होते हैं, पहुँच योग्य मेमोरी होती है, और अनुसरण करने वाले व्यवहार होते हैं। एजेंट स्वतंत्र रूप से काम कर सकते हैं या अन्य एजेंट्स के साथ मिलकर ऐसे जटिल समस्याएँ सुलझा सकते हैं जो एकल एजेंट के लिए कठिन हों।

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

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

हालाँकि, एजेंट हमेशा सही विकल्प नहीं होते। यदि आपका वर्कफ़्लो सीधा-सादा है—जैसे एकल API से डेटा लाना और परिणाम दिखाना—तो एक सरल स्क्रिप्ट या सिंगल-एजेंट ऑर्केस्ट्रेशन अधिक कुशल हो सकता है। मल्टी-एजेंट सिस्टम तब चमकते हैं जब कार्य में समन्वय, विशेषज्ञता, या गतिशील अनुकूलन की ज़रूरत हो।

मल्टी-एजेंट AI फ्रेमवर्क्स को समझना

मल्टी-एजेंट फ्रेमवर्क्स सिंगल-एजेंट पैराडाइम को सहयोग, डेलिगेशन और अनुकूलनशील वर्कफ़्लोज़ वाले सिस्टम्स तक बढ़ाते हैं। वे सहयोगी बुद्धिमत्ता के विचार को साकार करते हैं, जहाँ अलग-अलग एजेंट्स समस्या के हिस्सों में विशेषज्ञता रखते हैं और समग्र लक्ष्य के लिए संवाद करते हैं। 

यह वही तरीका है जैसा संगठनों में टीमें काम करती हैं—विशेषज्ञ किसी ऑर्केस्ट्रेशन लेयर के तहत साथ काम करते हैं।

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

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

इन अवयवों को सक्षम करके, मल्टी-एजेंट फ्रेमवर्क्स लचीली आर्किटेक्चर का समर्थन करते हैं जो वर्कफ़्लो ऑटोमेशन से लेकर रिसर्च विश्लेषण तक की समस्याएँ सुलझा सकते हैं। फ्रेमवर्क का चुनाव इस पर निर्भर करता है कि आपके प्रोजेक्ट को कितनी कंट्रोल, लचीलापन और स्केलेबिलिटी चाहिए।

CrewAI, LangGraph और AutoGen का अवलोकन

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

CrewAI कार्यस्थल-प्रेरित रूपक के साथ भूमिका-आधारित सहयोग पर ज़ोर देता है। प्रत्येक एजेंट की परिभाषित भूमिका, जिम्मेदारियाँ और टूल्स तक पहुँच होती है, जिससे टीम-आधारित वर्कफ़्लो सहज बनता है। 

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

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

LangGraph उन परिस्थितियों में चमकता है जहाँ कई निर्णय बिंदुओं और पैरेलल प्रोसेसिंग क्षमताओं के साथ परिष्कृत ऑर्केस्ट्रेशन चाहिए।

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

CrewAI, LangGraph, और AutoGen का अवलोकन

गहन तुलना: CrewAI बनाम LangGraph बनाम AutoGen

हर फ्रेमवर्क मल्टी-एजेंट ऑर्केस्ट्रेशन को एक अलग दृष्टिकोण से देखता है। CrewAI भूमिका आवंटन पर, LangGraph वर्कफ़्लो संरचना पर, और AutoGen बातचीत पर ज़ोर देता है। 

ये अंतर इस बात को प्रभावित करते हैं कि डेवलपर्स अपने सिस्टम्स को कैसे डिज़ाइन, प्रबंधित और स्केल करते हैं—और चुनाव से पहले इन्हें समझना आवश्यक है। 

आइए इन अंतरों को कुछ महत्वपूर्ण आयामों में विभाजित करके समझें, शुरुआत आर्किटेक्चर से करते हैं।

आर्किटेक्चरल अंतर

आर्किटेक्चर हर फ्रेमवर्क की नींव है। CrewAI भूमिका-आधारित मॉडल का पालन करता है जहाँ एजेंट विशिष्ट जिम्मेदारियों वाले कर्मचारियों की तरह व्यवहार करते हैं। इससे वर्कफ़्लोज़ को टीमवर्क के रूप में देखना आसान हो जाता है। 

इसके विपरीत, LangGraph ग्राफ-आधारित ऑर्केस्ट्रेशन पर केंद्रित है, जहाँ वर्कफ़्लोज़ नोड्स और एजेस के रूप में दर्शाए जाते हैं, जो अत्यंत मॉड्युलर और कंडीशनल निष्पादन सक्षम करते हैं। 

AutoGen अलग रास्ता अपनाता है—इंटरैक्शन को एजेंट्स या एजेंट्स और मनुष्यों के बीच बातचीत के रूप में मॉडल करता है, जिससे एक स्वाभाविक संवाद-प्रेरित प्रवाह बनता है।

उपयोग में सरलता

उपयोग में सरलता की बात करें तो, CrewAI किसी भी व्यक्ति के लिए सहज लगता है जो भूमिकाओं और कार्यों के संदर्भ में सोचता है। आप बस लक्ष्यों के साथ एजेंट्स परिभाषित करते हैं और उन्हें सहयोग करने देते हैं। 

LangGraph को ग्राफ डिज़ाइन की गहरी समझ की आवश्यकता होती है, जो सीखने की एक कर्व जोड़ सकती है, लेकिन बदले में वर्कफ़्लो लॉजिक पर अधिक नियंत्रण देती है। 

AutoGen मूलतः संवादात्मक है, जिससे छोटे प्रोजेक्ट शुरू करना आसान हो जाता है, और यह इटरेटिव डेवलपमेंट के लिए लचीला रहता है।

समर्थित टूल्स और इंटिग्रेशन्स

इंटिग्रेशन्स की दृष्टि से, सभी तीन फ्रेमवर्क व्यापक API सपोर्ट और बाहरी टूल्स से एकीकरण प्रदान करते हैं। CrewAI सामान्य क्लाउड सेवाओं और टूल्स के लिए बिल्ट-इन इंटिग्रेशन्स देता है। 

LangGraph को पूरे LangChain इकोसिस्टम का लाभ मिलता है, जो APIs और बाहरी सिस्टम्स के साथ व्यापक इंटिग्रेशन्स प्रदान करता है। 

वहीं, AutoGen बातचीत के भीतर टूल उपयोग को प्राथमिकता देता है और मनुष्यों को सीधे भाग लेने की अनुमति देता है, जो इटरेटिव या रिव्यू-प्रधान वर्कफ़्लोज़ में लचीलापन बढ़ाता है।

मेमोरी सपोर्ट और प्रकार

मेमोरी सपोर्ट फ्रेमवर्क्स के बीच काफ़ी अलग है। CrewAI संरचित, भूमिका-आधारित मेमोरी का उपयोग करता है, जिसमें संदर्भात्मक एजेंट व्यवहार के लिए RAG सपोर्ट है। 

LangGraph वर्कफ़्लो निरंतरता के लिए चेकपॉइंटिंग के साथ स्टेट-आधारित मेमोरी प्रदान करता है। 

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

स्ट्रक्चर्ड आउटपुट

स्ट्रक्चर्ड आउटपुट को संभालना एक और उल्लेखनीय अंतर है। CrewAI अपने रोल लॉजिक के माध्यम से संरचना लागू करता है—एजेंट्स अपनी परिभाषित जिम्मेदारियों के अनुरूप आउटपुट देते हैं। 

LangGraph यहाँ उत्कृष्ट है—अपनी स्टेट ग्राफ्स की वजह से, जो कड़े आउटपुट फ़ॉर्मैट्स और ट्रांज़िशन्स को लागू कर सकते हैं। 

AutoGen, अधिक बातचीत-प्रधान होने के कारण, लचीले आउटपुट देता है, जिनकी स्थिरता बातचीत के ऑर्केस्ट्रेशन पर निर्भर कर सकती है।

मल्टी-एजेंट सपोर्ट

तीनों फ्रेमवर्क्स मल्टी-एजेंट क्षमताएँ देते हैं, लेकिन सहयोग मॉडल भिन्न हैं। 

CrewAI भूमिका आवंटन पर केंद्रित है, जहाँ प्रत्येक एजेंट की स्पष्ट जिम्मेदारियाँ होती हैं—समन्वय एक संरचित टीम माहौल जैसा लगता है। 

LangGraph प्रत्येक एजेंट या फ़ंक्शन को ग्राफ के नोड के रूप में ट्रीट करके वर्कफ़्लो-स्तरीय सहयोग सक्षम करता है—वे संरचित स्टेट ट्रांज़िशन्स और कंडीशनल ब्रांचेस के माध्यम से इंटरैक्ट करते हैं। 

AutoGen समूह चैट मॉडल्स पर ज़ोर देता है, जहाँ एजेंट एक-दूसरे और मनुष्यों के साथ नैचुरल लैंग्वेज में बातचीत करते हैं—सहयोग अधिक गतिशील और कम कठोर होता है, पर कम पूर्वानुमेय भी हो सकता है।

ह्यूमन-इन-द-लूप फीचर्स

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

LangGraph अपने वर्कफ़्लो ग्राफ्स में ह्यूमन-इन-द-लूप हुक्स देता है—डेवलपर्स निष्पादन रोक सकते हैं, यूज़र इनपुट ले सकते हैं, और उसी स्टेट से फिर शुरू कर सकते हैं। 

AutoGen मानवीय भागीदारी को बातचीत के प्रवाह का हिस्सा बना देता है—यूज़र प्रॉक्सी एजेंट किसी भी समय वार्तालाप को निर्देशित या पुनर्निर्देशित कर सकता है। 

यह लचीलापन AutoGen को इंटरैक्टिव या रिव्यू-ड्रिवन वर्कफ़्लोज़ के लिए विशेष रूप से मज़बूत बनाता है, वहीं CrewAI और LangGraph हस्तक्षेप के अधिक संरचित मैकेनिज़्म देते हैं।

कैशिंग और रिप्ले

कैशिंग और रिप्ले के लिए, CrewAI कैशिंग हेतु व्यापक टूल शामिल करता है, जिसमें बिल्ट-इन एरर हैंडलिंग है ताकि कार्य सुचारु रूप से चलते रहें। 

LangGraph मेमोरी या SQLite जैसे बैकएंड्स के साथ नोड-स्तरीय कैशिंग सपोर्ट करता है और LangGraph Studio के माध्यम से रिप्ले और डिबगिंग प्रदान करता है। 

AutoGen डिस्क या Redis जैसे बैकएंड्स के साथ LLM कैशिंग पर केंद्रित है, जो एजेंट्स के बीच साझा कैश सक्षम करता है—लागत बचत और पुनरुत्पादनयोग्यता के लिए।

कोड निष्पादन

कोड निष्पादन के संदर्भ में, CrewAI असाइन किए गए टूल्स (CodeInterpreterTool) के माध्यम से निष्पादन सक्षम करता है, अपनी भूमिका-आधारित फिलॉसफी बनाए रखते हुए।

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

AutoGen निष्पादन को सीधे अपनी बातचीत में एकीकृत करता है, जहाँ एजेंट्स (CodeExecutorAgent) अपने डायलॉग के हिस्से के रूप में स्निपेट चला और मूल्यांकन कर सकते हैं।

कस्टमाइज़ेबिलिटी

कस्टमाइज़ेबिलिटी देखें तो तीनों फ्रेमवर्क्स मज़बूत हैं, यद्यपि अलग-अलग तरीकों से। CrewAI अपनी भूमिका-केंद्रित पैराडाइम के भीतर अत्यधिक कस्टमाइज़ेबल है। 

LangGraph सबसे अधिक मॉड्युलैरिटी देता है, जिससे डेवलपर्स कंडीशनल लॉजिक के साथ अत्यधिक विशिष्टीकृत वर्कफ़्लोज़ डिज़ाइन कर सकते हैं। 

AutoGen संवादात्मक लचीलापन देता है, जिससे रचनात्मक मल्टी-एजेंट डायलॉग संभव होते हैं, हालांकि इसकी संरचना अपेक्षाकृत कम औपचारिक है।

स्केलेबिलिटी

स्केलेबिलिटी भी अलग-अलग है। CrewAI परिभाषित भूमिकाओं के भीतर टास्क पैरेललाइज़ेशन और एजेंट्स की हॉरिज़ॉन्टल रेप्लिकेशन के माध्यम से स्केल करता है। 

LangGraph शुरुआत से ही स्केलेबिलिटी के लिए डिज़ाइन किया गया है, क्योंकि ग्राफ-आधारित वर्कफ़्लोज़ बड़े डिस्ट्रीब्यूटेड सिस्टम्स तक बढ़ाए जा सकते हैं। 

AutoGen संवादात्मक रूप से स्केल करता है—कई एजेंट्स को बड़े समूहों में सहयोग करने देता है—हालांकि बड़े पैमाने के अनुप्रयोगों के लिए इसकी सीमाएँ हैं।

डॉक्यूमेंटेशन और समुदाय

अंत में, किसी भी फ्रेमवर्क की दीर्घकालिक सफलता में डॉक्यूमेंटेशन और समुदाय महत्वपूर्ण भूमिका निभाते हैं। 

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

LangGraph को व्यापक LangChain इकोसिस्टम का लाभ मिलता है, जो विस्तृत डॉक्यूमेंटेशन, ट्यूटोरियल्स और सक्रिय सामुदायिक समर्थन लाता है। 

AutoGen, यद्यपि दूसरों की तुलना में कम परिपक्व है, स्पष्ट डॉक्यूमेंटेशन, सक्रिय समुदाय, और ट्यूटोरियल्स की व्यापक सूची प्रदान करता है।

तुलनात्मक तालिका

निम्न तालिका CrewAI, LangGraph और AutoGen के प्रमुख अंतरों का सभी मुख्य आयामों में सार-संक्षेप देती है, ताकि आप फ्रेमवर्क चयन का निर्णय ले सकें।

तुलनात्मक तालिका: CrewAI बनाम LangGraph बनाम Autogen

कब किसे चुनें

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

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

• AutoGen चुनें यदि आप बातचीत-प्रेरित सहयोग चाहते हैं, जिसमें लचीली ह्यूमन-इन-द-लूप निगरानी हो। यह इटरेटिव कार्यों, ब्रेनस्टॉर्मिंग, या रिव्यू-प्रधान वर्कफ़्लोज़ में उत्कृष्ट है जहाँ नैचुरल लैंग्वेज आयोजन सिद्धांत होता है।

अब जब हमने फ्रेमवर्क्स की उच्च-स्तरीय तुलना कर ली है, तो चलिए प्रत्येक को विस्तार से देखते हैं—शुरुआत करते हैं CrewAI के भूमिका-आधारित अप्रोच से।

CrewAI फ्रेमवर्क: गहराई से समझ

CrewAI संगठन के रूपक पर आधारित है। एजेंट्स को कर्मचारियों की तरह माना जाता है—हर एक के पास भूमिका और जिम्मेदारियों का सेट होता है। 

उदाहरण के लिए, एक एजेंट “शोधकर्ता” की तरह डेटा एकत्र कर सकता है, जबकि दूसरा “लेखक” की तरह रिपोर्ट तैयार कर सकता है। यह कार्य-विभाजन उन परिदृश्यों में CrewAI को विशेष रूप से सहज बनाता है जहाँ भूमिकाएँ और जिम्मेदारियाँ स्वाभाविक रूप से मौजूद होती हैं।

CrewAI आर्किटेक्चर

CrewAI का मेमोरी सिस्टम इसी संगठनात्मक संरचना को प्रतिबिंबित करता है। प्रत्येक एजेंट भूमिका-विशिष्ट मेमोरी बनाए रखता है, जिसमें टास्क संदर्भ, एंटिटी संबंध और संचित ज्ञान शामिल होता है। 

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

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

यहाँ एक सरल CrewAI स्निपेट है जहाँ मैं एक रिसर्च एजेंट परिभाषित करता हूँ:

from crewai import Agent, Task, Crew

# Environment variables
os.environ["OPENAI_API_KEY"] = "your-api-key"
os.environ["OPENAI_API_BASE"] = "https://api.your-provider.com/v1"
os.environ["OPENAI_MODEL_NAME"] = "your-model-name"

# Define agents
researcher = Agent(
    role="Researcher",
    goal="Gather information on AI frameworks",
    backstory="Expert in technical research and summarization",
)

writer = Agent(
    role="Writer",
    goal="Prepare well-structured reports",
    backstory="Skilled technical writer who explains concepts clearly",
)

# Define tasks
research_task = Task(
    description="Find details on CrewAI, LangGraph, and AutoGen",
    expected_output="A structured summary of each framework, including use cases and differences.",
    agent=researcher,
    output_file="output/research_notes.md", 
   human_input=True

)

writing_task = Task(
    description="Turn the research notes into a polished article section",
    expected_output="A readable, clear article comparing the three frameworks.",
    agent=writer,
    output_file="output/final_article.md",
    human_input=True
)

# Create a crew with both agents and tasks
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task]
)

# Run the crew
result = crew.kickoff()
print(result)

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

 CrewAI पूरे प्रक्रिया का समन्वय करता है, यह सुनिश्चित करते हुए कि एजेंट अपनी भूमिकाओं के अनुरूप रहें, जबकि मानव प्रमुख चेकपॉइंट्स पर नियंत्रण बनाए रखें। यह एक छोटी संपादकीय टीम के साथ काम करने जैसा लगता है—ठीक वही जिसे मॉडल करने के लिए CrewAI बनाया गया है।

CrewAI Flows भी पेश करता है, जो Crews को परिष्कृत वर्कफ़्लो नियंत्रण देने के लिए पूरक करते हैं। जहाँ Crews स्वायत्त एजेंट टीमों का प्रतिनिधित्व करते हैं, वहीं Flows इवेंट-ड्रिवन, प्रोडक्शन-रेडी पाइपलाइन्स हैं जो निष्पादन पथ, स्टेट और ब्रांचिंग लॉजिक का प्रबंधन करती हैं। 

इसका अर्थ है कि आप Crews में स्वायत्त निर्णय-निर्माण की लचीलापन को Flows में संरचित ऑर्केस्ट्रेशन की सटीकता के साथ मिला सकते हैं।

जहाँ CrewAI सहयोग को भूमिकाओं और जिम्मेदारियों के रूप में फ्रेम करता है, वहीं LangGraph संरचना और लॉजिक पर ज़ोर देता है और वर्कफ़्लोज़ को ग्राफ में परस्पर जुड़े नोड्स के रूप में ट्रीट करता है।

LangGraph फ्रेमवर्क: गहराई से समझ

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

LangGraph ब्रांचिंग आर्किटेक्चर

LangGraph मज़बूत मेमोरी क्षमताएँ भी देता है, जो ग्राफ स्टेट का हिस्सा होती हैं। शॉर्ट-टर्म मेमोरी सक्रिय थ्रेड्स में बनी रहती है और किसी भी नोड पर चेकपॉइंट की जा सकती है, जिससे वर्कफ़्लोज़ को पॉज़ और रिज़्यूम किया जा सके। 

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

LangGraph मेमोरी सिस्टम

LangGraph Studio—इसका विज़ुअल डेवलपमेंट एन्वायरनमेंट—इन वर्कफ़्लोज़ को बनाना और डिबग करना और भी सरल बनाता है।

LangGraph Studio

यहाँ एक LangGraph स्निपेट है जो दो एजेंट्स के साथ वर्कफ़्लो सेट करता है: एक रिसर्चर नोड जो जानकारी एकत्र करता है और एक एनालिसिस नोड जो परिणामों की व्याख्या करता है।

from langchain_openai import ChatOpenAI
from typing import Annotated
from typing_extensions import TypedDict
import os
from langchain.schema import HumanMessage
from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages

# Environment variables
os.environ["OPENAI_API_KEY"] = "your-api-key"

llm = ChatOpenAI(
    model="gpt-4o-mini",
)

# Define the graph state 
class State(TypedDict):
    messages: Annotated[list, add_messages]

# Define nodes powered by the LLM 
def research_node(state: State):
    """Research agent: collects information using the LLM."""
    prompt = "You are a researcher. Collect detailed information.\nUser query: "
    user_query = state["messages"][-1].content
    response = llm.invoke(prompt + user_query)
    return {"messages": [response]}

def analysis_node(state: State):
    """Analysis agent: analyzes research results with the LLM."""
    research_output = state["messages"][-1].content
    prompt = "You are an analyst. Provide insights based on this research:\n"
    response = llm.invoke(prompt + research_output)
    return {"messages": [response]}

# Build the graph
graph_builder = StateGraph(State)

# Add nodes
graph_builder.add_node("Research", research_node)
graph_builder.add_node("Analysis", analysis_node)

# Add edges (workflow order)
graph_builder.add_edge(START, "Research")
graph_builder.add_edge("Research", "Analysis")
graph_builder.add_edge("Analysis", END)

# Compile the graph
graph = graph_builder.compile()

# Run the workflow
if __name__ == "__main__":

    initial_messages = [HumanMessage(content="Please draft a comparison of CrewAI, LangGraph, and AutoGen.")]
    result = graph.invoke({"messages": initial_messages})
    
    print(f"Research and Analysis Complete. {result}")

    print("\nFinal Report:")
    for msg in result["messages"]:
        print(f"{type(msg).__name__}: {msg.content}")

रिसर्च-एनालिसिस वर्कफ़्लो

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

यह दर्शाता है कि LangGraph वर्कफ़्लोज़ को मॉड्युलर ग्राफ़्स के रूप में औपचारिक बनाता है—ऐसी पाइपलाइंस डिज़ाइन करना आसान हो जाता है जहाँ हर चरण पिछले चरण के परिणाम पर निर्भर करता है। CrewAI के भूमिका-आधारित रूपक या AutoGen की मुक्त-प्रवाह बातचीत के विपरीत, LangGraph यह नियंत्रित करने में सूक्ष्म-स्तरीय संरचनात्मक नियंत्रण देता है कि एजेंट्स कैसे सहयोग करें।

जहाँ LangGraph संरचनात्मक वर्कफ़्लोज़ पर ज़ोर देता है, वहीं AutoGen संगठन सिद्धांत के रूप में बातचीत पर केंद्रित है।

AutoGen फ्रेमवर्क: गहराई से समझ

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

Autogen आर्किटेक्चर

AutoGen की मेमोरी बातचीत-केंद्रित है—पूरी डायलॉग हिस्ट्री स्टोर करती है ताकि मल्टी-टर्न इंटरैक्शंस के दौरान संदर्भ बना रहे। यह संदेश-आधारित मेमोरी एजेंट्स को वार्तालाप के पहले के हिस्सों का संदर्भ देने और पिछले आदान-प्रदान पर निर्माण करने देती है। 

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

RoundRobinGroupChat क्षमता विशेष रूप से शक्तिशाली है। यह कई एजेंट्स को बारी-बारी से सहयोग करने देता है—हर प्रतिक्रिया सभी प्रतिभागियों तक प्रसारित होती है, ताकि पूरी टीम का संदर्भ एकसमान बना रहे। यह डिज़ाइन रिफ्लेक्शन पैटर्न को लागू करना आसान बनाता है, जहाँ एक एजेंट ड्राफ्ट बनाता है और दूसरा उसका मूल्यांकन/आलोचना करता है।

यहाँ एक AutoGen स्निपेट है जो लेखक, समीक्षक और यूज़र प्रॉक्सी के साथ एक ग्रुप चैट सेट करता है:

import asyncio
from autogen_agentchat.conditions import TextMentionTermination
from autogen_agentchat.agents import UserProxyAgent, AssistantAgent
from autogen_agentchat.conditions import MaxMessageTermination
from autogen_agentchat.messages import TextMessage
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_agentchat.teams import RoundRobinGroupChat  
from autogen_agentchat.ui import Console


async def simple_user_agent():
    # Model client
    model_client = OpenAIChatCompletionClient(model="gpt-4o")

    # Writer agent
    writer = AssistantAgent(
        "Writer",
        model_client=model_client,
        system_message=(
            "You are a professional writer. "
            "Always respond with a detailed draft when asked. "
        ),
    )

    # Reviewer agent
    reviewer = AssistantAgent(
        "Reviewer",
        model_client=model_client,
        system_message=(
            "You are a reviewer who critiques drafts and suggests improvements. "
        ),
    )

    # User proxy agent
    user_proxy = UserProxyAgent("User")

    # Termination conditions
    termination = MaxMessageTermination(max_messages=8)
    text_termination = TextMentionTermination("TERMINATE")

    # Group chat with Writer, Reviewer, and User
    team = RoundRobinGroupChat(
        [writer, reviewer, user_proxy],
        termination_condition=termination | text_termination,
        max_turns=8,
    )

    # Run the group chat
    await Console(
        team.run_stream(
            task=TextMessage(
                source=user_proxy.name,
                content="Please draft a comparison of CrewAI, LangGraph, and AutoGen."
            ),
        )
    )

if __name__ == "__main__":
    asyncio.run(simple_user_agent())

इस वर्कफ़्लो में, लेखक एजेंट ड्राफ्ट तैयार करता है, समीक्षक एजेंट ड्राफ्ट का मूल्यांकन कर प्रतिक्रिया देता है, और यूज़र प्रॉक्सी एजेंट मानवीय प्रतिभागी का प्रतिनिधित्व करता है। 

RoundRobinGroupChat सुनिश्चित करता है कि प्रत्येक प्रतिभागी क्रम से अपनी बारी ले—बातचीत संरचित रहती है। टर्मिनेशन कंडीशन्स, जैसे संदेश सीमा या कोई विशिष्ट कीवर्ड, आपको चैट कब समाप्त हो—इस पर नियंत्रण देती हैं। यह सेटअप AutoGen की संवादात्मक ताकत को दर्शाता है: एजेंट्स गतिशील रूप से सहयोग करते हैं, जबकि मनुष्य किसी भी चरण में निगरानी या मार्गदर्शन के लिए शामिल हो सकते हैं।

उपयोग परिदृश्य और अनुप्रयोग

जहाँ किस फ्रेमवर्क का उपयोग सबसे उपयुक्त है, यह सोचते समय मैं समस्या की प्रकृति से मैप करता हूँ। यदि मुझे सरल वर्कफ़्लो ऑटोमेशन चाहिए जहाँ भूमिकाएँ स्पष्ट हों—जैसे “डेटा फ़ेचर” एजेंट “लेखक” एजेंट को परिणाम सौंपे—तो CrewAI सबसे स्वाभाविक फ़िट है। इसका संगठनात्मक रूपक ऐसे परिदृश्यों से पूरी तरह मेल खाता है।

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

अंत में, ह्यूमन-इन-द-लूप सिस्टम्स के लिए AutoGen चमकता है। यदि मैं एक सहयोगी रिसर्च असिस्टेंट बना रहा हूँ जहाँ एजेंट्स साथ में ब्रेनस्टॉर्म करें और मानव पर्यवेक्षण करे, तो AutoGen की संवादात्मक आर्किटेक्चर स्वाभाविक और प्रभावी महसूस होती है।

तकनीकी कार्यान्वयन संबंधी विचार

इम्प्लीमेंटेशन परिप्रेक्ष्य से, प्रदर्शन, स्केलेबिलिटी और इंटिग्रेशन महत्वपूर्ण हैं। CrewAI भूमिका अनुक्रमों के भीतर एजेंट्स की हॉरिज़ॉन्टल रेप्लिकेशन और टास्क पैरेललाइज़ेशन के माध्यम से स्केल करता है। LangGraph डिस्ट्रीब्यूटेड ग्राफ निष्पादन और पैरेलल नोड प्रोसेसिंग के माध्यम से स्केल करता है। AutoGen कन्वर्सेशन शार्डिंग और डिस्ट्रीब्यूटेड चैट मैनेजमेंट के माध्यम से स्केल करता है—हालाँकि बातचीत संदर्भ बनाए रखना एक विशिष्ट चुनौती है।

इंटिग्रेशन एक अन्य कारक है। LangGraph को व्यापक LangChain इकोसिस्टम का लाभ मिलता है, जबकि AutoGen बातचीत इंटरफेसेस पर केंद्रित है और पारंपरिक API इंटिग्रेशन के लिए अतिरिक्त एब्स्ट्रैक्शन लेयर्स की ज़रूरत पड़ सकती है। CrewAI अपने भूमिका-आधारित वर्कफ़्लोज़ के संरचित अप्रोच के माध्यम से मौजूदा व्यवसायिक सिस्टम्स से अच्छी तरह एकीकृत होता है।

एंटरप्राइज़ और प्रोडक्शन तैयारियाँ

एंटरप्राइज़ संदर्भ में, लाइसेंसिंग और अनुपालन नज़रअंदाज़ नहीं किए जा सकते। CrewAI व्यावसायिक लाइसेंसिंग के साथ एंटरप्राइज़ सपोर्ट विकल्प देता है। LangGraph, LangChain द्वारा समर्थित, एंटरप्राइज़-ग्रेड सपोर्ट और कंसल्टिंग सेवाएँ प्रदान करता है। AutoGen Azure AI सेवाओं के साथ अपने एकीकरण के माध्यम से Microsoft-समर्थित सहायता देता है।

उतना ही महत्वपूर्ण है परिनियोजन की लचीलापन। CrewAI ऑन-प्रिमाइसेस या क्लाउड पर डिप्लॉय हो सकता है—कड़े डेटा गवर्नेंस आवश्यकताओं वाले संगठनों के लिए उपयुक्त। 

LangGraph का आर्किटेक्चर मौजूदा एंटरप्राइज़ सिस्टम्स और APIs के साथ सुचारु रूप से एकीकृत होता है और दो पूरक सेवाएँ देता है—वर्कफ़्लो डिज़ाइन और डिबगिंग के लिए LangGraph Studio, और LangSmith Deployment जो बड़े पैमाने पर परिनियोजन के प्रबंधन के लिए है।  

AutoGen को Microsoft के नैटिव संबंधों का लाभ मिलता है, जिससे यह Azure इकोसिस्टम में पहले से निवेश करने वाली टीमों के लिए स्वाभाविक विकल्प बनता है। यह Autogen Studio भी प्रदान करता है—जो अभी विकासाधीन एक लो-कोड इंटरफेस है—तेज़ प्रोटोटाइपिंग के लिए। 

आखिरकार, हर फ्रेमवर्क एक अलग डिप्लॉयमेंट पाथवे देता है—और सही विकल्प इस पर निर्भर करता है कि कोई संगठन स्थानीय नियंत्रण, मॉड्युलर इंटिग्रेशन, या सहज क्लाउड अपनाने को प्राथमिकता देता है।

इन एंटरप्राइज़ विचारों को ध्यान में रखते हुए, आइए अपने निष्कर्षों को समेटें और फ्रेमवर्क चयन के लिए मार्गदर्शन दें।

निष्कर्ष

इस ट्यूटोरियल के दौरान, मैंने आपको मल्टी-एजेंट AI फ्रेमवर्क्स की बुनियाद कराई और तीन भिन्न अप्रोच—CrewAI, LangGraph और AutoGen—की पड़ताल की। CrewAI भूमिका-आधारित सहयोग के लिए अलग दिखता है, LangGraph ग्राफ-चालित ऑर्केस्ट्रेशन में चमकता है, और AutoGen संवादात्मक, ह्यूमन-इन-द-लूप सिस्टम्स में उभरता है।

मुख्य निष्कर्ष यह है कि कोई एक फ्रेमवर्क सार्वभौमिक रूप से बेहतर नहीं है—चयन आपके प्रोजेक्ट की ज़रूरतों पर निर्भर करता है। यदि आप संरचित भूमिकाओं को महत्व देते हैं, तो CrewAI उपयुक्त हो सकता है। यदि आपके वर्कफ़्लो को अनुकूलनशील ब्रांचिंग चाहिए, तो LangGraph आपके काम आएगा। यदि आप चाहते हैं कि एजेंट्स बातचीत के माध्यम से सहयोग करें, तो AutoGen एक लचीला वातावरण देता है।

मैं आपको हर फ्रेमवर्क के साथ प्रयोग करने के लिए प्रोत्साहित करता हूँ। उनकी खूबियाँ और कमियाँ जानने का सबसे अच्छा तरीका छोटे प्रोटोटाइप बनाना है और अपनी विशिष्ट टास्क्स पर उनका व्यवहार देखना है। ऐसा करने से आप जान पाएँगे कि कौन-सा फ्रेमवर्क आपके वर्कफ़्लोज़ के लिए सबसे स्वाभाविक लगता है और आपके दीर्घकालीन लक्ष्यों से सबसे बेहतर मेल खाता है।

सीखना जारी रखने के लिए, निम्न संसाधन ज़रूर देखें:

• LangGraph ट्यूटोरियल: LangGraph क्या है और इसका उपयोग कैसे करें?
• LangGraph Studio गाइड: इंस्टॉलेशन, सेटअप, उपयोग के मामले
• CrewAI: मल्टी AI एजेंट सिस्टम्स के उदाहरणों के साथ गाइड
• AutoGen ट्यूटोरियल: मल्टी-एजेंट AI एप्लिकेशन बनाएं
• Gemini Fullstack LangGraph के साथ शुरुआत करें