Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Rakenda voogedastus Pythonis

Õppetund 6 / 16 Värskendatud 2. november 2026 Arendajatele
Sellel lehel
  1. Prototüübist tootmiskeskkonda
  2. Põhimuster
  3. Põhjalik veahaldus
  4. Asünkroonne voogedastus asyncio-ga
  5. Integreerimine FastAPI-ga
  6. Jõudluse mõõtmine
  7. Peamised punktid

Prototüübist tootmiskeskkonda

Eelmine tund käsitles SSE-voogedastuse kontseptsioone. Raskem osa on alles ees: muuta demo-tsükkel kliendiks, mis peab koormusele vastu, talub võrguvigu ja toidab veebiliidest. See tund järgib projekti tegelikku trajektoori – kõigepealt luustik, seejärel veahaldus, siis asünkroonsus, HTTP-kättesaadavus ja lõpuks mõõtmine.

Põhimuster

Kõik algab sellest kümnest reast koosnevast luustikust, mida kohandad iga projekti jaoks. See teeb korraga kahte asja: kuvab tokenid nende saabumisel ja kogub need funktsiooni tagastusväärtuseks.

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:
    """Saadab voogedastuse päringu ja kuvab tokenid reaalajas."""
    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()  # Uus rida
    return full_text

See versioon töötab kohalikus skriptis. Sellel on tootmiskeskkonnas saatuslik viga: see trükib terminali, nii et see ei saa teha muud kui terminalitööd.

Põhjalik veahaldus

Võrguvead, ajalõpud ja kiirusepiirangud ei ole hüpoteetilised: need on reaalse liikluse skaalal kindlad. Allpool olev klient lahendab mõlemad probleemid. See proovib 429 vigu automaatselt uuesti eksponentsiaalse taganemisega (exponential backoff) ja ei trüki enam midagi: see edastab tüübitud sündmusi yield kaudu, jättes väljakutsujale otsustada, mida nendega peale hakata – kuvada need, saata WebSocketi või kirjutada andmebaasi.

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:
    """Voogedastus automaatse uuestiproovimise ja meetrikaga."""
    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  # Eksponentsiaalne taganemine
                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

Eksponentsiaalne taganemine 2 ** attempt ootab 1 sekundi, siis 2, siis 4. See progressioon ei ole dekoratiivne: kui kõik sinu kliendid prooviksid uuesti sama fikseeritud rütmiga, tabaksid nad API-d sünkroniseeritud lainetena ja pikendaksid just seda küllastumist, mida nad kannatavad. Pane tähele ka, et ainult viga 429 käivitab uuestiproovimise – 401 vea uuestiproovimine kehtetu võtme tõttu lükkaks ainult diagnoosimist edasi.

Väljakutsuja poolel muutub tarbimine lihtsaks sündmuste lugemiseks:

messages = [
    {"role": "system", "content": "Oled tehniline assistent."},
    {"role": "user", "content": "Selgita disainimustreid Pythonis."}
]

for event in stream_with_retry(messages):
    if event["type"] == "token":
        print(event["content"], end="", flush=True)
    elif event["type"] == "retry":
        print(f"\n[Uuestiproovimine {event['attempt']}, ootan {event['wait']}s...]")
    elif event["type"] == "done":
        print(f"\n\n--- Valmis ({event['chunks']} tükki, {event['finish_reason']})")
    elif event["type"] == "error":
        print(f"\n[Viga: {event['message']}]")

Asünkroonne voogedastus asyncio-ga

Sünkroonne klient blokeerib oma lõime kogu genereerimise ajaks. Veebiserveris, mis peab haldama viiskümmet samaaegset vestlust, tähendab see viiekümne lõime immobiliseerimist ainult ootamiseks. Asünkroonne klient tõstab selle piirangu:

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:
    """Asünkroonne voogedastus samaaegsetele rakendustele."""
    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

# Käivitamine
async def main():
    messages = [{"role": "user", "content": "Tere, tutvusta ennast."}]
    result = await async_stream_chat(messages)
    print(f"\nKokku: {len(result)} tähemärki")

asyncio.run(main())

Loogika on identne sünkroonse versiooniga; muutuvad ainult stream_async, await väljakutsel ja async for tsüklis.

Integreerimine FastAPI-ga

Järgmiseks pead saama selle voogu oma Pythoni protsessist brauserisse. FastAPI haldab seda StreamingResponse abil, eeldusel, et vormindad iga fragmendi ümber eelmises tunnis nähtud SSE-vormingusse:

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 generaator FastAPI jaoks."""
    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"
    )

Kaks detaili määravad, kas see lõpp-punkt töötab õigesti. Topelt-uusrida \n\n, mis lõpetab iga yield-i, on see, mis eraldab sündmusi SSE protokollis: ilma selleta ootab brauser lõpmatult sündmust, mida ta peab lõpetamatuks. Ja media_type="text/event-stream" on see, mis võimaldab JavaScripti kliendil tarbida vastust EventSource abil, mitte tavalise fetch-iga.

Jõudluse mõõtmine

Kui voogedastus on paigas, tahad teada, kuidas see toimib. Optimeerimise juhtimiseks piisab kahest meetrikast:

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": "Kirjuta lõik Pariisist."}]
)

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"Aeg esimese tokenini (TTFT): {first_token_time:.3f}s")
print(f"Genereeritud tokenid: {token_count}")
print(f"Koguaeg: {total_time:.3f}s")
print(f"Tokenit sekundis: {token_count / total_time:.1f}")

TTFT (Time to First Token) – aeg päringu saatmisest esimese märgi kuvamiseni – on kasutajakogemuse jaoks kõige olulisem meetrika. See on ülimuslik koguaja suhtes: viieteistsekundiline genereerimine, mille esimene sõna ilmub kolme kümnendiku sekundi jooksul, tundub kiire, samas kui ühes plokis edastatud viiesekundiline genereerimine tundub aeglane. Mõõda seda oma tegelike vihjetega, kaasates süsteemsõnumi – kaheleheküljeline süsteemsõnum pikendab TTFT-d enne, kui esimene token on üldse genereeritud.

Peamised punktid

  • Kasuta generaatori mustrit (yield) voogedastuse tokenite edastamiseks
  • Rakenda eksponentsiaalne taganemine 429 vigade (kiirusepiirang) korral
  • Eelista stream_async-it samaaegsete veebirakenduste jaoks
  • Mõõda TTFT-d ja tokenid sekundis jõudluse optimeerimiseks
  • FastAPI puhul levitab StreamingResponse + text/event-stream SSE brauserisse