स्ट्रीमिंग के बिना चैट कंप्लीशन तब तक कुछ नहीं लौटाता जब तक पूरा जवाब तैयार न हो जाए। लगभग 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 रिकॉर्ड जाँचें। फ़्लैट प्लान पर कैंसल की गई स्ट्रीम का कोई अतिरिक्त ख़र्च नहीं, लेकिन सेशन तभी ख़ाली होता है जब सर्वर रुकता है।
स्ट्रीमिंग के पाँच बग जिन्हें जाँचना चाहिए
- बफ़र करने वाले प्रॉक्सी। Nginx और कुछ CDN रिस्पॉन्स बफ़र करते हैं, इसलिए क्लाइंट को सब कुछ एक साथ मिलता है। स्ट्रीमिंग रूट के लिए प्रॉक्सी बफ़रिंग बंद करें।
[DONE]की जाँच नहीं। टूटा कनेक्शन छोटे जवाब जैसा दिखता है।[DONE]न मिलने को अधूरा मानें औरX-Request-IDरिकॉर्ड करें, जैसा एरर गाइड बताती है।- स्ट्रीम के बीच में रीट्राई। बॉडी आनी शुरू होने के बाद SDK रीट्राई नहीं करते। रीट्राई एक नया अनुरोध है, और उपयोग के अनुसार भुगतान पर एक नया बिल।
finish_reason: lengthको अनदेखा करना। DeepSeek V4.1 Flash जैसे रीज़निंग मॉडल पर थिंकिंग max_tokens में गिनी जाती है, इसलिए छोटी सीमा कोई भी दिखने वाला टेक्स्ट आने से पहले स्ट्रीम रोक सकती है। रीज़निंग टोकन की लागत क्या है।- लाइनें ग़लत तोड़ना। अगर आप SSE हाथ से पार्स करते हैं, तो ख़ाली लाइन दिखने तक बाइट बफ़र करें। एक TCP रीड JSON चंक के बीच में ख़त्म हो सकती है।
BroadNet Inference कहाँ फ़िट होता है
BroadNet Inference स्टैंडर्ड OpenAI-कम्पैटिबल स्ट्रीमिंग ढाँचा इस्तेमाल करता है, इसलिए Python और Node SDK इसे बिना बदलाव पार्स करते हैं। आख़िरी चंक के usage में, जब मॉडल रिपोर्ट करे, कैश्ड और रीज़निंग टोकन शामिल होते हैं। इसकी डॉक्स कहती हैं कि प्रोडक्शन से पहले हर मॉडल पर स्ट्रीमिंग की पुष्टि करनी चाहिए, इसलिए ऊपर का कोड उसी मॉडल पर चलाएँ जिसे आप शिप करते हैं। अगर आपको मुख्य रूप से यह फ़िक्र है कि पहला टोकन कितनी जल्दी आता है, तो आगे TTFT बनाम थ्रूपुट पढ़ें। अगर आपको WebSockets पर रियलटाइम वॉइस चाहिए, तो यह API उसके लिए नहीं बना; यह चैट कंप्लीशन और फ़ाइल ट्रांसक्रिप्शन देता है।
