AI एजेंट्स: संपूर्ण कोर्स

हर कोई 2026 में AI एजेंट्स के बारे में बात कर रहा है।

ज़्यादातर लोगों को पता नहीं है कि वे असल में कैसे काम करते हैं।

आज यह बदल जाएगा।

मैंने हफ़्तों तक सब कुछ समेटा: कोर्स, किताबें, असली बिल्ड, प्रोडक्शन में असफलताएँ।

यहाँ वह सब है जो आपको वास्तव में जानना चाहिए।

चाहे आप अपना खुद का वर्कफ़्लो ऑटोमेट कर रहे हों या किसी कंपनी के लिए प्रोडक्शन AI सिस्टम बना रहे हों — यह आपका रोडमैप है।

इसे सेव करें। यह लंबा है। इसके लायक है।

भाग 1: शुरुआती AI एजेंट वास्तव में क्या हैं

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

एक सामान्य LLM एक काम करता है:

आप पूछते हैं। वह जवाब देता है। हो गया।

एक शॉट। लीनियर। कोई पुनरावृत्ति नहीं।

AI एजेंट अलग तरह से काम करता है।

यह उसी तरह काम करता है जैसे आप मुश्किल कामों पर वास्तव में काम करते हैं:

→ पहले योजना बनाएँ → रिसर्च करें → ड्राफ्ट बनाएँ → अपने काम की समीक्षा करें → संशोधित करें → दोहराएँ

इसे ReAct लूप कहा जाता है:

तर्क करें → कार्रवाई करें → निरीक्षण करें → दोहराएँ

मॉडल अगला कदम क्या करना है, इसके बारे में तर्क करता है। कार्रवाई करता है (आमतौर पर कोई टूल कॉल करके)। परिणाम का निरीक्षण करता है। फिर या तो आपको जवाब देता है या वापस लूप करता है।

इससे क्या फर्क पड़ता है?

हर पास गहराई जोड़ता है। मज़बूत तर्क। कम भ्रम (hallucinations)। बेहतर संगठन।

जो कुछ भी आप एक शॉट में करने की कोशिश में खो देते हैं — एजेंट उसे वापस पा लेते हैं।

2. एजेंट वास्तव में किसके लिए अच्छे हैं?

हर काम को एजेंट की ज़रूरत नहीं होती।

सही मेंटल मॉडल: एक 2×2 मैट्रिक्स।

अक्ष: जटिलता बनाम आवश्यक सटीकता।

→ कम जटिलता + उच्च सटीकता = सिर्फ कोड का उपयोग करें → कम जटिलता + कम सटीकता = सिर्फ एक LLM प्रॉम्प्ट का उपयोग करें → उच्च जटिलता + उच्च सटीकता = भारी गार्डरेल वाले एजेंट (टैक्स फॉर्म, कानूनी दस्तावेज़) → उच्च जटिलता + कम सटीकता = शुरू करने के लिए स्वीट स्पॉट

वह अंतिम क्वाड्रंट आपकी सबसे तेज़ शुरुआती जीत है।

सही एजेंट कार्यों के उदाहरण:

→ रिसर्च करके रिपोर्ट लिखना

→ ग्राहकों के ईमेल का जवाब देना (ऑर्डर देखना → ड्राफ्ट रिप्लाई)

→ इनवॉइस प्रोसेस करना

→ डेटाबेस में सेव करना

→ "क्या आपके पास $80 से कम की ब्लू जींस है?" का जवाब देना, इन्वेंट्री चेक करके

एजेंट तब चमकते हैं जब कार्य को चाहिए:

→ कई कदम

→ बाहरी जानकारी

→ पुनरावृत्ति और स्व-सुधार

अगर आप एक प्रॉम्प्ट से हल कर सकते हैं — तो एजेंट न बनाएँ।

3. ऑटोनॉमी स्पेक्ट्रम

एजेंट बनाते समय पहला बड़ा फैसला:

आप इसे कितना नियंत्रण देते हैं?

एक स्पेक्ट्रम के बारे में सोचें।

स्क्रिप्टेड (बाएँ छोर)

