API कुंजी के बिना LangChain और LangGraph

"बिना API कुंजी के" का व्यावहारिक अर्थ क्या हो सकता है

langchain और langraph बिना api key खोजना आमतौर पर तीन में से किसी एक का अर्थ होता है। आप शायद यह जानने से पहले भुगतान नहीं करना चाहते कि स्टैक काम करता है या नहीं। आप शायद किसी और विक्रेता को अपना क्रेडिट कार्ड नहीं देना चाहते। या आप शायद बिना किसी क्रेडेंशियल के एक एजेंट ग्राफ़ चलाकर देखना चाहते हैं।

तीसरी इच्छा किसी होस्टेड सर्विस द्वारा पूरी नहीं की जा सकती: एक सर्वर जो आपके लिए काम करता है, उसे यह जानना होगा कि कौन कॉल कर रहा है। आप जो प्राप्त कर सकते हैं वह एक कुंजी है जिसकी कोई लागत नहीं है और जिसमें कार्ड की आवश्यकता नहीं है। इस साइट पर नए उपयोगकर्ता Google या ईमेल और पासवर्ड से साइन इन करने के बाद API कुंजी पेज पर एक क्लिक से $0.50 का मुफ़्त ट्रायल क्रेडिट दावा कर सकते हैं। यह एक व्यक्ति के लिए एक बार मान्य है और 7 दिनों के लिए मान्य है।

"बिना कुंजी" का दूसरा मार्ग एक स्थानीय मॉडल है जो आपके अपने मशीन पर कुछ द्वारा चलाया जाता है। यह काम करता है, लेकिन आपको हार्डवेयर की जिम्मेदारी लेनी होगी, और एक लैपटॉप लंबे एजेंट रन के लिए एक होस्टेड एंडपॉइंट के बराबर नहीं होगा। एक होस्टेड ट्रायल यह पता लगाने का तेज़ तरीका है कि क्या आपका ग्राफ़ लॉजिक सही है, और आपका लिखा गया कोड उसी कोड के समान है जिसे आप बाद में फंडेड कुंजी के साथ चलाएंगे।

चूँकि एंडपॉइंट OpenAI-संगत है, LangChain को किसी विशेष इंटीग्रेशन की आवश्यकता नहीं है। आप अपने OpenAI चैट क्लास को एक अलग बेस URL की ओर निर्देशित करते हैं, उसे कुंजी देते हैं, और मॉडल को uncensored नाम देते हैं। नीचे दिया गया सब कुछ उसी सेटअप को मानता है।

चरण 1: ट्रायल कुंजी प्राप्त करें और वातावरण सेट करें

साइन अप करें, कुंजी पेज खोलें और ट्रायल बटन दबाएँ। कुंजी को कॉपी करें और इसे अपने रिपॉजिटरी से बाहर रखें। इसे एक एन्वायरनमेंट वेरिएबल में डालें ताकि एक ही स्क्रिप्ट आज ट्रायल कुंजी और बाद में पूर्ण कुंजी के साथ काम करे।

Copyexport UNCENSORED_API_KEY="paste-your-key-here"
pip install -U langchain-openai langgraph langchain-core

किसी फ्रेमवर्क को शामिल करने से पहले, एक सादे अनुरोध के साथ कुंजी की जाँच करें। इसमें दो मिनट लगते हैं, जो वास्तव में प्रमाणीकरण त्रुटियाँ होने वाले स्टैक ट्रेस को पढ़ने में एक घंटे की बचत करवाते हैं।

Copycurl https://api.stableaudio.top/v1/chat/completions \
  -H "Authorization: Bearer $UNCENSORED_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"uncensored","messages":[{"role":"user","content":"Reply with one word: ready"}]}'

एक GET /v1/models कॉल एक अन्य त्वरित जाँच है; इसमें uncensored सूचीबद्ध होना चाहिए। ट्रायल कुंजी 2 समानांतर अनुरोधों और प्रति मिनट 60 अनुरोधों की अनुमति देती है, जो एक ग्राफ़ विकसित करने के लिए पर्याप्त है, लेकिन जब आप समानांतर नोड जोड़ें तो इसे याद रखना महत्वपूर्ण है।

चरण 2: LangChain को एंडपॉइंट की ओर निर्देशित करें

