Streaming SSE
Op deze pagina
Real-time antwoorden met Server-Sent Events
Standaard wacht de Chat Completions API tot het model zijn volledige antwoord heeft gegenereerd voordat het dit naar u terugstuurt. Bij een korte vraag merkt niemand het verschil. Bij een rapport van duizend woorden betekent dit echter enkele seconden een leeg scherm, waardoor uw gebruiker zich afvraagt of de applicatie is vastgelopen. Streaming lost dit probleem op door tokens te verzenden zodra ze worden gegenereerd, wat het vertrouwde schrijfmachine-effect creëert dat u kent van conversatie-interfaces.
Het gebruikte protocol is Server-Sent Events (SSE), een HTTP-standaard waarmee de server continu gegevens naar de client kan pushen via een persistente verbinding. Er is niets exotisch aan: geen WebSockets om te installeren, geen extra afhankelijkheden.
Streaming versus niet-streaming
In de niet-streaming modus, wat de standaard is, stuurt de client het verzoek en wacht op het volledige antwoord:
Client ──── request ────► Server
(wait 3-10s)
Client ◄── complete response ── Server
Het voordeel is eenvoud: het antwoord is atomair, een enkel JSON-object dat eenvoudig te verwerken, valideren en opslaan is. Het nadeel is even duidelijk: de waargenomen latentie is hoog omdat de gebruiker tijdens het hele generatieproces niets ziet.
In de streaming modus stuurt de server tokens één voor één, of in kleine groepen:
Client ──── request ────► Server
Client ◄── chunk 1 ─────── Server (after ~200ms)
Client ◄── chunk 2 ─────── Server (after ~250ms)
Client ◄── chunk 3 ─────── Server (after ~300ms)
...
Client ◄── [DONE] ──────── Server
De waargenomen latentie daalt drastisch: het eerste teken verschijnt binnen een paar honderd milliseconden, wat de gebruikerservaring aanzienlijk verbetert. Als tegenprestatie moet u het bericht aan de clientzijde reconstrueren en de status beheren, die niet langer als één blok binnenkomt.
Het SSE-protocol in detail
Dit is hoe de HTTP-stream die u ontvangt er daadwerkelijk uitziet:
data: {"id":"cmpl-abc","choices":[{"delta":{"content":"Hello"}}],"usage":null}
data: {"id":"cmpl-abc","choices":[{"delta":{"content":" "}}],"usage":null}
data: {"id":"cmpl-abc","choices":[{"delta":{"content":"!"}}],"usage":null}
data: [DONE]
Elke regel begint met data: gevolgd door een JSON-object, en lege regels dienen als scheidingsteken tussen gebeurtenissen. Let op het detail waarin iedereen bij de eerste implementatie vastloopt: het tekstfragment bevindt zich in het veld delta, niet in message zoals in de klassieke modus. De stream eindigt met een data: [DONE]-gebeurtenis, wat expliciet het einde signaleert. Zonder dit zou u geen onderscheid kunnen maken tussen een voltooide generatie en een onderbroken verbinding.
Streaming inschakelen in Python
Met de Mistral SDK schakelt u streaming in door chat.stream() aan te roepen in plaats van chat.complete():
from mistralai.client import Mistral
import os
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
stream = client.chat.stream(
model="mistral-large-latest",
messages=[
{"role": "user", "content": "Explain how an electric motor works."}
]
)
for chunk in stream:
content = chunk.data.choices[0].delta.content
if content:
print(content, end="", flush=True)
print() # Final newline
Het argument flush=True verdient uitleg, want het vergeten ervan is de klassieke oorzaak van streaming die “niet werkt”. Zonder dit houdt Python tekens in de buffer en toont ze in blokken. Dit tenietdoet visueel alle voordelen van streaming, ook al komen de chunks correct binnen.
Structuur van een chunk
Een streaming-chunk leest niet als een volledig antwoord en de toegangspaden verschillen:
# Non-streaming: response.choices[0].message.content
# Streaming: chunk.data.choices[0].delta.content
# The first chunk often contains the role
# chunk.data.choices[0].delta.role == "assistant"
# Subsequent chunks contain text fragments
# chunk.data.choices[0].delta.content == "Hello"
# The last chunk contains finish_reason
# chunk.data.choices[0].finish_reason == "stop"
De eerste chunk bevat meestal de rol zonder tekst, de volgende bevatten tekstfragmenten en de laatste levert de finish_reason. Dit is waarom de if content:-controle in de vorige code geen overbodige voorzorgsmaatregel is: het samenvoegen van een None-waarde zou de lus bij de eerste iteratie laten mislukken.
Het volledige antwoord reconstrueren
Fragmenten weergeven is niet voldoende wanneer u het antwoord moet bewaren, bijvoorbeeld om het toe te voegen aan de conversatiegeschiedenis, te loggen of in een database op te slaan. U moet de tekst daarom parallel aan de weergave accumuleren:
from mistralai.client import Mistral
import os
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
stream = client.chat.stream(
model="mistral-large-latest",
messages=[{"role": "user", "content": "List 5 programming languages."}]
)
full_response = ""
finish_reason = None
for chunk in stream:
delta = chunk.data.choices[0].delta
if delta.content:
full_response += delta.content
print(delta.content, end="", flush=True)
if chunk.data.choices[0].finish_reason:
finish_reason = chunk.data.choices[0].finish_reason
print(f"\n\nFinish reason: {finish_reason}")
print(f"Complete response ({len(full_response)} characters)")
De variabele finish_reason wordt in dezelfde lus vastgelegd om dezelfde reden als in de klassieke modus: een antwoord dat wordt afgekapt door max_tokens ziet er op het scherm precies hetzelfde uit als een volledig antwoord, en alleen dit veld vertelt u het verschil.
Wanneer streaming gebruiken
Streaming is niet altijd beter. Het is aangewezen wanneer een mens naar het scherm kijkt, maar overbodig of zelfs schadelijk wanneer een machine de uitvoer verwerkt.
| Use case | Aanbeveling |
|---|---|
| Interactieve chatbot | Streaming (betere UX) |
| Batchverwerking | Niet-streaming (eenvoudiger) |
| Backend-API voor frontend | Streaming (SSE naar browser) |
| Data-pipeline | Niet-streaming (atomische verwerking) |
| Gestructureerde extractie | Niet-streaming (betrouwbaardere JSON-parsing) |
Het laatste geval is het meest instructief. Als u JSON verwacht, voegt streaming niets toe: u kunt een onvolledig object niet parseren en u moet toch wachten op het laatste fragment. U kunt de call net zo goed atomair houden en de code eenvoudig houden.
Belangrijkste punten
- Streaming vermindert de waargenomen latentie door tokens te verzenden zodra ze worden gegenereerd
- Het SSE-protocol is een eenvoudige en robuuste HTTP-standaard
- Gebruik in de streaming modus
delta.contentin plaats vanmessage.content - Accumuleer fragmenten aan de clientzijde om het volledige antwoord te reconstrueren
- Geef de voorkeur aan streaming voor gebruikersinterfaces en aan niet-streaming voor geautomatiseerde verwerking