Claude का उपयोग करके RAG सिस्टम कैसे बनाएं: एक AI जो आपके अपने डेटा पर चलता है (पूर्ण गाइड)

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

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

यह फ़ाइलों को सीधे चैट में पेस्ट करने से बेहतर क्यों है:

यह स्केल करता है। आपकी पूरी नॉलेज बेस एक चैट में फ़िट नहीं होगी। RAG सब कुछ स्टोर करता है और केवल वही खींचता है जो प्रत्येक प्रश्न को चाहिए।

यह सस्ता है। फ़ाइल पेस्ट करने का मतलब है कि Claude हर एक प्रश्न पर पूरी चीज़ को दोबारा पढ़ता है। RAG इसे एक बार पढ़ता है, फिर केवल प्रासंगिक भाग लाता है। हर बार 10,000-टोकन का मैनुअल भेजने के बजाय, यह आपकी ज़रूरत के सटीक सेक्शन के 500 टोकन भेज सकता है। वास्तविक सेटअप में टोकन उपयोग 80% या उससे अधिक कम हो जाता है।

यह अधिक सटीक है। मॉडल को टेक्स्ट का एक बहुत बड़ा ब्लॉक दें और वह बीच में विवरण खो देता है। उसे कुछ सटीक हिस्से दें और उत्तर अधिक सटीक हो जाते हैं।

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

इस गाइड के अंत तक, आपके पास अपनी फ़ाइलों पर चलने वाला एक सिस्टम होगा, कदम दर कदम, किसी PhD की ज़रूरत नहीं।

आपको क्या चाहिए होगा

इससे पहले कि हम कोई कोड छूएँ, यहाँ पूरी लिस्ट है। अच्छी खबर: इस वर्शन के लिए सिर्फ़ एक API की ज़रूरत है, और बाकी सब कुछ आपकी अपनी मशीन पर मुफ़्त चलता है।

1. Python 3.9 या उससे नया। यह जाँचने के लिए कि आपके पास है या नहीं, अपना टर्मिनल खोलें (Mac पर Terminal, Windows पर Command Prompt) और टाइप करें python --version। अगर आपको 3.11 जैसा कुछ दिखता है, तो आप ठीक हैं। यदि नहीं, तो इसे python.org से डाउनलोड करें और इंस्टॉलर चलाएँ। Windows पर, सेटअप के दौरान "Add Python to PATH" बॉक्स को टिक करें, अन्यथा नीचे दिए गए कमांड काम नहीं करेंगे।

2. एक Claude API कुंजी, साथ ही एक छोटी क्रेडिट बैलेंस। पूरे गाइड के लिए यही एकमात्र कुंजी और एकमात्र पैसा है। यहाँ सटीक पथ है, क्लिक दर क्लिक:

platform.claude.com पर जाएँ, और वहाँ लॉग इन (या साइन अप) करें।

API को चलने के लिए सकारात्मक बैलेंस की आवश्यकता है, इसलिए पहले फंड जोड़ें। जब संकेत दिया जाए, तो चुनें कि क्रेडिट आपके लिए हैं या किसी कंपनी के लिए, फिर आप भुगतान स्क्रीन पर पहुँच जाते हैं। $5 "Starting out" विकल्प चुनें। यह बहुत है: इस गाइड में बाकी सब कुछ मुफ़्त और स्थानीय है, इसलिए Claude ही एकमात्र ऐसी चीज़ है जिसमें पैसा खर्च होता है, और प्रत्येक प्रश्न पर आपको एक सेंट का एक अंश खर्च होता है। क्रेडिट खरीद के एक साल बाद समाप्त हो जाते हैं।

भुगतान करने के बाद, आप अपने Console डैशबोर्ड पर पहुँच जाएँगे। आपको अपनी बैलेंस (उदाहरण के लिए $5.00) ऊपर बाईं ओर "Organization credits" के नीचे दिखनी चाहिए।

अब कुंजी लें। Get API key (ऊपर दाईं ओर) पर क्लिक करें, फिर Create Key पर क्लिक करें। इसे अपनी पसंद का कोई भी नाम दें (उदाहरण के लिए my-rag-key) और वर्कस्पेस को Default पर छोड़ दें। क्रिएट पर क्लिक करें, फिर यह जो स्ट्रिंग दिखाता है उसे कॉपी करें। यह sk-ant- से शुरू होता है और आप इसे केवल एक बार देखते हैं, इसलिए इसे एक मिनट के लिए कहीं सुरक्षित पेस्ट करें।

