Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Streaming SSE

Lektion 5 av 16 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Realtidssvar med Server-Sent Events
  2. Streaming kontra icke-streaming
  3. SSE-protokollet i detalj
  4. Aktivera streaming i Python
  5. Struktur för en chunk
  6. Återskapa det kompletta svaret
  7. När ska du använda streaming?
  8. Viktiga punkter

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ändningsfallRekommendation
Interaktiv chattbotStreaming (bättre UX)
Batch-bearbetningIcke-streaming (enklare)
Backend-API för frontendStreaming (SSE till webbläsare)
DatapipelineIcke-streaming (atomär bearbetning)
Strukturerad extraktionIcke-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.content istället för message.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