आप हर कदम को हार्ड-कोड करते हैं।

→ सर्च टर्म जनरेट करें → वेब सर्च कॉल करें → पेज फ़ेच करें → निबंध लिखें।

मॉडल सिर्फ टेक्स्ट जनरेशन करता है। बाकी सब आप तय करते हैं। पूर्वानुमेय। डीबग करना आसान। सीमित।

अर्ध-स्वायत्त (मध्य)एजेंट आपके द्वारा परिभाषित टूल में से चुनता है। आपके द्वारा निर्धारित गार्डरेल के अंदर निर्णय लेता है। यह वह जगह है जहाँ अधिकांश वास्तविक प्रोडक्शन सिस्टम रहते हैं।

पूरी तरह से स्वायत्त (दाएँ छोर)LLM सब कुछ तय करता है। क्या सर्च करना है। कितने पेज फ़ेच करने हैं। क्या प्रतिबिंबित करना है। क्या नया कोड लिखकर चलाना है। अधिक शक्तिशाली। नियंत्रित करना बहुत मुश्किल।

आपको कहाँ से शुरू करना चाहिए?

स्पेक्ट्रम के मध्य से। इसे टूल दें। गार्डरेल सेट करें। स्वायत्तता तभी जोड़ें जब आपको विश्वास हो।

4. कॉन्टेक्स्ट इंजीनियरिंग

यहाँ वह है जो वास्तव में एजेंट को "बुद्धिमान" बनाता है।

यह सिर्फ मॉडल नहीं है।

यह वह कॉन्टेक्स्ट है जिसे आप उसके चारों ओर बनाते हैं।

कॉन्टेक्स्ट इंजीनियरिंग = यह तय करना कि हर पल एजेंट के पास कौन सी जानकारी हो।

इसमें शामिल है:

→ पृष्ठभूमि — कार्य क्या है, उपयोगकर्ता कौन है

→ भूमिका — "आप बाजार विश्लेषण में विशेषज्ञता वाले एक शोध एजेंट हैं"

→ मेमोरी — पिछले चरणों में क्या हुआ है

→ उपलब्ध टूल — यह किन फंक्शन को कॉल कर सकता है

→ ज्ञान — दस्तावेज़, डेटाबेस, PDF जिनका यह संदर्भ ले सकता है

इसे अच्छी तरह से इंजीनियर करें → मॉडल लगातार व्यवहार करता है।

इसे खराब तरीके से इंजीनियर करें → अप्रत्याशित बकवास।

मॉडल दोनों तरह से एक जैसा है।

कॉन्टेक्स्ट ही एक महान एजेंट को एक टूटे हुए एजेंट से अलग करता है।

5. टास्क डीकम्पोज़िशन

एजेंट बनाने में सबसे महत्वपूर्ण कौशल।

शुरू करें: एक इंसान यह कार्य कैसे करेगा?

फिर हर कदम के लिए पूछें: क्या LLM यह कर सकता है? थोड़ा सा कोड? एक API कॉल?

अगर जवाब नहीं है → इसे तब तक छोटे टुकड़ों में बाँटें जब तक जवाब हाँ न हो।

उदाहरण — निबंध लिखने वाला एजेंट:

1. आउटलाइन → LLM संरचना जनरेट करता है
2. सर्च टर्म → LLM जनरेट करता है, फिर सर्च API कॉल करता है
3. पेज फ़ेच करें → टूल कॉल
4. ड्राफ्ट लिखें → LLM फ़ेच किए गए स्रोतों का उपयोग करता है
5. स्व-आलोचना → LLM कमियाँ और कमज़ोरियाँ सूचीबद्ध करता है
6. संशोधित करें → LLM आलोचना के आधार पर फिर से लिखता है

हर कदम है: → छोटा → जाँचने योग्य → स्पष्ट इनपुट और आउटपुट है

जब अंतिम आउटपुट खराब होता है, तो आपको ठीक पता होता है कि कौन सा कदम ठीक करना है।

यह डीकम्पोज़िशन की महाशक्ति है।

भाग 2: मध्यवर्ती मल्टी-एजेंट सिस्टम बनाना जो वास्तव में काम करते हैं