यह पूरा सेटअप है।

चरण 1: अपनी कुंजी जोड़ें और अपनी फ़ाइलें लोड करें

1. प्रोजेक्ट फ़ोल्डर बनाएँ। अपने डेस्कटॉप पर एक नया फ़ोल्डर बनाएँ और उसका नाम rag-project रखें। सब कुछ यहीं जाएगा।

2. अपना टर्मिनल खोलें। Mac पर: Cmd+Space, टाइप करें Terminal, एंटर दबाएँ। Windows पर: Start बटन, टाइप करें cmd, एंटर दबाएँ।

3. टर्मिनल को अपने फ़ोल्डर पर पॉइंट करें। cd और एक स्पेस टाइप करें, फिर rag-project फ़ोल्डर को टर्मिनल विंडो पर खींचें और एंटर दबाएँ। नीचे दिए गए प्रत्येक कमांड को इस फ़ोल्डर के अंदर से चलाया जाता है।

1cd Desktop/rag-project

4. टूल्स इंस्टॉल करें। इसे अपने टर्मिनल में पेस्ट करें और एंटर दबाएँ (पहली बार चलने में एक मिनट लग सकता है):

1pip install anthropic chromadb sentence-transformers pypdf python-dotenv

अगर आपको pip: command not found मिलता है, तो pip के बजाय pip3 का उपयोग करें। जब टर्मिनल बिना किसी लाल एरर के एक नई लाइन दिखाता है, तो यह हो गया है।

5. अपनी कोड फ़ाइल बनाएँ। rag-project के अंदर, rag.py नाम की एक खाली फ़ाइल बनाएँ। इसे किसी भी टेक्स्ट एडिटर में खोलें।

6. अपनी कुंजी फ़ाइल बनाएँ। उसी फ़ोल्डर में, .env (एक डॉट से शुरू होता है, उसके पहले कोई नाम नहीं) नाम की एक फ़ाइल बनाएँ। इसके अंदर, सेटअप के दौरान बनाई गई वास्तविक कुंजी को = के बाद पेस्ट करें, बिना स्पेस, बिना कोट्स के:

1ANTHROPIC_API_KEY=sk-ant-paste-your-real-key-here

कुंजी को अपने कोड के बजाय .env में रखने का मतलब है कि अगर आप स्क्रिप्ट साझा करते हैं या इसे GitHub पर डालते हैं तो यह लीक नहीं होगी।

7. कुंजी लोड करें। इसे rag.py के शीर्ष पर रखें:

1import os
2from dotenv import load_dotenv
3
4load_dotenv()  # आपकी .env फ़ाइल पढ़ता है
5api_key = os.getenv("ANTHROPIC_API_KEY")

8. अपना नॉलेज बेस बनाएँ। rag-project के अंदर, documents नाम का एक फ़ोल्डर बनाएँ। वहाँ कोई भी .txt, .md, या .pdf फ़ाइल डालें: आपके नोट्स, एक प्रोडक्ट डॉक, मीटिंग सारांश, कुछ भी।

8.1. अगर आपके पास अभी तक फ़ाइलें नहीं हैं तो इस टेस्ट फ़ाइल का उपयोग करें। documents फ़ोल्डर के अंदर notes.txt बनाएँ और इसमें यह पेस्ट करें:

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

अंत में आप Claude से नॉर्थस्टार के बारे में पूछेंगे और इसे इसी फ़ाइल से उत्तर देते हुए देखेंगे।

9. वह कोड जोड़ें जो आपकी फ़ाइलों को पढ़ता है। चरण 7 के कोड के नीचे, rag.py में:

1from pathlib import Path
2from pypdf import PdfReader
3
4def load_documents(folder="documents"):
5    docs = []
6    for file in Path(folder).iterdir():
7        if file.suffix in [".txt", ".md"]:
8            text = file.read_text(encoding="utf-8")
9            docs.append({"source": file.name, "text": text})
10        elif file.suffix == ".pdf":
11            reader = PdfReader(str(file))
12            text = "\n".join(page.extract_text() or "" for page in reader.pages)
13            docs.append({"source": file.name, "text": text})
14    return docs
15
16documents = load_documents()
17print(f"लोड किए गए {len(documents)} दस्तावेज़.")

