Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Pretakanje in orodja

Lekcija 9 od 14 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Pretakanje s klicanjem funkcij
  2. Temeljno pravilo
  3. Implementacija pretakanja z orodji
  4. Rekonstrukcija klicev orodij pri pretakanju
  5. Arhitektura za pretakanje z orodji
  6. Zakasnitev in uporabniška izkušnja
  7. Dogodki, poslani s strežnika (SSE), za spletne aplikacije
  8. Ključne ugotovitve

Pretakanje s klicanjem funkcij

Pretakanje ti omogoča prejemanje odgovora modela postopoma, žeton za žetonom. To je ključno za odzivne uporabniške vmesnike. Kako pa pretakanje sodeluje s klicanjem funkcij?

Temeljno pravilo

Klici funkcij so vrnjeni v enem samem kosu, ne pa postopoma pretakani. To je velika razlika v primerjavi z običajnim besedilom, ki prihaja žeton za žetonom.

V praksi:

  • Odzivno besedilo se pretaka postopoma
  • tool_calls prispejo vsi naenkrat v enem samem dogodku

Ta omejitev obstaja z dobrim razlogom: klic orodja mora biti popoln (ime + veljavni argumenti JSON), da ga lahko izvršiš. Delni JSON bi bil neuporaben.

Implementacija pretakanja z orodji

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

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

    # Klici orodij (prispejo v enem bloku)
    if delta.tool_calls:
        for tc in delta.tool_calls:
            collected_tool_calls.append(tc)

    # Preveri konec toka
    if chunk.choices[0].finish_reason == "tool_calls":
        # Model pričakuje rezultate orodij
        break
    elif chunk.choices[0].finish_reason == "stop":
        # Odziv končan, nobeno orodje ni bilo poklicano
        break

Rekonstrukcija klicev orodij pri pretakanju

V nekaterih primerih lahko argumenti klica orodja prispejo v več delih znotraj toka. Rekonstruirati jih moraš:

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

Ta pristop s medpomnjenjem zagotavlja, da vsak klic orodja pravilno rekonstruiraš, tudi če podatki prispejo razdrobljeni.

Arhitektura za pretakanje z orodji

V realni aplikaciji moraš obravnavati dva sočasna toka:

  1. Prikaz v realnem času: prikaz besedila, ko prihaja
  2. Zbiranje klicev orodij: zbiranje klicev za izvršitev
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":
            # Izvrši orodja in ponovno zaženi
            results = await execute_tools(tool_calls)
            yield {"type": "tool_results", "data": results}

Zakasnitev in uporabniška izkušnja

Pretakanje z orodji vključuje naravne premore v toku:

  1. Uporabnik zastavi svoje vprašanje
  2. Model začne razmišljati (ni vidnih žetonov)
  3. Model se odloči poklicati orodje (prejmeš tool_call)
  4. Premor — izvršiš funkcijo
  5. Pošlješ nazaj rezultat
  6. Model generira svoj odgovor (postopoma pretakan)

Za uporabniško izkušnjo prikaži indikator med 4. korakom:

🔍 Iskanje vremenske napovedi za Pariz...

To prepreči, da bi uporabnik mislil, da je aplikacija zamrznila.

Dogodki, poslani s strežnika (SSE), za spletne aplikacije

Če gradiš spletni API, uporabi SSE za posredovanje toka:

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

Ključne ugotovitve

  • Klici orodij prispejo v enem samem kosu, ne pa postopoma pretakani
  • Običajno besedilo se še naprej pretaka žeton za žetonom
  • Razdrobljene klice orodij rekonstruiraj s medpomnilnikom, indeksiranim z index
  • Vzporedno obravnavaj dva toka: prikaz besedila + zbiranje klicev orodij
  • Med izvrševanjem orodij za boljšo uporabniško izkušnjo prikaži indikator
  • Za spletne aplikacije uporabi SSE