HI ▾
API कुंजी पाएँ
https://api.deepseekapipricing.com/v1

DeepSeek API LangChain सेटअप: Python और Node

deepseek API langchain सेटअप के लिए आपको केवल ChatOpenAI क्लास, एक बेस URL, एक कुंजी और मॉडल नाम की आवश्यकता है। यह गाइड चैट, स्ट्रीमिंग, फ़ंक्शन कॉलिंग, JSON आउटपुट और समानांतर अनुरोधों के लिए Python और Node कोड कवर करती है, जो एक स्वतंत्र OpenAI-संगत एंडपॉइंट का उपयोग करती है, न कि वेंडर की अपनी API।

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

सर्वर को चैट बबल्स से जोड़ने वाली चमकदार चेन लिंक्स, जो एक API के साथ LangChain इंटीग्रेशन का प्रतिनिधित्व करते हैं

मुख्य बिंदु

  1. ChatOpenAI का उपयोग base_url को https://api.deepseekapipricing.com/v1 पर सेट करके करें और मॉडल uncensored निर्धारित करें।
  2. api_key को स्पष्ट रूप से पास करें ताकि आपके वातावरण में मौजूद OpenAI कुंजी कभी यहाँ न भेजी जाए।
  3. स्ट्रीमिंग, bind_tools और JSON मोड मानक OpenAI-फॉर्मेट पैरामीटर के माध्यम से काम करते हैं।
  4. 429 त्रुटियों से बचने के लिए पूर्ण कुंजी के लिए max_concurrency को 8 पर, या ट्रायल कुंजी के लिए 2 पर सीमित करें।

शुरू करने से पहले आपको क्या चाहिए

LangChain किसी भी सर्वर से बात करता है जो OpenAI चैट कंप्लीशन प्रोटोकॉल लागू करता है, इसलिए इंस्टॉल करने के लिए कोई विशेष इंटीग्रेशन नहीं है। आपकी शुरुआत वही पैकेज होगी जिसका उपयोग आप OpenAI के लिए करते हैं: langchain-openai Python के लिए या @langchain/openai Node के लिए। केवल तीन मान बदलते हैं।

  • Base URL: https://api.deepseekapipricing.com/v1
  • मॉडल: uncensored
  • कुंजी: Authorization: Bearer <key> के रूप में भेजी जाती है, जिसे क्लाइंट आपके लिए करता है

नामकरण पर एक स्पष्टीकरण। यह एंडपॉइंट एक स्वतंत्र सेवा है जो एक ओपन-वेट मॉडल चलाती है जिसे कानूनी वयस्कों के उपयोग के लिए सामग्री अस्वीकृति के बिना उत्तर देने के लिए ट्यून्ड किया गया है। यह आधिकारिक DeepSeek API नहीं है और न ही वेंडर के बीच एक राउटर है, इसलिए मॉडल का नाम हमेशा uncensored होता है, न कि कोई वेंडर मॉडल ID। यदि आपको कुंजी की आवश्यकता है, तो API कुंजी पेज साइन-अप चरणों और एक-क्लिक $0.50 ट्रायल को दिखाता है।

Python में इंस्टॉल करें और पहला कॉल करें

पैकेज इंस्टॉल करें:

pip install -U langchain-openai langchain-core
# then use base_url https://api.deepseekapipricing.com/v1 and model "uncensored"

फिर मॉडल ऑब्जेक्ट बनाएं। OPENAI_API_KEY एनवायरनमेंट वेरिएबल पर निर्भर रहने के बजाय कुंजी स्पष्ट रूप से पास करें, जो एक वास्तविक OpenAI कुंजी हो सकती है जिसे आप अलग होस्ट पर भेजना नहीं चाहते।

import os
from langchain_openai import ChatOpenAI

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

print(llm.invoke("Say hello in five words.").content)

यदि यह एक अभिवादन प्रिंट करता है, तो कनेक्शन, कुंजी और मॉडल नाम सभी सही हैं। इस चरण पर सबसे आम गलती Base URL में /v1 छोड़ देना है, जो आमतौर पर not-found एरर पैदा करता है।

प्रॉम्प्ट, चेन और स्ट्रीमिंग

इसके बाद, LangChain सामान्य रूप से काम करता है। एक प्रॉम्प्ट टेम्पलेट, मॉडल और आउटपुट पार्सर पाइप ऑपरेटर के साथ एक चेन बनाते हैं:

# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_messages([
    ("system", "You write tight, vivid scene descriptions for adult fiction."),
    ("human", "Describe this setting in under 80 words: {setting}"),
])

chain = prompt | llm | StrOutputParser()
print(chain.invoke({"setting": "a flooded subway station at night"}))

स्ट्रीमिंग सर्वर-सेंट इवेंट्स के माध्यम से जाती है। LangChain में आप stream कॉल करते हैं, और प्रत्येक चंक टेक्स्ट का एक हिस्सा ले जाता है। यदि आप स्ट्रीम के अंत में टोकन गणना चाहते हैं, तो मॉडल पर stream_usage=True सेट करें; API उपयोग का विवरण अंतिम इवेंट में भेजता है।

llm_stream = ChatOpenAI(
    model="uncensored",
    base_url="https://api.deepseekapipricing.com/v1",
    api_key=os.environ["UNCENSORED_API_KEY"],
    stream_usage=True,
)

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

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

Node और TypeScript

JavaScript पैकेज Base URL को एक configuration ऑब्जेक्ट के अंदर लेता है:

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

const llm = new ChatOpenAI({
  model: "uncensored",
  apiKey: process.env.UNCENSORED_API_KEY,
  configuration: { baseURL: "https://api.deepseekapipricing.com/v1" },
  maxRetries: 2,
});

const res = await llm.invoke("Say hello in five words.");
console.log(res.content);

const stream = await llm.stream("Write a four-line poem about a night train.");
for await (const chunk of stream) {
  process.stdout.write(chunk.content);
}

इसे ES मॉड्यूल के रूप में चलाएं ("type": "module" package.json में, या एक .mjs फ़ाइल में)। Node API में बाकी सब कुछ, जिसमें प्रॉम्प्ट टेम्पलेट और runnables शामिल हैं, किसी अन्य चैट मॉडल के साथ जैसे व्यवहार करता है।

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

API OpenAI टूल फॉर्मेट का समर्थन करता है: tools और tool_choice पैरामीटर, स्ट्रीम किए गए tool_calls, और role: "tool" वाले संदेशों के रूप में लौटाए गए टूल रिजल्ट। LangChain में आप एक डेकोरेटर के साथ टूल घोषित करते हैं और उन्हें bind_tools के साथ जोड़ते हैं:

# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
from langchain_core.tools import tool
from langchain_core.messages import HumanMessage, ToolMessage

@tool
def order_status(order_id: str) -> str:
    """Return the shipping status of an order."""
    return f"Order {order_id} left the warehouse yesterday."

llm_tools = llm.bind_tools([order_status])

messages = [HumanMessage("Where is order 1042?")]
ai = llm_tools.invoke(messages)
messages.append(ai)

for call in ai.tool_calls:
    result = order_status.invoke(call["args"])
    messages.append(ToolMessage(content=result, tool_call_id=call["id"]))

print(llm_tools.invoke(messages).content)

लूप को हाथ से एक बार लिखना दस मिनट के लायक है। यह आपको ठीक दिखाता है कि मॉडल ने क्या लौटाया, प्रत्येक कॉल के लिए कौन-से आर्गुमेंट चुने, और एक खराब टूल विवरण गलत अनुमान की ओर कैसे ले जाता है। एक बार जब यह स्पष्ट हो जाए, तो एक प्रीबिल्ट एजेंट पर स्विच करें और डिबगिंग रेफरेंस के रूप में हाथ से लिखे गए संस्करण को रखें।

यह पूरा लूप हाथ से लिखा गया है: मॉडल एक टूल का अनुरोध करता है, आप उसे चलाते हैं, आप परिणाम लौटाते हैं, और मॉडल अंतिम उत्तर लिखता है। यदि आप एक तैयार एजेंट लूप को प्राथमिकता देते हैं, तो langgraph पैकेज create_react_agent(llm, [order_status]) प्रदान करता है, और आप इसे {"messages": [("user", "Where is order 1042?")]} के साथ इन्वोक करते हैं।

एक मॉडल टूल्स का चयन कितनी अच्छी तरह करता है, यह मॉडल पर निर्भर करता है, इसलिए अपने वास्तविक टूल स्कीमा के साथ परीक्षण करें। छोटे, विशिष्ट टूल विवरण और कम तापमान मदद करते हैं। एक एजेंट जो कुल मिलाकर लगभग 27,000 इनपुट टोकन और 1,800 आउटपुट टोकन के साथ बढ़ते इतिहास के साथ छह कॉल करता है, उसकी लागत लगभग $0.00405 प्लस $0.0009, या लगभग आधा सेंट आती है।

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

