Реализиране на стрийминг в Python
На тази страница
От прототип до продукция
Предишният урок обхвана концепциите за SSE стрийминг. По-трудната част остава: превръщането на демонстрационен цикъл в клиент, който издържа на натоварване, оцелява при мрежови грешки и захранва уеб интерфейс. Този урок следва реалната траектория на един проект – първо скелет, след това обработка на грешки, после асинхронност, излагане чрез HTTP и накрая измерване.
Основният шаблон
Всичко започва с този десетредов скелет, който ще адаптирате за всеки проект. Той прави две неща едновременно: показва токените, докато пристигат, и ги натрупва за връщане от функцията.
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:
"""Изпраща стрийминг заявка и показва токените в реално време."""
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() # Нов ред
return full_text
Тази версия работи за локален скрипт. Тя има фатален недостатък в продукция: принтира в терминала, така че може да върши само работа в терминала.
Изчерпателна обработка на грешки
Мрежовите грешки, изчакванията (timeouts) и ограниченията на скоростта не са хипотетични: те са сигурни при реален мащаб на трафика. Клиентът по-долу решава и двата проблема. Той автоматично повтаря грешки 429 с експоненциално забавяне (exponential backoff) и вече не принтира нищо: той излъчва типизирани събития чрез yield, оставяйки на извикващия да реши какво да прави с тях – да ги покаже, да ги изпрати към WebSocket или да ги запише в база данни.
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:
"""Стрийминг с автоматично повторение и метрики."""
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 # Експоненциално забавяне
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
Експоненциалното забавяне 2 ** attempt изчаква 1 секунда, после 2, после 4. Тази прогресия не е декоративна: ако всички ваши клиенти се опитваха отново с един и същи фиксиран ритъм, те биха ударили API със синхронизирани всплескове и биха удължили точно насищането, от което страдат. Обърнете внимание също, че само грешка 429 задейства повторение – повторението на 401 поради невалиден ключ би забавило само диагностицирането.
От страната на извикващия, консумирането става просто четене на събития:
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']}]")
Асинхронен стрийминг с asyncio
Синхронният клиент блокира своя нишка за цялото време на генериране. На уеб сървър, който трябва да обработва петдесет едновременни разговора, това означава обездвижване на петдесет нишки просто за изчакване. Асинхронният клиент премахва това ограничение:
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:
"""Асинхронен стрийминг за конкурентни приложения."""
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
# Изпълнение
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())
Логиката е идентична със синхронната версия; променят се само stream_async, await при извикването и async for в цикъла.
Интеграция с FastAPI
Следващата стъпка е да изведете този стрийминг от вашия Python процес и да го доставите в браузъра. FastAPI се справя с това чрез StreamingResponse, при условие че преформатирате всеки фрагмент във формата за SSE, видян в предишния урок:
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 генератор за 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"
)
Два детайла определят дали този крайна точка (endpoint) работи правилно. Двойният нов ред \n\n, който завършва всеки yield, е това, което разделя събитията в протокола SSE: без него браузърът чака безкрайно за събитие, което счита за незавършено. А media_type="text/event-stream" е това, което позволява на JavaScript клиента да консумира отговора с EventSource, а не със стандартен fetch.
Измерване на производителността
След като стриймингът е на място, ще искате да знаете как се представя. Две метрики са достатъчни, за да управлявате оптимизацията:
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) – времето между изпращането на заявката и показването на първия символ – е най-важната метрика за потребителското изживяване. Тя има предимство пред общото време: генериране от петнадесет секунди, чиято първа дума се появява за три десети от секундата, ще изглежда бързо, докато генериране от пет секунди, доставено наведнъж, ще изглежда бавно. Измервайте го върху вашите реални подкани (prompts), включително системното съобщение – дълго системно съобщение от две страници удължава TTFT, преди първият токен да бъде дори генериран.
Ключови изводи
- Използвайте шаблон с генератор (
yield), за да разпространявате стрийминг токени - Внедрете експоненциално забавяне за грешки 429 (ограничение на скоростта)
- Предпочитайте
stream_asyncза конкурентни уеб приложения - Измервайте TTFT и токени/секунда, за да оптимизирате производителността
- С FastAPI,
StreamingResponse+text/event-streamразпространява SSE към браузъра