क्या मुझे इस एंडपॉइंट के लिए एक विशेष LangChain पैकेज की आवश्यकता है?

नहीं। langchain-openai पैकेज पर्याप्त है। ChatOpenAI को base URL, आपकी कुंजी और मॉडल ID uncensored पास करें।

क्या यह LangGraph और एजेंट्स के साथ काम करता है?

हाँ, जब तक वे मानक OpenAI चैट और टूल कॉलिंग प्रारूप का उपयोग करते हैं। टूल कॉल, स्ट्रीम किए गए tool_calls और role tool परिणाम समर्थित हैं।

क्या मैं चेन के भीतर मॉडल के बीच स्विच कर सकता हूँ?

नहीं। एक ही मॉडल, uncensored है, और सेवा वेंडर्स के बीच एक रूटर नहीं है। यदि आपको किसी अन्य चरण के लिए एक अलग प्रदाता की आवश्यकता है, तो एक अलग LangChain मॉडल ऑब्जेक्ट का उपयोग करें।

429 त्रुटियों के बारे में मुझे क्या करना चाहिए?

अपनी बैच समानांतरता कम करें, Retry-After हेडर का सम्मान करें जब वह मौजूद हो, और सुनिश्चित करें कि समाप्त स्ट्रीम बंद हैं। एक पूर्ण कुंजी 8 समानांतर अनुरोधों और प्रति मिनट 300 की अनुमति देती है।

क्या मेरे वेक्टर स्टोर के लिए एम्बेडिंग्स उपलब्ध हैं?

नहीं। API केवल टेक्स्ट है और इसमें एम्बेडिंग एंडपॉइंट नहीं है, इसलिए आपको रेट्रीवल के लिए एक अलग एम्बेडिंग स्रोत की आवश्यकता है।

LangChain + LLM: एक बिना सेंसर API से कनेक्ट करें

संक्षिप्त सेटअप

सामान्य langchain + llm प्रश्न यह है कि क्या आपको एक थर्ड-पार्टी एंडपॉइंट के लिए विशेष इंटीग्रेशन की आवश्यकता है। आपको नहीं चाहिए। LangChain का OpenAI चैट व्रैपर एक कस्टम base URL स्वीकार करता है, और यह API OpenAI चैट कंप्लीशन्स प्रारूप का पालन करता है, इसलिए मानक क्लास काम करती है। पैकेज इंस्टॉल करें, तीन मान पास करें, और आपके पास एक चैट मॉडल ऑब्जेक्ट है जिसे आप किसी भी चेन में डाल सकते हैं।

pip install -U langchain-openai langchain-core

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.nsfwllmrouter.com/v1",
    api_key="YOUR_API_KEY",
    temperature=0.7,
)

print(llm.invoke("Give me one sentence about LangChain.").content)

API कुंजी पृष्ठ से कुंजी प्राप्त करें। नए उपयोगकर्ता साइन-अप के बाद एक क्लिक से वहाँ $0.50 का मुफ़्त ट्रायल क्रेडिट प्राप्त कर सकते हैं, जो इस आर्टिकल में दिए गए सभी उदाहरणों को कई बार चलाने के लिए पर्याप्त है। मॉडल ID हमेशा uncensored होती है, और अनुरोध POST /v1/chat/completions पर भेजे जाते हैं।

साइट नाम पर एक नोट: डोमेन में "router" शब्द होने के बावजूद, यह एक स्वतंत्र प्रदाता द्वारा चलाया जाने वाला एकल ओपन-वेट मॉडल है, न कि विभिन्न वेंडर्स के बीच एक रूटर, और न ही किसी वेंडर की आधिकारिक API। यहाँ आप मॉडल्स के बीच चयन नहीं करते। आपका कोड एक मॉडल का नाम बताता है, और वही मॉडल उत्तर देता है।

कुंजी को स्रोत कोड से बाहर रखें

कुंजी को हार्ड-कोड करना एक प्रारंभिक परीक्षण के लिए काम करता है, लेकिन फ़ाइल को कम्माइट करने पर यह समस्या बन जाता है। इसके बजाय इसे एन्वायरनमेंट से पढ़ें। LangChain द्वारा घेरे गए OpenAI क्लाइंट लाइब्रेरी डिफ़ॉल्ट रूप से OPENAI_API_KEY और OPENAI_BASE_URL की तलाश करती हैं, इसलिए आप उन्हें अपने शेल में सेट कर सकते हैं और मॉडल को कम आर्गुमेंट्स के साथ बना सकते हैं।

export OPENAI_API_KEY="YOUR_API_KEY"
export OPENAI_BASE_URL="https://api.nsfwllmrouter.com/v1"

import os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url=os.environ.get("OPENAI_BASE_URL", "https://api.nsfwllmrouter.com/v1"),
    api_key=os.environ["OPENAI_API_KEY"],
)

