യഥാർത്ഥത്തിൽ പ്രവർത്തിക്കുന്ന AI ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുക എന്നത് ഒരു മികച്ച പ്രോംപ്റ്റ് (prompt) തയ്യാറാക്കുന്നതിനെക്കാൾ ഉപരിയായി, മോഡലിലേക്ക് നിങ്ങൾ നൽകുന്ന വിവരങ്ങളെ നിയന്ത്രിക്കുന്നതിനെക്കുറിച്ചാണ്. ഒരു അസിസ്റ്റന്റുമായി നീണ്ട ചാറ്റിൽ ഏർപ്പെട്ടപ്പോൾ, പത്ത് മിനിറ്റ് മുമ്പ് നിങ്ങൾ പറഞ്ഞ കാര്യം അത് മറന്നുപോയതായി നിങ്ങൾക്ക് തോന്നിയിട്ടുണ്ടെങ്കിൽ, കോൺടെക്സ്റ്റ് എൻജിനീയറിംഗ് (context engineering) പരാജയപ്പെടുമ്പോൾ എന്ത് സംഭവിക്കുമെന്ന് നിങ്ങൾ ഇതിനകം അനുഭവിച്ചിട്ടുണ്ടാകാം. AI-ക്ക് മോശം ഓർമ്മശക്തിയാണെന്ന് കരുതുന്നത് എളുപ്പമാണ്. എന്നാൽ യഥാർത്ഥത്തിൽ, നിങ്ങൾ കോൺടെക്സ്റ്റ് വിൻഡോയുടെ (context window) പരിധികളിൽ തട്ടിയിരിക്കുകയാണ്.

വിശ്വസനീയവും വേഗത്തിൽ പ്രതികരിക്കുന്നതുമായ സിസ്റ്റങ്ങൾ നിർമ്മിക്കുന്നതിന്, മൂന്ന് അടിസ്ഥാന കാര്യങ്ങൾ നിങ്ങൾ മനസ്സിലാക്കേണ്ടതുണ്ട്: ടോക്കണുകൾ (tokens), കോൺടെക്സ്റ്റ് വിൻഡോകൾ (context windows), കോൺടെക്സ്റ്റും മെമ്മറിയും (context and memory) തമ്മിലുള്ള വ്യത്യാസം.

ടോക്കണുകളാണ് യഥാർത്ഥ കറൻസി

ഒരു ടോക്കൺ എന്നാൽ ഒരു വാക്ക് അല്ല. നിങ്ങൾ ഒരു മോഡലിലേക്ക് ടെക്സ്റ്റ് അയക്കുമ്പോൾ, ഒരു ടോക്കണൈസർ (tokenizer) അതിനെ ചെറിയ ഭാഗങ്ങളായി വിഭജിക്കുന്നു. "cat" അല്ലെങ്കിൽ "the" പോലുള്ള ചെറിയ വാക്കുകൾ ഓരോന്നും ഒരു ടോക്കൺ വീതം ഉപയോഗിച്ചേക്കാം. എന്നാൽ "internationalization" പോലുള്ള സങ്കീർണ്ണമായ സാങ്കേതിക പദങ്ങൾ പല ഭാഗങ്ങളായി മുറിക്കപ്പെടും. ചിഹ്നങ്ങൾ (punctuation), സ്പേസുകൾ, പ്രത്യേക അക്ഷരങ്ങൾ എന്നിവയെല്ലാം ഇതിൽ ഉൾപ്പെടും. ഇത് പ്രധാനമാണ്, കാരണം ടോക്കണുകളാണ് എല്ലാം നിയന്ത്രിക്കുന്നത്: നിങ്ങളുടെ API ബില്ല്, പ്രതികരണത്തിന്റെ വേഗത, ഔട്ട്പുട്ടിന്റെ ഗുണനിലവാരം എന്നിവയെല്ലാം.

