टूल का उपयोग
टूल का उपयोग (अक्सर फ़ंक्शन कॉलिंग कहा जाता है) यह है कि एक भाषा मॉडल अपने स्वयं के पाठ बॉक्स से परे कैसे पहुंचता है: आप इसे फ़ंक्शन की एक सूची देते हैं जिसे वह चलाने के लिए कह सकता है, और यह तय करता है कि उन्हें कब उपयोग करना है। मॉडल कभी भी स्वयं कुछ नहीं चलाता है, यह केवल कॉल का अनुरोध करता है, और आपका कोड काम करता है।
एक मॉडल अपने आप एक बॉक्स में बंद है। यह आज का मौसम नहीं देख सकता, आपके डेटाबेस में एक उपयोगकर्ता को नहीं देख सकता, या एक ईमेल नहीं भेज सकता। यह केवल जो सीखा है उससे पाठ का अनुमान लगाता है, प्रशिक्षण समय पर जमे हुए, एलएलएम कैसे काम करते हैं से समान चित्र। टूल का उपयोग यह है कि आप इसे बॉक्स से बाहर पहुंचने देते हैं, और यह वह आधार है जिस पर एजेंट बनाए गए हैं।
याद रखने योग्य शब्द "पूछना" है। मॉडल आपको बताता है कि कौन सा फ़ंक्शन वह चाहता है और किन तर्कों के साथ। आपका कोड इसे चलाता है और परिणाम वापस देता है। आप पूरे समय नियंत्रण में रहते हैं।
लूप
टूल का उपयोग एक आगे-पीछे है, एकल कॉल नहीं:
- आप उपयोगकर्ता का संदेश साथ ही टूल की एक सूची भेजते हैं जिसका मॉडल उपयोग कर सकता है।
- मॉडल दो तरीकों में से एक में उत्तर देता है: एक सामान्य उत्तर, या एक टूल को कॉल करने का अनुरोध, जिसमें वह तर्क चाहता है।
- अगर इसने एक टूल के लिए कहा, तो आपका कोड उस फ़ंक्शन को चलाता है और परिणाम को मॉडल को वापस भेज देता है।
- मॉडल परिणाम का उपयोग करके अपना अंतिम उत्तर लिखता है।
बस यही संपूर्ण पैटर्न है। मॉडल पूछता है, आपका कोड चलाता है। चरण 2 और 3 दोहराए जा सकते हैं यदि मॉडल को कई टूल की आवश्यकता है, जो एजेंट की शुरुआत है कुछ अध्याय आगे।
वास्तव में क्या हो रहा है
टूल का उपयोग ऐसा लग सकता है कि मॉडल को नई शक्तियां मिलीं, और उसे ऐसा नहीं हुआ। हुड के तहत, मॉडल वह एक काम कर रहा है जो वह हमेशा करता है: पाठ की भविष्यवाणी करना। इसके बॉक्स में वह कुछ नहीं बदला है।
जब आप अनुरोध में टूल परिभाषाएं शामिल करते हैं, तो आप उन्हें संदर्भ में जोड़ रहे हैं जिससे मॉडल भविष्यवाणी करता है। मॉडल को ऐसे उदाहरणों पर प्रशिक्षित किया गया था जहां, इस तरह के टूल दिए गए, सही निरंतरता कभी-कभी एक विशेष रूप से स्वरूपित संदेश होता है जिसका अर्थ है "कॉल get_weather शहर दिल्ली के साथ" एक सामान्य वाक्य के बजाय। इसलिए जब आपका प्रश्न एक टूल को उपयोगी दिखाता है, तो सबसे संभावित अगला आउटपुट वह संरचित टूल-कॉल संदेश है, और एपीआई इसे आपको tool_calls के रूप में सतह देता है।
मॉडल किसी चीज़ तक पहुंचा नहीं है और कुछ नहीं चलाया है। इसने भविष्यवाणी की है कि एक टूल कॉल सही कदम है और एक प्रारूप में एक अनुरोध लिखा है जिसे आपका कोड पढ़ना जानता है।
फिर आप, मॉडल नहीं, फ़ंक्शन चलाते हैं। आप वास्तविक परिणाम लेते हैं और इसे संदेशों में अधिक संदर्भ के रूप में वापस रखते हैं, और मॉडल उस विस्तारित संदर्भ से अपना अंतिम उत्तर भविष्यवाणी करता है। पूरी सुविधा दो साधारण भविष्यवाणियां हैं जिसमें आपका कोड बीच में वास्तविक काम करता है।
आप मॉडल के पाठ बॉक्स और वास्तविक दुनिया के बीच पुल हैं। उस चित्र को पकड़ें और अध्याय का बाकी हिस्सा, एजेंट शामिल हैं, रहस्यमय महसूस करना बंद कर देंगे: हर कार्रवाई जो एआई लेता है वह एक भविष्यवाणीयुक्त अनुरोध है जिसे आपका कोड चलाने के लिए चुनता है।
tool_calls के रूप में सौंपता है। मॉडल कभी कुछ नहीं चलाता है, यह एक अनुरोध की भविष्यवाणी करता है। आपका कोड फ़ंक्शन चलाता है और परिणाम को अगली भविष्यवाणी के लिए अधिक संदर्भ के रूप में वापस करता है, इसलिए आप मॉडल और वास्तविक दुनिया के बीच पुल हैं। एक टूल को परिभाषित करना
आप प्रत्येक टूल को मॉडल के लिए वर्णन करते हैं: इसका नाम, यह क्या करता है, और इसे किन तर्कों की आवश्यकता है। विवरण आपके लिए दस्तावेज़ नहीं है, यह टूल के बारे में मॉडल को एक निर्देश है, इसलिए इसे एक प्रॉम्प्ट की तरह लिखें।
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get the current weather for a city. Use when the user asks about weather.",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string", "description": "The city name, e.g. 'Delhi'"},
},
"required": ["city"],
},
},
},
]parameters ब्लॉक एक स्कीमा है, संरचित आउटपुट के समान विचार: यह तर्कों को परिभाषित करता है जिसे मॉडल को उत्पादन करना चाहिए। जब मॉडल get_weather को कॉल करने का निर्णय लेता है, तो यह इस आकृति से मेल खाने वाली एक city तर्क भेजता है। एक अस्पष्ट विवरण ("मौसम प्राप्त करता है") मॉडल को गलत क्षणों में टूल का उपयोग करने के लिए जन्म देता है। एक स्पष्ट ("जब उपयोगकर्ता मौसम के बारे में पूछता है तो उपयोग करें") इसे अच्छी तरह से गाइड करता है।
parameters स्कीमा है। विवरण वास्तव में एक प्रॉम्प्ट है: यह मॉडल को बताता है कि टूल को कब कॉल करना है, इसलिए सावधानी से इसे लिखें। पैरामीटर स्कीमा संरचित आउटपुट के समान तंत्र है, मॉडल भेजता है कि तर्कों को सीमित करता है। कॉल को संभालना
जब मॉडल एक टूल चाहता है, तो उत्तर में tool_calls होते हैं बजाय एक अंतिम उत्तर के। आप अनुरोधित फ़ंक्शन और तर्कों को पढ़ते हैं, वास्तविक फ़ंक्शन को चलाते हैं, और परिणाम को tool संदेश के रूप में वापस भेजते हैं। फिर आप मॉडल को फिर से कॉल करते हैं इसलिए यह समाप्त कर सकता है।
import json
# टूल का वास्तविक कार्यान्वयन
def get_weather(city):
# एक वास्तविक ऐप में यह मौसम एपीआई को कॉल करता है; यहां हम इसे नकली करते हैं
return {"city": city, "tempC": 18, "condition": "cloudy"}
messages = [{"role": "user", "content": "What's the weather in Delhi?"}]
# 1. पहली कॉल: टूल की पेशकश करें
response = client.chat.completions.create(model=MODEL, messages=messages, tools=tools)
tool_calls = response.choices[0].message.tool_calls
tool_call = tool_calls[0] if tool_calls else None
if tool_call:
# 2. मॉडल के तर्कों के साथ अनुरोधित फ़ंक्शन चलाएं
args = json.loads(tool_call.function.arguments)
result = get_weather(args["city"])
# 3. मॉडल के अनुरोध और आपका परिणाम वापस भेजें
messages.append(response.choices[0].message) # सहायक का टूल अनुरोध
messages.append({
"role": "tool",
"tool_call_id": tool_call.id,
"content": json.dumps(result),
})
# 4. फिर कॉल करें ताकि मॉडल परिणाम का उपयोग करके उत्तर दे सके
response = client.chat.completions.create(model=MODEL, messages=messages)
print(response.choices[0].message.content)
# "It's currently 18 degrees and cloudy in Delhi."तर्क JSON स्ट्रिंग के रूप में आते हैं, इसलिए आप उन्हें एक वास्तविक वस्तु में json.loads करते हैं, फिर उपयोग करने से पहले उन्हें जांचते हैं। आप इतिहास पर दो संदेश धक्का देते हैं: मॉडल का टूल अनुरोध और आपका tool परिणाम, tool_call_id से जुड़ा हुआ। अंतिम कॉल कच्चे मौसम डेटा को एक प्राकृतिक वाक्य में बदल देता है।
tool_calls होते हैं पाठ के बजाय। आप JSON स्ट्रिंग से तर्क को पार्स करते हैं, वास्तविक फ़ंक्शन चलाते हैं, और दो संदेश वापस धक्का देते हैं: मॉडल का अनुरोध और आपका परिणाम, tool_call_id से जुड़ा हुआ। एक अंतिम मॉडल कॉल आपके कच्चे परिणाम को एक प्राकृतिक उत्तर में बदल देता है। व्यवहार में
एक पुनर्प्रयोज्य फ़ंक्शन के रूप में समान प्रवाह। ध्यान दें कि मॉडल और आपके सिस्टम के बीच एकमात्र चीज़ आपके द्वारा लिखा गया कोड है और नियंत्रण:
import json
tool_impls = {"get_weather": lambda args: get_weather(args["city"])}
def answer_with_tools(user_text):
messages = [{"role": "user", "content": user_text}]
response = client.chat.completions.create(model=MODEL, messages=messages, tools=tools)
calls = response.choices[0].message.tool_calls
if not calls:
return response.choices[0].message.content # मॉडल सीधे उत्तर दिया
call = calls[0]
args = json.loads(call.function.arguments)
result = tool_impls[call.function.name](args)
messages.append(response.choices[0].message)
messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
response = client.chat.completions.create(model=MODEL, messages=messages)
return response.choices[0].message.contentयह एक टूल कॉल को संभालता है। एक मॉडल एक बार में कई भी अनुरोध कर सकता है, जिसे समानांतर टूल कॉल कहा जाता है, जिसे आप tool_calls में हर प्रविष्टि को लूप करके संभाले सकते हैं। और यदि आप मॉडल को लूप में टूल के लिए कॉल करना जारी रखने देते हैं जब तक यह किया नहीं जाता है, अपने अगले चरण का निर्णय हर बार ले रहा है, आप एक एजेंट प्राप्त करते हैं, जो ठीक वही जगह है जहां अगला अध्याय जाता है।