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

ഒരു ഏജന്റ് യഥാർത്ഥത്തിൽ എന്താണ്

ഒരു സാധാരണ ചാറ്റ്ബോട്ട് എന്നത് ഒരു സിംഗിൾ-ഷോട്ട് ഫംഗ്ഷൻ (single-shot function) ആണ്. നിങ്ങൾ ഒരു പ്രോംപ്റ്റ് നൽകുന്നു. മോഡൽ അടുത്ത ടോക്കണുകൾ പ്രവചിക്കുകയും ഒരു ടെക്സ്റ്റ് ബ്ലോക്ക് തിരികെ നൽകുകയും ചെയ്യുന്നു. അതിനുശേഷം അത് നിൽക്കുന്നു. അതിന്റെ ഉത്തരം കൃത്യമാണോ എന്ന് അത് പരിശോധിക്കുന്നില്ല. ഒരു വെബ് ലിങ്ക് പ്രവർത്തിക്കുന്നുണ്ടോ എന്നോ അല്ലെങ്കിൽ ഒരു കണക്കുകൂട്ടൽ ശരിയാണോ എന്നോ അത് പരിശോധിക്കുന്നില്ല. ഒറ്റയടിക്ക് അതിന്റെ ഏറ്റവും മികച്ച ഊഹം നിങ്ങൾക്ക് നൽകി അത് നിശബ്ദമാകുന്നു.

ഒരു ഏജന്റ് ആ സിംഗിൾ ഷോട്ടിനെ ഒരു ആവർത്തന ചക്രമാക്കി (repeating cycle) മാറ്റുന്നു. മോഡൽ ഇപ്പോഴും ടെക്സ്റ്റ് നിർമ്മിക്കുന്നുണ്ടെങ്കിലും, ഇപ്പോൾ അത് നിയന്ത്രിത ലൂപ്പിനുള്ളിലാണ് പ്രവർത്തിക്കുന്നത്. ഇതിലൂടെ പുറംലോകത്തെ സ്വാധീനിക്കാനും അവിടെ സംഭവിക്കുന്ന കാര്യങ്ങളോട് പ്രതികരിക്കാനും അതിന് കഴിയും.

ആ ചക്രം ഇപ്രകാരമാണ്:

  • ലക്ഷ്യം വിലയിരുത്തുകയും എന്തുചെയ്യണമെന്ന് ചിന്തിക്കുകയും ചെയ്യുക.
  • ഒരു ടൂൾ അല്ലെങ്കിൽ API ഉപയോഗിച്ച് ഒരു പ്രവൃത്തി (action) ചെയ്യുക.
  • ആ പ്രവൃത്തിയുടെ ഫലം നിരീക്ഷിക്കുക.
  • ആ പുതിയ വിവരത്തിന്റെ അടിസ്ഥാനത്തിൽ വീണ്ടും ചിന്തിക്കുക.

ടാസ്ക് പൂർത്തിയാകുന്നത് വരെ അല്ലെങ്കിൽ സിസ്റ്റം ഒരു സുരക്ഷാ പരിധിയിൽ എത്തുന്നതുവരെ ഈ ചക്രം ആവർത്തിച്ചുകൊണ്ടിരിക്കും. ഇതാണ് ഇതിന്റെ രഹസ്യം. ഇതിൽ ഒളിഞ്ഞിരിക്കുന്ന മറ്റ് ചിന്താശക്തികളൊന്നുമില്ല. യഥാർത്ഥ ടൂളുകളിൽ നിന്നുള്ള യഥാർത്ഥ ഡാറ്റ ഉപയോഗിച്ച് സ്വന്തം പാത തിരുത്താൻ മോഡലിന് അവസരം നൽകുന്നതിലൂടെയാണ് ഇതിന്റെ മാന്ത്രികത ഉണ്ടാകുന്നത്.

ReAct: ചിന്ത-പ്രവൃത്തി-നിരീക്ഷണം (Thought-Action-Observation) ചക്രം

