LangChain में बिना सेंसर वाले API के साथ Chat OpenAI करें

संक्षिप्त उत्तर: ChatOpenAI पर तीन सेटिंग्स

यदि आपने chat open ai langchain खोजा है, तो संभवतः आपके पास एक LangChain प्रोजेक्ट है जो पहले से ChatOpenAI का उपयोग करता है और आप इसे किसी अलग बैकएंड से जोड़ना चाहते हैं। यह कॉन्फ़िगरेशन बदलाव है, पुनर्लेखन नहीं। इस साइट का API OpenAI चैट कंप्लीशन प्रोटोकॉल का पालन करता है, इसलिए LangChain इसे किसी अन्य OpenAI-शैली सर्वर की तरह मानता है।

आपको बेस URL, अपनी API कुंजी और मॉडल ID uncensored की आवश्यकता है। पहले पैकेज इंस्टॉल करें:

Copypip install -U langchain-openai langgraph

फिर मॉडल ऑब्जेक्ट बनाएं:

Copyimport os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.nofilteraichat.com/v1",
    api_key=os.environ["NOFILTER_API_KEY"],
    temperature=0.8,
)

reply = llm.invoke("Write a two-sentence villain monologue for a heist novel.")
print(reply.content)

यही पूरा इंटीग्रेशन है। हर LangChain फीचर जो ChatOpenAI पर बना है, अब uncensored मॉडल से कनेक्ट होता है: चेन्स, चेट मॉडल को कॉल करने वाले रिट्रीवर्स, आउटपुट पार्सर और एजेंट्स। यदि आपके पास अभी तक कोई कुंजी नहीं है, तो API कुंजी पृष्ठ साइन-अप और वन-क्लिक ट्रायल क्रेडिट की व्याख्या करता है।

कुंजी को कोड से दूर रखें

कुंजी को एक एनवायरनमेंट वेरिएबल में रखें और स्टार्ट-अप पर इसे पढ़ें। Linux या macOS पर:

Copyexport NOFILTER_API_KEY="paste-your-key-here"

प्रोजेक्ट के लिए एक साझा क्लाइंट मॉड्यूल बनाएं, उदाहरण के लिए llm.py जो मॉडल को एक बार बनाता है और उसे निर्यात करता है। हर चेन अब उसी ऑब्जेक्ट को इम्पोर्ट करती है, और कुंजी, टाइमआउट या तापमान का बाद का बदलाव एक ही जगह होता है। इससे टूल स्टेप्स के लिए एक दूसरा, ठंडा इंस्टेंस और क्रिएटिव राइटिंग के लिए एक गर्म इंस्टेंस रखना आसान होता है, दोनों अलग-अलग सेटिंग्स के साथ उसी एंडपॉइंट की ओर इशारा करते हैं।

एक चूक कई लोगों को पकड़ती है: ChatOpenAI OPENAI_API_KEY और OPENAI_API_BASE को एनवायरनमेंट से भी पढ़ता है। यदि वेरिएबल्स किसी दूसरे प्रोजेक्ट के लिए सेट हैं, तो एक आधा-कॉन्फ़िगर ऑब्जेक्ट आपका अनुरोध गलत सर्वर पर भेज सकता है। ऊपर की तरह base_url और api_key स्पष्ट रूप से पास करने से अस्पष्टता दूर हो जाती है।

आप बिना LangChain के कनेक्शन की पुष्टि कर सकते हैं। मॉडल्स एंडपॉइंट को एकल एंट्री लौटना चाहिए:

Copycurl https://api.nofilteraichat.com/v1/models \
  -H "Authorization: Bearer $NOFILTER_API_KEY"

यदि यह काम करता है लेकिन LangChain विफल रहता है, तो समस्या आपकी Python पर्यावरण में है, न कि कुंजी में। यदि दोनों 401 के साथ विफल होते हैं, तो कुंजी में किसी अतिरिक्त स्थान या नई पंक्ति के लिए जांचें। क्विकस्टार्ट तुलना के लिए सटीक अनुरोध प्रारूप सूचीबद्ध करता है।

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

