6 महीने में AI इंजीनियर कैसे बनें (संसाधन)

AI इंजीनियरिंग तेजी से टेक्नोलॉजी के क्षेत्र में सबसे मूल्यवान स्किल सेट में से एक बन गई है

समस्या यह है कि ज़्यादातर शुरुआती लोगों को कोई स्पष्ट अंदाज़ा नहीं होता कि उन्हें वास्तव में क्या पढ़ना चाहिए

कुछ लोग मशीन लर्निंग थ्योरी से शुरुआत करते हैं

कुछ लोग अंतहीन ट्यूटोरियल देखने में फंस जाते हैं

वहीं कुछ लोग APIs, बैकएंड की बुनियादी बातों, या इस बात को समझे बिना कि असली प्रोडक्ट्स कैसे बनाए जाते हैं, सीधे प्रॉम्प्ट और एजेंट्स में कूद पड़ते हैं

नतीजा आमतौर पर एक जैसा ही होता है: ढेर सारा भ्रम और बहुत कम व्यावहारिक कौशल

अगर आपका लक्ष्य AI इंजीनियर बनना है, तो आपको आर्टिफिशियल इंटेलिजेंस के हर क्षेत्र में महारत हासिल करने की ज़रूरत नहीं है

आपको यह सीखना होगा कि वास्तविक दुनिया में उपयोगी AI सिस्टम कैसे बनाए जाते हैं

इसका मतलब है यह सीखना कि कैसे:

• LLMs के साथ एंड-टू-एंड एप्लिकेशन बनाएं
• OpenAI और Anthropic जैसे मॉडल APIs के साथ काम करें
• प्रॉम्प्ट और कॉन्टेक्स्ट को सही तरीके से डिज़ाइन करें
• स्ट्रक्चर्ड आउटपुट और टूल कॉलिंग का उपयोग करें
• ज़रूरत पड़ने पर रिट्रीवल जोड़ें
• प्रोजेक्ट्स को डिप्लॉय करें ताकि लोग वास्तव में उनका उपयोग कर सकें

यह गाइड आपको एक व्यावहारिक 6 महीने का रोडमैप देने के लिए बनाई गई है

यह लेख 10,000+ शब्दों का है, इसलिए इसे पढ़ने में कुछ घंटे या उससे भी अधिक समय लग सकता है

लेकिन इसका असली मूल्य यह है कि आपको जिस भी कौशल की ज़रूरत है, उसके लिए संसाधन और स्पष्ट स्पष्टीकरण दिए गए हैं कि क्या करना है

इस तरह, छह महीनों के भीतर आप AI इंजीनियरिंग के स्तर तक पहुँच सकते हैं, और पहले 1-2 महीनों के भीतर ही इसे अपने लिए उपयोग करना शुरू कर सकते हैं

इस लेख को लिखने में 40 घंटे से अधिक लगे, और मैंने अपने दोस्त @andy_ai0 के साथ मिलकर इस पर काम किया

उन्होंने अभी-अभी X पर अपना पर्सनल ब्रांड बनाना शुरू किया है, लेकिन वे AI को बहुत अच्छी तरह समझते हैं और इस लेख में उन्होंने बहुत मदद की

मुझे पूरा विश्वास है कि जैसे-जैसे वे आगे बढ़ेंगे, वे आपके फ़ॉलो और समर्थन के हकदार हैं

अब लेख पढ़ना शुरू करते हैं ⬇️

AI इंजीनियर वास्तव में क्या करता है

बहुत से लोग "AI इंजीनियर" शब्द सुनते हैं और किसी को शुरू से बड़े-बड़े मॉडल ट्रेन करने की कल्पना करते हैं

हकीकत में, ज़्यादातर आधुनिक AI इंजीनियर कुछ और ही व्यावहारिक करते हैं

वे मौजूदा मॉडलों के ऊपर प्रोडक्ट्स और सिस्टम बनाते हैं

इसमें आमतौर पर शामिल है:

• LLM APIs से कनेक्ट करना
• प्रॉम्प्ट और कॉन्टेक्स्ट फ़्लो डिज़ाइन करना
• चैट, सर्च या ऑटोमेशन सिस्टम बनाना
• टूल्स, डेटाबेस और एक्सटर्नल APIs को इंटीग्रेट करना
• स्ट्रक्चर्ड आउटपुट को हैंडल करना
• रिलायबिलिटी, कॉस्ट और लेटेंसी में सुधार करना
• AI फ़ीचर्स को रियल एप्लिकेशन में डिप्लॉय करना

इसलिए व्यवहार में, एक AI इंजीनियर अक्सर इनके बीच में कहीं होता है:

• सॉफ़्टवेयर इंजीनियरिंग
• प्रोडक्ट इंजीनियरिंग
• ऑटोमेशन
• एप्लाइड AI

यही कारण है कि यह भूमिका इतनी तेज़ी से बढ़ रही है

कंपनियों को केवल रिसर्चर्स की ही ज़रूरत नहीं है

उन्हें ऐसे लोगों की ज़रूरत है जो मॉडल ले सकें और उन्हें उपयोगी प्रोडक्ट्स में बदल सकें

यही कारण है कि यह रोडमैप भारी थ्योरी की बजाय व्यावहारिक निष्पादन पर अधिक ध्यान केंद्रित करता है

अगर आप वास्तविक LLM ऐप्स, रिट्रीवल सिस्टम, ऑटोमेशन और प्रोडक्शन-रेडी वर्कफ़्लो बना सकते हैं, तो आप पहले से ही ज़्यादातर शुरुआती लोगों की तुलना में नौकरी के लिए योग्य होने के बहुत करीब हैं

⏩------------------------------------------------------------------------⏪

महीना 1: कोडिंग और बुनियादी बातों में पर्याप्त रूप से मजबूत हो जाएँ

इस महीने आपका लक्ष्य: एक कार्यात्मक Python डेवलपर बनना

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

AI इंजीनियरिंग सबसे पहले और सबसे महत्वपूर्ण सॉफ़्टवेयर इंजीनियरिंग है

बाद के महीनों में सब कुछ यह मान लेता है कि आप साफ़ Python लिख सकते हैं, टर्मिनल का उपयोग कर सकते हैं, APIs को कॉल कर सकते हैं और कोडबेस प्रबंधित कर सकते हैं। यह महीना आपकी नींव है

क्या सीखना है

1. Python

Python AI इंजीनियरिंग की भाषा है। पूर्ण विराम। अगले छह महीनों में आपके सामने आने वाली लगभग हर लाइब्रेरी, API और ट्यूटोरियल Python में होगी

इसे कैसे सीखें:

एक संरचित कोर्स से शुरुआत करें जो आपको कोड लिखने के लिए मजबूर करे, न कि केवल वीडियो देखने के लिए

शुरुआती लोगों की सबसे आम गलती निष्क्रिय रूप से सामग्री का उपभोग करना, साथ-साथ पढ़ना, सिर हिलाना और कभी कोड एडिटर न खोलना है

जाते-जाते हर उदाहरण को कोड करके इसका मुकाबला करें

संसाधन:

1. Python for Everybody (Coursera, मुफ़्त ऑडिट)

लिंक: https://www.coursera.org/specializations/python

पूरी तरह से शुरुआती लोगों के लिए सबसे अच्छा शुरुआती बिंदु। डॉ. चक इंटरनेट पर सबसे शुरुआती-अनुकूल Python शिक्षकों में से एक हैं

2. freeCodeCamp Python कोर्स (YouTube, मुफ़्त)

लिंक: https://www.youtube.com/watch?v=rfscVS0vtbw

सभी बुनियादी बातों को कवर करने वाला एक व्यापक 4 घंटे का वीडियो

3. CS50P: Python के साथ प्रोग्रामिंग का परिचय (Harvard, मुफ़्त)

लिंक: https://cs50.harvard.edu/python/

अधिक कठोर। इसमें प्रॉब्लम सेट और एक अंतिम प्रोजेक्ट शामिल है। यदि आप संरचना चाहते हैं तो बढ़िया है

4. आधिकारिक Python डॉक्स (ट्यूटोरियल)

लिंक: https://docs.python.org/3/tutorial/

सूखा लेकिन आधिकारिक, संदर्भ के रूप में उपयोग करें

किस पर ध्यान केंद्रित करें:

• वेरिएबल्स, डेटा टाइप्स, लूप्स, कंडीशनल्स, फंक्शन्स
• लिस्ट्स, डिक्शनरीज़, सेट्स, टुपल्स
• फ़ाइल I/O और JSON के साथ काम करना
• क्लासेस और बेसिक OOP (आप जो पढ़ रहे हैं उसे समझने के लिए पर्याप्त)
• try/except के साथ एरर हैंडलिंग
• वर्चुअल एनवायरनमेंट (venv) और pip
• पैकेज मैनेजमेंट – requirements.txt को समझना

अभ्यास प्रोजेक्ट: Python में एक सरल CLI टूल बनाएँ। कुछ इस तरह जैसे एक व्यक्तिगत व्यय ट्रैकर जो JSON फ़ाइल को पढ़ता/लिखता है, या एक स्क्रिप्ट जो एक सार्वजनिक API (जैसे मौसम API) को कॉल करती है और फ़ॉर्मेट किए गए परिणाम प्रिंट करती है

2. Git और GitHub

Git वह तरीका है जिससे पेशेवर डेवलपर कोड को सेव और साझा करते हैं। आपको इसकी लगातार ज़रूरत होगी, अपने प्रोजेक्ट्स को वर्ज़न करने, सहयोग करने और GitHub पर अपने पोर्टफ़ोलियो के काम को प्रदर्शित करने के लिए

इसे कैसे सीखें:

Git पहली बार में भ्रमित करने वाला है क्योंकि मेंटल मॉडल स्पष्ट नहीं है

कमांड को याद करने की कोशिश न करें, इसके बजाय समझें कि Git किस समस्या का समाधान कर रहा है

(परिवर्तनों को ट्रैक करना, सहयोग सक्षम करना, आपको गलतियों को पूर्ववत करने देना) और कमांड समझ में आएँगे

संसाधन:

1. GitHub Skills (मुफ़्त, इंटरैक्टिव)

लिंक: https://skills.github.com/

GitHub के अंदर ही बनाए गए आधिकारिक इंटरैक्टिव कोर्स। यहाँ से शुरुआत करें

2. Learn Git Branching (मुफ़्त, इंटरैक्टिव)

लिंक: https://learngitbranching.js.org/

ब्रांच और मर्ज को समझने के लिए अब तक का सबसे अच्छा विज़ुअल टूल

3. Pro Git बुक (मुफ़्त ऑनलाइन किताब)

लिंक: https://git-scm.com/book/en/v2

व्यापक संदर्भ। अपनी ज़रूरत के अध्यायों पर जाएँ

किस पर ध्यान केंद्रित करें:

• git init, add, commit, push, pull
• ब्रांचिंग और मर्जिंग
• .gitignore को समझना
• GitHub पर रिपो बनाना और लोकल प्रोजेक्ट्स को पुश करना
• बेसिक README फ़ाइलें पढ़ना और लिखना

अभ्यास: अब से, आपके द्वारा बनाया गया हर एक प्रोजेक्ट, यहाँ तक कि छोटी स्क्रिप्ट्स भी, एक GitHub रिपो में होनी चाहिए। यह आदत बनाता है और आपको एक पोर्टफ़ोलियो देता है

3. CLI / टर्मिनल की बुनियादी बातें

एक AI इंजीनियर के रूप में आप कमांड लाइन से स्क्रिप्ट चलाएँगे, पैकेज इंस्टॉल करेंगे, सर्वर मैनेज करेंगे और फ़ाइलों को नेविगेट करेंगे

टर्मिनल में धीमा या डरा हुआ होना एक वास्तविक अड़चन है

संसाधन:

1. 50 सबसे लोकप्रिय Linux और टर्मिनल कमांड (शुरुआती के लिए पूरा कोर्स)

लिंक: https://www.youtube.com/watch?v=ZtqBQ68cfJc

Linux/Mac पर पूरी तरह से शुरुआती लोगों के लिए अच्छा है

2. आपकी CS शिक्षा का लापता सेमेस्टर (MIT, मुफ़्त)

लिंक: https://missing.csail.mit.edu/

शेल स्क्रिप्टिंग, टर्मिनल टूल्स और कमांड लाइन प्रवाह को कवर करता है जिसे अधिकांश CS कोर्स छोड़ देते हैं

किस पर ध्यान केंद्रित करें:

• नेविगेशन: cd, ls, pwd, mkdir, rm
• फ़ाइलें पढ़ना: cat, less, grep
• टर्मिनल से Python स्क्रिप्ट चलाना
• एनवायरनमेंट वेरिएबल्स
• PATH की बुनियादी समझ

4. JSON, APIs, HTTP और Async की बुनियादी बातें

आप महीने 2 के पहले दिन से ही LLM APIs को कॉल कर रहे होंगे

इसका मतलब है कि इससे पहले कि आप कभी OpenAI या Anthropic के SDKs को छुएँ, आपको यह समझना होगा कि वेब APIs कैसे काम करते हैं

संसाधन:

1. HTTP की बुनियादी बातें – MDN Web Docs (मुफ़्त)

लिंक: https://developer.mozilla.org/en-US/docs/Web/HTTP/Overview

HTTP अनुरोध और प्रतिक्रिया कैसे काम करते हैं, इसकी सबसे स्पष्ट व्याख्या

2. REST API ट्यूटोरियल

लिंक: https://restfulapi.net/

संक्षिप्त और व्यावहारिक

3. Python requests लाइब्रेरी डॉक्स

लिंक: https://requests.readthedocs.io/en/latest/

Python में किसी भी वेब API को कॉल करना सीखें

4. Python async/await (मुफ़्त)

लिंक: https://realpython.com/async-io-python/

बाद में स्ट्रीमिंग LLM प्रतिक्रियाओं के साथ काम करने के लिए async को समझना आवश्यक है

किस पर ध्यान केंद्रित करें:

• GET, POST अनुरोध – वे क्या हैं और उन्हें Python में कैसे करें
• JSON को पढ़ना और लिखना
• HTTP स्थिति कोड (200, 400, 401, 404, 500 – प्रत्येक का क्या अर्थ है)
• API कुंजी क्या है और बुनियादी प्रमाणीकरण पैटर्न
• async def और await क्या करते हैं और वे क्यों मौजूद हैं

