Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Implementē straumēšanu Python valodā

Nodarbība 6 no 16 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. No prototipa uz produkciju
  2. Pamata paraugs
  3. Visaptveroša kļūdu apstrāde
  4. Asinhrona straumēšana ar asyncio
  5. Integrācija ar FastAPI
  6. Veiktspējas mērīšana
  7. Galvenās atziņas

No prototipa uz produkciju

Iepriekšējā nodarbībā tika apskatīti SSE straumēšanas koncepti. Grūtākā daļa vēl priekšā: pārvērst demonstrācijas ciklu klientā, kas iztur slodzi, pārdzīvo tīkla kļūdas un baro tīmekļa saskarni. Šī nodarbība seko reālam projekta attīstības ceļam — vispirms skelets, tad kļūdu apstrāde, tad asinhronitāte, tad HTTP eksponēšana un visbeidzot mērījumi.

Pamata paraugs

Viss sākas ar šo desmit rindu skeletu, ko pielāgosi katram projektam. Tas dara divas lietas vienlaicīgi: parāda tokenus, tiklīdz tie ierodas, un uzkrāj tos funkcijas atgriešanai.

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:
    """Nosūta straumēšanas pieprasījumu un parāda tokenus reāllaikā."""
    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()  # Jauna rinda
    return full_text

Šī versija darbojas lokālam skriptam. Tai ir fatāls trūkums produkcijā: tā drukā terminālī, tāpēc spēj veikt tikai termināļa darbu.

Visaptveroša kļūdu apstrāde

Tīkla kļūdas, noildzes un ātruma ierobežojumi nav hipotētiski scenāriji: tie ir neizbēgami pie reālas satiksmes mēroga. Zemāk esošais klients atrisina abas problēmas. Tas automātiski atkārto 429 kļūdas, izmantojot eksponenciālu atkāpšanos, un vairs neko nedrukā: tas ģenerē tipizētus notikumus, izmantojot yield, atstājot izsauktājziņai lēmumu, ko ar tiem darīt — parādīt, nosūtīt uz WebSocket vai ierakstīt datubāzē.

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:
    """Straumēšana ar automātisku atkārtošanu un metrikām."""
    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  # Eksponenciāla atkāpšanās
                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

Eksponenciālā atkāpšanās 2 ** attempt gaida 1 sekundi, tad 2, tad 4. Šī progresija nav dekoratīva: ja visi klienti atkārtotu mēģinājumus vienādā fiksētā ritmā, tie trāpītu API sinhronizētos viļņos un pagarinātu tieši to piesātinājumu, no kura cieš. Ņem vērā arī to, ka tikai 429 kļūda izraisa atkārtošanu — 401 kļūdas atkārtošana nederīgas atslēgas dēļ tikai aizkavētu diagnostiku.

Izsauktājziņas pusē patēriņš kļūst par vienkāršu notikumu lasīšanu:

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

Asinhrona straumēšana ar asyncio

Sinhronais klients bloķē savu pavedienu visas ģenerācijas laikā. Tīmekļa serverī, kam jāapstrādā piecdesmit vienlaicīgas sarunas, tas nozīmē piecdesmit pavedienu imobilizēšanu tikai gaidīšanai. Asinhronais klients noņem šo ierobežojumu:

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:
    """Asinhrona straumēšana vienlaicīgām lietotnēm."""
    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

# Izpilde
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())

Loģika ir identiska sinhrónajai versijai; mainās tikai stream_async, await izsaukumā un async for ciklā.

Integrācija ar FastAPI

Tālāk tev jāizvada šī straume no Python procesa uz pārlūkprogrammu. FastAPI to apstrādā ar StreamingResponse, ja vien pārformatē katru fragmentu uz SSE formātu, kas apskatīts iepriekšējā nodarbībā:

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 ģenerators priekš 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"
    )

Divas detaļas nosaka, vai šis galapunkts darbojas pareizi. Dubultā jaunrinda \n\n, kas beidz katru yield, ir tas, kas atdala notikumus SSE protokolā: bez tās pārlūks bezgalīgi gaida notikumu, ko tas uzskata par nepabeigtu. Un media_type="text/event-stream" ir tas, kas ļauj JavaScript klientam patērēt atbildi ar EventSource, nevis standarta fetch.

Veiktspējas mērīšana

Kad straume ir ieviesta, vēlēsies uzzināt, kā tā darbojas. Optimizēšanai pietiek ar divām metrikām:

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) — laiks starp pieprasījuma nosūtīšanu un pirmā rakstzīmes parādīšanu — ir vissvarīgākais lietotāja pieredzes rādītājs. Tam ir prioritāte pār kopējo laiku: piecpadsmit sekunžu ģenerēšana, kuras pirmais vārds parādās trīs desmitdaļās sekundes, šķitīs ātra, savukārt piecu sekunžu ģenerēšana, kas piegādāta vienā blokā, šķitīs lēna. Mēri to uz saviem reālajiem uzdevumiem, ieskaitot sistēmas ziņojumu — divu lappušu garš sistēmas ziņojums pagarina TTFT pat pirms pirmā tokena ģenerēšanas.

Galvenās atziņas

  • Izmanto ģeneratora paraugu (yield), lai izplatītu straumētos tokenus
  • Ievies eksponenciālu atkāpšanos 429 kļūdām (ātruma ierobežojums)
  • Vienlaicīgām tīmekļa lietotnēm dod priekšroku stream_async
  • Mēri TTFT un tokenus sekundē, lai optimizētu veiktspēju
  • Ar FastAPI StreamingResponse + text/event-stream nogādā SSE uz pārlūkprogrammu