Strömning: Ta emot svar i realtid
På denna sida
Strömning: Ta emot svar i realtid
Strömning låter dig ta emot svaret token för token istället för att vänta på att hela genereringen ska bli klar. Det här är inte bara en kosmetisk detalj i gränssnittet: det är skillnaden mellan en chattbot som känns trög och en som känns snabb, även om serverprestandan är densamma.
Varför strömma
Utan strömning får användaren ibland stirra på en tom skärm i tio till trettio sekunder innan hela svaret dyker upp på en gång. Med strömning visas de första orden på under en sekund, och läsningen kan börja medan genereringen fortsätter. Den totala tiden är densamma; upplevelsen är det inte. För att aktivera det krävs bara en parameter, stream=True, vilket gör att returvärdet från create() blir en händelseiterator.
from openai import OpenAI
client = OpenAI()
# UTAN strömning — vänta på allt
response = client.responses.create(
model="gpt-5.6-terra",
input="Write a paragraph about artificial intelligence."
)
print(response.output_text) # Visas allt på en gång efter väntan
# MED strömning — token för token
stream = client.responses.create(
model="gpt-5.6-terra",
input="Write a paragraph about artificial intelligence.",
stream=True
)
for event in stream:
if event.type == "response.output_text.delta":
print(event.delta, end="", flush=True)
print() # Ny rad på slutet
Typade händelser, inte en odifferentierad ström
Strömmen innehåller inte bara text. Den notifierar dig när svaret skapas, när varje utmatningsobjekt läggs till, när fragment anländer och när genereringen är klar – den sista händelsen inkluderar användningsstatistik. Du filtrerar på event.type för att veta vad du hanterar. Denna struktur låter dig exempelvis visa en laddningsindikator så snart response.created triggar och summera tokens på slutet utan ett andra API-anrop.
stream = client.responses.create(
model="gpt-5.6-terra",
input="Hello!",
stream=True
)
for event in stream:
match event.type:
case "response.created":
print(f"[Svar skapat] ID: {event.response.id}")
case "response.output_item.added":
print(f"[Nytt utmatningsobjekt]")
case "response.output_text.delta":
print(f"[Text] {event.delta}", end="")
case "response.output_text.done":
print(f"\n[Text klar]")
case "response.completed":
print(f"[Klar] Tokens: {event.response.usage.total_tokens}")
# Utmatning:
# [Svar skapat] ID: resp_abc123
# [Nytt utmatningsobjekt]
# [Text] Hej[Text] ! [Text] Hur[Text] kan[Text] jag...
# [Text klar]
# [Klar] Tokens: 25
I en riktig applikation vill du nästan alltid göra två saker samtidigt: visa fragmenten och återskapa hela texten så att du kan arkivera den eller returnera den till anroparen. Regeln är enkel: ackumulera medan du itererar, eftersom strömmen inte kan spolas tillbaka när den väl är konsumerad.
def stream_and_collect(prompt: str) -> str:
"""Strömma svaret samtidigt som det samlas in."""
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
print(event.delta, end="", flush=True)
print() # Ny rad
return full_text
result = stream_and_collect("List 3 European capitals.")
print(f"\nInsamlad text ({len(result)} tecken)")
Strömning och funktionsanrop
Funktionsanrop strömmas också, med egna händelser: argument anländer i fragment via response.function_call_arguments.delta, och response.function_call_arguments.done signalerar att JSON:en är komplett. Detta har en viktig praktisk konsekvens – försök aldrig deserialisera argumenten före händelsen done, annars har du bara en trunkerad JSON.
stream = client.responses.create(
model="gpt-5.6-terra",
input="What time is it in Tokyo?",
tools=[{
"type": "function",
"name": "get_time",
"description": "Get the time in a city",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string"}
},
"required": ["city"]
}
}],
stream=True
)
for event in stream:
match event.type:
case "response.output_text.delta":
print(event.delta, end="")
case "response.function_call_arguments.delta":
print(f"[Arg] {event.delta}", end="")
case "response.function_call_arguments.done":
print(f"\n[Funktionsanrop klart]")
# Utmatning:
# [Arg] {"city": "Tokyo"}
# [Funktionsanrop klart]
Det asynkrona fallet
Så snart din applikation betjänar flera användare samtidigt bör du byta till AsyncOpenAI: den synkrona klienten skulle blockera händelseloopen under hela genereringen, vilket får dina andra förfrågningar att vänta. Syntaxen skiljer sig bara med två nyckelord – await vid skapandet och async for vid iterationen.
from openai import AsyncOpenAI
import asyncio
async_client = AsyncOpenAI()
async def stream_async(prompt: str):
"""Asynkron strömning av svaret."""
stream = await async_client.responses.create(
model="gpt-5.6-terra",
input=prompt,
stream=True
)
async for event in stream:
if event.type == "response.output_text.delta":
print(event.delta, end="", flush=True)
print()
asyncio.run(stream_async("Tell a short joke."))
På webben är strömning värdelös om den stannar vid din server: du måste utöka den till webbläsaren. FastAPI möjliggör detta med StreamingResponse, matad av en generator som vidarebefordrar fragment i takt med att de anländer.
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from openai import OpenAI
app = FastAPI()
client = OpenAI()
@app.get("/chat")
async def chat(question: str):
def generate():
stream = client.responses.create(
model="gpt-5.6-terra",
input=question,
stream=True
)
for event in stream:
if event.type == "response.output_text.delta":
yield event.delta
return StreamingResponse(generate(), media_type="text/plain")
Fel mitt i strömmen
En detalj förtjänar din uppmärksamhet: vid strömning kan ett fel uppstå efter att fragment redan har visats. Användaren ser då ett svar som börjar men blir avklippt. Därför bör du omsluta själva iterationen med en felhantering, inte bara skapandet av strömmen, så att du tydligt kan signalera avbrottet istället för att lämna en mening hängande.
from openai import APIError
def stream_with_errors(prompt: str):
"""Strömning med robust felhantering."""
try:
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)
print()
except APIError as e:
print(f"\nAPI-fel under strömning: {e.message}")
except Exception as e:
print(f"\nOväntat fel: {e}")
stream_with_errors("Explain streaming in 2 sentences.")
Viktiga punkter
- Aktivera strömning med
stream=Trueför en upplevelse i realtid - Filtrera händelser efter
event.typeför att hantera varje datatyp korrekt response.output_text.deltainnehåller textfragmentresponse.completedsignalerar slutet och inkluderar användningsstatistik- Använd
AsyncOpenAIför strömning i asynkrona applikationer - Hantera alltid fel, även i strömningsläge