Streaming geoptimaliseerd
Op deze pagina
Wat streaming daadwerkelijk verandert
Streaming maakt het model niet sneller: het maakt het wachten draaglijk. Bij een antwoord dat vijf seconden nodig heeft om te genereren, staart een gebruiker zonder streaming vijf seconden naar een leeg scherm voordat er een blok tekst verschijnt. Met streaming ziet de gebruiker na een paar honderd milliseconden de eerste woorden en leest mee terwijl het model schrijft. De totale duur is identiek, maar de perceptie is volledig anders. Daarom is het overslaan van streaming in productie bijna altijd een ontwerpfout in plaats van een bewuste keuze.
De stream moet echter door uw volledige keten stromen. Een stream die correct door de API wordt gegenereerd, maar door uw applicatieserver wordt verzameld of door uw reverse proxy wordt gebufferd, komt bij de gebruiker aan als één enkel blok: u heeft de complexiteitsprijs voor streaming betaald zonder de voordelen te plukken. Deze les volgt daarom het volledige pad, van de API-aanroep tot in de browser.
De stream aan de clientkant consumeren
Met de Responses API verandert het instellen van stream=True het antwoord in een reeks getypte gebeurtenissen waar u doorheen iterereert terwijl ze binnenkomen. Elk tekstfragment arriveert in een response.output_text.delta-gebeurtenis; het einde van de stream wordt gesignaleerd door response.completed, dat het volledige antwoordobject bevat, handig voor het ophalen van het tokengebruik.
import openai
client = openai.OpenAI()
def generate_streaming(prompt: str):
"""Streaming-generatie met de 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() # Nieuwe regel aan het einde
return event.response
De vlag flush=True is niet cosmetisch: zonder deze buffert Python de uitvoer zelf, en eindigt u met het blokgedrag dat u probeerde te vermijden. Dit detail herhaalt zich op elke laag van de keten en vormt de grootste uitdaging bij streaming.
Het mechanisme dekt ook functies aanroepen. Tool-argumenten worden progressief opgebouwd en u kunt ze tonen terwijl ze worden gegenereerd om de gebruiker te signaleren dat er een zoekopdracht wordt geformuleerd, in plaats van hen te laten staren naar een bevroren interface terwijl het model zijn aanroep voorbereidt.
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":
# Functieargumenten die momenteel worden gegenereerd
print(f"[arg: {event.delta}]", end="")
case "response.function_call_arguments.done":
print(f"\n[Functieaanroep voltooid]")
De stream doorsturen naar de browser
Uw frontend communiceert niet direct met de OpenAI API; het communiceert met uw server, die de stream dus moet doorsturen. Server-Sent Events (SSE) zijn het natuurlijke formaat hiervoor: een HTTP-antwoord dat open blijft, waarbij elke data:-regel een JSON-fragment bevat. Het volgende voorbeeld stuurt tekst door terwijl deze binnenkomt en zendt vervolgens een laatste bericht uit met het aantal tokens, zodat u kunt factureren of loggen zonder een tweede aanroep.
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", # Belangrijk voor nginx
},
)
Dan is er de reverse proxy, de gebruikelijke verdachte wanneer “streaming niet werkt in productie, hoewel het lokaal wel werkte”. Standaard accumuleert nginx het backend-antwoord voordat het wordt verzonden. De onderstaande configuratie schakelt dit gedrag uit, maar alleen voor het specifieke pad.
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;
}
De verbinding in stand houden na verloop van tijd
Een stream die tientallen seconden open staat, is kwetsbaarder dan een korte aanroep: een netwerkstoring, een quotumoverschrijding en de generatie stopt midden in een zin. Uw retry-strategie moet onderscheid maken tussen deze twee gevallen, omdat ze verschillende benaderingen vereisen. Een verbindingsfout moet opnieuw worden geprobeerd met exponentiële backoff, zodat het netwerk de tijd krijgt om te herstellen zonder de API te overladen; een quotumoverschrijding moet opnieuw worden geprobeerd na een vaste wachttijd, aangezien het tarieflimietvenster met regelmatige tussenpozen wordt gereset.
import openai
def resilient_streaming(prompt: str, max_attempts: int = 3):
"""Streaming met foutafhandeling en retry."""
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 # Succes, afsluiten
except openai.APIConnectionError:
if attempt < max_attempts - 1:
import time
time.sleep(2 ** attempt) # Exponentiële backoff
else:
raise
except openai.RateLimitError:
import time
time.sleep(5) # Vaste wachttijd voor tarieflimiet
Een laatste aanpassing verbetert het leescomfort. Het uitzenden van elk token produceert schokkerige tekst, vooral als uw interface een animatie toepast of als het resultaat naar tekst-naar-spraak gaat. Accumuleren tot het einde van een zin geeft een ritme dat dichter bij menselijk lezen ligt, ten koste van een lichte extra vertraging bij het eerste fragment.
def streaming_by_sentence(prompt: str):
"""Accumuleert en yieldt per volledige zin."""
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
# Zoek naar einde van zin
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()
Let op de laatste if buffer.strip(): zonder dit zou een antwoord dat niet eindigt met sterke leestekens zijn laatste woorden verliezen. Dit soort over het hoofd geziene fouten blijft onopgemerkt tijdens het testen en manifesteert zich in productie bij antwoorden die worden afgekapt door max_output_tokens.
Belangrijkste punten
- Gebruik in productie altijd streaming om de waargenomen latentie te verminderen
- Configureer nginx met
proxy_buffering offvoor SSE - Handel fouten af met retry en exponentiële backoff
- Accumuleer per zin voor een natuurlijker beeld