Optimalizált adatfolyam
Ezen az oldalon
Mit is változtat valójában az adatfolyam?
Az adatfolyam (streaming) nem teszi gyorsabbá a modellt: csupán elviselhetővé teszi a várakozást. Egy öt másodpercig generálódó válasz esetén a streaming nélkül a felhasználó öt másodpercig egy üres képernyőt bámul, mielőtt megkapná a szövegblokkot. Streaminggel már néhány száz milliszekundum után látja az első szavakat, és olvashatja a szöveget, ahogy a modell írja. A teljes időtartam ugyanaz marad, de az érzékelés teljesen más. Éppen ezért a production környezetben a streaming kihagyása szinte mindig tervezési hiba, nem pedig tudatos döntés.
Azonban az adatfolyamnak végig kell haladnia az egész láncodon. Ha az API helyesen generálja a streamet, de az alkalmazásszervered felhalmozza, vagy a reverse proxy-d puffereli, a felhasználó végül egyetlen blokkban kapja meg az adatot: kifizetted a streaming komplexitási árát anélkül, hogy élveznéd az előnyeit. Ez a lecke ezért végigköveti a teljes utat, az API-hívástól a böngészőig.
Az adatfolyam fogyasztása a kliens oldalon
A Responses API használatakor a stream=True beállítás az választ események típusozott sorozatává alakítja, amelyeket beérkezésük során iterálsz végig. Minden szövegrészlet egy response.output_text.delta eseményben érkezik; az adatfolyam végét a response.completed jelzi, amely a teljes válaszobjektumot tartalmazza – ez hasznos a tokenfelhasználás lekéréséhez.
import openai
client = openai.OpenAI()
def generate_streaming(prompt: str):
"""Streaming generálás a Responses API-val."""
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() # Új sor a végén
return event.response
A flush=True flag nem csupán kozmetikai: nélküle a Python saját maga puffereli a kimenetet, és végül azt a blokkos viselkedést kapod, amit el akartál kerülni. Ez a részlet a lánc minden rétegében megismétlődik, és ez jelenti a streaming fő nehézségét.
A mechanizmus a függvényhívásokat is lefedi. Az eszközök argumentumai fokozatosan épülnek fel, és megjelenítheted őket generálás közben, hogy jelezd a felhasználónak: egy keresés van folyamatban, ahelyett, hogy fagyott felületet bámulna, miközben a modell előkészíti a hívást.
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":
# Jelenleg generálódó függvényargumentumok
print(f"[arg: {event.delta}]", end="")
case "response.function_call_arguments.done":
print(f"\n[Függvényhívás befejezve]")
Az adatfolyam továbbítása a böngésző felé
A frontended nem közvetlenül az OpenAI API-val kommunikál, hanem a szervereddel, amelynek ezért továbbítania kell az adatfolyamot. Erre a Server-Sent Events (SSE) a természetes formátum: egy nyitva maradó HTTP-válasz, ahol minden data: sor egy JSON-részletet szállít. Az alábbi példa továbbítja a szöveget beérkezés közben, majd kibocsát egy záró üzenetet a tokenszámlálóval, így számlázhatsz vagy naplózhatsz anélkül, hogy második hívásra lenne szükség.
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", # Fontos az nginx számára
},
)
Aztán ott van a reverse proxy, a szokásos gyanúsított, amikor „productionben nem működik a streaming, pedig lokálisan igen“. Alapértelmezés szerint az nginx felhalmozza a backend válaszát, mielőtt továbbítaná. Az alábbi konfiguráció kikapcsolja ezt a viselkedést kizárólag az adott útvonalon.
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;
}
A kapcsolat fenntartása időben
Egy több tíz másodpercig nyitva tartott adatfolyam jobban ki van téve a hibáknak, mint egy rövid hívás: egy hálózati kimaradás, egy kvóta túllépése, és a generálás mondat közben megszakad. A retry stratégiádnak különbséget kell tennie e két eset között, mert eltérő megközelítést igényelnek. Kapcsolati hiba esetén exponenciális visszalépéssel (exponential backoff) kell újrapróbálkozni, időt adva a hálózatnak a helyreállásra anélkül, hogy az API-t terhelnéd; kvóta túllépés esetén fix várakozási idő után érdemes újrapróbálkozni, mivel a sebességkorlátozási ablak rendszeres időközönként resetelődik.
import openai
def resilient_streaming(prompt: str, max_attempts: int = 3):
"""Streaming hibakezeléssel és újrapróbálkozással."""
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 # Sikeres, kilépés
except openai.APIConnectionError:
if attempt < max_attempts - 1:
import time
time.sleep(2 ** attempt) # Exponenciális visszalépés
else:
raise
except openai.RateLimitError:
import time
time.sleep(5) # Fix várakozás sebességkorlátozás esetén
Egy utolsó finomhangolás javítja az olvasási élményt. Minden token egyesével történő kibocsátása rángatózó szöveget eredményez, különösen, ha a felületed animációt alkalmaz, vagy ha az eredmény szöveg-beszéd (TTS) konverzióra kerül. A mondat végéig történő felhalmozás az emberi olvasáshoz közelebb álló ritmust biztosít, az első részletnél fellépő csekély plusz késleltetés árán.
def streaming_by_sentence(prompt: str):
"""Felhalmozás és kibocsátás teljes mondatonként."""
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
# Mondatvég keresése
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()
Figyeld meg a záró if buffer.strip() feltételt: enélkül egy olyan válasz, amely nem erős írásjellel végződik, elveszítené az utolsó szavait. Az ilyen figyelmetlenség a tesztelés során észrevétlen marad, és productionben csak akkor mutatkozik meg, amikor a válaszokat a max_output_tokens levágja.
Főbb megállapítások
- Mindig használj streaminget productionben a észlelt késleltetés csökkentése érdekében
- Konfiguráld az nginxet a
proxy_buffering offbeállítással SSE esetén - Kezeld a hibákat újrapróbálkozással és exponenciális visszalépéssel
- Halmozz fel mondatonként a természetesebb megjelenítés érdekében