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

Implementera streaming i Python

Lektion 6 av 16 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Från prototyp till produktion
  2. Det grundläggande mönstret
  3. Omfattande felhantering
  4. Asynkron streaming med asyncio
  5. Integration med FastAPI
  6. Mätning av prestanda
  7. Viktiga punkter

Från prototyp till produktion

Den föregående lektionen täckte koncepten kring SSE-streaming. Den svårare delen återstår: att omvandla en demo-loop till en klient som håller under belastning, överlever nätverksfel och matar ett webbgränssnitt. Denna lektion följer ett projekts verkliga bana – först skelett, sedan felhantering, därefter asynkron kod, exponering via HTTP och slutligen mätning.

Det grundläggande mönstret

Allt börjar med detta tiolinjiga skelett, som du kommer att anpassa för varje projekt. Det gör två saker samtidigt: visar token när de anländer och ackumulerar dem för funktionens returvärde.

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:
    """Skickar en streaming-förfrågan och visar token 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 rad
    return full_text

Denna version fungerar för ett lokalt skript. Den har en ödesdiger brist i produktion: den skriver ut till terminalen, så den kan inte göra något annat än terminalarbete.

Omfattande felhantering

Nätverksfel, timeout och hastighetsbegränsningar är inte hypotetiska: de är certifikat vid verklig trafikskala. Klienten nedan adresserar båda problemen. Den försöker automatiskt igen vid 429-fel med exponentiell backoff, och den skriver inte längre ut något: den emitterar typade händelser via yield, vilket lämnar åt anroparen att besluta vad den ska göra med dem – visa dem, pusha dem till en WebSocket eller skriva dem till en databas.

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 återförsök och metrik."""
    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  # Exponentiell 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 exponentiella backoffen 2 ** attempt väntar 1 sekund, sedan 2, sedan 4. Denna progression är inte dekorativ: om alla dina klienter försökte igen i samma fasta rytm skulle de träffa API:t i synkroniserade burstar och förlänga den mättnad de lider av. Observera också att endast fel 429 utlöser ett återförsök – att försöka igen vid en 401 på grund av en ogiltig nyckel skulle bara fördröja diagnosen.

På anroparsidan blir konsumtionen en enkel händelseläsning:

messages = [
    {"role": "system", "content": "Du är en teknisk assistent."},
    {"role": "user", "content": "Förklara designmönster 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[Försök {event['attempt']}, väntar {event['wait']}s...]")
    elif event["type"] == "done":
        print(f"\n\n--- Klart ({event['chunks']} chunkar, {event['finish_reason']})")
    elif event["type"] == "error":
        print(f"\n[Fel: {event['message']}]")

Asynkron streaming med asyncio

Den synkrona klienten blockerar sin tråd under hela genereringen. På en webbserver som måste hantera femtio samtidiga konversationer innebär detta att femtio trådar immobiliseras bara för att vänta. Den asynkrona klienten lyfter denna 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 för samtidiga 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

# Exekvering
async def main():
    messages = [{"role": "user", "content": "Hej, presentera dig själv."}]
    result = await async_stream_chat(messages)
    print(f"\nTotalt: {len(result)} tecken")

asyncio.run(main())

Logiken är identisk med den synkrona versionen; endast stream_async, await på anropet och async for i loopen ändras.

Integration med FastAPI

Därefter måste du få ut denna stream från din Python-process och in i webbläsaren. FastAPI hanterar detta med StreamingResponse, förutsatt att du formaterar om varje fragment till SSE-formatet som sågs i den föregående lektionen:

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 för 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"
    )

Två detaljer avgör om denna endpoint fungerar korrekt. Den dubbla nyraden \n\n som avslutar varje yield är vad som separerar händelser i SSE-protokollet: utan den väntar webbläsaren oändligt på en händelse den anser vara oavslutad. Och media_type="text/event-stream" är vad som tillåter JavaScript-klienten att konsumera svaret med en EventSource snarare än en standard fetch.

Mätning av prestanda

När streamen väl är på plats vill du veta hur den presterar. Två metrik räcker för att driva 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 ett stycke 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 till första token (TTFT): {first_token_time:.3f}s")
print(f"Genererade token: {token_count}")
print(f"Total tid: {total_time:.3f}s")
print(f"Token/sekund: {token_count / total_time:.1f}")

TTFT (Time to First Token) – tiden mellan att förfrågan skickas och det första tecknet visas – är den viktigaste metriken för användarupplevelsen. Den går före total tid: en femtonsekundersgenerering vars första ord dyker upp på tre tiondelar av en sekund kommer att kännas snabb, medan en femsekundersgenerering som levereras i ett block kommer att kännas långsam. Mät den på dina verkliga prompts, inklusive systemmeddelandet – ett tvåsidigt systemmeddelande förlänger TTFT innan ens den första token genereras.

Viktiga punkter

  • Använd ett generatormönster (yield) för att propagera streaming-token
  • Implementera exponentiell backoff för 429-fel (hastighetsbegränsning)
  • Föredra stream_async för samtidiga webbapplikationer
  • Mät TTFT och token/sekund för att optimera prestanda
  • Med FastAPI propagerar StreamingResponse + text/event-stream SSE till webbläsaren