base URL को स्पष्ट रूप से पास करना, जैसा कि ऊपर दिखाया गया है, एक लाभ प्रदान करता है। यदि उसी मशीन पर कोई अन्य प्रोजेक्ट वास्तविक OpenAI सेवा का उपयोग करता है और उसी वातावरण चर पर निर्भर करता है, तो आपका स्पष्ट तर्क दोनों के बीच टकराव को रोकता है।

प्रॉम्प्ट टेम्पलेट के साथ पहली चेन

अधिकांश वास्तविक कार्य एक प्रॉम्प्ट टेम्पलेट, मॉडल और आउटपुट पार्सर का उपयोग करता है, जिन्हें पाइप ऑपरेटर से जोड़ा गया है। यह LangChain एक्सप्रेशन लैंग्वेज शैली है, और इसमें कस्टम एंडपॉइंट के लिए कुछ विशेष की आवश्यकता नहीं है।

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.nsfwllmrouter.com/v1",
    api_key="YOUR_API_KEY",
)

prompt = ChatPromptTemplate.from_messages([
    ("system", "You write short story openings in the style the user asks for."),
    ("human", "Genre: {genre}\nSetting: {setting}\nWrite three sentences."),
])

chain = prompt | llm | StrOutputParser()
print(chain.invoke({"genre": "noir mystery", "setting": "a rainy harbor town"}))

मॉडल में कानूनी वयस्कों के उपयोग के लिए कोई कंटेंट रिफ्यूज़ल नहीं है, जो महत्वपूर्ण है जब आपकी चेन फिक्शन, रोलप्ले सीन्स या कंपैनियन डायलॉग जनरेट करती है जिसे एक अधिक सावधान मॉडल अस्वीकार कर सकता है। एकमात्र निश्चित नियम यह है कि नाबालिगों से जुड़ा यौन सामग्री कभी उत्पन्न नहीं होती है। यदि आपके उत्पाद में अधिक कठोर नियम हैं, तो उस पर अपनी इनपुट वैलिडेशन बनाएं।

स्ट्रीमिंग और उपयोग

API stream: true के साथ सर्वर-सेंट इवेंट्स के माध्यम से स्ट्रीमिंग का समर्थन करती है, और उपयोग स्ट्रीम के अंत में रिपोर्ट किया जाता है। LangChain में आप .stream() कॉल करते हैं और चंक पर इटरेट करते हैं।

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.nsfwllmrouter.com/v1",
    api_key="YOUR_API_KEY",
)

for chunk in llm.stream("Write a four-line poem about debugging at night."):
    print(chunk.content, end="", flush=True)

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

फ़ंक्शन कॉलिंग और एजेंट्स

टूल कॉलिंग समर्थित है: आप tools पास करते हैं और वैकल्पिक रूप से tool_choice, मॉडल tool_calls के साथ जवाब देता है (जिसे भी स्ट्रीम किया जा सकता है), और आप role: "tool" के साथ संदेश भेजकर परिणाम वापस भेजते हैं। LangChain में, bind_tools आपके लिए वायर फॉर्मेट संभालता है।

from langchain_core.tools import tool
from langchain_openai import ChatOpenAI

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

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.nsfwllmrouter.com/v1",
    api_key="YOUR_API_KEY",
)
llm_with_tools = llm.bind_tools([word_count])

msg = llm_with_tools.invoke("How many words are in: the quick brown fox?")
for call in msg.tool_calls:
    print(call["name"], call["args"], word_count.invoke(call["args"]))

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

JSON मोड के साथ संरचित आउटपुट

JSON मोड response_format: {"type": "json_object"} के माध्यम से उपलब्ध है। LangChain में आप इसे मॉडल तर्क के रूप में पास कर सकते हैं और परिणाम को स्वयं पार्स कर सकते हैं, जिससे आपको वैलिडेशन और रेट्राइ पर नियंत्रण मिलता है।

import json
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.nsfwllmrouter.com/v1",
    api_key="YOUR_API_KEY",
    model_kwargs={"response_format": {"type": "json_object"}},
)

msg = llm.invoke(
    "Return a JSON object with keys title and tags (a list of three strings) "
    "for an article about hiking."
)
data = json.loads(msg.content)
print(data["title"], data["tags"])

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

कॉन्करेंसी, रेट्राइ और रेट लिमिट

LangChain .batch() के साथ काम को फैलाना आसान बनाता है, और यहीं पर अधिकांश लोग अपनी पहली रेट लिमिट पर पहुँचते हैं। एक पूर्ण कुंजी 8 समानांतर अनुरोध और प्रति मिनट 300 अनुरोध की अनुमति देती है। एक ट्रायल कुंजी 2 समानांतर अनुरोध और प्रति मिनट 60 की अनुमति देती है। यदि आप इससे अधिक जाते हैं, तो API HTTP 429 के साथ जवाब देता है। यदि आप प्रति मिनट अनुरोधों की सीमा पार करते हैं, तो त्रुटि कोड rate_limited होता है, और यदि एक साथ बहुत सारे अनुरोध चल रहे हैं, तो concurrency होता है। अस्थायी ओवरलोड पर आपको Retry-After: 5 हेडर के साथ एक 429 भी मिलता है।

