AI એજન્ટો અને સાધનનો ઉપયોગ

નફો:

• એજન્ટને 'મોડેલ + ટૂલ્સ + લૂપ' તરીકે વ્યાખ્યાયિત કરવું અને ક્યારે તેની જરૂર પડે તે નક્કી કરવું
• નામ, વર્ણન અને input_schema સાથે સાધનની વ્યાખ્યા લખવી
• ટૂલ_ઉપયોગ અને ટૂલ_રિઝલ્ટ લૂપના ફ્લો અને એરર હેન્ડલિંગનું નિરીક્ષણ કરવું

અત્યાર સુધી, મોડેલે હંમેશા એક જ કામ કર્યું છે: ટેક્સ્ટ ઇનપુટ મેળવો, ટેક્સ્ટ પ્રતિસાદ આપો. પરંતુ વાસ્તવિક કાર્યને ઘણીવાર ટેક્સ્ટ કરતાં વધુની જરૂર હોય છે; ગણતરી કરવી, ડેટાબેઝની પૂછપરછ કરવી, API ને કૉલ કરવો, વર્તમાન વિનિમય દર શોધવા. મોડેલ આ વસ્તુઓ જાતે કરી શકતું નથી - પરંતુ તે નક્કી કરી શકે છે કે તે ક્યારે કરવાની જરૂર છે અને કોઈને તે કરવા માટે કહી શકે છે. આ તે છે જે સાધનનો ઉપયોગ મોડેલ આપે છે, અને આ એઆઈ એજન્ટોનો આધાર છે. આ એકમમાં, આપણે જાણીશું કે એજન્ટ શું છે, ટૂલ કેવી રીતે વ્યાખ્યાયિત કરવામાં આવે છે અને સાધન_ઉપયોગ લૂપ કેવી રીતે કાર્ય કરે છે.

એજન્ટ શું છે? મોડલ + ટૂલ્સ + લૂપ

AI એજન્ટમાં ત્રણ ભાગોનો સમાવેશ થાય છે: મોડેલ (નિર્ણય લેતું મગજ), ટૂલ્સ (જે કાર્યોને મોડેલ કૉલ કરી શકે છે: હવામાન, ડેટાબેઝ ક્વેરી, ઇમેઇલ મોકલો), અને લૂપ (લૂપ; મોડેલ ટૂલને કૉલ કરે છે, પરિણામ મેળવે છે, ફરીથી શું કરવું તે નક્કી કરે છે, વગેરે).

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

એક મહત્વપૂર્ણ હકીકત: મોડેલ પોતે વાહન ચલાવતું નથી. મોડેલ ફક્ત કહે છે "હું આ ઇનપુટ્સ સાથે આ સાધનને કૉલ કરવા માંગુ છું". તમારી એપ્લિકેશન (જેને હાર્નેસ કહેવાય છે) ટૂલ ચલાવે છે અને પરિણામને મોડેલ પર પરત કરે છે. સુરક્ષા માટે આ મહત્વપૂર્ણ છે: મોડેલ સીધી તમારી સિસ્ટમને સ્પર્શતું નથી; દરેક ક્રિયા તમારા નિયંત્રણ હેઠળ છે.

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

સાધનની વ્યાખ્યા: નામ, વર્ણન, input_schema

મોડેલમાં ટૂલ દાખલ કરવા માટે, તમે ત્રણ વસ્તુઓ આપો:

• નામ: વાહનની ઓળખ, દા.ત. get_weather.
• વર્ણન: સાધન શું કરે છે અને તેને ક્યારે બોલાવવું. આ સૌથી મહત્વપૂર્ણ ક્ષેત્ર છે જે મોડેલને યોગ્ય સમયે યોગ્ય સાધન પસંદ કરવાની મંજૂરી આપે છે. ફક્ત "શું કરે છે" લખો નહીં પણ "ક્યારે કૉલ કરો" પણ લખો.
• input_schema (ઇનપુટ સ્કીમા): JSON સ્કીમા જે વ્યાખ્યાયિત કરે છે કે સાધન કયા પરિમાણોની અપેક્ષા રાખે છે, કયા પ્રકારમાં.

# વાહનની વ્યાખ્યા (વૈકલ્પિક — JSON સ્કીમા){ "નામ": "get_order_status", "description": "ઑર્ડરની વર્તમાન શિપિંગ સ્થિતિ પુનઃપ્રાપ્ત કરે છે. જ્યારે વપરાશકર્તા પૂછે કે ઑર્ડર નંબર ક્યાં છે અથવા તે ક્યારે આવશે.", "input_schema": { "type": "object", "properties": "description": "description": {{} "ઓર્ડર નંબર, દા.ત. SP-1024"} }, "જરૂરી": ["order_no"] }}

