Implementacija pretakanja v Pythonu
Na tej strani
Od prototipa do proizvodnje
Prejšnja lekcija je pokrila koncepte pretakanja SSE. Težji del šele sledi: pretvorba demonstracijske zanke v odjemalca, ki zdrži obremenitev, preživi napake v omrežju in napaja spletni vmesnik. Ta lekcija sledi realni poti projekta – najprej ogrodje, nato obravnava napak, asinhronost, izpostavitev HTTP in nazadnje merjenje.
Osnovni vzorec
Vse se začne s tem desetvrstičnim ogrodjem, ki ga boš prilagodil za vsak projekt. Hkrati počne dve stvari: prikazuje žetone, ko prispejo, in jih kopiči za vrnitev funkcije.
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:
"""Pošlje zahtevo za pretakanje in prikaže žetone v realnem času."""
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() # Nova vrstica
return full_text
Ta različica deluje za lokalno skripto. V proizvodnem okolju ima usodno pomanjkljivost: izpisuje v terminal, zato lahko opravlja le delo v terminalu.
Celovita obravnava napak
Napake v omrežju, časovne omejitve in omejitve hitrosti niso hipotetične: pri realnem obsegu prometa so neizogibne. Spodnji odjemalec rešuje obe težavi. Samodejno ponovno poskusi napake 429 z eksponentnim zamikom in ne izpisuje ničesar: namesto tega oddaja tipizirane dogodke prek yield, kar klicatelju prepusti odločitev, kaj z njimi storiti – jih prikazati, poslati v WebSocket ali zapisati v bazo podatkov.
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:
"""Pretakanje s samodejnim ponovnim poskusom in metrikami."""
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 # Eksponentni zamik
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
Eksponentni zamik 2 ** attempt čaka 1 sekundo, nato 2, nato 4. To napredovanje ni okrasno: če bi vsi tvoji odjemalci ponovno poskušali v istem fiksnem ritmu, bi zadeli API v sinhroniziranih sunkih in podaljšali prav tisto zasičenost, ki jo trpijo. Upoštevaj tudi, da samo napaka 429 sproži ponovni poskus – ponovni poskus 401 zaradi neveljavnega ključa bi le odložil diagnozo.
Na strani klicatelja poraba postane preprosto branje dogodkov:
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[Ponovni poskus {event['attempt']}, čakanje {event['wait']}s...]")
elif event["type"] == "done":
print(f"\n\n--- Končano ({event['chunks']} kosov, {event['finish_reason']})")
elif event["type"] == "error":
print(f"\n[Napaka: {event['message']}]")
Asinhrono pretakanje z asyncio
Sinhroni odjemalec blokira svojo nit za celoten čas generiranja. Na spletnem strežniku, ki mora obdelati petdeset simultanih pogovorov, to pomeni imobilizacijo petdesetih niti zgolj za čakanje. Asinhroni odjemalec to omejitev odpravi:
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:
"""Asinhrono pretakanje za sočasne aplikacije."""
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
# Izvedba
async def main():
messages = [{"role": "user", "content": "Hello, introduce yourself."}]
result = await async_stream_chat(messages)
print(f"\nSkupaj: {len(result)} znakov")
asyncio.run(main())
Logika je enaka sinhroni različici; spremenita se le stream_async, await pri klicu in async for v zanki.
Integracija s FastAPI
Nato moraš to pretakanje spraviti iz svojega procesa Python v brskalnik. FastAPI to obravnava z StreamingResponse, pod pogojem, da vsak fragment preoblikuješ v format SSE, kot smo ga videli v prejšnji lekciji:
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):
"""Generator SSE za 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"
)
Dve podrobnosti določata, ali ta končna točka deluje pravilno. Dvojno novo vrstico \n\n, ki zaključuje vsak yield, ločuje dogodke v protokolu SSE: brez nje brskalnik neskončno čaka na dogodek, ki ga šteje za nedokončan. In media_type="text/event-stream" je tisto, kar omogoča odjemalcu JavaScript, da odzive porabi z EventSource namesto s standardnim fetch.
Merjenje zmogljivosti
Ko je pretakanje vzpostavljeno, boš želel vedeti, kako deluje. Dve metрики sta dovolj za usmerjanje optimizacije:
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"Čas do prvega žetona (TTFT): {first_token_time:.3f}s")
print(f"Generirani žetoni: {token_count}")
print(f"Skupni čas: {total_time:.3f}s")
print(f"Žetonov/sekundo: {token_count / total_time:.1f}")
TTFT (Time to First Token) – čas med pošiljanjem zahteve in prikazom prvega znaka – je najpomembnejša metrika za uporabniško izkušnjo. Ima prednost pred skupnim časom: generiranje, ki traja petnajst sekund, a se prvi beseda pojavi v treh desetinkah sekunde, bo delovalo hitro, medtem ko bo petsekundno generiranje, dostavljeno v enem bloku, delovalo počasi. Izmeri ga na svojih realnih pozivih, vključno s sistemskim sporočilom – dolžina sistemskega sporočila na dveh straneh podaljša TTFT, še preden je prvi žeton sploh generiran.
Ključne ugotovitve
- Uporabi vzorec generatorja (
yield) za posredovanje žetonov pretakanja - Implementiraj eksponentni zamik za napake 429 (omejitev hitrosti)
- Za sočasne spletne aplikacije raje uporabi
stream_async - Za optimizacijo zmogljivosti izmeri TTFT in žetone na sekundo
- S FastAPI
StreamingResponse+text/event-streamposreduje SSE v brskalnik