Streaming SSE
På denne side
Svar i realtid med Server-Sent Events
Som standard venter Chat Completions API’et, indtil modellen har genereret hele sit svar, før det sender det tilbage til dig. Ved et kort spørgsmål lægger ingen mærke til forsinkelsen. Ved en rapport på tusind ord betyder det dog flere sekunders blank skærm, hvilket får din bruger til at undre sig over, om applikationen er gået ned. Streaming løser dette problem ved at sende tokens, efterhånden som de genereres, hvilket skaber den velkendte skrivemaskine-effekt, som ses i samtalegrænseflader.
Protokollen, der bruges, er Server-Sent Events (SSE), en HTTP-standard, der giver serveren mulighed for at skubbe data til klienten kontinuerligt over en vedvarende forbindelse. Der er intet eksotisk her: ingen WebSockets, der skal installeres, ingen ekstra afhængigheder.
Streaming kontra ikke-streaming
I ikke-streaming-tilstand, som er standarden, sender klienten anmodningen og venter på det komplette svar:
Client ──── request ────► Server
(wait 3-10s)
Client ◄── complete response ── Server
Fordelen er enkelhed: svaret er atomart, et enkelt JSON-objekt, der er let at behandle, validere og gemme. Ulempen er lige så tydelig: den oplevede ventetid er høj, fordi brugeren ikke ser noget under hele genereringsprocessen.
I streaming-tilstand sender serveren tokens ét ad gangen eller i små grupper:
Client ──── request ────► Server
Client ◄── chunk 1 ─────── Server (after ~200ms)
Client ◄── chunk 2 ─────── Server (after ~250ms)
Client ◄── chunk 3 ─────── Server (after ~300ms)
...
Client ◄── [DONE] ──────── Server
Den oplevede ventetid falder drastisk – det første tegn vises inden for få hundrede millisekunder – hvilket forbedrer brugeroplevelsen markant. Til gengæld skal du rekonstruere beskeden på klientsiden og håndtere tilstand, der ikke længere ankommer som én enkelt blok.
SSE-protokollen i detaljer
Sådan ser HTTP-strømmen, du modtager, faktisk ud:
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]
Hver linje starter med data: efterfulgt af et JSON-objekt, og tomme linjer fungerer som separatorer mellem begivenheder. Bemærk detaljen, der fanger alle ved deres første implementering: tekstfragmentet befinder sig i feltet delta, ikke i message som i klassisk tilstand. Strømmen slutter med en data: [DONE]-begivenhed, der eksplicit signalerer afslutningen. Uden den ville du ikke kunne skelne en afsluttet generering fra en afbrudt forbindelse.
Aktiver streaming i Python
Med Mistral SDK aktiverer du streaming ved at kalde chat.stream() i stedet for 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
Argumentet flush=True fortjener en forklaring, da det at glemme det er den klassiske årsag til streaming, der „ikke virker”. Uden det holder Python tegn i bufferen og viser dem i blokke. Dette annullerer visuelt alle fordelene ved streaming, selvom chunksene ankommer korrekt.
Struktur af en chunk
En streaming-chunk læses ikke som et komplet svar, og adgangsstierne er forskellige:
# 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"
Den første chunk indeholder normalt rollen uden tekst, de efterfølgende indeholder fragmenter, og den sidste giver finish_reason. Derfor er if content:-tjekket i den tidligere kode ikke en unødvendig forholdsregel: sammenkædning af en None-værdi ville få løkken til at fejle i første iteration.
Rekonstruer det komplette svar
Det er ikke nok at vise fragmenter, når du har brug for at beholde svaret – for eksempel for at føje det til samtalehistorikken, logge det eller gemme det i en database. Du skal derfor akkumulere teksten parallelt med at vise den:
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)")
Variablen finish_reason fanges i samme løkke af samme årsag som i klassisk tilstand: et svar, der er trunkeret af max_tokens, vises på skærmen præcis som et komplet svar, og kun dette felt vil fortælle dig forskellen.
Hvornår skal du bruge streaming?
Streaming er ikke altid bedre. Det er indiceret, når et menneske kigger på skærmen, men overflødigt eller endda skadeligt, når en maskine behandler outputtet.
| Use case | Recommendation |
|---|---|
| Interactive chatbot | Streaming (better UX) |
| Batch processing | Non-streaming (simpler) |
| Backend API for frontend | Streaming (SSE to browser) |
| Data pipeline | Non-streaming (atomic processing) |
| Structured extraction | Non-streaming (more reliable JSON parsing) |
Det sidste tilfælde er det mest lærerige. Hvis du forventer JSON, tilføjer streaming intet: du kan ikke parse et ufuldstændigt objekt, og du bliver alligevel nødt til at vente på det sidste fragment. Du kan lige så godt beholde kaldet atomart og koden enkel.
Vigtige pointer
- Streaming reducerer den oplevede ventetid ved at sende tokens, efterhånden som de genereres
- SSE-protokollen er en simpel og robust HTTP-standard
- I streaming-tilstand skal du bruge
delta.contenti stedet formessage.content - Akkumulér fragmenter på klientsiden for at rekonstruere det komplette svar
- Foretræk streaming til brugergrænseflader og ikke-streaming til automatiseret behandling