मूलभूत RAG अंमलबजावणी: टप्प्याटप्प्याने ट्युटोरियल

हे नवशिक्यांसाठी सोपे ट्युटोरियल मूलभूत RAG अंमलबजावणी कशी काम करते हे स्पष्ट करते, सर्वोत्तम पद्धतींचा आढावा घेते आणि Python, ChromaDB आणि Perplexity च्या एम्बेडिंग व भाषा मॉडेल्सचा वापर करून कार्यरत कमांड-लाइन RAG प्रणाली तयार करण्याची प्रक्रिया टप्प्याटप्प्याने समजावते.

Basic RAG implementation process diagram: the interface sends input to the orchestrator, which retrieves data from a vector database, builds the input context for the LLM, and returns the output to the interface.

RAG हा आधुनिक LLM-आधारित पायाभूत संरचनेचा एक अत्यावश्यक घटक आहे. AI मॉडेल्सना बाह्य डेटा वापरण्याची मुभा देऊन, तो हॅल्युसिनेशन्स आणि अपूर्ण प्रशिक्षण डेटा यांसारख्या समस्या सोडवण्यास मदत करतो. याचा अर्थ असाही होतो की कंपन्या संवेदनशील किंवा मालकीची माहिती असलेले अंतर्गत ज्ञानसंग्रह वापरू शकतात.

RAG ची अंमलबजावणी खूप गुंतागुंतीची असू शकते. मात्र, मूलभूत RAG प्रणाली तयार करणे आश्चर्यकारकरीत्या सोपे आहे. नवशिक्यांसाठी, एक साधी संरचना तयार केल्याने RAG प्रत्यक्षात कसे काम करते हे स्पष्ट होऊ शकते आणि पुढील प्रयोगांसाठी एक भक्कम पायरी मिळू शकते.

या लेखात, आम्ही मूलभूत RAG अंमलबजावणीची रूपरेषा मांडू, सर्वोत्तम पद्धतींचा आढावा घेऊ आणि त्यानंतर Python, ChromaDB आणि एम्बेडिंग व उत्तर निर्मितीसाठी दोन Perplexity मॉडेल्स वापरून एक कार्यरत प्रणाली तयार करू.

मूलभूत RAG अंमलबजावणी प्रक्रिया: एक संक्षिप्त आढावा

मूलभूत RAG प्रणालीचे तीन मुख्य घटक असतात: एक ऑर्केस्ट्रेटर, एक माहिती स्रोत आणि एक LLM. सामान्य वर्कफ्लोमध्ये, वापरकर्ता एखादा प्रॉम्प्ट प्रविष्ट करतो आणि ऑर्केस्ट्रेटर त्यात बदल करून जोडलेल्या कोणत्याही माहिती स्रोतांमध्ये शोध घेतो. त्यानंतर मिळालेली माहिती मूळ इनपुट संदर्भात जोडली जाते आणि उत्तर तयार करता यावे यासाठी LLM कडे पाठवली जाते.

तुमची RAG अंमलबजावणी तयार करताना तुम्हाला या टप्प्यांचा विचार करावा लागेल:

  1. इंडेक्सिंग आणि एम्बेडिंग: या टप्प्यात, तुमचे दस्तऐवज ऑर्केस्ट्रेटरला शोधता येईल अशा माहिती स्रोतात रूपांतरित केले जातात. हे करण्याचा सर्वात सामान्य मार्ग म्हणजे शोधण्यायोग्य व्हेक्टर इंडेक्स तयार करणे. तुमच्या दस्तऐवजांचे खंड एम्बेडिंग्जमध्ये रूपांतरित करण्यासाठी आम्ही Perplexity चे एक समर्पित मॉडेल वापरू. त्यानंतर आम्ही ही एम्बेडिंग्ज ChromaDB या लोकप्रिय ओपन-सोर्स व्हेक्टर डेटाबेसमध्ये संग्रहित करू.
  2. ऑर्केस्ट्रेशन: हे असे ॲप्लिकेशन आहे जे बाह्य माहिती स्रोत (आपल्या बाबतीत व्हेक्टर डेटाबेस) आणि LLM यांच्यामध्ये काम करते. ऑर्केस्ट्रेटर म्हणून काम करण्यासाठी आम्ही एक साधी Python स्क्रिप्ट तयार करू.
  3. पुनर्प्राप्ती आणि निर्मिती: जेव्हा वापरकर्ता चॅट इंटरफेसद्वारे प्रश्न विचारतो, तेव्हा ऑर्केस्ट्रेटर तो घेईल, व्हेक्टर शोध चालवेल आणि विस्तारित इनपुट LLM ला देईल. समर्पित फ्रंटएंड तयार करण्याऐवजी, आमच्या Python ऑर्केस्ट्रेटरशी संवाद साधण्यासाठी आम्ही प्रॉम्प्ट देण्याकरिता कमांड लाइन वापरू.

