Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Streaming SSE

Les 5 van 16 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Real-time antwoorden met Server-Sent Events
  2. Streaming versus niet-streaming
  3. Het SSE-protocol in detail
  4. Streaming inschakelen in Python
  5. Structuur van een chunk
  6. Het volledige antwoord reconstrueren
  7. Wanneer streaming gebruiken
  8. Belangrijkste punten

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 caseAanbeveling
Interactieve chatbotStreaming (betere UX)
BatchverwerkingNiet-streaming (eenvoudiger)
Backend-API voor frontendStreaming (SSE naar browser)
Data-pipelineNiet-streaming (atomische verwerking)
Gestructureerde extractieNiet-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.content in plaats van message.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