AutoGPT गाइड: स्वायत्त AI एजेंट्स को लोकली बनाना और परिनियोजित करना

AutoGPT प्लेटफ़ॉर्म एक ऐसा प्लेटफ़ॉर्म है जो उपयोगकर्ताओं को सतत रूप से चलने वाले AI एजेंट्स बनाने, परिनियोजित करने और प्रबंधित करने की सुविधा देता है। यह लो-कोड UI का उपयोग करता है ताकि उपयोगकर्ता हज़ारों डिजिटल प्रक्रियाओं को स्वचालित कर सकें, और एजेंट्स बैकग्राउंड में स्वायत्त रूप से चलते रहें।

AutoGPT प्लेटफ़ॉर्म के दो कोर घटक हैं: AutoGPT सर्वर — मुख्य लॉजिक और इंफ्रास्ट्रक्चर, और AutoGPT फ्रंटएंड — एजेंट बनाने, वर्कफ़्लोज़ प्रबंधित करने, और आवर्ती शेड्यूल लागू करने के लिए UI। 

यह OpenAI, Anthropic, Groq, और Llama जैसे LLM प्रदाताओं के साथ पूर्व-इंटीग्रेटेड है ताकि डेटा प्रोसेसिंग, कंटेंट निर्माण या मनोरंजक गतिविधियों जैसे अनेक कामों को स्वचालित किया जा सके। 

इस ट्यूटोरियल में, हम तकनीकी पेशेवरों को बताएंगे कि AutoGPT प्लेटफ़ॉर्म को लोकल रूप से कैसे सेट अप करें और अपना पहला एजेंट कैसे बनाएँ। और अधिक जानने के लिए आप हमारा पूरा गाइड AI एजेंट्स को समझना पढ़ सकते हैं, और एक अलग लेख में विभिन्न AI एजेंट्स के प्रकार भी खोज सकते हैं। 

AutoGPT क्या है?

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

इस लेखन के समय, यदि आप लोकल सेटअप की झंझट से बचना चाहते हैं, तो AutoGPT के आगामी क्लाउड वर्ज़न के लिए एक ओपन वेटलिस्ट उपलब्ध है।

AutoGPT की प्रमुख विशेषताएँ और क्षमताएँ शामिल हैं:

• लो-कोड वर्कफ़्लोज़: व्यापक कोडिंग ज्ञान के बिना वर्कफ़्लो बनाएँ।
• स्वायत्त संचालन: ऐसे एजेंट परिनियोजित करें जो निरंतर चलें और विशिष्ट ट्रिगर्स पर सक्रिय हों।
• इंटेलिजेंट ऑटोमेशन: डेटा प्रोसेसिंग, कंटेंट निर्माण और अन्य दोहराए जाने वाले कार्यों का स्वचालन करें।
• ब्लॉक-आधारित सिस्टम: विभिन्न क्रियाओं और इंटीग्रेशनों का प्रतिनिधित्व करने वाले मॉड्यूलर ब्लॉक्स से एजेंट बनाएँ।
• एकाधिक LLM सपोर्ट: OpenAI, Anthropic, Groq, और Llama के साथ संगत।
• मार्केटप्लेस: विशिष्ट उपयोग मामलों के लिए प्री-कॉन्फ़िगर्ड एजेंट्स तक पहुँच।

AutoGPT की आर्किटेक्चर का अवलोकन

AutoGPT प्लेटफ़ॉर्म दो मुख्य घटकों से बना है:

1. AutoGPT सर्वर:

• एजेंट्स और ऑटोमेशन का कोर लॉजिक
• विश्वसनीय परफ़ॉर्मेंस के लिए इंफ्रास्ट्रक्चर
• प्री-बिल्ट एजेंट्स का मार्केटप्लेस

2. AutoGPT फ्रंटएंड:

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

AutoGPT का बैकएंड Python का उपयोग करता है, वेब फ़्रेमवर्क के रूप में FastAPI और डेटा स्टोरेज के लिए Prisma ORM के साथ PostgreSQL। यह रियल-टाइम कम्युनिकेशन के लिए वेबसोकेट्स का उपयोग करता है और निष्पादन, शेड्यूलिंग और नोटिफिकेशंस के लिए मैनेजर्स शामिल करता है। 