10. इसे चलाएँ। rag.py को सेव करें, फिर अपने टर्मिनल में:

1python rag.py

आपको यह देखना चाहिए:

लोड किया गया 1 दस्तावेज़

अगर आपको "लोड किए गए 0 दस्तावेज़" दिखता है, तो documents फ़ोल्डर खाली है या गलत जगह पर है। इसे सीधे rag-project के अंदर, rag.py के बगल में होना चाहिए।

चरण 2: अपनी फ़ाइलों को टुकड़ों में विभाजित करें

अभी हर फ़ाइल टेक्स्ट का एक बड़ा ब्लॉक है। इसे खोजने से पहले, हमें इसे chucks नामक छोटे टुकड़ों में काटने की ज़रूरत है। यहाँ कारण है: जब कोई प्रश्न पूछता है, तो सिस्टम मेल खाने वाले टुकड़ों को ढूँढता है और केवल उन्हें Claude को भेजता है। यदि आपके टुकड़े पूरे 50-पृष्ठ के दस्तावेज़ हैं, तो आप बहुत अधिक भेजते हैं। यदि वे एकल वाक्य हैं, तो वे संदर्भ खो देते हैं। छोटे पैराग्राफ सबसे अच्छे होते हैं।

1. चंकिंग कोड जोड़ें। चरण 10 के कोड के नीचे, rag.py में:

1def chunk_text(text, chunk_size=500, overlap=100):
2    words = text.split()
3    chunks = []
4    start = 0
5    while start < len(words):
6        end = start + chunk_size
7        chunk = " ".join(words[start:end])
8        chunks.append(chunk)
9        start = end - overlap  # थोड़ा पीछे हटें ताकि टुकड़े ओवरलैप हों
10    return chunks

यहाँ दो संख्याएँ समझने के लिए हैं, सरल शब्दों में:

• chunk_size=500 का मतलब है कि प्रत्येक टुकड़ा लगभग 500 शब्दों का है। एक पूर्ण विचार रखने के लिए काफी बड़ा, सटीक रहने के लिए काफी छोटा।
• overlap=100 का मतलब है कि प्रत्येक टुकड़ा अपने पिछले वाले के अंतिम 100 शब्दों को दोहराता है। यह मायने रखता है क्योंकि एक उत्तर ठीक उस रेखा पर हो सकता है जहाँ दो टुकड़े मिलते हैं। ओवरलैप के बिना, बीच में विभाजित एक वाक्य खो सकता है। ओवरलैप यह सुनिश्चित करता है कि कोई भी विचार दरार से न गिरे।

2. हर दस्तावेज़ को टुकड़ों में बदलें। इसे नीचे जोड़ें:

1all_chunks = []
2for doc in documents:
3    for chunk in chunk_text(doc["text"]):
4        all_chunks.append({"source": doc["source"], "text": chunk})
5
6print(f"{len(documents)} दस्तावेज़(ों) से {len(all_chunks)} टुकड़ा(ड़े) बनाए गए।")

ध्यान दें कि प्रत्येक टुकड़ा अपना source (वह फ़ाइल नाम जहाँ से आया है) रखता है। हम इसे पूरे रास्ते संलग्न रखते हैं, ताकि जब Claude बाद में उत्तर दे, तो वह आपको बता सके कि उत्तर किस फ़ाइल से आया है।

3. इसे चलाएँ। rag.py को सेव करें, फिर अपने टर्मिनल में:

1python rag.py

आपको कुछ ऐसा देखना चाहिए:

लोड किया गया 1 दस्तावेज़।

1 दस्तावेज़(ों) से 1 टुकड़ा(ड़े) बनाए गए।

छोटी टेस्ट फ़ाइल सिर्फ़ एक टुकड़ा बन जाती है क्योंकि वह छोटी है। वास्तविक दस्तावेज़ कई बनाएँगे। यदि आपने फ़ोल्डर में एक लंबी PDF डाली है, तो आपको दर्जनों या सैकड़ों टुकड़े दिख सकते हैं, जो कि बिल्कुल वही है जो आप चाहते हैं।

