HI ▾

Uncensored Model HubLangChain ओपन सोर्स मॉडल्स एक बिना सेंसर API के माध्यम से

LangChain ओपन सोर्स मॉडल बिना सेंसर API के माध्यम से

LangChain किसी भी OpenAI-कम्पैटिबल सर्वर के माध्यम से ओपन सोर्स मॉडल के साथ काम करता है, और एक होस्टेड API आपको GPUs को स्वयं चलाने से बचाता है। यहाँ Python और Node में सेटअप है, जिसमें टूल्स, एक एजेंट, JSON आउटपुट, स्ट्रीमिंग और एक कन्करेंसी प्लान शामिल है।

अपडेट किया गया

ग्लास चेन लिंक्स मॉड्यूलर ब्लॉक्स को सर्वर क्यूब से जोड़ते हुए, एक ओपन-वेट मॉडल API के साथ LangChain को दर्शाते हुए

मुख्य बिंदु

  1. base_url को https://api.uncensoredmodelhub.com/v1 पर सेट करके ChatOpenAI का उपयोग करें और मॉडल uncensored रखें।
  2. टूल कॉलिंग, JSON मोड और स्ट्रीमिंग सभी मानक LangChain इंटरफेस के माध्यम से काम करते हैं।
  3. 429 त्रुटियों से बचने के लिए, पूर्ण कुंजी पर max_concurrency को 8 और ट्रायल कुंजी पर 2 पर सीमित करें।
  4. मूल्य निर्धारण $0.15 प्रति 1M इनपुट टोकन और $0.50 प्रति 1M आउटपुट टोकन है, बिना किसी सदस्यता के।

चार पंक्तियों में 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 दस्तावेज़ प्रत्येक समर्थित पैरामीटर की सूची देता है।

प्रश्न और उत्तर

मैं इस API के लिए LangChain की कौन सी क्लास उपयोग करूँ?

पायथन में langchain-openai से ChatOpenAI उपयोग करें या जावास्क्रिप्ट में @langchain/openai। मॉडल को uncensored पर सेट करें और base_url को https://api.uncensoredmodelhub.com/v1. की ओर इशारा करें।

क्या यह एजेंट्स और टूल कॉलिंग का समर्थन करता है?

हाँ। टूल कॉलिंग ओपनएआई-शैली के टूल्स फॉर्मेट का उपयोग करती है, इसलिए bind_tools और LangGraph एजेंट काम करते हैं। टूल आर्ग्युमेंट्स को स्वयं सत्यापित करें, क्योंकि मॉडल उन्हें टेक्स्ट के रूप में लौटाता है।

LangChain चेन्स के लिए कॉन्टेक्स्ट विंडो क्या है?

100,000 टोकन, जो प्रॉम्प्ट और कंप्लीशन दोनों के लिए साझा हैं। लंबी मेमोरी बफर और कई रीट्रीव किए गए चंक इसे कम कर देते हैं, इसलिए अपनी चेन में इतिहास को ट्रिम करें।

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

नहीं। API केवल टेक्स्ट चैट है, जिसमें एम्बेडिंग्स, इमेज, ऑडियो या फाइन-ट्यूनिंग नहीं है। रिट्रीवल के लिए एक अलग एम्बेडिंग प्रोवाइडर का उपयोग करें और जनरेशन चरण के लिए इस API का उपयोग करें।

आपकी कुंजी बस एक फ़ॉर्म दूर है

एक खाता बनाएँ, कुंजी कॉपी करें, बेस URL बदलें। सेटअप यही है।

API कुंजी पाएँ