उपयोग करने योग्य क्लास ChatOpenAI है जो langchain-openai से आती है। दो तर्क काम करते हैं: base_url और api_key। मॉडल का नाम uncensored है, और सामान्य सैंपलिंग सेटिंग्स पास की जाती हैं।

Copyimport os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.stableaudio.top/v1",
    api_key=os.environ["UNCENSORED_API_KEY"],
    temperature=0.7,
    max_retries=3,
)

print(llm.invoke("Give me three titles for an ambient track about rain.").content)

यदि यह टेक्स्ट प्रिंट करता है, तो कनेक्शन अच्छा है। स्ट्रीमिंग उसी तरह काम करती है: llm.stream(...) पर इटरेट करें और चंक सर्वर-सेंट इवेंट्स के माध्यम से आते हैं, जिसका उपयोग स्ट्रीम के अंत में रिपोर्ट किया जाता है।

एक सामान्य गलती OPENAI_API_KEY वेरिएबल को एक पुराने प्रोजेक्ट से सेट छोड़ देना है। LangChain यदि आप api_key पास करना भूल जाएँ तो उस मान को आपके कस्टम बेस URL पर भेज देगा। कुंजी को स्पष्ट रूप से पास करें और आप अनिश्चितता को हटा दें।

चरण 3: एक न्यूनतम LangGraph ग्राफ़

LangGraph एजेंट को नोड्स के बीच स्थानांतरित होने वाली स्थिति के रूप में मॉडल करता है। सबसे छोटा उपयोगी ग्राफ़ एक नोड होता है जो मॉडल को कॉल करता है और जवाब को एक संदेश सूची में जोड़ता है। MessagesState आपको वह सूची मुफ़्त में देता है।

Copyfrom langgraph.graph import StateGraph, MessagesState, START, END

def call_model(state: MessagesState):
    reply = llm.invoke(state["messages"])
    return {"messages": [reply]}

builder = StateGraph(MessagesState)
builder.add_node("model", call_model)
builder.add_edge(START, "model")
builder.add_edge("model", END)
graph = builder.compile()

out = graph.invoke({"messages": [("user", "Outline a three-act short story about a lighthouse keeper.")]})
print(out["messages"][-1].content)

यह जानबूझकर सादा है। बात यह है कि LangGraph में कुछ भी नहीं जानता या परवाह नहीं करता कि llm के पीछे कौन सा प्रोवाइडर बैठा है। कोई भी नोड एक अलग मॉडल ऑब्जेक्ट ले सकता है, इसलिए आप बाद में एक सस्ते प्लानिंग स्टेप और एक लंबे लेखन स्टेप को उनकी अपनी सेटिंग्स दे सकते हैं, जैसे कि प्लानिंग के लिए कम तापमान।

चरण 4: टूल्स और लूप जोड़ें

एजेंट तब दिलचस्प होते हैं जब मॉडल फ़ंक्शन कॉल कर सके। एंडपॉइंट tools और tool_choice के साथ फ़ंक्शन कॉलिंग का समर्थन करता है, और टूल परिणाम role: "tool" संदेशों के रूप में वापस आते हैं। LangChain और LangGraph आपके लिए वह प्लंबिंग संभालते हैं।

Copyfrom langchain_core.tools import tool
from langgraph.prebuilt import ToolNode, tools_condition

@tool
def word_count(text: str) -> int:
    'Count the words in a piece of text.'
    return len(text.split())

tools = [word_count]
llm_with_tools = llm.bind_tools(tools)

def agent(state: MessagesState):
    return {"messages": [llm_with_tools.invoke(state["messages"])]}

builder = StateGraph(MessagesState)
builder.add_node("agent", agent)
builder.add_node("tools", ToolNode(tools))
builder.add_edge(START, "agent")
builder.add_conditional_edges("agent", tools_condition)
builder.add_edge("tools", "agent")
graph = builder.compile()

result = graph.invoke({"messages": [("user", "Write a 40-word product blurb, then check its word count with the tool.")]})
print(result["messages"][-1].content)

लूप ही मुख्य विचार है: एजेंट नोड उत्तर देता है, tools_condition जाँच करता है कि क्या उत्तर में टूल की आवश्यकता है, टूल नोड उसे निष्पादित करता है, और नियंत्रण एजेंट के पास वापस आ जाता है। जब उत्तर में कोई टूल कॉल नहीं होती है, तो ग्राफ़ समाप्त हो जाता है।

