RAG और इसका LangChain, Bun, Ollama और Qdrant के साथ व्यावहारिक कार्यान्वयन

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

नोट: इस लेख में उल्लिखित उदाहरण परियोजना का पूरा स्रोत कोड GitHub पर उपलब्ध है।

लेख की रूपरेखा

1. RAG क्या है और इसका उपयोग क्यों करें?

   • संचालन सिद्धांत
   • शास्त्रीय दृष्टिकोणों पर लाभ
   • ठोस उपयोग के मामले

2. RAG प्रणाली की वास्तुकला

   • आवश्यक घटक
   • डेटा प्रवाह
   • प्रौद्योगिकी विकल्प

3. TypeScript के साथ व्यावहारिक कार्यान्वयन

   • Bun के साथ प्रोजेक्ट सेटअप
   • LangChain एकीकरण
   • Ollama और Qdrant कॉन्फ़िगरेशन

4. कोड विश्लेषण और सर्वोत्तम अभ्यास

   • दस्तावेज़ अनुक्रमण
   • सिमेंटिक खोज
   • प्रतिक्रिया पीढ़ी

5. तकनीकी स्टैक के लाभ

   • Node.js बनाम Bun प्रदर्शन
   • LangChain सरलता
   • Ollama लचीलापन
   • Qdrant स्केलेबिलिटी

6. आगे बढ़ते हुए

   • उन्नत अनुकूलन
   • मूल्यांकन और मेट्रिक्स
   • तकनीकी विकल्प

RAG क्या है और इसका उपयोग क्यों करें?

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

1. उपयोगकर्ता क्वेरी – उपयोगकर्ता एक प्रश्न पूछता है या प्राकृतिक भाषा में एक क्वेरी प्रदान करता है (उदाहरण के लिए, "इस परियोजना में क्लास X का उपयोग किस लिए किया जाता है?")।
2. प्रासंगिक दस्तावेजों की खोज – सिस्टम इस प्रश्न को एक वेक्टर प्रतिनिधित्व (एम्बेडिंग) में बदलता है और फिर क्वेरी के समानार्थक रूप से सबसे समान दस्तावेजों या अंशों को पुनः प्राप्त करने के लिए एक वेक्टर डेटाबेस से क्वेरी करता है। यह प्रासंगिक संदर्भ की पहचान करता है (उदाहरण के लिए, प्रलेखन, कोड, या प्रश्न के अनुरूप एक लेख से एक अंश)।
3. संदर्भ + प्रश्न संयोजन – प्राप्त दस्तावेज़ या अंश तब भाषा मॉडल को संदर्भ के रूप में प्रदान किए जाते हैं। व्यवहार में, उन्हें LLM के प्रॉम्प्ट में डाला जाता है, आमतौर पर एक सिस्टम संदेश के माध्यम से या पाए गए दस्तावेजों के पाठ के साथ उपयोगकर्ता के प्रश्न को उपसर्ग करके।
4. प्रतिक्रिया पीढ़ी – भाषा मॉडल (LLM) तब प्रश्न और प्रदान किए गए संदर्भ दोनों के आधार पर एक प्रतिक्रिया उत्पन्न करता है। प्रतिक्रिया में दस्तावेजों से जानकारी होनी चाहिए, जो LLM की क्षमताओं के कारण सुसंगत रूप से तैयार की गई हो।

यह प्रक्रिया मॉडल को पीढ़ी के समय विशिष्ट बाहरी ज्ञान पर भरोसा करने की अनुमति देती है, बिना इसे स्थायी रूप से याद किए। इसकी तुलना एक ऐसे इंसान से की जा सकती है, जो किसी प्रश्न का सामना करने पर, उत्तर देने से पहले पुस्तकों या संदर्भ दस्तावेजों से परामर्श करेगा: LLM बोलने से पहले "अपनी लाइब्रेरी खोजता है"।

RAG के लिए ठोस उपयोग के मामले

RAG दृष्टिकोण विशेष रूप से तब उपयोगी होता है जब एक संवादी सहायक को एक विकसित या विशाल ज्ञान आधार को संभालने की आवश्यकता होती है। यहाँ ठोस उपयोग के मामलों के कुछ उदाहरण दिए गए हैं जहाँ RAG शास्त्रीय तरीकों की तुलना में उत्कृष्ट है:

वृत्तचित्र चैटबॉट: एक कंपनी के तकनीकी प्रलेखन द्वारा संचालित एक सहायक, जो डेवलपर्स या ग्राहकों के सवालों का जवाब सीधे मैनुअल, आंतरिक ज्ञान आधारों, या यहां तक कि स्रोत कोड से प्राप्त करके दे सकता है। उदाहरण के लिए, मॉडल को API विनिर्देशों या ओपन-सोर्स प्रोजेक्ट कोड से जोड़ा जा सकता है ताकि यह समझाया जा सके कि कोई फ़ंक्शन कैसे काम करता है या किसी निश्चित डिज़ाइन का कारण क्या है।

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

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

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

RAG प्रणाली की वास्तुकला

आवश्यक घटक

एक पूर्ण RAG प्रणाली में आमतौर पर निम्नलिखित घटक शामिल होते हैं:

1. अनुक्रमण और भंडारण

   • दस्तावेज़ प्रोसेसर (निष्कर्षण, सफाई, चंकिंग)
   • एम्बेडिंग जनरेटर (वैक्टर में परिवर्तन)
   • वेक्टर डेटाबेस (भंडारण और खोज)

2. क्वेरी पाइपलाइन

   • क्वेरी प्रीप्रोसेसर
   • सिमेंटिक खोज इंजन
   • प्रॉम्प्ट जनरेटर

3. पीढ़ी और पोस्ट-प्रोसेसिंग

   • LLM इंटरफ़ेस
   • प्रतिक्रिया मूल्यांकनकर्ता
   • आउटपुट स्वरूपक

डेटा प्रवाह

typescript
1// RAG सिस्टम में डेटा प्रवाह का सरलीकृत उदाहरण
2async function processQuery(query: string): Promise<string> {
3  // 1. क्वेरी को एम्बेडिंग में बदलें
4  const queryEmbedding = await embedder.embedQuery(query);
5  
6  // 2. प्रासंगिक दस्तावेजों की खोज करें
7  const relevantDocs = await vectorStore.similaritySearch(queryEmbedding);
8  
9  // 3. संदर्भ के साथ प्रॉम्प्ट बनाएं
10  const prompt = buildPromptWithContext(query, relevantDocs);
11  
12  // 4. LLM के साथ प्रतिक्रिया उत्पन्न करें
13  const response = await llm.generate(prompt);
14  
15  return response;
16}

प्रौद्योगिकी विकल्प

हमारे कार्यान्वयन के लिए, हमने एक आधुनिक और प्रदर्शनकारी स्टैक चुना है:

• Bun: अल्ट्रा-फास्ट जावास्क्रिप्ट रनटाइम, सर्वर अनुप्रयोगों के लिए आदर्श
• TypeScript: बेहतर रखरखाव के लिए स्टेटिक टाइपिंग
• LangChain: LLM-आधारित अनुप्रयोगों के निर्माण के लिए फ्रेमवर्क
• Ollama: स्थानीय रूप से भाषा मॉडल चलाने के लिए उपकरण
• Qdrant: प्रदर्शनकारी और आसानी से तैनात करने योग्य वेक्टर डेटाबेस

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

TypeScript के साथ व्यावहारिक कार्यान्वयन

Bun के साथ प्रोजेक्ट सेटअप

आइए अपनी परियोजना शुरू करके शुरू करें:

bash
1# प्रोजेक्ट निर्माण
2mkdir rag-code-assistant
3cd rag-code-assistant
4bun init
5
6# निर्भरता स्थापना
7bun add langchain @langchain/community @langchain/openai
8bun add qdrant-js ollama
9bun add -d typescript @types/node

मूल विन्यास

typescript
1// src/config.ts
2export const CONFIG = {
3  // Ollama कॉन्फ़िगरेशन
4  OLLAMA_BASE_URL: 'http://localhost:11434',
5  OLLAMA_MODEL_NAME: 'llama3',
6  
7  // Qdrant कॉन्फ़िगरेशन
8  QDRANT_URL: 'http://localhost:6333',
9  QDRANT_COLLECTION_NAME: 'code_repository',
10  
11  // अनुक्रमण कॉन्फ़िगरेशन
12  CHUNK_SIZE: 1000,
13  CHUNK_OVERLAP: 200,
14  
15  // अनुक्रमित करने के लिए कोड रिपॉजिटरी का पथ
16  REPOSITORY_PATH: './repository',
17};

दस्तावेज़ अनुक्रमण

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

