અત્યારે દરેક AI ચર્ચામાં એજન્ટ્સ (Agents)નું વર્ચસ્વ છે. ડેમોમાં તેઓ એવા સ્વાયત્ત ડિજિટલ આસિસ્ટન્ટ્સ જેવા લાગે છે જે માનવીય મદદ વગર વિચારે છે, વ્યૂહરચના બનાવે છે અને સમસ્યાઓ ઉકેલે છે. જોકે, જો તમે ઇન્ટરફેસની પાછળ જોશો, તો તમને કંઈક ઘણું સરળ જોવા મળશે. એજન્ટ એ માત્ર લૂપ (loop) ની અંદર ચાલતું લેંગ્વેજ મોડલ છે. તે એક ડિઝાઇન પેટર્ન છે, કોઈ ચેતના (consciousness) નથી. આ તફાવત સમજવો મહત્વપૂર્ણ છે કારણ કે તે તમે આ સિસ્ટમ્સ કેવી રીતે બનાવો છો, ડિબગ કરો છો અને તેના પર કેવી રીતે વિશ્વાસ કરો છો તે બદલી નાખે છે.

એજન્ટ ખરેખર શું છે

એક સ્ટાન્ડર્ડ ચેટબોટ એ સિંગલ-શોટ ફંક્શન છે. તમે પ્રોમ્પ્ટ ટાઇપ કરો છો. મોડલ આગામી ટોકન્સનું અનુમાન લગાવે છે અને ટેક્સ્ટનો એક બ્લોક રિટર્ન કરે છે. પછી તે અટકી જાય છે. તે તપાસતું નથી કે તેનો જવાબ સચોટ હતો કે નહીં. તે વેબ લિંક કામ કરે છે કે નહીં અથવા ગણતરી સાચી છે કે નહીં તેની ચકાસણી કરતું નથી. તે એક જ વારમાં તેનો શ્રેષ્ઠ અંદાજ આપે છે અને શાંત થઈ જાય છે.

એજન્ટ તે સિંગલ શોટને પુનરાવર્તિત ચક્ર (repeating cycle) માં વિભાજિત કરે છે. મોડલ હજુ પણ ટેક્સ્ટ જનરેટ કરે છે, પરંતુ હવે તે એક નિયંત્રિત લૂપની અંદર કામ કરે છે જ્યાં તે બહારની દુનિયાને અસર કરી શકે છે અને જે કંઈ પણ થાય તેના પર પ્રતિક્રિયા આપી શકે છે.

આ ચક્ર આ મુજબ દેખાય છે:

  • લક્ષ્યનું મૂલ્યાંકન કરો અને શું કરવું તે વિશે વિચાર કરો.
  • કોઈ એક્શન લો, સામાન્ય રીતે કોઈ ટૂલ અથવા API ને કોલ કરીને.
  • તે એક્શનનું પરિણામ અવલોકન (observe) કરો.
  • તે નવી માહિતીના આધારે ફરીથી વિચાર કરો.

જ્યાં સુધી કાર્ય પૂર્ણ ન થાય અથવા સિસ્ટમ સેફ્ટી લિમિટ સુધી ન પહોંચે ત્યાં સુધી આ ચક્ર પુનરાવર્તિત થાય છે. આ જ સંપૂર્ણ રહસ્ય છે. અહીં કોઈ છુપાયેલું રીઝનિંગ એન્જિન નથી. સાચા ટૂલ્સમાંથી વાસ્તવિક ડેટાનો ઉપયોગ કરીને મોડલને તેના પોતાના માર્ગને સુધારવાની તક આપવાથી જ આ જાદુ સર્જાય છે.

ReAct: Thought-Action-Observation ચક્ર

આ લૂપને અમલમાં મૂકવાનો સૌથી સામાન્ય રસ્તો ReAct પેટર્ન છે, જેનો અર્થ 'Reason plus Act' થાય છે. લૂપના દરેક પાસ દરમિયાન, મોડલ ત્રણ અલગ-અલગ તબક્કાઓમાંથી પસાર થાય છે.

