Implementera streaming i Python
På denna sida
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_asyncför samtidiga webbapplikationer - Mät TTFT och token/sekund för att optimera prestanda
- Med FastAPI propagerar
StreamingResponse+text/event-streamSSE till webbläsaren