Optimeret streaming
På denne side
Hvad streaming faktisk ændrer
Streaming gør ikke modellen hurtigere: det gør ventetiden udholdelig. Uden streaming stirrer brugeren på en tom skærm i fem sekunder, før de modtager en tekstblok, hvis svaret tager fem sekunder at generere. Med streaming ser de de første ord efter få hundrede millisekunder og læser med, mens modellen skriver. Den samlede varighed er identisk, men oplevelsen er fuldstændig anderledes. Derfor er det næsten altid en designfejl at udelade streaming i produktion frem for et bevidst valg.
Strømmen skal dog løbe gennem hele din kæde. En stream, der genereres korrekt af API’et, men akkumuleres af din applikationsserver eller buffres af din reverse proxy, når brugeren som én enkelt blok: du har betalt prisen for streamingens kompleksitet uden at høste fordelene. Denne lektion følger derfor den komplette vej, fra API-kaldet til browseren.
Forbrug af streamen på klientsiden
Med Responses API transformerer indstillingen stream=True svaret til en sekvens af typede begivenheder, som du itererer gennem, efterhånden som de ankommer. Hvert tekstfragment ankommer i en response.output_text.delta-begivenhed; slutningen af streamen signaleres af response.completed, som indeholder det fulde svarobjekt, nyttigt til at hente token-forbrug.
import openai
client = openai.OpenAI()
def generate_streaming(prompt: str):
"""Streaming-generering med 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() # Ny linje til sidst
return event.response
Flaget flush=True er ikke kosmetisk: uden det buffrer Python selv outputtet, og du ender med den blok-adfærd, du forsøgte at undgå. Denne detalje gentages på hvert lag i kæden, og det er hovedudfordringen ved streaming.
Mekanismen dækker også funktionskald. Værktøjsargumenter opbygges gradvist, og du kan vise dem, efterhånden som de genereres, for at signalere til brugeren, at en søgning er under udarbejdelse, i stedet for at lade dem stirre på en frossen grænseflade, mens modellen forbereder sit kald.
tools = [
{
"type": "function",
"name": "search_product",
"description": "Søger efter et produkt i kataloget.",
"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":
# Funktionsargumenter, der genereres lige nu
print(f"[arg: {event.delta}]", end="")
case "response.function_call_arguments.done":
print(f"\n[Funktionskald fuldført]")
Videresendelse af streamen til browseren
Din frontend taler ikke direkte med OpenAI API – den taler med din server, som derfor skal videresende streamen. Server-Sent Events (SSE) er det naturlige format til dette: et HTTP-svar, der holdes åbent, hvor hver data:-linje bærer et JSON-fragment. Eksemplet nedenfor videresender tekst, efterhånden som den ankommer, og udsender derefter en endelig besked, der indeholder antallet af tokens, så du kan fakturere eller logge uden et ekstra kald.
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", # Vigtigt for nginx
},
)
Så er der reverse proxyen, den sædvanlige mistænkte, når „streaming ikke virker i produktion, selvom det virkede lokalt”. Som standard akkumulerer nginx backend-svaret, før det transmitteres. Konfigurationen nedenfor deaktiverer denne adfærd kun for den specifikke rute.
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;
}
Opretholdelse af forbindelsen over tid
En stream, der er åben i flere titusinder af sekunder, er mere udsat end et kort kald: et netværksudfald, en kvoteoverskridelse, og genereringen stopper midt i en sætning. Din genforsøgsstrategi skal skelne mellem disse to tilfælde, da de kræver forskellige tilgange. En forbindelsesfejl bør genforsøges med eksponentiel backoff, hvilket giver netværket tid til at komme sig uden at hamre på API’et; en kvoteoverskridelse bør genforsøges efter en fast ventetid, da vinduet for hastighedsbegrænsning nulstilles med jævne mellemrum.
import openai
def resilient_streaming(prompt: str, max_attempts: int = 3):
"""Streaming med fejlhåndtering og genforsøg."""
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, afslut
except openai.APIConnectionError:
if attempt < max_attempts - 1:
import time
time.sleep(2 ** attempt) # Eksponentiel backoff
else:
raise
except openai.RateLimitError:
import time
time.sleep(5) # Fast ventetid for hastighedsbegrænsning
Én sidste justering forbedrer læsekomforten. Udsendelse af hvert enkelt token producerer hakket tekst, især hvis din grænseflade anvender en animation, eller hvis resultatet går til tekst-til-tale. Akkumulering op til slutningen af en sætning giver en rytme, der ligner menneskelig læsning, på bekostning af en lille ekstra forsinkelse på det første fragment.
def streaming_by_sentence(prompt: str):
"""Akkumulerer og udsender pr. komplet sætning."""
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
# Kig efter slutningen af en sætning
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()
Bemærk det sidste if buffer.strip(): uden det ville et svar, der ikke slutter med stærk tegnsætning, miste sine sidste ord. Denne type overset bemærkes ikke under test og manifesterer sig i produktion på svar, der er trunkerede af max_output_tokens.
Vigtige pointer
- Brug altid streaming i produktion for at reducere den oplevede latenstid
- Konfigurer nginx med
proxy_buffering offtil SSE - Håndtér fejl med genforsøg og eksponentiel backoff
- Akkumulér pr. sætning for en mere naturlig visning