Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Voogedastus ja tööriistad

Õppetund 9 / 14 Värskendatud 29. juuli 2026 Arendajatele
Sellel lehel
  1. Voogedastus funktsioonide kutsumisega
  2. Põhireegel
  3. Voogedastuse rakendamine tööriistadega
  4. Tööriistakutsete rekonstrueerimine voogedastusel
  5. Arhitektuur tööriistadega voogedastuseks
  6. Latentsus ja kasutajakogemus
  7. Server-Sent Events (SSE) veebirakendustele
  8. Peamised punktid

Voogedastus funktsioonide kutsumisega

Voogedastus võimaldab sul saada mudeli vastust järk-järgult, tokeni haaval. See on hädavajalik reageerimisvõimeliste kasutajaliideste loomisel. Aga kuidas suhtleb voogedastus funktsioonide kutsumisega?

Põhireegel

Funktsioonikutsed tagastatakse ühes tükis, mitte järk-järgult voogedastatuna. See on suur erinevus tavalisest tekstist, mis saubub tokeni haaval.

Praktikas tähendab see:

  • Vastuse tekst edastatakse järk-järgult
  • tool_calls saubuvad korraga ühes sündmuses

See piirang on põhjendatud: tööriistakutse peab olema täielik (nimi + kehtiv JSON-argument), et saaksid seda käivitada. Osaline JSON oleks kasutu.

Voogedastuse rakendamine tööriistadega

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

    # Voogedastatud tekst
    if delta.content:
        collected_content += delta.content
        print(delta.content, end="", flush=True)

    # Tööriistakutsed (saabuvad ühes plokis)
    if delta.tool_calls:
        for tc in delta.tool_calls:
            collected_tool_calls.append(tc)

    # Kontrolli voogedastuse lõppu
    if chunk.choices[0].finish_reason == "tool_calls":
        # Mudel ootab tööriista tulemusi
        break
    elif chunk.choices[0].finish_reason == "stop":
        # Vastus lõppenud, tööriista ei kutsutud
        break

Tööriistakutsete rekonstrueerimine voogedastusel

Mõnel juhul võivad tööriistakutsete argumendid saabuda voos mitmes osas. Pead need uuesti kokku panema:

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

See puhverdamise lähenemine tagab, et rekonstrueerid iga tööriistakutse õigesti, isegi kui andmed saabuvad fragmenteeritult.

Arhitektuur tööriistadega voogedastuseks

Reaalses rakenduses pead haldama kahte samaaegset voogu:

  1. Reaalajas kuva: näita teksti selle saabumisel
  2. Tööriistakutsete kogumine: kogu kutseid täitmiseks
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":
            # Käivita tööriistad ja taaskäivita
            results = await execute_tools(tool_calls)
            yield {"type": "tool_results", "data": results}

Latentsus ja kasutajakogemus

Tööriistadega voogedastus toob kaasa loomulikke pause voos:

  1. Kasutaja esitab oma küsimuse
  2. Mudel hakkab mõtlema (nähtavaid tokeneid pole)
  3. Mudel otsustab kutsuda tööriista (saad tool_call)
  4. Pauss – käivitad funktsiooni
  5. Saadad tulemuse tagasi
  6. Mudel genereerib oma vastuse (edastatakse järk-järgult)

Kasutajakogemuse huvides kuva neljandal sammul indikaator:

🔍 Otsin ilmateadet Pariisi kohta...

See hoiab ära olukorra, kus kasutaja arvab, et rakendus on külmunud.

Server-Sent Events (SSE) veebirakendustele

Kui ehitad veebi-API-d, kasuta voogedastuse edastamiseks SSE-d:

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

Peamised punktid

  • Tööriistakutsed saubuvad ühes tükis, mitte järk-järgult voogedastatuna
  • Tavaline tekst edastatakse jätkuvalt tokeni haaval
  • Rekonstrueeri fragmenteeritud tööriistakutsed puhvriga, mis on indekseeritud index järgi
  • Halda kahte voogu paralleelselt: teksti kuvamine ja tööriistakutsete kogumine
  • Kuva tööriista täitmise ajal indikaator kasutajakogemuse parandamiseks
  • Kasuta veebirakendustes SSE-d