यह डिज़ाइन प्लेटफ़ॉर्म के बढ़ने के साथ स्केलेबिलिटी और मेंटेनेंस में सुधार करता है।

फ्रंटएंड Next.js 14 के साथ TypeScript, Radix कंपोनेंट्स और Tailwind CSS का उपयोग करता है, तथा वर्कफ़्लो विज़ुअलाइज़ेशन के लिए xyflow। इससे एक सहज लो-कोड इंटरफ़ेस बनता है, जहाँ उपयोगकर्ता व्यापक प्रोग्रामिंग ज्ञान के बिना AI एजेंट बना सकते हैं।

प्लेटफ़ॉर्म में ये प्रमुख सेवाएँ शामिल हैं:

• डेटाबेस मैनेजर: एजेंट कॉन्फ़िगरेशन और निष्पादन डेटा संग्रहीत करता है
• एक्ज़ीक्यूशन मैनेजर: वर्कफ़्लोज़ चलाता है और एजेंट स्टेट प्रबंधित करता है
• शेड्यूलर: समय-आधारित ऑटोमेशन और आवर्ती कार्यों को संभालता है
• वेबसोकेट सर्वर: रियल-टाइम अपडेट प्रदान करता है
• REST API: फ़ीचर्स तक प्रोग्रामैटिक एक्सेस देता है
• एजेंट प्रोटोकॉल: बाहरी सेवाओं के साथ संचार को मानकीकृत करता है
• इंटीग्रेशन APIs: थर्ड-पार्टी सेवाओं और AI प्रदाताओं से कनेक्ट करता है

2025 में AutoGPT बनाम पुराने वर्ज़न

जब इसे 2023 के आसपास पहली बार घोषित किया गया, तो AutoGPT खूब लोकप्रिय हुआ और ChatGPT का ओपन-सोर्स किलर माना गया। बेशक, वह सिर्फ सोशल मीडिया इन्फ्लुएंसर्स से चला हाइप था, क्योंकि अब 2025 है और ChatGPT अभी भी मौजूद है। लेकिन AutoGPT ने AI समुदाय का फोकस AI एजेंट्स की ओर शिफ्ट होने का संकेत ज़रूर दिया।

AutoGPT के शुरुआती वर्ज़न ने ऐसे पूरी तरह स्वायत्त एजेंट्स का वादा किया था जिन्हें एक ही प्रॉम्प्ट से ऑन-द-फ़्लाई बनाया जा सके। यह प्रॉम्प्ट को छोटे-छोटे टास्क्स में बाँटकर, तरह-तरह के टूल्स, सॉफ़्टवेयर और APIs को जोड़कर काम पूरा कर सकता था, और यह सब शॉर्ट-टर्म व लॉन्ग-टर्म मेमोरी तथा सेल्फ-रिफ्लेक्टिंग फ़ीडबैक लूप से बूस्टेड होता। 

हालाँकि, आगे चलकर उन्हें प्रोडक्शन परिदृश्यों में LLMs की अंतर्निहित अनिश्चितता के कारण इस दृष्टिकोण की सीमाएँ समझ में आ गई होंगी।

आज, AutoGPT वह “प्रॉम्प्ट-टू-एजेंट” प्लेटफ़ॉर्म नहीं है, बल्कि उससे बेहतर — एक लो-कोड प्लेटफ़ॉर्म है जो उपयोगकर्ताओं को अपने एजेंट्स कैसे बनते हैं इस पर नियंत्रण देता है। यदि आप 1–2 साल पुराने पोस्ट पढ़ें या YouTube वीडियो देखें, तो आप AutoGPT के मूल वर्ज़न से 2025 के प्लेटफ़ॉर्म तक यह बदलाव देख सकते हैं। 

वे पोस्ट उस सेटअप और वर्कफ़्लो उदाहरण दिखाते हैं जो मैं अब आपको सिखाने वाला हूँ उससे बिल्कुल अलग हैं।

