Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Streamovanie a nástroje

Lekcia 9 z 14 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Streamovanie s volaním funkcií
  2. Základné pravidlo
  3. Implementácia streamovania s nástrojmi
  4. Rekonštrukcia volaní nástrojov pri streamovaní
  5. Architektúra pre streamovanie s nástrojmi
  6. Latencia a používateľská skúsenosť
  7. Server-Sent Events (SSE) pre webové aplikácie
  8. Kľúčové poznatky

Streamovanie s volaním funkcií

Streamovanie ti umožňuje prijímať odpoveď modelu prírastkovo, token po tokene. To je kľúčové pre responzívne používateľské rozhrania. Ako však streamovanie interaguje s volaním funkcií?

Základné pravidlo

Volania funkcií sa vracajú v jednom bloku, nie sú streamované postupne. To je zásadný rozdiel oproti bežnému textu, ktorý prichádza token po tokene.

V praxi to znamená:

  • Odpoveď vo forme textu sa streamuje postupne
  • tool_calls prídu naraz v jednej udalosti

Toto obmedzenie má dobrý dôvod: volanie nástroja musí byť úplné (názov + platné argumenty JSON), aby si ho mohol vykonať. Čiastočný JSON by bol nepoužiteľný.

Implementácia streamovania s nástrojmi

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)

    # Volania nástrojov (prichádzajú v jednom bloku)
    if delta.tool_calls:
        for tc in delta.tool_calls:
            collected_tool_calls.append(tc)

    # Kontrola konca streamu
    if chunk.choices[0].finish_reason == "tool_calls":
        # Model očakáva výsledky nástrojov
        break
    elif chunk.choices[0].finish_reason == "stop":
        # Odpoveď skončila, žiadny nástroj nebol zavolaný
        break

Rekonštrukcia volaní nástrojov pri streamovaní

V niektorých prípadoch môžu argumenty volania nástroja prísť v streamu v niekoľkých častiach. Musíš ich zrekonštruovať:

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 prístup s vyrovnávacou pamäťou (bufferom) zabezpečuje správnu rekonštrukciu každého volania nástroja, aj keď dáta prichádzajú fragmentované.

Architektúra pre streamovanie s nástrojmi

V reálnej aplikácii musíš spracovávať dva simultánne streamy:

  1. Zobrazenie v reálnom čase: zobrazovanie textu, ako prichádza
  2. Akumulácia volaní nástrojov: zbieranie volaní na vykonanie
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":
            # Vykonanie nástrojov a reštart
            results = await execute_tools(tool_calls)
            yield {"type": "tool_results", "data": results}

Latencia a používateľská skúsenosť

Streamovanie s nástrojmi zahŕňa prirodzené pauzy v toku:

  1. Používateľ položí otázku
  2. Model začne „premýšľať“ (žiadne viditeľné tokeny)
  3. Model sa rozhodne zavolať nástroj (dostaneš tool_call)
  4. Pauza — vykonávaš funkciu
  5. Odošleš späť výsledok
  6. Model generuje svoju odpoveď (streamovanú postupne)

Pre dobrú používateľskú skúsenosť zobraz počas kroku 4 indikátor:

🔍 Hľadám počasie v Paríži...

Tým zabrániš tomu, aby si používateľ myslel, že aplikácia zamrzla.

Server-Sent Events (SSE) pre webové aplikácie

Ak buduješ webové API, použi SSE na prenos 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")

Kľúčové poznatky

  • Volania nástrojov prichádzajú v jednom bloku, nie sú streamované postupne
  • Bežný text sa naďalej streamuje token po tokene
  • Fragmentované volania nástrojov zrekonštruuj pomocou bufferu indexovaného podľa index
  • Spracúvaj dva streamy paralelne: zobrazovanie textu + zbieranie volaní nástrojov
  • Počas vykonávania nástrojov zobraz indikátor pre lepšiu UX
  • Pre webové aplikácie použi SSE