ഈ ലൂപ്പ് നടപ്പിലാക്കാനുള്ള ഏറ്റവും സാധാരണമായ മാർഗ്ഗം ReAct പാറ്റേൺ ആണ്. ഇതിന്റെ അർത്ഥം Reason (ചിന്ത) പ്ലസ് Act (പ്രവൃത്തി) എന്നാണ്. ലൂപ്പിലൂടെയുള്ള ഓരോ ഘട്ടത്തിലും, മോഡൽ മൂന്ന് വ്യത്യസ്ത ഘട്ടങ്ങളിലൂടെ കടന്നുപോകുന്നു.

ആദ്യമായി, മോഡൽ ഒരു Thought (ചിന്ത) ഉൽപ്പാദിപ്പിക്കുന്നു. നിലവിലെ സാഹചര്യം വിലയിരുത്തുകയും, യഥാർത്ഥ ലക്ഷ്യം ഓർമ്മിക്കുകയും, അടുത്തതായി എന്താണ് അറിയേണ്ടതെന്ന് തീരുമാനിക്കുകയും ചെയ്യുന്നു. രണ്ടാമതായി, അത് ഒരു Action (പ്രവൃത്തി) തിരഞ്ഞെടുക്കുന്നു. ഇതൊരു വെബ് സെർച്ച് ആകാം, ഒരു ഡാറ്റാബേസ് ക്വറി ആകാം, ഒരു കാൽക്കുലേറ്റർ ഉപയോഗിക്കലാവാം അല്ലെങ്കിൽ ഒരു ഫയൽ വായിക്കാനുള്ള അഭ്യർത്ഥനയാകാം. മൂന്നാമതായി, അതിന് ഒരു Observation (നിരീക്ഷണം) ലഭിക്കുന്നു. സിസ്റ്റം മോഡലിന് പുറത്ത് ആ പ്രവൃത്തി നടപ്പിലാക്കുകയും അതിന്റെ ഫലം സംഭാഷണ ചരിത്രത്തിലേക്ക് (conversation history) തിരികെ നൽകുകയും ചെയ്യുന്നു. തുടർന്ന് ആ പുതിയ നിരീക്ഷണത്തെ പുതിയ യാഥാർത്ഥ്യമായി കണക്കാക്കി മോഡൽ അടുത്ത ലൂപ്പ് ആരംഭിക്കുന്നു.

ലളിതമായ ഒരു ഉദാഹരണം നോക്കാം. ഓസ്റ്റിനിൽ നാളെ മഴ പെയ്യുമോ എന്ന് ഒരു ഏജന്റിനോട് നിങ്ങൾ ചോദിക്കുന്നു എന്ന് കരുതുക. മോഡൽ ഇങ്ങനെ ചിന്തിച്ചേക്കാം, "എനിക്ക് ഓസ്റ്റിനിലെ കാലാവസ്ഥാ പ്രവചനം ആവശ്യമാണ്." അതിന്റെ പ്രവൃത്തി നഗരത്തിന്റെ പേര് ഉപയോഗിച്ച് ഒരു വെതർ API (weather API) വിളിക്കുക എന്നതാണ്. നിരീക്ഷണം ഒരു റോ (raw) JSON ആയി ലഭിക്കുന്നു: താപനിലയും മഴ പെയ്യാനുള്ള സാധ്യതയും. തുടർന്ന് മോഡൽ വീണ്ടും ചിന്തിക്കുന്നു, "കാലാവസ്ഥാ പ്രവചനം എഴുപത് ശതമാനം മഴ സാധ്യത കാണിക്കുന്നു," അതിന്റെ അവസാന പ്രവൃത്തി ആ വിവരം ലളിതമായ ഇംഗ്ലീഷിൽ നിങ്ങൾക്ക് മറുപടിയായി നൽകുക എന്നതാണ്.

