Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Streaming SSE

Lektion 5 af 16 Opdateret 2. november 2026 Udvikler
På denne side
  1. Svar i realtid med Server-Sent Events
  2. Streaming kontra ikke-streaming
  3. SSE-protokollen i detaljer
  4. Aktiver streaming i Python
  5. Struktur af en chunk
  6. Rekonstruer det komplette svar
  7. Hvornår skal du bruge streaming?
  8. Vigtige pointer

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 caseRecommendation
Interactive chatbotStreaming (better UX)
Batch processingNon-streaming (simpler)
Backend API for frontendStreaming (SSE to browser)
Data pipelineNon-streaming (atomic processing)
Structured extractionNon-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.content i stedet for message.content
  • Akkumulér fragmenter på klientsiden for at rekonstruere det komplette svar
  • Foretræk streaming til brugergrænseflader og ikke-streaming til automatiseret behandling