LangChain एजेंटिक AI दस्तावेज़ीकरण: टूल्स और JSON मोड
अधिकांश LangChain एजेंटिक AI दस्तावेज़ीकरण एक वेंडर के अपने मॉडल क्लास को मानते हैं, लेकिन एक बार जब आप base URL सेट कर देते हैं, तो कोई भी OpenAI-संगत एंडपॉइंट ChatOpenAI के साथ काम करता है। यह गाइड LangChain को इस API से जोड़ती है और चरण दर चरण टूल-कॉलिंग एजेंट बनाती है।
अपडेट किया गया
मुख्य बिंदु
- base_url को इस API पर सेट करके ChatOpenAI का उपयोग करें और मॉडल को
uncensoredपर सेट करें। - टूल कॉलिंग और JSON मोड का समर्थन किया जाता है, इसलिए bind_tools और response_format दस्तावेज़ीकरण के अनुसार काम करते हैं।
- एजेंट लूप को सीमित करें, टूल तर्कों की जांच करें और पूर्ण कुंजी पर max_concurrency को 8 या उससे कम रखें।
- SSE के माध्यम से स्ट्रीमिंग अंत में टोकन उपयोग लौटाता है, जो आपको प्रत्येक एजेंट रन की लागत ट्रैक करने में मदद करता है।

