Válaszok streamelése Pythonban
Ezen az oldalon
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.
| Szempont | chat.complete() | chat.stream() |
|---|---|---|
| Visszatérési érték | Teljes objektum | Darabok iterátora |
| Érzékelt késleltetés | Magas (teljes várakozás) | Alacsony (gyors első token) |
| Szöveg elérése | response.choices[0].message.content | chunk.data.choices[0].delta.content |
| Tokenhasználat | Elérhető a válaszban | Elé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.contenthelyen található - Használd a
flush=Trueparamétert aprint()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