Streaming implementeren in Python
Op deze pagina
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_asyncvoor concurrente webapplicaties - Meet TTFT en tokens per seconde om prestaties te optimaliseren
- Met FastAPI propageert
StreamingResponse+text/event-streamSSE naar de browser