Streaming: Modtag svar i realtid
På denne side
Streaming: Modtag svar i realtid
Streaming giver dig mulighed for at modtage svaret token for token i stedet for at vente på, at hele genereringen er færdig. Dette er ikke blot en kosmetisk forbedring af brugergrænsefladen: Det er netop det, der adskiller en chatbot, der føles tung, fra en, der føles kvik, selv når serverens ydeevne er identisk.
Hvorfor bruge streaming
Uden streaming står brugeren nogle gange og stirrer på en tom skærm i ti til tredive sekunder, før hele svaret dukker op på én gang. Med streaming vises de første ord på under et sekund, og læsningen begynder, mens genereringen fortsætter. Den samlede varighed er den samme; oplevelsen er det ikke. Aktivering kræver blot én parameter, stream=True, som omdanner returvärdien fra create() til en event-iterator.
from openai import OpenAI
client = OpenAI()
# UDEN streaming — vent på alt
response = client.responses.create(
model="gpt-5.6-terra",
input="Write a paragraph about artificial intelligence."
)
print(response.output_text) # Vises på én gang efter ventetiden
# MED streaming — token for 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() # Nyt linjeskift til sidst
Typede events, ikke en udifferentieret strøm
Strømmen indeholder ikke kun tekst. Den giver dig besked, når svaret oprettes, når hvert output-element tilføjes, når fragmenter ankommer, og når processen er afsluttet – den sidste event indeholder brugsstatistik. Du filtrerer på event.type for at vide, hvad du håndterer. Denne struktur gør det muligt for dig at vise f.eks. en indlæsningsindikator, så snart response.created udløses, og optælle tokens til sidst uden et ekstra API-kald.
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"[Response created] ID: {event.response.id}")
case "response.output_item.added":
print(f"[New output item]")
case "response.output_text.delta":
print(f"[Text] {event.delta}", end="")
case "response.output_text.done":
print(f"\n[Text complete]")
case "response.completed":
print(f"[Done] Tokens: {event.response.usage.total_tokens}")
# Output:
# [Response created] ID: resp_abc123
# [New output item]
# [Text] Hello[Text] ! [Text] How[Text] can[Text] I...
# [Text complete]
# [Done] Tokens: 25
I en rigtig applikation vil du næsten altid skulle gøre to ting på én gang: vise fragmenterne og genopbygge den fulde tekst, så du kan arkivere den eller returnere den til kaldende. Reglen er simpel: Akkumulér, mens du itererer, for når strømmen er brugt, kan den ikke spoles tilbage.
def stream_and_collect(prompt: str) -> str:
"""Stream svaret mens det indsamles."""
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() # Nyt linjeskift
return full_text
result = stream_and_collect("List 3 European capitals.")
print(f"\nCollected text ({len(result)} characters)")
Streaming og funktionskald
Funktionskald streames også med deres egne events: argumenter ankommer i fragmenter via response.function_call_arguments.delta, og response.function_call_arguments.done signalerer, at JSON’en er komplet. Dette har en vigtig praktisk konsekvens: Forsøg aldrig at deserialisere argumenterne før done-eventen, ellers har du kun en afkortet 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"[Args] {event.delta}", end="")
case "response.function_call_arguments.done":
print(f"\n[Function call complete]")
# Output:
# [Args] {"city": "Tokyo"}
# [Function call complete]
Det asynkrone tilfælde
Så snart din applikation betjener flere brugere samtidigt, skal du skifte til AsyncOpenAI: Den synkrone klient ville blokere event-loopen under hele genereringen, hvilket får dine andre forespørgsler til at vente. Syntaksen adskiller sig kun med to nøgleord – await ved oprettelse og async for ved iteration.
from openai import AsyncOpenAI
import asyncio
async_client = AsyncOpenAI()
async def stream_async(prompt: str):
"""Asynkron streaming af 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å webbet er streaming nytteløs, hvis den stopper ved din server: Du skal udvide den til browseren. FastAPI muliggør dette med StreamingResponse, som fodres af en generator, der videresender fragmenter, efterhånden som de ankommer.
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")
Fejl midt i strømmen
Én detalje fortjener din opmærksomhed: Ved streaming kan en fejl opstå, efter at fragmenter allerede er vist. Brugeren ser så et svar, der starter, men bliver afbrudt. Omgiv derfor selve iterationen med en try/except-blok, ikke kun oprettelsen af strømmen, så du kan signalere afbrydelsen rent i stedet for at efterlade en sætning hængende.
from openai import APIError
def stream_with_errors(prompt: str):
"""Streaming med robust fejlhåndtering."""
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 error during streaming: {e.message}")
except Exception as e:
print(f"\nUnexpected error: {e}")
stream_with_errors("Explain streaming in 2 sentences.")
Vigtige pointer
- Aktivér streaming med
stream=Truefor en oplevelse i realtid - Filtrér events efter
event.typefor at håndtere hver datatype korrekt response.output_text.deltaindeholder tekstfragmenterresponse.completedsignalerer slutningen og indeholder brugsstatistik- Brug
AsyncOpenAItil streaming i asynkrone applikationer - Håndtér altid fejl, også i streaming-tilstand