जब टोकन जनरेट होते हुए दिखाई देते हैं तो चैट UI बेहतर लगते हैं। LangChain इसे .stream() के माध्यम से उजागर करता है, और सर्वर stream: true अंडर द होड सेट होने पर मानक SSE चंक्स भेजता है।

Copyfrom langchain_openai import ChatOpenAI
import os

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.nofilteraichat.com/v1",
    api_key=os.environ["NOFILTER_API_KEY"],
    stream_usage=True,
)

final = None
for chunk in llm.stream("Describe a rainy harbour town in four sentences."):
    print(chunk.content, end="", flush=True)
    final = chunk if final is None else final + chunk

print()
print(final.usage_metadata)

stream_usage=True के साथ, आखिरी चंक इनपुट और आउटपुट टोकन गिनती ले जाता है, जिसे API स्ट्रीम के अंत में भेजता है। उन संख्याओं को रखें। वे यह देखने का सबसे सस्ता तरीका हैं कि एक एजेंट वास्तव में क्या खर्च करता है, और हम लागत अनुभाग में नीचे उनका उपयोग करते हैं।

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

Node और TypeScript

JavaScript पैकेज एक थोड़ा अलग विकल्प नाम का उपयोग करता है। बेस URL configuration के अंदर जाता है:

Copynpm install @langchain/openai @langchain/core

Copyimport { ChatOpenAI } from "@langchain/openai";

const llm = new ChatOpenAI({
  model: "uncensored",
  apiKey: process.env.NOFILTER_API_KEY,
  configuration: { baseURL: "https://api.nofilteraichat.com/v1" },
  temperature: 0.8,
});

const res = await llm.invoke("Give me three names for a smuggler's ship.");
console.log(res.content);

प्रतिक्रिया के लिए टाइपस्क्रिप्ट टाइप्स आमतौर पर LangChain मैसेज क्लासेस हैं, इसलिए res.content या res.usage_metadata पढ़ने वाला मौजूदा कोड काम करता रहता है। जब आप इसे एक सर्वर रूट के अंदर चलाते हैं, तो मॉडल को मॉड्यूल स्कोप पर एक बार बनाएं, न कि प्रति अनुरोध। यह हर कॉल के लिए एक नया HTTP क्लाइंट बनाने से बचाता है और आपकी कॉन्करेंसी को तर्कसंगत रखना आसान बनाता है।

बाकी सब कुछ, जिसमें .stream(), .bindTools() और .withStructuredOutput() शामिल हैं, Python में की तरह ही व्यवहार करते हैं। तापमान, top_p, स्टॉप सीक्वेंस, सीड और पेनाल्टी विकल्प मॉडल में पास किए जाते हैं, इसलिए आप उन्हें किसी अन्य OpenAI-शैली बैकएंड की तरह कंस्ट्रक्टर पर सेट कर सकते हैं।

टूल कॉलिंग और एक छोटा एजेंट

API टूल कॉलिंग का समर्थन करती है: tools और tool_choice फ़ील्ड्स, स्ट्रीम किए गए tool_calls, और role: "tool" मैसेज के रूप में लौटाए गए टूल रिजल्ट्स। LangGraph का प्रीबिल्ट एजेंट बिल्कुल उसी लूप का उपयोग करता है। यहाँ एक टूल वाला एजेंट है:

Copyimport os
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent

@tool
def roll_dice(sides: int) -> int:
    """Roll a die with the given number of sides."""
    import random
    return random.randint(1, sides)

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.nofilteraichat.com/v1",
    api_key=os.environ["NOFILTER_API_KEY"],
)

agent = create_react_agent(llm, [roll_dice])
out = agent.invoke(
    {"messages": [("user", "Roll a twenty-sided die twice and tell me the total.")]}
)
print(out["messages"][-1].content)

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

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

