ब्लॉग पर वापस जाएं

API और SDKगाइड

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

आधिकारिक openai पैकेज के साथ मॉडल का उत्तर उत्पन्न होते ही प्रिंट करें — सिंक और async उदाहरण, रीज़निंग आउटपुट, टोकन उपयोग और त्रुटि प्रबंधन।

CheapTokens Team द्वाराप्रकाशित 5 मिनट का पाठ

Python कोड जिसमें स्ट्रीम चंक्स पर for लूप और टेक्स्ट टोकन-दर-टोकन प्रकट होता है
इस पृष्ठ पर
  1. सेटअप
  2. न्यूनतम उदाहरण
  3. रीज़निंग मॉडल
  4. टोकन उपयोग
  5. asyncio
  6. जल्दी रोकना और टाइमआउट
  7. त्रुटियाँ
  8. वायर पर क्या है

स्ट्रीमिंग के साथ, उत्तर टुकड़े-टुकड़े में आता है जबकि मॉडल अभी भी इसे उत्पन्न कर रहा होता है, इसलिए आपके उपयोगकर्ता पूरे उत्तर की प्रतीक्षा करने के बजाय तुरंत टेक्स्ट देखते हैं। API मानक OpenAI स्ट्रीमिंग प्रारूप (सर्वर-सेंट इवेंट्स) का उपयोग करता है, और आधिकारिक openai Python पैकेज इसे आपके लिए संभालता है।

नीचे दिया गया प्रत्येक उदाहरण पूर्ण है: इसे एक फ़ाइल में कॉपी करें और चलाएँ। उदाहरणों को Python 3.10.12 और openai 3.31.0 के साथ एक स्थानीय परीक्षण सर्वर के विरुद्ध जाँचा गया था जो API के स्ट्रीमिंग प्रारूप (सिंटैक्स और निष्पादन) को पुन: उत्पन्न करता है।

सेटअप#

bash
pip install openai
export CHEAPTOKENS_API_KEY="paste-your-key-here"

न्यूनतम उदाहरण#

python
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.cheaptokens.dev/v1",
    api_key=os.environ["CHEAPTOKENS_API_KEY"],
)

stream = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V4-Flash-0731",
    messages=[{"role": "user", "content": "Write a haiku about latency"}],
    stream=True,
)
for chunk in stream:
    if not chunk.choices:  # service chunk without text, e.g. the final usage chunk
        continue
    text = chunk.choices[0].delta.content
    if text:
        print(text, end="", flush=True)
print()

दो विवरण मायने रखते हैं:

  • choices के बिना चंक्स को छोड़ें। कुछ चंक्स में कोई टेक्स्ट नहीं होता — उदाहरण के लिए टोकन उपयोग वाला अंतिम चंक।
  • delta.content खाली हो सकता है। पहला चंक अक्सर केवल भूमिका लेकर आता है, और अंतिम केवल finish_reason। टेक्स्ट तभी प्रिंट करें जब वह मौजूद हो।

रीज़निंग मॉडल#

zai-org/GLM-5.3-Flash उत्तर देने से पहले तर्क करता है। तर्क डेल्टा के एक अलग फ़ील्ड में आता है, reasoning_content, और उत्तर स्वयं content में। SDK अज्ञात फ़ील्ड रखता है, इसलिए आप इसे getattr के साथ पढ़ सकते हैं। यह अपने स्वयं के क्लाइंट और अपनी स्वयं की स्ट्रीम के साथ एक पूर्ण उदाहरण है:

python
import os
import sys
from openai import OpenAI

client = OpenAI(
    base_url="https://api.cheaptokens.dev/v1",
    api_key=os.environ["CHEAPTOKENS_API_KEY"],
)

stream = client.chat.completions.create(
    model="zai-org/GLM-5.3-Flash",
    messages=[{"role": "user", "content": "Is 1013 a prime number?"}],
    stream=True,
)
for chunk in stream:
    if not chunk.choices:
        continue
    delta = chunk.choices[0].delta
    thinking = getattr(delta, "reasoning_content", None)
    if thinking:
        print(thinking, end="", flush=True, file=sys.stderr)  # reasoning → stderr
    if delta.content:
        print(delta.content, end="", flush=True)              # answer → stdout
print()

उत्तर का पहला शब्द प्रकट होने से पहले तर्क में कुछ समय लग सकता है — स्ट्रीम करने का एक और कारण।

टोकन उपयोग#

stream_options के साथ उपयोग माँगें; यह अंतिम चंक में आता है, जिसमें choices नहीं होता:

python
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.cheaptokens.dev/v1",
    api_key=os.environ["CHEAPTOKENS_API_KEY"],
)

