Streamování: Přijímání odpovědí v reálném čase
Na této stránce
Streamování: Přijímání odpovědí v reálném čase
Streamování ti umožňuje přijímat odpověď token po tokenu místo toho, abys čekal na dokončení celé generace. Nejde jen o vylepšení uživatelského rozhraní: právě to odděluje chatbota, který působí pomalu, od toho, který reaguje svižně, i když je výkon serveru totožný.
Proč streamovat
Bez streamování se uživatelé někdy dívají na prázdnou obrazovku deset až třicet sekund, než se najednou objeví celá odpověď. Při streamování se první slova zobrazí pod sekundu a čtení začíná ještě během generování. Celková doba trvání je stejná; vnímání nikoliv. Jeho povolení vyžaduje pouze jeden parametr, stream=True, který změní návratovou hodnotu create() na iterátor událostí.
from openai import OpenAI
client = OpenAI()
# BEZ streamování — čekej na vše
response = client.responses.create(
model="gpt-5.6-terra",
input="Write a paragraph about artificial intelligence."
)
print(response.output_text) # Objeví se najednou po čekání
# SE streamováním — token po tokenu
stream = client.responses.create(
model="gpt-5.6-terra",
input="Write a paragraph about artificial intelligence.",
stream=True
)
for event in stream:
if event.type == "response.output_text.delta":
print(event.delta, end="", flush=True)
print() # Nový řádek na konci
Typované události, nikoliv beztvarý proud
Stream nepřenáší pouze text. Upozorňuje tě, když je odpověď vytvořena, když je přidána každá výstupní položka, když přicházejí fragmenty a když dojde k dokončení — poslední událost zahrnuje metriky využití. Filtruješ podle event.type, abys věděl, s čím pracuješ. Tato struktura ti například umožňuje zobrazit indikátor načítání, jakmile se spustí response.created, a na konci sečíst tokeny bez druhého volání API.
stream = client.responses.create(
model="gpt-5.6-terra",
input="Hello!",
stream=True
)
for event in stream:
match event.type:
case "response.created":
print(f"[Response created] ID: {event.response.id}")
case "response.output_item.added":
print(f"[New output item]")
case "response.output_text.delta":
print(f"[Text] {event.delta}", end="")
case "response.output_text.done":
print(f"\n[Text complete]")
case "response.completed":
print(f"[Done] Tokens: {event.response.usage.total_tokens}")
# Výstup:
# [Response created] ID: resp_abc123
# [New output item]
# [Text] Hello[Text] ! [Text] How[Text] can[Text] I...
# [Text complete]
# [Done] Tokens: 25
V reálné aplikaci budeš téměř vždy chtít dělat dvě věci najednou: zobrazovat fragmenty a rekonstruovat celý text, abys jej mohl archivovat nebo vrátit volajícímu. Pravidlo je jednoduché: akumuluj data během iterace, protože jakmile je stream spotřebován, nelze jej převinout zpět.
def stream_and_collect(prompt: str) -> str:
"""Streamuje odpověď a zároveň ji shromažďuje."""
stream = client.responses.create(
model="gpt-5.6-terra",
input=prompt,
stream=True
)
full_text = ""
for event in stream:
if event.type == "response.output_text.delta":
full_text += event.delta
print(event.delta, end="", flush=True)
print() # Nový řádek
return full_text
result = stream_and_collect("List 3 European capitals.")
print(f"\nCollected text ({len(result)} characters)")
Streamování a volání funkcí
Volání funkcí jsou také streamována s vlastními událostmi: argumenty přicházejí ve fragmentech přes response.function_call_arguments.delta a response.function_call_arguments.done signalizuje, že JSON je kompletní. To má důležitý praktický dopad — nikdy se nepokoušej deserializovat argumenty před událostí done, jinak budeš mít pouze oříznutý JSON.
stream = client.responses.create(
model="gpt-5.6-terra",
input="What time is it in Tokyo?",
tools=[{
"type": "function",
"name": "get_time",
"description": "Get the time in a city",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string"}
},
"required": ["city"]
}
}],
stream=True
)
for event in stream:
match event.type:
case "response.output_text.delta":
print(event.delta, end="")
case "response.function_call_arguments.delta":
print(f"[Args] {event.delta}", end="")
case "response.function_call_arguments.done":
print(f"\n[Function call complete]")
# Výstup:
# [Args] {"city": "Tokyo"}
# [Function call complete]
Asynchronní případ
Jakmile tvoje aplikace obsluhuje více uživatelů současně, přepni se na AsyncOpenAI: synchronní klient by blokoval smyčku událostí po celou dobu generování a způsobil by čekání tvých dalších požadavků. Syntaxe se liší pouze dvěma klíčovými slovy — await při vytváření a async for při iteraci.
from openai import AsyncOpenAI
import asyncio
async_client = AsyncOpenAI()
async def stream_async(prompt: str):
"""Asynchronní streamování odpovědi."""
stream = await async_client.responses.create(
model="gpt-5.6-terra",
input=prompt,
stream=True
)
async for event in stream:
if event.type == "response.output_text.delta":
print(event.delta, end="", flush=True)
print()
asyncio.run(stream_async("Tell a short joke."))
Na webu je streamování zbytečné, pokud skončí na tvém serveru: musíš jej rozšířit až do prohlížeče. FastAPI to umožňuje pomocí StreamingResponse, které je napájeno generátorem přeposílajícím fragmenty, jak přicházejí.
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from openai import OpenAI
app = FastAPI()
client = OpenAI()
@app.get("/chat")
async def chat(question: str):
def generate():
stream = client.responses.create(
model="gpt-5.6-terra",
input=question,
stream=True
)
for event in stream:
if event.type == "response.output_text.delta":
yield event.delta
return StreamingResponse(generate(), media_type="text/plain")
Chyby uprostřed streamu
Jeden detail si zaslouží tvou pozornost: při streamování může dojít k chybě poté, co již byly zobrazeny fragmenty. Uživatel pak vidí odpověď, která začala, ale byla přerušena. Proto obal samotnou iteraci, nejen vytvoření streamu, abys mohl čistě signalizovat přerušení, místo aby věta zůstala nedokončená.
from openai import APIError
def stream_with_errors(prompt: str):
"""Streamování s robustním ošetřením chyb."""
try:
stream = client.responses.create(
model="gpt-5.6-terra",
input=prompt,
stream=True
)
for event in stream:
if event.type == "response.output_text.delta":
print(event.delta, end="", flush=True)
print()
except APIError as e:
print(f"\nAPI error during streaming: {e.message}")
except Exception as e:
print(f"\nUnexpected error: {e}")
stream_with_errors("Explain streaming in 2 sentences.")
Klíčové poznatky
- Povol streamování pomocí
stream=Truepro zážitek v reálném čase - Filtruj události podle
event.type, abys správně zpracoval každý typ dat response.output_text.deltaobsahuje textové fragmentyresponse.completedsignalizuje konec a zahrnuje metriky využití- Pro streamování v asynchronních aplikacích použij
AsyncOpenAI - Vždy ošetřuj chyby, a to i v režimu streamování