അടിസ്ഥാന RAG നടപ്പിലാക്കൽ: ഘട്ടം ഘട്ടമായുള്ള ട്യൂട്ടോറിയൽ

ആധുനിക LLM അധിഷ്ഠിത ഇൻഫ്രാസ്ട്രക്ചറിന്റെ ഒരു അനിവാര്യ ഘടകമാണ് RAG. ബാഹ്യ ഡാറ്റ ആക്‌സസ് ചെയ്യാൻ 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 അക്കൗണ്ട്: എംബെഡിംഗ് മോഡലും (നിങ്ങളുടെ ഡാറ്റയെ വെക്റ്റർ എംബെഡിംഗുകളാക്കി മാറ്റുന്നത്) വിപുലീകരിച്ച പ്രോംപ്റ്റ് പ്രോസസ്സ് ചെയ്യുന്ന LLM-ഉം Perplexity നൽകും. ഇതിനായി പണമടച്ചുള്ള അക്കൗണ്ട് ആവശ്യമില്ല, എന്നാൽ ചെറിയ തോതിൽ ക്രെഡിറ്റുകൾ ചെലവാകും.

ആദ്യം 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

താഴെപ്പറയുന്ന ഫയലുകൾ 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 കീ സ്വകാര്യമായി സൂക്ഷിക്കുക.

$10.00 ക്രെഡിറ്റ് ബാലൻസ്, Create API key ബട്ടൺ, ഓർക്കസ്ട്രേറ്റർ, ഏജന്റ്, സെർച്ച്, എംബെഡിംഗ്സ്, ഡിസിഷൻസ് API-കൾക്കുള്ള കാർഡുകൾ എന്നിവ കാണിക്കുന്ന Perplexity API Console ഡാഷ്‌ബോർഡ്.

നമ്മൾ രണ്ട് മോഡലുകൾ ഉപയോഗിക്കും: 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-ലേക്ക് പേസ്റ്റ് ചെയ്യുക. Perplexity SDK-യും ChromaDB-യുടെ ലോക്കൽ വെക്റ്റർ ഡാറ്റാബേസ് ഫംഗ്ഷണാലിറ്റിയും ഉപയോഗിക്കുന്ന, സമ്പൂർണ്ണവും എന്നാൽ ലളിതവുമായ ഒരു RAG നടപ്പിലാക്കലാണിത്.

പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുമ്പോൾ സംഭവിക്കുന്നത് ഇതാണ്:

Perplexity-യിലേക്കും നിങ്ങളുടെ പുതിയ ChromaDB ഡാറ്റാബേസിലേക്കും കണക്റ്റ് ചെയ്യുന്നു.
ഡാറ്റാബേസിൽ ഇൻഡെക്സ് ചെയ്ത ഡോക്യുമെന്റുകൾ ഉണ്ടെന്ന് പരിശോധിക്കുന്നു.
ഉപയോക്താവിൽ നിന്ന് ഒരു ചോദ്യം സ്വീകരിക്കുന്നു.
ചോദ്യം Perplexity-യുടെ എംബെഡിംഗ് മോഡലിലേക്ക് അയയ്ക്കുന്നു.
ലഭിക്കുന്ന എംബെഡിംഗ് NumPy ഉപയോഗിച്ച് ഡീകോഡ് ചെയ്യുകയും നോർമലൈസ് ചെയ്യുകയും ചെയ്യുന്നു.
ഏറ്റവും സമാനമായ മൂന്ന് ഡോക്യുമെന്റ് ചങ്കുകൾക്കായി ChromaDB-യിൽ തിരയുന്നു.
വീണ്ടെടുത്ത ചങ്കുകളും ഉപയോക്താവിന്റെ ചോദ്യവും അടങ്ങിയ ഒരു പ്രോംപ്റ്റ് തയ്യാറാക്കുന്നു.
Perplexity-യുടെ ഏജന്റ് 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: നിങ്ങൾ നിർമ്മിച്ചത് എന്താണെന്ന് മനസ്സിലാക്കുക

അടുത്ത ഘട്ടങ്ങൾ: ഈ നടപ്പിലാക്കൽ എങ്ങനെ കൂടുതൽ മുന്നോട്ട് കൊണ്ടുപോകാം