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

Válaszok streamelése Pythonban

6. lecke 14 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. A probléma, amit a streamelés megold
  2. A chat.stream() használata
  3. Mit tartalmaz egy darab (chunk)?
  4. Megjelenítés és mentés egyszerre
  5. Az aszinkron változat
  6. Mikor streamelj, és mikor hagyd ki?
  7. Főbb megállapítások

A probléma, amit a streamelés megold

A chat.complete() használatakor meg kell várnod, amíg a modell teljes választ generál, mielőtt egyetlen karaktert is kapnál. Rövid válasz esetén ez a késés észrevétlen marad. Részletes elemzés, hosszú kódrészlet vagy több bekezdésből álló érvelés esetén azonban a felhasználó több másodpercig bámul egy üres képernyőt. Egy csevegőfelületen már néhány másodpercnyi csend is azt a benyomást kelti, mintha az alkalmazás lefagyott volna.

A streamelés megváltoztatja ezt az érzékelést: a válasz fokozatosan, darabonként érkezik, és folyamatosan jelenik meg, pontosan úgy, ahogy a megszokott csevegőfelületeken láthatod. A teljes generálási idő milliszekundummal sem csökken, de az első szó szinte azonnal megjelenik. A felhasználó valójában ezt a kezdeti késést érzi.

A chat.stream() használata

A Mistral SDK V2 exposeálja a chat.stream() metódust, amely egyetlen objektum helyett darabok (chunkok) iterátorát adja vissza:

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

stream = client.chat.stream(
    model="mistral-small-latest",
    messages=[
        {
            "role": "user",
            "content": "Describe the steps to deploy a Flask application on a Linux server."
        }
    ]
)

for chunk in stream:
    content = chunk.data.choices[0].delta.content
    if content:
        print(content, end="", flush=True)

# Final newline
print()

Ebben a ciklusban két részlet teszi igazán szabaddá a különbséget. Az if content ellenőrzés elengedhetetlen, mert egyes darabok szöveg nélkül érkeznek, ami egyébként None értéket írna ki. A flush=True pedig arra kényszeríti a Pythont, hogy azonnal kiírja az adatot a kimenetre, ahelyett, hogy megvárná, míg a puffer megtelik. Enélkül az összes szöveg egyetlen blokkban jelenne meg a végén, teljesen megszüntetve azt az előnyt, amit el akarsz érni.

Szempontchat.complete()chat.stream()
Visszatérési értékTeljes objektumDarabok iterátora
Érzékelt késleltetésMagas (teljes várakozás)Alacsony (gyors első token)
Szöveg eléréseresponse.choices[0].message.contentchunk.data.choices[0].delta.content
TokenhasználatElérhető a válaszbanElérhető az utolsó darabban

Mit tartalmaz egy darab (chunk)?

Minden darab egy deltát hordoz, ami a válasz alatt álló töredékét jelenti. Ennek vizsgálatával hozzáférhetsz mind a szöveghez, mind a stream végére vonatkozó metaadatokhoz:

for chunk in stream:
    delta = chunk.data.choices[0].delta

    # Szöveges tartalom (néhány darabnál lehet None)
    text = delta.content

    # Leállási ok (None, kivéve az utolsó darabnál)
    end = chunk.data.choices[0].finish_reason

    if text:
        print(text, end="", flush=True)

    if end:
        print(f"\n[Stream end: {end}]")

A folyamat mindig ugyanazt a koreográfiát követi: az első darab általában az assistant szerepet hordozza, a közbenső darabok kis részletekben szállítják a szöveget, az utolsó pedig a finish_reason értéket adja meg. Ezen az utolsó darabon ellenőrizheted, hogy a válasz normálisan fejeződött-e be, vagy a max_tokens miatt vágták-e le.

Megjelenítés és mentés egyszerre

A streamelésnek van egy hátránya: a szöveg végiggörög, de sehol sem tartod meg. Egy valós alkalmazásnak azonban gyakran archiválnia kell a választ egy adatbázisban a beszélgetési előzmények érdekében. A megoldás az, hogy a megjelenítés közben felhalmozod a töredékeket:

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

stream = client.chat.stream(
    model="mistral-small-latest",
    messages=[
        {"role": "user", "content": "List five Python web frameworks."}
    ]
)

full_response = []

for chunk in stream:
    content = chunk.data.choices[0].delta.content
    if content:
        full_response.append(content)
        print(content, end="", flush=True)

print()

# Az újraösszeállított teljes válasz
final_text = "".join(full_response)
print(f"\nTotal length: {len(final_text)} characters")

Figyeld meg, hogy lista használatát követi egy végső "".join(), nem pedig karakterlánc-összefűzést minden ciklusiterációban. Hosszú válasz esetén az utóbbi megközelítés minden egyes kapott töredéknél lemásolja az összes addig felhalmozott szöveget, ami inefficiens.

Az aszinkron változat

Egy webszerverben – FastAPI, aiohttp – a szinkron verzió blokkolja a szálat a teljes generálás alatt, ezzel megfagyasztva a többi folyamatban lévő kérést. Az SDK ezért biztosítja a chat.stream_async() metódust:

import asyncio
import os
from mistralai.client import Mistral

async def generate_response():
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

    stream = await client.chat.stream_async(
        model="mistral-small-latest",
        messages=[
            {"role": "user", "content": "Explain the concept of a coroutine in Python."}
        ]
    )

    async for chunk in stream:
        content = chunk.data.choices[0].delta.content
        if content:
            print(content, end="", flush=True)

    print()

asyncio.run(generate_response())

A szerkezet megegyezik a szinkron verzióval, kivéve az await és az async for kulcsszavakat. Amint a kódod webszerverben fut, ezt a változatot kell használnod.

Mikor streamelj, és mikor hagyd ki?

Egy csevegőfelületen a streamelés mindig kötelező: az olvasási kényelem forog kockán. A backend API oldalán érdemes bekapcsolni, amennyiben a frontended képes fogyasztani a Server-Sent Events eseményeket. Néhány mondatnál hosszabb válaszok esetén az érzékelt késleltetésben elért nyereség igazolja a hozzáadott komplexitást. Ezzel szemben egy kötegelt szkriptben, amely ezer dokumentumot dolgoz fel és ír eredményt fájlba, senki nem figyeli a képernyőt: itt a chat.complete() egyszerűbb és teljesen megfelelő marad.

Főbb megállapítások

  • A chat.stream() darabok iterátorát adja vissza a fokozatos megjelenítéshez
  • A tartalom a chunk.data.choices[0].delta.content helyen található
  • Használd a flush=True paramétert a print() hívásokban a valós idejű megjelenítéshez
  • Szükség esetén a darabok felhalmozásával állítsd vissza a teljes választ
  • A webszerveres alkalmazásokhoz az aszinkron chat.stream_async() verzió ajánlott