அடிப்படை 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 மாடல்கள் வெளிப்புறத் தரவை அணுக அனுமதிப்பதன் மூலம், மாயத்தோற்றங்கள் (hallucinations), முழுமையற்ற பயிற்சித் தரவு போன்ற சிக்கல்களைத் தீர்க்க இது உதவுகிறது. மேலும், முக்கியமான அல்லது தனியுரிமத் தகவல்களைக் கொண்ட உள் அறிவுத் தளங்களை நிறுவனங்கள் பயன்படுத்தவும் இது வழிவகுக்கிறது.

RAG செயலாக்கம் மிகவும் சிக்கலானதாக இருக்கலாம். இருப்பினும், ஓர் அடிப்படை RAG அமைப்பை உருவாக்குவது வியக்கத்தக்க வகையில் எளிதானது. தொடக்கநிலையாளர்களுக்கு, ஓர் எளிய கட்டமைப்பை உருவாக்குவது நிஜ உலகில் RAG எவ்வாறு செயல்படுகிறது என்பதைத் தெளிவுபடுத்துவதுடன், மேலும் சோதனைகளைச் செய்வதற்கான தொடக்கப் புள்ளியாகவும் அமையும்.

இந்தக் கட்டுரையில், ஓர் அடிப்படை RAG செயலாக்கத்தின் வரைபடத்தை வகுத்து, சிறந்த நடைமுறைகளைப் பற்றி விவரித்து, பின்னர் Python, ChromaDB, எம்பெடிங் மற்றும் பதில் உருவாக்கத்துக்கான இரண்டு Perplexity மாடல்கள் ஆகியவற்றைப் பயன்படுத்திச் செயல்படும் ஓர் அமைப்பை உருவாக்குவோம்.

அடிப்படை RAG செயலாக்கச் செயல்முறை: ஒரு மேலோட்டப் பார்வை

ஓர் அடிப்படை RAG அமைப்பில் மூன்று முக்கியக் கூறுகள் உள்ளன: ஓர் ஆர்கெஸ்ட்ரேட்டர், ஒரு தகவல் மூலம், ஒரு LLM. வழக்கமான பணிப்பாய்வில், பயனர் ஒரு ப்ராம்ப்ட்டை உள்ளிடுகிறார்; இணைக்கப்பட்ட தகவல் மூலங்களில் தேடுவதற்காக ஆர்கெஸ்ட்ரேட்டர் அதை மாற்றியமைக்கிறது. பின்னர், மீட்டெடுக்கப்பட்ட தகவல் அசல் உள்ளீட்டுச் சூழலுடன் சேர்க்கப்பட்டு, பதிலை உருவாக்குவதற்காக LLM-க்கு அனுப்பப்படுகிறது.

உங்கள் RAG செயலாக்கத்தை உருவாக்கும்போது இந்தப் படிநிலைகளைக் கருத்தில் கொள்ள வேண்டும்:

  1. இன்டெக்ஸிங் மற்றும் எம்பெடிங்: இந்தக் கட்டத்தில், ஆர்கெஸ்ட்ரேட்டர் தேடக்கூடிய ஒரு தகவல் மூலமாக உங்கள் ஆவணங்கள் மாற்றப்படுகின்றன. இதைச் செய்வதற்கான மிகவும் பொதுவான வழிகளில் ஒன்று, தேடக்கூடிய வெக்டர் இன்டெக்ஸை உருவாக்குவதாகும். உங்கள் ஆவணத் துண்டுகளை (chunks) எம்பெடிங்குகளாக மாற்ற, 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. API வழியாக Perplexity-இன் மாடல்களுடன் இணைய Perplexity SDK உதவும். 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. உரையை ஒன்றோடொன்று மேற்பொருந்தும் (overlapping) துண்டுகளாகப் பிரிக்கிறது.
  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 கட்டமைப்பிலும் உள்ள இரண்டு முக்கிய பைப்லைன்கள் நீங்கள் உருவாக்கிய அமைப்பில் உள்ளன: இன்டெக்ஸிங் அல்லது “உள்ளீர்ப்பு” (ingestion) பைப்லைன், மீட்டெடுப்பு மற்றும் உருவாக்கப் பைப்லைன்.

உங்கள் அடிப்படை 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 அழைப்பைப் புதுப்பிக்க வேண்டியிருக்கலாம்.