RAG और LangChain: Retrieval-Augmented Generation की संपूर्ण गाइड

spinny:~/writing $ less rag-langchain-deep-dive.md

1 
2GPT-4 और Claude जैसे Large Language Models (LLMs) असाधारण रूप से शक्तिशाली हैं, लेकिन वे एक मूलभूत सीमा से ग्रस्त हैं: उनका ज्ञान ट्रेनिंग के समय जम जाता है। वे आपके आंतरिक दस्तावेज़ों, आपके डेटाबेस या वास्तविक समय की जानकारी तक नहीं पहुँच सकते। **Retrieval-Augmented Generation (RAG)** LLMs की जनरेटिव शक्ति को बाहरी स्रोतों से जानकारी प्राप्त करने की क्षमता के साथ जोड़कर इस समस्या को हल करती है।
3 
4## समस्या: LLMs की सीमाएं
5 
6RAG के बारे में बात करने से पहले, यह समझना ज़रूरी है कि हमें इसकी आवश्यकता क्यों है।
7 
81.  **स्थिर ज्ञान**: एक LLM केवल वही जानता है जो उसने ट्रेनिंग के दौरान देखा। यदि आप उसके कटऑफ के बाद हुई किसी घटना के बारे में पूछते हैं, तो वह उत्तर नहीं दे सकता।
92.  **हैलुसिनेशन**: जब LLM को उत्तर नहीं पता होता, तो वह एक गढ़ने की प्रवृत्ति रखता है, विश्वसनीय लेकिन पूरी तरह से गलत जानकारी उत्पन्न करता है।
103.  **निजी डेटा तक पहुँच नहीं**: एक सामान्य LLM के पास आपकी कंपनी के आंतरिक दस्तावेज़ों, टिकट या कोडबेस तक पहुँच नहीं है।
11 
12RAG क्वेरी के समय बाहरी स्रोतों से प्राप्त **प्रासंगिक संदर्भ** प्रदान करके इन तीनों समस्याओं का समाधान करती है।
13 
14## RAG क्या है?
15 
16Retrieval-Augmented Generation एक आर्किटेक्चर है जो LLM को भेजे गए प्रॉम्प्ट को बाहरी ज्ञान आधार से प्राप्त जानकारी से समृद्ध करती है। मॉडल के पैरामेट्रिक ज्ञान पर पूरी तरह निर्भर रहने के बजाय, RAG पहले प्रासंगिक जानकारी **खोजती** है और फिर उसे प्रॉम्प्ट में **इंजेक्ट** करती है, जिससे मॉडल सटीक, आधारित प्रतिक्रियाएं उत्पन्न कर सकता है।
17 
18```mermaid
19graph LR
20    User["उपयोगकर्ता"] -- "प्रश्न" --> Retriever
21    Retriever -- "प्रासंगिक दस्तावेज़\nखोजें" --> VectorStore["वेक्टर स्टोर"]
22    VectorStore -- "प्रासंगिक\nदस्तावेज़" --> Retriever
23    Retriever -- "संदर्भ + प्रश्न" --> LLM
24    LLM -- "आधारित\nउत्तर" --> User
25```
26 
27## RAG विस्तार से कैसे काम करता है
28 
29RAG आर्किटेक्चर दो मुख्य चरणों से बना है: **इंडेक्सिंग** (ऑफलाइन) और **रिट्रीवल + जनरेशन** (ऑनलाइन)।
30 
31### चरण 1: इंडेक्सिंग (दस्तावेज़ इंजेशन)
32 
33इंडेक्सिंग चरण आपके दस्तावेज़ों को सिमेंटिक खोज के लिए तैयार करता है। इसमें चार कदम शामिल हैं।
34 
35```mermaid
36graph TD
37    A["दस्तावेज़\n(PDF, HTML, MD, DB)"] --> B["डॉक्यूमेंट लोडर"]
38    B --> C["टेक्स्ट स्प्लिटर"]
39    C --> D["टेक्स्ट चंक्स"]
40    D --> E["एम्बेडिंग मॉडल"]
41    E --> F["संख्यात्मक वेक्टर"]
42    F --> G["वेक्टर स्टोर\n(ChromaDB, Pinecone, FAISS)"]
43```
44 
45#### 1. दस्तावेज़ लोडिंग
46 
47दस्तावेज़ किसी भी स्रोत से आ सकते हैं: PDF फाइलें, वेब पेज, डेटाबेस, Markdown फाइलें, APIs। **डॉक्यूमेंट लोडर** इन दस्तावेज़ों को पढ़ता है और उन्हें संरचित टेक्स्ट में बदलता है।
48 
49#### 2. टेक्स्ट स्प्लिटिंग (चंकिंग)
50 
51LLMs की कॉन्टेक्स्ट विंडो सीमित होती है, और दस्तावेज़ बहुत लंबे हो सकते हैं। **टेक्स्ट स्प्लिटर** दस्तावेज़ों को *चंक्स* नामक छोटे टुकड़ों में विभाजित करता है। चंकिंग की गुणवत्ता महत्वपूर्ण है: बहुत छोटे चंक्स संदर्भ खो देते हैं, बहुत बड़े चंक्स प्रासंगिकता को कम करते हैं।
52 
53सबसे आम रणनीतियां हैं:
54-   **रिकर्सिव कैरेक्टर स्प्लिटिंग**: `\n\n`, `\n`, `. ` जैसे सेपरेटर्स का उपयोग करके टेक्स्ट को रिकर्सिव रूप से विभाजित करता है, दस्तावेज़ संरचना का सम्मान करता है।
55-   **सिमेंटिक स्प्लिटिंग**: टेक्स्ट में प्राकृतिक ब्रेकपॉइंट खोजने के लिए एम्बेडिंग का उपयोग करता है।
56-   **चंक ओवरलैप**: सीमाओं पर संदर्भ को संरक्षित करने के लिए लगातार चंक्स के बीच ओवरलैप शामिल करता है।
57 
58#### 3. एम्बेडिंग
59 
60प्रत्येक चंक को एम्बेडिंग मॉडल (जैसे OpenAI का `text-embedding-3-small`) के माध्यम से एक **संख्यात्मक वेक्टर** (एम्बेडिंग) में बदला जाता है। ये वेक्टर टेक्स्ट के सिमेंटिक अर्थ को कैप्चर करते हैं: समान अर्थ वाले वाक्यों के वेक्टर बहुआयामी स्थान में पास होंगे।
61 
62#### 4. वेक्टर स्टोर
63 
64वेक्टर ChromaDB, Pinecone, Weaviate या FAISS जैसे **वेक्टर स्टोर** (वेक्टर डेटाबेस) में सहेजे जाते हैं। यह डेटाबेस **समानता खोज** के लिए अनुकूलित है: एक क्वेरी दिए जाने पर, यह सबसे समान वेक्टर (और इसलिए सबसे प्रासंगिक टेक्स्ट चंक्स) खोजता है।
65 
66### चरण 2: रिट्रीवल + जनरेशन
67 
68जब उपयोगकर्ता प्रश्न पूछता है:
69 
701.  प्रश्न को उसी एम्बेडिंग मॉडल का उपयोग करके एम्बेडिंग में बदला जाता है।
712.  वेक्टर स्टोर **समानता खोज** (आमतौर पर कोसाइन समानता या यूक्लिडियन दूरी) के माध्यम से सबसे समान चंक्स खोजता है।
723.  प्राप्त चंक्स को संदर्भ के रूप में प्रॉम्प्ट में डाला जाता है।
734.  LLM प्रदान किए गए संदर्भ के आधार पर उत्तर उत्पन्न करता है।
74 
75## LangChain के साथ RAG पाइपलाइन बनाना
76 
77**LangChain** LLM-आधारित एप्लिकेशन बनाने के लिए सबसे लोकप्रिय Python (और JavaScript) फ्रेमवर्क है। यह RAG पाइपलाइन के प्रत्येक घटक के लिए उच्च-स्तरीय एब्स्ट्रैक्शन प्रदान करता है।
78 
79### इंस्टॉलेशन
80 
81```bash
82pip install langchain langchain-openai langchain-community chromadb
83```
84 
85### स्टेप 1: दस्तावेज़ लोड करें
86 
87LangChain विभिन्न डेटा स्रोतों के लिए दर्जनों डॉक्यूमेंट लोडर प्रदान करता है।
88 
89```python
90from langchain_community.document_loaders import (
91    PyPDFLoader,
92    WebBaseLoader,
93    DirectoryLoader,
94    TextLoader,
95)
96 
97# एक PDF लोड करें
98pdf_loader = PyPDFLoader("docs/manual.pdf")
99pdf_docs = pdf_loader.load()
100 
101# एक वेब पेज लोड करें
102web_loader = WebBaseLoader("https://docs.example.com/guide")
103web_docs = web_loader.load()
104 
105# एक डायरेक्टरी से सभी .md फाइलें लोड करें
106dir_loader = DirectoryLoader("./knowledge_base", glob="**/*.md", loader_cls=TextLoader)
107md_docs = dir_loader.load()
108 
109all_docs = pdf_docs + web_docs + md_docs
110```
111 
112### स्टेप 2: दस्तावेज़ों को चंक्स में विभाजित करें
113 
114```python
115from langchain.text_splitter import RecursiveCharacterTextSplitter
116 
117text_splitter = RecursiveCharacterTextSplitter(
118    chunk_size=1000,
119    chunk_overlap=200,
120    separators=["\n\n", "\n", ". ", " ", ""],
121)
122 
123chunks = text_splitter.split_documents(all_docs)
124print(f"मूल दस्तावेज़: {len(all_docs)}, चंक्स: {len(chunks)}")
125```
126 
127`chunk_overlap` पैरामीटर महत्वपूर्ण है: यह लगातार चंक्स के बीच ओवरलैप बनाता है ताकि सीमाओं पर संदर्भ न खोए।
128 
129### स्टेप 3: एम्बेडिंग और वेक्टर स्टोर बनाएं
130 
131```python
132from langchain_openai import OpenAIEmbeddings
133from langchain_community.vectorstores import Chroma
134 
135embedding_model = OpenAIEmbeddings(model="text-embedding-3-small")
136 
137vectorstore = Chroma.from_documents(
138    documents=chunks,
139    embedding=embedding_model,
140    persist_directory="./chroma_db",
141)
142```
143 
144### स्टेप 4: रिट्रीवर बनाएं
145 
146रिट्रीवर वह घटक है जो, एक क्वेरी दिए जाने पर, वेक्टर स्टोर से सबसे प्रासंगिक चंक्स प्राप्त करता है।
147 
148```python
149retriever = vectorstore.as_retriever(
150    search_type="similarity",
151    search_kwargs={"k": 4},
152)
153 
154relevant_docs = retriever.invoke("प्रमाणीकरण कैसे काम करता है?")
155for doc in relevant_docs:
156    print(doc.page_content[:200])
157    print("---")
158```
159 
160### स्टेप 5: RAG चेन बनाएं
161 
162अब सब कुछ एक LLM और प्रॉम्प्ट टेम्पलेट के साथ जोड़ते हैं।
163 
164```python
165from langchain_openai import ChatOpenAI
166from langchain_core.prompts import ChatPromptTemplate
167from langchain_core.runnables import RunnablePassthrough
168from langchain_core.output_parsers import StrOutputParser
169 
170llm = ChatOpenAI(model="gpt-4o", temperature=0)
171 
172prompt = ChatPromptTemplate.from_template("""
173केवल प्रदान किए गए संदर्भ के आधार पर प्रश्न का उत्तर दें।
174यदि संदर्भ में पर्याप्त जानकारी नहीं है, तो कहें कि आप नहीं जानते।
175 
176संदर्भ:
177{context}
178 
179प्रश्न: {question}
180 
181उत्तर:
182""")
183 
184def format_docs(docs):
185    return "\n\n".join(doc.page_content for doc in docs)
186 
187rag_chain = (
188    {"context": retriever | format_docs, "question": RunnablePassthrough()}
189    | prompt
190    | llm
191    | StrOutputParser()
192)
193 
194response = rag_chain.invoke("सिस्टम में प्रमाणीकरण कैसे काम करता है?")
195print(response)
196```
197 
198## उन्नत RAG तकनीकें
199 
200बुनियादी पाइपलाइन अच्छी तरह काम करती है, लेकिन उत्तर की गुणवत्ता में उल्लेखनीय सुधार करने के लिए कई तकनीकें हैं।
201 
202### मल्टी-क्वेरी रिट्रीवल
203 
204कभी-कभी उपयोगकर्ता की क्वेरी अस्पष्ट होती है या दस्तावेज़ों में प्रयुक्त भाषा से मेल नहीं खाती। **मल्टी-क्वेरी रिट्रीवर** कई दृष्टिकोणों को कैप्चर करने के लिए मूल प्रश्न के वेरिएंट स्वचालित रूप से उत्पन्न करता है।
205 
206```python
207from langchain.retrievers import MultiQueryRetriever
208 
209multi_retriever = MultiQueryRetriever.from_llm(
210    retriever=vectorstore.as_retriever(),
211    llm=llm,
212)
213 
214docs = multi_retriever.invoke("सुरक्षा की सर्वोत्तम प्रथाएं क्या हैं?")
215```
216 
217### कॉन्टेक्स्चुअल कम्प्रेशन
218 
219चंक की सारी सामग्री क्वेरी के लिए प्रासंगिक नहीं होती। **कॉन्टेक्स्चुअल कम्प्रेशन रिट्रीवर** प्रत्येक प्राप्त चंक से केवल प्रासंगिक भागों को निकालने के लिए LLM का उपयोग करता है।
220 
221```python
222from langchain.retrievers import ContextualCompressionRetriever
223from langchain.retrievers.document_compressors import LLMChainExtractor
224 
225compressor = LLMChainExtractor.from_llm(llm)
226compression_retriever = ContextualCompressionRetriever(
227    base_compressor=compressor,
228    base_retriever=retriever,
229)
230```
231 
232### हाइब्रिड सर्च
233 
234शुद्ध सिमेंटिक खोज हमेशा इष्टतम नहीं होती। **हाइब्रिड सर्च** बेहतर परिणाम प्राप्त करने के लिए सिमेंटिक खोज (एम्बेडिंग) को लेक्सिकल खोज (BM25, कीवर्ड मैचिंग) के साथ जोड़ती है।
235 
236```python
237from langchain.retrievers import EnsembleRetriever
238from langchain_community.retrievers import BM25Retriever
239 
240bm25_retriever = BM25Retriever.from_documents(chunks)
241bm25_retriever.k = 4
242 
243semantic_retriever = vectorstore.as_retriever(search_kwargs={"k": 4})
244 
245hybrid_retriever = EnsembleRetriever(
246    retrievers=[bm25_retriever, semantic_retriever],
247    weights=[0.4, 0.6],
248)
249```
250 
251### कन्वर्सेशनल RAG (मेमोरी के साथ)
252 
253बातचीत के संदर्भ को याद रखने वाला RAG चैटबॉट बनाने के लिए, एक मेमोरी जोड़ना आवश्यक है जो बातचीत के इतिहास को ध्यान में रखते हुए उपयोगकर्ता के प्रश्नों को पुनर्निर्मित करे।
254 
255```python
256from langchain.chains import create_history_aware_retriever
257from langchain_core.prompts import MessagesPlaceholder
258 
259contextualize_prompt = ChatPromptTemplate.from_messages([
260    ("system", "चैट इतिहास और उपयोगकर्ता के नवीनतम प्रश्न को देखते हुए, "
261               "प्रश्न को इस तरह पुनर्निर्मित करें कि यह इतिहास के बिना भी समझ में आए।"),
262    MessagesPlaceholder("chat_history"),
263    ("human", "{input}"),
264])
265 
266history_aware_retriever = create_history_aware_retriever(
267    llm, retriever, contextualize_prompt
268)
269```
270 
271## सर्वोत्तम प्रथाएं
272 
2731.  **सही चंक आकार चुनें**: विभिन्न आकारों (500-1500 टोकन) के साथ प्रयोग करें। सटीक उत्तरों के लिए छोटे चंक्स, व्यापक संदर्भ के लिए बड़े चंक्स।
2742.  **दस्तावेज़ मेटाडेटा का उपयोग करें**: स्रोत, तिथि और श्रेणी को चंक्स में मेटाडेटा के रूप में जोड़ें। यह रिट्रीवल के दौरान परिणामों को फिल्टर करने की अनुमति देता है।
2753.  **गुणवत्ता का मूल्यांकन करें**: *faithfulness*, *relevancy* और *context precision* जैसे मेट्रिक्स मापने के लिए [RAGAS](https://docs.ragas.io/) जैसे फ्रेमवर्क का उपयोग करें।
2764.  **दस्तावेज़ अपडेट प्रबंधित करें**: वेक्टर स्टोर को अपने डेटा स्रोतों के साथ सिंक्रनाइज़ रखने के लिए री-इंजेशन पाइपलाइन लागू करें।
2775.  **री-रैंकर जोड़ें**: प्रारंभिक रिट्रीवल के बाद, वास्तविक प्रासंगिकता के आधार पर परिणामों को पुनर्क्रमित करने के लिए री-रैंकिंग मॉडल (जैसे Cohere Rerank) का उपयोग करें।
278 
279## निष्कर्ष
280 
281RAG विशिष्ट, अद्यतन ज्ञान तक पहुँच की आवश्यकता वाले AI एप्लिकेशन बनाने के लिए मानक आर्किटेक्चर बन गई है। LangChain पाइपलाइन के प्रत्येक घटक के लिए एब्स्ट्रैक्शन प्रदान करके कार्यान्वयन को बहुत सरल बनाता है।
282 
283**अगले कदम:**
284- **स्थानीय रूप से प्रयोग करें**: पाइपलाइन से परिचित होने के लिए ChromaDB और कुछ दस्तावेज़ों से शुरू करें।
285- **LangSmith का अन्वेषण करें**: प्रोडक्शन में अपनी चेन की निगरानी और डिबगिंग के लिए [LangSmith](https://smith.langchain.com/) का उपयोग करें।
286- **विभिन्न एम्बेडिंग मॉडल आज़माएं**: `text-embedding-3-small`, `text-embedding-3-large` और Sentence Transformers के ओपन-सोर्स मॉडल की तुलना करें।
287- **दस्तावेज़ देखें**: [LangChain दस्तावेज़](https://python.langchain.com/docs/) एक उत्कृष्ट और लगातार अपडेट होने वाला संसाधन है।
288

:RAG और LangChain: Retrieval-Augmented Generation की संपूर्ण गाइडlines 1-288 (END) — press q to close

2GPT-4 और Claude जैसे Large Language Models (LLMs) असाधारण रूप से शक्तिशाली हैं, लेकिन वे एक मूलभूत सीमा से ग्रस्त हैं: उनका ज्ञान ट्रेनिंग के समय जम जाता है। वे आपके आंतरिक दस्तावेज़ों, आपके डेटाबेस या वास्तविक समय की जानकारी तक नहीं पहुँच सकते। **Retrieval-Augmented Generation (RAG)** LLMs की जनरेटिव शक्ति को बाहरी स्रोतों से जानकारी प्राप्त करने की क्षमता के साथ जोड़कर इस समस्या को हल करती है।

4## समस्या: LLMs की सीमाएं

6RAG के बारे में बात करने से पहले, यह समझना ज़रूरी है कि हमें इसकी आवश्यकता क्यों है।

81. **स्थिर ज्ञान**: एक LLM केवल वही जानता है जो उसने ट्रेनिंग के दौरान देखा। यदि आप उसके कटऑफ के बाद हुई किसी घटना के बारे में पूछते हैं, तो वह उत्तर नहीं दे सकता।

92. **हैलुसिनेशन**: जब LLM को उत्तर नहीं पता होता, तो वह एक गढ़ने की प्रवृत्ति रखता है, विश्वसनीय लेकिन पूरी तरह से गलत जानकारी उत्पन्न करता है।

103. **निजी डेटा तक पहुँच नहीं**: एक सामान्य LLM के पास आपकी कंपनी के आंतरिक दस्तावेज़ों, टिकट या कोडबेस तक पहुँच नहीं है।

12RAG क्वेरी के समय बाहरी स्रोतों से प्राप्त **प्रासंगिक संदर्भ** प्रदान करके इन तीनों समस्याओं का समाधान करती है।

14## RAG क्या है?

16Retrieval-Augmented Generation एक आर्किटेक्चर है जो LLM को भेजे गए प्रॉम्प्ट को बाहरी ज्ञान आधार से प्राप्त जानकारी से समृद्ध करती है। मॉडल के पैरामेट्रिक ज्ञान पर पूरी तरह निर्भर रहने के बजाय, RAG पहले प्रासंगिक जानकारी **खोजती** है और फिर उसे प्रॉम्प्ट में **इंजेक्ट** करती है, जिससे मॉडल सटीक, आधारित प्रतिक्रियाएं उत्पन्न कर सकता है।

18```mermaid

19graph LR

20 User["उपयोगकर्ता"] -- "प्रश्न" --> Retriever

21 Retriever -- "प्रासंगिक दस्तावेज़\nखोजें" --> VectorStore["वेक्टर स्टोर"]

22 VectorStore -- "प्रासंगिक\nदस्तावेज़" --> Retriever

23 Retriever -- "संदर्भ + प्रश्न" --> LLM

24 LLM -- "आधारित\nउत्तर" --> User

25```

27## RAG विस्तार से कैसे काम करता है

29RAG आर्किटेक्चर दो मुख्य चरणों से बना है: **इंडेक्सिंग** (ऑफलाइन) और **रिट्रीवल + जनरेशन** (ऑनलाइन)।

31### चरण 1: इंडेक्सिंग (दस्तावेज़ इंजेशन)

33इंडेक्सिंग चरण आपके दस्तावेज़ों को सिमेंटिक खोज के लिए तैयार करता है। इसमें चार कदम शामिल हैं।

35```mermaid

36graph TD

37 A["दस्तावेज़\n(PDF, HTML, MD, DB)"] --> B["डॉक्यूमेंट लोडर"]

38 B --> C["टेक्स्ट स्प्लिटर"]

39 C --> D["टेक्स्ट चंक्स"]

40 D --> E["एम्बेडिंग मॉडल"]

41 E --> F["संख्यात्मक वेक्टर"]

42 F --> G["वेक्टर स्टोर\n(ChromaDB, Pinecone, FAISS)"]

43```

45#### 1. दस्तावेज़ लोडिंग

47दस्तावेज़ किसी भी स्रोत से आ सकते हैं: PDF फाइलें, वेब पेज, डेटाबेस, Markdown फाइलें, APIs। **डॉक्यूमेंट लोडर** इन दस्तावेज़ों को पढ़ता है और उन्हें संरचित टेक्स्ट में बदलता है।

49#### 2. टेक्स्ट स्प्लिटिंग (चंकिंग)

51LLMs की कॉन्टेक्स्ट विंडो सीमित होती है, और दस्तावेज़ बहुत लंबे हो सकते हैं। **टेक्स्ट स्प्लिटर** दस्तावेज़ों को *चंक्स* नामक छोटे टुकड़ों में विभाजित करता है। चंकिंग की गुणवत्ता महत्वपूर्ण है: बहुत छोटे चंक्स संदर्भ खो देते हैं, बहुत बड़े चंक्स प्रासंगिकता को कम करते हैं।

53सबसे आम रणनीतियां हैं:

54- **रिकर्सिव कैरेक्टर स्प्लिटिंग**: `\n\n`, `\n`, `. ` जैसे सेपरेटर्स का उपयोग करके टेक्स्ट को रिकर्सिव रूप से विभाजित करता है, दस्तावेज़ संरचना का सम्मान करता है।

55- **सिमेंटिक स्प्लिटिंग**: टेक्स्ट में प्राकृतिक ब्रेकपॉइंट खोजने के लिए एम्बेडिंग का उपयोग करता है।

56- **चंक ओवरलैप**: सीमाओं पर संदर्भ को संरक्षित करने के लिए लगातार चंक्स के बीच ओवरलैप शामिल करता है।

58#### 3. एम्बेडिंग

60प्रत्येक चंक को एम्बेडिंग मॉडल (जैसे OpenAI का `text-embedding-3-small`) के माध्यम से एक **संख्यात्मक वेक्टर** (एम्बेडिंग) में बदला जाता है। ये वेक्टर टेक्स्ट के सिमेंटिक अर्थ को कैप्चर करते हैं: समान अर्थ वाले वाक्यों के वेक्टर बहुआयामी स्थान में पास होंगे।

62#### 4. वेक्टर स्टोर

64वेक्टर ChromaDB, Pinecone, Weaviate या FAISS जैसे **वेक्टर स्टोर** (वेक्टर डेटाबेस) में सहेजे जाते हैं। यह डेटाबेस **समानता खोज** के लिए अनुकूलित है: एक क्वेरी दिए जाने पर, यह सबसे समान वेक्टर (और इसलिए सबसे प्रासंगिक टेक्स्ट चंक्स) खोजता है।

66### चरण 2: रिट्रीवल + जनरेशन

68जब उपयोगकर्ता प्रश्न पूछता है:

701. प्रश्न को उसी एम्बेडिंग मॉडल का उपयोग करके एम्बेडिंग में बदला जाता है।

712. वेक्टर स्टोर **समानता खोज** (आमतौर पर कोसाइन समानता या यूक्लिडियन दूरी) के माध्यम से सबसे समान चंक्स खोजता है।

723. प्राप्त चंक्स को संदर्भ के रूप में प्रॉम्प्ट में डाला जाता है।

734. LLM प्रदान किए गए संदर्भ के आधार पर उत्तर उत्पन्न करता है।

75## LangChain के साथ RAG पाइपलाइन बनाना

77**LangChain** LLM-आधारित एप्लिकेशन बनाने के लिए सबसे लोकप्रिय Python (और JavaScript) फ्रेमवर्क है। यह RAG पाइपलाइन के प्रत्येक घटक के लिए उच्च-स्तरीय एब्स्ट्रैक्शन प्रदान करता है।

79### इंस्टॉलेशन

81```bash

82pip install langchain langchain-openai langchain-community chromadb

83```

85### स्टेप 1: दस्तावेज़ लोड करें

87LangChain विभिन्न डेटा स्रोतों के लिए दर्जनों डॉक्यूमेंट लोडर प्रदान करता है।

89```python

90from langchain_community.document_loaders import (

91 PyPDFLoader,

92 WebBaseLoader,

93 DirectoryLoader,

94 TextLoader,

95)

97# एक PDF लोड करें

98pdf_loader = PyPDFLoader("docs/manual.pdf")

99pdf_docs = pdf_loader.load()

100

101# एक वेब पेज लोड करें

102web_loader = WebBaseLoader("https://docs.example.com/guide")

103web_docs = web_loader.load()

104

105# एक डायरेक्टरी से सभी .md फाइलें लोड करें

106dir_loader = DirectoryLoader("./knowledge_base", glob="**/*.md", loader_cls=TextLoader)

107md_docs = dir_loader.load()

108

109all_docs = pdf_docs + web_docs + md_docs

110```

111

112### स्टेप 2: दस्तावेज़ों को चंक्स में विभाजित करें

113

114```python

115from langchain.text_splitter import RecursiveCharacterTextSplitter

116

117text_splitter = RecursiveCharacterTextSplitter(

118 chunk_size=1000,

119 chunk_overlap=200,

120 separators=["\n\n", "\n", ". ", " ", ""],

121)

122

123chunks = text_splitter.split_documents(all_docs)

124print(f"मूल दस्तावेज़: {len(all_docs)}, चंक्स: {len(chunks)}")

125```

126

127`chunk_overlap` पैरामीटर महत्वपूर्ण है: यह लगातार चंक्स के बीच ओवरलैप बनाता है ताकि सीमाओं पर संदर्भ न खोए।

128

129### स्टेप 3: एम्बेडिंग और वेक्टर स्टोर बनाएं

130

131```python

132from langchain_openai import OpenAIEmbeddings

133from langchain_community.vectorstores import Chroma

134

135embedding_model = OpenAIEmbeddings(model="text-embedding-3-small")

136

137vectorstore = Chroma.from_documents(

138 documents=chunks,

139 embedding=embedding_model,

140 persist_directory="./chroma_db",

141)

142```

143

144### स्टेप 4: रिट्रीवर बनाएं

145

146रिट्रीवर वह घटक है जो, एक क्वेरी दिए जाने पर, वेक्टर स्टोर से सबसे प्रासंगिक चंक्स प्राप्त करता है।

147

148```python

149retriever = vectorstore.as_retriever(

150 search_type="similarity",

151 search_kwargs={"k": 4},

152)

153

154relevant_docs = retriever.invoke("प्रमाणीकरण कैसे काम करता है?")

155for doc in relevant_docs:

156 print(doc.page_content[:200])

157 print("---")

158```

159

160### स्टेप 5: RAG चेन बनाएं

161

162अब सब कुछ एक LLM और प्रॉम्प्ट टेम्पलेट के साथ जोड़ते हैं।

163

164```python

165from langchain_openai import ChatOpenAI

166from langchain_core.prompts import ChatPromptTemplate

167from langchain_core.runnables import RunnablePassthrough

168from langchain_core.output_parsers import StrOutputParser

169

170llm = ChatOpenAI(model="gpt-4o", temperature=0)

171

172prompt = ChatPromptTemplate.from_template("""

173केवल प्रदान किए गए संदर्भ के आधार पर प्रश्न का उत्तर दें।

174यदि संदर्भ में पर्याप्त जानकारी नहीं है, तो कहें कि आप नहीं जानते।

175

176संदर्भ:

177{context}

178

179प्रश्न: {question}

180

181उत्तर:

182""")

183

184def format_docs(docs):

185 return "\n\n".join(doc.page_content for doc in docs)

186

187rag_chain = (

188 {"context": retriever | format_docs, "question": RunnablePassthrough()}

189 | prompt

190 | llm

191 | StrOutputParser()

192)

193

194response = rag_chain.invoke("सिस्टम में प्रमाणीकरण कैसे काम करता है?")

195print(response)

196```

197

198## उन्नत RAG तकनीकें

199

200बुनियादी पाइपलाइन अच्छी तरह काम करती है, लेकिन उत्तर की गुणवत्ता में उल्लेखनीय सुधार करने के लिए कई तकनीकें हैं।

201

202### मल्टी-क्वेरी रिट्रीवल

203

204कभी-कभी उपयोगकर्ता की क्वेरी अस्पष्ट होती है या दस्तावेज़ों में प्रयुक्त भाषा से मेल नहीं खाती। **मल्टी-क्वेरी रिट्रीवर** कई दृष्टिकोणों को कैप्चर करने के लिए मूल प्रश्न के वेरिएंट स्वचालित रूप से उत्पन्न करता है।

205

206```python

207from langchain.retrievers import MultiQueryRetriever

208

209multi_retriever = MultiQueryRetriever.from_llm(

210 retriever=vectorstore.as_retriever(),

211 llm=llm,

212)

213

214docs = multi_retriever.invoke("सुरक्षा की सर्वोत्तम प्रथाएं क्या हैं?")

215```

216

217### कॉन्टेक्स्चुअल कम्प्रेशन

218

219चंक की सारी सामग्री क्वेरी के लिए प्रासंगिक नहीं होती। **कॉन्टेक्स्चुअल कम्प्रेशन रिट्रीवर** प्रत्येक प्राप्त चंक से केवल प्रासंगिक भागों को निकालने के लिए LLM का उपयोग करता है।

220

221```python

222from langchain.retrievers import ContextualCompressionRetriever

223from langchain.retrievers.document_compressors import LLMChainExtractor

224

225compressor = LLMChainExtractor.from_llm(llm)

226compression_retriever = ContextualCompressionRetriever(

227 base_compressor=compressor,

228 base_retriever=retriever,

229)

230```

231

232### हाइब्रिड सर्च

233

234शुद्ध सिमेंटिक खोज हमेशा इष्टतम नहीं होती। **हाइब्रिड सर्च** बेहतर परिणाम प्राप्त करने के लिए सिमेंटिक खोज (एम्बेडिंग) को लेक्सिकल खोज (BM25, कीवर्ड मैचिंग) के साथ जोड़ती है।

235

236```python

237from langchain.retrievers import EnsembleRetriever

238from langchain_community.retrievers import BM25Retriever

239

240bm25_retriever = BM25Retriever.from_documents(chunks)

241bm25_retriever.k = 4

242

243semantic_retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

244

245hybrid_retriever = EnsembleRetriever(

246 retrievers=[bm25_retriever, semantic_retriever],

247 weights=[0.4, 0.6],

248)

249```

250

251### कन्वर्सेशनल RAG (मेमोरी के साथ)

252

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

254

255```python

256from langchain.chains import create_history_aware_retriever

257from langchain_core.prompts import MessagesPlaceholder

258

259contextualize_prompt = ChatPromptTemplate.from_messages([

260 ("system", "चैट इतिहास और उपयोगकर्ता के नवीनतम प्रश्न को देखते हुए, "

261 "प्रश्न को इस तरह पुनर्निर्मित करें कि यह इतिहास के बिना भी समझ में आए।"),

262 MessagesPlaceholder("chat_history"),

263 ("human", "{input}"),

264])

265

266history_aware_retriever = create_history_aware_retriever(

267 llm, retriever, contextualize_prompt

268)

269```

270

271## सर्वोत्तम प्रथाएं

272

2731. **सही चंक आकार चुनें**: विभिन्न आकारों (500-1500 टोकन) के साथ प्रयोग करें। सटीक उत्तरों के लिए छोटे चंक्स, व्यापक संदर्भ के लिए बड़े चंक्स।

2742. **दस्तावेज़ मेटाडेटा का उपयोग करें**: स्रोत, तिथि और श्रेणी को चंक्स में मेटाडेटा के रूप में जोड़ें। यह रिट्रीवल के दौरान परिणामों को फिल्टर करने की अनुमति देता है।

2753. **गुणवत्ता का मूल्यांकन करें**: *faithfulness*, *relevancy* और *context precision* जैसे मेट्रिक्स मापने के लिए [RAGAS](https://docs.ragas.io/) जैसे फ्रेमवर्क का उपयोग करें।

2764. **दस्तावेज़ अपडेट प्रबंधित करें**: वेक्टर स्टोर को अपने डेटा स्रोतों के साथ सिंक्रनाइज़ रखने के लिए री-इंजेशन पाइपलाइन लागू करें।

2775. **री-रैंकर जोड़ें**: प्रारंभिक रिट्रीवल के बाद, वास्तविक प्रासंगिकता के आधार पर परिणामों को पुनर्क्रमित करने के लिए री-रैंकिंग मॉडल (जैसे Cohere Rerank) का उपयोग करें।

278

279## निष्कर्ष

280

281RAG विशिष्ट, अद्यतन ज्ञान तक पहुँच की आवश्यकता वाले AI एप्लिकेशन बनाने के लिए मानक आर्किटेक्चर बन गई है। LangChain पाइपलाइन के प्रत्येक घटक के लिए एब्स्ट्रैक्शन प्रदान करके कार्यान्वयन को बहुत सरल बनाता है।

282

283**अगले कदम:**

284- **स्थानीय रूप से प्रयोग करें**: पाइपलाइन से परिचित होने के लिए ChromaDB और कुछ दस्तावेज़ों से शुरू करें।

285- **LangSmith का अन्वेषण करें**: प्रोडक्शन में अपनी चेन की निगरानी और डिबगिंग के लिए [LangSmith](https://smith.langchain.com/) का उपयोग करें।

286- **विभिन्न एम्बेडिंग मॉडल आज़माएं**: `text-embedding-3-small`, `text-embedding-3-large` और Sentence Transformers के ओपन-सोर्स मॉडल की तुलना करें।

287- **दस्तावेज़ देखें**: [LangChain दस्तावेज़](https://python.langchain.com/docs/) एक उत्कृष्ट और लगातार अपडेट होने वाला संसाधन है।

288