चरण 3: अपने टुकड़ों को embeddings में बदलें

यह वह कदम है जो कंप्यूटर को सटीक शब्दों के बजाय अर्थ के आधार पर खोज करने देता है। प्रत्येक टुकड़ा संख्याओं की एक सूची (एक embedding) में परिवर्तित हो जाता है जो यह दर्शाता है कि वह किस बारे में है। समान अर्थ वाले टुकड़े समान संख्याओं के साथ समाप्त होते हैं। बाद में, जब कोई प्रश्न आता है, तो हम प्रश्न को भी संख्याओं में बदलते हैं और निकटतम मिलान ढूँढते हैं।

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

1. एम्बेडिंग मॉडल लोड करें। चरण 2 के कोड के नीचे, rag.py में:

1from sentence_transformers import SentenceTransformer
2
3print("एम्बेडिंग मॉडल लोड हो रहा है (पहली बार चलने पर यह डाउनलोड होता है, लगभग 90 MB)...")
4embedder = SentenceTransformer("all-MiniLM-L6-v2")

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

2. हर टुकड़े को एक embedding में बदलें। इसे नीचे जोड़ें:

1chunk_texts = [chunk["text"] for chunk in all_chunks]
2embeddings = embedder.encode(chunk_texts)
3
4print(f"बनाए गए {len(embeddings)} embedding(ings).")
5print(f"प्रत्येक embedding {len(embeddings[0])} संख्याओं की एक सूची है।")

embedder.encode(...) आपके टुकड़ों के टेक्स्ट की सूची लेता है और प्रति टुकड़ा एक embedding वापस देता है। बस इतना ही।

3. इसे चलाएँ। rag.py को सेव करें, फिर अपने टर्मिनल में:

1python rag.py

पहला रन मॉडल के डाउनलोड होने के दौरान रुकता है, फिर आपको कुछ ऐसा दिखना चाहिए:

लोड किया गया 1 दस्तावेज़।

1 दस्तावेज़(ों) से 1 टुकड़ा(ड़े) बनाए गए।

एम्बेडिंग मॉडल लोड हो रहा है (पहली बार चलने पर यह डाउनलोड होता है, लगभग 90 MB)...

बनाए गए 1 embedding(ings).

प्रत्येक embedding 384 संख्याओं की एक सूची है।

वह "384 संख्याएँ" वाली पंक्ति पूरे विचार को दृश्यमान बनाती है: आपका टेक्स्ट अब संख्याओं की एक पंक्ति है जिसकी कंप्यूटर तुलना कर सकता है। आपको उन संख्याओं को स्वयं पढ़ने या समझने की ज़रूरत नहीं है। अगले चरण में डेटाबेस आपके लिए सभी तुलना संभालता है।

यदि कनेक्शन त्रुटि के साथ डाउनलोड विफल होता है, तो कमांड फिर से चलाएँ। यह वहीं से उठाता है जहाँ छोड़ा था।

चरण 4: अपने वेक्टर डेटाबेस में सब कुछ स्टोर करें

अब हम टुकड़ों और उनके embeddings को Chroma में डालते हैं, जो आपका स्थानीय डेटाबेस है। यही खोज को तेज़ बनाता है: हर बार अपने प्रश्न की हर टुकड़े से मैन्युअल रूप से तुलना करने के बजाय, Chroma उन्हें उपयोग के लिए तैयार रखता है और आपके लिए मिलान करता है। यह आपकी मशीन पर एक फ़ोल्डर में सहेजता है, इसलिए आप इसे केवल एक बार बनाते हैं।

1. डेटाबेस सेट करें। चरण 3 के कोड के नीचे, rag.py में:

1import chromadb
2
3client = chromadb.PersistentClient(path="chroma_db")
4collection = client.get_or_create_collection("my_documents")

PersistentClient(path="chroma_db") Chroma को बताता है कि chroma_db नामक फ़ोल्डर में सेव करना है (यह इसे स्वचालित रूप से बनाता है, आपकी स्क्रिप्ट के ठीक बगल में)। क्योंकि यह डिस्क पर सहेजा जाता है, स्क्रिप्ट समाप्त होने के बाद आपका डेटा बच जाता है। एक collection सिर्फ़ एक नामित बॉक्स है जिसमें आपके टुकड़े रहते हैं।

