Optimalizované streamovanie
Na tejto strane
Čo streamovanie skutočne mení
Streamovanie nezrýchľuje model: robí čakanie znesiteľným. Pri odpovedi, ktorej generovanie trvá päť sekúnd, sa používateľ bez streamovania pozerá päť sekúnd na prázdnu obrazovku, kým dostane blok textu. So streamovaním vidí prvé slová po niekoľkých stovkách milisekúnd a číta ich súčasne s tým, ako ich model píše. Celková dĺžka trvania je identická, ale vnímanie je úplne odlišné. Preto je vynechanie streamovania v produkcii takmer vždy chybou v dizajne, nie vedomou voľbou.
Stream však musí pretekať celým tvojím reťazcom. Stream správne vygenerovaný API, ale akumulovaný tvojím aplikačným serverom alebo bufferovaný reverznou proxy, dorazí k používateľovi v jednom bloku: zaplatil si cenu za zložitosť streamovania, bez toho, aby si zožal jeho výhody. Táto lekcia preto sleduje kompletnú cestu od volania API až po prehliadač.
Spracovanie streamu na strane klienta
Pri Responses API nastavenie stream=True transformuje odpoveď na sekvenciu typovaných udalostí, ktorými iteruješ, ako prichádzajú. Každý fragment textu dorazí v udalosti response.output_text.delta; koniec streamu signalizuje response.completed, ktorá nesie celý objekt odpovede, čo je užitočné na získanie využitia tokenov.
import openai
client = openai.OpenAI()
def generate_streaming(prompt: str):
"""Streamované generovanie pomocou Responses API."""
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)
elif event.type == "response.completed":
print() # Nový riadok na konci
return event.response
Príznak flush=True nie je kozmetický: bez neho si Python sám bufferuje výstup a skončíš s blokovým správaním, ktorému si sa chcel vyhnúť. Tento detail sa opakuje na každej vrstve reťazca a je hlavnou ťažkosťou streamovania.
Mechanizmus pokrýva aj volania funkcií. Argumenty nástrojov sa budujú postupne a môžeš ich zobrazovať počas generovania, aby si používateľovi signalizoval, že sa formuluje vyhľadávanie, namiesto toho, aby ho nechal pozerať na zamrznuté rozhranie, kým model pripravuje svoje volanie.
tools = [
{
"type": "function",
"name": "search_product",
"description": "Vyhľadá produkt v katalógu.",
"parameters": {
"type": "object",
"properties": {
"query": {"type": "string"},
"category": {"type": "string"},
},
"required": ["query"],
},
}
]
def streaming_with_tools(prompt: str):
stream = client.responses.create(
model="gpt-5.6-terra",
input=prompt,
tools=tools,
stream=True,
)
for event in stream:
match event.type:
case "response.output_text.delta":
print(event.delta, end="", flush=True)
case "response.function_call_arguments.delta":
# Argumenty funkcie sa práve generujú
print(f"[arg: {event.delta}]", end="")
case "response.function_call_arguments.done":
print(f"\n[Volanie funkcie dokončené]")
Preposielanie streamu do prehliadača
Tvoj frontend nekomunikuje priamo s API OpenAI – komunikuje s tvojim serverom, ktorý musí stream preposlať ďalej. Server-Sent Events (SSE) sú pre toto prirodzeným formátom: HTTP odpoveď, ktorá zostáva otvorená, kde každý riadok data: nesie JSON fragment. Nasledujúci príklad preposiela text, ako prichádza, a následne vysiela finálnu správu obsahujúcu počet tokenov, čo ti umožňuje fakturovať alebo logovať bez druhého volania.
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
import openai
import json
app = FastAPI()
client = openai.OpenAI()
@app.post("/api/chat")
async def chat_streaming(request: dict):
prompt = request["message"]
async def generate():
stream = client.responses.create(
model="gpt-5.6-terra",
input=prompt,
stream=True,
)
for event in stream:
if event.type == "response.output_text.delta":
data = json.dumps({"text": event.delta})
yield f"data: {data}\n\n"
elif event.type == "response.completed":
usage = event.response.usage
data = json.dumps({
"end": True,
"input_tokens": usage.input_tokens,
"output_tokens": usage.output_tokens,
})
yield f"data: {data}\n\n"
return StreamingResponse(
generate(),
media_type="text/event-stream",
headers={
"Cache-Control": "no-cache",
"X-Accel-Buffering": "no", # Dôležité pre nginx
},
)
Potom tu máme reverznú proxy, obvyklého podozrivého, keď „streamovanie nefunguje v produkcii, hoci lokálne fungovalo.“ Predvolene nginx akumuluje odpoveď z backendu pred jej odoslaním. Nižšie uvedená konfigurácia vypína toto správanie len pre konkrétnu trasu.
location /api/chat {
proxy_pass http://127.0.0.1:8000;
proxy_buffering off;
proxy_cache off;
proxy_set_header Connection "";
chunked_transfer_encoding on;
}
Udržiavanie pripojenia v čase
Stream otvorený niekoľko desiatok sekúnd je viac vystavený riziku ako krátke volanie: výpadok siete, dosiahnutie kvóty a generovanie sa zastaví v polovici vety. Tvoja stratégia opakovania musí rozlišovať medzi týmito dvoma prípadmi, pretože vyžadujú odlišný prístup. Chyba pripojenia by sa mala opakovať s exponenciálnym oneskorením (exponential backoff), čím sa sieti dá čas na zotavenie bez zahlcovania API; prekročenie kvóty by sa malo opakovať po pevnej čakacej dobe, keďže okno limitu rýchlosti sa resetuje v pravidelných intervaloch.
import openai
def resilient_streaming(prompt: str, max_attempts: int = 3):
"""Streamovanie s ošetrením chýb a opakovaním."""
for attempt in range(max_attempts):
try:
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
yield event.delta
return # Úspech, ukončenie
except openai.APIConnectionError:
if attempt < max_attempts - 1:
import time
time.sleep(2 ** attempt) # Exponenciálne oneskorenie
else:
raise
except openai.RateLimitError:
import time
time.sleep(5) # Pevné čakanie na limit rýchlosti
Jedna posledná úprava zlepšuje komfort čítania. Vysielanie každého tokenu produkuje trhavý text, najmä ak tvoje rozhranie aplikuje animáciu alebo ak výsledok smeruje do prevodu textu na reč. Akumulácia až do konca vety poskytuje rytmus bližší ľudskému čítaniu, za cenu mierneho dodatočného oneskorenia pri prvom fragmente.
def streaming_by_sentence(prompt: str):
"""Akumuluje a vysiela po celých vetách."""
buffer = ""
stream = client.responses.create(
model="gpt-5.6-terra",
input=prompt,
stream=True,
)
for event in stream:
if event.type == "response.output_text.delta":
buffer += event.delta
# Hľadanie konca vety
for separator in [".\n", "!\n", "?\n", ". ", "! ", "? "]:
if separator in buffer:
parts = buffer.split(separator, 1)
yield parts[0] + separator.rstrip()
buffer = parts[1] if len(parts) > 1 else ""
if buffer.strip():
yield buffer.strip()
Všimni si záverečné if buffer.strip(): bez neho by odpoveď, ktorá nekončí silnou interpunkciou, stratila svoje posledné slová. Tento druh prehliadnutia zostane pri testovaní nepovšimnutý a v produkcii sa prejaví pri odpovediach orezaných pomocou max_output_tokens.
Kľúčové poznatky
- V produkcii vždy používaj streamovanie na zníženie vnímanej latencie
- Nakonfiguruj nginx s
proxy_buffering offpre SSE - Spracúvaj chyby pomocou opakovania a exponenciálneho oneskorenia
- Akumuluj po vetách pre prirodzenejšie zobrazenie