ప్రాథమిక 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 ఖాతా: ఎంబెడింగ్ మోడల్ (మీ డేటాను వెక్టర్ ఎంబెడింగ్‌లుగా మార్చేది), విస్తరించిన ప్రాంప్ట్‌ను ప్రాసెస్ చేసే LLM — ఈ రెండింటినీ Perplexity అందిస్తుంది. దీని కోసం మీకు చెల్లింపు ఖాతా అవసరం లేదు, అయితే కొద్దిపాటి క్రెడిట్స్ ఖర్చవుతాయి.

దశ 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 కాల్‌ను అప్‌డేట్ చేయాల్సి రావచ్చు.