typescript
1// src/indexer.ts
2import { DirectoryLoader } from 'langchain/document_loaders/fs/directory';
3import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
4import { OllamaEmbeddings } from '@langchain/community/embeddings/ollama';
5import { QdrantClient } from 'qdrant-js';
6import { CONFIG } from './config';
7
8export async function indexRepository() {
9  // 1. रिपॉजिटरी फ़ाइलें लोड हो रही हैं
10  const loader = new DirectoryLoader(
11    CONFIG.REPOSITORY_PATH,
12    {
13      '.ts': (path) => new TextLoader(path),
14      '.js': (path) => new TextLoader(path),
15      '.tsx': (path) => new TextLoader(path),
16      '.jsx': (path) => new TextLoader(path),
17      '.md': (path) => new TextLoader(path),
18    }
19  );
20  
21  const docs = await loader.load();
22  console.log(`${docs.length} फ़ाइलों का लोडिंग पूरा हुआ`);
23  
24  // 2. टुकड़ों में विभाजन
25  const textSplitter = new RecursiveCharacterTextSplitter({
26    chunkSize: CONFIG.CHUNK_SIZE,
27    chunkOverlap: CONFIG.CHUNK_OVERLAP,
28  });
29  
30  const chunks = await textSplitter.splitDocuments(docs);
31  console.log(`${chunks.length} टुकड़ों का निर्माण पूरा हुआ`);
32  
33  // 3. एम्बेडिंग उत्पन्न करना
34  const embeddings = new OllamaEmbeddings({
35    baseUrl: CONFIG.OLLAMA_BASE_URL,
36    model: CONFIG.OLLAMA_MODEL_NAME,
37  });
38  
39  // 4. Qdrant में भंडारण
40  const qdrant = new QdrantClient({ url: CONFIG.QDRANT_URL });
41  
42  // संग्रह बनाना यदि यह मौजूद नहीं है
43  try {
44    await qdrant.createCollection(CONFIG.QDRANT_COLLECTION_NAME, {
45      vectors: {
46        size: 1536, // एम्बेडिंग वैक्टर का आकार
47        distance: 'Cosine',
48      },
49    });
50  } catch (e) {
51    console.log('संग्रह पहले से मौजूद है या त्रुटि:', e.message);
52  }
53  
54  // उनके एम्बेडिंग के साथ दस्तावेज़ सम्मिलित करना
55  for (let i = 0; i < chunks.length; i += 100) {
56    const batch = chunks.slice(i, i + 100);
57    const batchEmbeddings = await embeddings.embedDocuments(
58      batch.map(chunk => chunk.pageContent)
59    );
60    
61    await qdrant.upsert(CONFIG.QDRANT_COLLECTION_NAME, {
62      points: batchEmbeddings.map((vector, idx) => ({
63        id: `${i + idx}`,
64        vector,
65        payload: {
66          text: batch[idx].pageContent,
67          metadata: batch[idx].metadata,
68        },
69      })),
70    });
71    
72    console.log(`बैच ${i}-${i + batch.length} का प्रसंस्करण पूरा हुआ`);
73  }
74  
75  console.log('अनुक्रमण सफलतापूर्वक पूरा हुआ!');
76}

खोज और प्रतिक्रिया पीढ़ी

typescript
1// src/rag.ts
2import { OllamaEmbeddings } from '@langchain/community/embeddings/ollama';
3import { QdrantClient } from 'qdrant-js';
4import { Ollama } from '@langchain/community/llms/ollama';
5import { CONFIG } from './config';
6
7export async function generateResponse(query: string): Promise<string> {
8  // 1. घटकों को इनिशियलाइज़ करना
9  const embeddings = new OllamaEmbeddings({
10    baseUrl: CONFIG.OLLAMA_BASE_URL,
11    model: CONFIG.OLLAMA_MODEL_NAME,
12  });
13  
14  const qdrant = new QdrantClient({ url: CONFIG.QDRANT_URL });
15  
16  const llm = new Ollama({
17    baseUrl: CONFIG.OLLAMA_BASE_URL,
18    model: CONFIG.OLLAMA_MODEL_NAME,
19  });
20  
21  // 2. क्वेरी एम्बेडिंग उत्पन्न करना
22  const queryEmbedding = await embeddings.embedQuery(query);
23  
24  // 3. प्रासंगिक दस्तावेजों की खोज
25  const searchResults = await qdrant.search(CONFIG.QDRANT_COLLECTION_NAME, {
26    vector: queryEmbedding,
27    limit: 5,
28  });
29  
30  const relevantDocs = searchResults.map(result => result.payload.text).join('\n\n');
31  
32  // 4. संदर्भ के साथ प्रॉम्प्ट बनाना
33  const prompt = `
34  आप एक विशेषज्ञ प्रोग्रामिंग सहायक हैं जो एक परियोजना के स्रोत कोड को समझने में मदद करते हैं।
35  उपयोगकर्ता के प्रश्न का उत्तर देने के लिए निम्नलिखित संदर्भ का उपयोग करें।
36  यदि आपको संदर्भ में जानकारी नहीं मिल रही है, तो स्पष्ट रूप से ऐसा कहें।
37  
38  CONTEXT:
39  ${relevantDocs}
40  
41  QUESTION: ${query}
42  
43  ANSWER:
44  `;
45  
46  // 5. प्रतिक्रिया उत्पन्न करना
47  const response = await llm.call(prompt);
48  
49  return response;
50}

