बुनियादी RAG इम्प्लीमेंटेशन: चरण-दर-चरण ट्यूटोरियल

RAG आधुनिक LLM-आधारित इन्फ्रास्ट्रक्चर का एक अनिवार्य घटक है। AI मॉडल को बाहरी डेटा तक पहुँच देकर, यह हैलुसिनेशन और अधूरे ट्रेनिंग डेटा जैसी समस्याओं को दूर करने में मदद करता है। इसका यह भी मतलब है कि कंपनियाँ ऐसे आंतरिक नॉलेज बेस का उपयोग कर सकती हैं जिनमें संवेदनशील या मालिकाना जानकारी होती है।

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

इस लेख में, हम एक बुनियादी RAG इम्प्लीमेंटेशन की रूपरेखा तैयार करेंगे, सर्वोत्तम तरीकों पर चर्चा करेंगे, और फिर Python, ChromaDB और एम्बेडिंग व उत्तर जनरेशन के लिए दो Perplexity मॉडल का उपयोग करके एक कार्यशील सिस्टम बनाएँगे।

एक बुनियादी RAG सिस्टम के तीन मुख्य घटक होते हैं: एक ऑर्केस्ट्रेटर, एक सूचना स्रोत और एक LLM। एक सामान्य वर्कफ़्लो में, उपयोगकर्ता एक प्रॉम्प्ट दर्ज करता है, और ऑर्केस्ट्रेटर उसे संशोधित करके किसी भी जुड़े हुए सूचना स्रोत में खोज करता है। फिर प्राप्त की गई जानकारी को मूल इनपुट संदर्भ में जोड़कर LLM को भेजा जाता है, ताकि उत्तर जनरेट किया जा सके।

अपना RAG इम्प्लीमेंटेशन बनाते समय आपको इन चरणों को ध्यान में रखना होगा:

इंडेक्सिंग और एम्बेडिंग: इस चरण में, आपके दस्तावेज़ों को एक ऐसे सूचना स्रोत में बदला जाता है जिसमें ऑर्केस्ट्रेटर खोज कर सके। ऐसा करने के सबसे आम तरीकों में से एक है खोजने योग्य वेक्टर इंडेक्स बनाना। हम आपके दस्तावेज़ के चंक्स को एम्बेडिंग में बदलने के लिए Perplexity के एक समर्पित मॉडल का उपयोग करेंगे। फिर हम एम्बेडिंग को ChromaDB में स्टोर करेंगे, जो एक लोकप्रिय ओपन-सोर्स वेक्टर डेटाबेस है।
ऑर्केस्ट्रेशन: यह वह एप्लिकेशन है जो बाहरी सूचना स्रोत (हमारे मामले में एक वेक्टर डेटाबेस) और LLM के बीच काम करता है। ऑर्केस्ट्रेटर के रूप में काम करने के लिए हम एक सरल Python स्क्रिप्ट बनाएँगे।
रिट्रीवल और जनरेशन: जब कोई उपयोगकर्ता चैट इंटरफ़ेस के माध्यम से कोई प्रश्न पूछता है, तो ऑर्केस्ट्रेटर उसे लेकर वेक्टर सर्च चलाएगा और विस्तारित इनपुट LLM को देगा। एक समर्पित फ़्रंटएंड बनाने के बजाय, हम अपने Python ऑर्केस्ट्रेटर से संवाद करने के लिए कमांड लाइन प्रॉम्प्ट का उपयोग करेंगे।

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

निम्नलिखित सर्वोत्तम तरीके सभी प्रकार के RAG इम्प्लीमेंटेशन पर लागू होते हैं:

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

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

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

सुनिश्चित करें कि आपके कंप्यूटर पर निम्नलिखित इंस्टॉल हैं और आपके पास Perplexity API खाता है:

Python: यह वह प्रोग्रामिंग भाषा है जिसका उपयोग हम ऑर्केस्ट्रेटर बनाने के लिए करेंगे, जो एम्बेडिंग मॉडल, ChromaDB और Perplexity के बीच डेटा के प्रवाह का समन्वय करेगा।
Visual Studio: हम कोड एडिटर के रूप में Visual Studio का उपयोग करेंगे। इंस्टॉल होने के बाद, Extensions पैनल खोलें और Python एक्सटेंशन डाउनलोड करें।
Perplexity API खाता: Perplexity एम्बेडिंग मॉडल (जो आपके डेटा को वेक्टर एम्बेडिंग में बदलता है) और वह LLM, दोनों प्रदान करेगा जो विस्तारित प्रॉम्प्ट को प्रोसेस करेगा। इसके लिए आपको सशुल्क खाते की ज़रूरत नहीं है, हालाँकि इसमें थोड़े क्रेडिट्स खर्च होंगे।

