Streamovanie: Prijímanie odpovedí v reálnom čase
Na tejto strane
Streamovanie: Prijímanie odpovedí v reálnom čase
Streamovanie ti umožňuje prijímať odpoveď token po tokene namiesto čakania na dokončenie celej generácie. Nie je to len kozmetická úprava rozhrania: práve toto oddeľuje chatbota, ktorý pôsobí pomaly, od toho, ktorý pôsobí svižne, aj keď je výkon servera úplne rovnaký.
Prečo streamovať
Bez streamovania sa používatelia niekedy pozerajú na prázdnu obrazovku desať až tridsať sekúnd, kým sa celá odpoveď objaví naraz. So streamovaním sa prvé slová objavia za menej ako sekundu a čítanie začína ešte počas generovania. Celková dĺžka trvania je rovnaká, vnímanie však nie. Jeho aktivácia si vyžaduje len jeden parameter, stream=True, ktorý zmení návratovú hodnotu create() na iterátor udalostí.
from openai import OpenAI
client = OpenAI()
# BEZ streamovania — čakanie na všetko
response = client.responses.create(
model="gpt-5.6-terra",
input="Write a paragraph about artificial intelligence."
)
print(response.output_text) # Objaví sa naraz po čakání
# SO streamovaním — token po tokene
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ý riadok na konci
Typované udalosti, nie nediferencovaný prúd
Stream neprenáša len text. Upozorňuje ťa, keď sa odpoveď vytvorí, keď sa pridá každá výstupná položka, keď prichádzajú fragmenty a keď dôjde k dokončeniu – posledná udalosť obsahuje metriky využitia. Filtruješ podľa event.type, aby si vedel, s čím pracuješ. Táto štruktúra ti umožňuje napríklad zobraziť indikátor načítania hneď, ako sa spustí response.created, a na konci spočítať tokeny bez ďalšieho volania 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álnej aplikácii budeš takmer vždy chcieť robiť dve veci naraz: zobrazovať fragmenty a rekonštruovať celý text, aby si ho mohol archivovať alebo vrátiť volajúcemu. Pravidlo je jednoduché: akumuluj počas iterácie, pretože keď sa stream spotrebuje, nemožno ho previnúť späť.
def stream_and_collect(prompt: str) -> str:
"""Streamuje odpoveď a zároveň ju zhromažď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ý riadok
return full_text
result = stream_and_collect("List 3 European capitals.")
print(f"\nCollected text ({len(result)} characters)")
Streamovanie a volanie funkcií
Volania funkcií sa tiež streamujú s vlastnými udalosťami: argumenty prichádzajú vo fragmentoch cez response.function_call_arguments.delta a response.function_call_arguments.done signalizuje, že JSON je kompletný. Má to dôležitý praktický dôsledok – nikdy sa nepokúšaj deserializovať argumenty pred udalosťou done, inak budeš mať len orezaný 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]
Asynchrónny prípad
Akonáhle tvoja aplikácia obsluhuje viacerých používateľov súčasne, prepnite na AsyncOpenAI: synchroný klient by blokoval slučku udalostí počas celej generácie, čo by spôsobilo čakanie ostatných požiadaviek. Syntax sa líši len dvoma kľúčovými slovami – await pri vytváraní a async for pri iterácii.
from openai import AsyncOpenAI
import asyncio
async_client = AsyncOpenAI()
async def stream_async(prompt: str):
"""Asynchrónne streamovanie odpovede."""
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 webe je streamovanie zbytočné, ak sa zastaví na tvojom serveri: musíš ho rozšíriť až do prehliadača. FastAPI to umožňuje pomocou StreamingResponse, ktorý je napájaný generátorom preposielajúcim fragmenty, ako prichádzajú.
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 počas streamovania
Jeden detail si zaslúži tvoju pozornosť: pri streamovaní môže dôjsť k chybe až po zobrazení fragmentov. Používateľ potom vidí odpoveď, ktorá začala, ale bola prerušená. Preto obal samotnú iteráciu, nielen vytvorenie streamu, aby si mohol čisto signalizovať prerušenie namiesto toho, aby si nechal vetu visieť vo vzduchu.
from openai import APIError
def stream_with_errors(prompt: str):
"""Streamovanie s robustným ošetrovaním chýb."""
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.")
Kľúčové poznatky
- Povoľ streamovanie pomocou
stream=Truepre zážitok v reálnom čase - Filtruj udalosti podľa
event.type, aby si správne spracoval každý typ dát response.output_text.deltaobsahuje textové fragmentyresponse.completedsignalizuje koniec a obsahuje metriky využitia- Použi
AsyncOpenAIpre streamovanie v asynchrónnych aplikáciách - Vždy ošetruj chyby, aj v režime streamovania