Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Implementér streaming i Python

Lektion 6 af 16 Opdateret 2. november 2026 Udvikler
På denne side
  1. Fra prototype til produktion
  2. Det grundlæggende mønster
  3. Omfattende fejlhåndtering
  4. Asynkron streaming med asyncio
  5. Integration med FastAPI
  6. Måling af ydeevne
  7. Vigtige pointer

Fra prototype til produktion

Den foregående lektion dækkede begreberne bag SSE-streaming. Den sværere del mangler stadig: at omdanne en demo-løkke til en klient, der holder under belastning, overlever netværksfejl og fodrer et webinterface. Denne lektion følger et projekts virkelige forløb – først skelet, derefter fejlhåndtering, så asynkronitet, eksponering via HTTP og til sidst måling.

Det grundlæggende mønster

Alt starter med dette ti-linjers skelet, som du vil tilpasse til hvert projekt. Det gør to ting på én gang: viser tokens, efterhånden som de ankommer, og akkumulerer dem til funktionens returværdi.

from mistralai.client import Mistral
import os

client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))

def stream_chat(messages: list, model: str = "mistral-large-latest") -> str:
    """Sender en streaming-anmodning og viser tokens i realtid."""
    stream = client.chat.stream(
        model=model,
        messages=messages
    )

    full_text = ""
    for chunk in stream:
        content = chunk.data.choices[0].delta.content
        if content:
            full_text += content
            print(content, end="", flush=True)

    print()  # Ny linje
    return full_text

Denne version fungerer til et lokalt script. Den har en fatal fejl i produktion: den skriver til terminalen, så den kan kun udføre terminalarbejde.

Omfattende fejlhåndtering

Netværksfejl, timeouts og rate limits er ikke hypotetiske scenarier: de er en given ved reel trafikskala. Klienten nedenfor løser begge problemer. Den genprøver automatisk 429-fejl med eksponentiel backoff, og den skriver ikke længere noget ud: den udsender typede begivenheder via yield, hvilket overlader det til kalderen at beslutte, hvad der skal gøres med dem – vise dem, skubbe dem til en WebSocket eller skrive dem til en database.

from mistralai.client import Mistral
from mistralai.client.errors import SDKError
import os
import time

client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))

def stream_with_retry(
    messages: list,
    model: str = "mistral-large-latest",
    max_retries: int = 3,
    max_tokens: int = 2000
) -> dict:
    """Streaming med automatisk genprøvning og metrikker."""
    for attempt in range(max_retries):
        try:
            stream = client.chat.stream(
                model=model,
                messages=messages,
                max_tokens=max_tokens
            )

            full_text = ""
            finish_reason = None
            chunk_count = 0

            for chunk in stream:
                delta = chunk.data.choices[0].delta
                if delta.content:
                    full_text += delta.content
                    chunk_count += 1
                    yield {"type": "token", "content": delta.content}

                if chunk.data.choices[0].finish_reason:
                    finish_reason = chunk.data.choices[0].finish_reason

            yield {
                "type": "done",
                "full_text": full_text,
                "finish_reason": finish_reason,
                "chunks": chunk_count
            }
            return

        except SDKError as e:
            if e.status_code == 429 and attempt < max_retries - 1:
                wait_time = 2 ** attempt  # Eksponentiel backoff
                yield {"type": "retry", "wait": wait_time, "attempt": attempt + 1}
                time.sleep(wait_time)
            else:
                yield {"type": "error", "message": str(e), "status": e.status_code}
                return

        except Exception as e:
            yield {"type": "error", "message": str(e), "status": None}
            return

Den eksponentielle backoff 2 ** attempt venter 1 sekund, derefter 2, derefter 4. Denne progression er ikke dekorativ: hvis alle dine klienter genprøvede i samme faste rytme, ville de ramme API’et i synkroniserede bølger og forlænge netop den mætning, de lider under. Bemærk også, at kun fejl 429 udløser en genprøvning – at genprøve en 401 på grund af en ugyldig nøgle ville kun forsinke diagnosen.

På kaldersiden bliver forbruget til en simpel begivenhedslæsning:

messages = [
    {"role": "system", "content": "Du er en teknisk assistent."},
    {"role": "user", "content": "Forklar designmønstre i Python."}
]

