BroadRouter

LLM स्ट्रीमिंग समझें: SSE चंक, डेल्टा, usage और कैंसल

BroadNet Inference टीम · 4 मिनट में पढ़ें · प्रकाशित · अपडेट किया गया

LLM API चैट कंप्लीशन को Server-Sent Events के रूप में स्ट्रीम करता है: हर data लाइन में एक JSON चंक होता है, जिसका choices[0].delta टेक्स्ट का अगला टुकड़ा लाता है। डेल्टा जोड़ते जाएँ, data: [DONE] पर रुकें, और stream_options में include_usage सेट करें ताकि ख़ाली choices सूची वाले आख़िरी चंक में टोकन की गिनती मिले। कैंसल करने के लिए कनेक्शन बंद करें।

स्ट्रीमिंग के बिना चैट कंप्लीशन तब तक कुछ नहीं लौटाता जब तक पूरा जवाब तैयार न हो जाए। लगभग 100 टोकन प्रति सेकंड पर 600 टोकन के जवाब का मतलब है कई सेकंड की चुप्पी। स्ट्रीमिंग के साथ पहले शब्द मॉडल के लिखते ही दिखने लगते हैं। यह पोस्ट बताती है कि वायर पर असल में क्या जाता है, उसे कैसे पार्स करें, स्ट्रीम से टोकन usage कैसे निकालें, और उसे साफ़ तरीक़े से कैसे रोकें। BroadNet के ख़ास नियम संक्षेप में देखने के लिए स्ट्रीमिंग रेफ़रंस गाइड देखें।

वायर पर SSE स्ट्रीम कैसी दिखती है?

Server-Sent Events एक सादा HTTP रिस्पॉन्स है, Content-Type: text/event-stream के साथ। सर्वर कनेक्शन खुला रखता है और इवेंट लिखता जाता है। हर इवेंट एक या ज़्यादा data: लाइनें हैं, जिनके बाद एक ख़ाली लाइन आती है। OpenAI-कम्पैटिबल API हर इवेंट में एक JSON चंक रखते हैं और अंत में शब्दशः [DONE] भेजते हैं:

data: {"id":"c1","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}],"usage":null}

data: {"id":"c1","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"One, "},"finish_reason":null}],"usage":null}

data: {"id":"c1","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"two, three."},"finish_reason":"stop"}],"usage":null}

data: {"id":"c1","object":"chat.completion.chunk","choices":[],"usage":{"prompt_tokens":14,"completion_tokens":6,"total_tokens":20}}

data: [DONE]

ऊपर का ढाँचा उदाहरण के लिए है और छोटा किया गया है। असली चंक में model और created भी होते हैं, और रीज़निंग मॉडल usage में रीज़निंग टोकन भी बता सकते हैं।

एक चंक में क्या होता है?

फ़ील्ड कहाँ मतलब
choices[0].delta.role पहला चंक आम तौर पर assistant। एक बार भेजा जाता है।
choices[0].delta.content ज़्यादातर चंक टेक्स्ट का अगला टुकड़ा। ख़ाली भी हो सकता है।
choices[0].delta.tool_calls टूल कॉल फ़ंक्शन के नाम और JSON arguments के टुकड़े, जिन्हें index से जोड़ना है।
choices[0].finish_reason आख़िरी कंटेंट चंक stop, length या tool_calls। तब तक null।
usage आख़िरी चंक, अगर माँगा गया हो पूरे अनुरोध की कुल गिनती। बाक़ी हर जगह null।

मुख्य बात है डेल्टा, स्नैपशॉट नहीं। हर चंक में सिर्फ़ वही होता है जो नया है। आप टुकड़ों को क्रम से जोड़कर मैसेज दोबारा बनाते हैं। टूल कॉल भी इसी तरह स्ट्रीम होते हैं: arguments स्ट्रिंग के टुकड़ों में आते हैं जो आख़िरी टुकड़ा आने तक वैध JSON नहीं होते, इसलिए उन्हें तभी पार्स करें जब finish_reason tool_calls हो।

स्ट्रीम से टोकन usage कैसे निकालें?

बिना स्ट्रीम वाले रिस्पॉन्स में usage हमेशा होता है। स्ट्रीम में नहीं, जब तक आप न माँगें। stream_options: {"include_usage": true} सेट करें, और सर्वर [DONE] से पहले एक अतिरिक्त चंक भेजता है। उस चंक में कुल गिनती और एक ख़ाली choices ऐरे होता है। BroadNet Inference पर, जब मॉडल रिपोर्ट करे, usage में prompt_tokens_details.cached_tokens और completion_tokens_details.reasoning_tokens भी हो सकते हैं, और लागत लॉगिंग के लिए आपको यही चाहिए।

आम बग: जो कोड हर चंक पर chunk.choices[0] पढ़ता है, वह usage वाले चंक पर index एरर फेंकता है। पहले choices जाँचें।

Python: स्ट्रीम करें, usage लें, कैंसल करें

import os
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

stream = client.chat.completions.create(
    model="broadnet/deepseek-v4.1-flash",  # DeepSeek V4.1 Flash, a reasoning model
    messages=[{"role": "user", "content": "Explain SSE in three sentences."}],
    stream=True,
    stream_options={"include_usage": True},
    max_tokens=2000,  # reasoning counts toward this limit
)

def user_pressed_stop():  # replace with your own condition
    return False

parts, usage, finish = [], None, None
try:
    for chunk in stream:
        if chunk.choices:
            choice = chunk.choices[0]
            if choice.delta.content:
                parts.append(choice.delta.content)
                print(choice.delta.content, end="", flush=True)
            if choice.finish_reason:
                finish = choice.finish_reason
        if chunk.usage:
            usage = chunk.usage
        if user_pressed_stop():  # your own condition
            break
finally:
    stream.close()  # closes the HTTP connection

text = "".join(parts)

सिर्फ़ break पढ़ना रोक देता है, लेकिन सॉकेट तब तक खुला रहता है जब तक garbage collection न हो। उसे साफ़ तौर पर बंद करें ताकि सर्वर को डिस्कनेक्ट दिखे।

Node: AbortController के साथ स्ट्रीम

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://inference.broadnet.ai/v1", apiKey: process.env.BROADNET_API_KEY });
const controller = new AbortController();
setTimeout(() => controller.abort(), 30_000); // hard stop after 30 s

const stream = await client.chat.completions.create(
  {
    model: "broadnet/deepseek-v4.1-flash",
    messages: [{ role: "user", content: "Explain SSE in three sentences." }],
    stream: true,
    stream_options: { include_usage: true },
  },
  { signal: controller.signal },
);

let text = "";
for await (const chunk of stream) {
  const delta = chunk.choices[0]?.delta?.content;
  if (delta) text += delta;
  if (chunk.usage) console.log(chunk.usage);
}

openai-node README signal विकल्प दर्ज करता है, और यह तब भी काम करता है जब बॉडी अभी पढ़ी जा रही हो। वेब सर्वर में controller.abort() को क्लाइंट अनुरोध के close इवेंट से जोड़ें, ताकि पेज छोड़ने वाला यूज़र जेनरेशन भी रोक दे। ज़्यादा सेटअप Node SDK गाइड में है।

curl: कच्चे इवेंट देखें

curl -N https://inference.broadnet.ai/v1/chat/completions \
  -H "Authorization: Bearer $BROADNET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"broadnet/gemma-4-26b-a4b","stream":true,"stream_options":{"include_usage":true},"messages":[{"role":"user","content":"Count to five."}]}'

-N आउटपुट बफ़रिंग बंद करता है, ताकि इवेंट आते ही प्रिंट हों। कैंसल करने के लिए Ctrl+C दबाएँ; इससे कनेक्शन बंद हो जाता है। API रिक्वेस्ट बिल्डर किसी भी मॉडल और base URL के लिए यह अनुरोध, और इसके Python व Node वर्ज़न, बनाता है।

स्ट्रीम कैसे कैंसल करें, और इसकी लागत क्या है?

SSE में कैंसल करना बस कनेक्शन बंद करना है। कोई “stop” मैसेज नहीं होता। आगे क्या होगा, यह सर्वर पर निर्भर है: ठीक से बना सर्वर बंद सॉकेट को देखकर जेनरेशन रोक देता है। उस पल से पहले बने टोकन असली काम थे। BroadNet का API रेफ़रंस कैंसल की गई स्ट्रीम की बिलिंग दर्ज नहीं करता, इसलिए मानकर योजना बनाएँ कि उपयोग के अनुसार भुगतान पर डिस्कनेक्ट तक बने टोकन बिल होते हैं, और अपने usage रिकॉर्ड जाँचें। फ़्लैट प्लान पर कैंसल की गई स्ट्रीम का कोई अतिरिक्त ख़र्च नहीं, लेकिन सेशन तभी ख़ाली होता है जब सर्वर रुकता है।

स्ट्रीमिंग के पाँच बग जिन्हें जाँचना चाहिए

  1. बफ़र करने वाले प्रॉक्सी। Nginx और कुछ CDN रिस्पॉन्स बफ़र करते हैं, इसलिए क्लाइंट को सब कुछ एक साथ मिलता है। स्ट्रीमिंग रूट के लिए प्रॉक्सी बफ़रिंग बंद करें।
  2. [DONE] की जाँच नहीं। टूटा कनेक्शन छोटे जवाब जैसा दिखता है। [DONE] न मिलने को अधूरा मानें और X-Request-ID रिकॉर्ड करें, जैसा एरर गाइड बताती है।
  3. स्ट्रीम के बीच में रीट्राई। बॉडी आनी शुरू होने के बाद SDK रीट्राई नहीं करते। रीट्राई एक नया अनुरोध है, और उपयोग के अनुसार भुगतान पर एक नया बिल।
  4. finish_reason: length को अनदेखा करना। DeepSeek V4.1 Flash जैसे रीज़निंग मॉडल पर थिंकिंग max_tokens में गिनी जाती है, इसलिए छोटी सीमा कोई भी दिखने वाला टेक्स्ट आने से पहले स्ट्रीम रोक सकती है। रीज़निंग टोकन की लागत क्या है।
  5. लाइनें ग़लत तोड़ना। अगर आप SSE हाथ से पार्स करते हैं, तो ख़ाली लाइन दिखने तक बाइट बफ़र करें। एक TCP रीड JSON चंक के बीच में ख़त्म हो सकती है।

BroadNet Inference कहाँ फ़िट होता है

BroadNet Inference स्टैंडर्ड OpenAI-कम्पैटिबल स्ट्रीमिंग ढाँचा इस्तेमाल करता है, इसलिए Python और Node SDK इसे बिना बदलाव पार्स करते हैं। आख़िरी चंक के usage में, जब मॉडल रिपोर्ट करे, कैश्ड और रीज़निंग टोकन शामिल होते हैं। इसकी डॉक्स कहती हैं कि प्रोडक्शन से पहले हर मॉडल पर स्ट्रीमिंग की पुष्टि करनी चाहिए, इसलिए ऊपर का कोड उसी मॉडल पर चलाएँ जिसे आप शिप करते हैं। अगर आपको मुख्य रूप से यह फ़िक्र है कि पहला टोकन कितनी जल्दी आता है, तो आगे TTFT बनाम थ्रूपुट पढ़ें। अगर आपको WebSockets पर रियलटाइम वॉइस चाहिए, तो यह API उसके लिए नहीं बना; यह चैट कंप्लीशन और फ़ाइल ट्रांसक्रिप्शन देता है।

अक्सर पूछे जाने वाले सवाल

LLM स्ट्रीमिंग के लिए SSE और WebSockets में क्या फ़र्क़ है?

SSE एकतरफ़ा है, सर्वर से क्लाइंट की ओर, एक सामान्य HTTP रिस्पॉन्स पर। चैट कंप्लीशन को बस इतना ही चाहिए, इसलिए OpenAI-कम्पैटिबल API SSE इस्तेमाल करते हैं। WebSockets दोतरफ़ा हैं और उन्हें प्रोटोकॉल अपग्रेड चाहिए; वे रियलटाइम वॉइस के लिए इस्तेमाल होते हैं, चैट कंप्लीशन के लिए नहीं।

मेरे स्ट्रीमिंग चंक में usage null क्यों है?

Usage तभी भेजा जाता है जब आप माँगें। stream_options जोड़ें और उसमें include_usage को true करें। तब आख़िरी को छोड़कर हर चंक में usage null होता है, और आख़िरी चंक ख़ाली choices सूची के साथ कुल गिनती लाता है।

अगर मैं स्ट्रीम कैंसल करूँ तो क्या मुझसे पैसे लगेंगे?

प्रोवाइडर अलग-अलग हैं और कई इसे दर्ज नहीं करते। मानकर चलें कि सर्वर को बंद कनेक्शन का पता चलने से पहले बने टोकन बिल होते हैं। X-Request-ID लॉग करें और अपने usage रिकॉर्ड से मिलाएँ।

कैसे पता चले कि स्ट्रीम सामान्य रूप से पूरी हुई?

आपको data: [DONE] मिला और आख़िरी कंटेंट चंक में stop जैसा finish_reason था। length वाले finish_reason का मतलब है कि max_tokens ने जवाब काट दिया। [DONE] न मिले, तो कनेक्शन टूट गया।

क्या स्ट्रीमिंग से मॉडल तेज़ हो जाता है?

नहीं। कुल जेनरेशन समय उतना ही रहता है। स्ट्रीमिंग वह समय घटाती है जब तक यूज़र को पहले शब्द दिखते हैं, और इसी से चैट इंटरफ़ेस तेज़ महसूस होता है।

Markdown में पढ़ेंChatGPT से पूछेंClaude से पूछेंPerplexity से पूछें