6. मूल्यांकन (वह उबाऊ चीज़ जो पेशेवरों को शौकीनों से अलग करती है)

कोई भी एवल्स के बारे में बात नहीं करना चाहता।

हर कोई जो असली सिस्टम शिप करता है, करता है।

आप कैसे मापते हैं कि आपका एजेंट काम कर रहा है?

सरल कार्य → सही उत्तर गिनें। क्या कस्टमर सर्विस बॉट ने इन्वेंट्री के सवाल का सही जवाब दिया? हाँ/नहीं।

जटिल कार्य → एक LLM को जज के रूप में उपयोग करें। एक दूसरे मॉडल को एक निश्चित रूब्रिक का उपयोग करके आउटपुट को 1–5 रेट करने दें। क्या निबंध में मज़बूत तर्क थे? उचित उद्धरण? सही लहजा?

मूल्यांकन के दो स्तर जिनकी आपको ज़रूरत है:

→ कंपोनेंट-स्तर — क्या हर व्यक्तिगत कदम काम कर रहा है? (क्या सर्च क्वेरी काफी विशिष्ट हैं? क्या आलोचना वास्तविक फीडबैक दे रही है?)

→ एंड-टू-एंड — क्या अंतिम आउटपुट अच्छा है? (क्या निबंध वास्तव में अच्छा है?)

अगर एंड-टू-एंड विफल रहता है लेकिन कंपोनेंट एवल्स पास करते हैं → हैंडऑफ समस्या। अगर कोई विशिष्ट कंपोनेंट विफल होता है → उस एजेंट पर काम करने की ज़रूरत है।

पहले दिन से मूल्यांकन शुरू करें। "परफेक्ट" एवल सिस्टम का इंतज़ार न करें। कुछ जल्दी शिप करें और पुनरावृत्ति करें।

7. मेमोरी और ज्ञान

दो बहुत अलग चीज़ें जिन्हें लोग भ्रमित करते हैं।

मेमोरी = गतिशील। हर रन के साथ अपडेट होती है।

→ अल्पकालिक: एजेंट काम करते समय नोट्स लिखता है। दूसरे एजेंट उन नोट्स को पढ़ सकते हैं। → दीर्घकालिक: कार्य के बाद, एजेंट प्रतिबिंबित करता है। क्या अच्छा रहा? क्या नहीं? सबक संग्रहीत करता है।

अगला रन → उन सबक को लोड करता है → उन्हें लागू करता है।

इस तरह आप बिना फाइन-ट्यूनिंग के एजेंटों को "प्रशिक्षित" करते हैं। फीडबैक दें → एजेंट हर रन में सुधार करता है।

ज्ञान = स्थिर। शुरुआत में लोड किया जाता है।

→ PDF, CSV, आंतरिक दस्तावेज़, डेटाबेस एक्सेस → एजेंट की संदर्भ लाइब्रेरी → एक बार दें। सटीक जवाबों के लिए जब भी ज़रूरत हो, उससे खींचता है।

इसे इस तरह सोचें:

मेमोरी = जो आपने अनुभव से सीखा। ज्ञान = पाठ्यपुस्तकें जिन्हें आप संदर्भित कर सकते हैं।

दोनों मायने रखते हैं। कोई भी दूसरे की जगह नहीं लेता।

8. गार्डरेल

एक काम करने वाला एजेंट एक सुरक्षित एजेंट नहीं है।

LLMs नॉन-डिटर्मिनिस्टिक हैं।

वे फ़ॉर्मेट गलत कर सकते हैं, गलत तथ्य बता सकते हैं, काम से भटक सकते हैं।

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

तीन प्रकार:

प्रकार 1 — कोड जाँच (तेज़ + सस्ता)निर्धारित चीज़ों के लिए उपयोग करें। → क्या आउटपुट सही फ़ॉर्मेट में है? सही लंबाई? आवश्यक फ़ील्ड मौजूद हैं? एक सरल वैलिडेशन फंक्शन लिखें। इसे तुरंत चलाएँ। जब संभव हो, इसे हमेशा पसंद करें।

