स्ट्रीमिंग आपको क्या देती है
स्ट्रीमिंग के बिना, API पूरा जवाब तब तक रखता है जब तक मॉडल खत्म न कर दे, और फिर उसे एक JSON बॉडी के रूप में भेजता है। लंबे जवाब के लिए इसका मतलब कई सेकंड तक खाली स्क्रीन हो सकता है। stream: true के साथ, सर्वर एक ही जवाब को छोटे-छोटे इवेंट्स की श्रृंखला के रूप में भेजता है, जिनमें से प्रत्येक जवाब के कुछ कैरेक्टर लेता है, और आपका UI उन्हें आते ही प्रिंट कर सकता है।
वायर फॉर्मेट सामान्य HTTP रिस्पॉन्स पर सर्वर-सेंट इवेंट्स (SSE) है। हर इवेंट एक लाइन से शुरू होता है data: के साथ, जिसके बाद एक JSON चंक आता है, और स्ट्रीम data: [DONE] के साथ समाप्त होती है। आप इसे हाथ से पार्स नहीं करते, क्योंकि OpenAI SDKs इसे आपके लिए करते हैं। यदि आप कच्चे बाइट्स देखना चाहते हैं, तो डेवलपर ओवरव्यू एंडपॉइंट लेआउट दिखाता है और API दस्तावेज़ हर पैरामीटर की सूची देता है।
कोड लिखने से पहले दो बातें तय करने की जरूरत है। पहला, स्ट्रीम कौन पढ़ेगा: क्या ब्राउज़र आपके सर्वर से बात कर रहा है, या केवल आपका सर्वर। दूसरा, जब कनेक्शन बीच में टूट जाए तो आप क्या करेंगे। इस पेज का शेष भाग दोनों को कवर करता है।
पाइथन: ओपनएआई एसडीके के साथ स्ट्रीमिंग
SDK को pip install openai के साथ इंस्टॉल करें, हमारे बेस URL के साथ एक क्लाइंट बनाएं, और stream=True पास करें। मॉडल ID uncensored है।
from openai import OpenAI
client = OpenAI(
base_url="https://api.uncensoredllmapi.com/v1",
api_key="YOUR_KEY",
)
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a four-line poem about rain."}],
stream=True,
)
text = []
usage = None
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
piece = chunk.choices[0].delta.content
text.append(piece)
print(piece, end="", flush=True)
if getattr(chunk, "usage", None):
usage = chunk.usage
print()
print("tokens:", usage)
chunk.choices and ... की जाँच करें। अंतिम chunk जिसमें usage होता है, उसमें choices की सूची खाली हो सकती है, और उस पर इंडेक्स करने से त्रुटि आएगी। लंबे उत्तरों पर बार-बार स्ट्रिंग संयोजन करने की तुलना में टुकड़ों को एक सूची में एकत्र करके अंत में जोड़ना कम खर्चीला होता है।
नोड: जावास्क्रिप्ट में वही कॉल
Node के लिए आधिकारिक openai पैकेज के साथ स्ट्रीम एक एसी इटरेटर है। यह उदाहरण ES मॉड्यूल का उपयोग करता है।
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.uncensoredllmapi.com/v1",
apiKey: process.env.API_KEY,
});
const stream = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "Name three uses for a stream." }],
stream: true,
});
let full = "";
let usage = null;
for await (const chunk of stream) {
const piece = chunk.choices?.[0]?.delta?.content;
if (piece) {
full += piece;
process.stdout.write(piece);
}
if (chunk.usage) usage = chunk.usage;
}
console.log("\nusage:", usage);
यदि आप SDK नहीं चाहते, तो fetch भी काम करेगा: stream: true के साथ समान JSON बॉडी भेजें, फिर response.body को TextDecoder से पढ़ें और खाली पंक्तियों पर विभाजित करें। SDK आपको चंक सीमा पर आधे काटे गए इवेंट्स को संभालने से बचाता है, जो हैंडराइटन पार्सर में आम बग है।
उपयोग और शेष राशि पढ़ना
उपयोग स्ट्रीम के अंत में रिपोर्ट किया जाता है। यह वह नंबर है जिसे लागत ट्रैकिंग के लिए लॉग करें, क्योंकि यह आपके बैलेंस पर चार्ज किया जाता है। प्रति 1M इनपुट टोकन $0.15 और प्रति 1M आउटपुट टोकन $0.50 पर, 1,200 इनपुट टोकन और 800 आउटपुट टोकन वाले जवाब की लागत 1,200 x 0.15 / 1,000,000 + 800 x 0.50 / 1,000,000 = $0.00018 + $0.0004 = $0.00058 होती है।
हर रिस्पॉन्स में आपका शेष क्रेडिट लेकर एक X-Balance-USD हेडर भी होता है, ताकि आप बिना दूसरे अनुरोध के कम बैलेंस चेतावनी दिखा सकें। आप टाइमर पर GET /v1/balance भी कॉल कर सकते हैं। विफल या रिफ्यूज अनुरोधों पर चार्ज नहीं होता, जिसका मतलब है कि पहले टोकन से पहले की त्रुटि की कोई लागत नहीं है।
उसी प्रतिक्रिया हेडर में X-Request-Id भी शामिल है। प्रत्येक स्ट्रीम के लिए अपने लॉग लाइन के बगाल इसे स्टोर करें। यदि स्ट्रीम अजीब व्यवहार करती है, तो वह ID वह है जिसे आप सपोर्ट को देते हैं ताकि अनुरोध खोजा जा सके।
ड्रॉप हुए स्ट्रीम और उनसे निपटने का तरीका
स्ट्रीम टूट सकती हैं। एक फोन Wi-Fi से मोबाइल डेटा पर स्विच करता है, एक प्रॉक्सी एक आइडल कनेक्शन बंद कर देता है, एक यूज़र टैब बंद कर देता है। शुरुआत से ही इसकी योजना बनाएं।
आंशिक टेक्स्ट रखें
जैसे ही टुकड़े आएं, उन्हें एक बफर में जोड़ें, और लूप समाप्त होने या त्रुटि आने पर बफर सेव करें। यदि स्ट्रीम फेल हुई, तो आपके पास एक उपयोग करने योग्य आधा जवाब है। उसे फेंकने के बजाय रीट्राई बटन के साथ दिखाएं।
रीट्राई या जारी रखें
पुनर्प्राप्ति का सबसे सरल तरीका मूल अनुरोध को पुनः भेजना है। छोटे उत्तर के लिए यह पर्याप्त है। लंबे उत्तर के लिए, आप सहेजे गए आंशिक पाठ को एक सहायक संदेश के रूप में भेज सकते हैं और मॉडल से उसी स्थान से जारी रखने के लिए कह सकते हैं जहाँ वह रुका था। परिणाम पहले स्ट्रीम से उत्पन्न होने वाले डेटा से मेल नहीं खा सकता है, इसलिए इसे एक सर्वोत्म प्रयास के रूप में मानें और यदि सटीकता मायने रखती है तो अपने UI में इसे लेबल करें।
जो छोड़ दें, उसे बंद करें
एक स्ट्रीम किए गए अनुरोध में उसकी कॉन्करेंसी स्लॉट तब तक बनी रहती है जब तक स्ट्रीम खत्म न हो जाए। एक फुल की एक साथ 8 अनुरोधों की अनुमति देती है, और एक ट्रायल की केवल 2। यदि आपका सर्वर एक ऐसे उपयोगकर्ता के लिए स्ट्रीम पढ़ना जारी रखता है जो चला गया है, तो वह स्लॉट व्यक्त रहता है। जब क्लाइंट डिस्कनेक्ट हो जाए तो अनुरोध रद्द करें। Python में, stream.close() कॉल करें; Node में, stream.controller.abort() कॉल करें।
ब्राउज़र को स्ट्रीम रिले करना
अपनी API कुंजी ब्राउज़र कोड में कभी न रखें। सामान्य सेटअप आपके अपने सर्वर पर एक छोटा एंडपॉइंट है जो API को stream: true के साथ कॉल करता है और हर टुकड़े को पेज पर आगे बढ़ाता है। Node में Express के साथ, Content-Type: text/event-stream सेट करें, हर टुकड़े को data: ... के रूप में लिखें, उसके बाद एक खाली लाइन छोड़ें, और अनुरोध पर close इवेंट के लिए सुनें ताकि ऊपरी कॉल रद्द की जा सके। पेज पर, EventSource GET एंडपॉइंट्स हैंडल करता है, जबकि fetch रीडर के साथ POST बॉडीज हैंडल करता है, जो आपको संदेश इतिहास भेजते समय चाहिए।
संदेश इतिहास को अपने सर्वर या अनुरोध बॉडी पर रखें, और जब बातचीत लंबी हो जाए तो सबसे पुराने टर्न्स को काट दें। कॉन्टेक्स्ट विंडो प्रॉम्प्ट और कंप्लीशन के लिए 100,000 टोकन की है, जो चैट के लिए बहुत कुछ है, लेकिन एक लंबे सत्र में यह अंततः आ जाएगा।
स्ट्रीमिंग के दौरान रेट लिमिट
सीमाएँ हैं 300 अनुरोध प्रति मिनट और 8 समानांतर अनुरोध एक फुल की पर, और 60 प्रति मिनट और 2 समानांतर एक ट्रायल की पर। अधिक जाने पर HTTP 429 लौटाता है। त्रुटि कोड बताता है कि आपने कौन सी सीमा पार की: rate_limited का मतलब प्रति मिनट बहुत सारे अनुरोध हैं, और concurrency का मतलब एक साथ बहुत सारे हैं। अस्थायी ओवरलोड पर API 429 भी Retry-After: 5 हेडर के साथ लौटाता है।
चूँकि 429 किसी भी टोकन के स्ट्रीम होने से पहले आता है, इसे पढ़ना शुरू करने से पहले इसे संभालें। एक छोटा पुनः प्रयास रैपर पर्याप्त है:
import time
from openai import OpenAI, RateLimitError
client = OpenAI(base_url="https://api.uncensoredllmapi.com/v1", api_key="YOUR_KEY")
def open_stream(messages, tries=4):
for n in range(tries):
try:
return client.chat.completions.create(
model="uncensored", messages=messages, stream=True
)
except RateLimitError as e:
wait = 5 if n == 0 else 5 * (n + 1)
time.sleep(wait)
raise RuntimeError("still rate limited")
बहुत सारे उपयोगकर्ताओं वाले चेट ऐप्स के लिए, concurrency त्रुटियों का असली समाधान आपके पक्ष में एक छोटा क्यू है जो एक समय में 8 से अधिक लाइव स्ट्रीम की अनुमति नहीं देता।
स्ट्रीमिंग चैट भेजने से पहले चेकलिस्ट
- अंतिम चंक में खाली
choicesसे सावधान रहें। - आंशिक पाठ को बफर करें और त्रुटि पर इसे सहेजें।
- जब ब्राउज़र डिस्कनेक्ट हो जाए तो अपस्ट्रीम अनुरोध रद्द करें।
- लाइव स्ट्रीम को अपनी कॉन्करेंसी सीमा तक सीमित करें।
- प्रत्येक स्ट्रीम के लिए उपयोग और अनुरोध ID लॉग करें।
- अपने सर्वर के सामने किसी भी रिवर्स प्रॉक्सी पर प्रतिक्रिया बफरिंग बंद करें, अन्यथा टोकन बर्स्ट में आएंगे।
अंतिम बिंदु कई पहले डिप्लॉयमेंट को फंसाता है। Nginx, उदाहरण के लिए, प्रॉक्सी किए गए जवाबों को डिफ़ॉल्ट रूप से बफर करता है, इसलिए स्ट्रीम लोकलहोस्ट पर काम करती है और उत्पादन में फ्रोजन दिखती है जब तक उस रूट के लिए बफरिंग अक्षम न कर दी जाए। मुफ्त टेक्स्ट के बजाय JSON आउटपुट के लिए, JSON मोड पर नोट्स देखें। ऊपर दिए गए कोड को आज़माने के लिए, एक API कुंजी बनाएं; नए खाते एक क्लिक में $0.50 का मुफ़्त ट्रायल क्रेडिट दावा कर सकते हैं, जो 7 दिनों के लिए मान्य है। टॉप-अप केवल क्रिप्टो से हैं (TRC20 पर USDT या Base पर USDC), $20 से।