सबसे पहले rag-project नाम का एक फ़ोल्डर बनाएँ और File > Open Folder चुनकर इसे VS Code में खोलें। फिर इंटीग्रेटेड टर्मिनल खोलने के लिए Terminal > New Terminal चुनें।

वर्चुअल Python एनवायरनमेंट बनाने के लिए निम्नलिखित दर्ज करें:

bash

py -3.12 -m venv .venv

अब आपको चार Python लाइब्रेरी इंस्टॉल करनी होंगी: perplexityai, chromadb, python-dotenv और numpy। Perplexity SDK की मदद से आप API के माध्यम से Perplexity के मॉडल से कनेक्ट कर पाएँगे। ChromaDB वेक्टर डेटाबेस बनाता है और लोकल रूप से चलेगा। Python-dotenv आपकी API कुंजियों को एक लोकल फ़ाइल से सुरक्षित रूप से लोड करता है, और इनजेशन प्रक्रिया के दौरान NumPy की ज़रूरत होती है।

इन्हें निम्नलिखित कमांड से इंस्टॉल करें:

bash

.\.venv\Scripts\python.exe -m pip install perplexityai chromadb python-dotenv numpy

rag-project (प्रोजेक्ट रूट) में निम्नलिखित फ़ाइलें जोड़ने के लिए Explorer साइडबार में New File… चुनें:

index.py: यह वह एप्लिकेशन है जो आपके दस्तावेज़ को इंडेक्स करेगा। और टेक्स्ट जोड़ने के लिए आप इसे दोबारा चला सकते हैं।
rag.py: यह वह Python एप्लिकेशन है जो ऑर्केस्ट्रेटर के रूप में काम करेगा।
document.txt: इसमें वह दस्तावेज़ीकरण होगा जिसे आप वेक्टर डेटाबेस में बदलेंगे।
.env: यहाँ आप अपनी Perplexity API कुंजी रखेंगे।

.env में निम्नलिखित दर्ज करें:

plaintext

PERPLEXITY_API_KEY=your_api_key_here

your_api_key_here को अपनी असली कुंजी से बदलें। इसके लिए, आपको Perplexity API Console के होम डैशबोर्ड पर जाकर Create an API key चुनना होगा। इस API कुंजी को निजी रखें।

Perplexity API Console डैशबोर्ड, जिसमें $10.00 का क्रेडिट बैलेंस, Create API key बटन, और Orchestrator, Agent, Search, Embeddings और Decisions API के कार्ड दिखाई दे रहे हैं।

हम दो मॉडल का उपयोग करेंगे: ChromaDB पर अपलोड करने से पहले अपने दस्तावेज़ीकरण को एम्बेड करने के लिए Perplexity का pplx-embed-v1-0.6b, और GPT-5.6-Luna (Perplexity के API के माध्यम से एक्सेस किया गया), जो प्राप्त जानकारी को प्रोसेस करेगा।

document.txt में वह टेक्स्ट जोड़ें जिसे आपकी RAG पाइपलाइन प्राप्त करेगी। यदि आपके पास कोई दस्तावेज़ उपलब्ध नहीं है, तो इस ट्यूटोरियल के लिए Project Gutenberg से विलियम ब्लेक की Songs of Innocence and of Experience का उपयोग करें। यह सार्वजनिक डोमेन में उपलब्ध एक छोटा और समझने में आसान टेक्स्ट है।

नीचे दिए गए कोड को कॉपी करके index.py में पेस्ट करें। प्रत्येक उपशीर्षक संक्षेप में बताता है कि उसके बाद आने वाला कोड सेगमेंट क्या करता है। यही वह प्रोग्राम है जो Perplexity के एम्बेडिंग मॉडल pplx-embed-v1-0.6b और NumPy लाइब्रेरी का उपयोग करके आपकी स्रोत सामग्री को वेक्टर एम्बेडिंग में बदलेगा और उन्हें ChromaDB डेटाबेस में स्टोर करेगा।

यह प्रोग्राम ये काम करता है:

document.txt खोलता है।
टेक्स्ट को एक-दूसरे पर ओवरलैप करने वाले चंक्स में विभाजित करता है।
उन चंक्स को Perplexity के pplx-embed-v1-0.6b एम्बेडिंग मॉडल को भेजता है।
कंप्यूटिंग फ़ंक्शन की Python लाइब्रेरी NumPy का उपयोग करके लौटाए गए वेक्टर को डिकोड और नॉर्मलाइज़ करता है।
वेक्टर और मूल चंक्स को ChromaDB डेटाबेस में स्टोर करता है (आप इसे अपनी प्रोजेक्ट डायरेक्टरी में दिखाई देते हुए देखेंगे)।

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

python

from pathlib import Path
from collections import defaultdict, deque
from hashlib import sha256
import base64
import numpy as np
import chromadb
from dotenv import load_dotenv
from perplexity import Perplexity
# 1. Connect to Perplexity and ChromaDB
load_dotenv()
ai = Perplexity()
db = chromadb.PersistentClient(path="./rag_database_perplexity")
collection = db.get_or_create_collection(
    name="documents",
    metadata={"hnsw:space": "cosine"}
)
# Convert Perplexity's encoded embeddings into numerical vectors
def decode_embedding(encoded):
    vector = np.frombuffer(base64.b64decode(encoded), dtype=np.int8).astype(np.float32)
    norm = np.linalg.norm(vector)
    if norm == 0:
        raise ValueError("Received a zero-length embedding vector.")
    return (vector / norm).tolist()
# 2. Read the document and split it into chunks
text = Path("document.txt").read_text(encoding="utf-8")
words = text.split()
chunk_size = 180
overlap = 30
step = chunk_size - overlap
chunks = [" ".join(words[i:i + chunk_size]) for i in range(0, len(words), step)]
if not chunks:
    raise ValueError("document.txt is empty.")
# 3. Retrieve the chunks already stored in ChromaDB
existing = collection.get(include=["documents"])
stored_chunks = defaultdict(deque)
existing_ids = set(existing["ids"])
for chunk_id, document in zip(existing["ids"], existing["documents"]):
    stored_chunks[document].append(chunk_id)
# 4. Identify unchanged and new chunks
new_chunks = []
new_ids = []
kept_ids = set()
unchanged = 0
for chunk in chunks:
    if stored_chunks[chunk]:
        chunk_id = stored_chunks[chunk].popleft()
        kept_ids.add(chunk_id)
        unchanged += 1
    else:
        chunk_hash = sha256(chunk.encode("utf-8")).hexdigest()
        chunk_id = f"chunk-{chunk_hash}"
        suffix = 1
        while chunk_id in existing_ids or chunk_id in kept_ids or chunk_id in new_ids:
            chunk_id = f"chunk-{chunk_hash}-{suffix}"
            suffix += 1
        new_chunks.append(chunk)
        new_ids.append(chunk_id)
        kept_ids.add(chunk_id)
# 5. Generate embeddings in batches of up to 100 chunks
batch_size = 100
for i in range(0, len(new_chunks), batch_size):
    batch_chunks = new_chunks[i:i + batch_size]
    batch_ids = new_ids[i:i + batch_size]
    embeddings = ai.embeddings.create(
        model="pplx-embed-v1-0.6b",
        input=batch_chunks,
        encoding_format="base64_int8"
    )
    vectors = [decode_embedding(item.embedding) for item in embeddings.data]
    # 6. Store each batch in ChromaDB
    collection.upsert(
        ids=batch_ids,
        documents=batch_chunks,
        embeddings=vectors
    )
    print(f"Indexed batch {(i // batch_size) + 1}")
# 7. Remove outdated chunks
old_ids = [chunk_id for chunk_id in existing["ids"] if chunk_id not in kept_ids]
if old_ids:
    collection.delete(ids=old_ids)
# 8. Display indexing results
print("Indexing complete!")
print("Unchanged chunks:", unchanged)
print("New or modified chunks:", len(new_chunks))
print("Removed chunks:", len(old_ids))
print("Total stored chunks:", collection.count())

नीचे दिए गए कोड को कॉपी करके rag.py में पेस्ट करें। यह एक पूर्ण लेकिन न्यूनतम RAG इम्प्लीमेंटेशन है, जो Perplexity SDK और ChromaDB की लोकल वेक्टर डेटाबेस सुविधा का उपयोग करता है।

प्रोग्राम चलाने पर यह ये काम करेगा:

Perplexity और आपके नए ChromaDB डेटाबेस से कनेक्ट करता है।
जाँचता है कि डेटाबेस में इंडेक्स किए गए दस्तावेज़ मौजूद हैं।
उपयोगकर्ता से एक प्रश्न स्वीकार करता है।
प्रश्न को Perplexity के एम्बेडिंग मॉडल को भेजता है।
NumPy का उपयोग करके परिणामी एम्बेडिंग को डिकोड और नॉर्मलाइज़ करता है।
ChromaDB में तीन सबसे मिलते-जुलते दस्तावेज़ चंक्स खोजता है।
एक प्रॉम्प्ट तैयार करता है जिसमें प्राप्त चंक्स और उपयोगकर्ता का प्रश्न शामिल होते हैं।
Perplexity के Agent API के माध्यम से प्रॉम्प्ट को GPT-5.6 Luna को भेजता है।
उत्तर दिखाता है और अगले प्रश्न की प्रतीक्षा करता है।

python

import base64
import numpy as np
import chromadb
from dotenv import load_dotenv
from perplexity import Perplexity
# 1. Connect to Perplexity and the existing ChromaDB database
load_dotenv()
ai = Perplexity()
db = chromadb.PersistentClient(path="./rag_database_perplexity")
collection = db.get_collection("documents")
# Convert Perplexity's encoded embeddings into numerical vectors
def decode_embedding(encoded):
    vector = np.frombuffer(base64.b64decode(encoded), dtype=np.int8).astype(np.float32)
    norm = np.linalg.norm(vector)
    if norm == 0:
        raise ValueError("Received a zero-length embedding vector.")
    return (vector / norm).tolist()
# 2. Check that the database contains indexed documents
count = collection.count()
if count == 0:
    raise ValueError("The database is empty. Run index.py first.")
print("Connected to existing ChromaDB database.")
print("Stored chunks:", count)
# 3. Accept questions from the user
while True:
    question = input("\nAsk a question (or type exit): ")
    if question.lower().strip() == "exit":
        break
    if not question.strip():
        continue
    # 4. Convert the question into a Perplexity embedding
    question_response = ai.embeddings.create(
        model="pplx-embed-v1-0.6b",
        input=[question],
        encoding_format="base64_int8"
    )
    question_vector = decode_embedding(question_response.data[0].embedding)
    # 5. Retrieve the most similar document chunks from ChromaDB
    results = collection.query(
        query_embeddings=[question_vector],
        n_results=min(3, count)
    )
    context = "\n\n".join(results["documents"][0])
    # 6. Construct a prompt and send it to the fixed LLM
    response = ai.responses.create(
        model="openai/gpt-5.6-luna",
        instructions=(
            "Answer using only the supplied document excerpts. "
            "Do not use external information. "
            "If the answer is not present, say you don't know."
        ),
        input=f"Document excerpts:\n{context}\n\nQuestion: {question}"
    )
    # 7. Display the answer
    print("\nAnswer:\n", response.output_text)

document.txt की सामग्री को एम्बेड करने के लिए VS Code के PowerShell टर्मिनल में निम्नलिखित दर्ज करें:

bash

.\.venv\Scripts\python.exe index.py

यदि आपका दस्तावेज़ सफलतापूर्वक इंडेक्स हो गया है, तो आपको इसके समान आउटपुट दिखाई देना चाहिए:

plaintext

Indexing complete!
Unchanged chunks: 0
New or modified chunks: 58
Removed chunks: 0
Total stored chunks: 58

अब मुख्य ऑर्केस्ट्रेटर एप्लिकेशन चलाने का समय है। यह कमांड दर्ज करें:

bash

.\.venv\Scripts\python.exe rag.py

यदि यह सफलतापूर्वक चलता है, तो आपको निम्नलिखित दिखाई देगा:

plaintext

Connected to existing ChromaDB database.
Stored chunks: 58
Ask a question (or type exit):

अब आप ऐसे प्रश्न पूछ सकते हैं जिनके उत्तर आपके बनाए गए वेक्टर डेटाबेस से लिए जाएँगे, जैसे:

plaintext

Ask a question (or type exit): What animals does William Blake talk about?
Answer: The excerpts mention sheep, lambs, birds, beasts, wolves, tigers, and a lion.

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

आपका बुनियादी RAG इम्प्लीमेंटेशन अब ये सभी काम करता है:

वेक्टर स्टोरेज: आपकी नॉलेज फ़ाइल के आधार पर एम्बेडिंग आपके लोकल एनवायरनमेंट में ChromaDB डेटाबेस में सहेजी जाती हैं।
इंक्रीमेंटल इंडेक्सिंग: अपरिवर्तित दस्तावेज़ चंक्स को दोबारा एम्बेड नहीं किया जाता, और आप जब चाहें दस्तावेज़ को अपडेट कर सकते हैं।
सिमेंटिक रिट्रीवल: ChromaDB वेक्टर समानता के आधार पर चंक्स प्राप्त करता है (जिसकी शुरुआत ऑर्केस्ट्रेटर करता है)।
स्रोत-आधारित उत्तर जनरेशन: LLM प्राप्त अंशों को संदर्भ के रूप में लेता है और उन्हें उत्तर में शामिल करता है।
स्वतंत्र इंडेक्सिंग और क्वेरी: आप अपनी नॉलेज फ़ाइल के पूरे टेक्स्ट को दोबारा प्रोसेस किए बिना प्रश्न पूछ सकते हैं।
API-आधारित मॉडल कनेक्शन: सभी उत्तर आपकी मशीन पर चलने वाले मॉडल के बजाय Perplexity के माध्यम से GPT-5.6 Luna का उपयोग करके जनरेट किए जाते हैं।

इस ट्यूटोरियल का उद्देश्य एक सीधा-सादा, बुनियादी इम्प्लीमेंटेशन बनाना है। इसमें आधुनिक सिस्टम में मौजूद कुछ मुख्य RAG आर्किटेक्चर घटक शामिल हैं। यदि आप और आगे जाना चाहते हैं, तो इसे आगे विकसित करने के कई तरीके हैं।

अपने इम्प्लीमेंटेशन का दायरा बढ़ाने के लिए यहाँ कुछ सुझाव दिए गए हैं:

LangChain के साथ प्रयोग करें: LangChain सबसे लोकप्रिय ओपन-सोर्स ऑर्केस्ट्रेशन फ़्रेमवर्क में से एक है। इसमें जटिल RAG पाइपलाइन चलाने में सक्षम ऐप्स बनाने के लिए पहले से तैयार घटक मौजूद हैं।
सर्च की क्षमता बढ़ाएँ: डेंस वेक्टर सर्च को BM25 जैसे लेक्सिकल (कीवर्ड) सर्च के साथ मिलाएँ। Perplexity Search API के ज़रिए वेब सर्च जोड़ने से आप उत्तरों को वर्तमान डेटा पर भी आधारित कर पाएँगे।
रीरैंकिंग मॉडल जोड़ें: एक ऐसा रीरैंकिंग मॉडल इंटीग्रेट करें जो प्राप्त अंशों को शुरुआती प्रॉम्प्ट के आधार पर रैंक करे और LLM को दिए जाने वाले इनपुट संदर्भ में शामिल करने के लिए सबसे प्रासंगिक अंशों को चुने।
एडैप्टिव RAG सिस्टम बनाएँ: मॉड्यूलर RAG सिस्टम में किस रिट्रीवल विधि का उपयोग करना है, यह तय करने के लिए एडैप्टिव RAG या तो किसी LLM या किसी क्लासिफ़ायर (ऑर्केस्ट्रेटर के भीतर का एक घटक) का उपयोग करता है। इसे बनाना अधिक उन्नत RAG इम्प्लीमेंटेशन को समझने का एक अच्छा तरीका है।

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

नोट: यह ट्यूटोरियल GPT-5.6 Luna का उपयोग करता है। मॉडल की उपलब्धता बदल सकती है, इसलिए आपको API कॉल अपडेट करनी पड़ सकती है।

बुनियादी RAG इम्प्लीमेंटेशन प्रक्रिया: एक संक्षिप्त अवलोकन

सर्वोत्तम तरीके: एक प्रभावी RAG इम्प्लीमेंटेशन की पहचान क्या है?

बुनियादी RAG इम्प्लीमेंटेशन: 7 चरणों वाला ट्यूटोरियल

चरण 1: सॉफ़्टवेयर इंस्टॉल करें

चरण 2: एक प्रोजेक्ट फ़ोल्डर बनाएँ

चरण 3: अपनी फ़ाइलें सेट अप करें

चरण 4: इंडेक्सिंग प्रोग्राम लिखें

चरण 5. RAG सिस्टम के लिए ऑर्केस्ट्रेटर लिखें

चरण 6: एप्लिकेशन चलाएँ

चरण 7: समझें कि आपने क्या बनाया है

अगले कदम: इस इम्प्लीमेंटेशन को आगे कैसे ले जाएँ