ओपन-वेट मॉडल अपने टूल तर्कों की व्यवस्था में भिन्न होते हैं। यदि कॉल खराब रूप से आती है, तो टूल के docstring को सटीक करें, तापमान कम करें और तर्क स्कीमा को छोटा रखें। छोटी, टाइप की गई स्कीमा लंबी स्कीमा की तुलना में कम बार विफल होती है जिसमें कई वैकल्पिक फ़ील्ड होती हैं।

रेट लिमिट, पुनः प्रयास और समानांतर शाखाएँ

एजेंट ग्राफ़्स में सबसे ज़्यादा जहाँ फँसते हैं, वह कन्करेंसी है। एक फुल कुंजी 8 समानांतर अनुरोध और प्रति मिनट 300 अनुरोधों की अनुमति देती है; एक ट्रायल कुंजी 2 और 60 की अनुमति देती है। यदि आपका ग्राफ़ ट्रायल कुंजी पर पाँच समानांतर नोड्स में फैलता है, तो उनमें से तीन HTTP 429 के साथ concurrency त्रुटि कोड के साथ अस्वीकार कर दिए जाएँगे। प्रति मिनट बजट से अधिक जाने पर rate_limited लौटाया जाता है। अस्थायी ओवरलोड भी Retry-After: 5 हेडर के साथ 429 देता है।

इसे प्रबंधित रखने के लिए तीन आदतें:

• max_retries को ChatOpenAI पर 2 या 3 पर रखें ताकि छोटे 429 को बैकऑफ़ के साथ पुनः प्रयास किया जा सके।
• अपनी कन्करेंसी सीमा पर फैन-आउट को सीमित करें। LangGraph में, आप ग्राफ़ को कॉल करते समय config={"max_concurrency": 2} पास कर सकते हैं।
• याद रखें कि एक स्ट्रीम किए गए अनुरोध में उसकी स्लॉट तब तक बनी रहती है जब तक स्ट्रीम समाप्त न हो जाए, इसलिए एक धीमा कंज्यूमर स्लॉट को व्यस्त रखता है।

Copyout = graph.invoke(
    {"messages": [("user", "Draft five taglines in parallel.")]},
    config={"max_concurrency": 2},
)

प्रतिक्रिया हेडर डिबगिंग में मदद करते हैं। X-Request-Id एक कॉल की पहचान करता है यदि आपको उस बारे में सहायता से पूछना है, और X-Balance-USD प्रत्येक अनुरोध के बाद आपकी शेष क्रेडिट दिखाता है।

जब ग्राफ़ गलत व्यवहार करता है तो डिबगिंग चेकलिस्ट

पहले LangGraph प्रोजेक्ट में अधिकांश विफलताएँ मॉडल से नहीं होती हैं। वे कॉन्फ़िगरेशन से आती हैं, और एक छोटी चेकलिस्ट लगभग सभी को पकड़ लेती है।

1. 401 या प्रमाणीकरण त्रुटियाँ। कुंजी गायब है, गलत टाइप की गई है, या एक पुरानी OPENAI_API_KEY पढ़ी जा रही है। उस मान के पहले चार अक्षर प्रिंट करें जिसका उपयोग आपका स्क्रिप्ट वास्तव में कर रहा है।
2. 404 या मॉडल नहीं मिला। मॉडल का नाम uncensored होना चाहिए। यदि आपको यकीन नहीं है कि एंडपॉइंट क्या सूचीबद्ध करता है, तो GET /v1/models कॉल करें।
3. कनेक्शन त्रुटियाँ। बेस URL को /v1 पर समाप्त होना चाहिए और इसमें /chat/completions शामिल नहीं होना चाहिए; क्लाइंट उस भाग को जोड़ता है।
4. अनंत लूप। यदि एजेंट लगातार एक टूल को कॉल करता है, तो टूल का रिटर्न मान प्रश्न का उत्तर नहीं दे रहा हो सकता है। सादे, छोटे स्ट्रिंग लौटाएँ और ग्राफ़ कॉन्फ़िग के माध्यम से रिकर्सन सीमा सेट करें ताकि एक खराब लूप जल्दी रुक जाए।
5. खाली या अजीब उत्तर। रन के बाद पूर्ण संदेश सूची प्रिंट करें। अक्सर एक पूर्व नोड ने एक सिस्टम संदेश लिखा होता है जो बाद वाले के विरोधाभासी होता है।

