Поточно предаване чрез SSE
На тази страница
Отговори в реално време със Server-Sent Events
По подразбиране API за Chat Completions изчаква моделът да завърши генерирането на целия си отговор, преди да го изпрати обратно към Вас. За кратък въпрос никой не забелязва забавянето. За доклад от хиляда думи обаче това означава няколко секунди празен екран, което кара потребителя да се чуди дали приложението не е блокирало. Поточното предаване решава този проблем, като изпраща токените веднага щом бъдат генерирани, създавайки познатия ефект на пишеща машина, срещан в разговорните интерфейси.
Използваният протокол е Server-Sent Events (SSE) – HTTP стандарт, който позволява на сървъра да изпраща данни към клиента непрекъснато през постоянна връзка. Тук няма нищо екзотично: няма WebSockets за инсталиране, няма допълнителни зависимости.
Поточно предаване срещу непоточно предаване
В режим без поточно предаване, който е по подразбиране, клиентът изпраща заявката и изчаква пълния отговор:
Client ──── request ────► Server
(wait 3-10s)
Client ◄── complete response ── Server
Предимството е простотата: отговорът е атомен, един единствен JSON обект, който лесно се обработва, валидира и съхранява. Недостатъкът е също толкова очевиден: възприеманата латентност е висока, защото потребителят не вижда нищо по време на целия процес на генериране.
В режим на поточно предаване сървърът изпраща токените един по един или на малки групи:
Client ──── request ────► Server
Client ◄── chunk 1 ─────── Server (after ~200ms)
Client ◄── chunk 2 ─────── Server (after ~250ms)
Client ◄── chunk 3 ─────── Server (after ~300ms)
...
Client ◄── [DONE] ──────── Server
Възприеманата латентност намалява драстично – първият символ се появява в рамките на няколкостотин милисекунди, което значително подобрява потребителското изживяване. В замяна обаче трябва да реконструирате съобщението от страна на клиента и да управлявате състояние, което вече не пристига като единен блок.
Протоколът SSE в детайли
Ето как всъщност изглежда HTTP потокът, който получавате:
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]
Всеки ред започва с data: , следван от JSON обект, а празните редове служат като разделители между събитията. Обърнете внимание на детайла, в който всички попадат при първата си реализация: текстовият фрагмент се намира в полето delta, а не в message, както е в класическия режим. Потокът завършва със събитието data: [DONE], което изрично сигнализира края. Без него не бихте могли да различите завършено генериране от прекъсната връзка.
Активиране на поточно предаване в Python
С Mistral SDK активирате поточното предаване, като извиквате chat.stream() вместо chat.complete():
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
Аргументът flush=True заслужава обяснение, тъй като пропускането му е класическата причина поточното предаване да „не работи“. Без него Python държи символите в буфера и ги показва на блокове. Това визуално анулира всички предимства на поточното предаване, въпреки че чанковете пристигат правилно.
Структура на чанк (chunk)
Поточният чанк не се чете като пълен отговор и пътищата за достъп са различни:
# 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"
Първият чанк обикновено носи ролята без текст, следващите носят фрагментите, а последният предоставя finish_reason. Ето защо проверката if content: в предишния код не е излишна предпазна мярка: конкатенирането на стойност None би довело до срив на цикъла още при първата итерация.
Реконструиране на пълния отговор
Показването на фрагменти не е достатъчно, когато трябва да запазите отговора – например, за да го добавите към историята на разговора, да го регистрирате или съхраните в база данни. Затова трябва да натрупвате текста успоредно с показването му:
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)")
Променливата finish_reason се улавя в същия цикъл по същата причина, както и в класическия режим: отговор, съкратен от max_tokens, се появява на екрана точно като пълен отговор и само това поле ще Ви покаже разликата.
Кога да използвате поточно предаване
Поточното предаване не винаги е по-добро. То е препоръчително, когато човек наблюдава екрана, но е излишно или дори вредно, когато машина обработва изхода.
| Случай на употреба | Препоръка |
|---|---|
| Интерактивен чатбот | Поточно предаване (по-добро UX) |
| Пакетна обработка | Без поточно предаване (по-просто) |
| Backend API за фронтенд | Поточно предаване (SSE към браузъра) |
| Data pipeline | Без поточно предаване (атомна обработка) |
| Структурирано извличане | Без поточно предаване (по-надежден JSON парсинг) |
Последният случай е най-поучителен. Ако очаквате JSON, поточното предаване не добавя нищо: не можете да анализирате непълен обект и така или иначе ще трябва да изчакате последния фрагмент. По-добре запазете извикването атомно и кода прост.
Ключови изводи
- Поточното предаване намалява възприеманата латентност, като изпраща токените веднага щом бъдат генерирани
- Протоколът SSE е прост и надежден HTTP стандарт
- В режим на поточно предаване използвайте
delta.contentвместоmessage.content - Натрупвайте фрагментите от страна на клиента, за да реконструирате пълния отговор
- Предпочитайте поточно предаване за потребителски интерфейси, а непоточно – за автоматизирана обработка