DeepSeek API Python उदाहरण: चैट, स्ट्रीमिंग, टूल्स

इंस्टॉल करें और पहला अनुरोध भेजें

यह सेवा आधिकारिक DeepSeek API नहीं है। यह एक होस्टेड, OpenAI-संगत एंडपॉइंट है जो एक ओपन-वेट मॉडल, ID uncensored, चलाता है, जो एक स्वतंत्र प्रदाता द्वारा संचालित है। चूँकि यह OpenAI फॉर्मेट का पालन करता है, इसलिए मानक Python SDK URL और कुंजी के अलावा किसी भी बदलाव के बिना काम करता है।

Copypip install openai

API कुंजी पेज से एक कुंजी प्राप्त करें। साइन-अप करने के बाद आप एक क्लिक के साथ $0.50 का मुफ़्त ट्रायल क्रेडिट दावा कर सकते हैं, बिना किसी कार्ड के, जो 7 दिनों के लिए मान्य है। कुंजी को स्रोत फ़ाइल के बजाय एक एनवायरनमेंट वेरिएबल में स्टोर करें:

Copyexport API_KEY="YOUR_KEY"

Copyimport os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.deepseekapi.top/v1",
    api_key=os.environ["API_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Explain list comprehensions in two sentences."},
    ],
    temperature=0.7,
)

print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)

दो उपयोग संख्याएँ वे हैं जिन पर आपको बिल किया जाता है। किसी भी कॉल की लागत देखने के लिए उन्हें कीमतों से गुणा करें: इनपुट टोकन × $0.15 और आउटपुट टोकन × $0.50, प्रत्येक को 1,000,000 से विभाजित करें।

एसेंक क्लाइंट का उपयोग करना

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

Copyimport asyncio
import os
from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://api.deepseekapi.top/v1",
    api_key=os.environ["API_KEY"],
)

sem = asyncio.Semaphore(8)

async def ask(prompt):
    async with sem:
        r = await client.chat.completions.create(
            model="uncensored",
            messages=[{"role": "user", "content": prompt}],
        )
        return r.choices[0].message.content

async def main():
    prompts = ["Define idempotent.", "Define monotonic.", "Define pure function."]
    answers = await asyncio.gather(*(ask(p) for p in prompts))
    for a in answers:
        print(a)

asyncio.run(main())

सेमाफोर 8 पर सेट है क्योंकि यह एक पूर्ण कुंजी की समानांतर अनुरोध क्षमता है। ट्रायल कुंजी पर 2 का उपयोग करें। बिना कैप के, कार्यों की अचानक बाढ़ concurrency त्रुटियाँ उत्पन्न करेगा, भले ही प्रत्येक अनुरोध वैध हो।

स्ट्रीमिंग प्रतिक्रियाएं

stream=True सेट करें और एंडपॉइंट सर्वर-सेंट इवेंट्स भेजता है। प्रत्येक चंक delta.content में टेक्स्ट का एक छोटा टुकड़ा ले जाता है। उपयोग मांगने का अर्थ है कि अंतिम चंक टोकन गणना रिपोर्ट करता है।

Copy# client = OpenAI(base_url="https://api.deepseekapi.top/v1", ...) as above
stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a haiku about debugging."}],
    stream=True,
    stream_options={"include_usage": True},
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if chunk.usage:
        print("\n", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)

दो बातें लोगों को परेशान करती हैं। आखिरी उपयोग चंक में एक खाली choices लिस्ट हो सकती है, इसलिए लूप chunk.choices को पहले चेक करता है। और एक स्ट्रीम किए गए अनुरोध की कन्करेंसी स्लॉट तब तक बनी रहती है जब तक स्ट्रीम खत्म न हो जाए, इसलिए लूप से साफ़ तरीके से बाहर निकलें और उन स्ट्रीम्स को बंद करें जिन्हें आप छोड़ रहे हैं। एक फुल कुंजी 8 समानांतर अनुरोधों की अनुमति देती है; एक ट्रायल कुंजी 2 की अनुमति देती है।

JSON मोड

ऐसे आउटपुट के लिए जिसे कोई प्रोग्राम पार्स करेगा, response_format का उपयोग json_object के साथ करें। प्रॉम्प्ट में JSON शब्द भी कहें और जो आकार आप चाहते हैं उसे वर्णित करें। मॉडल को उस निर्देश की आवश्यकता है; फ्लैग अकेले स्कीमा प्रदान नहीं करता है।