जब सर्वर साइड पर कोई अनुरोध विफल होता है, तो अपने संदेश में X-Request-Id हेडर का ज़िक्र करें support को। इससे उन्हें बिना अनुमान लगाए उसी कॉल को ढूँढने में मदद मिलती है। यह भी ध्यान रखें कि विफल या अस्वीकृत अनुरोधों के लिए चार्ज नहीं किया जाता, इसलिए त्रुटियों से भरी डीबगिंग सत्र आपका मुफ़्त ट्रायल क्रेडिट खत्म नहीं करता।

एक और डिज़ाइन बिंदु। प्रत्येक नोड को एक संकीर्ण कार्य और एक छोटा प्रॉम्प्ट दें। एक ग्राफ़ जिसमें एक प्लैन्नर, एक राइटर और एक चेकर होता है, जिनमें से प्रत्येक का अपना छोटा सिस्टम संदेश होता है, एकल नोड की तुलना में आसानी से परीक्षण योग्य होता है जिसके पास निर्देशों का एक पेज होता है, और प्रत्येक टुकड़े को सीधे llm.invoke कॉल के साथ अकेले आजमाया जा सकता है, इसे वायर करने से पहले।

एक ट्रायल रन का वास्तविक खर्च

मूल्य निर्धारण प्रीपेड क्रेडिट से प्रति 1M इनपुट टोकन के लिए $0.15 और प्रति 1M आउटपुट टोकन के लिए $0.50 है। विफल या अस्वीकृत अनुरोधों के लिए चार्ज नहीं किया जाता है। एजेंट ग्राफ़ प्रत्येक कार्य के लिए मॉडल को कई बार कॉल करते हैं, और हर कॉल बढ़ते संदेश सूची को फिर से भेजती है, इसलिए इनपुट टोकन प्रमुख होते हैं।

छह मॉडल कॉल के साथ एक रन लें। मान लें कि प्रत्येक कॉल 3,000 टोकन इनपुट भेजती है और 400 टोकन आउटपुट लौटाती है। यह 18,000 इनपुट टोकन और 2,400 आउटपुट टोकन है।

• इनपुट: 18,000 / 1,000,000 x $0.15 = $0.0027
• आउटपुट: 2,400 / 1,000,000 x $0.50 = $0.0012
• कुल: प्रति रन $0.0039

$0.50 के ट्रायल को $0.0039 से विभाजित करने पर उस आकार के लगभग 128 रन मिलते हैं, जो एक ग्राफ़ को ठीक से बनाने और परीक्षण करने के लिए पर्याप्त हैं। जब आप उससे आगे निकल जाते हैं, तो टॉप-अप $20 से $500 तक पूर्ण राशि में होते हैं, $50 से 5% बोनस, $100 से 10% और $200 से 15% बोनस के साथ; मूल्य निर्धारण पेज पर विवरण उपलब्ध है। आप कार्ड (Visa, Mastercard, Apple Pay, Google Pay) या क्रिप्टो (TRC20 पर USDT, Base पर USDC) से भुगतान कर सकते हैं। क्रेडिट कभी खत्म नहीं होता, और प्रॉम्प्ट को प्रशिक्षण के लिए उपयोग नहीं किया जाता है।

प्रॉम्प्ट और पूर्णता के लिए कॉन्टेक्स्ट विंडो 100,000 टोकन की है, इसलिए लंबे एजेंट इतिहास फिट हो सकते हैं, लेकिन आपको हर टोकन के लिए भुगतान करना होगा जिसे आप फिर से भेजते हैं। LangGraph के संदेश उपयोगिताओं के साथ पुराने संदेशों को काटने से लागत और लेटेंसी कम रहती है। इसके पीछे के कच्चे अनुरूप प्रारूप के लिए, API दस्तावेज़ देखें।

अधिक गाइड

• टेक्स्ट टू ऑडियो LLM: यह क्या कर सकता है और क्या नहीं
• वीडियो प्रॉम्प्ट्स के लिए बिना सेंसर टेक्स्ट API