വാക്കുകൾ എണ്ണിക്കൊണ്ട് ചിലവ് കണക്കാക്കുന്ന ഒരു ഡെവലപ്പർക്ക് കൃത്യമായ ധാരണ ഉണ്ടാകില്ല. കോഡ് ബ്രാക്കറ്റുകളും നീളമുള്ള വേരിയബിൾ പേരുകളും അടങ്ങിയ നൂറ് വാക്കുകളുള്ള ഒരു പ്രോംപ്റ്റ് പ്രതീക്ഷിച്ചതിലും വലിയ ചിലവ് വരുത്തിയേക്കാം. അതുകൊണ്ടാണ് ടോക്കണൈസറുകൾ പ്രത്യേക ടൂളുകളായി നിലകൊള്ളുന്നത്. ഒരു ഫീച്ചർ പുറത്തിറക്കുന്നതിന് മുമ്പ്, നിങ്ങളുടെ സാധാരണ പേലോഡുകൾ (payloads) ഒരു ടോക്കണൈസറിലൂടെ കടത്തിവിട്ടു പരിശോധിക്കുക. സിസ്റ്റം ഇൻസ്ട്രക്ഷനുകൾ, ഫോർമാറ്റിംഗ് ബൊയിലർപ്ലേറ്റ് (formatting boilerplate), ചാറ്റ് ഹിസ്റ്ററി എന്നിവ യഥാർത്ഥ യൂസർ ക്വറിയേക്കാൾ കൂടുതൽ നിങ്ങളുടെ ബജറ്റ് ഉപയോഗിക്കുന്നുണ്ടെന്ന് നിങ്ങൾ പലപ്പോഴും കണ്ടെത്തിയേക്കാം. ആദ്യ ദിവസം മുതൽ ടോക്കണുകളെ പരിമിതമായ ഒരു വിഭവമായി കാണുക.

കോൺടെക്സ്റ്റ് വിൻഡോ എന്നത് ഒരു നിശ്ചിത വൈറ്റ്ബോർഡ് പോലെയാണ്

ഒരു സിംഗിൾ റിക്വസ്റ്റിൽ ഒരു മോഡലിന് കാണാൻ കഴിയുന്ന ആകെ വിവരങ്ങളുടെ അളവാണ് കോൺടെക്സ്റ്റ് വിൻഡോ. നിശ്ചിത അളവുകളുള്ള ഒരു വൈറ്റ്ബോർഡ് പോലെ ഇതിനെ കരുതുക. സിസ്റ്റം നിയമങ്ങൾ, സംഭാഷണ ചരിത്രം, ലഭ്യമായ രേഖകൾ, നിലവിലെ ചോദ്യം എന്നിവ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് നിറയ്ക്കാം. എന്നാൽ ഉപരിതലം നിറഞ്ഞു കഴിഞ്ഞാൽ, എന്തെങ്കിലും മാറ്റം വരുത്തേണ്ടി വരും. പഴയ കുറിപ്പുകൾ മായ്ക്കപ്പെടുകയോ, ഫോട്ടോ എടുത്ത് സംഗ്രഹിക്കുകയോ ചെയ്യേണ്ടി വരും, അല്ലെങ്കിൽ ബോർഡ് നിറഞ്ഞു കവിയുകയും ചെയ്യും.