JSON मोड response_format के माध्यम से समर्थित है। इसे मॉडल से बाइंड करें और प्रॉम्प्ट में भी कहें कि आप विशिष्ट कुंजियों के साथ JSON चाहते हैं, क्योंकि फॉर्मेट फ्लैग सिंटैक्स को नियंत्रित करता है, आपके स्कीमा को नहीं:

# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
import json

json_llm = llm.bind(response_format={"type": "json_object"})

msg = json_llm.invoke(
    "Return a JSON object with keys title (string) and tags (list of 3 strings) "
    "for a short story about a lighthouse keeper."
)
data = json.loads(msg.content)
print(data["title"], data["tags"])

पार्स किए गए परिणाम पर भरोसा करने से पहले उसे Pydantic या अपने स्वयं के चेक से सत्यापित करें, और json.JSONDecodeError को एक बार पुनः प्रयास करके हैंडल करें। बड़े एक्सट्रैक्शन जॉब्स के लिए, प्रत्येक प्रतिक्रिया को डिफेंसिवली पार्स करें, न कि यह मानकर कि पहली साफ़ है।

रिट्रीवल, मेमोरी और कॉलबैक्स

इस API में कोई एम्बेडिंग एंडपॉइंट नहीं है, इसलिए एक रिट्रीवल पाइपलाइन को एम्बेडिंग्स का एक अलग स्रोत चाहिए। रिट्रीवल के बाद सब कुछ साधारण चैट है। एक सामान्य रिट्रीवल चेन आपके वेक्टर स्टोर से शीर्ष अंश खींचती है, उन्हें प्रॉम्प्ट में पेस्ट करती है, और मॉडल से उस टेक्स्ट से उत्तर देने के लिए कहती है। क्योंकि कॉन्टेक्स्ट विंडो 100,000 टोकन है, आप लंबे अंश इस्तेमाल कर सकते हैं, लेकिन बिल याद रखें: रिट्रीव किए गए कॉन्टेक्स्ट का हर टोकन इनपुट के रूप में $0.15 प्रति मिलियन पर गिना जाता है, इसलिए 20,000 टोकन कॉन्टेक्स्ट पर प्रति प्रश्न $0.003 खर्च होता है।

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

कॉलबैक वह स्थान हैं जहां आप रिकॉर्ड कर सकते हैं कि एक कॉल की लागत कितनी हुई। प्रत्येक प्रतिक्रिया में एक उपयोग ब्लॉक होता है जिसमें प्रॉम्प्ट और कंप्लीशन टोकन होते हैं, और LangChain में लौटाया गया संदेश इसे usage_metadata में धारण करता है:

# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
msg = llm.invoke("Name three rivers.")
u = msg.usage_metadata
cost = u["input_tokens"] * 0.15 / 1_000_000 + u["output_tokens"] * 0.50 / 1_000_000
print(u, f"${cost:.6f}")

एक आश्चर्यजनक बिल को एक चेन तक ट्रैक करने के लिए, अनुरोध आईडी के साथ लागत लॉग करें।

सिस्टम प्रॉम्प्ट और टोन

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

शिप करने से पहले एक छोटी चेकलिस्ट

  • कुंजी एक एनवायरनमेंट वेरिएबल या सीक्रेट स्टोर में रहती है, रीपॉजिटरी में कभी नहीं।
  • max_concurrency को आपकी कुंजी की सीमा पर सेट किया गया है, या यदि अन्य सेवाएं कुंजी साझा करती हैं तो उससे नीचे।
  • रीट्राइज में एक छोटा बैक-ऑफ होता है, और Retry-After: 5 के साथ 429 प्रतिक्रियाओं का सम्मान किया जाता है।
  • क्लाइंट डिस्कनेक्ट होने पर स्ट्रीम्स बंद कर दी जाती हैं ताकि स्लॉट मुक्त हो सकें।
  • JSON आउटपुट को डिफेंसिवली पार्स और वैलिडेट किया जाता है।
  • लागत का रिकॉर्ड प्रत्येक चेन से उपयोग ब्लॉक के आधार पर किया जाता है।
  • एक फॉलबैक मौजूद है उस स्थिति के लिए जब एंडपॉइंट पहुँच से बाहर हो, भले ही फॉलबैक एक त्रुटि संदेश हो।

