Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Įgyvendinkite srautinį perdavimą Python kalba

Paskaita 6 iš 16 Atnaujinta 2026 m. lapkričio 2 d. Kūrėjas
Šiame puslapyje
  1. Nuo prototipo iki gamybos
  2. Pagrindinis šablonas
  3. Išsamus klaidų apdorojimas
  4. Asinchronis srautinis perdavimas naudojant asyncio
  5. Integracija su FastAPI
  6. Našumo matavimas
  7. Svarbiausi punktai

Nuo prototipo iki gamybos

Ankstesnėje pamokoje nagrinėjome SSE srautinio perdavimo koncepcijas. Sunkioji dalis dar laukia: paversti demonstracinę kilpą klientu, kuris atlaikytų apkrovas, išgyventų tinklo klaidas ir maitintų žiniatinklio sąsają. Ši pamoka seka tikrąją projekto eigą: pirmiausia skeletas, tada klaidų apdorojimas, vėliau asinchroniškumas, HTTP eksponavimas ir galiausiai matavimai.

Pagrindinis šablonas

Viskas prasideda nuo šio dešimties eilučių skeleto, kurį pritaikysi kiekvienam projektui. Jis vienu metu atlieka du dalykus: rodo žetonus jiems atvykstant ir kaupia juos funkcijos grąžinamajai reikšmei.

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:
    """Siunčia srautinę užklausą ir rodo žetonus realiuoju laiku."""
    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()  # Nauja eilutė
    return full_text

Ši versija veikia vietiniame scenarijuje. Tačiau gamyboje ji turi lemtingą trūkumą: ji spausdina į terminalą, todėl gali atlikti tik terminalo užduotis.

Išsamus klaidų apdorojimas

Tinklo klaidos, laiko limitai ir dažnio apribojimai nėra hipotetiniai dalykai: esant realiam srautui, jie neišvengiami. Toliau pateiktas klientas sprendžia abi problemas. Jis automatiškai kartoją 429 klaidas taikydamas eksponentinį delsą ir nieko nespausdina: vietoj to jis generuoja tipizuotus įvykius naudodamas yield, palikdamas kviečiančiajai programai spręsti, ką su jais daryti – rodyti, siųsti į „WebSocket“ arba rašyti į duomenų bazę.

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:
    """Srautinis perdavimas su automatiniu kartojimu ir metrika."""
    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  # Eksponentinis delsa
                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

Eksponentinis delsa 2 ** attempt laukia 1 sekundę, tada 2, tada 4. Ši progresija nėra dekoratyvinė: jei visi tavo klientai kartotų užklausas tuo pačiu fiksuotu ritmu, jie pasiektų API sinchronizuotais pliūpsniais ir tik pailgintų tą patį sotumą, nuo kurio kenčia. Taip pat atkreipk dėmesį, kad tik 429 klaida sukelia kartojimą – 401 klaidos dėl neteisingo rakto kartojimas tik atidėtų diagnostiką.

Kviečiančiojoje pusėje vartojimas tampa paprastu įvykių skaitymu:

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

Asinchronis srautinis perdavimas naudojant asyncio

Sinchroninis klientas užblokuoja savo giją visam generavimo laikui. Žiniatinklio serveryje, kuris turi apdoroti penkiasdešimt simultaniškų pokalbių, tai reiškia penkiasdešimties gijų imobilizavimą vien tik laukimui. Asinchronis klientas pašalina šį apribojimą:

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:
    """Asinchronis srautinis perdavimas konkurencinėms programoms."""
    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

# Vykdymas
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 yra identiška sinchroninei versijai; keičiasi tik stream_async, await kvietime ir async for kilpoje.

Integracija su FastAPI

Toliau reikia šį srautą išvesti iš Python proceso į naršyklę. FastAPI tai tvarko naudodamas StreamingResponse, su sąlyga, kad kiekvieną fragmentą performuosi į SSE formatą, matytą ankstesnėje pamokoje:

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

Du detalės lemia, ar šis galinis taškas veiks tinkamai. Dviguba nauja eilutė \n\n, užbaigianti kiekvieną yield, yra tai, kas atskiria įvykius SSE protokole: be jos naršyklė neribotai lauktų įvykio, kurį laiko neužbaigtu. O media_type="text/event-stream" leidžia JavaScript klientui vartoti atsakymą naudojant EventSource, o ne standartinį fetch.

Našumo matavimas

Kai srautinis perdavimas jau veikia, norėsi sužinoti, kaip jis pasirodo. Optimizavimui pakanka dviejų metrikų:

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 (laikas iki pirmojo žetono) – laikas tarp užklausos išsiuntimo ir pirmojo simbolio atsiradimo – yra svarbiausia naudotojo patirties metrika. Ji turi pirmenybę prieš bendrą laiką: penkiolikos sekundžių generavimas, kurio pirmasis žodis pasirodo per tris dešimtąsias sekundės, atrodys greitas, tuo tarpu penkių sekundžių generavimas, pateiktas vienu bloku, atrodys lėtas. Matuok tai naudodamas tikrus savo raginimus, įskaitant sistemos žinutę – dviejų puslapių sistemos žinutė pailgina TTFT dar prieš sugeneruojant pirmąjį žetoną.

Svarbiausi punktai

  • Naudok generatoriaus šabloną (yield) srautiniams žetonams perduoti
  • Įgyvendink eksponentinį delsą 429 klaidoms (dažnio apribojimas)
  • Konkurencinėms žiniatinklio programoms teik pirmenybę stream_async
  • Našumui optimizuoti matuok TTFT ir žetonus per sekundę
  • Naudojant FastAPI, StreamingResponse + text/event-stream perduoda SSE į naršyklę