तो बिना देर किए, आइए देखते हैं कि आप अपने सिस्टम पर यह प्लेटफ़ॉर्म कैसे सेट अप कर सकते हैं।

AutoGPT इंस्टॉलेशन और कॉन्फ़िगरेशन

AutoGPT को लोकल रूप से सेट अप करने के लिए आपके डेवलपमेंट वातावरण का सही कॉन्फ़िगरेशन और कंटेनराइज़ेशन टूल्स की समझ आवश्यक है — यदि आपको रिफ्रेशर चाहिए, तो हमारा कोर्स on Containerization and Virtualization with Docker and Kubernetes देखें। इस अनुभाग में हम प्रीरिक्विज़िट्स से लेकर पहली बार प्लेटफ़ॉर्म चलाने तक की पूरी प्रक्रिया बताएँगे।

प्रीरिक्विज़िट्स और एनवायरनमेंट सेटअप

AutoGPT इंस्टॉल करने से पहले, सुनिश्चित करें कि आपके पास निम्न प्रीरिक्विज़िट्स हैं:

1. Node.js & NPM

• Mac:
• brew install node
• Linux/WSL2:
• sudo apt update sudo apt install nodejs npm
• इंस्टॉलेशन जाँचें:
• node -v npm -v

2. Docker & Docker Compose

• Mac: डाउनलोड और इंस्टॉल करें Docker Desktop
• Linux (WSL2 में Docker कर्नेल आता है, इंस्टॉल करना होगा):
• sudo apt update sudo apt install docker.io docker-compose sudo systemctl enable --now docker
• इंस्टॉलेशन जाँचें:
• docker -v docker compose -v

3. Git

• Mac:
• brew install git
• Linux/WSL2:
• sudo apt update sudo apt install git

AutoGPT रिपोजिटरी क्लोन करें:

git clone https://github.com/Significant-Gravitas/AutoGPT.gitसंचालित द्वारा

ये प्रीरिक्विज़िट्स AutoGPT को प्रभावी रूप से चलाने के लिए आवश्यक हैं। Node.js और NPM फ्रंटएंड एप्लिकेशन के लिए ज़रूरी हैं, जिससे आप यूज़र-फ़्रेंडली इंटरफ़ेस के माध्यम से AutoGPT के साथ इंटरैक्ट कर सकते हैं। 

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

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

Docker के साथ लोकल होस्टिंग 

Docker AutoGPT को चलाने के लिए एक आइसोलेटेड, सुसंगत वातावरण प्रदान करता है, जिससे आपके होस्ट सिस्टम की परवाह किए बिना सभी डिपेंडेंसियाँ सही काम करें।

1. बैकएंड सेवाएँ सेट अप करें

cd AutoGPT/autogpt_platform
cp .env.example .env
docker compose up -d --buildसंचालित द्वारा

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

आखिरी docker compose कमांड पहली रन पर आपके इंटरनेट स्पीड के अनुसार 15 मिनट तक ले सकती है। यह उन बैकएंड कंपोनेंट्स को सेट अप करती है जिनसे फ्रंटएंड कनेक्ट होगा।

2. फ्रंटएंड एप्लिकेशन सेट अप करें

cd frontend
cp .env.example .env
npm install
npm run devसंचालित द्वारा

ये कमांड्स फ्रंटएंड के लिए एनवायरनमेंट फ़ाइल सेट करती हैं, Node.js के साथ उसकी डिपेंडेंसियाँ इंस्टॉल करती हैं, और UI शुरू करती हैं।

3. इंस्टॉलेशन वेरिफ़ाई करें

• AutoGPT UI तक पहुँचें: http://localhost:3000
• बैकएंड सेवाएँ इन पोर्ट्स पर चलती हैं:
• WebSocket सर्वर: 8001
• Execution API: 8006

पोर्ट 3000 पर जाना आपको मार्केटप्लेस UI दिखाना चाहिए, जिसके माध्यम से आपको अपना अकाउंट बनाना और लॉग इन करना होगा।

4. अपनी एन्क्रिप्शन की को कस्टमाइज़ करें (वैकल्पिक, लेकिन अनुशंसित)

