ഞാൻ ഒരു RAG ആപ്പ് നിർമ്മിച്ചു, എന്നിട്ട് എനിക്ക് ഏത് കാറാണ് ഇഷ്ടമെന്ന് അതിനോട് ചോദിച്ചു. അതിന് അറിയില്ലായിരുന്നു.

ഞാൻ Kenning എന്ന പേരിൽ ഒരു ഡോക്യുമെന്റ്-ചാറ്റ് ടൂൾ നിർമ്മിച്ചുകൊണ്ടിരിക്കുകയാണ്. അപ്‌ലോഡ് ചെയ്ത ഫയലുകളെക്കുറിച്ച് ഉപയോക്താക്കൾക്ക് ചോദ്യങ്ങൾ ചോദിക്കാൻ ഇത് RAG (Retrieval-Augmented Generation) ഉപയോഗിക്കുന്നു.

താഴെ പറയുന്നവ ഉപയോഗിച്ച് ഞാൻ ഈ മുഴുവൻ പൈപ്പ്‌ലൈനും പൂജ്യത്തിൽ നിന്ന് നിർമ്മിച്ചു:

• Java 21 and Spring Boot
• Spring AI
• PostgreSQL with pgvector
• Ollama (running llama3.2:3b and nomic-embed-text)
• Docker Compose

ഈ പൈപ്പ്‌ലൈൻ ഇപ്രകാരമാണ് പ്രവർത്തിക്കുന്നത്: Upload file → Extract text → Chunk text → Convert chunks to vectors → Store in pgvector → Search for similar chunks → Send chunks + question to the model → Get answer with sources.

സിസ്റ്റം പ്രവർത്തിക്കുന്നുണ്ടായിരുന്നു, പക്ഷേ എനിക്ക് രണ്ട് വ്യത്യസ്ത പരാജയങ്ങൾ നേരിടേണ്ടി വന്നു. അവ ഒരേപോലെ തോന്നിച്ചെങ്കിലും കാരണങ്ങൾ വ്യത്യസ്തമായിരുന്നു.

പരാജയം 1: മോഡൽ ആശയക്കുഴപ്പത്തിലായി.

ഞാൻ ചോദിച്ചു: "What embedding model does this project use?" ഡോക്യുമെന്റിൽ ഉത്തരം വ്യക്തമായി രേഖപ്പെടുത്തിയിട്ടുണ്ടായിരുന്നു. മോഡൽ ശരിയായ ടെക്സ്റ്റ് കണ്ടെത്തിയിരുന്നു. എന്നിരുന്നാലും, അടുത്ത വാക്യത്തിൽ ശരിയായ മോഡലിന്റെ പേര് ആവർത്തിച്ചു പറഞ്ഞിട്ടും, തനിക്ക് അറിയില്ല എന്നാണ് അത് മറുപടി നൽകിയത്.

എന്റെ നിഗമനം: 3B മോഡൽ വളരെ ചെറുതാണ്. അത് ശരിയായ ഡാറ്റ കണ്ടെത്തിയെങ്കിലും ആത്മവിശ്വാസത്തോടെ ഒരു ഉത്തരം നൽകാൻ അതിന് കഴിഞ്ഞില്ല. ഒരു വലിയ മോഡൽ ഉപയോഗിച്ചാൽ ഇത് പരിഹരിക്കാൻ സാധിച്ചേക്കും.

പരാജയം 2: മോഡലിന് ഒന്നും കണ്ടെത്താനായില്ല.

ഞാൻ ചോദിച്ചു: "What car brand do I like?" എനിക്ക് BMW ആണ് ഇഷ്ടമെന്ന് ഡോക്യുമെന്റിൽ സൂചിപ്പിച്ചിരുന്നു. എന്നാൽ സിസ്റ്റം ഒരു ഫലവും നൽകിയില്ല. എന്റെ നിശ്ചിത പരിധിയിൽ (threshold) എത്തുന്നതിനായുള്ള സമാനത സ്കോർ (similarity score) വളരെ കുറവായിരുന്നു.

എന്റെ നിഗമനം: Chunk dilution. എന്റെ ടെസ്റ്റ് ഡോക്യുമെന്റ് ചെറുതായിരുന്നു. Spring AI, OAuth2, എന്റെ കാർ താൽപ്പര്യം എന്നിങ്ങനെ പല വിഷയങ്ങൾ ഒരു ചങ്കിൽ (chunk) തന്നെ കലർന്നിരുന്നു. ആ ചങ്കിന്റെ വെക്റ്റർ എല്ലാ വിഷയങ്ങളിലുമായി വിതരണം ചെയ്യപ്പെട്ടു (diluted). കാറുകളെക്കുറിച്ചുള്ള ഒരു പ്രത്യേക ചോദ്യത്തിന്, ഇത്രയും വലിയൊരു ചങ്കിനെ നേരിടാൻ കഴിഞ്ഞില്ല. മെച്ചപ്പെട്ട ഒരു ചങ്കിംഗ് സ്ട്രാറ്റജി (chunking strategy) ഇതിന് പരിഹാരമാകും.

പഠിച്ച പാഠങ്ങൾ:

• ചെറിയ മോഡലുകൾക്ക് യുക്തിപരമായ ചിന്താശേഷി (reasoning) പരിമിതമാണ്.
• ലളിതമായ ചങ്കിംഗ് രീതികൾ വിവരങ്ങൾ കണ്ടെത്തുന്നതിൻ്റെ കൃത്യതയെ ബാധിക്കുന്നു.
• ഒരു പിശക് പരിഹരിക്കുന്നതിനേക്കാൾ അത് "എന്തുകൊണ്ട്" സംഭവിച്ചു എന്ന് കണ്ടെത്തുന്നതാണ് കൂടുതൽ പ്രധാനം.

ആർക്കിടെക്ചർ നിലനിൽക്കുന്നുണ്ട്. ഇത് സാവധാനത്തിലാണ് പ്രവർത്തിക്കുന്നത്, ചിലപ്പോൾ തെറ്റായ ഉത്തരങ്ങളും നൽകുന്നു, എങ്കിലും പ്രക്രിയ പൂർണ്ണമാണ്.

Source: https://dev.to/mido-dev/i-built-a-rag-app-then-asked-it-what-car-i-like-it-didnt-know-583n

Optional learning community: https://t.me/GyaanSetuAi