ഈ ഘടന വളരെ പ്രധാനമാണ് കാരണം ഇത് മോഡലിനെ യാഥാർത്ഥ്യവുമായി ബന്ധിപ്പിക്കുന്നു. ഒരു കാര്യം തുടരുന്നതിന് മുമ്പ് മോഡൽ സെർച്ച് ചെയ്യുകയും ഫലങ്ങൾ വായിക്കുകയും വേണമെങ്കിൽ, അതിന് വെറുതെ വസ്തുതകൾ കെട്ടിച്ചമയ്ക്കാൻ കഴിയില്ല. അടുത്ത ചിന്തയ്ക്ക് നിരീക്ഷണം ഒരു കടുത്ത നിയന്ത്രണമായി (hard constraint) പ്രവർത്തിക്കുന്നു. മോഡൽ സംസാരിക്കുന്നതിന് മുമ്പ് കാര്യങ്ങൾ പരിശോധിക്കേണ്ടതുകൊണ്ട്, തെറ്റായ വിവരങ്ങൾ നിർമ്മിക്കുന്നത് ഈ ലൂപ്പ് പ്രയാസകരമാക്കുന്നു.

വിശ്വസനീയമായ ഒരു ലൂപ്പ് നിർമ്മിക്കാൻ നിങ്ങൾക്ക് എന്താണ് വേണ്ടത്

ഈ പാറ്റേൺ പ്രൊഡക്ഷനിൽ പ്രവർത്തിപ്പിക്കാൻ ഒരു മികച്ച പ്രോംപ്റ്റ് മാത്രം പോരാ. നിങ്ങൾക്ക് മൂന്ന് പ്രായോഗിക ഗാർഡ്‌റെയിലുകൾ (guardrails) ആവശ്യമാണ്.

ഒരു സ്റ്റെപ്പ് ബജറ്റ് (Step budget) നിശ്ചയിക്കുക. ലൂപ്പ് ആവർത്തനങ്ങളുടെ പരമാവധി എണ്ണം എപ്പോഴും നിർവചിക്കുക. ഒരു പരിധിയില്ലെങ്കിൽ, ഒരു ഏജന്റ് സ്വന്തം വാല് പിടിക്കാൻ ശ്രമിക്കുന്നത് പോലെ സെർച്ച് ചെയ്യാനും നിരീക്ഷിക്കാനും ചിന്തിക്കാനും വീണ്ടും സെർച്ച് ചെയ്യാനും തുടങ്ങി നിങ്ങളുടെ API ബജറ്റ് തീർക്കുന്നത് വരെ തുടർന്നേക്കാം. ഒരു സ്റ്റെപ്പ് ലിമിറ്റ് (step limit) പ്രവർത്തനം അവസാനിപ്പിക്കാൻ നിർബന്ധിക്കുന്നു. പരിധി എത്തുമ്പോൾ ഭാഗികമായ ഫലം നൽകണോ, ഒരു മനുഷ്യനെ ഏൽപ്പിക്കണോ അതോ ലളിതമായി പരാജയപ്പെടണോ എന്ന് നിങ്ങൾക്ക് തീരുമാനിക്കാം.

കോഡ് എക്സിക്യൂഷൻ (Code execution) നിങ്ങൾ തന്നെ കൈകാര്യം ചെയ്യുക. ലാംഗ്വേജ് മോഡൽ ടൂളുകൾ പ്രവർത്തിപ്പിക്കുന്നില്ല. അത് പ്രവൃത്തികൾ നിർദ്ദേശിക്കുക മാത്രമാണ് ചെയ്യുന്നത്, സാധാരണയായി ഒരു ടൂളിന്റെ പേരും പാരാമീറ്ററുകളും നൽകിക്കൊണ്ട് ഒരു സ്ട്രക്ചേർഡ് ടെക്സ്റ്റ് അല്ലെങ്കിൽ JSON ഔട്ട്പുട്ട് നൽകുന്നു. നിങ്ങളുടെ കോഡ്