बैच कॉन्करेंसी को स्वयं सेट करें, और क्लाइंट को बैकऑफ़ के साथ रेट्राइ करने दें:

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.nsfwllmrouter.com/v1",
    api_key="YOUR_API_KEY",
    max_retries=4,
    timeout=120,
)

inputs = [f"Summarize idea number {i} in one line." for i in range(40)]
results = llm.batch(inputs, config={"max_concurrency": 6})
print(len(results))

पूर्ण कुंजी पर 6 पर रहने से खाते के अन्य अनुरोधों के लिए जगह बनी रहती है। ट्रायल कुंजी पर 2 का उपयोग करें। यदि आप अभी भी concurrency त्रुटियाँ देखते हैं, तो उन स्ट्रीम की तलाश करें जो कभी समाप्त नहीं हुईं, क्योंकि प्रत्येक एक स्लॉट पकड़े रखती है। प्रत्येक प्रतिक्रिया X-Request-Id ले जाती है, जो सहायता से संपर्क करने पर उद्धृत करने के लिए मान है, और X-Balance-USD, जो आपका शेष क्रेडिट दिखाता है।

वेब ऐप्स के लिए async कॉल

वेब सर्वर में आप आमतौर पर ब्लॉकिंग कॉल्स नहीं चाहते। हर LangChain चैट मॉडल के अपने एसींक ट्विन होते हैं, जिनके नाम ainvoke, astream और abatch हैं, और वे इस एंडपॉइंट पर सिंक संस्करणों की तरह ही काम करते हैं।

import asyncio
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.nsfwllmrouter.com/v1",
    api_key="YOUR_API_KEY",
)

async def main():
    async for chunk in llm.astream("Describe a quiet harbor at dawn in two sentences."):
        print(chunk.content, end="", flush=True)

asyncio.run(main())

एक एसींक सर्विस में, अपने की के आकार के बराबर सेमाफोर से चल रहे कॉल्स की संख्या पर नियंत्रण रखें, उदाहरण के लिए पूर्ण की पर 8। इससे आपके ऐप का एक व्यस्त एंडपॉइंट सभी स्लॉट्स भरेगा नहीं और अन्य कॉल्स भूखे नहीं रहेंगे। कॉल के आसपास अपवादों को कैच करें, जब उपलब्ध हो तो X-Request-Id हेडर को लॉग करें, और स्टैक ट्रेस के बजाय उपयोगकर्ता को एक छोटा पुनः प्रयास संदेश दिखाएं।

डिबगिंग टिप: यदि कोई चेन अजीब व्यवहार करती है, तो मॉडल द्वारा प्राप्त सटीक संदेश प्रिंट करें। प्रॉम्प्ट टेम्पलेट कभी-कभी अतिरिक्त स्पेस जोड़ देते हैं या कोई वेरिएबल छोड़ देते हैं, और मॉडल केवल वही उत्तर दे सकता है जो उसे भेजा गया है। LangChain के विस्तृत (verbose) और डिबग स्विच, या LangSmith ट्रेसिंग यदि आप पहले से ही उसका उपयोग करते हैं, अंतिम संदेश सूची दिखाते हैं।

चेन के लिए कॉन्टेक्स्ट विंडो का क्या अर्थ है

प्रॉम्प्ट और पूर्णता (completion) दोनों के लिए कॉन्टेक्स्ट विंडो 100,000 टोकन है, और max_tokens वैकल्पिक है। यह उन रिट्रीवल चेन के लिए पर्याप्त बड़ा है जो एक प्रॉम्प्ट में कई दस्तावेज डालती हैं, या एक बातचीत मेमोरी के लिए जो लंबी इतिहास रखती है। यह इतना बड़ा है कि यदि आप हर चरण पर बिना ट्रिम किए पूरा इतिहास पुनः भेजते हैं तो यह महंगा पड़ सकता है।

एक त्वरित गणना। 12,000 इनपुट टोकन भेजने और 800 वापस पाने वाले एक रीट्रीवल चरण की लागत 0.012 x $0.15 + 0.0008 x $0.50 = $0.0018 + $0.0004 = $0.0022 है। इसे 1,000 बार चलाएं और आपको $2.20 भरे। मूल्य निर्धारण $0.15 प्रति 1M इनपुट टोकन और $0.50 प्रति 1M आउटपुट टोकन है, कोई सब्सक्रिप्शन नहीं है, इसलिए आप केवल उसी के लिए भरे जो चेन वास्तव में उपयोग करती है। मूल्य निर्धारण पृष्ठ में टॉप-अप विकल्प हैं, और क्विकस्टार्ट दस्तावेज़ में प्रत्येक समर्थित पैरामीटर सूचीबद्ध है। प्रॉम्प्ट को प्रशिक्षण के लिए उपयोग नहीं किया जाता है।

अधिक गाइड

NSFW LLM Router

LangChain + LLM: बिना सेंसर API से कनेक्ट करें

मुख्य बिंदु