सर्वोत्तम पद्धती: प्रभावी RAG अंमलबजावणी कशामुळे होते?

RAG संरचनेचे अनेक प्रकार आहेत आणि वेगवेगळ्या वापर प्रकरणांसाठी वेगवेगळे दृष्टिकोन आवश्यक असतात. असे असले तरी, अनेक सर्वोत्तम पद्धती सर्व प्रकरणांना लागू होतात आणि अचूक, किफायतशीर, स्केलेबल व देखभालीस सोप्या प्रणाली सुनिश्चित करतात.

पुढील सर्वोत्तम पद्धती सर्व प्रकारच्या RAG अंमलबजावणीला लागू होतात:

  • स्वच्छ इंजेशन पाइपलाइन सुनिश्चित करा: इंडेक्सिंगपूर्वी तुमचा स्रोत डेटा शक्य तितका स्वच्छ असावा. तुम्ही तुमच्या सामग्रीला अनुरूप असे एम्बेडिंग मॉडेलही वापरावे.
  • हायब्रिड शोध वापरा: सर्वोत्तम पुनर्प्राप्ती पद्धती, मग त्या व्हेक्टर डेटाबेस शोध, API-आधारित वेब शोध, नॉलेज ग्राफ ट्रॅव्हर्सल, कीवर्ड शोध किंवा इतर कोणत्याही पद्धती असोत, वापर प्रकरणानुसार बदलतात. खर्च कमी ठेवण्यासाठी योग्य मिश्रण निवडणे महत्त्वाचे आहे.
  • तुमच्या प्रणालीचे मूल्यमापन करा: अंमलबजावणीनंतर, तुम्ही तीन मुख्य निकषांवर मूल्यमापन केले पाहिजे: अचूकता, प्रासंगिकता आणि लेटन्सी. अचूकता म्हणजे तथ्यात्मक बरोबरपणा, प्रासंगिकता म्हणजे पुनर्प्राप्त माहिती वापरकर्त्यांच्या क्वेरींना किती लागू होते आणि लेटन्सी म्हणजे माहिती किती वेगाने पुनर्प्राप्त केली जाते.
  • माहिती सुरक्षितपणे हाताळा: तुमची RAG प्रणाली खाजगी अंतर्गत माहितीवर आधारित असल्यास, ती सुरक्षितपणे संग्रहित केली आहे आणि प्रणालीच्या इंटरफेसचा ॲक्सेस व्यवस्थापित केला जातो याची खात्री करा. API कीज कधीही शेअर करू नयेत.

मूलभूत RAG अंमलबजावणी: 7 पायऱ्यांचे ट्युटोरियल

या ट्युटोरियलसाठी आम्ही एका दस्तऐवजाबद्दलच्या प्रश्नांची उत्तरे देणारे कमांड-लाइन ॲप्लिकेशन तयार करू. आम्ही Python, ChromaDB आणि Perplexity API वापरू.

प्रोडक्शनसाठी तयार RAG प्रणाली तयार करणे हा यामागचा उद्देश नाही. उलट, प्राथमिक RAG संरचना प्रत्यक्षात कशी काम करते हे स्पष्ट करण्यासाठी तयार केलेले हे नवशिक्यांसाठी सोपे ट्युटोरियल आहे.

पायरी 1: सॉफ्टवेअर इंस्टॉल करा

तुमच्या संगणकावर पुढील गोष्टी इंस्टॉल केलेल्या आहेत आणि तुमचे Perplexity API खाते आहे याची खात्री करा:

  • Python: ही ती प्रोग्रामिंग भाषा आहे जिचा वापर आम्ही एम्बेडिंग मॉडेल, ChromaDB आणि Perplexity यांच्यातील डेटाच्या प्रवाहाचे समन्वय करणारा ऑर्केस्ट्रेटर तयार करण्यासाठी करू.
  • Visual Studio: आम्ही कोड एडिटर म्हणून Visual Studio वापरू. इंस्टॉल झाल्यावर, Extensions पॅनेल उघडा आणि Python एक्सटेन्शन डाउनलोड करा.
  • Perplexity API खाते: Perplexity एम्बेडिंग मॉडेल (जे तुमचा डेटा व्हेक्टर एम्बेडिंग्जमध्ये रूपांतरित करते) आणि विस्तारित प्रॉम्प्टवर प्रक्रिया करणारे LLM हे दोन्ही पुरवेल. यासाठी तुम्हाला सशुल्क खात्याची आवश्यकता नाही, मात्र थोडे क्रेडिट्स खर्च होतील.