ആധുനിക മോഡലുകൾ ഏതാനും ആയിരം ടോക്കണുകൾ മുതൽ ലക്ഷക്കണക്കിന് ടോക്കണുകൾ വരെയുള്ള കോൺടെക്സ്റ്റ് വിൻഡോകൾ വാഗ്ദാനം ചെയ്യുന്നുണ്ട്. വലിയ വിൻഡോ ഉള്ളതുകൊണ്ട് അത് പരിധിയില്ലാത്ത സ്റ്റോറേജ് ആണെന്ന് കരുതുന്നത് സ്വാഭാവികമാണ്. എന്നാൽ അങ്ങനെയല്ല. വൈറ്റ്ബോർഡിന് ഇപ്പോഴും അതിരുകളുണ്ട്. ഹിസ്റ്ററി പരിധി കവിയുമ്പോൾ, ആപ്ലിക്കേഷൻ പഴയ സന്ദേശങ്ങൾ ഒഴിവാക്കുകയോ അവ സംഗ്രഹിക്കുകയോ (compress) ചെയ്യേണ്ടതുണ്ട്. ഈ പരിമിതി മനസ്സിലാക്കുന്നത് വിൻഡോയെ ഒരു ഡാറ്റാബേസ് പോലെ കാണുന്നത് ഒഴിവാക്കാനും അതിനെ ഒരു ആക്റ്റീവ് വർക്ക്സ്പേസ് (active workspace) ആയി കാണാനും നിങ്ങളെ സഹായിക്കും.

കോൺടെക്സ്റ്റ് എന്നത് മെമ്മറി അല്ല

പരിചയസമ്പന്നരായ ബിൽഡർമാരെപ്പോലും തെറ്റിക്കുന്ന ഒരു വ്യത്യാസമാണിത്. മോഡൽ സ്വയം 'സ്റ്റേറ്റ്‌ലെസ്സ്' (stateless) ആണ്. ഇന്നലെയോ, കഴിഞ്ഞ ആഴ്ചയോ, അല്ലെങ്കിൽ പത്ത് മിനിറ്റ് മുമ്പ് മറ്റൊരു സെഷനിലോ നിങ്ങൾ ആരാണെന്ന് അതിന് ഓർമ്മയുണ്ടാവില്ല. നിങ്ങൾക്ക് ജാവാസ്ക്രിപ്റ്റിനേക്കാൾ പൈത്തൺ ആണ് ഇഷ്ടമെന്നോ, അല്ലെങ്കിൽ നിങ്ങൾക്ക് ചുരുങ്ങിയ ഉത്തരങ്ങളാണ് വേണ്ടതെന്നോ ഒരു AI ഓർത്തെടുക്കുന്നുണ്ടെങ്കിൽ, ആ ഓർമ്മ നിലനിൽക്കുന്നത് ആപ്ലിക്കേഷൻ ലെയറിലാണ് (application layer), മോഡലിലല്ല.

ആപ്ലിക്കേഷൻ ആ വിവരങ്ങൾ ഒരു ഡാറ്റാബേസിലോ, കാഷെയിലോ (cache), മെമ്മറി സ്റ്റോറിലോ സൂക്ഷിക്കുന്നു. ഓരോ പുതിയ റിക്വസ്റ്റിലും, അത് പ്രസക്തമായ പ്രൊഫൈൽ ഡാറ്റ പ്രോംപ്റ്റിലേക്ക് വീണ്ടും ഉൾപ്പെടുത്തുന്നു. മോഡൽ വെറുതെ അതിന്റെ ആദ്യ ഭാഗത്തെ വരികൾ ഉൾക്കൊള്ളുന്ന ഒരു സ്ക്രിപ്റ്റ് വായിക്കുക മാത്രമാണ് ചെയ്യുന്നത്. അതിന് സ്ഥിരമായ ഒരു സ്വത്വം (persistent self) ഇല്ല. ഈ വ്യത്യാസം നിങ്ങൾ മനസ്സിലാക്കിക്കഴിഞ്ഞാൽ, നിങ്ങളുടെ ആർക്കിടെക്ചർ മാറും. മോഡലിനോട് ഓർമ്മിക്കാൻ ആവശ്യപ്പെടുന്നതിന് പകരം, ശരിയായ സമയത്ത് ശരിയായ കോൺടെക്സ്റ്റ് കണ്ടെത്തി നൽകുന്ന സിസ്റ്റങ്ങൾ രൂപകൽപ്പന ചെയ്യാൻ നിങ്ങൾ തുടങ്ങും.

കൂടുതൽ കോൺടെക്സ്റ്റ് നൽകുന്നത് എന്തുകൊണ്ട് തിരിച്ചടിയാകുന്നു