प्रकार 2 — LLM जजसूक्ष्म गुणवत्ता जाँच के लिए उपयोग करें। → "क्या यह प्रतिक्रिया स्रोत दस्तावेज़ों के साथ तथ्यात्मक रूप से सुसंगत है?" → "क्या लहजा पेशेवर और सकारात्मक है?" अगर जज कहता है नहीं → समझाता है क्यों → एजेंट संशोधित करता है → फिर से प्रयास करता है।

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

अधिकांश प्रोडक्शन सिस्टम इन तीन में से कम से कम दो का उपयोग करते हैं।

1. 4 डिज़ाइन पैटर्न जो हर एजेंट को बेहतर बनाते हैं

ये चार पैटर्न विश्वसनीय रूप से एजेंटों को बेहतर बनाते हैं।

पैटर्न 1: प्रतिबिंप

पहले ड्राफ्ट पर न रुकें।

मॉडल आउटपुट तैयार करता है → इसकी आलोचना करता है → आलोचना के आधार पर फिर से लिखता है।

ईमेल v1: "अरे, चलो अगले महीने मिलते हैं। धन्यवाद।" आलोचना: अस्पष्ट तारीख, कोई साइन-ऑफ नहीं, लहजा बहुत अनौपचारिक। ईमेल v2: "नमस्ते एलेक्स, चलो 5-7 जनवरी को मिलते हैं। मुझे बताएं क्या काम करता है। शुभकामनाएँ, सई।"

कोड के साथ और भी शक्तिशाली — इसे लिखें, चलाएँ, त्रुटियाँ कैप्चर करें, वापस फीड करें, मॉडल ठीक करता है।

इसके लिए उपयोग करें: संरचित आउटपुट, लंबी-फ़ॉर्म राइटिंग, कोड, प्रक्रियात्मक कदम।

पैटर्न 2: टूल उपयोग

LLM को फंक्शन का एक मेन्यू दें जिसे वह कॉल कर सके।

मॉडल तय करता है कि कब और कौन सा टूल उपयोग करना है।

वेब सर्च। डेटाबेस क्वेरी। कोड निष्पादन। कैलेंडर। ईमेल। API कॉल।

LLM इनमें से कोई भी अकेला नहीं कर सकते। टूल वह तरीका है जिससे एजेंट दुनिया के साथ बातचीत करते हैं।

पैटर्न 3: योजना

एक निश्चित पाइपलाइन के बजाय, एजेंट को कदम तय करने दें।

इसे एक टूलकिट दें। एक योजना बनाने के लिए प्रॉम्प्ट करें। कदम दर कदम निष्पादित करें।

खुदरा उदाहरण: "$100 से कम के कोई गोल धूप का चश्मा?" एजेंट योजना बनाता है: विवरण सर्च करें → इन्वेंट्री जाँचें → कीमत के अनुसार फ़िल्टर करें → जवाब दें।

आपने उन सटीक कदमों को स्क्रिप्ट नहीं किया। एजेंट ने उन्हें चुना।

पैटर्न 4: मल्टी-एजेंट सहयोग

जटिल कार्य को विशेषज्ञ एजेंटों के बीच विभाजित करें।

रिसर्चर → डिज़ाइनर → राइटर।

हर एजेंट अपने विशिष्ट काम में महान है। आउटपुट बेहतर है क्योंकि कोई एक एजेंट सब कुछ करने की कोशिश नहीं कर रहा है।

10. मल्टी-एजेंट सिस्टम डिज़ाइन

आप वास्तव में मल्टी-एजेंट सिस्टम की संरचना कैसे करते हैं?

चार समन्वय पैटर्न, सबसे सरल से सबसे जटिल।

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

पैटर्न 2: समानांतरस्वतंत्र एजेंटों को एक साथ चलाएँ। रिसर्चर + डिज़ाइनर एक ही समय में काम करते हैं। राइटर उनके आउटपुट को जोड़ता है। तेज़। अधिक समन्वय जटिलता।