સારા ટૂલના વર્ણન માટેના નિયમો: સ્પષ્ટ અને સંક્ષિપ્ત નામ, "ક્યારે ઉપયોગ કરવો" સાથેનું વર્ણન, દરેક પરિમાણ માટેનું વર્ણન, ખરેખર ફરજિયાતને જરૂરી મૂકવું. વાહનોની સંખ્યા કેન્દ્રિત રાખો; ડઝનબંધ સમાન વાહન મોડેલો આશ્ચર્યજનક છે.

વિસ્તાર

તે શું કરે છે?

સારું ઉદાહરણ

ખરાબ ઉદાહરણ

નામ

વાહન ID

order_status_getir

લાવો

વર્ણન

તે શું કરે છે + ક્યારે કૉલ કરવો

"કાર્ગો સ્થિતિ પરત કરે છે; જ્યારે વપરાશકર્તા પૂછે કે ઓર્ડર ક્યાં છે ત્યારે કૉલ કરો"

"ડેટા લાવે છે"

input_schema

પરિમાણ પ્રકાર અને જરૂરિયાત

{ઓર્ડર_નો: શબ્દમાળા, ટીકા}

કોઈ ડાયાગ્રામ / કોઈ વર્ણન નથી

સાધન_ઉપયોગ → સાધન_પરિણામ લૂપ

ચક્ર આ રીતે કાર્ય કરે છે, પગલું દ્વારા:

1. તમે મોડેલને વપરાશકર્તા પ્રશ્ન + સાધન વર્ણન મોકલો.
2. મોડેલ કાં તો સીધો પ્રતિસાદ આપે છે અથવા ટૂલ_ઉપયોગ બ્લોક જનરેટ કરે છે: "ઓર્ડર_નો=SP-1024 સાથે ઓર્ડર_દુરુમુ_ગેટિરને કૉલ કરો."
3. તમારી એપ્લિકેશન વાસ્તવમાં ટૂલ ચલાવે છે (ડેટાબેઝને પૂછે છે).
4. તમે પરિણામને ટૂલ_રિઝલ્ટ તરીકે મોડલ પર પાછા મોકલો.
5. આ પરિણામ સાથે, મોડેલ કાં તો અંતિમ જવાબ ઉત્પન્ન કરે છે અથવા અન્ય સાધનને કૉલ કરે છે. જ્યાં સુધી મોડેલ કહે "મારું થઈ ગયું" ત્યાં સુધી ચક્ર ચાલુ રહે છે.

# એજન્ટ લૂપ (વૈકલ્પિક)સંદેશાઓ = [user_question]જ્યારે સાચું: પ્રતિભાવ = model.uret(messages, tools=tool_definitions) if response.tur == "ટૂલ_ઉપયોગ": પરિણામ = harness.run(response.tool_name, response.entries) # એપ્લિકેશન રન કરે છે (response.tool_name, response.entries) # APPLICATION સંદેશાઓ ચલાવે છે, # ફાઈનલ રિટર્ન પરિણામ += રિટર્ન. પ્રતિભાવ લૂપ છેડા

આધુનિક SDK ટૂલ રનર્સ ઓફર કરે છે જે તમારા માટે આ લૂપ ચલાવે છે; તમે ફક્ત સાધન કાર્યો લખો. પરંતુ પડદા પાછળ જે થઈ રહ્યું છે તે બરાબર છે.

ભૂલ વ્યવસ્થાપન

ટૂલ્સ નિષ્ફળ થઈ શકે છે: ઓર્ડર મળ્યો નથી, API સમય સમાપ્ત થયો છે, ઇનપુટ અમાન્ય છે. જો તમે ટૂલ ચલાવી શકતા નથી, તો એક વર્ણનાત્મક સાધન_પરિણામ ("ભૂલ: ઓર્ડર નંબર SP-9999 મળ્યો નથી") અને ભૂલ ફ્લેગ તરીકે મોડેલમાં ભૂલ પરત કરો. મૉડલ આ જોઈ શકે છે અને વપરાશકર્તાને હળવાશથી સમજાવી શકે છે અથવા બીજી રીત અજમાવી શકે છે. ભૂલને ગળી જશો નહીં અને ખાલી પરિણામો પરત કરશો નહીં; મોડેલને ખબર હોવી જોઈએ કે શું ખોટું થયું છે.