अभ्यास प्रोजेक्ट: एक Python स्क्रिप्ट लिखें जो एक मुफ़्त सार्वजनिक API को कॉल करती है (मौसम डेटा के लिए Open-Meteo आज़माएँ – किसी API कुंजी की आवश्यकता नहीं है) और परिणाम को एक साफ़ JSON आउटपुट के रूप में फ़ॉर्मेट करती है

5. बुनियादी SQL और Pandas

आपको डेटा वैज्ञानिक बनने की ज़रूरत नहीं होगी, लेकिन आपको नियमित रूप से डेटा का निरीक्षण, क्वेरी और हेरफेर करने की आवश्यकता होगी

SQL की बुनियादी बातें और Pandas प्रवाह आपको लगातार बचाएंगे

संसाधन:

1. SQLBolt (मुफ़्त, इंटरैक्टिव)

लिंक: https://sqlbolt.com/

शुरू से SQL सीखने का सबसे तेज़ तरीका। ब्राउज़र में अभ्यास के साथ 20 छोटे पाठ

2. Pandas आधिकारिक शुरुआत गाइड

लिंक: https://pandas.pydata.org/docs/getting_started/index.html

10 मिनट से Pandas ट्यूटोरियल के माध्यम से काम करें

3. Kaggle Pandas कोर्स (मुफ़्त)

लिंक: https://www.kaggle.com/learn/pandas

हैंड्स-ऑन, व्यावहारिक, छोटा

किस पर ध्यान केंद्रित करें:

• SQL: SELECT, WHERE, GROUP BY, JOIN, ORDER BY
• Pandas: CSVs लोड करना, पंक्तियों को फ़िल्टर करना, कॉलम चुनना, बुनियादी एग्रीगेशन

6. FastAPI

संसाधन:

1. FastAPI आधिकारिक ट्यूटोरियल (मुफ़्त)

लिंक: https://fastapi.tiangolo.com/tutorial/

वास्तव में अब तक लिखे गए सबसे अच्छे फ्रेमवर्क डॉक्स में से एक

शुरू से अंत तक इसके माध्यम से काम करें। पथ पैरामीटर, अनुरोध निकाय, Pydantic वैलिडेशन और डेव सर्वर चलाने को कवर करता है

2. Python API डेवलपमेंट (19 घंटे का कोर्स, freeCodeCamp, YouTube, मुफ़्त)

लिंक: https://www.youtube.com/watch?v=ZtqBQ68cfJc

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

किस पर ध्यान केंद्रित करें: GET और POST एंडपॉइंट बनाना, पथ और क्वेरी पैरामीटर, Pydantic के साथ अनुरोध निकाय, uvicorn चलाना, और क्लाइंट लिखे बिना अपने API का परीक्षण करने के लिए FastAPI के अंतर्निहित /docs इंटरफ़ेस का उपयोग करना

महीने 1 का माइलस्टोन

इस महीने के अंत तक आपको इसमें सक्षम होना चाहिए:

• Python प्रोग्राम लिखना जो फ़ाइलें पढ़ें/लिखें, APIs को कॉल करें और त्रुटियों को संभालें
• Git के साथ अपने कोड को वर्ज़न करें और प्रोजेक्ट्स को GitHub पर पुश करें
• बिना किसी हिचकिचाहट के टर्मिनल को नेविगेट करें
• समझें कि HTTP अनुरोध क्या है और Python में एक बनाएँ
• बुनियादी SQL के साथ SQLite डेटाबेस को क्वेरी करें
• स्थानीय रूप से एक सरल FastAPI ऐप बनाएँ और चलाएँ

⏩------------------------------------------------------------------------⏪

महीना 2: LLM ऐप डेवलपमेंट में महारत हासिल करें

इस महीने आपका लक्ष्य: OpenAI और Anthropic APIs का उपयोग करके वास्तविक AI-संचालित एप्लिकेशन बनाना

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

यह AI इंजीनियरिंग का मूल है। रोडमैप में बाकी सब कुछ आप यहाँ जो सीखते हैं उसी पर बनता है

क्या सीखना है

1. प्रॉम्प्टिंग की बुनियादी बातें

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

एक AI इंजीनियर के रूप में आप यहाँ आश्चर्यजनक रूप से बहुत समय बिताएँगे

इसे कैसे सीखें:

Anthropic के इंटरैक्टिव ट्यूटोरियल से शुरुआत करें क्योंकि यह सबसे अधिक हैंड्स-ऑन है

फिर OpenAI की आधिकारिक गाइड पढ़ें। उसके बाद, प्रॉम्प्ट इंजीनियरिंग गाइड सब कुछ समेकित करता है

सभी तीनों को क्रम से करें – प्रत्येक दूसरे को सुदृढ़ करता है

संसाधन:

1. Anthropic का इंटरैक्टिव प्रॉम्प्ट इंजीनियरिंग ट्यूटोरियल (मुफ़्त, GitHub)

लिंक: https://github.com/anthropics/prompt-eng-interactive-tutorial

अभ्यास के साथ 9 अध्यायों में विभाजित एक चरण-दर-चरण कोर्स, जिसे आपको स्वयं प्रॉम्प्ट लिखने और समस्या निवारण का अभ्यास करने के कई अवसर देने के लिए डिज़ाइन किया गया है

इसे Claude API के साथ Jupyter नोटबुक के रूप में चलाएँ

2. Anthropic प्रॉम्प्ट इंजीनियरिंग डॉक्स (मुफ़्त)

लिंक: https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview

आधिकारिक संदर्भ। बुनियादी स्पष्टता से लेकर XML संरचना और एजेंटिक सिस्टम तक सब कुछ कवर करता है

3. OpenAI प्रॉम्प्ट इंजीनियरिंग गाइड (मुफ़्त)

लिंक: https://platform.openai.com/docs/guides/prompt-engineering

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

4. PromptingGuide.ai (मुफ़्त)

लिंक: https://www.promptingguide.ai/

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

किस पर ध्यान केंद्रित करें: सिस्टम और उपयोगकर्ता संदेशों के बीच अंतर, विशिष्टता क्यों मायने रखती है, चेन-ऑफ़-थॉट प्रॉम्प्टिंग (चरण दर चरण सोचना), प्रॉम्प्ट में उदाहरणों का उपयोग करना (फ़्यू-शॉट), और कैसे शब्दों में छोटे बदलाव आउटपुट गुणवत्ता को नाटकीय रूप से बदल सकते हैं

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

3. स्ट्रक्चर्ड आउटपुट / JSON स्कीमा

वास्तविक एप्लिकेशन में आप लगभग कभी भी LLM से कच्चा टेक्स्ट नहीं चाहते, आप स्ट्रक्चर्ड डेटा चाहते हैं जिसे आप पार्स, स्टोर और अपने कोड में उपयोग कर सकें

स्ट्रक्चर्ड आउटपुट मॉडल को आपके द्वारा परिभाषित स्कीमा से मेल खाने के लिए मजबूर करके इस समस्या का समाधान करते हैं

संसाधन:

1. OpenAI स्ट्रक्चर्ड आउटपुट गाइड (आधिकारिक डॉक्स, मुफ़्त)

लिंक: https://platform.openai.com/docs/guides/structured-outputs

उस फ़ीचर को कवर करता है जो सुनिश्चित करता है कि मॉडल हमेशा आपके JSON Schema का पालन करने वाली प्रतिक्रियाएँ उत्पन्न करें, ताकि आपको गुम कुंजियों या काल्पनिक मानों के बारे में चिंता करने की ज़रूरत न हो

2. Instructor लाइब्रेरी (मुफ़्त, ओपन सोर्स)

लिंक: https://python.useinstructor.com/

Pydantic मॉडल का उपयोग करके किसी भी LLM प्रदाता से स्ट्रक्चर्ड आउटपुट प्राप्त करने का सबसे साफ़ तरीका

OpenAI, Anthropic, Google और 15+ अन्य प्रदाताओं के साथ उसी कोड इंटरफ़ेस का उपयोग करके काम करता है, जब वैलिडेशन विफल हो जाता है तो स्वचालित पुनर्प्रयास के साथ

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

3. OpenAI कुकबुक: स्ट्रक्चर्ड आउटपुट परिचय (मुफ़्त)

लिंक: https://developers.openai.com/cookbook/examples/structured_outputs_intro/

वास्तविक दुनिया के उपयोग के मामलों को समझने के लिए चेन-ऑफ़-थॉट आउटपुट, स्ट्रक्चर्ड डेटा निष्कर्षण और UI जनरेशन को कवर करने वाले व्यावहारिक उदाहरण

किस पर ध्यान केंद्रित करें: अपने डेटा के लिए Pydantic मॉडल को परिभाषित करना, API को स्कीमा पास करना, स्ट्रक्चर्ड आउटपुट और JSON मोड के बीच अंतर को समझना, और अस्वीकृतियों को शालीनता से संभालना

अभ्यास प्रोजेक्ट: एक इनवॉइस या रसीद पार्सर बनाएँ। इसे कच्चा टेक्स्ट दें (जैसे "इनवॉइस #123, 3 विजेट के लिए $45.99, 30 मार्च तक देय") और यह invoice_number, amount, items, due_date जैसे फ़ील्ड के साथ एक स्ट्रक्चर्ड Python ऑब्जेक्ट लौटाए

4. फंक्शन / टूल कॉलिंग

टूल कॉलिंग ही वह चीज़ है जो LLM को एक टेक्स्ट जनरेटर से कुछ ऐसा बदल देती है जो कार्रवाई कर सकता है – वेब सर्च करना, डेटाबेस को क्वेरी करना, आपकी API को कॉल करना, कोड चलाना। यह इस पूरी गाइड में सबसे महत्वपूर्ण कौशलों में से एक है

इसे कैसे समझें: मॉडल वास्तव में आपके फंक्शन को निष्पादित नहीं करता है

यह प्रॉम्प्ट की जाँच करता है और जब यह तय करता है कि किसी टूल का उपयोग किया जाना चाहिए, तो फंक्शन नाम और तर्कों के साथ एक स्ट्रक्चर्ड कॉल लौटाता है

आपका कोड तब कॉल निष्पादित करता है और परिणाम वापस भेजता है

संसाधन:

1. OpenAI फंक्शन कॉलिंग गाइड (आधिकारिक डॉक्स, मुफ़्त)

लिंक: https://platform.openai.com/docs/guides/function-calling

निश्चित संदर्भ। टूल को परिभाषित करना, 5-चरणीय कॉलिंग प्रवाह, समानांतर कॉल और सर्वोत्तम अभ्यास शामिल हैं

2. Anthropic टूल उपयोग डॉक्स (मुफ़्त)

लिंक: https://docs.anthropic.com/en/docs/build-with-claude/tool-use

Claude के लिए Anthropic का समकक्ष गाइड। अवधारणाएँ समान हैं, सिंटैक्स थोड़ा अलग है

3. OpenAI कुकबुक: चैट मॉडल के साथ फंक्शन कैसे कॉल करें (मुफ़्त, GitHub)

लिंक: https://github.com/openai/openai-cookbook/blob/main/examples/How_to_call_functions_with_chat_models.ipynb

एक पूर्ण चलने योग्य नोटबुक जो वास्तविक उदाहरणों के साथ पूरे टूल-कॉलिंग लूप के माध्यम से चलती है

किस पर ध्यान केंद्रित करें: JSON Schema में फंक्शनों का स्पष्ट रूप से वर्णन करना, टूल कॉल प्रतिक्रियाओं को पार्स करना, फंक्शन को निष्पादित करना और परिणाम वापस खिलाना, उन मामलों को संभालना जहाँ किसी टूल कॉल की आवश्यकता नहीं है, और tool_choice: "auto" की अवधारणा

अभ्यास प्रोजेक्ट: एक सरल सहायक बनाएँ जिसमें तीन टूल हों: get_weather(city), calculate(expression) और search_notes(query) (बस एक हार्डकोडेड डिक्ट में सर्च करें)। उन सभी को वायर करें और देखें कि मॉडल आपके पूछने के आधार पर किसे कॉल करना है, यह कैसे तय करता है

5. स्ट्रीमिंग प्रतिक्रियाएँ

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

संसाधन:

1. OpenAI स्ट्रीमिंग डॉक्स (आधिकारिक, मुफ़्त)

लिंक: https://platform.openai.com/docs/api-reference/streaming

अनुरोधों में stream=True जोड़ने और चंक्स पर पुनरावृति करने के लिए संदर्भ

2. Anthropic स्ट्रीमिंग डॉक्स (आधिकारिक, मुफ़्त)

लिंक: https://docs.anthropic.com/en/api/messages-streaming

Python उदाहरणों के साथ Anthropic का स्ट्रीमिंग API संदर्भ

3. स्ट्रीमिंग LLM APIs कैसे काम करती हैं – Simon Willison (मुफ़्त)

लिंक: https://til.simonwillison.net/llms/streaming-llm-apis

OpenAI, Anthropic और Google के लिए Server-Sent Events हुड के नीचे कैसे काम करता है, इसका एक स्पष्ट तकनीकी विश्लेषण, HTTP स्तर पर वास्तव में क्या हो रहा है, यह समझने के लिए उपयोगी

किस पर ध्यान केंद्रित करें: stream=True सेट करना, डेल्टा चंक्स पर पुनरावृति करना, भागों से पूरी प्रतिक्रिया इकट्ठा करना, और StreamingResponse का उपयोग करके स्ट्रीमिंग को FastAPI एंडपॉइंट में वायर करना

टिप: उपयोगकर्ता-सामना करने वाले ऐप्स के लिए स्ट्रीमिंग लगभग हमेशा सही विकल्प है। कोई भी एक बार में पूरी प्रतिक्रिया प्रकट होने की प्रतीक्षा में 10 सेकंड तक लोडिंग स्पिनर को घूरना नहीं चाहता

5. वार्तालाप स्थिति