കൂടുതൽ പശ്ചാത്തല വിവരങ്ങൾ നൽകിയാൽ മികച്ച ഉത്തരങ്ങൾ ലഭിക്കുമെന്ന് പൊതുവായ അറിവ് പറയുന്നു. എന്നാൽ പലപ്പോഴും നേരെ തിരിച്ചാണ് സംഭവിക്കുന്നത്. അമിതമായ കോൺടെക്സ്റ്റ് അനാവശ്യമായ ശബ്ദങ്ങൾ (noise) സൃഷ്ടിക്കുന്നു. ഒരു ഫംഗ്ഷൻ മാത്രം ശരിയാക്കാൻ ആവശ്യമായിരിക്കുമ്പോൾ നിങ്ങൾ ഒരു കോഡ്ബേസ് മുഴുവൻ നൽകിയാൽ, അനാവശ്യ വിവരങ്ങൾക്കിടയിൽ നിന്ന് ശരിയായ കാര്യം കണ്ടെത്താൻ നിങ്ങൾ അതിനെ നിർബന്ധിക്കുന്നു. ഗവേഷകർ "Lost in the Middle" എന്ന പ്രതിഭാസം കണ്ടെത്തിയിട്ടുണ്ട്: പ്രോംപ്റ്റിന്റെ തുടക്കത്തിലും അവസാനത്തിലും നൽകുന്ന വിവരങ്ങൾക്ക് മോഡലുകൾ കൂടുതൽ ശ്രദ്ധ നൽകുന്നു, എന്നാൽ മധ്യഭാഗത്തുള്ള വിവരങ്ങൾ അവഗണിക്കപ്പെടുകയോ അവയുടെ പ്രാധാന്യം കുറയുകയോ ചെയ്യുന്നു. ഇത് ബുദ്ധിപരമായ വാക്കുകൾ ഉപയോഗിച്ച് പരിഹരിക്കാൻ കഴിയുന്ന ഒരു ബഗ്ഗ് അല്ല. ഇത് ട്രാൻസ്ഫോർമർ അധിഷ്ഠിത ആർക്കിടെക്ചറുകളിൽ (transformer-based architectures) നിലനിൽക്കുന്ന ഒരു ഘടനാപരമായ സ്വഭാവമാണ്.

അമിതമായി വലുതാക്കിയ പ്രോംപ്റ്റുകൾ വലിയ പ്രത്യാഘാതങ്ങൾ ഉണ്ടാക്കും. ഓരോ അധിക ടോക്കണിനും കമ്പ്യൂട്ടേഷൻ ആവശ്യമാണ്. ഇത് ലേറ്റൻസി (latency) വർദ്ധിപ്പിക്കുന്നു, ചിലവ് കൂട്ടുന്നു, ഉപഭോക്താക്കളുടെ ക്ഷമ കുറയ്ക്കുന്നു. അനാവശ്യ രേഖകൾ കൊണ്ട് നിറച്ച പ്രോംപ്റ്റുകൾ വൈരുദ്ധ്യങ്ങൾ ഉണ്ടാക്കുകയും, മോഡലിന്റെ ശ്രദ്ധ തിരിക്കുകയും ചെയ്യുന്നു, കൂടാതെ തെറ്റായ പ്രശ്നത്തിൽ പ്രതികരണം കേന്ദ്രീകരിക്കാനുള്ള സാധ്യതയും വർദ്ധിപ്പിക്കുന്നു. അളവ് (Volume) എന്നത് കൃത്യതയുടെ (precision) ശത്രുവാണ്.

എങ്ങനെ മികച്ച കോൺടെക്സ്റ്റ് എൻജിനീയറിംഗ് നടത്താം

