Streaming SSE
Ezen az oldalon
Valós idejű válaszok Server-Sent Events segítségével
Alapértelmezés szerint a Chat Completions API megvárja, amíg a modell teljesen befejezi a válasz generálását, mielőtt visszaküldené azt neked. Egy rövid kérdés esetén senki nem veszi észre a késleltetést. Egy ezer szavas jelentés esetén azonban ez több másodpercnyi üres képernyőt jelent, amitől a felhasználód azt hiheti, hogy az alkalmazás lefagyott. A streaming megoldja ezt a problémát azáltal, hogy a tokeneket generálás közben küldi el, létrehozva azt a beszélgető felületekről ismerős írógép-hatást.
A használt protokoll a Server-Sent Events (SSE), egy HTTP-szabvány, amely lehetővé teszi a szerver számára, hogy folyamatos kapcsolaton keresztül adatokat küldjön a kliensnek. Nincs itt semmi egzotikus: nincs szükség WebSocket telepítésére, nincs szükség extra függőségekre.
Streaming vs. nem streaming mód
Nem streaming módban, ami az alapértelmezett, a kliens elküldi a kérést, és megvárja a teljes választ:
Client ──── request ────► Server
(wait 3-10s)
Client ◄── complete response ── Server
Előnye az egyszerűség: a válasz atomi, egyetlen JSON-objektum, amelyet könnyű feldolgozni, validálni és tárolni. A hátrány ugyanilyen egyértelmű: az érzékelt késleltetés magas, mert a felhasználó a teljes generálási folyamat alatt semmit sem lát.
Streaming módban a szerver tokenenként vagy kis csoportokban küldi az adatokat:
Client ──── request ────► Server
Client ◄── chunk 1 ─────── Server (after ~200ms)
Client ◄── chunk 2 ─────── Server (after ~250ms)
Client ◄── chunk 3 ─────── Server (after ~300ms)
...
Client ◄── [DONE] ──────── Server
Az érzékelt késleltetés drasztikusan csökken – az első karakter néhány száz milliszekundumon belül megjelenik –, ami jelentősen javítja a felhasználói élményt. Cserébe neked kell újraösszeraknod az üzenetet a kliens oldalon, és kezelned az állapotot, amely már nem egyetlen blokkként érkezik.
Az SSE protokoll részletesen
Így néz ki valójában a fogadott HTTP adatfolyam:
data: {"id":"cmpl-abc","choices":[{"delta":{"content":"Hello"}}],"usage":null}
data: {"id":"cmpl-abc","choices":[{"delta":{"content":" "}}],"usage":null}
data: {"id":"cmpl-abc","choices":[{"delta":{"content":"!"}}],"usage":null}
data: [DONE]
Minden sor a data: karaktersorozattal kezdődik, amelyet egy JSON-objektum követ, az üres sorok pedig elválasztóként szolgálnak az események között. Figyeld meg azt a részletet, amelybe mindenki belebukik az első implementáció során: a szövegrészlet a delta mezőben található, nem a message mezőben, mint a klasszikus módban. Az adatfolyam egy data: [DONE] eseménnyel végződik, amely expliciten jelzi a befejezést. Enélkül nem tudnád megkülönböztetni a befejezett generálást a megszakadt kapcsolattól.
A streaming engedélyezése Pythonban
A Mistral SDK-val a streaminget úgy engedélyezed, hogy a chat.complete() helyett a chat.stream() metódust hívod meg:
from mistralai.client import Mistral
import os
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
stream = client.chat.stream(
model="mistral-large-latest",
messages=[
{"role": "user", "content": "Explain how an electric motor works."}
]
)
for chunk in stream:
content = chunk.data.choices[0].delta.content
if content:
print(content, end="", flush=True)
print() # Final newline
A flush=True argumentum magyarázatra szorul, mivel ennek elfelejtése a streaming „nem működik“ jellegű hibák klasszikus oka. Enélkül a Python a pufferekben tartja a karaktereket, és blokkokban jeleníti meg őket. Ez vizuálisan megszünteti a streaming összes előnyét, még akkor is, ha a chunkok megfelelően érkeznek.
Egy chunk szerkezete
Egy streaming chunk nem úgy olvasható, mint egy teljes válasz, és a hozzáférési utak is eltérnek:
# Non-streaming: response.choices[0].message.content
# Streaming: chunk.data.choices[0].delta.content
# The first chunk often contains the role
# chunk.data.choices[0].delta.role == "assistant"
# Subsequent chunks contain text fragments
# chunk.data.choices[0].delta.content == "Hello"
# The last chunk contains finish_reason
# chunk.data.choices[0].finish_reason == "stop"
Az első chunk általában a szerepet tartalmazza szöveg nélkül, a következők a szövegrészleteket, az utolsó pedig a finish_reason értéket szolgáltatja. Ezért nem felesleges óvintézkedés az előző kódban szereplő if content: ellenőrzés: egy None érték összefűzése miatt a ciklus már az első iterációnál elbukna.
A teljes válasz újraösszerakása
A részletek megjelenítése nem elég, ha meg kell őrizned a választ – például hogy hozzáadd a beszélgetés előzményeihez, naplózd, vagy elmentsd egy adatbázisba. Ezért párhuzamosan kell felhalmoznod a szöveget a megjelenítéssel:
from mistralai.client import Mistral
import os
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
stream = client.chat.stream(
model="mistral-large-latest",
messages=[{"role": "user", "content": "List 5 programming languages."}]
)
full_response = ""
finish_reason = None
for chunk in stream:
delta = chunk.data.choices[0].delta
if delta.content:
full_response += delta.content
print(delta.content, end="", flush=True)
if chunk.data.choices[0].finish_reason:
finish_reason = chunk.data.choices[0].finish_reason
print(f"\n\nFinish reason: {finish_reason}")
print(f"Complete response ({len(full_response)} characters)")
A finish_reason változót ugyanazon okból rögzítjük ugyanabban a ciklusban, mint a klasszikus módban: a max_tokens által csonkított válasz pontosan úgy jelenik meg a képernyőn, mint egy teljes válasz, és csak ez a mező árulja el a különbséget.
Mikor használj streaminget?
A streaming nem mindig jobb. Ott javasolt, ahol emberi szem figyeli a képernyőt, de felesleges, sőt káros, amikor egy gép dolgozza fel a kimenetet.
| Használati eset | Ajánlás |
|---|---|
| Interaktív chatbot | Streaming (jobb UX) |
| Köteges feldolgozás | Nem streaming (egyszerűbb) |
| Backend API frontendhez | Streaming (SSE a böngésző felé) |
| Adatfolyamat (Data pipeline) | Nem streaming (atomi feldolgozás) |
| Strukturált kinyerés | Nem streaming (megbízhatóbb JSON-elemzés) |
Az utolsó eset a legtanulságosabb. Ha JSON-t vársz, a streaming nem ad hozzá semmit: nem tudsz egy hiányos objektumot elemezni, és amúgy is meg kell várnod az utolsó részletet. Érdemes tehát atomi hívást megtartani, és a kódot egyszerűen hagyni.
Főbb megállapítások
- A streaming csökkenti az érzékelt késleltetést azáltal, hogy a tokeneket generálás közben küldi el
- Az SSE protokoll egy egyszerű és robusztus HTTP-szabvány
- Streaming módban a
delta.contenthasználandó amessage.contenthelyett - Halmozd fel a részleteket a kliens oldalon a teljes válasz újraösszerakásához
- Részesítsd előnyben a streaminget a felhasználói felületeknél, a nem streaminget pedig az automatizált feldolgozásnál