LLM स्टेटलेस हैं – उनके पास कॉल के बीच कोई मेमोरी नहीं है। वार्तालाप इतिहास एक ऐसी चीज़ है जिसे आप हर अनुरोध के साथ पूरी संदेश सूची भेजकर प्रबंधित करते हैं। इसे समझना मौलिक है

संसाधन:

1. OpenAI चैट कम्प्लीशन गाइड, वार्तालाप प्रबंधन (आधिकारिक, मुफ़्त)

लिंक: https://platform.openai.com/docs/guides/conversation-state

मैसेज ऐरे कैसे काम करता है और मल्टी-टर्न वार्तालापों को कैसे प्रबंधित किया जाए, इसकी विहित व्याख्या

2. Anthropic मैसेजेस API डॉक्स (आधिकारिक, मुफ़्त)

लिंक: https://docs.anthropic.com/en/api/messages

Anthropic का समकक्ष। समान अवधारणा, यह देखने के लिए दोनों को पढ़ना उचित है कि वे कैसे भिन्न हैं

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

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

6. लागत, विलंबता और टोकन की बुनियादी बातें

लागत और टोकन को समझे बिना AI ऐप्स शिप करना यह है कि आप आश्चर्यजनक बिल और धीमे ऐप्स के साथ कैसे समाप्त होते हैं। यह उबाऊ लेकिन महत्वपूर्ण है

संसाधन:

1. OpenAI मूल्य निर्धारण पृष्ठ (आधिकारिक)

लिंक: https://openai.com/api/pricing

जानें कि प्रति मॉडल इनपुट और आउटपुट टोकन की लागत कितनी है। इसे बुकमार्क करें और जब भी आप कोई मॉडल चुनें तो इसे जाँचें

2. Anthropic मूल्य निर्धारण पृष्ठ (आधिकारिक)

लिंक: https://www.anthropic.com/pricing

Claude मॉडल के लिए भी ऐसा ही

3. OpenAI टोकनाइज़र टूल (मुफ़्त, इंटरैक्टिव)

लिंक: https://platform.openai.com/tokenizer

कोई भी टेक्स्ट पेस्ट करें और देखें कि यह वास्तव में कितने टोकन है। सीखते समय इसका लगातार उपयोग करें

4. Tiktoken (Python लाइब्रेरी, मुफ़्त)

लिंक: https://github.com/openai/tiktoken

अनुरोध भेजने से पहले कोड में टोकन गिनने के लिए OpenAI की टोकनाइज़र लाइब्रेरी

किस पर ध्यान केंद्रित करें: टोकन क्या है (लगभग 4 वर्ण / 3/4 शब्द), इनपुट बनाम आउटपुट टोकन की कीमत कैसे अलग होती है, संदर्भ विंडो का आकार आप जो कर सकते हैं उसे कैसे प्रभावित करता है, और छोटे तेज़ मॉडल और बड़े अधिक स्मार्ट मॉडल के बीच विलंबता व्यापार-बंद

यह भी: हर चीज़ के लिए GPT-4/Opus का उपयोग न करें – सस्ते मॉडल अक्सर सरल कार्यों के लिए पर्याप्त अच्छे होते हैं

7. विफलता प्रबंधन

LLM APIs विफल हो जाती हैं। दर सीमाएँ हिट हो जाती हैं, प्रतिक्रियाएँ टाइम आउट हो जाती हैं, मॉडल मैलफ़ॉर्मेड JSON लौटाता है। विफलताओं को शालीनता से संभालना ही एक डेमो को प्रोडक्शन ऐप से अलग करता है

संसाधन:

1. OpenAI त्रुटि कोड संदर्भ (आधिकारिक, मुफ़्त)

लिंक: https://platform.openai.com/docs/guides/error-codes

हर त्रुटि प्रकार जिसका आप सामना करेंगे और इसके बारे में क्या करना है

2. Anthropic त्रुटि प्रबंधन डॉक्स (आधिकारिक, मुफ़्त)

लिंक: https://docs.anthropic.com/en/api/errors

Claude के लिए भी ऐसा ही

3. Tenacity (Python लाइब्रेरी, मुफ़्त)

लिंक: https://tenacity.readthedocs.io/

किसी भी Python फंक्शन में एक्सपोनेंशियल बैकऑफ़ के साथ रीट्राई लॉजिक जोड़ने के लिए एक साफ़ लाइब्रेरी। एक डेकोरेटर और आपके रीट्राई हैंडल हो जाते हैं

किस पर ध्यान केंद्रित करें: दर सीमा त्रुटियाँ (429) और एक्सपोनेंशियल बैकऑफ़, httpx/requests के साथ टाइमआउट हैंडलिंग, उपयोग करने से पहले मॉडल आउटपुट को मान्य करना, फ़ॉलबैक रणनीतियाँ (एक अलग मॉडल के साथ पुनर्प्रयास, कैश की गई प्रतिक्रिया वापस करना), और अपने ऐप को कभी क्रैश न करना क्योंकि LLM ने अप्रत्याशित आउटपुट लौटाया

8. प्रॉम्प्ट इंजेक्शन जागरूकता

प्रॉम्प्ट इंजेक्शन LLM एप्लिकेशन में #1 सुरक्षा जोखिम है

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

आपको सुरक्षा विशेषज्ञ बनने की ज़रूरत नहीं है, लेकिन आपको कुछ भी शिप करने से पहले यह जानना होगा कि यह मौजूद है

संसाधन:

1. LLM ऐप्स के लिए OWASP टॉप 10 – LLM01: प्रॉम्प्ट इंजेक्शन (मुफ़्त)

लिंक: https://genai.owasp.org/llmrisk/llm01-prompt-injection/

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

2. OWASP प्रॉम्प्ट इंजेक्शन रोकथाम Cheat Sheet (मुफ्त)

लिंक: https://cheatsheetseries.owasp.org/cheatsheets/LLM_Prompt_Injection_Prevention_Cheat_Sheet.html

व्यावहारिक रक्षात्मक पैटर्न: इनपुट वैलिडेशन, विशेषाधिकार नियंत्रण और आउटपुट वैलिडेशन

3. Evidently AI: प्रॉम्प्ट इंजेक्शन क्या है (मुफ्त)

लिंक: https://www.evidentlyai.com/llm-guide/prompt-injection-llm

हमले के प्रकारों, जोखिमों और उन्हें कम करने के लिए डिज़ाइन पैटर्न पर एक स्पष्ट डेवलपर-केंद्रित व्याख्याकार।

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

दूसरे महीने का माइलस्टोन

इस महीने के अंत तक आपको यह करने में सक्षम होना चाहिए:

• किसी दिए गए कार्य के लिए सुसंगत, विश्वसनीय आउटपुट देने वाले प्रॉम्प्ट लिखना
• Pydantic + Instructor का उपयोग करके किसी भी मॉडल से संरचित JSON डेटा प्राप्त करना
• टूल कॉलिंग को वायर करना ताकि मॉडल आपके Python फ़ंक्शन को कॉल कर सके
• FastAPI एंडपॉइंट के माध्यम से रीयल टाइम में प्रतिक्रियाओं को स्ट्रीम करना
• मल्टी-टर्न वार्तालाप इतिहास को उचित रूप से प्रबंधित करना
• अनुरोध भेजने से पहले उसकी टोकन लागत का अनुमान लगाना
• बिना क्रैश हुए API त्रुटियों, टाइमआउट और खराब आउटपुट को संभालना
• प्रॉम्प्ट इंजेक्शन क्या है, यह समझाना और बुनियादी सुरक्षा लागू करना

⏩------------------------------------------------------------------------⏪

तीसरा महीना: RAG को सही तरीके से सीखें

इस महीने आपका लक्ष्य: ऐसे सिस्टम बनाना जो LLM को आपके दस्तावेज़ों से प्रश्नों के उत्तर देने दें, न कि केवल उनके प्रशिक्षण डेटा से।

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

RAG अभी AI इंजीनियरिंग में सबसे अधिक मांग वाला व्यावहारिक कौशल है। लगभग हर वास्तविक उद्यम AI उपयोग मामला – कस्टमर सपोर्ट बॉट, आंतरिक ज्ञानकोष, दस्तावेज़ Q&A – इसी पर बनाया गया है।

इसे गहराई से समझना, न कि केवल एक ट्यूटोरियल कॉपी करना, अच्छे इंजीनियरों को महान इंजीनियरों से अलग करता है।

1. Embeddings

RAG सिस्टम बनाने से पहले, आपको यह समझना होगा कि एम्बेडिंग वास्तव में क्या है – क्योंकि यही वह नींव है जिस पर बाकी सब कुछ बनाया गया है।

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

संसाधन:

1. Stack Overflow Blog: टेक्स्ट एम्बेडिंग का सहज परिचय (मुफ्त)

लिंक: https://stackoverflow.blog/2023/11/09/an-intuitive-introduction-to-text-embeddings/

शुरुआती लोगों के लिए सबसे अच्छी व्याख्या। एक डेवलपर द्वारा लिखित जिसने NLP उत्पाद बनाने में वर्षों बिताए हैं, गणित के बजाय सही अंतर्ज्ञान बनाने पर ध्यान केंद्रित करते हुए।

2. Google ML Crash Course: Embeddings (मुफ्त)

लिंक: https://developers.google.com/machine-learning/crash-course/embeddings

यह बताता है कि क्यों सघन वेक्टर प्रतिनिधित्व उन समस्याओं को हल करते हैं जो one-hot एन्कोडिंग नहीं कर सकती – विशेष रूप से, वस्तुओं के बीच अर्थगत संबंधों को कैप्चर करना।

3. HuggingFace: Embeddings के साथ शुरुआत (मुफ्त)

लिंक: https://huggingface.co/blog/getting-started-with-embeddings

व्यावहारिक गाइड। दिखाता है कि sentence-transformers लाइब्रेरी का उपयोग करके एम्बेडिंग कैसे उत्पन्न करें, उन्हें होस्ट करें और एक वास्तविक FAQ डेटासेट पर अर्थगत खोज के लिए उपयोग करें।

4. OpenAI Embeddings Guide (आधिकारिक दस्तावेज़, मुफ्त)

लिंक: https://platform.openai.com/docs/guides/embeddings

कोड में OpenAI के text-embedding-3-small और text-embedding-3-large मॉडल का उपयोग करने के लिए संदर्भ।

किस पर ध्यान केंद्रित करें: वेक्टर अवधारणात्मक रूप से क्या है, समान टेक्स्ट समान वेक्टर क्यों उत्पन्न करता है, कोसाइन समानता कैसे काम करती है, एम्बेडिंग मॉडल (OpenAI, HuggingFace sentence-transformers) के बीच अंतर, और एम्बेडिंग आयाम व्यवहार में क्या मायने रखता है।

अभ्यास: संबंधित विषयों पर 20 वाक्य लें, उन्हें OpenAI या sentence-transformers का उपयोग करके एम्बेड करें, और एक सरल निकटतम-पड़ोसी खोज लिखें जो क्वेरी से 3 सबसे समान लौटाए। यह सचमुच RAG का दिल है।

2. Chunking

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

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

संसाधन:

1. Weaviate: RAG के लिए चंकिंग रणनीतियाँ (मुफ्त)

लिंक: https://weaviate.io/blog/chunking-strategies-for-rag

सबसे व्यावहारिक गाइड। फिक्स्ड-साइज़, रिकर्सिव और सिमैंटिक चंकिंग को कवर करता है, प्रत्येक का उपयोग कब करना है इस पर स्पष्ट मार्गदर्शन के साथ।

2. Unstructured: RAG बेस्ट प्रैक्टिसेज़ के लिए चंकिंग (मुफ्त)

लिंक: https://unstructured.io/blog/chunking-for-rag-best-practices

चंक आकार, ओवरलैप और एम्बेडिंग मॉडल के कॉन्टेक्स्ट विंडो द्वारा लगाई गई कठोर सीमाओं पर एक तकनीकी गहराई से अध्ययन। प्रयोग के लिए एक अच्छा प्रारंभिक बिंदु लगभग 250 टोकन (लगभग 1,000 वर्ण) का चंक आकार है, जिसमें सीमाओं पर संदर्भ खोने से बचने के लिए लगातार चंकों के बीच 10-20% ओवरलैप हो।

3. LangChain Text Splitters Docs (आधिकारिक, मुफ्त)

लिंक: https://python.langchain.com/docs/concepts/text_splitters/

कोड में RecursiveCharacterTextSplitter, MarkdownTextSplitter और सिमैंटिक स्प्लिटर का उपयोग करने के लिए व्यावहारिक संदर्भ।

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

शुरुआती टिप: LangChain से RecursiveCharacterTextSplitter को chunk_size=500 और chunk_overlap=50 के साथ शुरू करें। यह अधिकांश दस्तावेज़ों के लिए सबसे समझदार डिफ़ॉल्ट है और आपको सुधारने के लिए एक काम करने वाला आधारभूत देता है।

3. Vector Databases

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

सही चुनाव आपकी स्थिति पर निर्भर करता है: तेज़ स्थानीय प्रोटोटाइप के लिए Chroma, प्रबंधित टर्नकी स्केल के लिए Pinecone, मजबूत हाइब्रिड खोज के साथ ओपन-सोर्स लचीलेपन के लिए Weaviate, जटिल फ़िल्टर और लागत-कुशल सेल्फ-होस्टिंग के लिए Qdrant, और pgvector यदि आप पहले से PostgreSQL पर हैं और दूसरा सिस्टम जोड़ने से बचना चाहते हैं।

संसाधन:

1. Chroma आधिकारिक दस्तावेज़ (मुफ्त)

लिंक: https://docs.trychroma.com/

Chroma व्यक्तिगत डेवलपर्स और छोटी टीमों के लिए एकदम सही है जो विकास गति और सादगी को प्राथमिकता देते हैं, यह इन-मेमोरी या स्थानीय रूप से बिना किसी बुनियादी ढांचे के प्रबंधन के चलता है।

2. Pinecone Learning Center (मुफ्त)

लिंक: https://www.pinecone.io/learn/

वेक्टर खोज अवधारणाओं, हाइब्रिड खोज और RAG पाइपलाइनों को कवर करने वाले उत्कृष्ट मुफ्त ट्यूटोरियल। भले ही आप Pinecone का उपयोग न करें, अच्छी प्रदाता-अज्ञेयवादी सामग्री।