Copy# client = OpenAI(base_url="https://api.deepseekapi.top/v1", ...) as above
import json

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "Reply with JSON only: {\"title\": str, \"tags\": [str]}"},
        {"role": "user", "content": "Summarize: a guide to caching HTTP responses."},
    ],
    response_format={"type": "json_object"},
    temperature=0,
)

data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])

try/except को json.loads के आसपास रखें। यदि कोई प्रतिक्रिया टोकन लिमिट द्वारा काट दी जाती है तो वह पार्स नहीं होगी, इसलिए JSON के साथ एक छोटा max_tokens से बचें। temperature को 0 सेट करना और एक seed दोबारा चलाने को अधिक दोहराने योग्य बनाता है, क्योंकि दोनों पास किए जाते हैं।

टूल कॉलिंग

API tools और tool_choice स्वीकार करता है, और असिस्टेंट मैसेज पर tool_calls लौटाता है। आप फ़ंक्शन को स्वयं चलाते हैं और परिणाम को role: "tool" के साथ एक मैसेज के रूप में वापस भेजते हैं।

Copy# client = OpenAI(base_url="https://api.deepseekapi.top/v1", ...) as above
import json

tools = [{
    "type": "function",
    "function": {
        "name": "add",
        "description": "Add two numbers.",
        "parameters": {
            "type": "object",
            "properties": {"a": {"type": "number"}, "b": {"type": "number"}},
            "required": ["a", "b"],
        },
    },
}]

messages = [{"role": "user", "content": "What is 17.5 plus 24.25?"}]
first = client.chat.completions.create(
    model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)

msg = first.choices[0].message
if msg.tool_calls:
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = args["a"] + args["b"]
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": str(result),
        })
    final = client.chat.completions.create(
        model="uncensored", messages=messages, tools=tools
    )
    print(final.choices[0].message.content)
else:
    print(msg.content)

हमेशा arguments को सावधानीपूर्वक पार्स करें। यह मॉडल द्वारा उत्पादित एक JSON स्ट्रिंग है, और एक खराब स्ट्रिंग संभव है। इस पर कार्रवाई करने से पहले इसे वैलिडेट करें, खासकर यदि फ़ंक्शन फ़ाइलों या डेटाबेस को छूता है।

त्रुटियां, सीमाएं और रीट्राईज

एक लिमिट से अधिक अनुरोध HTTP 429 लौटाता है। त्रुटि कोड आपको बताता है कि कौन सी लिमिट: rate_limited प्रति मिनट अनुरोधों के लिए (फुल कुंजी पर 300, ट्रायल कुंजी पर 60) और concurrency एक साथ बहुत अधिक के लिए। अस्थायी ओवरलोड पर आपको Retry-After: 5 के साथ भी 429 मिलता है। SDK openai.RateLimitError उठाता है।

Copy# client = OpenAI(base_url="https://api.deepseekapi.top/v1", ...) as above
import time
import openai

def ask(prompt, tries=4):
    for attempt in range(tries):
        try:
            r = client.chat.completions.create(
                model="uncensored",
                messages=[{"role": "user", "content": prompt}],
            )
            return r.choices[0].message.content
        except openai.RateLimitError as e:
            wait = int(e.response.headers.get("Retry-After", 5))
            time.sleep(wait * (attempt + 1))
    raise RuntimeError("still rate limited")

print(ask("Name three Python web frameworks."))

यदि आप कई अनुरोध भेजते हैं, तो एक सेमाफोर या 8 वर्कर्स के थ्रेड पूल के साथ अपनी समानांतरता को कैप करें, या ट्रायल कुंजी पर 2। यह concurrency त्रुटियों से बचता है, उनके माध्यम से रीट्राई करने के बजाय।

हेडर पढ़ना

प्रत्येक प्रतिक्रिया X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests और X-RateLimit-Limit-Concurrency ले जाती है। SDK उन्हें रैस्पॉन्स के माध्यम से एक्सपोज़ करता है:

Copy# client = OpenAI(base_url="https://api.deepseekapi.top/v1", ...) as above
raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "ping"}],
)
print(raw.headers.get("X-Balance-USD"), raw.headers.get("X-Request-Id"))
completion = raw.parse()