2. अपने टुकड़ों को डेटाबेस में जोड़ें। इसे नीचे जोड़ें:

1collection.add(
2    ids=[str(i) for i in range(len(all_chunks))],
3    embeddings=[emb.tolist() for emb in embeddings],
4    documents=[chunk["text"] for chunk in all_chunks],
5    metadatas=[{"source": chunk["source"]} for chunk in all_chunks],
6)
7
8print(f"डेटाबेस में {collection.count()} टुकड़ा(ड़े) संग्रहीत किए गए।")

यहाँ बताया गया है कि प्रत्येक पंक्ति Chroma को क्या देती है, सरल शब्दों में: ids प्रत्येक टुकड़े को एक अद्वितीय लेबल देता है (0, 1, 2...), embeddings चरण 3 की संख्याएँ हैं, documents वास्तविक टुकड़ा टेक्स्ट है, और metadatas स्रोत दिखाने में सक्षम होने के लिए फ़ाइल नाम ले जाता है। Chroma चारों को एक साथ बाँध कर रखता है।

3. इसे चलाएँ। rag.py को सेव करें, फिर अपने टर्मिनल में:

1python rag.py

आपको यह दिखना चाहिए:

डेटाबेस में 1 टुकड़ा(ड़े) संग्रहीत किए गए।

बाद में जानने के लिए एक बात। हर बार जब आप अभी स्क्रिप्ट चलाते हैं, तो यह टुकड़ों को फिर से जोड़ता है, इसलिए बार-बार चलाने पर गिनती बढ़ सकती है (1, फिर 2, फिर 3...)। जब हम निर्माण कर रहे हैं तब यह ठीक है। साफ़ शुरू करने के लिए, chroma_db फ़ोल्डर को हटाएँ और एक बार फिर से चलाएँ। अंतिम संस्करण में हम इसे ठीक से संभालेंगे ताकि यह दोगुना न हो।

चरण 5: अपने दस्तावेज़ खोजें

यह RAG का "रिट्रीवल" भाग है, नाम में R। हम एक प्रश्न लेते हैं, इसे उसी तरह एक embedding में बदलते हैं जैसे हमने टुकड़ों के साथ किया था, और Chroma से उन टुकड़ों के लिए पूछते हैं जिनका अर्थ सबसे करीब है। वे मिलान करने वाले टुकड़े वही हैं जो हम अगले चरण में Claude को देंगे।

1. खोज फ़ंक्शन जोड़ें। चरण 4 के कोड के नीचे, rag.py में:

1def search(question, n_results=3):
2    question_embedding = embedder.encode([question])[0]
3    results = collection.query(
4        query_embeddings=[question_embedding.tolist()],
5        n_results=n_results,
6    )
7    return results

यह क्या करता है, सरल शब्दों में लाइन दर लाइन: यह प्रश्न को उसी मॉडल से संख्याओं में बदलता है जिसका उपयोग आपने अपने टुकड़ों पर किया था (यह महत्वपूर्ण है, दोनों को एक ही "संख्या भाषा" बोलनी चाहिए), फिर निकटतम मिलान के लिए Chroma से पूछता है। n_results=3 का मतलब है "मुझे 3 सबसे प्रासंगिक टुकड़े दें।" तीन एक अच्छा डिफ़ॉल्ट है: पर्याप्त संदर्भ, इतना नहीं कि आप टोकन बर्बाद करें।

2. एक खोज आज़माएँ। इसे परीक्षण करने के लिए नीचे जोड़ें:

1question = "नॉर्थस्टार कौन चलाता है और प्रतिक्रिया की समीक्षा कब होती है?"
2results = search(question)
3
4for i, doc in enumerate(results["documents"][0]):
5    source = results["metadatas"][0][i]["source"]
6    print(f"\n--- मिलान {i+1} ({source} से) ---")
7    print(doc)

यह आपके डेटाबेस के विरुद्ध एक वास्तविक प्रश्न चलाता है और मिले टुकड़ों को प्रिंट करता है, प्रत्येक उस फ़ाइल नाम के साथ जहाँ से आया है।

