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

Потоково предаване и инструменти

Урок 9 от 14 Обновен 29 юли 2026 г. Програмист
На тази страница
  1. Потоково предаване при извикване на функции
  2. Основното правило
  3. Имплементиране на потоково предаване с инструменти
  4. Реконструиране на извиквания на инструменти при потоково предаване
  5. Архитектура за потоково предаване с инструменти
  6. Латентност и потребителско изживяване
  7. Server-Sent Events (SSE) за уеб приложения
  8. Ключови изводи

Потоково предаване при извикване на функции

Потоковото предаване Ви позволява да получавате отговора на модела постъпателно, токен по токен. Това е от съществено значение за отзивчивите потребителски интерфейси. Но как взаимодейства потоковото предаване с извикването на функции?

Основното правило

Извикванията на функции се връщат в един единствен чанк, а не се предават прогресивно. Това е съществена разлика спрямо обикновения текст, който пристига токен по токен.

На практика:

  • Текстът на отговора се предава прогресивно
  • tool_calls пристигат изведнъж в едно събитие

Това ограничение съществува с добра причина: извикването на инструмент трябва да бъде пълно (име + валидни JSON аргументи), за да можете да го изпълните. Частичен JSON би бил неизползваем.

Имплементиране на потоково предаване с инструменти

stream = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    stream=True
)

collected_tool_calls = []
collected_content = ""

for chunk in stream:
    delta = chunk.choices[0].delta

    # Потоков текст
    if delta.content:
        collected_content += delta.content
        print(delta.content, end="", flush=True)

    # Извиквания на инструменти (пристигат в един блок)
    if delta.tool_calls:
        for tc in delta.tool_calls:
            collected_tool_calls.append(tc)

    # Проверка за край на потока
    if chunk.choices[0].finish_reason == "tool_calls":
        # Моделът очаква резултати от инструменти
        break
    elif chunk.choices[0].finish_reason == "stop":
        # Отговорът приключи, няма извикан инструмент
        break

Реконструиране на извиквания на инструменти при потоково предаване

В някои случаи аргументите за извикване на инструмент могат да пристигнат на няколко части в рамките на потока. Трябва да ги реконструирате:

tool_calls_buffer = {}

for chunk in stream:
    delta = chunk.choices[0].delta

    if delta.tool_calls:
        for tc_chunk in delta.tool_calls:
            idx = tc_chunk.index

            if idx not in tool_calls_buffer:
                tool_calls_buffer[idx] = {
                    "id": tc_chunk.id,
                    "function": {
                        "name": tc_chunk.function.name or "",
                        "arguments": ""
                    }
                }

            if tc_chunk.function.name:
                tool_calls_buffer[idx]["function"]["name"] = tc_chunk.function.name
            if tc_chunk.function.arguments:
                tool_calls_buffer[idx]["function"]["arguments"] += tc_chunk.function.arguments

Този подход с буфериране гарантира, че ще реконструирате правилно всяко извикване на инструмент, дори ако данните пристигнат фрагментирани.

Архитектура за потоково предаване с инструменти

В реално приложение трябва да обработвате два едновременни потока:

  1. Дисплей в реално време: показване на текста, докато пристига
  2. Натрупване на извиквания на инструменти: събиране на извикванията за изпълнение
async def handle_streaming_response(stream):
    content_parts = []
    tool_calls = []
    current_tool = None

    async for chunk in stream:
        delta = chunk.choices[0].delta

        if delta.content:
            content_parts.append(delta.content)
            yield {"type": "text", "data": delta.content}

        if delta.tool_calls:
            for tc in delta.tool_calls:
                tool_calls.append(tc)

        if chunk.choices[0].finish_reason == "tool_calls":
            # Изпълнение на инструментите и рестартиране
            results = await execute_tools(tool_calls)
            yield {"type": "tool_results", "data": results}

Латентност и потребителско изживяване

Потоковото предаване с инструменти включва естествени паузи в потока:

  1. Потребителят задава въпроса си
  2. Моделът започва да „мисли“ (няма видими токени)
  3. Моделът решава да извика инструмент (Вие получавате tool_call)
  4. Пауза — Вие изпълнявате функцията
  5. Вие изпращате резултата обратно
  6. Моделът генерира своя отговор (предаван прогресивно)

За потребителското изживяване показвайте индикатор по време на стъпка 4:

🔍 Търсене на времето в Париж...

Това предотвратява впечатлението у потребителя, че приложението е замръзнало.

Server-Sent Events (SSE) за уеб приложения

Ако изграждате уеб API, използвайте SSE, за да препредадете потока:

from fastapi import FastAPI
from fastapi.responses import StreamingResponse

app = FastAPI()

@app.get("/chat")
async def chat(message: str):
    async def event_stream():
        stream = client.chat.completions.create(
            model="grok-4.5",
            messages=[{"role": "user", "content": message}],
            tools=tools,
            stream=True
        )
        for chunk in stream:
            if chunk.choices[0].delta.content:
                yield f"data: {chunk.choices[0].delta.content}\n\n"

    return StreamingResponse(event_stream(), media_type="text/event-stream")

Ключови изводи

  • Извикванията на инструменти пристигат в един чанк, а не се предават прогресивно
  • Обикновеният текст продължава да се предава токен по токен
  • Реконструирайте фрагментираните извиквания на инструменти с буфер, индексиран по index
  • Обработвайте два потока паралелно: показване на текст + събиране на извиквания на инструменти
  • Показвайте индикатор по време на изпълнение на инструмента за по-добро потребителско изживяване
  • Използвайте SSE за уеб приложения