चार पंक्तियों में LangChain कनेक्ट करें
यदि आप कुछ भी होस्ट किए बिना langchain ओपन सोर्स मॉडल का उपयोग करना चाहते हैं, तो सबसे छोटा मार्ग एक OpenAI-कम्पैटिबल API है। LangChain की OpenAI चैट क्लास को इससे कोई फर्क नहीं पड़ता कि कौन जवाब देता है, बशर्ते एंडपॉइंट समान प्रोटोकॉल बोलता हो। आप base URL और कुंजी बदल देते हैं, और आपकी चेन्स, प्रॉम्प्ट्स और एजेंट्स का बाकी हिस्सा वैसा ही रहता है।
यह सेवा एक ओपन-वेट मॉडल होस्ट करती है, जिसे एक स्वतंत्र प्रदाता द्वारा चलाया जाता है और वयस्कों के वैध उपयोग के लिए बिना कंटेंट अस्वीकार किए उत्तर देने के लिए ट्यून किया गया है। यह किसी मॉडल विक्रेता की आधिकारिक API नहीं है और न ही यह विक्रेताओं के बीच एक रूटर है। पैकेज इंस्टॉल करें और मॉडल ऑब्जेक्ट बनाएं:
pip install langchain-openai langchain-core
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.uncensoredmodelhub.com/v1",
api_key="YOUR_API_KEY",
temperature=0.7,
)
print(llm.invoke("Give me three names for a fantasy tavern.").content)
यही पूरा कनेक्शन है। असली प्रोजेक्ट्स में कुंजी को एनवायरनमेंट वेरिएबल में रखें और उसे फ़ाइल में लिखने के बजाय os.environ से पढ़ें। यदि आपके पास अभी तक कोई कुंजी नहीं है, तो कुंजी पेज पर साइन अप करने और $0.50 के ट्रायल क्रेडिट का दावा करने का तरीका दिखाया गया है, जिसके लिए कार्ड की आवश्यकता नहीं है।
Node.js और LangChain.js
JavaScript पैकेज भी उसी विचार का पालन करता है, जहां बेस URL एक कॉन्फ़िगरेशन ऑब्जेक्ट के माध्यम से पास किया जाता है।
import { ChatOpenAI } from "@langchain/openai";
const llm = new ChatOpenAI({
model: "uncensored",
apiKey: process.env.API_KEY,
temperature: 0.7,
configuration: { baseURL: "https://api.uncensoredmodelhub.com/v1" },
});
const reply = await llm.invoke("Summarize the plot of a heist film in two lines.");
console.log(reply.content);
यदि आपको त्रुटि में 404 या एक HTML पेज दिखता है, तो बेस URL आमतौर पर गलत होता है। इसे /v1 पर समाप्त होना चाहिए। पृष्ठभूमि में दो एंडपॉइंट्स हैं POST /v1/chat/completions और GET /v1/models, और LangChain के चैट मॉडल के लिए कुछ और आवश्यक नहीं है।
क्या LangChain में एक ओपन सोर्स मॉडल होस्ट किया जाना बेहतर है या स्थानीय?
LangChain आपकी अपनी मशीन पर ओपन मॉडल भी चला सकता है, उदाहरण के लिए Ollama या एक लोकल सर्वर के माध्यम से। उस रास्ते के वास्तविक लाभ हैं, और इसे ईमानदारी से कहना उचित है। लोकल मॉडल में प्रति-टोकन शुल्क नहीं होता, ऑफलाइन काम करते हैं, और हर बाइट आपके हार्डवेयर पर रहता है। कीमत हार्डवेयर है: आपको उस मॉडल के लिए पर्याप्त GPU मेमोरी चाहिए जिसका आप चयन करते हैं, आपको रनटाइम बनाए रखना होता है, और थ्रूपुट आपकी मशीन द्वारा सीमित होता है।
| प्रश्न | स्थानीय सर्वर | यह होस्टेड API |
|---|---|---|
| अग्रिम लागत | हार्डवेयर या किराये की GPU | कोई नहीं; $20 से प्रीपेड क्रेडिट |
| प्रति-टोकन लागत | कोई नहीं, लेकिन बिजली और हार्डवेयर की खपत | $0.15 प्रति 1M इनपुट, $0.50 प्रति 1M आउटपुट |
| कॉन्टेक्स्ट विंडो | आपके पास कितनी मेमोरी है, इस पर निर्भर करता है | 100,000 टोकन |
| समानांतर अनुरोध | आपके सेटअप पर निर्भर करता है | एक पूर्ण कुंजी के लिए 8 |
| डेटा स्थान | आपकी मशीन | होस्टेड; प्रॉम्प्ट्स प्रशिक्षण के लिए उपयोग नहीं किए जाते |
एक सामान्य पैटर्न होस्टेड एंडपॉइंट के खिलाफ प्रोटोटाइप बनाना है, फिर वास्तविक टोकन गणना के साथ यह तय करना है कि क्या स्थानीय तैनाती समझ में आती है। चूंकि दोनों ओर OpenAI प्रोटोकॉल बोलते हैं, स्विचिंग base_url में एक लाइन बदलाव है, और आपकी बनाई गई चेन अपरिवर्तित रहती हैं। एक बिना सेंसर मॉडल क्या है पेज समझाता है कि ट्यूनिंग व्यवहार के बारे में क्या बदलाव लाती है।
टूल्स और एक सरल एजेंट
टूल कॉलिंग सामान्य OpenAI-शैली tools फ़ील्ड के माध्यम से जाती है, और LangChain का bind_tools आपके लिए एक डिकोरेटेड Python फ़ंक्शन से इसे बनाता है। मॉडल टूल कॉल अनुरोध लौटाता है, और परिणाम role: "tool" संदेशों के रूप में वापस जाते हैं।
from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent
@tool
def word_count(text: str) -> int:
'''Count the words in a piece of text.'''
return len(text.split())
agent = create_react_agent(llm, [word_count])
result = agent.invoke({"messages": [("user", "How many words are in 'the quick brown fox jumps'?")]})
print(result["messages"][-1].content)
एजेंट लूप मॉडल को कॉल करता है, जब मांगा जाता है तो टूल चलाता है, और मॉडल सादे टेक्स्ट में जवाब देने तक आउटपुट वापस भेजता है। दो सावधानियां लागू होती हैं। हर टूल को एक डॉकस्ट्रिंग दें जो मॉडल के लिए लिखी गई हो, क्योंकि वह टेक्स्ट ही है जिसे वह टूल चुनने के लिए पढ़ता है। और एजेंट्स पर एक रिकर्सन लिमिट सेट करें ताकि एक भ्रमित रन क्रेडिट खर्च करना जारी न रखे; LangGraph कॉन्फ़िगरेशन में recursion_limit स्वीकार करता है।
एजेंट के बिना सीधे नियंत्रण के लिए, llm.bind_tools([word_count]) का उपयोग करें और लौटाए गए संदेश पर .tool_calls को स्वयं निरीक्षित करें।
JSON मोड के साथ संरचित आउटपुट
एक्सट्रैक्शन जॉब्स के लिए, JSON मोड पैरामीटर को bind के माध्यम से पास करें। प्रॉम्प्ट को मॉडल को यह बताना चाहिए कि आपको कौन सी कीज़ चाहिए, क्योंकि JSON मोड इसे केवल एक वैध JSON ऑब्जेक्ट उत्पन्न करने के लिए धकेलता है।
import json
from langchain_core.prompts import ChatPromptTemplate
json_llm = llm.bind(response_format={"type": "json_object"})
prompt = ChatPromptTemplate.from_messages([
("system", "Return a JSON object with keys title, genre and summary."),
("human", "{idea}"),
])
chain = prompt | json_llm
raw = chain.invoke({"idea": "A lighthouse keeper finds a door in the sea floor."})
data = json.loads(raw.content)
उपयोग करने से पहले Pydantic या एक साधारण कुंजी जाँच से परिणाम की पुष्टि करें। मोड स्कीमा को लागू नहीं करता है, इसलिए एक फ़ील्ड का गायब होना संभव है, और एक स्पष्ट प्रॉम्प्ट के साथ पुनः प्रयास आमतौर पर इसे ठीक कर देता है।
स्ट्रीमिंग और समानांतरता
स्ट्रीमिंग सर्वर-सेंट इवेंट्स के माध्यम से चलती है और मानक stream विधि के साथ काम करती है। उपयोग स्ट्रीम के अंत में भेजा जाता है।
for chunk in llm.stream("Write a four-line poem about rain on a tin roof."):
print(chunk.content, end="", flush=True)
जब आप कई आइटम प्रोसेस करते हैं, batch उन्हें समानांतर में चलाता है, और यहीं पर सीमाएं मायने रखती हैं। एक पूर्ण कुंजी 8 समानांतर अनुरोधों और प्रति मिनट 300 अनुरोधों की अनुमति देती है। एक ट्रायल कुंजी 2 और 60 की अनुमति देती है। एक स्ट्रीम किया गया अनुरोध अपना स्लॉट स्ट्रीम समाप्त होने तक पकड़े रखता है। एक सीमा पास करें ताकि LangChain कभी भी उससे अधिक न करे जो आपकी कुंजी अनुमति देती है:
prompts = [f"Write a one-line tagline for product {i}." for i in range(40)]
results = llm.batch(prompts, config={"max_concurrency": 6})
यदि आपको अभी भी HTTP 429 दिखता है, तो एरर कोड आपको बताता है कि आपने कौन सी सीमा टोकी: rate_limited प्रति मिनट अनुरोधों के लिए, concurrency एक साथ बहुत सारे के लिए। एक 429 Retry-After: 5 हेडर के साथ अस्थायी ओवरलोड को चिह्नित करता है। ChatOpenAI में max_retries विकल्प है जो ऐसी त्रुटियों पर बैकऑफ़ के साथ पुन: प्रयास करता है; बैच जॉब्स के लिए इसे 3 या 4 पर सेट करें।
एक बिना एम्बेडिंग्स एंडपॉइंट वाली रिट्रीवल चेन
यह API केवल जनरेशन को कवर करता है, इसलिए एक रिट्रीवल चेन को दो प्रदाताओं की आवश्यकता होती है: एम्बेडिंग्स के लिए एक और चैट स्टेप के लिए एक। LangChain इसे आसान बनाता है, क्योंकि वेक्टर स्टोर और चैट मॉडल अलग-अलग ऑब्जेक्ट हैं। अपने दस्तावेज़ों को इंडेक्स करने के लिए किसी भी एम्बेडिंग मॉडल का उपयोग करें, चाहे वह एक लोकल लाइब्रेरी से हो या किसी अन्य सेवा से। फिर प्राप्त टेक्स्ट को प्रॉम्प्ट के माध्यम से चैट मॉडल में पास करें।
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_messages([
("system", "Answer using only the context. If the answer is not there, say so.\n\nContext:\n{context}"),
("human", "{question}"),
])
chain = prompt | llm | StrOutputParser()
answer = chain.invoke({"context": "\n\n".join(top_chunks), "question": "What is the refund window?"})
यहाँ top_chunks वह है जो आपके रिट्रीवर ने लौटाया है। इसे केवल उन कुछ अंशों तक सीमित रखें जो मायने रखते हैं। 300 टोकन के चार चंक्स हर कॉल पर 1,200 टोकन जोड़ते हैं, जो ठीक है, लेकिन चालीस चंक्स 12,000 जोड़ते हैं और हर अनुरोध को दस गुना भारी बना देते हैं।
ट्रबलशूटिंग चेकलिस्ट
- प्रमाणीकरण त्रुटियाँ: सुनिश्चित करें कि कुंजी
api_keyमें है, किसी अन्य पैरामीटर में नहीं, और कोईOPENAI_API_KEYएनवायरनमेंट वेरिएबल आप जो पास करना चाहते हैं, उसे चुपचाप ओवरराइड नहीं कर रहा है। - मॉडल नहीं मिला: मॉडल ID बिल्कुल
uncensoredहै।GET /v1/modelsकॉल करें ताकि देख सकें कि सर्वर क्या सूचीबद्ध करता है। - असामान्य टूल आर्ग्युमेंट्स: कच्ची आर्ग्युमेंट स्ट्रिंग पढ़ें, टूल विवरण को सख्त करें, और एजेंट रन के लिए तापमान को लगभग 0.2 तक कम करें।
- ट्रेसिंग और डीबगिंग: प्रत्येक प्रॉम्प्ट जो बाहर जाता है और प्रत्येक जवाब जो वापस आता है, देखने के लिए स्थानीय रूप से LangChain का विस्तृत या डीबग मोड चालू करें।
- दोहराए जा सकने वाले परीक्षण: प्रॉम्प्ट संस्करणों की तुलना करते समय
seedऔर कम तापमान का उपयोग करें, ताकि अंतर आपके परिवर्तन से आए, न कि सैंपलिंग के भाग्य से।
LangChain वर्कलोड की लागत
बिलिंग प्रीपेड क्रेडिट से प्रति टोकन होता है। कोई सदस्यता नहीं है, विफल या अस्वीकृत अनुरोधों के लिए चार्ज नहीं किया जाता है, और क्रेडिट कभी समाप्त नहीं होता है। टॉप-अप $20 से $500 तक किसी भी पूर्ण राशि में, क्रिप्टो (TRC20 पर USDT, Base पर USDC) द्वारा किए जा सकते हैं, $50 या अधिक पर 5%, $100 या अधिक पर 10% और $200 या अधिक पर 15% बोनस मिलता है। विवरण मूल्य निर्धारण पृष्ठ पर उपलब्ध हैं।
आइए एक उदाहरण देखें। एक सपोर्ट बॉट एक दिन में 2,000 प्रश्नों का उत्तर देता है। प्रत्येक अनुरोध लगभग 1,500 टोकन भेजता है (सिस्टम प्रॉम्प्ट, प्राप्त स्निपेट, प्रश्न) और लगभग 250 टोकन लौटाता है।
- इनपुट: 2,000 x 1,500 = 3,000,000 टोकन, इसलिए 3 x $0.15 = $0.45।
- आउटपुट: 2,000 x 250 = 500,000 टोकन, इसलिए 0.5 x $0.50 = $0.25।
- कुल: 2,000 जवाबों के लिए प्रति दिन $0.70, या प्रत्येक के लिए $0.00035।
रिट्रीवल चेन में लागत बढ़ सकती है, क्योंकि प्रत्येक अतिरिक्त प्राप्त चंक प्रत्येक कॉल में इनपुट टोकन जोड़ता है। प्रतिक्रियाओं से usage_metadata लॉग करें, औसत प्रॉम्प्ट आकार पर नज़र रखें, और स्केल अप करने से पहले चंक की संख्या कम करें। यदि आप आगे बढ़ना चाहते हैं, तो API दस्तावेज़ प्रत्येक समर्थित पैरामीटर की सूची देता है।