सरल उपयोगकर्ता इंटरफ़ेस

typescript
1// src/index.ts
2import { indexRepository } from './indexer';
3import { generateResponse } from './rag';
4
5async function main() {
6  // अनुक्रमण या क्वेरी करने के लिए तर्क
7  const args = process.argv.slice(2);
8  
9  if (args[0] === 'index') {
10    console.log('अनुक्रमण शुरू हो रहा है...');
11    await indexRepository();
12  } else if (args[0] === 'query') {
13    const query = args.slice(1).join(' ');
14    if (!query) {
15      console.log('उपयोग: bun run src/index.ts query "कोड के बारे में आपका प्रश्न"');
16      process.exit(1);
17    }
18    
19    console.log(`प्रश्न: ${query}`);
20    console.log('प्रतिक्रिया उत्पन्न हो रही है...');
21    const response = await generateResponse(query);
22    console.log('\nउत्तर:');
23    console.log(response);
24  } else {
25    console.log('उपयोग: bun run src/index.ts [index|query "आपका प्रश्न"]');
26  }
27}
28
29main().catch(console.error);

कोड विश्लेषण और सर्वोत्तम अभ्यास

कुशल चंकिंग

दस्तावेजों को टुकड़ों में विभाजित करना एक महत्वपूर्ण कदम है जो सीधे परिणामों की गुणवत्ता को प्रभावित करता है। कुछ सर्वोत्तम अभ्यास:

• उपयुक्त आकार: टुकड़े संदर्भ रखने के लिए पर्याप्त बड़े होने चाहिए, लेकिन प्रासंगिक बने रहने के लिए बहुत बड़े नहीं (आमतौर पर 500 और 1500 वर्णों के बीच)।
• ओवरलैप: टुकड़ों के बीच ओवरलैप सीमाओं पर संदर्भ खोने से रोकता है।
• सिमेंटिक विभाजन: आदर्श रूप से, विभाजन को दस्तावेजों की सिमेंटिक संरचना (पैराग्राफ, फ़ंक्शन, आदि) का सम्मान करना चाहिए।

खोज अनुकूलन

सिमेंटिक खोज की गुणवत्ता आवश्यक है:

• मेटाडेटा फ़िल्टर: खोजों को परिष्कृत करने के लिए मेटाडेटा (फ़ाइल प्रकार, दिनांक, लेखक) का उपयोग करें।
• पुनः-रैंकिंग: प्रासंगिकता में सुधार के लिए फ़िल्टरिंग का दूसरा स्तर लागू करें।
• विविधता: प्रश्न के विभिन्न पहलुओं को कवर करने के लिए परिणामों में विविधता सुनिश्चित करें।

उन्नत प्रॉम्प्टिंग

प्रॉम्प्ट निर्माण एक कला है जो प्रतिक्रियाओं की गुणवत्ता को दृढ़ता से प्रभावित करती है:

typescript
1// एक अधिक उन्नत प्रॉम्प्ट का उदाहरण
2const prompt = `
3# ROLE
4आप स्रोत कोड विश्लेषण में विशेषज्ञता वाले एक विशेषज्ञ प्रोग्रामिंग सहायक हैं।
5
6# CONTEXT
7${relevantDocs}
8
9# INSTRUCTIONS
10- केवल प्रदान किए गए संदर्भ के आधार पर उपयोगकर्ता के प्रश्न का उत्तर दें
11- यदि संदर्भ में आवश्यक जानकारी नहीं है, तो इसे स्पष्ट रूप से इंगित करें
12- अपने उत्तर में प्रासंगिक कोड अंश उद्धृत करें
13- कोड को शैक्षिक तरीके से समझाएं
14- यदि आप कोई सुधार पहचानते हैं तो सुझाव दें
15
16# QUESTION
17${query}
18`;

तकनीकी स्टैक के लाभ

Node.js बनाम Bun प्रदर्शन

Bun इस प्रकार के अनुप्रयोग के लिए महत्वपूर्ण लाभ प्रदान करता है:

• तेज स्टार्टअप: Node.js की तुलना में 4 गुना तेज स्टार्टअप समय
• अनुकूलित निष्पादन: बेहतर निष्पादन प्रदर्शन, विशेष रूप से I/O संचालन के लिए
• एकीकृत बंडलर: विकास वर्कफ़्लो का सरलीकरण

LangChain सरलता

LangChain LLM-आधारित अनुप्रयोगों के विकास को बहुत सुगम बनाता है:

• अमूर्तता: विभिन्न मॉडलों और प्रदाताओं के लिए एकीकृत इंटरफ़ेस
• पुन: प्रयोज्य घटक: उपयोग के लिए तैयार चेन, एजेंट और उपकरण
• स्थापित पैटर्न: सामान्य उपयोग के मामलों के लिए संदर्भ कार्यान्वयन

Ollama लचीलापन

Ollama बड़ी लचीलेपन के साथ स्थानीय रूप से भाषा मॉडल चलाने की अनुमति देता है:

• स्थानीय मॉडल: बाहरी API पर कोई निर्भरता नहीं
• गोपनीयता: डेटा आपके बुनियादी ढांचे पर रहता है
• अनुकूलन: आपकी आवश्यकताओं के अनुसार मॉडल समायोजित करने की संभावना

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

Qdrant सिमेंटिक खोज के लिए डिज़ाइन किया गया एक आधुनिक वेक्टर डेटाबेस है:

• प्रदर्शन: तेज समानता खोजों के लिए अनुकूलित
• फ़िल्टरिंग: मेटाडेटा पर उन्नत फ़िल्टरिंग क्षमताएं
• लचीला परिनियोजन: एम्बेडेड मोड में या सेवा के रूप में प्रयोग करने योग्य

आगे बढ़ते हुए

उन्नत अनुकूलन

• हाइब्रिड खोज: वेक्टर खोज और कीवर्ड खोज को मिलाएं
• पदानुक्रमित चंकिंग: टुकड़ों के लिए ग्रैन्युलैरिटी के विभिन्न स्तरों का उपयोग करें
• कैशिंग: खोज परिणामों और लगातार प्रतिक्रियाओं को कैश करें

मूल्यांकन और मेट्रिक्स

RAG प्रणाली की गुणवत्ता को मापने के लिए:

• प्रासंगिकता: क्या प्राप्त दस्तावेज़ प्रश्न के लिए प्रासंगिक हैं?
• वफ़ादारी: क्या उत्तर स्रोत दस्तावेजों के प्रति वफादार है?
• उपयोगिता: क्या उत्तर प्रभावी रूप से उपयोगकर्ता के प्रश्न को संबोधित करता है?

तकनीकी विकल्प

• फ्रेमवर्क: LangChain के विकल्प के रूप में Haystack, LlamaIndex
• वेक्टर डेटाबेस: Qdrant के विकल्प के रूप में Pinecone, Weaviate, Milvus
• मॉडल: विभिन्न स्थानीय मॉडल (Llama, Mistral) या API (OpenAI, Anthropic)

निष्कर्ष

रिट्रीवल-ऑगमेंटेड जेनरेशन एक बड़ी प्रगति का प्रतिनिधित्व करता है कि हम विशिष्ट उपयोग के मामलों के लिए भाषा मॉडल का लाभ कैसे उठा सकते हैं। ज्ञान को पीढ़ी मॉडल से अलग करके, RAG AI सहायकों के निर्माण को सक्षम बनाता है जो अधिक सटीक, अधिक अद्यतित और अधिक पारदर्शी होते हैं।

TypeScript, Bun, LangChain, Ollama, और Qdrant के साथ हमारा कार्यान्वयन दर्शाता है कि अब आधुनिक और सुलभ प्रौद्योगिकियों के साथ प्रदर्शनकारी RAG सिस्टम बनाना संभव है। यह दृष्टिकोण AI सहायकों की एक नई पीढ़ी के लिए मार्ग प्रशस्त करता है जो बड़े भाषा मॉडल की तरलता और सुसंगतता बनाए रखते हुए विशिष्ट ज्ञान आधारों पर तर्क करने में सक्षम हैं।

GitHub पर पूरा स्रोत कोड एक्सप्लोर करने और इसे अपने स्वयं के उपयोग के मामलों में अनुकूलित करने के लिए स्वतंत्र महसूस करें। RAG एक विकसित हो रही तकनीक है, और इस रोमांचक क्षेत्र में नवाचार के कई अवसर हैं।