3. इसे चलाएँ। rag.py को सेव करें, फिर अपने टर्मिनल में:

1python rag.py

नॉर्थस्टार टेस्ट फ़ाइल के साथ, आपको इसे मिलान करने वाला टुकड़ा वापस लाते हुए देखना चाहिए, कुछ इस तरह:

--- मिलान 1 (notes.txt से) ---

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

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

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

चरण 6: Claude को जो मिला है उससे उत्तर देने को कहें

यह "जनरेशन" भाग है, RAG में G। हम चरण 5 के टुकड़ों को लेते हैं, उन्हें प्रश्न के साथ Claude Opus 4.8 को देते हैं, और इसे केवल उसी संदर्भ का उपयोग करके उत्तर देने के लिए कहते हैं। यही इसे अनुमान लगाने से रोकता है: Claude आपकी फ़ाइलों से उत्तर देता है, अपनी याददाश्त से नहीं, और आपको बताता है कि उसने किस फ़ाइल का उपयोग किया।

1. उत्तर फ़ंक्शन जोड़ें। चरण 5 के कोड के नीचे, rag.py में:

1import anthropic
2
3claude = anthropic.Anthropic(api_key=api_key)
4
5def answer(question):
6    results = search(question)
7    chunks = results["documents"][0]
8    sources = [m["source"] for m in results["metadatas"][0]]
9
10    context = ""
11    for i, chunk in enumerate(chunks):
12        context += f"[{sources[i]} से]\n{chunk}\n\n"
13
14    message = claude.messages.create(
15        model="claude-opus-4-8",
16        max_tokens=1024,
17        system=(
18            "आप केवल प्रदान किए गए संदर्भ का उपयोग करके प्रश्नों के उत्तर देते हैं। "
19            "यदि उत्तर संदर्भ में नहीं है, तो कहें कि आप नहीं जानते। "
20            "हमेशा उल्लेख करें कि आपका उत्तर किस फ़ाइल से आया है।"
21        ),
22        messages=[
23            {
24                "role": "user",
25                "content": f"संदर्भ:\n{context}\nप्रश्न: {question}",
26            }
27        ],
28    )
29    return message.content[0].text

यहाँ क्या हो रहा है, सरल शब्दों में: हम प्रासंगिक टुकड़ों की खोज करते हैं, उन्हें एक context ब्लॉक में एक साथ जोड़ते हैं (प्रत्येक अपने फ़ाइल नाम के साथ लेबल किया गया है), फिर उस ब्लॉक को प्रश्न के साथ Claude को भेजते हैं। system निर्देश मुख्य भाग है। यह Claude को तीन बातें बताता है: केवल संदर्भ से उत्तर दें, स्वीकार करें जब उत्तर मौजूद न हो, और स्रोत फ़ाइल का नाम बताएं। ये तीन नियम ही उत्तरों को गढ़े जाने के बजाय भरोसेमंद बनाते हैं।

model="claude-opus-4-8" सटीक मॉडल नाम है (डैश, डॉट नहीं)। max_tokens=1024 उत्तर की लंबाई को सीमित करता है।

2. एक प्रश्न पूछें। इसे नीचे जोड़ें:

1question = "नॉर्थस्टार कौन चलाता है और प्रतिक्रिया की समीक्षा कब होती है?"
2print(answer(question))

3. इसे चलाएँ। rag.py को सेव करें, फिर अपने टर्मिनल में:

1python rag.py

आपको आपकी फ़ाइल से निर्मित एक वास्तविक उत्तर मिलना चाहिए, कुछ इस तरह:

डाना रेयेस लीड इंजीनियर हैं जो प्रोजेक्ट नॉर्थस्टार चलाती हैं, और प्रतिक्रिया की हर शुक्रवार को समीक्षा की जाती है। (स्रोत: notes.txt)

यह एक पूर्ण RAG सिस्टम काम कर रहा है। Claude ने प्रशिक्षण के दौरान इस फ़ाइल को कभी नहीं देखा, वह नहीं जान सकता कि डाना रेयेस कौन हैं, फिर भी इसने सही उत्तर दिया और आपको ठीक-ठीक बताया कि उत्तर कहाँ से आया। इसे कुछ ऐसा पूछें जो आपकी फ़ाइलों में नहीं है और यह कहेगा कि वह नहीं जानता, उत्तर गढ़ने के बजाय। वह "मैं नहीं जानता" एक विशेषता है, विफलता नहीं: यह एक ऐसे टूल के बीच का अंतर है जिस पर आप भरोसा कर सकते हैं और जो अनुमान लगाता है।