നല്ല കോൺടെക്സ്റ്റ് എൻജിനീയറിംഗ് എന്നത് കൃത്യമായ എഡിറ്റിംഗിലൂടെയുള്ള ഒരു പ്രക്രിയയാണ്. അത് എങ്ങനെ പ്രായോഗികമാക്കാം എന്ന് നോക്കാം.

ആവശ്യമായ കാര്യങ്ങൾ മാത്രം അയക്കുക. ഒരു ഉപഭോക്താവ് നിങ്ങളുടെ റീഫണ്ട് പോളിസിയെക്കുറിച്ച് ചോദിച്ചാൽ, എംപ്ലോയി ഹാൻഡ്‌ബുക്കും, API ഡോക്യുമെന്റേഷനും, കഴിഞ്ഞ പാദത്തിലെ മാർക്കറ്റിംഗ് കോപ്പിയും ഉൾപ്പെടുത്തരുത്. സമഗ്രതയേക്കാൾ പ്രധാനം പ്രസക്തിയാണ്.

പ്രസക്തമായ ഡോക്യുമെന്റുകൾ കണ്ടെത്താൻ RAG ഉപയോഗിക്കുക. Retrieval-Augmented Generation ഉപയോഗിച്ച് നിങ്ങൾക്ക് വലിയൊരു നോളജ് ബേസ് തിരയാനും ഏറ്റവും അനുയോജ്യമായ ഭാഗങ്ങൾ മാത്രം പ്രോംപ്റ്റിലേക്ക് ഉൾപ്പെടുത്താനും സാധിക്കും. ആയിരം പേജുകളുള്ള ഒരു മാനുവൽ മുഴുവനായി വിൻഡോയിലേക്ക് നൽകുന്നതിന് പകരം, നിങ്ങളുടെ ഡോക്യുമെന്റുകൾ എംബെഡ് ചെയ്യുകയും ഉപഭോക്താവിന്റെ ചോദ്യത്തിന് അനുസൃതമായി ഒരു സെമാന്റിക് സെർച്ച് നടത്തുകയും ചെയ്ത് ഏറ്റവും പ്രസക്തമായ മൂന്ന് ഖണ്ഡികകൾ മാത്രം ഉൾപ്പെടുത്തുക. ഇതിലൂടെ മോഡലിന് കൃത്യമായി ആവശ്യമുള്ള കാര്യങ്ങൾ ലഭിക്കുന്നു, കൂടാതെ നിങ്ങളുടെ ടോക്കൺ ബജറ്റും ലാഭിക്കാം.

പഴയ സംഭാഷണങ്ങൾ സംഗ്രഹിക്കുക. മുഴുവൻ ചാറ്റ് ട്രാൻസ്ക്രിപ്റ്റുകളും ചിലവേറിയതും ആശയക്കുഴപ്പമുണ്ടാക്കുന്നതുമാണ്. നീളമേറിയ മെസ്സേജ് ഹിസ്റ്ററികൾക്ക് പകരം സംഗ്രഹങ്ങൾ (summaries) ഉപയോഗിക്കുക. ഉദാഹരണത്തിന്, മുപ്പതോളം മെസ്സേജുകൾ മോഡലിന് നൽകുന്നതിന് പകരം, ഒരു ഖണ്ഡിക മാത്രം സൂക്ഷിക്കുക: "ഉപഭോക്താവ് Django deployment-നെ കുറിച്ച് ചോദിച്ചു, static files error നേരിട്ടു, തുടർന്ന് permissions ശരിയാക്കി. നിലവിലെ പ്രശ്നം Postgres 14-ൽ database migration പരാജയപ്പെടുന്നതാണ്." ഇത്തരത്തിൽ ഒരു സംഗ്രഹം ഉപയോഗിക്കുന്നത് വിവരങ്ങൾ നഷ്ടപ്പെടാതെ തന്നെ കാര്യങ്ങൾ ലളിതമായി നിലനിർത്താൻ സഹായിക്കുന്നു.

