Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Implementace streamování v Pythonu

Lekce 6 z 16 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Od prototypu k produkci
  2. Základní vzor
  3. Komplexní zpracování chyb
  4. Asynchronní streamování s asyncio
  5. Integrace s FastAPI
  6. Měření výkonu
  7. Klíčové poznatky

Od prototypu k produkci

Minulá lekce pokryla koncepty streamování SSE. To těžší však teprve přichází: proměnit demonstrační smyčku v klienta, který zvládne zátěž, přežije chyby sítě a bude napájet webové rozhraní. Tato lekce následuje skutečný vývoj projektu – nejprve kostra, poté zpracování chyb, pak asynchronnost, vystavení přes HTTP a nakonec měření.

Základní vzor

Všechno začíná touto desetirádkovou kostrou, kterou přizpůsobíš pro každý projekt. Dělá dvě věci najednou: zobrazuje tokeny, jak přicházejí, a zároveň je akumuluje pro návratovou hodnotu funkce.

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:
    """Odešle streamovací požadavek a zobrazí tokeny v reálném čase."""
    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()  # Nový řádek
    return full_text

Tato verze funguje pro lokální skript. Má však fatální chybu pro produkci: tiskne do terminálu, takže neumí dělat nic jiného než práci v terminálu.

Komplexní zpracování chyb

Chyby sítě, vypršení časových limitů a omezení rychlosti (rate limits) nejsou hypotetické scénáře: při reálném provozu jsou jistotou. Níže uvedený klient řeší oba problémy. Automaticky opakuje chyby 429 s exponenciálním backoffem a již nic netiskne: místo toho emituje typované události prostřednictvím yield a nechává na volajícím, aby se rozhodl, co s nimi udělá – zobrazil je, poslal přes WebSocket nebo zapsal do databáze.

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:
    """Streamování s automatickým opakováním a 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  # Exponenciální 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

Exponenciální backoff 2 ** attempt čeká 1 sekundu, pak 2, pak 4. Tato progrese není jen dekorace: pokud by všichni vaši klienti opakovali pokusy ve stejném pevném rytmu, udeřili by na API synchronizovanými vlnami a prodloužili by právě to přetížení, kterým trpí. Všimni si také, že pouze chyba 429 spouští opakování – opakování chyby 401 kvůli neplatnému klíči by pouze oddálilo diagnostiku.

Na straně volajícího se spotřeba stane jednoduchým čtením událostí:

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']}]")

Asynchronní streamování s asyncio

Synchronní klient blokuje své vlákno po celou dobu generování. Na webovém serveru, který musí obsluhovat padesát simultánních konverzací, to znamená imobilizaci padesáti vláken jen kvůli čekání. Asynchronní klient toto omezení odstraňuje:

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:
    """Asynchronní streamování pro konkurentní aplikace."""
    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

# Spuštění
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())

Logika je totožná se synchronní verzí; mění se pouze stream_async, klíčové slovo await při volání a async for ve smyčce.

Integrace s FastAPI

Dále potřebuješ dostat tento stream z tvého Python procesu do prohlížeče. FastAPI to zvládá pomocí StreamingResponse, za předpokladu, že přeformátuješ každý fragment do formátu SSE, který jsme viděli v minulé lekci:

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 pro 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"
    )

Dva detaily rozhodují o tom, zda tento endpoint funguje správně. Dvojité nové řádky \n\n, které ukončují každé yield, oddělují události v protokolu SSE: bez nich by prohlížeč donekonečna čekal na událost, kterou považuje za nedokončenou. A media_type="text/event-stream" je to, co umožňuje JavaScript klientovi konsumovat odpověď pomocí EventSource namísto standardního fetch.

Měření výkonu

Jakmile je stream hotový, budeš chtít vědět, jak si vede. K řízení optimalizace stačí dvě metriky:

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) – čas mezi odesláním požadavku a zobrazením prvního znaku – je nejdůležitější metrikou pro uživatelskou zkušenost. Má přednost před celkovým časem: patnáctisekundové generování, jehož první slovo se objeví za tři desetiny sekundy, bude působit rychle, zatímco pětisekundové generování doručené v jednom bloku bude působit pomalu. Měř to na svých reálných prompotech včetně systémové zprávy – dvoustránková systémová zpráva prodlužuje TTFT ještě předtím, než je vygenerován první token.

Klíčové poznatky

  • Použij vzor generátoru (yield) k propagaci streamovaných tokenů
  • Implementuj exponenciální backoff pro chyby 429 (omezení rychlosti)
  • Pro konkurentní webové aplikace upřednostni stream_async
  • Měř TTFT a tokeny za sekundu pro optimalizaci výkonu
  • S FastAPI kombinace StreamingResponse + text/event-stream propaguje SSE do prohlížeče