3. Qdrant दस्तावेज़ीकरण (मुफ्त)

लिंक: https://qdrant.tech/documentation/

उन्नत फ़िल्टरिंग के साथ उत्पादन के लिए सबसे अच्छा ओपन-सोर्स विकल्प। बहुत तेज़, लचीला और सेल्फ-होस्ट करने के लिए मुफ्त।

4. pgvector (ओपन सोर्स, मुफ्त)

लिंक: https://github.com/pgvector/pgvector

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

किस पर ध्यान केंद्रित करें: कलेक्शन बनाना, मेटाडेटा के साथ एम्बेडिंग सम्मिलित करना, top_k के साथ समानता द्वारा क्वेरी करना और क्वेरी समय पर मेटाडेटा द्वारा फ़िल्टर करना।

आपको इंडेक्सिंग एल्गोरिदम (HNSW, IVF) को समझने की आवश्यकता नहीं है – बस उनका उपयोग करना समझें।

अभ्यास परियोजना: किसी भी सार्वजनिक दस्तावेज़ीकरण (जैसे Python docs, या Wikipedia लेख डंप) से 50-100 पृष्ठों को मेटाडेटा (स्रोत URL, अनुभाग शीर्षक) के साथ Chroma में इंडेक्स करें। एक क्वेरी फ़ंक्शन लिखें जो किसी भी प्रश्न के लिए 5 सबसे प्रासंगिक चंक्स पुनर्प्राप्त करे।

4. Metadata Filtering

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

संसाधन:

1. Pinecone: मेटाडेटा फ़िल्टरिंग गाइड (मुफ्त)

लिंक: https://docs.pinecone.io/guides/data/filter-with-metadata

समानता खोज से पहले या उसके दौरान मेटाडेटा फ़ील्ड द्वारा वेक्टर फ़िल्टर करने के कोड उदाहरणों के साथ स्पष्ट व्याख्या।

2. LlamaIndex: मेटाडेटा फ़िल्टर गाइड (आधिकारिक दस्तावेज़, मुफ्त)

लिंक: https://docs.llamaindex.ai/en/stable/module_guides/querying/node_postprocessors/node_postprocessors/

LlamaIndex पाइपलाइनों में क्वेरी समय पर फ़िल्टर कैसे लागू करें, इसकी व्याख्या।

किस पर ध्यान केंद्रित करें: इन्जेस्ट समय पर प्रत्येक चंक को प्रासंगिक मेटाडेटा (स्रोत फ़ाइल नाम, पृष्ठ संख्या, अनुभाग, तिथि, श्रेणी) के साथ टैग करना और क्वेरी समय पर परिणाम फ़िल्टर करने के लिए उन फ़ील्ड का उपयोग करना। यह एक टॉय डेमो और प्रोडक्शन सिस्टम के बीच का अंतर बनाता है जहाँ उपयोगकर्ता पूछ सकते हैं "मुझे केवल Q4 2025-Q1 2026 रिपोर्ट के परिणाम दिखाएं"।

5. Reranking

रीरैंकिंग एक तकनीक है जो किसी भी कीवर्ड या वेक्टर खोज सिस्टम की खोज गुणवत्ता में अर्थगत बढ़ावा जोड़ती है।

पहले चरण की पुनर्प्राप्ति उम्मीदवार सेट लौटाने के बाद, एक रीरैंकर उन परिणामों को क्वेरी के वास्तविक प्रासंगिक संदर्भ के आधार पर पुनः स्कोर करता है – न कि केवल वेक्टर निकटता के आधार पर।

दो-चरण पैटर्न है: एम्बेड और खोजें (तेज़, अनुमानित) → top-k को फिर से रैंक करें (धीमा, अधिक सटीक)। परिणाम नाटकीय रूप से बेहतर पुनर्प्राप्ति गुणवत्ता है जिसमें केवल मामूली विलंबता लागत होती है।

संसाधन:

1. Cohere Reranking Docs (आधिकारिक, मुफ्त)

लिंक: https://docs.cohere.com/docs/reranking-with-cohere

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

2. LangChain: Cohere Reranker इंटीग्रेशन (आधिकारिक दस्तावेज़, मुफ्त)

लिंक: https://python.langchain.com/docs/integrations/retrievers/cohere-reranker/

ContextualCompressionRetriever का उपयोग करके Cohere रीरैंकिंग को LangChain रिट्रीवर से कैसे जोड़ा जाए, इसकी व्याख्या।

किस पर ध्यान केंद्रित करें: दो-चरण retrieve-then-rerank पैटर्न, bi-encoder (पहले चरण की एम्बेडिंग खोज के लिए उपयोग किया जाता है) और cross-encoder (रीरैंकिंग के लिए उपयोग किया जाता है) के बीच अंतर, और top-20 बनाम top-5 परिणामों को रीरैंक करने का व्यावहारिक विलंबता/गुणवत्ता व्यापार-बंद।

6. पुनर्प्राप्ति गुणवत्ता के मुद्दे

अधिकांश RAG विफलताएँ मॉडल विफलताएँ नहीं हैं, वे पुनर्प्राप्ति विफलताएँ हैं। वास्तविक सिस्टम को डीबग करने के लिए पुनर्प्राप्ति के गलत होने के तरीकों को समझना आवश्यक है।

सामान्य मुद्दे सीखने के लिए:

• सिमैंटिक ड्रिफ्ट: क्वेरी एम्बेडिंग प्रासंगिक चंक एम्बेडिंग से मेल नहीं खाती, भले ही जानकारी मौजूद हो। समाधान: क्वेरी राइटिंग या HyDE (हाइपोथेटिकल डॉक्यूमेंट एम्बेडिंग) आज़माएँ।
• चंक बाउंड्री समस्याएँ: प्रासंगिक जानकारी दो चंकों में विभाजित हो जाती है। समाधान: ओवरलैप बढ़ाएँ या सिमैंटिक चंकिंग का उपयोग करें।
• गुम मेटाडेटा संदर्भ: चंक क्वेरी के समान अर्थगत रूप से समान हैं लेकिन गलत दस्तावेज़, तिथि या उपयोगकर्ता के हैं। समाधान: मेटाडेटा फ़िल्टरिंग का उपयोग करें।
• Top-k बहुत छोटा: सही चंक मौजूद है लेकिन पुनर्प्राप्त top-5 में नहीं है। समाधान: पुनर्प्राप्ति पर top_k बढ़ाएँ और रीरैंकिंग के बाद कम करें।

संसाधन:

1. LangChain: क्वेरी ट्रांसफ़ॉर्मेशन (मुफ्त)

लिंक: https://python.langchain.com/docs/how_to/#query-analysis

क्वेरी राइटिंग, स्टेप-बैक प्रॉम्प्टिंग और HyDE को कवर करता है।

2. Pinecone: पुनर्प्राप्ति गुणवत्ता में सुधार (मुफ्त)

लिंक: https://www.pinecone.io/learn/retrieval-augmented-generation/#retrieval-quality

समाधानों के साथ सामान्य विफलता मोड का व्यावहारिक वॉकथ्रू।

7. हैल्युसिनेशन में कमी

RAG एक सादे LLM की तुलना में हैल्युसिनेशन को नाटकीय रूप से कम करता है, लेकिन यह उन्हें समाप्त नहीं करता है।

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

लेकिन पुनर्प्राप्ति विफलताएँ, खराब चंक और परस्पर विरोधी जानकारी अभी भी मॉडल को चीज़ें बनाने का कारण बन सकती हैं।

संसाधन:

1. Zep: LLM हैल्युसिनेशन कम करना – एक डेवलपर गाइड (मुफ्त)

लिंक: https://www.getzep.com/ai-agents/reducing-llm-hallucinations/

प्रॉम्प्ट ग्राउंडिंग रणनीतियों, तथ्यात्मक कार्यों के लिए चेन-ऑफ-थॉट और आउटपुट सत्यापन पैटर्न को कवर करने वाली व्यावहारिक डेवलपर-केंद्रित गाइड।

2. Voiceflow: LLM हैल्युसिनेशन कम करने के 5 तरीके (मुफ्त)

लिंक: https://www.voiceflow.com/blog/prevent-llm-hallucinations

संयुक्त रणनीति का अच्छा अवलोकन: RAG + चेन-ऑफ-थॉट + गार्डरेल एक साथ किसी एक दृष्टिकोण से बेहतर प्रदर्शन करते हैं।

किस पर ध्यान केंद्रित करें: मॉडल को केवल प्रदान किए गए संदर्भ से उत्तर देने के लिए प्रॉम्प्ट करना (और जब उत्तर नहीं है तो "मुझे नहीं पता" कहना), प्रतिक्रियाएँ प्रस्तुत करने से पहले एक विश्वास सीमा जोड़ना और LLM को दोष देने से पहले हमेशा पुनर्प्राप्ति गुणवत्ता को मान्य करना।

8. उद्धरण और ग्राउंडिंग

एक आधारित RAG सिस्टम केवल उत्तर नहीं देता – यह बताता है कि उत्तर कहाँ से आया। यह उपयोगकर्ता के विश्वास और डीबगिंग के लिए महत्वपूर्ण है।

संसाधन:

1. Anthropic: Claude को स्रोत देना (दस्तावेज़, मुफ्त)

लिंक: https://docs.anthropic.com/en/docs/build-with-claude/citations

स्रोत संदर्भों के साथ उद्धृत प्रतिक्रिया देने के लिए Claude को प्रॉम्प्ट करने का तरीका बताया गया है।

2. LangChain: स्रोतों के साथ RAG (मुफ्त)

लिंक: https://python.langchain.com/docs/how_to/qa_sources/

LangChain RAG पाइपलाइन में उत्तरों के साथ स्रोत दस्तावेज़ वापस करने का तरीका बताया गया है।

किस पर ध्यान केंद्रित करें: अपने प्रॉम्प्ट संदर्भ में चंक मेटाडेटा (स्रोत फ़ाइल नाम, पृष्ठ संख्या, URL) पास करना, मॉडल को अपने उत्तर में स्रोतों को संदर्भित करने का निर्देश देना और अपने UI या API प्रतिक्रिया में उन स्रोतों को प्रस्तुत करना।

9. आपका RAG फ्रेमवर्क: LangChain या LlamaIndex

आपको RAG पाइपलाइन स्क्रैच से बनाने की आवश्यकता नहीं है। दो फ्रेमवर्क इस क्षेत्र पर हावी हैं और जानने लायक हैं:

LlamaIndex खोज और इंडेक्सिंग को पहले रखने के लिए अनुकूलित है – यह इन्जेस्ट, चंकिंग, एम्बेडिंग और क्वेरी को कोड की कुछ पंक्तियों में सारगर्भित करता है, जिससे आप एक दोपहर में काम करने वाला प्रोटोटाइप बना सकते हैं।

LangChain तब चमकता है जब आपका एप्लिकेशन एक ऑर्केस्ट्रेशन इंजन की तरह दिखता है – यह मल्टी-एजेंट वर्कफ़्लो, टूल कॉलिंग और सशर्त श्रृंखलाओं में उत्कृष्ट है जो उत्तर उत्पन्न करने से पहले कई LLM या बाहरी API को क्वेरी करते हैं।

तीसरे महीने के लिए, RAG के लिए LlamaIndex से शुरू करें। जब आप चौथे महीने के एजेंट कार्य पर पहुँचें तो LangChain पर जाएँ।

संसाधन:

1. LlamaIndex: RAG का परिचय (आधिकारिक दस्तावेज़, मुफ्त)

लिंक: https://developers.llamaindex.ai/python/framework/understanding/rag/

RAG के पाँच प्रमुख चरणों को कवर करता है: लोडिंग, इंडेक्सिंग, स्टोर करना, क्वेरी करना और मूल्यांकन करना – और LlamaIndex उनमें से प्रत्येक को कैसे संभालता है।

2. LlamaIndex स्टार्टर ट्यूटोरियल (आधिकारिक दस्तावेज़, मुफ्त)

लिंक: https://developers.llamaindex.ai/python/framework/getting_started/starter_example/

आधिकारिक क्विकस्टार्ट। 30 पंक्तियों से कम में एक काम करने वाला RAG सिस्टम बनाएँ।

3. LangChain: एक RAG एजेंट बनाएँ (आधिकारिक दस्तावेज़, मुफ्त)

लिंक: https://docs.langchain.com/oss/python/langchain/rag

दिखाता है कि RAG एजेंट का उपयोग करके असंरचित टेक्स्ट पर Q&A ऐप कैसे बनाया जाए, एक 40-लाइन न्यूनतम संस्करण से लेकर रीरैंकिंग के साथ पूर्ण पुनर्प्राप्ति पाइपलाइन तक।

अभ्यास परियोजना: एक "अपने दस्तावेज़ों से चैट करें" ऐप बनाएँ। 10-20 PDF या टेक्स्ट फ़ाइलें इन्जेस्ट करें (आपके अपने नोट्स, एक पाठ्यपुस्तक अध्याय, उत्पाद दस्तावेज़ीकरण – कुछ भी)। एक FastAPI एंडपॉइंट बनाएँ जो एक प्रश्न स्वीकार करता है, रीरैंकिंग के साथ शीर्ष 5 सबसे प्रासंगिक चंक्स पुनर्प्राप्त करता है और Claude या OpenAI से एक उद्धृत उत्तर लौटाता है। यह एक वास्तविक पोर्टफोलियो टुकड़ा है।

तीसरे महीने का माइलस्टोन

इस महीने के अंत तक आपको यह करने में सक्षम होना चाहिए:

• समझाएँ कि एम्बेडिंग क्या है और समान टेक्स्ट समान वेक्टर क्यों उत्पन्न करता है
• उपयुक्त रणनीतियों का उपयोग करके किसी भी दस्तावेज़ को बुद्धिमानी से चंक करें
• मेटाडेटा फ़िल्टरिंग के साथ वेक्टर डेटाबेस में एम्बेडिंग स्टोर और क्वेरी करें
• पुनर्प्राप्ति गुणवत्ता में सुधार के लिए एक रीरैंकिंग चरण जोड़ें
• सामान्य पुनर्प्राप्ति विफलताओं को व्यवस्थित रूप से डीबग करें
• LlamaIndex या LangChain का उपयोग करके एक पूर्ण एंड-टू-एंड RAG पाइपलाइन बनाएँ जो दस्तावेज़ों को इन्जेस्ट करती है, प्रासंगिक चंक्स पुनर्प्राप्त करती है और आधारित, उद्धृत उत्तर लौटाती है