# Python के साथ नई की जनरेट करें
from cryptography.fernet import Fernet
Fernet.generate_key().decode()

# या बिल्ट-इन CLI का उपयोग करें
poetry run cli gen-encrypt-keyसंचालित द्वारा

अपनी नई की को autogpt_platform/backend/.env में मौजूद मौजूदा की से बदल दें।

Windows उपयोगकर्ताओं के लिए नोट: Windows पर Docker का उपयोग करते समय, इंस्टॉलेशन के दौरान WSL 2 चुनें, Hyper-V नहीं, ताकि Supabase के साथ कंपैटिबिलिटी समस्याओं से बचा जा सके। यदि आपने पहले से Hyper-V के साथ इंस्टॉल किया है, तो आप Docker Desktop सेटिंग्स में WSL 2 पर स्विच कर सकते हैं।

AutoGPT यूज़र इंटरफ़ेस का अवलोकन

एक काम करने वाला एजेंट बनाने से पहले, आइए AutGPT के बिल्डर इंटरफ़ेस का अनुभव लें।

यह इंटरफ़ेस एक बड़ा खाली कैनवास है, जिसमें चार मुख्य बटन होते हैं:

• ब्लॉक्स
• Undo/redo बटन
• सेव

“ब्लॉक्स” पर क्लिक करने से AutoGPT के बिल्ट-इन, पुन: प्रयोज्य कंपोनेंट्स की कैटेगरीवार मेन्यू खुलती है।

ये ब्लॉक्स आवश्यक टूल्स देते हैं, जिन्हें कई एजेंट परिदृश्यों में सार्वभौमिक रूप से लागू किया जा सकता है। 

उदाहरण के लिए, नीचे मैंने दो ब्लॉक्स खोजकर जोड़े — लॉन्ग टेक्स्ट इनपुट और AI टेक्स्ट जनरेटर। ये दो कंपोनेंट्स मेरे लिए ChatGPT इंटरफ़ेस का बुनियादी संस्करण बनाने के लिए पर्याप्त हैं:

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

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

यदि आप ध्यान दें, तो दोनों ब्लॉक्स के छोटे किनारे हैं (3 और 5 देखें) जिनसे आप उन्हें कनेक्ट कर सकते हैं:

ऊपर के चित्र में, मैं इनपुट ब्लॉक को एक नाम (1) और एक डिफ़ॉल्ट वैल्यू (2) दे रहा हूँ, और उसके टेक्स्ट परिणाम (3) को टेक्स्ट जनरेटर के प्रॉम्प्ट फ़ील्ड (4) से जोड़ रहा हूँ। यह कनेक्शन एक बुनियादी एजेंट वर्कफ़्लो बनाता है, जिसे एजेंट को सेव करने के बाद चलाया जा सकता है (कदम 5–8)।

रन पर क्लिक करने के बाद, आपको इनपुट फ़ील्ड के लिए “Run settings” मेन्यू पॉप-अप दिखाई देगा:

अपना प्रॉम्प्ट लिखें और पूरी प्रक्रिया चलाएँ ताकि आपको नीचे जैसा पहला आउटपुट मिले:

आप देख सकते हैं कि बड़े टेक्स्ट जनरेशन ब्लॉक के भीतर मॉडल का उत्तर पढ़ना कठिन है। इसलिए AutoGPT में एजेंट आउटपुट्स के लिए ब्लॉक्स हैं, जिन्हें मैं नीचे जोड़ रहा हूँ:

ध्यान दें कि मैंने टेक्स्ट जनरेटर के रेस्पॉन्स फ़ील्ड को एजेंट आउटपुट ब्लॉक की वैल्यू से कैसे जोड़ा है। आउटपुट ब्लॉक जोड़ने से आप “Agent Outputs” पैन का उपयोग करके विभिन्न ब्लॉक्स से आने वाले सभी एजेंट आउटपुट्स को एक ही जगह देख सकते हैं:

एक बार जब आप अपने एजेंट को सेव कर लेते हैं, तो यह आपकी लाइब्रेरी में सेव हो जाएगा। साथ ही, यही पूरा एजेंट आगे आपके द्वारा बनाए गए अन्य एजेंट्स में एक ब्लॉक के रूप में उपयोग किया जा सकता है। यह मॉड्यूलर दृष्टिकोण कई लाभ देता है:

1. पुन: प्रयोज्यता: आप जटिल फ़ंक्शनैलिटी को कई प्रोजेक्ट्स में बिना दोबारा बनाए पुन: उपयोग कर सकते हैं।
2. कंपोज़ेबिलिटी: आप अलग-अलग एजेंट्स को जोड़कर अधिक परिष्कृत वर्कफ़्लोज़ बना सकते हैं।
3. मेंटेनेबिलिटी: जब आप मूल एजेंट को अपडेट करते हैं, तो उसे ब्लॉक के रूप में उपयोग करने वाली सभी इंस्टेंसिस सुधारों का लाभ उठाती हैं।
4. एब्स्ट्रैक्शन: जटिल प्रक्रियाओं को एक ही ब्लॉक में समाहित किया जा सकता है, जिससे आपके मुख्य एजेंट वर्कफ़्लोज़ साफ़ और समझने में आसान बनते हैं।
5. सहयोग: आप विशेषज्ञ एजेंट ब्लॉक्स को टीम के साथियों या समुदाय के साथ साझा कर सकते हैं, जिससे विकास तेज़ होता है।

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

AutoGPT में Python से कस्टम ब्लॉक्स लिखना

सिंटैक्स और सामान्य प्रक्रिया का अवलोकन

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

कस्टम ब्लॉक बनाने में ये आवश्यक चरण शामिल हैं:

1. नया Python फ़ाइल बनाएँ, autogpt_platform/backend/backend/blocks डायरेक्टरी में snake_case नामकरण के साथ
2. ऐसी क्लास परिभाषित करें जो Block बेस क्लास से इनहेरिट करती हो
3. इनपुट और आउटपुट स्कीमा बनाएँ, डेटा स्ट्रक्चर परिभाषित करने के लिए BlockSchema का उपयोग करें
4. यूनिक ID और टेस्ट डेटा के साथ __init__ मेथड इम्प्लीमेंट करें
5. अपने ब्लॉक का कोर लॉजिक युक्त run मेथड लिखें
6. एरर को सही तरह से हैंडल करें ताकि ब्लॉक गरिमापूर्ण ढंग से फ़ेल हो
7. अपने ब्लॉक का परीक्षण करें, प्लेटफ़ॉर्म के टेस्टिंग इंफ्रास्ट्रक्चर का उपयोग करते हुए

अब प्रत्येक घटक को विस्तार से समझते हैं:

ब्लॉक क्लास संरचना

हर ब्लॉक को Block बेस क्लास से इनहेरिट करना होता है और अपना इनपुट/आउटपुट स्कीमा परिभाषित करना होता है:

from backend.data.block import Block, BlockSchema, BlockOutput

class MyCustomBlock(Block):
   class Input(BlockSchema):
       # Define input fields with types
       field1: str
       field2: int
      
   class Output(BlockSchema):
       # Define output fields with types
       result: str
       error: str  # Always include an error field
      
   def __init__(self):
       super().__init__(
           id="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",  # Generate proper UUID
           input_schema=MyCustomBlock.Input,
           output_schema=MyCustomBlock.Output,
           test_input={"field1": "test", "field2": 42},
           test_output=("result", "expected output"),
           test_mock=None  # Only needed for external API calls
       )
      
   def run(self, input_data: Input, **kwargs) -> BlockOutput:
       try:
           # Your block logic here
           result = f"Processed {input_data.field1} and {input_data.field2}"
           yield "result", result
       except Exception as e:
           raise RuntimeError(f"Error in block: {str(e)}")संचालित द्वारा

महत्वपूर्ण घटक

1. इनपुट/आउटपुट स्कीमा: टाइप हिंट्स के साथ डेटा स्ट्रक्चर परिभाषित करें
2. UUID जेनरेशन: सही UUID जेनरेटर का उपयोग करें (अपना ख़ुद न बनाएँ)
3. टेस्ट डेटा: यथार्थपरक टेस्ट इनपुट्स और अपेक्षित आउटपुट्स दें
4. एरर हैंडलिंग: run मेथड में हमेशा उचित एरर हैंडलिंग शामिल करें
5. परिणाम देना: परिणाम एक-एक करके आउटपुट करने के लिए yield का उपयोग करें

