Streaming SSE
På denna sida
Realtidssvar med Server-Sent Events
Som standard väntar Chat Completions API:t tills modellen har genererat hela sitt svar innan det skickas tillbaka till dig. För en kort fråga märker ingen fördröjningen. För en rapport på tusen ord innebär det dock flera sekunder av tom skärm, vilket får användaren att undra om applikationen har kraschat. Streaming löser detta problem genom att skicka token i takt med att de genereras, vilket skapar den välkända skrivmaskinseffekten som ses i konversationsgränssnitt.
Protokollet som används är Server-Sent Events (SSE), en HTTP-standard som låter servern pusha data till klienten kontinuerligt över en bestående anslutning. Det finns inget exotiskt här: inga WebSockets att installera, inga extra beroenden.
Streaming kontra icke-streaming
I icke-streaming-läge, vilket är standard, skickar klienten begäran och väntar på det kompletta svaret:
Client ──── request ────► Server
(wait 3-10s)
Client ◄── complete response ── Server
Fördelen är enkelheten: svaret är atomärt, ett enda JSON-objekt som är lätt att bearbeta, validera och lagra. Nackdelen är lika tydlig: den upplevda latensen är hög eftersom användaren inte ser något under hela genereringsprocessen.
I streaming-läge skickar servern token en och en, 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 upplevda latensen minskar drastiskt – den första tecknet visas inom några hundra millisekunder – vilket förbättrar användarupplevelsen avsevärt. I gengäld måste du återskapa meddelandet på klientsidan och hantera tillstånd som inte längre anländer som ett enda block.
SSE-protokollet i detalj
Så här ser HTTP-strömmen du receives faktiskt ut:
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]
Varje rad börjar med data: följt av ett JSON-objekt, och tomma rader fungerar som avgränsare mellan händelser. Lägg märke till detaljen som lurar alla vid deras första implementation: textfragmentet finns i fältet delta, inte i message som i klassiskt läge. Strömmen avslutas med en händelse data: [DONE], vilket explicit signalerar slutet. Utan den skulle du inte kunna skilja en avslutad generering från en avbruten anslutning.
Aktivera streaming i Python
Med Mistral SDK aktiverar du streaming genom att anropa chat.stream() istället för 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 förtjänar en förklaring, eftersom att glömma det är den klassiska orsaken till att streaming “inte fungerar”. Utan det håller Python tecknen i bufferten och visar dem i block. Detta tar visuellt ut alla fördelar med streaming, även om chunken anländer korrekt.
Struktur för en chunk
En streaming-chunk läses inte som ett komplett svar, och sökvägarna skiljer sig åt:
# 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örsta chunken innehåller oftast rollen utan text, efterföljande innehåller fragment, och den sista ger finish_reason. Det är därför kontrollen if content: i koden ovan inte är en onödig försiktighetsåtgärd: att konkatenera ett None-värde skulle få loopen att misslyckas vid första iterationen.
Återskapa det kompletta svaret
Att visa fragment räcker inte när du behöver behålla svaret – till exempel för att lägga till det i konversationshistoriken, logga det eller lagra det i en databas. Du måste därför ackumulera texten parallellt med att du visar 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)")
Variabeln finish_reason fångas i samma loop av samma anledning som i klassiskt läge: ett svar som trunkerats av max_tokens visas på skärmen exakt som ett komplett svar, och endast detta fält kommer att berätta skillnaden.
När ska du använda streaming?
Streaming är inte alltid bättre. Det är indicerat när en människa tittar på skärmen, men överflödigt eller till och med skadligt när en maskin bearbetar utdata.
| Användningsfall | Rekommendation |
|---|---|
| Interaktiv chattbot | Streaming (bättre UX) |
| Batch-bearbetning | Icke-streaming (enklare) |
| Backend-API för frontend | Streaming (SSE till webbläsare) |
| Datapipeline | Icke-streaming (atomär bearbetning) |
| Strukturerad extraktion | Icke-streaming (mer tillförlitlig JSON-parsning) |
Det sista fallet är det mest instruktiva. Om du förväntar dig JSON tillför streaming ingenting: du kan inte parsa ett ofullständigt objekt, och du kommer ändå att behöva vänta på det sista fragmentet. Du kan lika gärna behålla anropet atomärt och koden enkel.
Viktiga punkter
- Streaming minskar den upplevda latensen genom att skicka token i takt med att de genereras
- SSE-protokollet är en enkel och robust HTTP-standard
- I streaming-läge använder du
delta.contentistället förmessage.content - Ackumulera fragment på klientsidan för att återskapa det kompletta svaret
- Föredra streaming för användargränssnitt och icke-streaming för automatiserad bearbetning