Streaming: antwoorden in realtime ontvangen
Op deze pagina
Streaming: antwoorden in realtime ontvangen
Met streaming ontvangt u het antwoord token voor token, in plaats van te wachten tot de volledige generatie is voltooid. Dit is niet slechts een cosmetische verbetering van de gebruikersinterface: het is het verschil tussen een chatbot die traag aanvoelt en een die vlot reageert, zelfs als de serverprestaties identiek zijn.
Waarom streamen?
Zonder streaming staren gebruikers soms tien tot dertig seconden naar een leeg scherm voordat het volledige antwoord in één keer verschijnt. Met streaming verschijnen de eerste woorden binnen een seconde en begint de lezing terwijl de generatie doorgaat. De totale duur is hetzelfde; de perceptie niet. Het inschakelen vereist slechts één parameter, stream=True, waarmee de retourwaarde van create() wordt omgezet in een event-iterator.
from openai import OpenAI
client = OpenAI()
# ZONDER streaming — wacht op alles
response = client.responses.create(
model="gpt-5.6-terra",
input="Write a paragraph about artificial intelligence."
)
print(response.output_text) # Verschijnt in één keer na het wachten
# MET streaming — token voor 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() # Nieuwe regel aan het einde
Getypte events, geen ongeordende stream
De stream bevat niet alleen tekst. U krijgt een melding wanneer het antwoord wordt gemaakt, wanneer elk uitvoeritem wordt toegevoegd, wanneer fragmenten binnenkomen en wanneer de voltooiing plaatsvindt; het laatste event bevat gebruiksstatistieken. U filtert op event.type om te weten wat u verwerkt. Deze structuur stelt u bijvoorbeeld in staat om direct een laadindicator weer te geven zodra response.created wordt geactiveerd en aan het einde tokens te tellen zonder een tweede API-aanroep.
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
In een echte toepassing wilt u bijna altijd twee dingen tegelijk doen: de fragmenten weergeven en de volledige tekst reconstrueren, zodat u deze kunt archiveren of teruggeven aan de aanroeper. De regel is eenvoudig: verzamel tijdens het itereren, want zodra de stream is verbruikt, kan deze niet worden teruggespoeld.
def stream_and_collect(prompt: str) -> str:
"""Stream het antwoord terwijl u het verzamelt."""
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() # Nieuwe regel
return full_text
result = stream_and_collect("List 3 European capitals.")
print(f"\nCollected text ({len(result)} characters)")
Streaming en functieaanroepen
Functieaanroepen worden ook gestreamd, met hun eigen events: argumenten komen in fragmenten binnen via response.function_call_arguments.delta, en response.function_call_arguments.done geeft aan dat de JSON voltooid is. Dit heeft een belangrijke praktische consequentie: probeer de argumenten nooit te deserialiseren voordat het done-event plaatsvindt, anders heeft u slechts afgekapt 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]
Het asynchrone geval
Zodra uw toepassing meerdere gebruikers gelijktijdig bedient, schakelt u over op AsyncOpenAI: de synchrone client zou de event-loop blokkeren voor de volledige generatie, waardoor uw andere verzoeken moeten wachten. De syntaxis verschilt slechts met twee trefwoorden: await bij het aanmaken en async for bij het itereren.
from openai import AsyncOpenAI
import asyncio
async_client = AsyncOpenAI()
async def stream_async(prompt: str):
"""Asynchroon streamen van het antwoord."""
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."))
Op het web is streaming nutteloos als het stopt bij uw server: u moet het uitbreiden naar de browser. FastAPI maakt dit mogelijk met StreamingResponse, gevoed door een generator die fragmenten doorgeeft zodra ze binnenkomen.
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")
Fouten tijdens het streamen
Eén detail verdient uw aandacht: bij streaming kan er een fout optreden nadat fragmenten al zijn weergegeven. De gebruiker ziet dan een antwoord dat begint maar wordt afgebroken. Omhul daarom de iteratie zelf, niet alleen het aanmaken van de stream, zodat u de onderbreking netjes kunt signaleren in plaats van een zin in de lucht te laten hangen.
from openai import APIError
def stream_with_errors(prompt: str):
"""Streamen met robuuste foutafhandeling."""
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.")
Belangrijkste punten
- Schakel streaming in met
stream=Truevoor een realtime-ervaring - Filter events op
event.typeom elk gegevenstype correct te verwerken response.output_text.deltabevat tekstfragmentenresponse.completedsignaleert het einde en bevat gebruiksstatistieken- Gebruik
AsyncOpenAIvoor streaming in asynchrone toepassingen - Handel fouten altijd af, zelfs in de stream-modus