# Streaming कैसे काम करती है — Claude API / OpenAI API की बुनियाद

Source: https://www.geekswithgeeks.com/hi/llm-apis/s-how

> Server-sent events समझें और हर SDK से उन्हें उपयोग करें।

## एक बड़े response की जगह events

लंबा उत्तर बनने में कई सेकंड लग सकते हैं। **Streaming** में server उत्तर को छोटे **events** की शृंखला के रूप में भेजता है (सामान्य HTTP response पर **Server-Sent Events** से) जबकि मॉडल अभी बना रहा होता है, इसलिए user को पहले शब्द लगभग तुरंत दिखते हैं। कुल समय समान है, पर **अनुभव की latency** तेज़ी से घटती है। Anthropic की stream में typed events हैं (message शुरू, content-block शुरू, पाठ deltas, content-block समाप्त, stop reason व usage वाला message delta, message समाप्त); OpenAI ऐसे chunks stream करता है जिनके `delta` में नया पाठ होता है, अंत में अंतिम chunk और `[DONE]`। SDKs parsing छिपाते हैं: आप पाठ टुकड़ों पर iterate करते हैं और अंत में **जुड़ा हुआ अंतिम message** और usage माँग सकते हैं।

## पाठ बनते ही दिखाएँ

Streaming उत्तर छोटे events में भेजती है ताकि users उसे तुरंत देखें।

![तीन विचार: events, जोड़ना, errors सँभालना।](assets/figures/llm-apis/section-3-map.svg) — चित्र 3.1 — Events, जोड़ना और errors सँभालना।

## दोनों SDKs के साथ streaming, चलाकर

मैंने यह Python virtual environment में anthropic 1.11.0 और openai 3.22.1 SDKs के साथ छोटे स्थानीय stand-in server (testing विषय में दिखाया, `mock.py` नाम से सहेजा) के विरुद्ध चलाया। Server तैयार उत्तर लौटाता है, इसलिए कोई key, network या असली मॉडल शामिल नहीं: यह साबित करता है कि SDK requests कैसे बनाता और उत्तर कैसे सँभालता है, यह नहीं कि असली मॉडल क्या कहता। दोनों SDKs वही तीन पाठ टुकड़े ("Hel", "lo ", "there") देते हैं। Anthropic stop reason सहित अंतिम जुड़ा message भी देता है; OpenAI में आप `delta.content` टुकड़े ख़ुद जोड़ते हैं।

```python
import mock, anthropic, openai
srv = mock.start(); base = f"http://127.0.0.1:{srv.server_address[1]}"      # local stand-in server, not a real API

a = anthropic.Anthropic(api_key="k", base_url=base)
with a.messages.stream(model="demo-model", max_tokens=50, messages=[{"role": "user", "content": "Hi"}]) as stream:
    pieces = list(stream.text_stream)
    final = stream.get_final_message()
print("anthropic pieces:", pieces, "| final:", final.content[0].text, "|", final.stop_reason)

o = openai.OpenAI(api_key="k", base_url=base + "/v1")
chunks = o.chat.completions.create(model="demo-model", stream=True, messages=[{"role": "user", "content": "Hi"}])
parts = []
for ch in chunks:
    delta = ch.choices[0].delta.content
    if delta: parts.append(delta)
print("openai pieces:   ", parts, "| joined:", "".join(parts))

```

Output:

```
anthropic pieces: ['Hel', 'lo ', 'there'] | final: Hello there | end_turn
openai pieces:    ['Hel', 'lo ', 'there'] | joined: Hello there
```

## Stream का अंत सँभालें

Stop reason और usage के लिए अंतिम event पढ़ें; जो stream उसके बिना समाप्त हो वह बीच में कटी हो सकती है।

**Quiz:** Streaming मुख्य रूप से क्या सुधारती है?

- [ ] Token क़ीमत
- [ ] उत्तरों की सटीकता
- [x] अनुभव की latency, क्योंकि पाठ बनते समय दिखता है
- [ ] Key सुरक्षा

*Answer:* अनुभव की latency, क्योंकि पाठ बनते समय दिखता है. कुल समय समान हो तब भी users को पहले शब्द जल्दी दिखते हैं।