Премини към основното съдържание
Български— Изберете език
Меню

Поточно предаване чрез SSE

Урок 5 от 16 Обновен 2 ноември 2026 г. Програмист
На тази страница
  1. Отговори в реално време със Server-Sent Events
  2. Поточно предаване срещу непоточно предаване
  3. Протоколът SSE в детайли
  4. Активиране на поточно предаване в Python
  5. Структура на чанк (chunk)
  6. Реконструиране на пълния отговор
  7. Кога да използвате поточно предаване
  8. Ключови изводи

Отговори в реално време със 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
  • Натрупвайте фрагментите от страна на клиента, за да реконструирате пълния отговор
  • Предпочитайте поточно предаване за потребителски интерфейси, а непоточно – за автоматизирана обработка