Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Streamování a nástroje

Lekce 9 z 14 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Streamování při volání funkcí
  2. Základní pravidlo
  3. Implementace streamování s nástroji
  4. Rekonstrukce volání nástrojů při streamování
  5. Architektura pro streamování s nástroji
  6. Latence a uživatelská zkušenost
  7. Server-Sent Events (SSE) pro webové aplikace
  8. Klíčové poznatky

Streamování při volání funkcí

Streamování ti umožňuje přijímat odpověď modelu postupně, token po tokenu. To je zásadní pro responzivní uživatelská rozhraní. Jak ale streamování spolupracuje s voláním funkcí?

Základní pravidlo

Volání funkcí se vrací v jediném bloku, nikoliv postupně po částech. To je zásadní rozdíl oproti běžnému textu, který přichází token po tokenu.

V praxi to znamená:

  • Odpověď ve formě textu je streamována postupně
  • tool_calls dorazí najednou v jedné události

Toto omezení má svůj důvod: volání nástroje musí být úplné (název + platné argumenty ve formátu JSON), abys ho mohl provést. Částečný JSON by byl nepoužitelný.

Implementace streamování s nástroji

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

    # Streamovaný text
    if delta.content:
        collected_content += delta.content
        print(delta.content, end="", flush=True)

    # Volání nástrojů (přicházejí v jednom bloku)
    if delta.tool_calls:
        for tc in delta.tool_calls:
            collected_tool_calls.append(tc)

    # Kontrola konce streamu
    if chunk.choices[0].finish_reason == "tool_calls":
        # Model očekává výsledky nástrojů
        break
    elif chunk.choices[0].finish_reason == "stop":
        # Odpověď dokončena, žádný nástroj nebyl zavolán
        break

Rekonstrukce volání nástrojů při streamování

V některých případech mohou argumenty volání nástroje dorazit ve streamu v několika částech. Musíš je znovu sestavit:

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

Tento přístup s vyrovnávací pamětí zajišťuje správnou rekonstrukci každého volání nástroje, i když data přicházejí roztříštěná.

Architektura pro streamování s nástroji

V reálné aplikaci musíš zpracovávat dva simultánní proudy dat:

  1. Zobrazení v reálném čase: ukazuj text, jak přichází
  2. Shromažďování volání nástrojů: sbírej volání k provedení
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":
            # Proveď nástroje a restartuj
            results = await execute_tools(tool_calls)
            yield {"type": "tool_results", "data": results}

Latence a uživatelská zkušenost

Streamování s nástroji přirozeně vytváří v toku pauzy:

  1. Uživatel položí otázku
  2. Model začne „přemýšlet“ (žádné viditelné tokeny)
  3. Model se rozhodne zavolat nástroj (obdržíš tool_call)
  4. Pauza — provádíš funkci
  5. Odešleš zpět výsledek
  6. Model generuje svou odpověď (streamovanou postupně)

Pro lepší uživatelskou zkušenost zobraz během kroku 4 indikátor:

🔍 Hledám počasí v Paříži...

Tím zabráníš tomu, aby si uživatel myslel, že aplikace zamrzla.

Server-Sent Events (SSE) pro webové aplikace

Pokud buduješ webové API, použij SSE k přenosu streamu:

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")

Klíčové poznatky

  • Volání nástrojů přichází v jediném bloku, nikoliv postupně
  • Běžný text je nadále streamován token po tokenu
  • Roztříštěná volání nástrojů rekonstruuj pomocí vyrovnávací paměti indexované podle index
  • Zpracovávej paralelně dva proudy: zobrazení textu + sběr volání nástrojů
  • Během provádění nástroje zobraz indikátor pro lepší UX
  • Pro webové aplikace použij SSE