ലോംഗ്-ടേം മെമ്മറിയെ ആക്റ്റീവ് ചാറ്റിൽ നിന്ന് വേർതിരിക്കുക. ഉപഭോക്താവിന്റെ താൽപ്പര്യങ്ങൾ, പ്രോജക്റ്റ് സെറ്റിംഗുകൾ, അക്കൗണ്ട് ഹിസ്റ്ററി എന്നിവ ഒരു എക്സ്റ്റേണൽ മെമ്മറി സ്റ്റോറിൽ സൂക്ഷിക്കേണ്ടതാണ്. ആ സ്റ്റോറിൽ നിന്ന് ആവശ്യമായ വിവരങ്ങൾ മാത്രം തിരഞ്ഞടുക്കുക. ലൈവ് കോൺടെക്സ്റ്റ് വിൻഡോയിൽ നിലവിലെ ടാസ്ക്കും, സംഭാഷണം തുടരാൻ ആവശ്യമായ ഏറ്റവും ചുരുങ്ങിയ വ്യക്തിഗത വിവരങ്ങളും മാത്രം ഉണ്ടായിരിക്കണം.

പ്രൊഡക്ഷനിൽ ടോക്കൺ ഉപയോഗം നിരീക്ഷിക്കുക. കോൺടെക്സ്റ്റ് അമിതമാകുന്നതാണ് പലപ്പോഴും ലേറ്റൻസി (latency) വർദ്ധിക്കാൻ കാരണം. റിക്വസ്റ്റുകൾ മോഡലിന്റെ പരിധിയിലേക്ക് അടുക്കുമ്പോൾ അലേർട്ടുകൾ സെറ്റ് ചെയ്യുക. അനാവശ്യമായ വിവരങ്ങൾ അടങ്ങിയ പ്രോംപ്റ്റുകൾ തിരിച്ചറിയാൻ ലോഗുകൾ പരിശോധിക്കുക. ഓരോ തവണയും ഒരേ ചോദ്യത്തിലൂടെയാണ് ഒപ്റ്റിമൈസേഷൻ തുടങ്ങുന്നത്: ടാസ്കിനെ ബാധിക്കാതെ നമുക്ക് ഒഴിവാക്കാൻ കഴിയുന്ന കാര്യങ്ങൾ എന്തൊക്കെയാണ്?

യഥാർത്ഥ പാഠം

മികച്ച AI ആപ്ലിക്കേഷനുകൾ വിജയിക്കുന്നത് അവയ്ക്ക് വലിയ കോൺടെക്സ്റ്റ് വിൻഡോകൾ ഉള്ളതുകൊണ്ടല്ല. മറിച്ച്, അവ കോൺടെക്സ്റ്റ് കൃത്യമായ അച്ചടക്കത്തോടെ കൈകാര്യം ചെയ്യുന്നതുകൊണ്ടാണ്. അക്ഷരപ്പൂക്കൾ കൊണ്ട് നിറച്ച ഒരു വലിയ വൈറ്റ്ബോർഡ് ഉപയോഗശൂന്യമാണ്. വിവരങ്ങൾ കണ്ടെത്താനും (retrieve), സംഗ്രഹിക്കാനും (summarize), ഫിൽട്ടർ ചെയ്യാനും കഴിയുന്ന സിസ്റ്റങ്ങൾ നിർമ്മിക്കുക. അപ്പോൾ ഉപഭോക്താക്കൾക്ക് വേഗത്തിൽ മറുപടികൾ ലഭിക്കുന്നു, ഇൻഫ്രാസ്ട്രക്ചർ ചിലവ് നിയന്ത്രിക്കാൻ സാധിക്കുന്നു, കൂടാതെ നിങ്ങളുടെ മോഡലുകൾക്ക് ഏറ്റവും പ്രധാനപ്പെട്ട കാര്യങ്ങളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാനും കഴിയുന്നു.

ഉറവിടം: AI Context Engineering: Tokens, Context Windows, & Memory

കമ്മ്യൂണിറ്റി: GyaanSetu AI on Telegram