Strömning optimerad
På denna sida
Vad strömning faktiskt ändrar
Strömning gör inte modellen snabbare: den gör väntan uthärdlig. För ett svar som tar fem sekunder att generera, stirrar en användare utan strömning på en tom skärm i fem sekunder innan hen får ett textblock. Med strömning ser hen de första orden efter några hundra millisekunder och läser medan modellen skriver. Den totala varaktigheten är identisk, men upplevelsen är helt annorlunda. Därför är det nästan alltid ett designfel att utelämna strömning i produktion, snarare än ett medvetet val.
Strömmen måste dock flyta genom hela din kedja. En ström som genereras korrekt av API:t men ackumuleras av din applikationsserver eller buffras av din reverse proxy når användaren som ett enda block: du har betalat komplexitetspriset för strömning utan att skörda fördelarna. Denna lektion följer därför hela vägen, från API-anropet till webbläsaren.
Konsumera strömmen på klientsidan
Med Responses API:t omvandlar inställningen stream=True svaret till en sekvens av typade händelser som du itererar över när de anländer. Varje textfragment anländer i en händelse response.output_text.delta; slutet på strömmen signaleras av response.completed, som bär på hela svarsobjektet, vilket är användbart för att hämta tokenanvändning.
import openai
client = openai.OpenAI()
def generate_streaming(prompt: str):
"""Strömmande generering med Responses API:t."""
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 rad på slutet
return event.response
Flaggan flush=True är inte kosmetisk: utan den buffrar Python utmatningen själv, och du hamnar med blockbeteendet du försökte undvika. Denna detalj upprepas på varje lager i kedjan, och det är huvudsvårigheten med strömning.
Mekanismen täcker även funktionsanrop. Argument för verktyg byggs progressivt, och du kan visa dem medan de genereras för att signalera till användaren att en sökning formuleras, istället för att låta hen stirra på ett fruset gränssnitt medan modellen förbereder sitt anrop.
tools = [
{
"type": "function",
"name": "search_product",
"description": "Söker efter en produkt i katalogen.",
"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":
# Funktionsargument som genereras just nu
print(f"[arg: {event.delta}]", end="")
case "response.function_call_arguments.done":
print(f"\n[Funktionsanrop slutfört]")
Vidarebefordra strömmen till webbläsaren
Din frontend pratar inte direkt med OpenAI:s API – den pratar med din server, som därför måste vidarebefordra strömmen. Server-Sent Events (SSE) är det naturliga formatet för detta: ett HTTP-svar som hålls öppet, där varje rad data: bär på ett JSON-fragment. Följande exempel vidarebefordrar text när den anländer och skickar sedan ett slutmeddelande som innehåller tokenantallet, vilket låter dig fakturera eller logga utan ett andra anrop.
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", # Viktigt för nginx
},
)
Sedan har vi reverse-proxyn, den vanliga boven när “strömning inte fungerar i produktion även om det fungerade lokalt”. Som standard ackumulerar nginx backend-svaret innan det skickas vidare. Konfigurationen nedan inaktiverar detta beteende endast för den specifika routen.
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;
}
Upprätthålla anslutningen över tid
En ström som är öppen i flera tiotals sekunder är mer utsatt än ett kort anrop: ett nätverksavbrott, en kvotöverskridning, och genereringen stoppar mitt i en mening. Din strategi för återförsök måste skilja mellan dessa två fall, eftersom de kräver olika tillvägagångssätt. Ett anslutningsfel bör försökas igen med exponentiell backoff, vilket ger nätverket tid att återhämta sig utan att hamra mot API:t; en kvotöverskridning bör försökas igen efter en fast väntetid, eftersom tidsfönstret för hastighetsbegränsning återställs med jämna mellanrum.
import openai
def resilient_streaming(prompt: str, max_attempts: int = 3):
"""Strömning med felhantering och återförsök."""
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 # Lyckades, avsluta
except openai.APIConnectionError:
if attempt < max_attempts - 1:
import time
time.sleep(2 ** attempt) # Exponentiell backoff
else:
raise
except openai.RateLimitError:
import time
time.sleep(5) # Fast väntetid för hastighetsbegränsning
En sista finjustering förbättrar läskomforten. Att skicka varje token ger hackig text, särskilt om ditt gränssnitt applicerar en animation eller om resultatet går till text-till-tal. Att ackumulera upp till slutet av en mening ger en rytm närmare mänsklig läsning, till priset av en liten ytterligare fördröjning på det första fragmentet.
def streaming_by_sentence(prompt: str):
"""Ackumulerar och skickar per hel mening."""
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
# Leta efter slutet på en mening
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()
Notera det sista if buffer.strip(): utan det skulle ett svar som inte slutar med stark interpunktion förlora sina sista ord. Denna typ av förbiseende går obemärkt förbi vid testning och visar sig i produktion på svar som trunkerats av max_output_tokens.
Viktiga punkter
- Använd alltid strömning i produktion för att minska den upplevda latensen
- Konfigurera nginx med
proxy_buffering offför SSE - Hantera fel med återförsök och exponentiell backoff
- Ackumulera per mening för en mer naturlig visning