Streaming implementálása Pythonban
Ezen az oldalon
Prototípustól a éles rendszerig
Az előző leckében átvettük az SSE streaming alapfogalmait. A nehezebb rész még hátravan: hogyan alakítsd át a demonstrációs ciklust olyan klienssé, amely bírja a terhelést, túléli a hálózati hibákat, és képes kiszolgálni egy webes felületet. Ez a lecke egy valós projekt életútját követi nyomon: először a váz, majd a hibakezelés, az aszinkron működés, a HTTP elérhetővé tétel, végül pedig a mérések.
Az alapsablon
Minden ezzel a tízsoros vázzal kezdődik, amelyet minden projektnél testre szabhatsz. Ez egyszerre csinál két dolgot: megjeleníti a beérkező tokeneket, és összegyűjti őket a függvény visszatérési értékéhez.
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:
"""Streaming kérést küld, és valós időben megjeleníti a tokeneket."""
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() # Új sor
return full_text
Ez a verzió helyi szkriptként működik. Éles környezetben azonban végzetes hibája van: a terminálra ír, így csak terminálos feladatokra használható.
Átfogó hibakezelés
A hálózati hibák, időtúllépések és sebességkorlátozások nem elméleti lehetőségek: valós forgalom mellett biztosra vehetők. Az alábbi kliens mindkét problémát kezeli. Automatikusan újrapróbálja a 429-es hibákat exponenciális visszalépéssel (exponential backoff), és már nem ír ki semmit a képernyőre: helyette típusos eseményeket bocsát ki a yield segítségével, így a hívó fél dönti el, mit kezd velük – megjeleníti, WebSocketen továbbítja, vagy adatbázisba írja.
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 automatikus újrapróbálással és metrikákkal."""
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 # Exponenciális visszalépés
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
Az exponenciális visszalépés (2 ** attempt) először 1 másodpercet, majd 2-t, majd 4-et vár. Ez a progresszió nem díszítés: ha minden kliensed ugyanabban a fix ritmusban próbálná újra, szinkronizált hullámokban érnék el az API-t, és csak elhúznák azt a telítettséget, amitől szenvednek. Jegyezd meg azt is, hogy csak a 429-es hiba vált ki újrapróbálkozást – egy érvénytelen kulcs miatti 401-es hiba újrapróbálása csak késleltetné a hiba diagnosztizálását.
A hívó oldalon a fogyasztás egyszerű eseményolvasássá válik:
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']}]")
Aszinkron streaming az asyncio segítségével
A szinkron kliens a teljes generálás idejére blokkolja a szálat. Egy olyan webkiszolgálón, amelynek ötven egyidejű beszélgetést kell kezelnie, ez azt jelenti, hogy ötven szálat immobilizálsz pusztán a várakozás miatt. Az aszinkron kliens feloldja ezt a korlátot:
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:
"""Aszinkron streaming párhuzamos alkalmazásokhoz."""
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
# Végrehajtás
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())
A logika megegyezik a szinkron verzióéval; csak a stream_async, a híváson lévő await, valamint a cikluson lévő async for változik.
Integráció FastAPI-val
Ezután ki kell juttatnod ezt a streamet a Python folyamatodból a böngészőbe. A FastAPI ezt a StreamingResponse segítségével kezeli, feltéve, hogy minden fragmentumot az előző leckében látott SSE formátumba alakítasz át:
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 generátor FastAPI-hoz."""
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"
)
Két részlet dönti el, hogy ez a végpont helyesen működik-e. A dupla új sor (\n\n), amely lezár minden yield-et, választja el az eseményeket az SSE protokollban: enélkül a böngésző végtelenül várna egy olyan eseményre, amelyet befejezetlennek tekint. A media_type="text/event-stream" pedig lehetővé teszi, hogy a JavaScript kliens egy szabványos fetch helyett EventSource segítségével fogyasztsa a választ.
Teljesítmény mérése
Ha a stream már működik, tudni szeretnéd, hogyan teljesít. Két metrika elég a optimalizálás irányításához:
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}")
A TTFT (Time to First Token) – azaz a kérés elküldése és az első karakter megjelenítése között eltelt idő – a legfontosabb metrika a felhasználói élmény szempontjából. Ez elsőbbséget élvez a teljes idővel szemben: egy tizenöt másodperces generálás, amelynek első szava háromtized másodperc alatt megjelenik, gyorsnak tűnik, míg egy öt másodperces generálás, amely egyben érkezik, lassúnak hat. Mérd ezt a valós promptjaidon, beleértve a rendszerüzenetet is – egy kétoldalas rendszerüzenet meghosszabbítja a TTFT-t, még mielőtt az első token megszületne.
Főbb megállapítások
- Használj generátor mintát (
yield) a streaming tokenek továbbításához - Implementálj exponenciális visszalépést a 429-es hibákhoz (sebességkorlátozás)
- Részesítsd előnyben a
stream_async-ot párhuzamos webalkalmazásoknál - Mérd a TTFT-t és a másodpercenkénti tokenek számát a teljesítmény optimalizálásához
- FastAPI esetén a
StreamingResponseés atext/event-streamkombináció juttatja el az SSE-t a böngészőbe