లాభాలు:
- ఏజెంట్ను 'మోడల్ + టూల్స్ + లూప్'గా నిర్వచించడం మరియు అది ఎప్పుడు అవసరమో నిర్ణయించడం
- పేరు, వివరణ మరియు ఇన్పుట్_స్కీమాతో సాధనం నిర్వచనాన్ని వ్రాయడం
- tool_use మరియు tool_result లూప్ యొక్క ఫ్లో మరియు ఎర్రర్ హ్యాండ్లింగ్ను పర్యవేక్షిస్తోంది
ఇప్పటి వరకు, మోడల్ ఎల్లప్పుడూ ఒక పనిని చేస్తుంది: టెక్స్ట్ ఇన్పుట్ను స్వీకరించండి, వచన ప్రతిస్పందనలను ఉత్పత్తి చేయండి. కానీ నిజమైన పని తరచుగా టెక్స్ట్ కంటే ఎక్కువ అవసరం; గణన చేయడం, డేటాబేస్ను ప్రశ్నించడం, APIకి కాల్ చేయడం, ప్రస్తుత మారకపు రేటును కనుగొనడం. మోడల్ ఈ పనులను స్వయంగా చేయలేకపోతుంది - కానీ అవి ఎప్పుడు చేయాలో ఆమె నిర్ణయించుకోవచ్చు మరియు వాటిని చేయమని ఎవరినైనా అడగవచ్చు. ఈ సాధనం ఉపయోగం మోడల్ను ఇస్తుంది మరియు ఇది AI ఏజెంట్లకు ఆధారం. ఈ యూనిట్లో, ఏజెంట్ అంటే ఏమిటి, సాధనం ఎలా నిర్వచించబడింది మరియు tool_use లూప్ ఎలా పనిచేస్తుందో తెలుసుకుందాం.
ఏజెంట్ అంటే ఏమిటి? మోడల్ + టూల్స్ + లూప్
AI ఏజెంట్ మూడు భాగాలను కలిగి ఉంటుంది: మోడల్ (నిర్ణయం తీసుకునే మెదడు), సాధనాలు (మోడల్ కాల్ చేయగల విధులు: వాతావరణం, డేటాబేస్ ప్రశ్న, ఇమెయిల్ పంపడం) మరియు లూప్ (లూప్; మోడల్ సాధనాన్ని పిలుస్తుంది, ఫలితాన్ని పొందుతుంది, ఏమి చేయాలో మళ్లీ నిర్ణయిస్తుంది మరియు మొదలైనవి).
క్లిష్టమైన వ్యత్యాసం: ఒకే నమూనా కాల్ ఏజెంట్ కాదు. ఏజెంట్ అనేది ఒక ప్రక్రియ, దీనిలో మోడల్ దశలవారీగా కొనసాగుతుంది, ప్రతి దశలో సాధన ఫలితం ఆధారంగా తదుపరి కదలికను ఎంచుకుంటుంది. "మనిషిలా ఆలోచించండి, మీ చేతులను ఉపయోగించండి, ఫలితం చూడండి, మళ్ళీ ఆలోచించండి."
ఒక ముఖ్యమైన వాస్తవం: మోడల్ వాహనాన్ని ఆపరేట్ చేయదు. మోడల్ కేవలం "నేను ఈ ఇన్పుట్లతో ఈ సాధనాన్ని పిలవాలనుకుంటున్నాను" అని చెప్పింది. మీ అప్లికేషన్ (హార్నెస్ అని పిలుస్తారు) సాధనాన్ని అమలు చేస్తుంది మరియు ఫలితాన్ని మోడల్కి అందిస్తుంది. భద్రతకు ఇది చాలా ముఖ్యమైనది: మోడల్ నేరుగా మీ సిస్టమ్ను తాకదు; ప్రతి చర్య మీ నియంత్రణలో ఉంటుంది.
చిట్కా: ఏజెంట్తో ప్రతి సమస్యను పరిష్కరించడానికి ప్రయత్నించవద్దు. ఏజెంట్; ఆలస్యం, ఖర్చులు మరియు లోపాల ప్రమాదాన్ని పెంచుతుంది. ముందుగా అడగండి: "ఇది ఒకే కాల్ లేదా స్థిర వర్క్ఫ్లోతో పరిష్కరించబడుతుందా?" సమాధానం అవును అయితే, ఏజెంట్ అవసరం లేదు. ఏజెంట్ అనేది ఓపెన్-ఎండెడ్ టాస్క్ల కోసం, స్టెప్లు ముందుగానే తెలియవు.
సాధనం నిర్వచనం: పేరు, వివరణ, ఇన్పుట్_స్కీమా
మోడల్లో సాధనాన్ని పరిచయం చేయడానికి, మీరు మూడు విషయాలను ఇస్తారు:
- పేరు: వాహనం యొక్క గుర్తింపు, ఉదా. పొందండి_వాతావరణం.
- వివరణ: సాధనం ఏమి చేస్తుంది మరియు దానిని ఎప్పుడు పిలవాలి. మోడల్ సరైన సమయంలో సరైన సాధనాన్ని ఎంచుకోవడానికి అనుమతించే అత్యంత ముఖ్యమైన ప్రాంతం ఇది. "ఏమి చేస్తుంది" అని మాత్రమే కాకుండా "ఎప్పుడు కాల్ చేయండి" అని కూడా వ్రాయండి.
- input_schema (ఇన్పుట్ స్కీమా): JSON స్కీమా, సాధనం ఏ పారామితులను ఆశించాలో, ఏ రకంలో ఉంటుందో నిర్వచిస్తుంది.
# వాహన నిర్వచనం (సంభావిత — JSON స్కీమా){ "name": "get_order_status", "description": "ఆర్డర్ యొక్క ప్రస్తుత షిప్పింగ్ స్థితిని తిరిగి పొందుతుంది. వినియోగదారు ఆర్డర్ నంబర్ ఎక్కడ ఉంది లేదా ఎప్పుడు వస్తుంది అని అడిగినప్పుడు కాల్ చేయండి.", "input_schema": { "type": "object"no:" {"type": "object"no:" "properties:" "properties" "string", "description": "ఆర్డర్ నంబర్, ఉదా. SP-1024"} }, "అవసరం": ["order_no"] }}
మంచి సాధనం వివరణ కోసం నియమాలు: స్పష్టమైన మరియు సంక్షిప్త పేరు, "ఎప్పుడు ఉపయోగించాలి"తో వివరణ, ప్రతి పరామితి కోసం వివరణ, అవసరమైన వాటిలో నిజంగా తప్పనిసరి వాటిని ఉంచడం. వాహనాల సంఖ్యను దృష్టిలో ఉంచుకోండి; ఇలాంటి డజన్ల కొద్దీ వాహన నమూనాలు ఆశ్చర్యం కలిగిస్తాయి.
ప్రాంతం
అది ఏమి చేస్తుంది?
మంచి ఉదాహరణ
చెడ్డ ఉదాహరణ
పేరు
వాహన ID
ఆర్డర్_స్టేటస్_గెటిర్
తీసుకురండి
వివరణ
అది ఏమి చేస్తుంది + ఎప్పుడు కాల్ చేయాలి
"కార్గో స్థితిని అందిస్తుంది; ఆర్డర్ ఎక్కడ ఉందని వినియోగదారు అడిగినప్పుడు కాల్ చేయండి"
"డేటా పొందుతుంది"
ఇన్పుట్_స్కీమా
పారామీటర్ రకం మరియు అవసరం
{order_no: స్ట్రింగ్, వ్యాఖ్యానం}
రేఖాచిత్రం లేదు / వివరణ లేదు
tool_use → tool_result లూప్
చక్రం ఇలా పనిచేస్తుంది, దశల వారీగా:
- మీరు వినియోగదారు ప్రశ్న + సాధనం వివరణలను మోడల్కి పంపుతారు.
- మోడల్ నేరుగా ప్రతిస్పందిస్తుంది లేదా టూల్_యూజ్ బ్లాక్ని ఉత్పత్తి చేస్తుంది: "order_no=SP-1024తో order_durumu_getirకు కాల్ చేయండి."
- మీ అప్లికేషన్ వాస్తవానికి సాధనాన్ని అమలు చేస్తుంది (డేటాబేస్ను ప్రశ్నిస్తుంది).
- మీరు ఫలితాన్ని టూల్_రిజల్ట్గా మోడల్కి తిరిగి పంపుతారు.
- ఈ ఫలితంతో, మోడల్ తుది సమాధానాన్ని ఉత్పత్తి చేస్తుంది లేదా మరొక సాధనాన్ని కాల్ చేస్తుంది. మోడల్ "నేను పూర్తి చేసాను" అని చెప్పే వరకు చక్రం కొనసాగుతుంది.
# ఏజెంట్ లూప్ (conceptual)messages = [user_question]నిజమైనవేళ: ప్రతిస్పందన = model.uret(messages, tools=tool_definitions) if response.tur == "tool_use": result = harness.run(response.tool_name, response.entries) # APPLICATION రెస్పాన్ మెసేజ్లు రిటర్న్, రిటర్న్ రిటర్న్ సందేశాలు += # తుది ప్రతిస్పందన; లూప్ ముగుస్తుంది
ఆధునిక SDKలు మీ కోసం ఈ లూప్ను అమలు చేసే టూల్ రన్నర్లను అందిస్తాయి; మీరు టూల్ ఫంక్షన్లను వ్రాస్తారు. అయితే తెరవెనుక అదే జరుగుతోంది.
లోపం నిర్వహణ
సాధనాలు విఫలం కావచ్చు: ఆర్డర్ కనుగొనబడలేదు, API సమయం ముగిసింది, ఇన్పుట్ చెల్లదు. మీరు సాధనాన్ని అమలు చేయలేకపోతే, వివరణాత్మక సాధనం_ఫలితం ("లోపం: ఆర్డర్ నంబర్ SP-9999 కనుగొనబడలేదు") మరియు ఎర్రర్ ఫ్లాగ్గా లోపాన్ని మోడల్కి తిరిగి ఇవ్వండి. మోడల్ దీన్ని చూడగలదు మరియు వినియోగదారుకు సున్నితంగా వివరించగలదు లేదా వేరొక విధంగా ప్రయత్నించవచ్చు. లోపాన్ని మింగవద్దు మరియు ఖాళీ ఫలితాలను తిరిగి ఇవ్వవద్దు; మోడల్ తప్పు ఏమిటో తెలుసుకోవాలి.
బలహీనమైన/బలమైన వాహన వివరణ
బలహీనమైన (నిరవధిక నామవాచకం, "ఎప్పుడు" కాదు):
పేరు: "డేటా", వివరణ: "డేటాను పొందుతుంది"# మోడల్కు ఎప్పుడు మరియు ఎలా కాల్ చేయాలో తెలియదు; ఇది అస్సలు కాల్ చేయదు లేదా తప్పుగా కాల్ చేస్తుంది.
బలమైన (నికర పేరు + ఎప్పుడు + పారామీటర్ వివరణ):
name: "musteri_bakiyesi_getir"వివరణ: "కస్టమర్ యొక్క కరెంట్ ఖాతా బ్యాలెన్స్ను తిరిగి ఇస్తుంది. వినియోగదారు డెబిట్, క్రెడిట్ లేదా బ్యాలెన్స్ కోసం అడిగినప్పుడు కాల్ చేయండి. చెల్లింపు చేయదు." input_schema: {custeri_id: string ("కస్టమర్ ID")}# మోడల్ సరైన సమయంలో, దాని పరిమితిని తెలుసుకుని, సరైన సమయంలో కాల్ చేస్తుంది.
మూడు మినీ కేసులు
కేసు 1 - అనవసరమైన ఏజెంట్. ఒక బృందం మల్టీ-టూల్ ఏజెంట్తో "టెక్స్ట్ సారాంశం" వ్యాపారాన్ని నిర్మించింది; ప్రతి రీక్యాప్కు 4 మోడల్ కాల్లు మరియు 9 సెకన్లు పడుతుంది. ఉద్యోగం నిజానికి వన్-కాల్ జాబ్. మేము ఏజెంట్ని తీసివేసి, ఒకే కాల్కి తగ్గించినప్పుడు, సమయం 1.5 సెకన్లకు తగ్గింది మరియు ఖర్చు పావు వంతుకు తగ్గింది. పాఠం: నిజంగా అవసరమైనప్పుడు ఏజెంట్ని ఉపయోగించండి.
కేసు 2 - బలహీనమైన వివరణ, తప్పు కాల్. సపోర్ట్ ఏజెంట్లో, బ్యాలెన్స్ ప్రశ్న మరియు షిప్పింగ్ క్వశ్చన్ రెండింటిలోనూ మోడల్ ద్వారా పొందడం అనే అస్పష్ట సాధనం యాదృచ్ఛికంగా పిలువబడుతుంది. వాహనాలను balance_getir మరియు cargo_durumu_getirగా విభజించి, "కాల్ చేసినప్పుడు" వివరణలను జోడించినప్పుడు, తప్పు వాహనం ఎంపిక 50 ఉదాహరణలలో 18 నుండి 1కి తగ్గింది.
కేస్ 3 - ఎర్రర్ మింగబడింది. ఆర్డర్ కనుగొనబడనప్పుడు ఏజెంట్ ఖాళీ ఫలితాలను తిరిగి ఇస్తున్నారు; మోడల్ దీనిని "ఆర్డర్ డెలివరీ చేయబడింది" అని వ్యాఖ్యానించింది మరియు కస్టమర్ను తప్పుదారి పట్టించింది. దోష సందేశం tool_result ("ఆర్డర్ కనుగొనబడలేదు")కి స్పష్టంగా వ్రాసినప్పుడు, మోడల్ సరిగ్గా "నేను ఈ నంబర్ను కనుగొనలేకపోయాను, మీరు దీన్ని తనిఖీ చేయగలరా?" అతను చెప్పడం ప్రారంభించాడు.
సాధారణ తప్పులు
- అన్నింటినీ ఏజెంట్గా మార్చడం: ఒక కాల్ సరిపోతుంది, ఏజెంట్ ఖర్చు మరియు ఆలస్యాన్ని జోడిస్తుంది.
- అస్పష్టమైన వాహన వివరణ: మోడల్కు ఎప్పుడు కాల్ చేయాలో తెలియదు; తప్పు ఎంచుకుంటుంది.
- మోడల్ వాహనాన్ని నడుపుతుందని ఆలోచిస్తూ: జీను వాహనాన్ని నడుపుతుంది; మోడల్ కేవలం కోరుకుంటున్నారు.
- లోపాన్ని మింగడం: మోడల్ ఏమి తప్పు జరిగిందో తెలుసుకోవాలి; లోపాన్ని ఓపెన్ టూల్_రిజల్ట్గా ఇవ్వండి.
- చాలా సారూప్య వాహనాలు: మోడల్ గందరగోళానికి గురవుతుంది; టూల్సెట్ను ఫోకస్గా మరియు కనిష్టంగా ఉంచండి.
శ్రద్ధ: మోడల్ "ఆ వాహనానికి కాల్ చేయండి" అని చెప్పినందున చర్య తీసుకోవాలి అని కాదు. విధ్వంసక సాధనాలపై (తొలగించు, చెక్అవుట్, ఇమెయిల్) మీ అప్లికేషన్ గుడ్డిగా కాల్ని అమలు చేయకూడదు - ఇది తదుపరి యూనిట్లోని భద్రతా అంశం యొక్క ప్రధాన అంశం.
సారాంశంలో
- ఏజెంట్ = మోడల్ (నిర్ణయం) + సాధనాలు (ఫంక్షన్లు) + లూప్ (కాల్ టూల్, ఫలితాన్ని పొందండి, మళ్లీ నిర్ణయించండి).
- ఒకే నమూనా కాల్ ఏజెంట్ కాదు; ఏజెంట్ అనేది దశల వారీ ప్రక్రియ.
- మోడల్ వాహనాన్ని నడపదు; మీ అప్లికేషన్ రన్ (హార్నెస్) మరియు ఫలితాన్ని tool_resultగా అందిస్తుంది.
- సాధనం పేరు, వివరణ (ప్రత్యేకంగా "ఎప్పుడు కాల్") మరియు ఇన్పుట్_స్కీమా ద్వారా గుర్తించబడుతుంది.
- లూప్ టూల్_యూజ్ → హార్నెస్ రన్ → టూల్_ఫలితం → మోడల్ "పూర్తయింది" అని చెప్పే వరకు కొనసాగుతుంది; లోపాలు మోడల్కు స్పష్టంగా నివేదించబడ్డాయి.
అప్లికేషన్ టాస్క్
ఏజెంట్కు ఇవ్వగలిగే మీ స్వంత వ్యాపారం నుండి 3 సాధనాలను రూపొందించండి. (1) ప్రతిదానికీ పేరు, వివరణ "కాల్ ఎప్పుడు" మరియు ఇన్పుట్_స్కీమాతో వ్రాయండి; కనీసం ఒకటి నాన్-డిస్ట్రక్టివ్ రీడింగ్ టూల్ మరియు ఒకటి గణనగా ఉండనివ్వండి. (2) వాస్తవిక వినియోగదారు ప్రశ్నను ఎంచుకుని, మాన్యువల్గా దశలవారీగా వ్రాయండి (లూప్లో) వీటిలో మోడల్ ఏ ఇన్పుట్లతో కాల్ చేస్తుంది మరియు tool_result వచ్చిన తర్వాత అది ఏమి చేస్తుంది. (3) సాధనాల్లో ఒకటి విఫలమయ్యే దృష్టాంతాన్ని సెటప్ చేయండి మరియు దోష సందేశం మోడల్కు ఎలా తిరిగి వస్తుందో చూపుతుంది.
చెక్లిస్ట్
- [ ] నేను ఏజెంట్ను "మోడల్ + టూల్స్ + లూప్"గా నిర్వచించగలను మరియు అది ఎప్పుడు అవసరమో నిర్ణయించుకోగలను.
- [ ] జీను వాహనం నడుపుతుందని నాకు తెలుసు, మోడల్ దానిని కోరుకుంటుంది.
- నేను [ ] పేరు, వివరణ ("కాల్ ఎప్పుడు") మరియు ఇన్పుట్_స్కీమాతో ఘన వాహన వివరణను వ్రాయగలను.
- నేను [ ] tool_use → tool_result సైకిల్ను దశలవారీగా అనుసరించగలను.
- [ ] నేను టూల్ లోపాలను మోడల్కి ఓపెన్ టూల్_రిజల్ట్గా నివేదిస్తాను.