for event in stream_with_retry(messages):
    if event["type"] == "token":
        print(event["content"], end="", flush=True)
    elif event["type"] == "retry":
        print(f"\n[Genprøvning {event['attempt']}, venter {event['wait']}s...]")
    elif event["type"] == "done":
        print(f"\n\n--- Færdig ({event['chunks']} chunks, {event['finish_reason']})")
    elif event["type"] == "error":
        print(f"\n[Fejl: {event['message']}]")

Asynkron streaming med asyncio

Den synkrone klient blokerer sin tråd under hele genereringen. På en webserver, der skal håndtere halvtreds samtidige samtaler, betyder det, at halvtreds tråde immobiliseres blot for at vente. Den asynkrone klient ophæver denne begrænsning:

from mistralai.client import Mistral
import asyncio
import os

client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))

async def async_stream_chat(messages: list) -> str:
    """Asynkron streaming til samtidige applikationer."""
    stream = await client.chat.stream_async(
        model="mistral-large-latest",
        messages=messages
    )

    full_text = ""
    async for chunk in stream:
        content = chunk.data.choices[0].delta.content
        if content:
            full_text += content
            print(content, end="", flush=True)

    print()
    return full_text

# Eksekvering
async def main():
    messages = [{"role": "user", "content": "Hej, introducer dig selv."}]
    result = await async_stream_chat(messages)
    print(f"\nI alt: {len(result)} tegn")

asyncio.run(main())

Logikken er identisk med den synkrone version; kun stream_async, await på kaldet og async for i løkken ændres.

Integration med FastAPI

Dernæst skal du få denne stream ud af din Python-proces og ind i browseren. FastAPI håndterer dette med StreamingResponse, forudsat at du omformaterer hvert fragment til det SSE-format, du så i den foregående lektion:

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from mistralai.client import Mistral
import os
import json

app = FastAPI()
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))

async def generate_stream(prompt: str):
    """SSE-generator til FastAPI."""
    stream = await client.chat.stream_async(
        model="mistral-large-latest",
        messages=[{"role": "user", "content": prompt}]
    )

    async for chunk in stream:
        content = chunk.data.choices[0].delta.content
        if content:
            data = json.dumps({"content": content})
            yield f"data: {data}\n\n"

    yield "data: [DONE]\n\n"

@app.get("/chat/stream")
async def chat_stream(prompt: str):
    return StreamingResponse(
        generate_stream(prompt),
        media_type="text/event-stream"
    )

To detaljer afgør, om dette endpoint fungerer korrekt. Den dobbelte ny linje \n\n, der afslutter hvert yield, er det, der adskiller begivenheder i SSE-protokollen: uden den venter browseren uendeligt på en begivenhed, den betragter som uafsluttet. Og media_type="text/event-stream" er det, der tillader JavaScript-klienten at forbruge svaret med en EventSource i stedet for en standard fetch.

Måling af ydeevne

Når strømmen er på plads, vil du vide, hvordan den performer. To metrikker er nok til at drive optimering:

import time

start = time.perf_counter()
first_token_time = None
token_count = 0

stream = client.chat.stream(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "Skriv et afsnit om Paris."}]
)

for chunk in stream:
    if chunk.data.choices[0].delta.content:
        if first_token_time is None:
            first_token_time = time.perf_counter() - start
        token_count += 1

total_time = time.perf_counter() - start

print(f"Tid til første token (TTFT): {first_token_time:.3f}s")
print(f"Genererede tokens: {token_count}")
print(f"Samlet tid: {total_time:.3f}s")
print(f"Tokens/sekund: {token_count / total_time:.1f}")

TTFT (Time to First Token) – tiden mellem afsendelse af anmodningen og visning af det første tegn – er den vigtigste metrik for brugeroplevelsen. Den har prioritet over samlet tid: en femten sekunders generering, hvor det første ord vises på tre tiendedele af et sekund, vil føles hurtig, mens en fem sekunders generering leveret i én blok vil føles langsom. Mål den på dine rigtige prompts, inklusive systembesked – en systembesked på to sider forlænger TTFT, før det første token overhovedet er genereret.

Vigtige pointer

  • Brug et generator-mønster (yield) til at propagere streaming-tokens
  • Implementér eksponentiel backoff for 429-fejl (rate limit)
  • Foretræk stream_async til samtidige webapplikationer
  • Mål TTFT og tokens/sekund for at optimere ydeevnen
  • Med FastAPI propagerer StreamingResponse + text/event-stream SSE til browseren