⏩------------------------------------------------------------------------⏪

चौथा महीना: एजेंट, टूल्स, वर्कफ़्लो और मूल्यांकन

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

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

यह वह जगह है जहाँ AI इंजीनियरिंग वास्तव में जटिल हो जाती है। चौथे महीने के कौशल जूनियर AI इंजीनियरों को उन लोगों से अलग करते हैं जो संपूर्ण AI सुविधा को एंड-टू-एंड अपने कब्जे में ले सकते हैं।

1. Agent Loops

एजेंट जादू नहीं है, यह एक आश्चर्यजनक रूप से सरल पैटर्न है।

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

यह लूप उन्हें ऐसे कार्यों से निपटने की अनुमति देता है जो सरल प्रश्नों और उत्तरों से परे जाते हैं, वास्तविक ऑटोमेशन, टूल उपयोग और चलते-फिरते अनुकूलन की ओर बढ़ते हैं।

"सोच" प्रॉम्प्ट में होती है, "ब्रांचिंग" तब होती है जब एजेंट उपलब्ध टूल के बीच चुनता है, और "करना" तब होता है जब हम बाहरी फ़ंक्शन कॉल करते हैं। बाकी सब सिर्फ प्लंबिंग है।

एक बार जब आप इसे आंतरिक कर लेते हैं, तो सबसे जटिल एजेंट फ्रेमवर्क भी पढ़ने योग्य हो जाते हैं।

संसाधन:

1. Anthropic: प्रभावी एजेंट बनाना (आधिकारिक, मुफ्त)

लिंक: https://www.anthropic.com/research/building-effective-agents

प्रोडक्शन में एजेंटों पर एकल सबसे अच्छा लेखन। एजेंट कोड की एक पंक्ति लिखने से पहले इसे पढ़ें।

2. OpenAI: एजेंट बनाने के लिए एक व्यावहारिक गाइड (आधिकारिक PDF, मुफ्त)

लिंक: https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf

OpenAI की पूरक गाइड जो प्रोडक्शन में एजेंट पैटर्न, गार्डरेल और सुरक्षा पैटर्न को कवर करती है।

3. freeCodeCamp: ओपन सोर्स LLM एजेंट हैंडबुक (मुफ्त)

लिंक: https://www.freecodecamp.org/news/the-open-source-llm-agent-handbook/

एजेंट लूप, LangGraph, CrewAI, प्लानिंग, मेमोरी और टूल उपयोग को कवर करने वाली एक व्यापक व्यावहारिक गाइड। जल्दी से व्यावहारिक होने के लिए अच्छा है।

4. LangChain Academy: LangGraph का परिचय (मुफ्त पाठ्यक्रम)

लिंक: https://academy.langchain.com/courses/intro-to-langgraph

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

किस पर ध्यान केंद्रित करें: परसेप्ट → प्लान → एक्ट → ऑब्ज़र्व चक्र, एजेंट लूप कैसे समाप्त होता है, लूप के अंदर टूल कॉल विफल होने पर क्या होता है, और एजेंट केवल while लूप हैं जिसमें LLM ब्रांचिंग निर्णय लेता है।

अभ्यास: बिना किसी फ्रेमवर्क के स्क्रैच से एक एजेंट बनाएँ – केवल सीधे OpenAI या Anthropic API का उपयोग करें। इसे 3 टूल, एक लक्ष्य और एक लूप दें। फ्रेमवर्क वास्तव में क्या सारगर्भित कर रहे हैं, यह समझने के लिए यह सबसे मूल्यवान काम है जो आप कर सकते हैं।

2. Tool Selection

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

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

संसाधन:

1. OpenAI: फ़ंक्शन कॉलिंग बेस्ट प्रैक्टिसेज़ (आधिकारिक दस्तावेज़, मुफ्त)

लिंक: https://platform.openai.com/docs/guides/function-calling/best-practices

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

2. Anthropic: टूल उपयोग बेस्ट प्रैक्टिसेज़ (आधिकारिक दस्तावेज़, मुफ्त)

लिंक: https://docs.anthropic.com/en/docs/build-with-claude/tool-use/implement-tool-use#best-practices-for-tool-definitions

Anthropic का समकक्ष। इस बात पर मार्गदर्शन पर विशेष ध्यान दें कि मॉडल को चुनने देना बनाम किसी विशिष्ट टूल को मजबूर करना कब है।

किस पर ध्यान केंद्रित करें: स्व-व्याख्यात्मक क्रिया वाले टूल नाम लिखना, ऐसे विवरण लिखना जो समझाएँ कि टूल को कब कॉल करना है (न कि केवल यह क्या करता है), पैरामीटर को न्यूनतम और अच्छी तरह से टाइप करके रखना, और LLM को कॉलर के रूप में डिज़ाइन किए गए टूल बनाना।

शुरुआती टिप: स्वयं से पूछकर प्रत्येक टूल विवरण का परीक्षण करें: "यदि मेरे पास कोई दस्तावेज़ीकरण नहीं था और केवल यह JSON स्कीमा था, तो क्या मुझे ठीक-ठीक पता होगा कि इसे कब और कैसे कॉल करना है?" यदि नहीं, तो इसे और अधिक काम की आवश्यकता है।

3. State Management

LangGraph में, स्टेट एक साझा मेमोरी ऑब्जेक्ट है जो ग्राफ के माध्यम से प्रवाहित होता है। यह सभी प्रासंगिक जानकारी – संदेश, चर, मध्यवर्ती परिणाम और निर्णय इतिहास – संग्रहीत करता है और निष्पादन के दौरान स्वचालित रूप से प्रबंधित होता है।

स्टेट को समझना उन एजेंटों के निर्माण की कुंजी है जो मल्टी-टर्न कार्यों को संभाल सकते हैं, विफलताओं से उबर सकते हैं और घटकों के बीच सफाई से हाथ बदल सकते हैं।

संसाधन:

1. LangGraph आधिकारिक दस्तावेज़: स्टेट प्रबंधन (मुफ्त)

लिंक: https://langchain-ai.github.io/langgraph/concepts/low_level/#state

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

निश्चित संदर्भ। स्टेट स्कीमा, रिड्यूसर, और स्टेट नोड्स और एजेज के माध्यम से कैसे प्रवाहित होता है, इसे कवर करता है।

2. DataCamp: LangGraph एजेंट ट्यूटोरियल (मुफ्त)

लिंक: https://www.datacamp.com/tutorial/langgraph-agents

स्टेट, नोड्स और एजेज की मूल बातें हाथों-हाथ कोड के साथ कवर करता है, और सत्रों के बीच लगातार मेमोरी वाले स्टेटफुल एजेंट तक पहुँचता है।

3. Real Python: लैंगग्राफ़ इन पायथन (मुफ्त)

लिंक: https://realpython.com/langgraph-python/

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

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

4. एजेंट्स में पुनर्प्रयास और विफलता प्रबंधन

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

संसाधन:

1. LangGraph: एरर हैंडलिंग और रिट्राईज़ (आधिकारिक दस्तावेज़, मुफ्त)

लिंक: https://langchain-ai.github.io/langgraph/how-tos/autofill-tool-errors/

LangGraph में टूल नोड स्तर पर स्वचालित त्रुटि प्रबंधन और पुनर्प्रयास तर्क कैसे जोड़ें, इसकी व्याख्या।

2. OpenAI प्रैक्टिकल एजेंट्स गाइड: गार्डरेल्स सेक्शन (मुफ्त)

लिंक: https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf

गार्डरेल्स को एक स्तरित रक्षा के रूप में शामिल करता है, जो एजेंट लूप के हर चरण में इनपुट और आउटपुट दोनों की जांच करने के लिए LLM-आधारित जाँच, नियम-आधारित फ़िल्टर जैसे regex, और मॉडरेशन API को जोड़ता है।

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

5. एजेंट्स का उपयोग कब नहीं करना चाहिए

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

Anthropic सबसे सरल संभव समाधान खोजने और आवश्यकता पड़ने पर ही जटिलता बढ़ाने की सलाह देता है – इसका मतलब यह हो सकता है कि एजेंटिक सिस्टम बिल्कुल न बनाएं।

एजेंटिक सिस्टम बेहतर कार्य प्रदर्शन के लिए विलंबता और लागत का व्यापार करते हैं, और आपको सावधानीपूर्वक विचार करना चाहिए कि यह व्यापार कब समझ में आता है।

निर्णय ढांचा इस प्रकार है:

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

संसाधन:

1. Anthropic: प्रभावी एजेंट बनाना, एजेंट्स का उपयोग कब करें (आधिकारिक, मुफ्त)

लिंक: https://www.anthropic.com/research/building-effective-agents

इस प्रश्न का सबसे आधिकारिक उत्तर, सीधे उस टीम से जो मॉडल बनाती है।

2. साइमन विलिसन: डिज़ाइनिंग एजेंटिक लूप्स (मुफ्त)

लिंक: https://simonwillison.net/2025/Sep/30/designing-agentic-loops/

एक वरिष्ठ इंजीनियर का व्यावहारिक दृष्टिकोण कि एजेंट जटिलता कब उचित है और एजेंटिक लूप डिज़ाइन के बारे में कैसे सोचें।

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

6. मल्टी-स्टेप वर्कफ़्लोज़

"एकल प्रॉम्प्ट" और "पूर्ण एजेंट" के बीच एक विशाल उत्पादक मध्य मैदान है: वर्कफ़्लोज़। वर्कफ़्लोज़ तब आदर्श होते हैं जब कार्य को साफ-साफ निश्चित उप-कार्यों में विघटित किया जा सकता है – प्रत्येक व्यक्तिगत LLM कॉल को एक आसान, अधिक केंद्रित कार्य बनाकर उच्च सटीकता के लिए विलंबता का व्यापार करना।

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

संसाधन:

1. Anthropic: वर्कफ़्लो पैटर्न्स (आधिकारिक, मुफ्त)

लिंक: https://www.anthropic.com/research/building-effective-agents#workflow-patterns

सभी मुख्य पैटर्न को आरेख और कोड उदाहरणों के साथ शामिल करता है। समानांतरीकरण और ऑर्केस्ट्रेशन अनुभाग विशेष रूप से उपयोगी हैं।

2. LangGraph: मल्टी-एजेंट नेटवर्क्स (आधिकारिक दस्तावेज़, मुफ्त)

लिंक: https://langchain-ai.github.io/langgraph/concepts/multi_agent/

सुपरवाइज़र और हैंडऑफ़ पैटर्न के साथ, कई एजेंटों को एक नेटवर्क के रूप में कैसे जोड़ा जाए, इसकी व्याख्या।

अभ्यास परियोजना: एक 3-चरणीय सामग्री पाइपलाइन बनाएं:

चरण 1 – एक LLM एक लेख से मुख्य तथ्य निकालता है।

चरण 2 – एक और LLM कॉल उन तथ्यों का उपयोग करके समानांतर में एक ट्वीट, एक LinkedIn पोस्ट और एक सारांश उत्पन्न करती है।

चरण 3 – एक अंतिम LLM कॉल गुणवत्ता के लिए तीनों का मूल्यांकन करती है और सर्वश्रेष्ठ का चयन करती है।

कोई एजेंट की आवश्यकता नहीं, शुद्ध वर्कफ़्लो।

7. मूल्यांकन हार्नेस

एवल्स वह तरीका है जिससे आप जानते हैं कि आपका AI सिस्टम वास्तव में काम कर रहा है या नहीं — केवल उन उदाहरणों पर नहीं जिन्हें आपने हाथ से परखा, बल्कि सैकड़ों इनपुट्स पर व्यवस्थित रूप से।

AI एजेंट शक्तिशाली हैं लेकिन तैनात करने में जटिल हैं क्योंकि उनका संभाव्य, बहु-चरणीय व्यवहार विफलता के कई बिंदु पेश करता है।

एजेंट के विभिन्न भागों – LLMs, टूल्स, रिट्रीवर्स और वर्कफ़्लोज़ – में से प्रत्येक को अपने स्वयं के मूल्यांकन दृष्टिकोण की आवश्यकता होती है।

संसाधन:

1. DeepEval (ओपन सोर्स, मुफ्त)

लिंक: https://deepeval.com/docs/getting-started

pytest से प्रेरित एक ओपन-सोर्स LLM मूल्यांकन ढांचा। इनपुट और अपेक्षित आउटपुट के साथ परीक्षण मामले लिखें, उन्हें 50+ अंतर्निहित मीट्रिक (जिसमें हैल्युसिनेशन, उत्तर प्रासंगिकता और तथ्यात्मक स्थिरता शामिल है) के साथ चलाएं, और संस्करणों के बीच प्रतिगमन को पकड़ें।

2. Promptfoo (ओपन सोर्स, मुफ्त)

लिंक: https://github.com/promptfoo/promptfoo

स्वचालित परीक्षण सूट के साथ LLM ऐप्स के परीक्षण और मूल्यांकन के लिए एक CLI और लाइब्रेरी। कई मॉडलों पर कई प्रॉम्प्ट की साथ-साथ तुलना, CI/CD एकीकरण और सुरक्षा कमजोरियों के लिए रेड टीमिंग का समर्थन करता है।

3. LangSmith (मुफ्त स्तर)

लिंक: https://smith.langchain.com/

LangChain और LangGraph ऐप्स के लिए ट्रेसिंग, डीबगिंग और मूल्यांकन। मुफ्त स्तर उदार है और ट्रेसिंग UI एजेंट लूप्स को डीबग करना नाटकीय रूप से आसान बनाता है।

4. Ragas (ओपन सोर्स, मुफ्त)

लिंक: https://docs.ragas.io/

RAG पाइपलाइनों के लिए विशेष मूल्यांकन ढांचा। विश्वसनीयता, उत्तर प्रासंगिकता, संदर्भ सटीकता और संदर्भ पुनर्प्राप्ति को मापता है। यदि आप महीने 3 से RAG सिस्टम का मूल्यांकन कर रहे हैं तो आवश्यक है।