शुरू करने से पहले आपको क्या चाहिए
यदि आप LangChain एजेंटिक AI दस्तावेज़ पढ़ रहे हैं और यह सोच रहे हैं कि उदाहरणों में मॉडल वेंडर से नहीं होने पर क्या बदलाव आते हैं, तो उत्तर बहुत कम है। LangChain में एक एजेंट एक लूप है: मॉडल बातचीत पढ़ता है, यह तय करता है कि क्या टूल कॉल करना है, आपका कोड टूल चलाता है, और परिणाम वापस मॉडल में जाता है जब तक कि यह अंतिम उत्तर न दे। मॉडल एंडपॉइंट को टूल कॉलिंग के साथ chat completions का समर्थन करना होता है, और यह API ऐसा ही करता है।
आपको तीन चीज़ों की आवश्यकता है: कुंजी पृष्ठ से एक API कुंजी, Python 3.10 या नया संस्करण, और नीचे दिए गए पैकेज। बेस URL है https://api.unlimitedaiapi.com/v1 और मॉडल ID है uncensored। यह एक ओपन-वेट मॉडल है जो एक स्वतंत्र प्रदाता द्वारा चलाया जाता है, इसलिए चुनने के लिए कोई मॉडल सूची नहीं है; GET /v1/models क्लाइंट खोज के लिए इसे लौटाता है।
pip install -U langchain langchain-openai
export UNLIMITED_API_KEY="your-key-here"चरण 1: ChatOpenAI को एंडपॉइंट से कनेक्ट करें
LangChain की ChatOpenAI क्लास एक कस्टम base_url लेती है। इसके बारे में बाकी सब कुछ वही रहता है, जिसमें invoke, stream, batch और async वेरिएंट शामिल हैं।
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.unlimitedaiapi.com/v1",
api_key=os.environ["UNLIMITED_API_KEY"],
temperature=0.2,
)
print(llm.invoke("Reply with one short sentence.").content)
यदि यह एक वाक्य प्रिंट करता है, तो प्रमाणीकरण, रूटिंग और मॉडल का नाम सभी सही हैं। प्रमाणीकरण मानक Authorization: Bearer हेडर है, जो क्लास आपके लिए जोड़ती है। एक सामान्य गलती base URL में /v1 छोड़ देना है, जिससे आमतौर पर पहला कॉल विफल हो जाता है।
चरण 2: टूल्स परिभाषित करें और उन्हें बाइंड करें
टूल्स सादे Python फ़ंक्शन होते हैं जिनमें docstring होती है। docstring और टाइप हिंट्स वह स्कीमा बन जाते हैं जिसे मॉडल देखता है, इसलिए उन्हें इस तरह लिखें जैसे आप किसी नए सहकर्मी को फ़ंक्शन समझा रहे हों।
import os
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
@tool
def get_order_status(order_id: str) -> str:
'''Look up the status of an order by its ID, for example A100.'''
return {"A100": "shipped", "A101": "processing"}.get(order_id, "not found")
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.unlimitedaiapi.com/v1",
api_key=os.environ["UNLIMITED_API_KEY"],
temperature=0,
)
llm_with_tools = llm.bind_tools([get_order_status])
ai = llm_with_tools.invoke("Where is order A100?")
print(ai.tool_calls)
प्रिंट की गई सूची में get_order_status नाम और {"order_id": "A100"} जैसे तर्कों के साथ एक कॉल है। पर्दे के पीछे LangChain आपके फ़ंक्शन को chat completions अनुरोध के tools सरणी में एक प्रविष्टि के रूप में भेजता है, और API tools, tool_choice और स्ट्रीम्ड tool_calls का समर्थन करता है। टूल कॉल को बाध्य करने के लिए, bind_tools को tool_choice पास करें।
तापमान कम क्यों है
एजेंट कई मॉडल कॉल को चेन करते हैं, इसलिए एक गलत प्रारूप वाला तर्क पूरे रन को बिगाड़ सकता है। 0 से 0.2 का तापमान टूल चयन को अधिक दोहराने योग्य बनाता है। यदि आप अधिक विविध पाठ चाहते हैं, तो इसे केवल अंतिम उत्तर चरण के लिए बढ़ाएं।
चरण 3: एजेंट लूप चलाएं
लूप खुद लिखने में पंद्रह पंक्तियाँ लगती हैं और यह प्रत्येक चरण पर क्या होता है, यह दिखाती हैं, जो कुछ गलत होने पर मदद करती है। टूल परिणाम मॉडल को ToolMessage ऑब्जेक्ट्स के रूप में वापस भेजे जाते हैं, जो वायर पर role: "tool" संदेश बन जाते हैं।
import os
from langchain_core.messages import HumanMessage, ToolMessage
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
@tool
def get_order_status(order_id: str) -> str:
'''Look up the status of an order by its ID, for example A100.'''
return {"A100": "shipped", "A101": "processing"}.get(order_id, "not found")
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.unlimitedaiapi.com/v1",
api_key=os.environ["UNLIMITED_API_KEY"],
temperature=0,
)
tools = {"get_order_status": get_order_status}
llm_with_tools = llm.bind_tools(list(tools.values()))
messages = [HumanMessage("Where is order A100, and what about A101?")]
for _ in range(5): # hard cap on loop length
ai = llm_with_tools.invoke(messages)
messages.append(ai)
if not ai.tool_calls:
break
for call in ai.tool_calls:
result = tools[call["name"]].invoke(call["args"])
messages.append(ToolMessage(content=str(result), tool_call_id=call["id"]))
print(ai.content)
range(5) पर ध्यान दें। एक एजेंट बिना स्टेप लिमिट के भ्रमित करने वाले टूल परिणाम पर अनंत लूप में फंस सकता है, और हर पास अब तक की पूरी बातचीत के लिए इनपुट टोकन खर्च करता है। पाँच सरल कार्यों के लिए एक उचित ऊपरी सीमा है; इसे जानबूझकर बढ़ाएं।
प्रीबिल्ट एजेंट हेल्पर का उपयोग करें
हाल के LangChain वर्जन आपके लिए यह लूप चलाने वाला एक हेल्पर शामिल है। नाम और इम्पोर्ट पथ रिलीज के बीच बदल गया है, इसलिए इंस्टॉल किए गए वर्जन के दस्तावेज़ों से उनकी पुष्टि करें। वर्तमान 1.x लाइन में यह इस तरह दिखता है:
import os
from langchain.agents import create_agent
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
@tool
def get_order_status(order_id: str) -> str:
'''Look up the status of an order by its ID, for example A100.'''
return {"A100": "shipped", "A101": "processing"}.get(order_id, "not found")
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.unlimitedaiapi.com/v1",
api_key=os.environ["UNLIMITED_API_KEY"],
temperature=0,
)
agent = create_agent(llm, tools=[get_order_status], system_prompt="You are a concise support assistant.")
result = agent.invoke({"messages": [{"role": "user", "content": "Where is order A100?"}]})
print(result["messages"][-1].content)
जब आपको मानक पैटर्न चाहिए तो हेल्पर का उपयोग करें, और जब आपको कस्टम स्टॉपिंग नियम, प्रति स्टेप लॉगिंग, या टूल परिणाम चाहिए जिन्हें मॉडल देखने से पहले फ़िल्टर करना हो तो हाथ से लिखे लूप का उपयोग करें।
JSON मोड के साथ संरचित आउटपुट
एजेंट को अक्सर डेटा को अन्य कोड, जैसे कि एक योजना, वर्गीकरण या निकाले गए फ़ील्ड्स की सूची को, सौंपने की आवश्यकता होती है। JSON मोड प्रतिक्रिया को एक मान्य JSON ऑब्जेक्ट बना देता है। LangChain में आप इसे bind के माध्यम से पास कर सकते हैं:
import json
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.unlimitedaiapi.com/v1",
api_key=os.environ["UNLIMITED_API_KEY"],
temperature=0,
)
json_llm = llm.bind(response_format={"type": "json_object"})
msg = json_llm.invoke(
"Extract the city and country from: 'I moved to Lyon, France last spring.' "
"Answer as JSON with the keys city and country."
)
print(json.loads(msg.content))
प्रॉम्प्ट में JSON शब्द का उल्लेख करें और उदाहरण की तरह उन कुंजियों का वर्णन करें जिन्हें आप उम्मीद करते हैं। JSON मोड सिंटैक्स की गारंटी देता है, आपकी स्कीमा की नहीं, इसलिए अभी भी पार्स किए गए ऑब्जेक्ट की जाँच करें (उदाहरण के लिए, Pydantic के साथ) और एक गायब कुंजी को संभालें।
एजेंट रन के लिए लिमिट, स्ट्रीमिंग और लागत
एजेंट्स कम समय में कई कॉल करते हैं, इसलिए खाता सीमाएँ एक साधारण चैटबॉट की तुलना में अधिक महत्वपूर्ण होती हैं। एक पूर्ण कुंजी 8 समानांतर अनुरोध और प्रति मिनट 300 अनुरोध की अनुमति देती है। एक ट्रायल कुंजी 2 और 60 की अनुमति देती है। यदि आप batch के साथ समानांतर चलाते हैं या एक साथ कई एजेंट्स चलाते हैं, तो कॉन्फ़िगरेशन में समानांतरता को सीमित करें:
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.unlimitedaiapi.com/v1",
api_key=os.environ["UNLIMITED_API_KEY"],
)
prompts = ["Name one prime number.", "Name one even number.", "Name one square number."]
answers = llm.batch(prompts, config={"max_concurrency": 8})
for a in answers:
print(a.content)
ट्रायल कुंजी पर 8 की जगह 2 का उपयोग करें। इंटरैक्टिव एजेंट्स के लिए, llm.stream(...) टोकन को SSE के माध्यम से लौटाता है जैसे ही वे उत्पन्न होते हैं, और उपयोग संख्याएं स्ट्रीम के अंत में आती हैं।
लागत का अनुमान लगाना आसान है। 5-चरणों की एक रन में प्रति चरण औसतन 4,000 इनपुट टोकन और 300 आउटपुट टोकन का उपयोग होता है, जिसमें कुल 20,000 इनपुट और 1,500 आउटपुट टोकन लगते हैं, जो 1M टोकन के लिए $0.15 और $0.50 की दर से प्रति रन $0.003 + $0.00075 = $0.00375 आता है। मूल्य निर्धारण पृष्ठ पर दरें दी गई हैं, और दस्तावेज़ में अनुरोध पैरामीटर और हेडर सूचीबद्ध हैं, जिसमें X-Request-Id शामिल है जो एक अकेले विफल कॉल को ट्रैक करने के लिए है।
मॉडल द्वारा उपयोग किए जाने वाले टूल डिज़ाइन करना
अधिकतर एजेंट विफलताएं लूप की नहीं, बल्कि टूल की ओर संकेत करती हैं। किसी भी मॉडल के लिए कुछ नियम मदद करते हैं:
- प्रत्येक टूल को संकीर्ण रखें।
get_order_statusनाम का टूलdatabase_queryनाम के उस टूल से बेहतर काम करता है जो खुला टेक्स्ट लेता है। - सरल तर्क प्रकार का उपयोग करें: स्ट्रिंग्स, पूर्णांक और छोटे enum। गहराई से नेस्टेड ऑब्जेक्ट्स मॉडल को फ़ील्ड में गलती करने के अधिक तरीके देते हैं।
- छोटे, स्पष्ट परिणाम लौटाएं। एक टूल जो बातचीत में 50,000 वर्ण डंप करता है, कॉन्टेक्स्ट विंडो को भर देता है और हर बाद के स्टेप की लागत बढ़ा देता है।
- त्रुटियों को पाठ के रूप में लौटाएं, जैसे "order_id A100 की तरह दिखना चाहिए", रन को समाप्त करने वाले एक्सेप्शन फेंकने के बजाय।
स्केल अप करने से पहले $0.50 के ट्रायल क्रेडिट के साथ कुछ वास्तविक प्रॉम्प्ट्स पर एजेंट का परीक्षण करें। नए उपयोगकर्ता कुंजी पृष्ठ पर एक क्लिक के साथ इसे प्राप्त करते हैं, और यह 7 दिनों के लिए मान्य होता है।
पहली जांच की जाने वाली चुनौतियाँ
- टूल कॉल कभी दिखाई नहीं देता। डॉकस्ट्रिंग को विशिष्ट बनाएँ, तापमान कम करें, या
tool_choiceसे कॉल को बाध्य करें। - अमान्य तर्क। टूल के अंदर सत्यापित करें और एक स्पष्ट त्रुटि स्ट्रिंग लौटाएँ, ताकि मॉडल अगले चरण पर स्वयं को ठीक कर सके।
- कॉन्टेक्स्ट वृद्धि। विंडो में जवाब सहित 100,000 टोकन हैं। विंडो भर जाने से पहले पुराने टूल आउटपुट को काटें।
अधिक गाइड
प्रश्न और उत्तर
LangChain की कौन सी क्लास इस API के साथ काम करती है?
langchain-openai से ChatOpenAI। base_url को https://api.unlimitedaiapi.com/v1 पर सेट करें, मॉडल को uncensored पर रखें और अपनी कुंजी api_key के रूप में पास करें।
क्या API एजेंट्स के लिए टूल कॉलिंग का समर्थन करता है?
हाँ। यह tools और tool_choice पैरामीटर स्वीकार करता है, tool_calls लौटाता है (स्ट्रीमिंग के दौरान भी), और परिणामों को role: tool वाले संदेशों के रूप में लेता है।
क्या LangChain इस API के माध्यम से संरचित आउटपुट को पार्स कर सकता है?
हाँ, JSON मोड के माध्यम से: response_format को json_object टाइप पर सेट करें। यह वैध JSON सिंटैक्स सुनिश्चित करता है, इसलिए फ़ील्ड्स का स्वयं सत्यापन करें।
मैं समानांतर कितने एजेंट चला सकता हूँ?
एक पूर्ण कुंजी 8 समानांतर अनुरोधों और प्रति मिनट 300 की अनुमति देती है। ट्रायल कुंजी प्रति मिनट 2 समानांतर और 60 की अनुमति देती है।
आपकी कुंजी बस एक फ़ॉर्म दूर है
एक खाता बनाएँ, कुंजी कॉपी करें, बेस URL बदलें। सेटअप यही है।