पायरी 2: प्रोजेक्ट फोल्डर तयार करा

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

पायरी 3: तुमच्या फाइल्स सेट अप करा

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 की खाजगी ठेवा.

आम्ही दोन मॉडेल्स वापरणार आहोत: ChromaDB वर अपलोड करण्यापूर्वी आमचे दस्तऐवजीकरण एम्बेड करण्यासाठी Perplexity चे pplx-embed-v1-0.6b आणि पुनर्प्राप्त माहितीवर प्रक्रिया करणारे GPT-5.6-Luna (Perplexity च्या API द्वारे ॲक्सेस केलेले).

document.txt मध्ये, तुमची RAG पाइपलाइन जो मजकूर पुनर्प्राप्त करेल तो जोडा. तुमच्याकडे हाताशी एखादा दस्तऐवज नसल्यास, या ट्युटोरियलसाठी Project Gutenberg वरील विल्यम ब्लेक यांचे Songs of Innocence and of Experience वापरा. हा सार्वजनिक डोमेनमधील एक छोटा, समजण्यास सोपा मजकूर आहे.

पायरी 4: इंडेक्सिंग प्रोग्राम लिहा

खालील कोड कॉपी करून index.py मध्ये पेस्ट करा. प्रत्येक उपशीर्षक त्यापुढील कोड विभाग काय करतो याचे थोडक्यात स्पष्टीकरण देते. हाच तो प्रोग्राम आहे जो Perplexity चे एम्बेडिंग मॉडेल pplx-embed-v1-0.6b आणि NumPy लायब्ररी वापरून तुमच्या स्रोत सामग्रीचे व्हेक्टर एम्बेडिंग्जमध्ये रूपांतर करेल आणि ती ChromaDB डेटाबेसमध्ये संग्रहित करेल.

हा प्रोग्राम पुढील गोष्टी करतो:

  1. document.txt उघडतो.
  2. मजकुराचे एकमेकांवर आच्छादित होणाऱ्या खंडांमध्ये विभाजन करतो.
  3. ते खंड Perplexity च्या pplx-embed-v1-0.6b एम्बेडिंग मॉडेलकडे पाठवतो.
  4. संगणकीय फंक्शन्सची Python लायब्ररी असलेल्या NumPy चा वापर करून परत मिळालेले व्हेक्टर्स डीकोड आणि नॉर्मलाइझ करतो.
  5. व्हेक्टर्स आणि मूळ खंड 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())

पायरी 5. RAG प्रणालीसाठी ऑर्केस्ट्रेटर लिहा

खालील कोड कॉपी करून rag.py मध्ये पेस्ट करा. ही Perplexity SDK आणि ChromaDB ची स्थानिक व्हेक्टर डेटाबेस कार्यक्षमता वापरणारी, संपूर्ण पण किमान RAG अंमलबजावणी आहे.

तुम्ही प्रोग्राम चालवल्यावर पुढील गोष्टी घडतील:

  1. Perplexity आणि तुमच्या नवीन ChromaDB डेटाबेसशी कनेक्ट होतो.
  2. डेटाबेसमध्ये इंडेक्स केलेले दस्तऐवज आहेत की नाही हे तपासतो.
  3. वापरकर्त्याकडून प्रश्न स्वीकारतो.
  4. प्रश्न Perplexity च्या एम्बेडिंग मॉडेलकडे पाठवतो.
  5. परिणामी मिळालेले एम्बेडिंग NumPy वापरून डीकोड आणि नॉर्मलाइझ करतो.
  6. सर्वाधिक समान असलेल्या तीन दस्तऐवज खंडांसाठी ChromaDB मध्ये शोध घेतो.
  7. पुनर्प्राप्त खंड आणि वापरकर्त्याचा प्रश्न असलेला प्रॉम्प्ट तयार करतो.
  8. Perplexity च्या Agent API द्वारे प्रॉम्प्ट GPT-5.6 Luna कडे पाठवतो.
  9. उत्तर दाखवतो आणि पुढील प्रश्नाची वाट पाहतो.
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)

पायरी 6: ॲप्लिकेशन्स चालवा

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.

पायरी 7: तुम्ही काय तयार केले आहे ते समजून घ्या

तुम्ही तयार केलेल्या प्रणालीमध्ये प्रत्येक 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 कॉल अपडेट करावा लागू शकतो.