किस पर ध्यान दें: अपेक्षित आउटपुट या रूब्रिक के साथ 20-50 प्रतिनिधि इनपुट का एक गोल्डन टेस्ट सेट बनाना, मूल्यांकन फ़ंक्शन लिखना जो निर्धारित रूप से आउटपुट को स्कोर करते हैं (स्ट्रिंग मैच, JSON स्कीमा सत्यापन) या LLM-एज़-जज के साथ, और जब आप प्रॉम्प्ट बदलते हैं या मॉडल स्वैप करते हैं तो स्वचालित रूप से एवल्स चलाना।

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

8. कार्य सफलता मीट्रिक्स

स्वचालित एवल्स से परे, आपको ऐसे मीट्रिक्स की आवश्यकता है जो आपको बताएं कि आपका एजेंट अपने वास्तविक लक्ष्य को प्राप्त कर रहा है या नहीं।

संसाधन:

1. हामेल हुसैन: आपके AI उत्पाद को एवल्स की आवश्यकता है (मुफ्त)

लिंक: https://hamel.dev/blog/posts/evals/

वास्तविक उत्पादन AI सिस्टम के लिए एवल पाइपलाइन बनाने पर लिखे गए सबसे व्यावहारिक लेखों में से एक, जो किसी ऐसे व्यक्ति द्वारा लिखा गया है जिसने इसे पैमाने पर किया है।

2. OpenAI एवल्स फ्रेमवर्क (ओपन सोर्स, मुफ्त)

लिंक: https://github.com/openai/evals

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

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

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

महीने 4 का माइलस्टोन

इस महीने के अंत तक आपको इसमें सक्षम होना चाहिए:

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

⏩------------------------------------------------------------------------⏪

महीना 5: तैनाती, उत्पाद सोच, और विश्वसनीयता

इस महीने आपका लक्ष्य: आपके द्वारा बनाई गई हर चीज़ को प्रोडक्शन-रेडी बनाना।

अंत तक आपको एक AI ऐप तैनात करने में सक्षम होना चाहिए जो वास्तविक उपयोगकर्ताओं, वास्तविक ट्रैफ़िक और वास्तविक विफलताओं को बिना रात 2 बजे बिखरे संभाल सके।

यह वह जगह है जहाँ अधिकांश AI इंजीनियर अटक जाते हैं। वे एक शानदार डेमो बना सकते हैं लेकिन कोई ऐसा उत्पाद शिप नहीं कर सकते जो वास्तविक दुनिया के संपर्क में जीवित रहे।

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

1. FastAPI प्रोडक्शन पैटर्न

आप पहले से ही जानते हैं कि महीने 1 से FastAPI ऐप कैसे बनाया जाता है। अब आपको इसे प्रोडक्शन ट्रैफ़िक से बचने योग्य बनाने की आवश्यकता है।

देव और प्रोड के बीच का अंतर क्रूर है। --reload के साथ एकल uvicorn प्रक्रिया निर्माण के लिए ठीक है। प्रोडक्शन में यह अड़चन बन जाती है जैसे ही वास्तविक ट्रैफ़िक आता है।

आपको वास्तव में क्या चाहिए: मल्टी-वर्कर ASGI कॉन्फ़िगरेशन, उचित त्रुटि प्रबंधन मिडलवेयर, हेल्थ चेक एंडपॉइंट और CORS नीतियाँ।

संसाधन:

1. FastAPI तैनाती दस्तावेज़ (आधिकारिक, मुफ्त)

लिंक: https://fastapi.tiangolo.com/deployment/

Uvicorn वर्कर्स, Gunicorn और Docker तैनाती को कवर करने वाली आधिकारिक मार्गदर्शिका। किसी भी अन्य चीज़ से पहले यहाँ से शुरू करें।

2. FastAPI प्रोडक्शन तैनाती गाइड (CYS दस्तावेज़, मुफ्त)

लिंक: https://craftyourstartup.com/cys-docs/fastapi-production-deployment/

व्यापक प्रोडक्शन पैटर्न: Gunicorn कॉन्फ़िग, Nginx रिवर्स प्रॉक्सी, हेल्थ चेक, रेट लिमिटिंग। वास्तविक कॉन्फ़िग फ़ाइलें शामिल हैं जिन्हें आप अनुकूलित कर सकते हैं।

3. प्रोडक्शन के लिए FastAPI सर्वोत्तम अभ्यास (FastLaunchAPI, मुफ्त)

लिंक: https://fastlaunchapi.dev/blog/fastapi-best-practices-production-2026

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

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

2. Docker

Docker वह तरीका है जिससे आप "यह मेरी मशीन पर काम करता है" कहना बंद करते हैं और सुसंगत तैनाती शिप करना शुरू करते हैं।

यदि आप AI ऐप्स बना रहे हैं, तो Docker निर्भरता विरोधों को हल करता है, सुसंगत वातावरण सुनिश्चित करता है और स्केलिंग को सीधा बनाता है।

आपको Docker विशेषज्ञ बनने की आवश्यकता नहीं है। आपको अपने FastAPI + LLM ऐप को कंटेनरीकृत करने और इसे कहीं भी तैनात करने में सक्षम होना चाहिए।

संसाधन:

1. Docker आधिकारिक आरंभिक मार्गदर्शिका (मुफ्त)

लिंक: https://docs.docker.com/get-started/

विहित प्रारंभिक बिंदु। इमेज, कंटेनर, Dockerfiles और Docker Compose को कवर करता है।

2. freeCodeCamp: पायथन और Docker के साथ मल्टी-एजेंट AI सिस्टम कैसे बनाएं और तैनात करें (मुफ्त)

लिंक: https://www.freecodecamp.org/news/build-and-deploy-multi-agent-ai-with-python-and-docker/

Docker Compose के साथ एक वास्तविक मल्टी-एजेंट पाइपलाइन बनाने वाला व्यावहारिक अंत-से-अंत ट्यूटोरियल। चिंताओं के पृथक्करण, क्रॉन शेड्यूलिंग और सुरक्षा विचारों को कवर करता है।

3. DataCamp: Docker का उपयोग करके LLM अनुप्रयोग तैनात करें (मुफ्त)

लिंक: https://www.datacamp.com/tutorial/deploy-llm-applications-using-docker

RAG पाइपलाइनों के साथ विशेष रूप से LLM ऐप्स के लिए चरण-दर-चरण मार्गदर्शिका। Dockerfile निर्माण, पर्यावरण प्रबंधन और तैनाती को कवर करता है।

4. LLM ऐप्स के लिए Docker कंटेनरीकरण (ApXML, मुफ्त)

लिंक: https://apxml.com/courses/python-llm-workflows/chapter-10-deployment-operational-practices/containerization-docker-llm-apps

बेस इमेज चयन, निर्भरता प्रबंधन, मल्टी-स्टेज बिल्ड और मल्टी-सर्विस LLM तैनाती के लिए Docker Compose को कवर करता है।

किस पर ध्यान दें: Python/FastAPI ऐप के लिए Dockerfile लिखना, इमेज को छोटा रखने के लिए मल्टी-स्टेज बिल्ड का उपयोग करना, मल्टी-सर्विस सेटअप (ऐप + डेटाबेस + Redis) के लिए Docker Compose, रहस्यों के लिए पर्यावरण चर और संवेदनशील फ़ाइलों को लीक होने से बचाने के लिए .dockerignore।

अभ्यास परियोजना: महीने 3 से अपने RAG ऐप को कंटेनरीकृत करें। एक docker-compose.yml बनाएं जो आपके FastAPI ऐप, एक वेक्टर डेटाबेस (Chroma या Qdrant) और कैशिंग के लिए Redis चलाता है। इसे तैनात करें ताकि docker compose up सब कुछ शुरू कर दे।

3. बैकग्राउंड जॉब्स और कतारें

LLM कॉल धीमी होती हैं। यदि कोई उपयोगकर्ता आपके ऐप से किसी दस्तावेज़ को प्रोसेस करने के लिए कहता है और आप उन्हें प्रतिक्रिया के लिए 30 सेकंड प्रतीक्षा कराते हैं, तो वे चले जाएंगे।

बैकग्राउंड जॉब्स आपको अनुरोध को तुरंत स्वीकार करने, इसे एसिंक प्रोसेस करने और पूरा होने पर उपयोगकर्ता को सूचित करने देते हैं।

संसाधन:

1. Celery आधिकारिक आरंभिक मार्गदर्शिका (मुफ्त)

लिंक: https://docs.celeryq.dev/en/stable/getting-started/introduction.html

मानक पायथन टास्क कतार। बुनियादी सेटअप, कार्य परिभाषा और कार्यकर्ता प्रबंधन को कवर करता है।

2. FastAPI बैकग्राउंड टास्क दस्तावेज़ (आधिकारिक, मुफ्त)

लिंक: https://fastapi.tiangolo.com/tutorial/background-tasks/

सरल उपयोग के मामलों के लिए अंतर्निहित हल्के बैकग्राउंड टास्क। त्वरित फायर-एंड-फ़ॉरगेट कार्यों के लिए इसका उपयोग करें, किसी भी भारी चीज़ के लिए Celery का उपयोग करें।

किस पर ध्यान दें: यह समझना कि FastAPI के अंतर्निहित BackgroundTasks का उपयोग कब करना है बनाम एक उचित कार्य कतार जैसे Celery, संदेश ब्रोकर के रूप में Redis सेट करना, कार्य विफलताओं और पुनर्प्रयासों को संभालना, और उपयोगकर्ता को कार्य स्थिति वापस करना।

4. प्रमाणीकरण और API कुंजी सुरक्षा

यदि आपके AI ऐप में API है, तो उसे प्रमाणीकरण की आवश्यकता है। इसके बिना, कोई भी आपके एंडपॉइंट का उपयोग कर सकता है, आपके LLM क्रेडिट के माध्यम से जल सकता है, और आप $5,000 के बिल के साथ जागेंगे।

संसाधन:

1. FastAPI सुरक्षा दस्तावेज़ (आधिकारिक, मुफ्त)

लिंक: https://fastapi.tiangolo.com/tutorial/security/

OAuth2, JWT टोकन, API कुंजियाँ और निर्भरता-आधारित प्रमाणीकरण पैटर्न को कवर करता है। आधिकारिक संदर्भ, पूर्ण ट्यूटोरियल के माध्यम से काम करें।

2. OWASP API सुरक्षा शीर्ष 10 (मुफ्त)

लिंक: https://owasp.org/API-Security/

API सुरक्षा जोखिमों की आधिकारिक सूची। कुछ भी शिप करने से पहले टूटे हुए प्रमाणीकरण, इंजेक्शन और मास असाइनमेंट को समझें।

3. Auth0: API प्रमाणीकरण सर्वोत्तम अभ्यास (मुफ्त)

लिंक: https://auth0.com/docs/get-started/authentication-and-authorization

API में प्रमाणीकरण और प्राधिकरण लागू करने के लिए व्यावहारिक मार्गदर्शिका।

किस पर ध्यान दें: उपयोगकर्ता प्रमाणीकरण के लिए JWT टोकन, सेवा-से-सेवा संचार के लिए API कुंजी प्रबंधन, प्रति उपयोगकर्ता/कुंजी दर सीमित करना, कोड में कभी भी रहस्यों को संग्रहीत न करना (पर्यावरण चर का उपयोग करें), और प्रमाणीकरण (आप कौन हैं) और प्राधिकरण (आप क्या कर सकते हैं) के बीच अंतर को समझना।

5. लॉगिंग और ऑब्ज़र्वेबिलिटी

प्रोडक्शन में, यदि आप नहीं देख सकते कि क्या हो रहा है, तो आप जो टूटा है उसे ठीक नहीं कर सकते।

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

संसाधन:

1. Langfuse (ओपन सोर्स, मुफ्त स्तर)

लिंक: https://langfuse.com/docs/observability/overview

ओपन-सोर्स LLM ऑब्ज़र्वेबिलिटी प्लेटफ़ॉर्म। हर अनुरोध को ट्रेस करता है: भेजा गया प्रॉम्प्ट, प्राप्त प्रतिक्रिया, टोकन उपयोग, विलंबता, टूल कॉल। प्रॉम्प्ट वर्ज़निंग, मूल्यांकन और LLM-एज़-जज स्कोरिंग का समर्थन करता है। OpenAI, Anthropic, LangChain, LlamaIndex के साथ एकीकृत होता है।

2. LangSmith (मुफ्त स्तर)

लिंक: https://smith.langchain.com/

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

3. पायथन स्ट्रक्टलॉग (मुफ्त)

लिंक: https://www.structlog.org/

पायथन के लिए संरचित लॉगिंग। JSON लॉग तैयार करता है जो वास्तव में खोजने और पार्स करने योग्य हैं। प्रोडक्शन ऐप्स के लिए प्रिंट() या बुनियादी लॉगिंग से कहीं बेहतर।

किस पर ध्यान दें: प्रत्येक LLM कॉल को ट्रेस करना (इनपुट प्रॉम्प्ट, आउटपुट, टोकन, विलंबता, लागत), JSON आउटपुट के साथ संरचित लॉगिंग, डैशबोर्ड सेट करना जो अनुरोध की मात्रा, त्रुटि दर और प्रति दिन लागत दिखाते हैं, और जब कुछ टूटता है या लागत बढ़ती है तो अलर्ट करना।

6. प्रॉम्प्ट और वर्ज़न प्रबंधन

प्रोडक्शन में, आपके प्रॉम्प्ट कोड हैं। उन्हें संस्करण नियंत्रण, परीक्षण और वापस रोल करने की क्षमता की आवश्यकता होती है।

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

संसाधन:

1. Langfuse प्रॉम्प्ट प्रबंधन (मुफ्त)

लिंक: https://langfuse.com/docs/prompts

परीक्षण के लिए अंतर्निहित प्लेग्राउंड के साथ केंद्रीकृत प्रॉम्प्ट वर्ज़निंग। अपने एप्लिकेशन कोड से अलग अपने प्रॉम्प्ट को संस्करण नियंत्रित करें। अपने ऐप को फिर से तैनात किए बिना प्रॉम्प्ट परिवर्तन तैनात करें।