stream = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V4-Flash-0731",
    messages=[{"role": "user", "content": "Explain idempotency in one paragraph"}],
    stream=True,
    stream_options={"include_usage": True},
)
usage = None
for chunk in stream:
    if chunk.usage:
        usage = chunk.usage
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

if usage:
    print(f"\ninput: {usage.prompt_tokens}, output: {usage.completion_tokens}")

अनुरोध की लागत प्राप्त करने के लिए इन संख्याओं को मॉडल की दरों से गुणा करें — देखें How to estimate the cost of an AI agent।

asyncio#

async कोड में AsyncOpenAI और async for का उपयोग करें। क्लाइंट का अपना नाम है, async_client, ताकि यह अन्य उदाहरणों के सिंक्रोनस client से टकराए नहीं:

python
import asyncio
import os
from openai import AsyncOpenAI

async_client = AsyncOpenAI(
    base_url="https://api.cheaptokens.dev/v1",
    api_key=os.environ["CHEAPTOKENS_API_KEY"],
)

async def main() -> None:
    stream = await async_client.chat.completions.create(
        model="deepseek-ai/DeepSeek-V4-Flash-0731",
        messages=[{"role": "user", "content": "Name three uses of a message queue"}],
        stream=True,
    )
    async for chunk in stream:
        if chunk.choices and chunk.choices[0].delta.content:
            print(chunk.choices[0].delta.content, end="", flush=True)
    print()

asyncio.run(main())

जल्दी रोकना और टाइमआउट#

जनरेशन रोकने के लिए लूप छोड़ें। with के साथ स्ट्रीम खोलने पर ब्लॉक समाप्त होने पर कनेक्शन बंद हो जाता है। क्लाइंट टाइमआउट स्पष्ट रूप से सेट किया गया है; SDK कुछ विफल अनुरोधों को स्वयं भी पुनः प्रयास करता है (max_retries, डिफ़ॉल्ट रूप से 2)।

python
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.cheaptokens.dev/v1",
    api_key=os.environ["CHEAPTOKENS_API_KEY"],
    timeout=120,  # seconds; long answers take time
)

received = ""
with client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V4-Flash-0731",
    messages=[{"role": "user", "content": "Write a long story about a lighthouse"}],
    stream=True,
) as stream:
    for chunk in stream:
        if chunk.choices and chunk.choices[0].delta.content:
            received += chunk.choices[0].delta.content
        if len(received) > 300:  # stop early: enough text received
            break
print(received)

त्रुटियाँ#

पहले चंक से पहले होने वाली त्रुटियाँ — गलत कुंजी, खाली शेष राशि, अज्ञात मॉडल — स्ट्रीम बनाते समय अपवाद के रूप में उठाई जाती हैं:

python
import os
import openai
from openai import OpenAI

client = OpenAI(
    base_url="https://api.cheaptokens.dev/v1",
    api_key=os.environ["CHEAPTOKENS_API_KEY"],
)

try:
    stream = client.chat.completions.create(
        model="deepseek-ai/DeepSeek-V4-Flash-0731",
        messages=[{"role": "user", "content": "Hello"}],
        stream=True,
    )
    for chunk in stream:
        if chunk.choices and chunk.choices[0].delta.content:
            print(chunk.choices[0].delta.content, end="", flush=True)
    print()
except openai.AuthenticationError:          # 401: wrong or rotated key
    print("Check the API key")
except openai.BadRequestError as e:         # 400: e.g. unknown model ID
    print("Bad request:", e.message)
except openai.APIStatusError as e:          # other statuses, e.g. 402 when the balance is used up
    print(e.status_code, e.message)

स्टेटस कोड और समाधान की पूरी सूची Common connection errors and how to fix them में है।

वायर पर क्या है#

डीबग करने के लिए, curl के साथ कच्ची स्ट्रीम देखें (-N बफ़रिंग बंद करता है):

bash
curl -N https://api.cheaptokens.dev/v1/chat/completions \
  -H "Authorization: Bearer $CHEAPTOKENS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "deepseek-ai/DeepSeek-V4-Flash-0731", "stream": true,
       "messages": [{"role": "user", "content": "Hi"}]}'

प्रत्येक इवेंट एक data: {…} लाइन है जिसमें एक JSON चंक होता है; स्ट्रीम data: [DONE] के साथ समाप्त होती है। कोलन से शुरू होने वाली लाइनें लंबे विराम के दौरान भेजी जाने वाली कीप-अलाइव टिप्पणियाँ हैं — क्लाइंट उन्हें अनदेखा करते हैं।