चरण 7: इसे किसी ऐसी चीज़ में बदलें जिसका आप वास्तव में उपयोग कर सकते हैं

अभी आपको हर बार कुछ पूछने पर कोड को संपादित करना होगा और पूरी स्क्रिप्ट को फिर से चलाना होगा। इससे भी बदतर, हर रन आपकी फ़ाइलों को फिर से पढ़ता है और उन्हें डेटाबेस में फिर से जोड़ता है, इसलिए टुकड़े जमा होते जाते हैं। आइए दोनों को ठीक करें: डेटाबेस को केवल एक बार बनाएँ, फिर आपको एक लूप पर प्रश्न पूछने दें, उन्हें सीधे टर्मिनल में टाइप करें।

1. डबल-एडिंग को ठीक करें। चरण 4 के उस ब्लॉक को ढूँढें जो टुकड़े जोड़ता है ( collection.add(...) भाग) और इसे इस संस्करण से बदलें, जो केवल डेटाबेस बनाता है यदि वह खाली है:

1if collection.count() == 0:
2    collection.add(
3        ids=[str(i) for i in range(len(all_chunks))],
4        embeddings=[emb.tolist() for emb in embeddings],
5        documents=[chunk["text"] for chunk in all_chunks],
6        metadatas=[{"source": chunk["source"]} for chunk in all_chunks],
7    )
8    print(f"डेटाबेस में {collection.count()} टुकड़ा(ड़े) संग्रहीत किए गए।")
9else:
10    print(f"डेटाबेस में पहले से ही {collection.count()} टुकड़ा(ड़े) हैं, पुनर्निर्माण छोड़ दिया गया।")

अब भारी काम (फ़ाइलें पढ़ना, embeddings बनाना, डेटाबेस भरना) केवल पहली बार होता है। बाद के रन सीधे उत्तर देने पर जाते हैं।

2. प्रश्न लूप जोड़ें। rag.py के बिल्कुल नीचे, चरण 6 के एकल परीक्षण प्रश्न को इससे बदलें:

1print("\nअपने दस्तावेज़ों के बारे में एक प्रश्न पूछें (या बाहर निकलने के लिए 'quit' टाइप करें)।\n")
2
3while True:
4    question = input("आप: ")
5    if question.lower() in ["quit", "exit"]:
6        break
7    print("\nClaude: " + answer(question) + "\n")

input("आप: ") आपके द्वारा एक प्रश्न टाइप करने और एंटर दबाने की प्रतीक्षा करता है। while True इसे जारी रखता है ताकि आप जितने चाहें उतने पूछ सकें। quit टाइप करने से यह रुक जाता है।

3. इसे चलाएँ। rag.py को सेव करें, फिर अपने टर्मिनल में:

1python rag.py

अब आप बस अपनी फ़ाइलों से बात कर सकते हैं:

अपने दस्तावेज़ों के बारे में एक प्रश्न पूछें (या बाहर निकलने के लिए 'quit' टाइप करें)।

आप: नॉर्थस्टार पर लीड इंजीनियर कौन है?

Claude: प्रोजेक्ट नॉर्थस्टार पर लीड इंजीनियर डाना रेयेस हैं। (स्रोत: notes.txt)

आप: इसने किसे बदला?

Claude: नॉर्थस्टार ने पुरानी स्प्रेडशीट प्रणाली को बदल दिया जिसका उपयोग 2025 तक किया जा रहा था। (स्रोत: notes.txt)

आप: quit

यह आपकी तैयार RAG प्रणाली है। यह आपकी फ़ाइलों को एक बार पढ़ता है, उन्हें याद रखता है, और मांग पर उनके बारे में प्रश्नों के उत्तर देता है, हर बार स्रोत के साथ।