हर विफलता के साथ रिक्वेस्ट आईडी लॉग करने से सपोर्ट सवालों का जवाब देना बहुत आसान हो जाता है। विफल या अस्वीकृत अनुरोधों के लिए चार्ज नहीं किया जाता है।

बातचीत को जारी रखना

API स्टेटलेस है। यह पहले अनुरोधों को याद नहीं रखता, इसलिए एक मल्टी-टर्न चैट का मतलब है कि आपको हर बार पूरी हिस्ट्री भेजनी होती है। एक लिस्ट रखें और उसमें ऐपेंड करें:

Copy# client = OpenAI(base_url="https://api.deepseekapi.top/v1", ...) as above
history = [{"role": "system", "content": "You are a helpful tutor."}]

def chat(user_text):
    history.append({"role": "user", "content": user_text})
    r = client.chat.completions.create(model="uncensored", messages=history)
    reply = r.choices[0].message.content
    history.append({"role": "assistant", "content": reply})
    return reply

print(chat("What is a closure?"))
print(chat("Show me one in Python."))

प्रत्येक टर्न सब कुछ फिर से भेजता है, इसलिए इनपुट टोकन टर्न-बाय-टर्न बढ़ते हैं। सूची लंबी होने पर पुराने संदेशों को ट्रिम करें, या मॉडल से शुरुआती हिस्से का सारांश बनाने के लिए कहें और उसे बदलें। 100,000-टोकन विंडो के साथ आपके पास पर्याप्त जगह है, लेकिन बिल इतिहास के साथ बढ़ता है, इसलिए एक ट्रिम की गई सूची सस्ती है।

सैम्पलिंग मान चुनना

कोड और एक्सट्रैक्शन के लिए temperature 0 से 0.3 का उपयोग करें, सामान्य चैट के लिए लगभग 0.7, और कथा के लिए अधिक। top_p, stop, seed और आवृत्ति व उपस्थिति दंड पास किए जाते हैं, इसलिए वे OpenAI दस्तावेज़ीकरण द्वारा वर्णित के रूप में व्यवहार करते हैं। एक बार में एक ही मान बदलें और तुलना करें।

लागत और कॉन्टेक्स्ट की योजना

कॉन्टेक्स्ट विंडो 100,000 टोकन की है, प्रॉम्प्ट प्लस पूर्णता, और बॉडी सीमा 8 MB है। पूर्णता विंडो के बचे हुए हिस्से का उपयोग कर सकती है, और max_tokens वैकल्पिक है। बैच जॉब्स के लिए इसे सेट करना अभी भी अच्छा अभ्यास है।

एक कार्य उदाहरण: 1,000 सारांशों का बैच, प्रत्येक में 1,500 इनपुट टोकन और 200 आउटपुट टोकन हैं।

• इनपुट: 1,000 × 1,500 = 1,500,000 टोकन, जो 1.5 × $0.15 = $0.225 है
• आउटपुट: 1,000 × 200 = 200,000 टोकन, जो 0.2 × $0.50 = $0.10 है
• कुल: $0.325

मूल्य निर्धारण प्रीपेड क्रेडिट से पे-एज़-यू-गो है, कोई सब्सक्रिप्शन नहीं है, और क्रेडिट कभी समाप्त नहीं होता। टॉप-अप $20 से $500 तक पूर्ण राशि में होते हैं, $50 पर +5%, $100 पर +10% और $200 पर +15% बोनस मिलता है, जो कार्ड या क्रिप्टो से भुगतान किया जा सकता है। मूल्य निर्धारण पृष्ठ और क्विकस्टार्ट दस्तावेज़ में curl और Node उदाहरण देखें। यदि आपको केवल अपनी API कुंजी खोजनी है, तो API कुंजी अवलोकन इसकी जानकारी देता है।

प्रॉम्प्ट्स को ट्रेनिंग के लिए उपयोग नहीं किया जाता है। सेवा केवल टेक्स्ट है: कोई इमेज, ऑडियो, एम्बेडिंग्स या फाइन-ट्यूनिंग नहीं, इसलिए उन एंडपॉइंट्स के आसपास योजना न बनाएं।

अधिक गाइड

• Cursor में DeepSeek API कैसे उपयोग करें: कस्टम बेस यूआरएल सेटअप
• ⟦a0⟡SillyTavern में DeepSeek API का उपयोग कैसे करें: कस्टम एंडपॉइंट/a0⟡
• DeepSeek API कुंजी: बिना सेंसर LLM API एक्सेस