Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Streaming implementeren in Python

Les 6 van 16 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Van prototype naar productie
  2. Het basispatroon
  3. Uitgebreide foutafhandeling
  4. Asynchroon streamen met asyncio
  5. Integratie met FastAPI
  6. Prestaties meten
  7. Belangrijkste punten

Van prototype naar productie

De vorige les behandelde de concepten van SSE-streaming. Het moeilijkere deel resteert: een demo-lus omvormen tot een client die bestand is tegen belasting, netwerkfouten overleeft en een webinterface voedt. Deze les volgt het echte traject van een project: eerst het skelet, dan foutafhandeling, vervolgens asynchroon programmeren, daarna HTTP-blootstelling en tot slot meting.

Het basispatroon

Alles begint met dit skelet van tien regels, dat u voor elk project zult aanpassen. Het doet twee dingen tegelijk: tokens weergeven zodra ze binnenkomen en ze accumuleren voor de retourwaarde van de functie.

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:
    """Verstuurt een streaming-verzoek en toont tokens in real time."""
    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()  # Nieuwe regel
    return full_text

Deze versie werkt voor een lokaal script. Het heeft een fatale fout in productie: het drukt af naar de terminal, waardoor het niets anders dan terminalwerk kan verrichten.

Uitgebreide foutafhandeling

Netwerkfouten, time-outs en tarieflimieten zijn geen hypothesen: het zijn zekerheden bij echte verkeersschalen. De onderstaande client lost beide problemen op. Hij probeert 429-fouten automatisch opnieuw met exponentiële back-off en drukt niets meer af: hij zendt getypeerde events uit via yield, waardoor de aanroeper kan beslissen wat ermee te doen—ze weergeven, naar een WebSocket pushen of naar een database schrijven.

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 met automatisch opnieuw proberen en metrieken."""
    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  # Exponentiële back-off
                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

De exponentiële back-off 2 ** attempt wacht 1 seconde, dan 2, dan 4. Deze progressie is niet decoratief: als al uw clients op hetzelfde vaste ritme opnieuw zouden proberen, zouden ze de API in gesynchroniseerde bursts raken en de verzadiging waaronder ze lijden juist verlengen. Merk ook op dat alleen fout 429 een nieuwe poging activeert—een 401 vanwege een ongeldige sleutel opnieuw proberen, zou de diagnose alleen maar vertragen.

Aan de kant van de aanroeper wordt consumptie een eenvoudige event-lezing:

messages = [
    {"role": "system", "content": "You are a technical assistant."},
    {"role": "user", "content": "Explain design patterns in 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[Retry {event['attempt']}, waiting {event['wait']}s...]")
    elif event["type"] == "done":
        print(f"\n\n--- Done ({event['chunks']} chunks, {event['finish_reason']})")
    elif event["type"] == "error":
        print(f"\n[Error: {event['message']}]")

Asynchroon streamen met asyncio

De synchrone client blokkeert zijn thread voor de volledige generatie. Op een webserver die vijftig gelijktijdige gesprekken moet afhandelen, betekent dit dat vijftig threads worden geïmmobiliseerd alleen om te wachten. De asynchrone client heft deze beperking op:

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:
    """Asynchroon streamen voor concurrente applicaties."""
    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

# Uitvoering
async def main():
    messages = [{"role": "user", "content": "Hello, introduce yourself."}]
    result = await async_stream_chat(messages)
    print(f"\nTotal: {len(result)} characters")

asyncio.run(main())

De logica is identiek aan de synchrone versie; alleen stream_async, de await bij de aanroep en de async for in de lus veranderen.

Integratie met FastAPI

Vervolgens moet u deze stream uit uw Python-proces halen en naar de browser brengen. FastAPI regelt dit met StreamingResponse, op voorwaarde dat u elk fragment herformatteert naar het SSE-formaat zoals gezien in de vorige les:

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 voor 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"
    )

Twee details bepalen of dit eindpunt correct werkt. De dubbele nieuwe regel \n\n die elke yield beëindigt, is wat events scheidt in het SSE-protocol: zonder dit wacht de browser eindeloos op een event dat hij als onvoltooid beschouwt. En media_type="text/event-stream" is wat de JavaScript-client in staat stelt het antwoord te consumeren met een EventSource in plaats van een standaard fetch.

Prestaties meten

Zodra de stream staat, wilt u weten hoe deze presteert. Twee metrieken volstaan om optimalisatie aan te sturen:

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": "Write a paragraph about 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"Time to First Token (TTFT): {first_token_time:.3f}s")
print(f"Tokens generated: {token_count}")
print(f"Total time: {total_time:.3f}s")
print(f"Tokens/second: {token_count / total_time:.1f}")

TTFT (Time to First Token)—de tijd tussen het verzenden van het verzoek en het weergeven van het eerste teken—is de belangrijkste metriek voor de gebruikerservaring. Deze gaat voor op de totale tijd: een generatie van vijftien seconden waarvan het eerste woord in drie tienden van een seconde verschijnt, voelt snel aan, terwijl een generatie van vijf seconden die in één blok wordt geleverd, langzaam aanvoelt. Meet dit op uw echte prompts, inclusief systeembericht—een systeembericht van twee pagina’s verlengt de TTFT voordat het eerste token überhaupt is gegenereerd.

Belangrijkste punten

  • Gebruik een generatorpatroon (yield) om streaming-tokens door te geven
  • Implementeer exponentiële back-off voor 429-fouten (tarieflimiet)
  • Geef de voorkeur aan stream_async voor concurrente webapplicaties
  • Meet TTFT en tokens per seconde om prestaties te optimaliseren
  • Met FastAPI propageert StreamingResponse + text/event-stream SSE naar de browser