पैटर्न 3: प्रबंधक पदानुक्रमएक मैनेजर एजेंट विशेषज्ञों का समन्वय करता है। मैनेजर योजना बनाता है, प्रतिनिधि करता है, समीक्षा करता है। विशेषज्ञ मैनेजर को रिपोर्ट करते हैं, एक-दूसरे को नहीं। आज वास्तविक प्रोडक्शन सिस्टम में सबसे आम पैटर्न।

पैटर्न 4: ऑल-टू-ऑलकोई भी एजेंट किसी भी दूसरे एजेंट को संदेश भेज सकता है। अराजक। भविष्यवाणी करना मुश्किल। केवल रचनात्मक/कम-दांव वाले काम के लिए जहाँ भिन्नता ठीक है। प्रोडक्शन में उपयोग न करें।

अंगूठे का नियम: अनुक्रमिक से शुरू करें। जटिलता तभी जोड़ें जब आपको इसकी ज़रूरत हो।

भाग 3: प्रोडक्शन वास्तव में आपको प्रोटोटाइप से शिप तक क्या ले जाता है

11. उन्नत कार्य अपघटन

जटिल मल्टी-एजेंट सिस्टम में, आप अपघटन कैसे करते हैं, यह बहुत मायने रखता है।

4 पैटर्न:

कार्यात्मक — तकनीकी डोमेन द्वारा विभाजित। फ्रंटएंड एजेंट। बैकएंड एजेंट। डेटाबेस एजेंट। इंजीनियरिंग टीमों के लिए क्लासिक।

स्थानिक — फ़ाइल या निर्देशिका संरचना द्वारा विभाजित। एजेंट 1 /services/users/ संभालता है। एजेंट 2 /services/orders/ संभालता है। बड़े कोडबेस के लिए बढ़िया। संघर्षों को कम करता है।

अस्थायी — अनुक्रमिक चरणों द्वारा विभाजित। चरण 1: शोध। चरण 2: योजना। चरण 3: निर्माण। चरण 4: लॉन्च। प्रत्येक चरण अगले शुरू होने से पहले समाप्त होता है।

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

आप इन्हें मिक्स कर सकते हैं।

मुख्य संरचना के लिए कार्यात्मक अपघटन + प्रत्येक एजेंट के अंदर अस्थायी अपघटन।

जो भी आपके कार्य की प्राकृतिक सीमाओं से मेल खाता हो, उसका उपयोग करें।

12. प्रोडक्शन में गुणवत्ता में सुधार

सिस्टम काम कर रहा है लेकिन पर्याप्त अच्छा नहीं है।

दो प्रकार के घटक। दो अलग-अलग सुधार रणनीतियाँ।

गैर-LLM घटक (वेब सर्च, RAG, OCR, कोड निष्पादन):

→ नॉब्स को ट्यून करें: सर्च डेट रेंज, शीर्ष-k परिणाम, चंक आकार, समानता सीमा → प्रदाता बदलें: विभिन्न सर्च API, विज़न मॉडल, पार्सर आज़माएँ

LLM घटक (जनरेशन, रीज़निंग, एक्सट्रैक्शन):

→ बेहतर प्रॉम्प्ट करें: बाधाएँ, उदाहरण, आउटपुट स्कीमा जोड़ें → एक अलग मॉडल आज़माएँ: कुछ मॉडल कोड में बेहतर होते हैं, अन्य निर्देशों का पालन करने में → कठिन कार्यों को छोटे टुकड़ों में विघटित करें → फाइन-ट्यून करें (अंतिम उपाय — महंगा, अंतिम कुछ % के लिए बचाएँ)

क्रम मायने रखता है।

पहले प्रॉम्प्ट ठीक करें। एक अलग मॉडल आज़माएँ। और अधिक विघटित करें। सबसे अंत में फाइन-ट्यून करें।

अधिकांश टीमें चरण 2 में पर्याप्त अच्छी गुणवत्ता तक पहुँचती हैं।

13. विलंबता और लागत

पहले गुणवत्ता। फिर गति और लागत।

विलंबता कम करना:

1. हर कदम को मापें। वास्तविक बाधा खोजें।
2. ऐसी किसी भी चीज़ को समानांतर करें जो दूसरे कदम पर निर्भर नहीं है।
3. मॉडल को सही आकार दें — सरल कदमों के लिए तेज़ सस्ता LLM, तर्क के लिए बड़ा मॉडल।
4. तेज़ प्रदाता आज़माएँ — टोकन स्ट्रीमिंग गति बहुत भिन्न होती है।
5. कॉन्टेक्स्ट ट्रिम करें — छोटे प्रॉम्प्ट तेज़ी से डीकोड होते हैं।

लागत कम करना:

एक सामान्य शोध एजेंट रन के लिए वास्तविक लागत विवरण:

→ LLM जनरेशन कॉल: ~$0.04 → वेब सर्च API कॉल: ~$0.02 → एम्बेडिंग कॉल: ~$0.005 → बुनियादी ढाँचा: ~$0.015 → प्रति रन कुल: ~$0.08

1,000 रन/दिन पर = $80/दिन = $2,400/महीना।

इसे कैसे कम करें:

→ पहले सबसे बड़े बकेट पर हमला करें → अपने मॉडल को स्तरबद्ध करें — आसान के लिए सस्ता, कठिन के लिए महँगा → परिणामों को आक्रामक रूप से कैश करें (सर्च परिणाम, एम्बेडिंग, सारांश) → आउटपुट को बाधित करें ("JSON लौटाएँ। अधिकतम 5 फ़ील्ड।") → जहाँ संभव हो, संचालन को बैच करें

14. अवलोकन क्षमता: अपने एजेंटों को पैमाने पर देखना

पारंपरिक सॉफ्टवेयर: निष्पादन पथ का पता लगाएँ। A, B को कॉल करता है। B, DB को कॉल करता है। परिणाम लौटाता है।

AI एजेंट उस तरह काम नहीं करते।

वे नॉन-डिटर्मिनिस्टिक हैं। एक ही इनपुट → अलग आउटपुट। वितरित निष्पादन। बाहरी निर्भरताएँ जो विफल हो सकती हैं।

आपको दो प्रकार की दृश्यता की आवश्यकता है:

ज़ूम-इन मीट्रिक्स (एकल रन डीबगिंग)→ पूर्ण ट्रेस: हर प्रॉम्प्ट, हर टूल कॉल, हर उपयोग किया गया टोकन → एजेंट ने यह टूल क्यों चुना? → प्रत्येक कदम ने क्या लौटाया? → यह वास्तव में कहाँ विफल रहा?

सिर्फ यह नहीं कि क्या हुआ, बल्कि यह भी लॉग करें कि क्यों: "एजेंट ने RAG के बजाय वेब सर्च को चुना क्योंकि क्वेरी में 'हालिया' था" "प्रतिबिंब ने 3 मुद्दों की पहचान की: लापता उद्धरण, अस्पष्ट तारीख, गलत लहजा"

ज़ूम-आउट मीट्रिक्स (कई रनों में सिस्टम स्वास्थ्य)→ समय के साथ गुणवत्ता स्कोर → भ्रम दरें → सफलता दरें → क्या परिवर्तन मदद कर रहे हैं या नुकसान पहुँचा रहे हैं?

आप पैमाने पर हर ट्रेस को मैन्युअल रूप से निरीक्षण नहीं कर सकते।

गुणवत्ता नमूनाकरण का उपयोग करें — सभी रनों के प्रतिशत का मूल्यांकन करें। एक प्रवृत्ति रेखा बनाएँ।

इस तरह आप उपयोगकर्ताओं से पहले प्रतिगमन को पकड़ते हैं।

15. सुरक्षा: वह हिस्सा जिसके बारे में कोई बात नहीं करता (लेकिन करना चाहिए)

AI एजेंटों के लिए सुरक्षा पारंपरिक ऐप सुरक्षा की तरह नहीं है।

आप सिर्फ बाहरी हमलावरों से रक्षा नहीं कर रहे हैं।

आप अपने खुद के सिस्टम को खतरनाक निर्णय लेने से बचा रहे हैं।

खतरे:

→ प्रॉम्प्ट इंजेक्शन — उपयोगकर्ता इनपुट में दुर्भावनापूर्ण सामग्री एजेंट के निर्देशों को हाईजैक कर लेती है → असुरक्षित कोड जनरेशन — एजेंट ऐसा कोड लिखता है जो संवेदनशील डेटा तक पहुँचता है या हानिकारक काम करता है → डेटा लीकेज — आउटपुट या टूल कॉल के माध्यम से PII या मालिकाना जानकारी उजागर होना → संसाधन थकावट — एजेंट अनंत लूप घुमाना या महँगे API कॉल जलाना

कोड निष्पादन सबसे जोखिम भरी सुविधा है।

यदि आप इसे सक्षम करते हैं, तो इसे सुरक्षित रूप से कैसे करें:

→ Docker में सैंडबॉक्स करें। हर रन के बाद कंटेनर नष्ट हो जाता है। → कठोर संसाधन सीमाएँ निर्धारित करें: टाइमआउट, मेमोरी कैप, CPU सीमाएँ → केवल विशिष्ट सुरक्षित लाइब्रेरी को व्हाइटलिस्ट करें → एजेंट तक पहुँचने से पहले सभी इनपुट को मान्य करें → संवेदनशील डेटा (API कुंजी, PII) के लिए सभी आउटपुट को स्कैन करें → निर्धारित I/O का उपयोग करें — कोड उपयोगकर्ताओं को मुक्त-पाठ नहीं, बल्कि संरचित JSON लौटाता है

अधिकांश टीमें ये सबक कठिन तरीके से सीखती हैं।

शिप करने से पहले इसे पढ़ें।

यह पूरा कोर्स है।

पुनर्कथन

शुरुआती:→ एजेंट पुनरावृत्त रूप से काम करते हैं — योजना बनाएँ, कार्य करें, निरीक्षण करें, दोहराएँ → जटिल बहु-चरण कार्यों के लिए सबसे अच्छा जो ~90% सटीकता संभाल सकते हैं → पूरी तरह से स्वायत्त नहीं, अर्ध-स्वायत्त से शुरू करें → कॉन्टेक्स्ट इंजीनियरिंग ही वास्तविक बुद्धिमत्ता है → कार्य अपघटन सबसे महत्वपूर्ण कौशल है

मध्यवर्ती:→ पहले दिन से मूल्यांकन — जटिल कार्यों के लिए LLM-एज़-जज → मेमोरी (गतिशील) ≠ ज्ञान (स्थिर) → तीन प्रकार के गार्डरेल: कोड → LLM जज → मानव → 4 पैटर्न जो हमेशा मदद करते हैं: प्रतिबिंब, टूल उपयोग, योजना, मल्टी-एजेंट → अनुक्रमिक से शुरू करें। जटिलता तभी जोड़ें जब आवश्यक हो।

प्रोडक्शन:→ 4 अपघटन पैटर्न: कार्यात्मक, स्थानिक, अस्थायी, डेटा-संचालित → फाइन-ट्यूनिंग से पहले प्रॉम्प्ट ठीक करें → प्रति चरण विलंबता और लागत मापें, फिर सबसे बड़े बकेट पर हमला करें → दो अवलोकन क्षमता मोड: ज़ूम-इन ट्रेस + ज़ूम-आउट स्वास्थ्य मीट्रिक्स → सुरक्षा = सिर्फ हमलावरों से नहीं, बल्कि अपने खुद के सिस्टम से बचाव

अधिकांश लोग एजेंट बनाना शुरू करते हैं।

कुछ लोग एजेंटों को पैमाने पर विश्वसनीय रूप से काम करने के लिए शिप करते हैं।

अंतर इस लेख में सब कुछ है।

अगर यह उपयोगी था:

→ इसे शेयर करने के लिए रीपोस्ट करें → इस तरह के और विवरण के लिए @sairahul1 को फॉलो करें → इसे बुकमार्क करें — बनाते समय आप इसका संदर्भ लेंगे

मैं AI सिस्टम, उत्पाद बनाने और ऑटोमेशन के बारे में लिखता हूँ जो आपके सोते समय काम करता है।