JSON मोड

JSON मोड response_format के माध्यम से उपलब्ध है। LangChain में, JSON मोड विधि के साथ पूछें और अपने प्रॉम्प्ट में कुंजियों का नाम दें:

Copyfrom pydantic import BaseModel
from langchain_openai import ChatOpenAI
import os

class Character(BaseModel):
    name: str
    role: str
    secret: str

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.nofilteraichat.com/v1",
    api_key=os.environ["NOFILTER_API_KEY"],
)
structured = llm.with_structured_output(Character, method="json_mode")
print(structured.invoke(
    "Return JSON with keys name, role and secret for a noir detective."
))

रेट लिमिट, रीट्राइज और लागत

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

LangChain आपको इसके लिए दो नॉब्स देता है। मॉडल पर max_retries बैकऑफ़ के साथ विफल कॉल्स को पुन: प्रयास करता है, और रन कॉन्फ़िगरेशन में max_concurrency समानांतर बैच वर्क को सीमित करता है:

Copyllm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.nofilteraichat.com/v1",
    api_key=os.environ["NOFILTER_API_KEY"],
    max_retries=4,
    timeout=120,
)

answers = llm.batch(
    ["Prompt one", "Prompt two", "Prompt three", "Prompt four"],
    config={"max_concurrency": 6},
)

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

एजेंट रन का खर्च

मूल्य निर्धारण $0.15 प्रति 1M इनपुट टोकन और $0.50 प्रति 1M आउटपुट टोकन है। मान लीजिए कि एक एजेंट स्टेप 3,000 टोकन का इतिहास, टूल्स और निर्देश भेजता है, और मॉडल 500 टोकन लिखता है। इनपुट की लागत 3,000 × $0.15 / 1,000,000 = $0.00045 है। आउटपुट की लागत 500 × $0.50 / 1,000,000 = $0.00025 है। एक स्टेप $0.0007 है। एक दस-स्टेप रन $0.007 है, और 1,000 ऐसे रन $7.00 का खर्च करते हैं।

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

सामान्य समस्याएं

• हर कॉल पर 404। बेस URL को /v1 पर समाप्त होना चाहिए और /chat/completions नहीं होना चाहिए। LangChain स्वयं पथ जोड़ देता है।
• मॉडल नहीं मिला। एकमात्र मॉडल ID uncensored है। gpt-4o जैसे नाम काम नहीं करेंगे।
• कॉन्टेक्स्ट त्रुटियाँ। विंडो प्रॉम्प्ट और कम्प्लीशन के लिए 100,000 टोकन की है। लंबी रीट्रीवल चेन्स इसे पार कर सकती हैं। भेजने से पहले सारांश बनाएँ या ट्रिम करें।
• अनुरोध बहुत बड़ा है। बॉडी सीमा 8 MB है, जो मायने रखती है यदि आप पूरे दस्तावेज़ों को प्रॉम्प्ट में डालते हैं।
• एम्बेडिंग विफल। यह API केवल टेक्स्ट चैट के लिए है। अपनी एम्बेडिंग मॉडल को किसी अन्य प्रोवाइडर पर रखें और जनरेशन के लिए इस एंडपॉइंट का उपयोग करें।

यही पैटर्न अन्य फ्रेमवर्क्स और चैट फ्रंटएंड के लिए भी काम करता है; संयोजन गाइड अधिक क्लाइंट्स को कवर करता है। किसी भी असामान्य मामले के लिए, सहायता पृष्ठ शुरुआत करने की जगह है।

अधिक गाइड

• बिना फ़िल्टर के फ्री अनलिमिटेड AI चैट: असली लागत
• Open WebUI और n8n: चैट को एक अनसेंसर्ड API से कनेक्ट करें
• Uncensored.chat API इंटीग्रेशन गाइड