उस सूची का पालन करें और इंटीग्रेशन किसी अन्य LangChain चैट मॉडल की तरह व्यवहार करेगा। अंतर सामग्री की ओर है, जहां अन्य मॉडल कानूनी वयस्क उपयोग के लिए जिन अनुरोधों को अस्वीकार करते हैं, उनका उत्तर दिया जाता है।

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

एक फुल कुंजी 8 समानांतर अनुरोध और प्रति मिनट 300 अनुरोधों की अनुमति देती है। एक ट्रायल कुंजी 2 समानांतर अनुरोध और प्रति मिनट 60 की अनुमति देती है। अनुरोध बॉडी 8 MB तक हो सकती है, और कॉन्टेक्स्ट विंडो 100,000 टोकन का है जो प्रॉम्प्ट और कंप्लीशन को मिलाकर कवर करता है।

LangChain के बैच हेल्पर अनुरोधों को समानांतर भेजते हैं, इसलिए ऊपरी सीमा तय करें जो आपकी कुंजी से मेल खाती हो:

# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
inputs = [{"setting": s} for s in ["a rooftop garden", "a desert diner", "a quiet harbor"]]
results = chain.batch(inputs, config={"max_concurrency": 8})

ट्रायल कुंजी पर 2 का उपयोग 8 के बजाय करें। जब आप एक सीमा को पार कर जाते हैं, तो API HTTP 429 लौटाती है त्रुटि कोड rate_limited (प्रति मिनट बहुत सारे अनुरोध) या concurrency (एक साथ बहुत सारे) के साथ। अस्थायी ओवरलोड पर यह भी 429 लौटाती है, Retry-After: 5 हेडर के साथ। क्लाइंट में max_retries सेटिंग अस्थायी मामलों को संभालती है, लेकिन यदि आप त्रुटि कोड concurrency को बार-बार देखते हैं, तो रीट्राइज जोड़ने के बजाय max_concurrency कम करें।

  • हर कॉल पर नॉट-फाउंड एरर: जांचें कि बेस URL /v1 पर समाप्त होता है।
  • प्रमाणीकरण त्रुटि: कुंजी अनुपस्थित है या इसमें टाइपो है; सुनिश्चित करें कि इसे api_key के माध्यम से भेजा गया है।
  • मॉडल त्रुटियाँ: मॉडल का नाम बिल्कुल uncensored होना चाहिए।
  • धीमी बैच रन: रुके हुए स्ट्रीम कन्करेंसी स्लॉट्स को पकड़े रखते हैं, इसलिए उन्हें बंद करें या टाइमआउट सेट करें।

मूल्य $0.15 प्रति मिलियन इनपुट टोकन और $0.50 प्रति मिलियन आउटपुट टोकन है, और विफल या अस्वीकृत अनुरोधों के लिए चार्ज नहीं किया जाता है। मूल्य निर्धारण पृष्ठ टॉप-अप सूचीबद्ध करता है, और दस्तावेज़ीकरण प्रत्येक पैरामीटर और प्रतिक्रिया हेडर को कवर करता है, जिसमें X-Request-Id और X-Balance-USD शामिल हैं, जो LangChain कॉलबैक में लॉग करने के लिए उपयोगी हैं।

01

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

मुझे किस LangChain क्लास का उपयोग करना चाहिए?

Python में langchain-openai से ChatOpenAI का उपयोग करें, या Node में @langchain/openai से ChatOpenAI का उपयोग करें। बेस URL को https://api.deepseekapipricing.com/v1 पर सेट करें और मॉडल को uncensored पर सेट करें।

क्या LangChain के साथ स्ट्रीमिंग काम करता है?

हाँ। API SSE के माध्यम से स्ट्रीम करता है और अंत में उपयोग भेजता है, इसलिए llm.stream काम करता है। यदि आप स्ट्रीम में टोकन गणना चाहते हैं, तो stream_usage=True सेट करें।

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

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

मुझे HTTP 429 क्यों मिलता है?

या तो आपने प्रति-मिनट की सीमा (rate_limited) पार कर ली है, एक साथ बहुत सारे अनुरोध भेजे हैं (concurrency), या प्रदाता अस्थायी रूप से ओवरलोड था। max_concurrency कम करें और Retry-After का सम्मान करें।

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

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

API कुंजी पाएँ