2. Anthropic प्रॉम्प्ट प्रबंधन सर्वोत्तम अभ्यास (मुफ्त)

लिंक: https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview

पैमाने पर प्रॉम्प्ट को व्यवस्थित करने, पुनरावृत्त करने और प्रबंधित करने के लिए सर्वोत्तम अभ्यास।

किस पर ध्यान दें: अपने एप्लिकेशन कोड के बाहर प्रॉम्प्ट संग्रहीत करना, प्रत्येक प्रॉम्प्ट परिवर्तन का संस्करण बनाना, प्रोडक्शन में प्रॉम्प्ट वेरिएंट का A/B परीक्षण करना, और जब कोई नया प्रॉम्प्ट खराब प्रदर्शन करता है तो वापस रोल रणनीति रखना।

7. लागत निगरानी और दर सीमाएँ

LLM API प्रति टोकन शुल्क लेते हैं। लागत नियंत्रण के बिना, एक ट्रैफ़िक स्पाइक या आपके प्रॉम्प्ट में एक बग मिनटों में सैकड़ों डॉलर जला सकता है।

संसाधन:

1. OpenAI उपयोग डैशबोर्ड (आधिकारिक)

लिंक: https://platform.openai.com/usage

मॉडल, दिन के अनुसार खर्च को ट्रैक करें और उपयोग सीमाएँ निर्धारित करें।

2. Anthropic उपयोग डैशबोर्ड (आधिकारिक)

लिंक: https://console.anthropic.com/ Claude API उपयोग के लिए भी यही।

3. Helicone (मुफ्त स्तर)

लिंक: https://www.helicone.ai/

प्रॉक्सी-आधारित ऑब्ज़र्वेबिलिटी जो स्वचालित लागत ट्रैकिंग के साथ प्रत्येक LLM कॉल को कैप्चर करती है। सेट अप करने के लिए कोड की एक पंक्ति: बस अपना बेस URL बदलें।

4. LiteLLM (ओपन सोर्स, मुफ्त)

लिंक: https://github.com/BerriAI/litellm

100+ LLM प्रदाताओं के लिए एकीकृत इंटरफ़ेस। प्रदाताओं में बजट प्रबंधन, दर सीमित करना और खर्च ट्रैकिंग शामिल है।

किस पर ध्यान दें: प्रति दिन/माह सख्त खर्च सीमाएँ निर्धारित करना, अपने API में प्रति-उपयोगकर्ता दर सीमाएँ लागू करना, सरल कार्यों के लिए सस्ते मॉडल का उपयोग करना (हर चीज़ के लिए GPT-4/Opus का उपयोग न करें), Redis के साथ दोहराए गए समान अनुरोधों को कैश करना, और महंगे प्रॉम्प्ट को जल्दी पकड़ने के लिए प्रति अनुरोध लागत की निगरानी करना।

8. कैशिंग

यदि आपके 20% उपयोगकर्ता समान प्रश्न पूछते हैं, तो आप एक ही LLM कॉल के लिए 20 बार भुगतान कर रहे हैं।

कैशिंग एक साथ लागत और विलंबता को कम करने का सबसे सरल तरीका है।

संसाधन:

1. Redis आधिकारिक दस्तावेज़ (मुफ्त)

लिंक: https://redis.io/docs/

मानक इन-मेमोरी डेटा स्टोर। तेज़, सरल, और LLM प्रतिक्रिया कैशिंग के लिए पूरी तरह से काम करता है।

2. GPTCache (ओपन सोर्स, मुफ्त)

लिंक: https://github.com/zilliztech/GPTCache

विशेष रूप से LLM अनुप्रयोगों के लिए डिज़ाइन किया गया सिमेंटिक कैशिंग। अर्थगत रूप से समान (केवल समान नहीं) प्रश्नों के लिए कैश की गई प्रतिक्रियाओं को खोजने के लिए एम्बेडिंग समानता का उपयोग करता है।

किस पर ध्यान दें: समान प्रॉम्प्ट के लिए सटीक-मिलान कैशिंग, समान प्रश्नों के लिए सिमेंटिक कैशिंग, कैश अमान्यकरण रणनीतियाँ (TTL-आधारित सबसे सरल है), और वास्तविक लागत बचत को समझने के लिए कैश हिट दर को मापना।

महीने 5 का माइलस्टोन

इस महीने के अंत तक आपको इसमें सक्षम होना चाहिए:

• उचित प्रोडक्शन कॉन्फ़िगरेशन के साथ Docker में एक FastAPI + LLM ऐप तैनात कर सकें
• बैकग्राउंड जॉब्स और कतारों के साथ लंबे समय तक चलने वाले कार्यों को संभाल सकें
• प्रमाणीकरण, दर सीमाओं और API कुंजी प्रबंधन के साथ अपने API को सुरक्षित कर सकें
• Langfuse या LangSmith का उपयोग करके LLM कॉल को ट्रेस और डीबग कर सकें
• संस्करण नियंत्रण और वापस रोल करने की क्षमता के साथ प्रॉम्प्ट प्रबंधित कर सकें
• वास्तविक समय में लागत की निगरानी कर सकें और खर्च सीमाएँ निर्धारित कर सकें
• विलंबता और लागत को कम करने के लिए LLM प्रतिक्रियाओं को कैश कर सकें

⏩------------------------------------------------------------------------⏪

महीना 6: विशेषज्ञ बनें और नौकरी के योग्य बनें

आपके द्वारा प्राप्त ये ज्ञान और कौशल तीन दिशाओं में लागू किए जा सकते हैं (निश्चित रूप से केवल वही हैं जो मैं देखता हूँ)

आपको उनमें से एक को चुनना होगा और अभ्यास पर ध्यान केंद्रित करना होगा

हालाँकि ऊपर बताई गई हर चीज़ भी विशुद्ध रूप से अभ्यास के माध्यम से सबसे अच्छी तरह सीखी जाती है।

दिशा 1: AI उत्पाद इंजीनियर

सबसे अच्छा यदि आप तेजी से स्टार्टअप नौकरियां चाहते हैं।

यह सबसे आम रास्ता है। आप AI-संचालित उत्पाद बनाते हैं जिनके साथ वास्तविक उपयोगकर्ता बातचीत करते हैं।

आपके पास पहले से ही महीने 1-5 के अधिकांश कौशल हैं। अब उत्पाद पक्ष पर गहराई से जाएं।

ध्यान केंद्रित करें:

• LLM ऐप्स
• RAG
• एजेंट्स
• तैनाती
• उत्पाद UX

इस महीने क्या सीखें:

1. अंत-से-अंत उत्पाद निर्माण

ट्यूटोरियल बनाना बंद करें। ऐसे उत्पाद बनाएं जिनका उपयोग लोग कर सकें।

संसाधन:

1. Vercel AI SDK (मुफ्त)

लिंक: https://sdk.vercel.ai/docs

स्ट्रीमिंग समर्थन के साथ AI-संचालित UI बनाने का सबसे तेज़ तरीका। React, Next.js और Vue एकीकरण अंतर्निहित स्ट्रीमिंग UI घटकों के साथ।

2. Streamlit (मुफ्त)

लिंक: https://docs.streamlit.io/

शुद्ध पायथन में डेटा ऐप्स और AI डेमो बनाएं। आंतरिक टूल और MVP के लिए आदर्श, प्रोडक्शन-स्केल UI के लिए नहीं।

3. Gradio (मुफ्त)

लिंक: https://www.gradio.app/docsQuick न्यूनतम कोड के साथ ML/AI इंटरफ़ेस। मॉडल को डेमो करने और प्रोटोटाइप बनाने के लिए विशेष रूप से अच्छा।

ध्यान केंद्रित करें: इस महीने 2-3 पूरे प्रोजेक्ट बनाएं जिन्हें आप डेमो कर सकें। एक "अपने डॉक्स से चैट करें" ऐप, एक AI-संचालित आंतरिक टूल, या एक एजेंट जो वास्तविक वर्कफ़्लो को ऑटोमेट करता हो। उन्हें शिप करें। GitHub पर डालें। उन्हें कहीं ऐसी जगह डिप्लॉय करें जहाँ लोग उन्हें आज़मा सकें।

2. AI के लिए प्रोडक्ट UX

AI प्रोडक्ट तब विफल होते हैं जब UX मॉडल की सीमाओं का ध्यान नहीं रखता

संसाधन:

1. Google: People + AI Guidebook (मुफ्त)

लिंक: https://pair.withgoogle.com/guidebook/

मानव-AI इंटरैक्शन को डिज़ाइन करने का सबसे अच्छा संसाधन। उम्मीदें सेट करना, त्रुटियों को संभालना और विश्वास बनाना शामिल है।

2. Nielsen Norman Group: AI UX Guidelines (मुफ्त)

लिंक: https://www.nngroup.com/topic/artificial-intelligence/

AI इंटरफ़ेस के लिए शोध-समर्थित दिशानिर्देश।

ध्यान केंद्रित करें: स्ट्रीमिंग के साथ लोडिंग स्टेट को कैसे संभालें, मॉडल के गलत होने पर क्या दिखाएँ, उपयोगकर्ताओं को फीडबैक कैसे दें, और इस तथ्य के लिए डिज़ाइन करें कि AI आउटपुट प्रायिक है – यह कभी-कभी गलत होगा।

दिशा 2: एप्लाइड ML / LLM इंजीनियर

यदि आप गहरी तकनीकी भूमिकाएँ चाहते हैं तो सबसे अच्छा।

यह दिशा उन इंजीनियरों के लिए है जो API कॉल से आगे जाना चाहते हैं और समझना चाहते हैं कि हुड के नीचे क्या हो रहा है।

ध्यान केंद्रित करें:

• फ़ाइन-ट्यूनिंग
• फ़ाइन-ट्यून कब करें बनाम प्रॉम्प्ट कब करें
• मूल्यांकन
• इन्फ़रेंस ऑप्टिमाइज़ेशन
• ओपन-सोर्स मॉडल
• ट्रेनिंग पाइपलाइन

इस महीने क्या सीखें:

1. फ़ाइन-ट्यून कब करें बनाम प्रॉम्प्ट इंजीनियर कब करें

एप्लाइड ML में सबसे महत्वपूर्ण निर्णय: क्या आपको मॉडल बदलने की ज़रूरत है, या सिर्फ़ उससे बात करने का तरीका?

संसाधन:

1. Google ML Crash Course: Fine-tuning, Distillation, and Prompt Engineering (मुफ्त)

लिंक: https://developers.google.com/machine-learning/crash-course/llm/tuning

तीनों दृष्टिकोणों और प्रत्येक का उपयोग कब करना है, इसकी सबसे स्पष्ट व्याख्या।

2. Codecademy: Prompt Engineering vs Fine-Tuning (मुफ्त)

लिंक: https://www.codecademy.com/article/prompt-engineering-vs-fine-tuning

प्रत्येक दृष्टिकोण के लिए स्पष्ट उपयोग के मामलों के साथ व्यावहारिक निर्णय फ्रेमवर्क।

3. IBM: RAG vs Fine-Tuning vs Prompt Engineering (मुफ्त)

लिंक: https://www.ibm.com/think/topics/rag-vs-fine-tuning-vs-prompt-engineering

दृष्टिकोणों को संयोजित करने के समय सहित संपूर्ण निर्णय स्थान को कवर करता है।

याद रखने योग्य निर्णय फ्रेमवर्क: प्रॉम्प्ट इंजीनियरिंग से शुरू करें (सबसे सस्ता, सबसे तेज़) यदि मॉडल को विशिष्ट डेटा तक पहुँच की आवश्यकता हो तो RAG जोड़ें फ़ाइन-ट्यून केवल तभी करें जब प्रॉम्प्टिंग + RAG आवश्यक गुणवत्ता, स्थिरता या विलंबता प्राप्त नहीं कर सकते।

2. व्यवहार में फ़ाइन-ट्यूनिंग

जब आपको फ़ाइन-ट्यून करने की आवश्यकता हो, तो यहाँ बताया गया है कैसे:

संसाधन:

1. OpenAI Fine-tuning Guide (आधिकारिक, मुफ्त)

लिंक: https://platform.openai.com/docs/guides/fine-tuning

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

2. HuggingFace Transformers Fine-tuning Tutorial (मुफ्त)

लिंक: https://huggingface.co/docs/transformers/training

ओपन-सोर्स मॉडल के साथ काम करने के लिए मानक लाइब्रेरी। प्रशिक्षण, मूल्यांकन और मॉडल सेविंग को कवर करता है।

3. Unsloth (ओपन सोर्स, मुफ्त)

लिंक: https://github.com/unslothai/unsloth

80% कम मेमोरी के साथ 2x तेज़ फ़ाइन-ट्यूनिंग। LoRA और QLoRA को आउट ऑफ़ द बॉक्स सपोर्ट करता है। कंज़्यूमर हार्डवेयर पर ओपन-सोर्स मॉडल को फ़ाइन-ट्यून करने का सबसे तेज़ तरीका।

4. LLaMA-Factory (ओपन सोर्स, मुफ्त)

लिंक: https://github.com/hiyouga/LLaMA-Factory

100+ LLMs को फ़ाइन-ट्यून करने के लिए यूनिफ़ाइड फ्रेमवर्क। नो-कोड फ़ाइन-ट्यूनिंग के लिए एक वेब UI शामिल है। LoRA, QLoRA, फुल फ़ाइन-ट्यूनिंग, RLHF और DPO को सपोर्ट करता है।

ध्यान केंद्रित करें: ट्रेनिंग डेटासेट तैयार करना (JSONL फ़ॉर्मेट), LoRA और QLoRA (पैरामीटर-एफिशिएंट फ़ाइन-ट्यूनिंग) को समझना, OpenAI पर या HuggingFace के साथ फ़ाइन-ट्यूनिंग जॉब चलाना, फ़ाइन-ट्यून किए गए मॉडल का बेस मॉडल के विरुद्ध मूल्यांकन करना, और यह जानना कि फ़ाइन-ट्यूनिंग कब लागत के लायक नहीं है।

3. ओपन-सोर्स मॉडल

