Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Streaming implementálása Pythonban

6. lecke 16 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Prototípustól a éles rendszerig
  2. Az alapsablon
  3. Átfogó hibakezelés
  4. Aszinkron streaming az asyncio segítségével
  5. Integráció FastAPI-val
  6. Teljesítmény mérése
  7. Főbb megállapítások

Prototípustól a éles rendszerig

Az előző leckében átvettük az SSE streaming alapfogalmait. A nehezebb rész még hátravan: hogyan alakítsd át a demonstrációs ciklust olyan klienssé, amely bírja a terhelést, túléli a hálózati hibákat, és képes kiszolgálni egy webes felületet. Ez a lecke egy valós projekt életútját követi nyomon: először a váz, majd a hibakezelés, az aszinkron működés, a HTTP elérhetővé tétel, végül pedig a mérések.

Az alapsablon

Minden ezzel a tízsoros vázzal kezdődik, amelyet minden projektnél testre szabhatsz. Ez egyszerre csinál két dolgot: megjeleníti a beérkező tokeneket, és összegyűjti őket a függvény visszatérési értékéhez.

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:
    """Streaming kérést küld, és valós időben megjeleníti a tokeneket."""
    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()  # Új sor
    return full_text

Ez a verzió helyi szkriptként működik. Éles környezetben azonban végzetes hibája van: a terminálra ír, így csak terminálos feladatokra használható.

Átfogó hibakezelés

A hálózati hibák, időtúllépések és sebességkorlátozások nem elméleti lehetőségek: valós forgalom mellett biztosra vehetők. Az alábbi kliens mindkét problémát kezeli. Automatikusan újrapróbálja a 429-es hibákat exponenciális visszalépéssel (exponential backoff), és már nem ír ki semmit a képernyőre: helyette típusos eseményeket bocsát ki a yield segítségével, így a hívó fél dönti el, mit kezd velük – megjeleníti, WebSocketen továbbítja, vagy adatbázisba írja.

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 automatikus újrapróbálással és metrikákkal."""
    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ális visszalépé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

Az exponenciális visszalépés (2 ** attempt) először 1 másodpercet, majd 2-t, majd 4-et vár. Ez a progresszió nem díszítés: ha minden kliensed ugyanabban a fix ritmusban próbálná újra, szinkronizált hullámokban érnék el az API-t, és csak elhúznák azt a telítettséget, amitől szenvednek. Jegyezd meg azt is, hogy csak a 429-es hiba vált ki újrapróbálkozást – egy érvénytelen kulcs miatti 401-es hiba újrapróbálása csak késleltetné a hiba diagnosztizálását.

A hívó oldalon a fogyasztás egyszerű eseményolvasássá válik:

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

Aszinkron streaming az asyncio segítségével

A szinkron kliens a teljes generálás idejére blokkolja a szálat. Egy olyan webkiszolgálón, amelynek ötven egyidejű beszélgetést kell kezelnie, ez azt jelenti, hogy ötven szálat immobilizálsz pusztán a várakozás miatt. Az aszinkron kliens feloldja ezt a korlátot:

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:
    """Aszinkron streaming párhuzamos alkalmazásokhoz."""
    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

# Végrehajtás
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())

A logika megegyezik a szinkron verzióéval; csak a stream_async, a híváson lévő await, valamint a cikluson lévő async for változik.

Integráció FastAPI-val

Ezután ki kell juttatnod ezt a streamet a Python folyamatodból a böngészőbe. A FastAPI ezt a StreamingResponse segítségével kezeli, feltéve, hogy minden fragmentumot az előző leckében látott SSE formátumba alakítasz át:

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

Két részlet dönti el, hogy ez a végpont helyesen működik-e. A dupla új sor (\n\n), amely lezár minden yield-et, választja el az eseményeket az SSE protokollban: enélkül a böngésző végtelenül várna egy olyan eseményre, amelyet befejezetlennek tekint. A media_type="text/event-stream" pedig lehetővé teszi, hogy a JavaScript kliens egy szabványos fetch helyett EventSource segítségével fogyasztsa a választ.

Teljesítmény mérése

Ha a stream már működik, tudni szeretnéd, hogyan teljesít. Két metrika elég a optimalizálás irányításához:

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

A TTFT (Time to First Token) – azaz a kérés elküldése és az első karakter megjelenítése között eltelt idő – a legfontosabb metrika a felhasználói élmény szempontjából. Ez elsőbbséget élvez a teljes idővel szemben: egy tizenöt másodperces generálás, amelynek első szava háromtized másodperc alatt megjelenik, gyorsnak tűnik, míg egy öt másodperces generálás, amely egyben érkezik, lassúnak hat. Mérd ezt a valós promptjaidon, beleértve a rendszerüzenetet is – egy kétoldalas rendszerüzenet meghosszabbítja a TTFT-t, még mielőtt az első token megszületne.

Főbb megállapítások

  • Használj generátor mintát (yield) a streaming tokenek továbbításához
  • Implementálj exponenciális visszalépést a 429-es hibákhoz (sebességkorlátozás)
  • Részesítsd előnyben a stream_async-ot párhuzamos webalkalmazásoknál
  • Mérd a TTFT-t és a másodpercenkénti tokenek számát a teljesítmény optimalizálásához
  • FastAPI esetén a StreamingResponse és a text/event-stream kombináció juttatja el az SSE-t a böngészőbe