एक उदाहरण कस्टम ब्लॉक

आइए OpenAI API का उपयोग करके सेंटिमेंट एनालिसिस करने वाला एक विस्तृत कस्टम ब्लॉक बनाते हैं। यह दिखाता है कि बाहरी AI सेवाओं के साथ कैसे इंटीग्रेट करें और API कीज़ को सुरक्षित रूप से कैसे संभालें।

OpenAI API की के लिए सेटअप निर्देश

इस ब्लॉक का उपयोग करने से पहले, आपको अपना OpenAI API की सेट अप करना होगा:

1. आवश्यक पैकेज इंस्टॉल करें:

• pip install openai python-dotenv

2. .env फ़ाइल autogpt_platform/backend/blocks डायरेक्टरी में अपने OpenAI API की के साथ बनाएँ:

• OPENAI_API_KEY=your_api_key_here

अब, ब्लॉक बनाते हैं:

डिपेंडेंसियाँ इम्पोर्ट करें और वातावरण तैयार करें

पहले, इम्पोर्ट्स और एनवायरनमेंट सेटअप संभालते हैं:

# autogpt_platform/backend/blocks/sentiment_analyzer.py
from backend.data.block import Block, BlockSchema, BlockOutput
from typing import Dict, Any, List
import os
from dotenv import load_dotenv
from openai import OpenAI
import json

# Load environment variables from .env file
load_dotenv()संचालित द्वारा

यह भाग आवश्यक लाइब्रेरीज़ इम्पोर्ट करता है और .env फ़ाइल से एनवायरनमेंट वेरिएबल्स लोड करता है। load_dotenv() फ़ंक्शन सुनिश्चित करता है कि आपका API की os.getenv() के माध्यम से उपलब्ध हो।

ब्लॉक स्कीमा परिभाषित करें और इनिशियलाइज़ करें

अब हम इनपुट और आउटपुट स्कीमा के साथ ब्लॉक क्लास परिभाषित करते हैं:

class OpenAISentimentBlock(Block):
   """Block to analyze sentiment of text using OpenAI API"""
  
   class Input(BlockSchema):
       text: str  # Text to analyze
       model: str = "gpt-3.5-turbo"  # OpenAI model to use
       detailed_analysis: bool = False  # Whether to return detailed analysis
      
   class Output(BlockSchema):
       sentiment: str  # Positive, Negative, or Neutral
       confidence: float  # Confidence score of the prediction
       explanation: str  # Brief explanation of the sentiment
       detailed_analysis: Dict[str, Any]  # Optional detailed analysis
       error: str  # Error message if analysis failsसंचालित द्वारा

इनपुट स्कीमा तीन पैरामीटर परिभाषित करता है:

• text: विश्लेषण हेतु सामग्री (आवश्यक)
• model: उपयोग होने वाला OpenAI मॉडल (डिफ़ॉल्ट "gpt-3.5-turbo")
• detailed_analysis: क्या अतिरिक्त विवरण लौटाने हैं (डिफ़ॉल्ट False)

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

टेस्ट डेटा के साथ ब्लॉक इनिशियलाइज़ करें

__init__ मेथड ब्लॉक को टेस्ट डेटा के साथ सेट अप करता है और OpenAI क्लायंट इनिशियलाइज़ करता है:

def __init__(self):
   super().__init__(
       id="8f67d394-9f52-4352-a78b-175d5d1d7182",  # Generated UUID
       input_schema=OpenAISentimentBlock.Input,
       output_schema=OpenAISentimentBlock.Output,
       test_input={
           "text": "I really enjoyed this product, it exceeded my expectations!",
           "detailed_analysis": True
       },
       test_output=[
           ("sentiment", str),
           ("confidence", float),
           ("explanation", str),
           ("detailed_analysis", dict)
       ],
       test_mock={
           "_analyze_sentiment": lambda text, model, detailed: {
               "sentiment": "positive",
               "confidence": 0.92,
               "explanation": "The text expresses clear enjoyment and states that expectations were exceeded.",
               "detailed_analysis": {
                   "emotions": {
                       "joy": "high",
                       "satisfaction": "high",
                       "disappointment": "none"
                   },
                   "key_phrases": ["really enjoyed", "exceeded expectations"],
                   "tone": "enthusiastic"
               }
           }
       }
   )
   # Initialize OpenAI client
   api_key = os.getenv("OPENAI_API_KEY")
   if not api_key:
       raise RuntimeError("OpenAI API key not found. Please set OPENAI_API_KEY in .env file.")
   self.client = OpenAI(api_key=api_key)संचालित द्वारा

यह मेथड:

• टेस्टिंग के लिए यथार्थपरक टेस्ट इनपुट्स और अपेक्षित आउटपुट्स सेट करता है
• टेस्टिंग के दौरान API कॉल से बचने के लिए सेंटिमेंट एनालिसिस फ़ंक्शन का मॉक देता है
• एनवायरनमेंट वेरिएबल्स से API की लेकर OpenAI क्लायंट इनिशियलाइज़ करता है
• API की गायब होने पर एरर थ्रो करता है

सेंटिमेंट एनालिसिस मेथड इम्प्लीमेंट करें

कोर फ़ंक्शनैलिटी _analyze_sentiment मेथड में इम्प्लीमेंट की गई है:

@staticmethod
def _analyze_sentiment(self, text: str, model: str, detailed: bool) -> Dict[str, Any]:
   """Analyze sentiment using OpenAI API"""
   # Create prompt based on whether detailed analysis is requested
   if detailed:
       system_prompt = """
       You are a sentiment analysis expert. Analyze the following text and provide:
       1. The overall sentiment (positive, negative, or neutral)
       2. A confidence score from 0.0 to 1.0
       3. A brief explanation of your assessment
       4. A detailed analysis including:
          - Key emotions detected and their intensity
          - Key phrases that influenced your assessment
          - Overall tone of the text
      
       Format your response as a JSON object with the following structure:
       {
           "sentiment": "positive|negative|neutral",
           "confidence": 0.0-1.0,
           "explanation": "brief explanation",
           "detailed_analysis": {
               "emotions": {"emotion1": "intensity", "emotion2": "intensity"},
               "key_phrases": ["phrase1", "phrase2"],
               "tone": "description of tone"
           }
       }
       """
   else:
       system_prompt = """
       You are a sentiment analysis expert. Analyze the following text and provide:
       1. The overall sentiment (positive, negative, or neutral)
       2. A confidence score from 0.0 to 1.0
       3. A brief explanation of your assessment
      
       Format your response as a JSON object with the following structure:
       {
           "sentiment": "positive|negative|neutral",
           "confidence": 0.0-1.0,
           "explanation": "brief explanation"
       }
       """
  
   try:
       # Make API call using the latest OpenAI API syntax
       response = self.client.chat.completions.create(
           model=model,
           response_format={"type": "json_object"},
           messages=[
               {"role": "system", "content": system_prompt},
               {"role": "user", "content": text}
           ],
           temperature=0.2  # Low temperature for more consistent results
       )
      
       # Extract and parse JSON response
       content = response.choices[0].message.content
       result = json.loads(content)
      
       return result
      
   except Exception as e:
       raise RuntimeError(f"OpenAI API error: {str(e)}")संचालित द्वारा

यह मेथड:

• विस्तृत विश्लेषण माँगे जाने पर अलग सिस्टम प्रॉम्प्ट बनाता है
• OpenAI API का उपयोग करके संरचित सेंटिमेंट एनालिसिस जनरेट करता है
• ज़्यादा सुसंगत परिणामों के लिए लो टेम्परेचर (0.2) सेट करता है
• JSON रेस्पॉन्स को पार्स करके लौटाता है
• API कॉल के दौरान आने वाले अपवादों को हैंडल करता है

run मेथड इम्प्लीमेंट करें

अंत में, run मेथड सब कुछ जोड़ता है:

def run(self, input_data: Input, **kwargs) -> BlockOutput:
   try:
       # Validate input
       if not input_data.text or not isinstance(input_data.text, str):
           raise ValueError("Text must be a non-empty string")
      
       # Process through OpenAI
       results = self._analyze_sentiment(
           input_data.text,
           input_data.model,
           input_data.detailed_analysis
       )
      
       # Yield the results
       yield "sentiment", results["sentiment"]
       yield "confidence", results["confidence"]
       yield "explanation", results["explanation"]
      
       # Only return detailed analysis if requested and available
       if input_data.detailed_analysis and "detailed_analysis" in results:
           yield "detailed_analysis", results["detailed_analysis"]
      
   except ValueError as e:
       raise RuntimeError(f"Input validation error: {str(e)}")
   except Exception as e:
       raise RuntimeError(f"Sentiment analysis failed: {str(e)}")संचालित द्वारा

यह मेथड:

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

इस उदाहरण के मुख्य पहलू

1. OpenAI API इंटीग्रेशन: चैट कम्प्लीशन्स एन्डपॉइंट के साथ नवीनतम OpenAI API सिंटैक्स का उपयोग
2. सुरक्षित API की हैंडलिंग: dotenv के माध्यम से एनवायरनमेंट वेरिएबल्स से की लोड करना
3. कस्टमाइज़ेबल विश्लेषण: उपयोगकर्ता की पसंद के आधार पर बेसिक या विस्तृत सेंटिमेंट एनालिसिस
4. संरचित आउटपुट: सेंटिमेंट श्रेणी, कॉन्फिडेंस स्कोर, व्याख्या और वैकल्पिक विस्तृत विश्लेषण लौटाता है
5. JSON प्रोसेसिंग: OpenAI से प्राप्त संरचित JSON रेस्पॉन्स को हैंडल करता है
6. टेस्टिंग रणनीति: वास्तविक API क्रेडिट्स उपयोग किए बिना टेस्टिंग के लिए OpenAI API कॉल को मॉक करता है

यह ब्लॉक अत्याधुनिक AI सेवाओं के साथ इंटीग्रेट करने का तरीका दिखाता है, ताकि आपके एजेंट्स की क्षमताएँ बढ़ सकें। OpenAI इंटीग्रेशन ऐसा परिष्कृत टेक्स्ट विश्लेषण सक्षम करता है, जिसे साधारण नियम-आधारित तरीकों से लागू करना कठिन होता।

अपने ब्लॉक्स लिखते समय हमेशा विचार करें:

• API कीज़ को सुरक्षित रूप से कैसे संभालें
• API विफलताओं के लिए स्पष्ट एरर संदेश कैसे दें
• ऐसे इनपुट्स डिज़ाइन करना जो ब्लॉक के उपयोग में लचीलापन दें
• ऐसे आउटपुट्स संरचित करना जिन्हें डाउनस्ट्रीम ब्लॉक्स आसानी से कन्ज़्यूम कर सकें

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

निष्कर्ष

AutoGPT अपने सहज, ब्लॉक-आधारित इंटरफ़ेस के माध्यम से स्वायत्त AI एजेंट्स बनाने और परिनियोजित करने के लिए एक शक्तिशाली प्लेटफ़ॉर्म प्रदान करता है। इस ट्यूटोरियल ने आपको पूरी प्रक्रिया से गुजारा है — लोकल इंस्टॉलेशन और कॉन्फ़िगरेशन से लेकर UI समझने, बुनियादी एजेंट बनाने और कस्टम ब्लॉक्स के साथ फ़ंक्शनैलिटी बढ़ाने तक। 

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

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

Introduction to GPTs कोर्स बड़े भाषा मॉडल्स की आपकी समझ को मज़बूत कर सकता है, जबकि Building RAG Chatbots for Technical Documentation AI एजेंट्स के एक अन्य व्यावहारिक अनुप्रयोग का प्रदर्शन करता है। जैसे-जैसे आप AI एजेंट्स के साथ प्रयोग जारी रखते हैं, आप Mistral Agents API, Dify AI, और Langflow जैसे नए टूल्स भी देखना चाहेंगे।