सब कुछ OpenAI या Anthropic के माध्यम से जाने की ज़रूरत नहीं है। ओपन-सोर्स मॉडल आपको पूर्ण नियंत्रण, कोई API लागत नहीं और स्थानीय रूप से चलाने की क्षमता देते हैं।

संसाधन:

1. Ollama (मुफ्त)

लिंक: https://ollama.ai/

एक कमांड से ओपन-सोर्स LLMs को स्थानीय रूप से चलाएँ। Llama, Mistral, Gemma और दर्जनों अन्य को सपोर्ट करता है। ओपन-सोर्स मॉडल के साथ प्रयोग करने का सबसे तेज़ तरीका।

2. HuggingFace Model Hub (मुफ्त)

लिंक: https://huggingface.co/models

ओपन-सोर्स मॉडल का सबसे बड़ा भंडार। किसी भी कार्य के लिए मॉडल ब्राउज़ करें, डाउनलोड करें और डिप्लॉय करें।

3. vLLM (ओपन सोर्स, मुफ्त)

लिंक: https://github.com/vllm-project/vllm

हाई-थ्रूपुट LLM इन्फ़रेंस इंजन। सरल HuggingFace सर्विंग की तुलना में 2-4x तेज़। ओपन-सोर्स मॉडल की प्रोडक्शन सर्विंग के लिए मानक।

ध्यान केंद्रित करें: परीक्षण के लिए Ollama के साथ स्थानीय रूप से मॉडल चलाना, क्वांटाइज़ेशन (GGUF, GPTQ, AWQ) और डिप्लॉयमेंट के लिए इसके महत्व को समझना, अपने उपयोग के मामले के लिए API मॉडल के विरुद्ध ओपन-सोर्स मॉडल को बेंचमार्क करना, और vLLM के साथ प्रोडक्शन में मॉडल सर्व करना।

4. इन्फ़रेंस ऑप्टिमाइज़ेशन

प्रोडक्शन में मॉडल को तेज़ और सस्ता चलाना।

संसाधन:

1. HuggingFace: Optimizing LLM Inference (मुफ्त)

लिंक: https://huggingface.co/docs/transformers/llm_optims

KV-कैश ऑप्टिमाइज़ेशन, क्वांटाइज़ेशन और बैचिंग रणनीतियों को कवर करता है।

2. NVIDIA TensorRT-LLM (मुफ्त)

लिंक: https://github.com/NVIDIA/TensorRT-LLM

NVIDIA GPUs पर अधिकतम इन्फ़रेंस प्रदर्शन। बड़े पैमाने पर अधिकांश प्रोडक्शन LLM सर्विंग द्वारा उपयोग किया जाता है।

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

दिशा 3: AI ऑटोमेशन इंजीनियर

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

यह दिशा AI के साथ वास्तविक व्यावसायिक वर्कफ़्लो को ऑटोमेट करने के बारे में है। प्रोडक्ट बनाने से कम, परिचालन संबंधी समस्याओं को हल करने के बारे में अधिक।

ध्यान केंद्रित करें:

• वर्कफ़्लो ऑर्केस्ट्रेशन
• व्यावसायिक प्रक्रिया ऑटोमेशन
• मल्टी-टूल सिस्टम
• CRM, डॉक्स, ईमेल, सपोर्ट, ऑप्स उपयोग के मामले

इस महीने क्या सीखें:

1. वर्कफ़्लो ऑर्केस्ट्रेशन

वास्तविक व्यावसायिक ऑटोमेशन लगभग कभी भी एक LLM कॉल नहीं है। यह कई सिस्टमों में क्रियाओं की श्रृंखलाएँ हैं।

संसाधन:

1. n8n (ओपन सोर्स, सेल्फ-होस्ट करने के लिए मुफ्त)

लिंक: https://docs.n8n.io/

AI नोड्स के साथ विज़ुअल वर्कफ़्लो ऑटोमेशन। LLMs को 400+ इंटीग्रेशन (Slack, Gmail, Notion, CRMs, आदि) से कनेक्ट करें। AI ऑटोमेशन के लिए सबसे अच्छा नो-कोड/लो-कोड विकल्प।

2. LangGraph: Multi-Agent Workflows (मुफ्त)

लिंक: https://langchain-ai.github.io/langgraph/concepts/multi_agent/

जटिल मल्टी-एजेंट सिस्टम के लिए कोड-फ़र्स्ट ऑर्केस्ट्रेशन। जब n8n पर्याप्त न हो और आपको पूर्ण प्रोग्रामेटिक नियंत्रण की आवश्यकता हो।

3. Temporal (ओपन सोर्स, मुफ्त)

लिंक: https://docs.temporal.io/

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

ध्यान केंद्रित करें: वर्कफ़्लो डिज़ाइन करना जो विफलताओं को शान से संभालें, AI को वास्तविक व्यावसायिक टूल (ईमेल, CRM, डेटाबेस, स्प्रेडशीट) से जोड़ना, ह्यूमन-इन-द-लूप अनुमोदन चरण बनाना, और ऑडिट ट्रेल के लिए प्रत्येक स्वचालित क्रिया को लॉग करना।

2. व्यावसायिक प्रक्रिया ऑटोमेशन

AI ऑटोमेशन में पैसा विशिष्ट, महँगी व्यावसायिक समस्याओं को हल करने में है।

संसाधन:

1. Zapier AI Actions (मुफ्त टियर)

लिंक: https://zapier.com/ai

बिना कोड के AI को 6,000+ ऐप्स से कनेक्ट करें। कस्टम समाधान बनाने से पहले ऑटोमेशन को प्रोटोटाइप करने के लिए अच्छा है।

2. Make (Integromat) (मुफ्त टियर)

लिंक: https://www.make.com/

उन्नत तर्क और AI इंटीग्रेशन के साथ विज़ुअल ऑटोमेशन प्लेटफ़ॉर्म। जटिल वर्कफ़्लो के लिए Zapier से अधिक शक्तिशाली।

ध्यान केंद्रित करें: उच्चतम-आरओआई ऑटोमेशन लक्ष्यों की पहचान करना (आमतौर पर ऐसे कार्य जो दोहराए जाने वाले, समय लेने वाले और नियम-आधारित हों), ऐसे ऑटोमेशन बनाना जो मनुष्यों को बदलने के बजाय उन्हें बढ़ाएँ, और बचाए गए वास्तविक समय और धन को मापना।

3. CRM, डॉक्स, ईमेल, सपोर्ट ऑटोमेशन

सबसे सामान्य और सबसे मूल्यवान AI ऑटोमेशन उपयोग के मामले।

संसाधन:

1. OpenAI Cookbook: AI-Powered Email Processing (मुफ्त)

लिंक: https://github.com/openai/openai-cookbook

AI के साथ ईमेल को वर्गीकृत करने, रूट करने और उत्तर देने के पैटर्न।

2. LangChain: Document Processing Pipelines (मुफ्त)

लिंक: https://python.langchain.com/docs/how_to/#document-loaders

80+ स्रोतों से दस्तावेज़ों को इन्जेस्ट और प्रोसेस करना।

ध्यान केंद्रित करें: एक AI-संचालित ईमेल क्लासिफ़ायर और ऑटो-रिस्पॉन्डर बनाना, एक दस्तावेज़ प्रोसेसिंग पाइपलाइन बनाना जो संरचित डेटा निकालती है, एक सपोर्ट चैटबॉट बनाना जो आपके नॉलेज बेस पर RAG का उपयोग करता है, और AI को मौजूदा CRM वर्कफ़्लो (HubSpot, Salesforce, आदि) में एकीकृत करना।

दिशा 3 के लिए अभ्यास प्रोजेक्ट: एक एंड-टू-एंड लीड क्वालिफिकेशन सिस्टम बनाएँ। इसे चाहिए:

किसी स्रोत (CSV, API या फ़ॉर्म) से लीड स्क्रेप या इम्पोर्ट करें

प्रत्येक लीड पर शोध करने के लिए LLM का उपयोग करें (कंपनी की जानकारी, फ़िट आकलन)

अपने ICP के आधार पर लीड को स्कोर और रैंक करें

वैयक्तिकृत आउटरीच संदेशों का ड्राफ़्ट तैयार करें

सब कुछ एक स्प्रेडशीट या CRM में लॉग करें

यह एक वास्तविक, बिक्री योग्य ऑटोमेशन है जिसके लिए व्यवसाय वास्तव में भुगतान करते हैं।

⏩------------------------------------------------------------------------⏪

निष्कर्ष

इन 6 महीनों के बाद आप क्या उम्मीद कर सकते हैं???

मैं आपसे ईमानदार रहूँगा, बिना किसी पैसों के पहाड़ों के

यह रोडमैप आपको 6 महीनों में सीनियर AI इंजीनियर नहीं बनाएगा

लेकिन यह आपको ऐसा व्यक्ति बनाएगा जो वास्तविक AI सिस्टम बना सकता है, शिप कर सकता है और डिप्लॉय कर सकता है जो वास्तविक समस्याओं को हल करते हैं

और अभी, बाजार ठीक इसी के लिए भुगतान कर रहा है

AI इंजीनियरों की माँग धीमी नहीं हो रही है। नौकरी के पोस्टिंग में साल-दर-साल 25% की वृद्धि हुई है

PwC ने AI कौशल की आवश्यकता वाली भूमिकाओं के लिए उसी भूमिका के बिना 56% वेतन प्रीमियम पाया

केवल 1% कंपनियों को "AI परिपक्व" माना जाता है, जिसका अर्थ है कि 99% को अभी भी मदद की आवश्यकता है। US Bureau of Labor Statistics 2034 तक 26% नौकरी वृद्धि का अनुमान लगाता है

ये हाइप नंबर नहीं हैं। ये एनालिटिक्स पर आधारित वास्तविक संख्याएँ हैं (क्लॉड केक से ली गईं)

यदि आप US में फुल-टाइम जाते हैं:

जूनियर AI इंजीनियर $90,000-$130,000 से शुरू होते हैं

मिड-लेवल (3-5 वर्ष) $155,000-$200,000 पर है

सीनियर भूमिकाएँ $195,000-$350,000+ तक जाती हैं

Glassdoor (मार्च 2026) के अनुसार, औसत $184,757 है

मिड-लेवल बैंड साल-दर-साल 9.2% की दर से सबसे तेज़ी से बढ़ रहा है क्योंकि कंपनियों को सख्त ज़रूरत है उन लोगों की जो बिना लगातार निगरानी के प्रोडक्शन AI शिप कर सकें

यदि फ्रीलांसिंग आपकी चीज़ अधिक है:

AI एजेंट डेवलपमेंट $175-$300/घंटा में जाता है

RAG इम्प्लीमेंटेशन $150-$250/घंटा

LLM इंटीग्रेशन $125-$200/घंटा

Reddit पर एक डेवलपर ने एक लीगल फर्म के लिए दो सप्ताह में एक दस्तावेज़ सारांश टूल बनाया और $8,000 कमाए। एक फ्रीलांसर जो $150/घंटा पर 25 घंटे/सप्ताह बिल करता है, वह $195,000/वर्ष कमाता है

और यदि आप कंसल्टिंग रूट पर जाते हैं, जिसके बारे में मैंने अपनी पिछली पोस्ट में बात की थी, तो आप चार्ज कर सकते हैं:

एक व्यवसाय के लिए AI एजेंट सेट करने के लिए $300-$5,000

AI सामग्री प्रबंधन के लिए $500-$2,000/माह

ग्राहक सहायता को ऑटोमेट करने के लिए $1,000-$4,000

कोल्ड आउटरीच सेटअप के लिए $500-$2,000

सेवा स्पेक्ट्रम और भी व्यापक है, लेकिन एक बार जब आप इस रोडमैप के कौशल में महारत हासिल कर लेते हैं, तो आप 2026 में पहले से ही एक माँग वाले विशेषज्ञ हैं

ये वास्तविक लोगों के वास्तविक नंबर हैं जो वास्तविक कार्य कर रहे हैं

अब यहाँ है जो मैं वास्तव में चाहता हूँ कि आप इन सब से दूर ले जाएँ:

प्रत्येक महीने से एक प्रोजेक्ट चुनें और उसे बनाएँ। इसके बारे में न पढ़ें। कोई ट्यूटोरियल न देखें। इसे बनाएँ, तोड़ें, ठीक करें, डिप्लॉय करें, GitHub पर डालें। जो इंजीनियर काम पर रखे जाते हैं, वे वे हैं जो दिखाते हैं कि उन्होंने क्या बनाया है, न कि उन्होंने क्या पढ़ा है।

आप जो सीखते हैं उसे साझा करना शुरू करें। इसके बारे में X, LinkedIn, कहीं भी लिखें। पढ़ाना सीखने का सबसे तेज़ तरीका है और यह उसी समय आपकी प्रतिष्ठा भी बनाता है। मैंने जो सबसे अच्छे अवसर देखे हैं, वे उन लोगों से आए हैं जो दिखाई दे रहे थे, न कि उन लोगों से जिन्होंने 500 नौकरी सूचियों में आवेदन किया था।

और कृपया तब तक प्रतीक्षा न करें जब तक आप तैयार महसूस न करें। आप कभी तैयार महसूस नहीं करेंगे। "मैं सीख रहा हूँ" और "मैं बना रहा हूँ" के बीच का अंतर वह जगह है जहाँ अधिकांश लोग हमेशा के लिए फँस जाते हैं।

जैसे ही आपके पास काम करने वाले प्रोजेक्ट हों, आवेदन करना शुरू करें, फ्रीलांसिंग शुरू करें, सेवाएँ देना शुरू करें। भले ही वे परफेक्ट न हों। बाजार पूर्णता को पुरस्कृत नहीं करता है। यह उन लोगों को पुरस्कृत करता है जो शिप कर सकते हैं।

6 महीने सब कुछ बदलने के लिए पर्याप्त हैं यदि आप वास्तव में काम में लग जाएँ।

और मैं वास्तव में विश्वास करता हूँ कि आप में से प्रत्येक जो इसे पढ़ रहा है, वह यह कर सकता है।

बस कभी भी बनाना बंद न करें और कभी भी सीखना बंद न करें।

आशा है कि यह आपके लिए उपयोगी रहा होगा मेरे प्यारे दोस्तों ❤️