जब आप नई फ़ाइलें जोड़ते हैं तो जानने के लिए एक बात। क्योंकि डेटाबेस अब केवल एक बार बनता है, documents में नई फ़ाइलें डालने पर वे स्वचालित रूप से दिखाई नहीं देंगी। नई फ़ाइलें लोड करने के लिए, chroma_db फ़ोल्डर को हटाएँ और स्क्रिप्ट को एक बार चलाएँ। यह फ़ोल्डर में सब कुछ के साथ खरोंच से पुनर्निर्माण करता है।

वैकल्पिक: इसे अपने ब्राउज़र में एक चैट विंडो दें

टर्मिनल काम करता है, लेकिन यदि आप एक वास्तविक चैट विंडो चाहते हैं, तो Streamlit लगभग 20 लाइनों में एक जोड़ता है।

1. इसे इंस्टॉल करें। अपने टर्मिनल में:

1pip install streamlit

2. उसी फ़ोल्डर में app.py बनाएँ और इसमें यह पेस्ट करें। यह आपके rag.py से उत्तर फ़ंक्शन का पुन: उपयोग करता है:

1import streamlit as st
2from rag import answer
3
4st.title("अपने दस्तावेज़ों से चैट करें")
5
6if "history" not in st.session_state:
7    st.session_state.history = []
8
9question = st.chat_input("अपनी फ़ाइलों के बारे में पूछें...")
10
11if question:
12    reply = answer(question)
13    st.session_state.history.append((question, reply))
14
15for q, a in st.session_state.history:
16    st.chat_message("user").write(q)
17    st.chat_message("assistant").write(a)

3. इसे चलाएँ। अपने टर्मिनल में (ध्यान दें: streamlit run, python नहीं):

1streamlit run app.py

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

एक नोट: इसके काम करने के लिए, चरण 7 के प्रश्न लूप को आयात पर नहीं चलना चाहिए। rag.py के निचले भाग में उस लूप को if __name__ == "__main__": में लपेटें ताकि यह केवल तब चले जब आप rag.py को सीधे चलाते हैं, न कि जब app.py इसे आयात करता है।

सामान्य प्रश्नों का भी उत्तर देने देना

यदि आप चाहते हैं कि यह सामान्य प्रश्नों का भी उत्तर दे। अभी सिस्टम केवल आपकी फ़ाइलों से उत्तर देता है, इसलिए "वेनेज़ुएला की राजधानी क्या है?" जैसे प्रश्न पर "यह दस्तावेज़ों में नहीं है" मिलता है, भले ही Claude उत्तर जानता हो। यदि आप चाहते हैं कि यह अपने स्वयं के ज्ञान पर वापस आए, तो rag.py खोलें, चरण 6 में system=(...) ब्लॉक ढूँढें, और इस पंक्ति को बदलें:

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

इसके लिए:

1"यदि उत्तर संदर्भ में नहीं है, तो अपने सामान्य ज्ञान से उत्तर दें, लेकिन बताएं कि आप ऐसा कर रहे हैं।"

सहेजें और पुनः चलाएँ। अब यह पहले आपकी फ़ाइलों से उत्तर देता है, और जब फ़ाइलें कवर नहीं करतीं, तो सामान्य ज्ञान का उपयोग करता है, और बताता है कि किसका उपयोग किया गया।

समापन

आपने अभी एक काम करने वाला RAG सिस्टम बनाया है। यह आपकी अपनी फ़ाइलों को पढ़ता है, प्रासंगिक भागों को ढूँढता है, और Claude से उनके आधार पर सटीक स्रोत के साथ उत्तर देता है। यही सेटअप कुछ नोट्स से लेकर आपके पूरे ज्ञानकोष तक स्केल करता है।

अब यह आपका है—इसे कहीं भी इंगित करें: आपका Obsidian vault, आपके काम के दस्तावेज़, आपकी सहेजी गई शोध सामग्री। फ़ाइलें डालें, एक बार फिर से बिल्ड करें, और पूछना शुरू करें। आपने यहाँ जो कुछ भी सीखा—चंक्स, एम्बेडिंग्स, सर्च, उत्तर—वही वह बुनियाद है जो हर "अपने दस्तावेज़ों से चैट करें" टूल के पीछे होती है।

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

अलविदा,

[@undefinedKi]([https://x.com/@undefinedKi](https://x.com/@undefinedKi))