નબળા/મજબૂત વાહનનું વર્ણન

નબળા (અનિશ્ચિત સંજ્ઞા, "ક્યારે" નહીં):

નામ: "ડેટા", વર્ણન: "ડેટા મેળવે છે"# મોડેલને ખબર નથી કે ક્યારે અને કેવી રીતે કૉલ કરવો; તે કાં તો બિલકુલ કૉલ કરતો નથી અથવા ખોટી રીતે કૉલ કરે છે.

મજબૂત (ચોખ્ખું નામ + જ્યારે + પરિમાણ વર્ણન):

નામ: "musteri_bakiyesi_getir"વર્ણન: "ગ્રાહકનું ચાલુ એકાઉન્ટ બેલેન્સ પરત કરે છે. જ્યારે વપરાશકર્તા ડેબિટ, ક્રેડિટ અથવા બેલેન્સ માટે પૂછે ત્યારે કૉલ કરો. ચુકવણી કરતું નથી."input_schema: {custeri_id: string ("Customer ID")}# મોડલ તેની યોગ્ય મર્યાદા સાથે, યોગ્ય સમયે કૉલ કરે છે, જાણો.

ત્રણ મિની કેસ

કેસ 1 - બિનજરૂરી એજન્ટ. એક ટીમે મલ્ટી-ટૂલ એજન્ટ સાથે "ટેક્સ્ટનો સારાંશ" વ્યવસાય બનાવ્યો; દરેક રીકેપમાં 4 મોડલ કોલ્સ અને 9 સેકન્ડ લાગે છે. જોબ વાસ્તવમાં એક-કોલની નોકરી હતી. જ્યારે અમે એજન્ટને દૂર કર્યો અને તેને એક કૉલમાં ઘટાડી દીધો, ત્યારે સમય ઘટીને 1.5 સેકન્ડ થઈ ગયો અને કિંમત ઘટીને એક ક્વાર્ટર થઈ ગઈ. પાઠ: જ્યારે ખરેખર જરૂરી હોય ત્યારે એજન્ટનો ઉપયોગ કરો.

કેસ 2 - નબળું સમજૂતી, ખોટો કોલ. સપોર્ટ એજન્ટમાં, બેલેન્સ પ્રશ્ન અને શિપિંગ પ્રશ્ન બંનેમાં મોડલ દ્વારા અવ્યવસ્થિત રીતે ફેચ નામનું એક અસ્પષ્ટ સાધન બોલાવવામાં આવ્યું હતું. જ્યારે વાહનોને બેલેન્સ_ગેટિર અને કાર્ગો_દુરુમુ_ગેટિરમાં વિભાજિત કરવામાં આવ્યા હતા અને "ક્યારે કૉલ કરો" સમજૂતી ઉમેરવામાં આવી હતી, ત્યારે વાહનની ખોટી પસંદગી 50 ઉદાહરણોમાં 18 થી ઘટીને 1 થઈ ગઈ હતી.

કેસ 3 - ભૂલ ગળી ગઈ. જ્યારે ઓર્ડર મળ્યો ન હતો ત્યારે એજન્ટ ખાલી પરિણામો પરત કરી રહ્યો હતો; મોડેલે આને "ઓર્ડર વિતરિત કરવામાં આવ્યો" તરીકે અર્થઘટન કર્યું અને ગ્રાહકને ગેરમાર્ગે દોર્યા. જ્યારે ટૂલ_રિઝલ્ટ ("ઓર્ડર મળ્યો નથી") પર ભૂલનો સંદેશ સ્પષ્ટ રીતે લખવામાં આવે છે, ત્યારે મોડેલ યોગ્ય રીતે કહે છે "મને આ નંબર મળી શક્યો નથી, શું તમે તેને તપાસી શકો છો?" તેણે કહેવાનું શરૂ કર્યું.

સામાન્ય ભૂલો

