Optimalizované streamování
Na této stránce
Co streamování skutečně mění
Streamování nezrychluje model: činí čekání snesitelným. U odpovědi, jejíž generování trvá pět sekund, se uživatel bez streamování dívá pět sekund na prázdnou obrazovku, než obdrží blok textu. Se streamováním vidí první slova po několika stovkách milisekund a čte si společně s modelem, jak píše. Celková doba trvání je totožná, ale vnímání je zcela odlišné. Proto je vynechání streamování v produkci téměř vždy chybou v návrhu, nikoliv vědomou volbou.
Stream však musí protékat celým tvým řetězcem. Stream správně generovaný API, ale akumulovaný tvým aplikačním serverem nebo bufferovaný reverzní proxy, dorazí k uživateli jako jeden blok: zaplatil jsi cenu za složitost streamování, aniž bys sklidil jeho výhody. Tato lekce proto sleduje kompletní cestu od volání API až po prohlížeč.
Spotřeba streamu na straně klienta
Pomocí Responses API nastavení stream=True transformuje odpověď na sekvenci typovaných událostí, kterými iteruješ, jak přicházejí. Každý fragment textu dorazí v události response.output_text.delta; konec streamu je signalizován událostí response.completed, která nese celý objekt odpovědi, což je užitečné pro získání využití tokenů.
import openai
client = openai.OpenAI()
def generate_streaming(prompt: str):
"""Streamované generování s 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ý řádek na konci
return event.response
Příznak flush=True není kosmetický: bez něj Python sám bufferuje výstup a skončíš s chováním bloku, kterému ses chtěl vyhnout. Tento detail se opakuje v každé vrstvě řetězce a je hlavní obtížností streamování.
Mechanismus také pokrývá volání funkcí. Argumenty nástrojů se budují postupně a můžeš je zobrazovat, jak se generují, abys signalizoval uživateli, že se formuluje vyhledávání, místo abys ho nechal zírat na zamrzlé rozhraní, zatímco model připravuje své volání.
tools = [
{
"type": "function",
"name": "search_product",
"description": "Searches for a product in the catalog.",
"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 funkce právě generované
print(f"[arg: {event.delta}]", end="")
case "response.function_call_arguments.done":
print(f"\n[Function call complete]")
Předávání streamu do prohlížeče
Tvůj frontend nekomunikuje přímo s OpenAI API – komunikuje s tvým serverem, který musí stream dále předávat. Server-Sent Events (SSE) jsou pro toto přirozeným formátem: HTTP odpověď, která zůstává otevřená, kde každý řádek data: nese fragment JSON. Následující příklad předává text, jak přichází, a poté vysílá závěrečnou zprávu obsahující počet tokenů, což ti umožňuje fakturovat nebo logovat bez druhého volání.
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é pro nginx
},
)
Pak tu je reverzní proxy, obvyklý podezřelý, když „streamování nefunguje v produkci, přestože lokálně fungovalo.“ Ve výchozím nastavení nginx akumuluje odpověď backendu před jejím přenosem. Níže uvedená konfigurace toto chování zakazuje pouze pro konkrétní 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žování připojení v čase
Stream otevřený po několik desítek sekund je více vystaven než krátké volání: výpadek sítě, dosažení kvóty a generování se zastaví uprostřed věty. Tvá strategie opakování musí rozlišovat mezi těmito dvěma případy, protože vyžadují odlišné přístupy. Chyba připojení by měla být opakována s exponenciálním backoffem, aby se síti dal čas na obnovu bez zahlcování API; překročení kvóty by mělo být opakováno po pevné době čekání, protože okno limitu rychlosti se resetuje v pravidelných intervalech.
import openai
def resilient_streaming(prompt: str, max_attempts: int = 3):
"""Streamování s ošetřením chyb a opakování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 # Úspěch, konec
except openai.APIConnectionError:
if attempt < max_attempts - 1:
import time
time.sleep(2 ** attempt) # Exponenciální backoff
else:
raise
except openai.RateLimitError:
import time
time.sleep(5) # Pevné čekání pro limit rychlosti
Jedna poslední úprava zlepšuje komfort čtení. Vysílání každého tokenu produkuje trhavý text, zejména pokud tvé rozhraní aplikuje animaci nebo pokud výsledek směřuje do převodu textu na řeč. Akumulace až do konce věty dává rytmus bližší lidskému čtení za cenu mírného dodatečného zpoždění u prvního fragmentu.
def streaming_by_sentence(prompt: str):
"""Akumuluje a vydává po celých větá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
# Hledání konce věty
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ávěrečného if buffer.strip(): bez něj by odpověď, která nekončí silnou interpunkcí, přišla o svá poslední slova. Tento druh přehlédnutí zůstane při testování bez povšimnutí a projeví se v produkci u odpovědí zkrácených pomocí max_output_tokens.
Klíčové poznatky
- V produkci vždy používej streamování ke snížení vnímané latence
- Nakonfiguruj nginx s
proxy_buffering offpro SSE - Ošetřuj chyby pomocí opakování a exponenciálního backoffu
- Akumuluj po větách pro přirozenější zobrazení