AI એજન્ટ્સ માટે PRG પેટર્ન
AI એજન્ટ્સ એક જૂની સમસ્યાનો સામનો કરી રહ્યા છે. આ એ જ બગ છે જેણે 90ના દાયકામાં વેબ ફોર્મ્સને બગાડી નાખ્યા હતા.
જૂના વેબના દિવસોમાં, વપરાશકર્તા ફોર્મ સબમિટ કરતો હતો. જો તેઓ રિફ્રેશ (refresh) બટન દબાવે, તો બ્રાઉઝર ડેટા ફરીથી સબમિટ કરી દેતું હતું. આનો અર્થ બે ઓર્ડર, બે ચાર્જ અથવા બે ઈમેલ થતો હતો.
આનો ઉકેલ Post/Redirect/Get (PRG) પેટર્ન હતી.
તર્ક સરળ છે:
- વપરાશકર્તા POST રિક્વેસ્ટ મોકલે છે.
- સર્વર કામગીરી પ્રોસેસ કરે છે.
- સર્વર નવા URL પર 302 Redirect મોકલે છે.
- બ્રાઉઝર GET રિક્વેસ્ટ સાથે રિડાયરેક્ટને અનુસરે છે.
હવે રિફ્રેશ કરવાથી ફક્ત રિઝલ્ટ પેજ જ ફરીથી લોડ થાય છે. તે ક્રિયાને ફરીથી દોહરાવતું નથી.
AI એજન્ટ્સ આ બગને એક નવા સ્તરે પાછો લાવ્યા છે.
જ્યારે કોઈ એજન્ટ કાર્ડ ચાર્જ કરવા અથવા રેકોર્ડ બનાવવા માટે કોઈ ટૂલને કોલ કરે છે, ત્યારે સમસ્યાઓ ઊભી થાય છે. નેટવર્ક ડ્રોપ થાય છે. કન્ટેનર રીસ્ટાર્ટ થાય છે. રેટ લિમિટ (rate limit) લાગુ પડે છે. એજન્ટને ખબર નથી હોતી કે છેલ્લી કોલ સફળ રહી હતી કે નહીં. તેથી, તે ફરીથી પ્રયાસ (retry) કરે છે.
ઉકેલ વિના, એજન્ટ ડુપ્લીકેટ ઓર્ડર બનાવે છે અને ગ્રાહકો પાસેથી ખોટી રીતે ચાર્જ લઈને તેમને નારાજ કરે છે.
તમારે idempotency keys નો ઉપયોગ કરીને તમારા એજન્ટિક પાઇપલાઇન્સમાં PRG પેટર્ન લાગુ કરવી જોઈએ.
Idempotency key એ તમારું રિડાયરેક્ટ છે. તે ક્રિયાને પરિણામથી અલગ કરે છે.
તેને કેવી રીતે અમલમાં મૂકવું:
- દરેક મ્યુટેટિંગ (mutating) ટૂલે idempotency key સ્વીકારવી જોઈએ.
- પ્રથમ પ્રયાસ પહેલાં કી (key) જનરેટ કરો.
- કી યુઝરના ઇન્ટેન્ટ (intent) પરથી મેળવો, ટાઇમસ્ટેમ્પ પરથી નહીં.
- સર્વરે તપાસવું જોઈએ કે તેણે આ કી પહેલાં જોઈ છે કે નહીં.
- જો કી અસ્તિત્વમાં હોય, તો કાર્ય ફરીથી ચલાવવાને બદલે સંગ્રહિત પરિણામ (stored result) પરત કરો.
લાંબા કાર્યો માટે, તમારે માત્ર કી કરતાં વધુની જરૂર છે. તમારે ચેકપોઇન્ટિંગ (checkpointing) ની જરૂર છે.
ચેકપોઇન્ટિંગ દરેક સ્ટેપ પર સ્ટેટ (state) ને સેવ કરે છે. જો એજન્ટ વીસ મિનિટના કાર્યના અધવચ્ચે ક્રેશ થાય, તો તે જ્યાંથી અટક્યું હતું ત્યાંથી જ ફરી શરૂ કરે છે. તે ફરીથી શરૂઆત કરતું નથી.
જો તમે માત્ર એક જ વસ્તુ કરી શકતા હોવ, તો દરેક ટૂલ કોલને બે વાર ચલાવવા માટે સુરક્ષિત બનાવો.
તમારા એજન્ટ્સને આ પાંચ ચેક્સ સાથે બનાવો:
- શું દરેક ટૂલ idempotency key સ્વીકારે છે?
- શું કી સમયને બદલે ઇન્ટેન્ટ પર આધારિત છે?
- શું દરેક રિટ્રાય (retry) પર કીનો ફરીથી ઉપયોગ કરવામાં આવે છે?
- શું સર્વર ડુપ્લીકેટ કી માટે સંગ્રહિત પરિણામો પરત કરે છે?
- શું લાંબા કાર્યો માટે મધ્યવર્તી સ્ટેપ્સ (intermediate steps) સેવ કરવામાં આવે છે?
પેટર્ન એ જ છે. માત્ર સ્તર (layer) બદલાયું છે.