Поточни отговори в Python
На тази страница
Проблемът, който решава поточната предаване
При използване на chat.complete() чакате моделът да генерира целия си отговор, преди да получите дори един единствен символ. За кратък отговор това забавяне остава незабелязано. Но при подробен анализ, дълъг фрагмент код или разсъждения, състоящи се от множество абзаци, потребителят гледа в празен екран в продължение на няколко секунди. В чат интерфейс дори няколко секунди тишина могат да накарат приложението да изглежда замръзнало.
Поточната предаване (Streaming) променя това възприятие: отговорът пристига постепенно, парче по парче, и се показва прогресивно, точно както в познатите Ви чат интерфейси. Общото време за генериране не намалява с нито милисекунда, но първата дума се появява почти веднага. Именно това начално забавяне е това, което потребителят усеща реално.
Използване на chat.stream()
Mistral SDK V2 предоставя метода chat.stream(), който връща итератор на частици (chunks) вместо един единствен обект:
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()
Два детайла правят цялата разлика в този цикъл. Проверката if content е от съществено значение, защото някои частици пристигат без текст и иначе биха отпечатали None. А flush=True принуждава Python да запише незабавно в изхода, вместо да чака буферът му да се запълни. Без това целият текст би се появил наведнъж в края, което напълно обезсмисля ползата, която търсите.
| Аспект | chat.complete() | chat.stream() |
|---|---|---|
| Връща | Пълен обект | Итератор на частици |
| Възприемана латентност | Висока (цялото чакане) | Ниска (бърз първи токен) |
| Достъп до текст | response.choices[0].message.content | chunk.data.choices[0].delta.content |
| Използване на токени | Налично в отговора | Налично в последната частица |
Какво съдържа една частица
Всяка частица носи делта, което означава фрагмент от отговора, който се изгражда. Чрез инспектирането ѝ получавате достъп както до текста, така и до метаданните за края на потока:
for chunk in stream:
delta = chunk.data.choices[0].delta
# Text content (can be None for some chunks)
text = delta.content
# Stop reason (None except for the last chunk)
end = chunk.data.choices[0].finish_reason
if text:
print(text, end="", flush=True)
if end:
print(f"\n[Stream end: {end}]")
Потокът винаги следва една и съща хореография: първата частица обикновено носи ролята assistant, междинните частици доставят текста на малки парченца, а последната предоставя finish_reason. Чрез проверка на тази последна частица определяте дали отговорът е приключил нормално или е бил прекъснат от max_tokens.
Едновременно показване и запазване
Поточната предаване има един недостатък: текстът се превърта, но не го задържате никъде. Въпреки това едно реално приложение често се нуждае да архивира отговора в база данни за история на разговора. Решението е да натрупвате фрагментите, докато ги показвате:
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()
# The reconstituted full response
final_text = "".join(full_response)
print(f"\nTotal length: {len(final_text)} characters")
Обърнете внимание на използването на списък, последван от финално "".join(), вместо конкатенация на низове във всяка итерация на цикъла. При дълъг отговор последният подход копира целия натрупан текст за всеки получен фрагмент, което е неефективно.
Асинхронният вариант
В уеб сървър – FastAPI, aiohttp – синхронната версия блокира нишката по време на цялото генериране, замразявайки други текущи заявки. Затова SDK предоставя chat.stream_async():
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())
Структурата е идентична със синхронната версия, с изключение на ключовите думи await и async for. Веднага щом кодът Ви работи в уеб сървър, това е вариантът, който трябва да използвате.
Кога да използвате поточна предаване и кога да я пропуснете
В чат интерфейс поточната предаване е винаги задължителна: става въпрос за комфорта на четене. От страна на бекенд API, си струва да я активирате, стига фронтендът Ви да може да консумира Server-Sent Events. За всеки отговор, по-дълъг от няколко изречения, печалбата във възприеманата латентност оправдава добавената сложност. Обратно, в скрипт за пакетна обработка, който обработва хиляда документа и записва резултатите във файл, никой не гледа екрана: chat.complete() остава по-прост и напълно адекватен.
Ключови изводи
chat.stream()връща итератор на частици за прогресивно показване- Съдържанието се намира в
chunk.data.choices[0].delta.content - Използвайте
flush=Trueвъв Вашите обаждания наprint()за показване в реално време - Възстановете пълния отговор чрез натрупване на частици, ако е необходимо
- Асинхронната версия
chat.stream_async()се препоръчва за уеб приложения