Премини към основното съдържание
Български— Изберете език
Меню

Реализиране на стрийминг в Python

Урок 6 от 16 Обновен 2 ноември 2026 г. Програмист
На тази страница
  1. От прототип до продукция
  2. Основният шаблон
  3. Изчерпателна обработка на грешки
  4. Асинхронен стрийминг с asyncio
  5. Интеграция с FastAPI
  6. Измерване на производителността
  7. Ключови изводи

От прототип до продукция

Предишният урок обхвана концепциите за 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 към браузъра