• બધું એજન્ટ તરફ ફેરવવું: જ્યારે એક કૉલ પૂરતો છે, ત્યારે એજન્ટ ખર્ચ અને વિલંબ ઉમેરે છે.
• અસ્પષ્ટ વાહન વર્ણન: મોડેલને ખબર નથી કે ક્યારે કૉલ કરવો; ખોટું પસંદ કરે છે.
• એવું વિચારીને કે મોડેલ વાહન ચલાવે છે: હાર્નેસ વાહન ચલાવે છે; મોડેલ ફક્ત ઇચ્છે છે.
• ભૂલને ગળી જવું: મોડેલને ખબર હોવી જોઈએ કે શું ખોટું થયું છે; ઓપન ટૂલ_રિઝલ્ટ તરીકે ભૂલ આપો.
• ઘણા બધા સમાન વાહનો: મોડેલ મૂંઝવણમાં આવે છે; ટૂલસેટને કેન્દ્રિત અને ન્યૂનતમ રાખો.

ધ્યાન: માત્ર કારણ કે મોડેલ કહે છે કે "તે વાહનને કૉલ કરો" નો અર્થ એ નથી કે પગલાં લેવા જોઈએ. વિનાશક સાધનો પર (ડિલીટ, ચેકઆઉટ, ઈમેઈલ) તમારી એપ્લીકેશનને આંખ બંધ કરીને કોલ એક્ઝીક્યુટ ન કરવો જોઈએ — આ આગલા યુનિટમાં સુરક્ષા વિષયનો મુખ્ય ભાગ છે.

સારાંશમાં

• એજન્ટ = મોડેલ (નિર્ણય) + સાધનો (કાર્યો) + લૂપ (કૉલ ટૂલ, પરિણામ મેળવો, ફરીથી નિર્ણય કરો).
• સિંગલ પેટર્ન કૉલ એ એજન્ટ નથી; એજન્ટ એ એક પગલું-દર-પગલાની પ્રક્રિયા છે.
• મોડેલ વાહન ચલાવતું નથી; તમારી એપ્લિકેશન ચાલે છે (હાર્નેસ) અને પરિણામ ટૂલ_રિઝલ્ટ તરીકે આપે છે.
• ટૂલને નામ, વર્ણન (ખાસ કરીને "ક્યારે કૉલ કરો"), અને input_schema દ્વારા ઓળખવામાં આવે છે.
• લૂપ ટૂલ_ઉપયોગ → હાર્નેસ રન તરીકે ચાલુ રહે છે → સાધન_પરિણામ → મોડલ જ્યાં સુધી મોડલ "થઈ ગયું" ના કહે ત્યાં સુધી ચાલુ રહે છે; ભૂલો સ્પષ્ટપણે મોડેલને જાણ કરવામાં આવે છે.

એપ્લિકેશન કાર્ય

તમારા પોતાના વ્યવસાયમાંથી 3 ટૂલ્સ ડિઝાઇન કરો જે એજન્ટને આપી શકાય. (1) દરેક માટે નામ, "કૉલ ક્યારે" સાથે વર્ણન અને ઇનપુટ_સ્કીમા લખો; ઓછામાં ઓછું એક બિન-વિનાશક વાંચન સાધન છે અને એક ગણતરી છે. (2) એક વાસ્તવિક વપરાશકર્તા પ્રશ્ન પસંદ કરો અને મેન્યુઅલી સ્ટેપ બાય સ્ટેપ (લૂપમાં) લખો કે આમાંથી કયા ટૂલ્સને મોડેલ કયા ઇનપુટ્સ સાથે કૉલ કરશે અને ટૂલ_રિઝલ્ટ આવ્યા પછી તે શું કરશે. (3) એક દૃશ્ય સેટ કરો જેમાં એક સાધન નિષ્ફળ જાય અને બતાવો કે કેવી રીતે ભૂલ સંદેશો મોડેલ પર પાછો આવશે.

ચેકલિસ્ટ

• [ ] હું એજન્ટને "મોડેલ + ટૂલ્સ + લૂપ" તરીકે વ્યાખ્યાયિત કરી શકું છું અને તે ક્યારે જરૂરી છે તે નક્કી કરી શકું છું.
• [ ] હું જાણું છું કે હાર્નેસ વાહન ચલાવે છે, મોડેલ ફક્ત તે ઇચ્છે છે.
• હું [ ] નામ, વર્ણન ("ક્યારે કૉલ કરો") અને ઇનપુટ_સ્કેમા સાથે નક્કર વાહનનું વર્ણન લખી શકું છું.
• હું [ ] tool_use → tool_result ચક્રને સ્ટેપ બાય સ્ટેપ ફોલો કરી શકું છું.
• [ ] હું ટૂલની ભૂલોને મોડલને ઓપન ટૂલ_રિઝલ્ટ તરીકે જાણ કરું છું.