Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Implementácia streamingu v Pythone

Lekcia 6 z 16 Aktualizované 2. novembra 2026 Vývojár
Na tejto strane
  1. Od prototypu k produkcii
  2. Základný vzor
  3. Komplexné ošetrenie chýb
  4. Asynchrónny streaming s asyncio
  5. Integrácia s FastAPI
  6. Meranie výkonu
  7. Kľúčové poznatky

Od prototypu k produkcii

Predchádzajúca lekcia pokryla koncepty streamingu cez SSE. To ťažšie však ešte len príde: premeniť demonštračnú slučku na klienta, ktorý zvládne záťaž, prežije chyby siete a napája webové rozhranie. Táto lekcia sleduje skutočný vývoj projektu – najprv kostra, potom ošetrenie chýb, následne asynchronnosť, vystavenie cez HTTP a nakoniec meranie.

Základný vzor

Všetko začína touto desaťriadkovou kostrou, ktorú prispôsobíš pre každý projekt. Robí dve veci naraz: zobrazuje tokeny, ako prichádzajú, a zároveň ich akumuluje pre návratovú hodnotu funkcie.

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:
    """Odošle streamingovú požiadavku a zobrazí tokeny v reálnom č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ý riadok
    return full_text

Táto verzia funguje pre lokálny skript. Má však fatálnu chybu pre produkciu: vypisuje do terminálu, takže nedokáže robiť nič iné než terminálovú prácu.

Komplexné ošetrenie chýb

Chyby siete, časové limity a obmedzenia rýchlosti (rate limits) nie sú hypotetické scenáre: pri reálnej prevádzke sú istotou. Nižšie uvedený klient rieši oba problémy. Automaticky opakuje chyby 429 s exponenciálnym oneskorením (backoff) a už nič nevypisuje: namiesto toho vysiela typované udalosti cez yield a necháva na volajúcom, čo s nimi urobí – či ich zobrazí, pošle cez WebSocket, alebo zapíše do databázy.

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 s automatickým opakovaní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álne oneskorenie
                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álne oneskorenie 2 ** attempt čaká 1 sekundu, potom 2, potom 4. Tento postup nie je len ozdobný: keby všetci tvoji klienti skúšali znova v rovnakom pevnom rytme, trafili by API synchronizovanými nárazmi a predĺžili by práve to presýtenie, ktorým trpia. Všimni si tiež, že iba chyba 429 spúšťa opakovanie – opakovanie chyby 401 spôsobenej neplatným kľúčom by len oddialilo diagnostiku.

Na strane volajúceho sa spotreba stáva jednoduchým čítaním udalostí:

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[Opakujem {event['attempt']}, čakám {event['wait']}s...]")
    elif event["type"] == "done":
        print(f"\n\n--- Hotovo ({event['chunks']} chunkov, {event['finish_reason']})")
    elif event["type"] == "error":
        print(f"\n[Chyba: {event['message']}]")

Asynchrónny streaming s asyncio

Synchronný klient blokuje svoje vlákno počas celej generácie. Na webovom serveri, ktorý musí obsluhovať päťdesiat simultánnych konverzácií, to znamená imobilizovať päťdesiat vlákien len čakáním. Asynchrónny klient toto obmedzenie 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:
    """Asynchrónny streaming pre konkurentné aplikácie."""
    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

# Spustenie
async def main():
    messages = [{"role": "user", "content": "Hello, introduce yourself."}]
    result = await async_stream_chat(messages)
    print(f"\nCelkom: {len(result)} znakov")

asyncio.run(main())

Logika je totožná so synchronnou verziou; menia sa len stream_async, await pri volaní a async for v slučke.

Integrácia s FastAPI

Ďalej potrebuješ dostať tento stream z tvojho Python procesu do prehliadača. FastAPI to zvláda pomocou StreamingResponse, za predpokladu, že každý fragment preformátuješ do formátu SSE, ktorý sme videli v predchádzajúcej lekcii:

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 pre 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, či tento endpoint funguje správne. Dvojité nové riadky \n\n, ktoré ukončujú každé yield, sú tým, čo oddeľuje udalosti v protokole SSE: bez nich by prehliadač čakal donekonečna na udalosť, ktorú považuje za nedokončenú. A media_type="text/event-stream" je to, čo umožňuje JavaScript klientovi spracovať odpoveď pomocou EventSource namiesto štandardného fetch.

Meranie výkonu

Akonáhle máš streaming hotový, budeš chcieť vedieť, ako si vedie. Na riadenie optimalizácie stačia dve 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"Vygenerované tokeny: {token_count}")
print(f"Celkový čas: {total_time:.3f}s")
print(f"Tokeny za sekundu: {token_count / total_time:.1f}")

TTFT (Time to First Token) – čas medzi odoslaním požiadavky a zobrazením prvého znaku – je najdôležitejšou metrikou pre používateľskú skúsenosť. Má prednosť pred celkovým časom: generácia trvajúca pätnásť sekúnd, ktorej prvé slovo sa objaví za tri desatiny sekundy, bude pôsobiť rýchlo, zatiaľ čo päťsekundová generácia doručená v jednom bloku bude pôsobiť pomaly. Meraj ju na svojich reálnych promptoch vrátane systémovej správy – dvojstranová systémová správa predlžuje TTFT ešte predtým, než sa vygeneruje prvý token.

Kľúčové poznatky

  • Použi vzor generátora (yield) na propagáciu streamingových tokenov
  • Implementuj exponenciálne oneskorenie pre chyby 429 (obmedzenie rýchlosti)
  • Pre konkurentné webové aplikácie uprednostni stream_async
  • Na optimalizáciu výkonu meraj TTFT a tokeny za sekundu
  • S FastAPI kombinácia StreamingResponse + text/event-stream propaguje SSE do prehliadača