Оптимизирано стрийминг предаване
На тази страница
Какво всъщност променя стриймингът
Стриймингът не прави модела по-бърз: той прави очакването по-поносимо. При отговор, чието генериране отнема пет секунди, потребителят без стрийминг гледа празен екран цели пет секунди, преди да получи блок текст. При стрийминг той вижда първите думи след няколкостотин милисекунди и чете успоредно с писането на модела. Общата продължителност е идентична, но възприятието е коренно различно. Ето защо в производствена среда пропускането на стрийминг почти винаги е проектен дефект, а не съзнателен избор.
Въпреки това потокът трябва да преминава през цялата ви верига. Стрийминг, генериран правилно от API, но натрупан от вашия приложение сървър или буфериран от вашия reverse proxy, достига до потребителя като единичен блок: платили сте цената на сложността за стрийминг, без да пожънете ползите. Затова този урок следва пълния път – от API повикването до браузъра.
Консумиране на стрийма от страна на клиента
При Responses API задаването на stream=True трансформира отговора в поредица от типизирани събития, през които итерирате, докато пристигат. Всеки текстов фрагмент идва в събитие response.output_text.delta; краят на потока се сигнализира от response.completed, което носи пълния обект на отговора, полезен за извличане на използването на токени.
import openai
client = openai.OpenAI()
def generate_streaming(prompt: str):
"""Генериране със стрийминг чрез Responses API."""
stream = client.responses.create(
model="gpt-5.6-terra",
input=prompt,
stream=True,
)
for event in stream:
if event.type == "response.output_text.delta":
print(event.delta, end="", flush=True)
elif event.type == "response.completed":
print() # Нов ред в края
return event.response
Флагът flush=True не е козметичен: без него Python сам буферира изхода и в крайна сметка получавате блоковото поведение, което сте се опитвали да избегнете. Този детайл се повтаря на всеки слой от веригата и това е основната трудност при стрийминга.
Механизмът обхваща и извиквания на функции. Аргументите на инструментите се изграждат прогресивно и можете да ги показвате, докато се генерират, за да сигнализирате на потребителя, че се формулира търсене, вместо да го оставите да гледа замръзнал интерфейс, докато моделът подготвя своето извикване.
tools = [
{
"type": "function",
"name": "search_product",
"description": "Searches for a product in the catalog.",
"parameters": {
"type": "object",
"properties": {
"query": {"type": "string"},
"category": {"type": "string"},
},
"required": ["query"],
},
}
]
def streaming_with_tools(prompt: str):
stream = client.responses.create(
model="gpt-5.6-terra",
input=prompt,
tools=tools,
stream=True,
)
for event in stream:
match event.type:
case "response.output_text.delta":
print(event.delta, end="", flush=True)
case "response.function_call_arguments.delta":
# Аргументи на функцията, които се генерират в момента
print(f"[arg: {event.delta}]", end="")
case "response.function_call_arguments.done":
print(f"\n[Function call complete]")
Препредаване на стрийма към браузъра
Вашият фронтенд не говори директно с OpenAI API – той говори с вашия сървър, който следователно трябва да препредаде стрийма. Server-Sent Events (SSE) са естественият формат за това: HTTP отговор, който остава отворен, където всеки ред data: носи JSON фрагмент. Следващият пример препредава текста, докато пристига, след което изпраща финално съобщение, съдържащо броя токени, което ви позволява да таксувате или логвате без второ повикване.
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
import openai
import json
app = FastAPI()
client = openai.OpenAI()
@app.post("/api/chat")
async def chat_streaming(request: dict):
prompt = request["message"]
async def generate():
stream = client.responses.create(
model="gpt-5.6-terra",
input=prompt,
stream=True,
)
for event in stream:
if event.type == "response.output_text.delta":
data = json.dumps({"text": event.delta})
yield f"data: {data}\n\n"
elif event.type == "response.completed":
usage = event.response.usage
data = json.dumps({
"end": True,
"input_tokens": usage.input_tokens,
"output_tokens": usage.output_tokens,
})
yield f"data: {data}\n\n"
return StreamingResponse(
generate(),
media_type="text/event-stream",
headers={
"Cache-Control": "no-cache",
"X-Accel-Buffering": "no", # Важно за nginx
},
)
След това идва reverse proxy – обичайният заподозрян, когато „стриймингът не работи в продукция, въпреки че работеше локално“. По подразбиране nginx натрупва отговора от бекенда, преди да го предаде. Конфигурацията по-долу деактивира това поведение само за конкретния маршрут.
location /api/chat {
proxy_pass http://127.0.0.1:8000;
proxy_buffering off;
proxy_cache off;
proxy_set_header Connection "";
chunked_transfer_encoding on;
}
Поддържане на връзката във времето
Връзка, отворена за няколко десетки секунди, е по-изложена от кратко повикване: прекъсване на мрежата, достигане на квота и генерирането спира посред изречение. Вашата стратегия за повторни опити трябва да прави разлика между тези два случая, защото те изискват различни подходи. Грешка във връзката трябва да бъде повторена с експоненциално забавяне (exponential backoff), давайки време на мрежата да се възстанови, без да тормози API; надвишаване на квота трябва да бъде повторено след фиксирано изчакване, тъй като прозорецът за ограничаване на скоростта се нулира на редовни интервали.
import openai
def resilient_streaming(prompt: str, max_attempts: int = 3):
"""Стрийминг с обработка на грешки и повторни опити."""
for attempt in range(max_attempts):
try:
stream = client.responses.create(
model="gpt-5.6-terra",
input=prompt,
stream=True,
)
full_text = ""
for event in stream:
if event.type == "response.output_text.delta":
full_text += event.delta
yield event.delta
return # Успех, изход
except openai.APIConnectionError:
if attempt < max_attempts - 1:
import time
time.sleep(2 ** attempt) # Експоненциално забавяне
else:
raise
except openai.RateLimitError:
import time
time.sleep(5) # Фиксирано изчакване за ограничение на скоростта
Една последна настройка подобрява комфорта на четене. Изпращането на всеки токен произвежда накъсан текст, особено ако вашият интерфейс прилага анимация или ако резултатът отива към текст-към-говор. Натрупването до края на изречението дава ритъм, по-близък до човешкото четене, с цената на леко допълнително забавяне на първия фрагмент.
def streaming_by_sentence(prompt: str):
"""Натрупва и връща по цели изречения."""
buffer = ""
stream = client.responses.create(
model="gpt-5.6-terra",
input=prompt,
stream=True,
)
for event in stream:
if event.type == "response.output_text.delta":
buffer += event.delta
# Търсене на край на изречение
for separator in [".\n", "!\n", "?\n", ". ", "! ", "? "]:
if separator in buffer:
parts = buffer.split(separator, 1)
yield parts[0] + separator.rstrip()
buffer = parts[1] if len(parts) > 1 else ""
if buffer.strip():
yield buffer.strip()
Обърнете внимание на крайното if buffer.strip(): без него отговор, който не завършва със силна пунктуация, би загубил последните си думи. Този вид пропуск остава незабелязан при тестване и се проявява в продукция при отговори, съкратени от max_output_tokens.
Ключови изводи
- Винаги използвайте стрийминг в продукция, за да намалите възприеманата латентност
- Конфигурирайте nginx с
proxy_buffering offза SSE - Обработвайте грешките с повторни опити и експоненциално забавяне
- Натрупвайте по изречения за по-естествено показване