Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Transliavimas ir įrankiai

Paskaita 9 iš 14 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Transliavimas kviečiant funkcijas
  2. Pagrindinė taisyklė
  3. Transliavimo su įrankiais įgyvendinimas
  4. Įrankių kvietimų atkūrimas transliuojant
  5. Transliavimo su įrankiais architektūra
  6. Vėlavimas ir vartotojo patirtis
  7. Serverio siunčiami įvykiai (SSE) žiniatinklio programoms
  8. Svarbiausi punktai

Transliavimas kviečiant funkcijas

Transliavimas leidžia gauti modelio atsakymą palaipsniui, žetonas po žetono. Tai būtina norint užtikrinti greitą vartotojo sąsajos veikimą. Tačiau kaip transliavimas sąveikauja su funkcijų kvietimu?

Pagrindinė taisyklė

Funkcijų kvietimai grąžinami vienu gabalu, o ne transliuojami palaipsniui. Tai esminis skirtumas, palyginti su įprastu tekstu, kuris ateina žetonas po žetono.

Praktiškai tai reiškia:

  • Atsakymo tekstas transliuojamas palaipsniui
  • tool_calls atvyksta visi vienu metu viename įvykyje

Šis apribojimas egzistuoja dėl svarbios priežasties: įrankio kvietimas turi būti pilnas (pavadinimas + galiojantys JSON argumentai), kad galėtumėte jį įvykdyti. Dalinis JSON būtų nenaudingas.

Transliavimo su įrankiais įgyvendinimas

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

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

    # Įrankių kvietimai (atvyksta vienu bloku)
    if delta.tool_calls:
        for tc in delta.tool_calls:
            collected_tool_calls.append(tc)

    # Tikrinama, ar srautas baigtas
    if chunk.choices[0].finish_reason == "tool_calls":
        # Modelis tikisi įrankių rezultatų
        break
    elif chunk.choices[0].finish_reason == "stop":
        # Atsakymas baigtas, įrankis nekviestas
        break

Įrankių kvietimų atkūrimas transliuojant

Kai kuriais atvejais įrankio kvietimo argumentai sraute gali atvykti keliomis dalimis. Juos reikia surinkti ir atkurti:

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

Šis buferizavimo būdas užtikrina, kad kiekvieną įrankio kvietimą atkursite teisingai, net jei duomenys atvyksta fragmentuotai.

Transliavimo su įrankiais architektūra

Realioje programoje turite valdyti du lygiagrečius srautus:

  1. Rodymas realiuoju laiku: rodyti tekstą jam atsirandant
  2. Įrankių kvietimų kaupimas: rinkti kvietimus jų įvykdymui
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":
            # Įvykdyti įrankius ir paleisti iš naujo
            results = await execute_tools(tool_calls)
            yield {"type": "tool_results", "data": results}

Vėlavimas ir vartotojo patirtis

Transliuojant su įrankiais sraute natūraliai atsiranda pauzių:

  1. Vartotojas užduoda klausimą
  2. Modelis pradeda „galvoti“ (matomų žetonų nėra)
  3. Modelis nusprendžia iškviesti įrankį (gaunate tool_call)
  4. Pauzė – vykdote funkciją
  5. Grąžinate rezultatą
  6. Modelis generuoja atsakymą (transliuojama palaipsniui)

Siekiant geros vartotojo patirties, 4 žingsnio metu rodykite indikatorių:

🔍 Ieškoma oro sąlygų Paryžiuje...

Tai neleidžia vartotojui manyti, kad programa užstrigo.

Serverio siunčiami įvykiai (SSE) žiniatinklio programoms

Jei kuriate žiniatinklio API, srautui perduoti naudokite 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")

Svarbiausi punktai

  • Įrankių kvietimai atvyksta vienu gabalu, o ne transliuojami palaipsniui
  • Įprastas tekstas ir toliau transliuojamas žetonas po žetono
  • Fragmentuotus įrankių kvietimus atkurkite naudodami buferį, indeksuotą pagal index
  • Lygiagrečiai valdykite du srautus: teksto rodymą ir įrankių kvietimų kaupimą
  • Įrankių vykdymo metu rodykite indikatorių, kad pagerintumėte vartotojo patirtį
  • Žiniatinklio programoms naudokite SSE