પ્રથમ, મોડલ એક Thought ઉત્પન્ન કરે છે. તે વર્તમાન પરિસ્થિતિ પર વિચાર કરે છે, મૂળ લક્ષ્યને યાદ કરે છે અને આગળ શું જાણવાની જરૂર છે તે નક્કી કરે છે. બીજું, તે એક Action પસંદ કરે છે. આ વેબ સર્ચ, ડેટાબેઝ ક્વેરી, કેલ્ક્યુલેટર કોલ અથવા ફાઇલ વાંચવાની વિનંતી હોઈ શકે છે. ત્રીજું, તેને એક Observation મળે છે. સિસ્ટમ મોડલની બહાર એક્શન એક્ઝિક્યુટ કરે છે અને કાચું પરિણામ (raw result) વાતચીતના ઇતિહાસમાં પાછું મોકલે છે. ત્યારબાદ મોડલ તે તાજા અવલોકનને તેની નવી વાસ્તવિકતા તરીકે ઉપયોગ કરીને આગામી લૂપ શરૂ કરે છે.

એક સરળ ઉદાહરણ લો. ધારો કે તમે એજન્ટને પૂછો છો કે શું આવતીકાલે ઓસ્ટિનમાં વરસાદ પડશે. મોડલ વિચારી શકે છે, "મારે ઓસ્ટિન માટે હવામાનની આગાહીની જરૂર છે." તેની એક્શન શહેરના નામ સાથે વેધર API ને કોલ કરવાની છે. અવલોકન કાચા JSON તરીકે પાછું આવે છે: તાપમાનનું રીડિંગ અને વરસાદની સંભાવના. ત્યારબાદ મોડલ ફરીથી વિચારે છે, "આગાહી મુજબ સિત્તેર ટકા વરસાદની શક્યતા છે," અને તેની અંતિમ એક્શન તેને તમારા માટે સાદા અંગ્રેજીમાં જવાબ તરીકે તૈયાર કરવાની છે.

આ માળખું મહત્વનું છે કારણ કે તે મોડલને વાસ્તવિકતા સાથે જોડી રાખે છે. જો મોડલે આગળ વધતા પહેલા સર્ચ કરવું અને પરિણામો વાંચવા જ પડે, તો તે ફક્ત તથ્યોની શોધખોળ કરી શકતું નથી. અવલોકન આગામી વિચાર પર એક કડક મર્યાદા (hard constraint) તરીકે કામ કરે છે. આ લૂપ ખોટી માહિતી બનાવવી ખૂબ મુશ્કેલ બનાવે છે કારણ કે મોડલે બોલતા પહેલા જોવું પડે છે.

વિશ્વસનીય લૂપ બનાવવા માટે તમારે શું જોઈએ

પ્રોડક્શનમાં આ પેટર્નને ચલાવવા માટે માત્ર એક ચતુર પ્રોમ્પ્ટ પૂરતો નથી. તમારે ત્રણ વ્યવહારુ ગાર્ડરેલ્સ (guardrails) રાખવાની જરૂર છે.

સ્ટેપ બજેટ સેટ કરો. હંમેશા લૂપ ઇટરેશનની મહત્તમ સંખ્યા નક્કી કરો. કોઈ મર્યાદા વગર, એજન્ટ પોતાની પાછળ દોડતો રહી શકે છે—સર્ચ કરવું, અવલોકન કરવું, વિચારવું, ફરીથી સર્ચ કરવું—જ્યાં સુધી તે તમારા API બજેટને ખતમ ન કરી નાખે. સ્ટેપ લિમિટ તેને સમાપ્ત કરવા માટે મજબૂર કરે છે. લિમિટ પહોંચ્યા પછી તમે આંશિક પરિણામ આપવાનું, કોઈ માણસને જાણ કરવાનું અથવા ફક્ત ગ્રેસફુલી ફેઈલ થવાનું નક્કી કરી શકો છો.

કોડ એક્ઝિક્યુશન જાતે હેન્ડલ કરો. લેંગ્વેજ મોડલ ટૂલ્સ ચલાવતું નથી. તે ફક્ત એક્શન સૂચવે છે, સામાન્ય રીતે સ્ટ્રક્ચર્ડ ટેક્સ્ટ અથવા JSON આઉટપુટ દ્વારા જે ટૂલનું નામ આપે છે અને પેરામીટર્સ પૂરા પાડે છે. તમારા કોડને