Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Streaming i alati

Lekcija 9 od 14 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Streaming s pozivanjem funkcija
  2. Temeljno pravilo
  3. Implementacija streaminga s alatima
  4. Rekonstrukcija poziva alata u streamingu
  5. Arhitektura za streaming s alatima
  6. Kašnjenje i korisničko iskustvo
  7. Server-Sent Events (SSE) za web aplikacije
  8. Ključne točke

Streaming s pozivanjem funkcija

Streaming ti omogućuje primanje odgovora modela inkrementalno, token po token. To je ključno za responzivna korisnička sučelja. No, kako streaming stupa u interakciju s pozivanjem funkcija?

Temeljno pravilo

Pozivi funkcija vraćaju se u jednom komadu, a ne streamaju se progresivno. To je velika razlika u odnosu na običan tekst koji stiže token po token.

U praksi:

  • Tekst odgovora streama se progresivno
  • tool_calls stižu odjednom u jednom događaju

Ovo ograničenje postoji s dobrim razlogom: poziv alata mora biti potpun (ime + valjani JSON argumenti) da bi ga mogao izvršiti. Djelomični JSON bio bi neupotrebljiv.

Implementacija streaminga s alatima

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

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

    # Pozivi alata (stižu u jednom bloku)
    if delta.tool_calls:
        for tc in delta.tool_calls:
            collected_tool_calls.append(tc)

    # Provjera kraja streama
    if chunk.choices[0].finish_reason == "tool_calls":
        # Model očekuje rezultate alata
        break
    elif chunk.choices[0].finish_reason == "stop":
        # Odgovor je završen, alat nije pozvan
        break

Rekonstrukcija poziva alata u streamingu

U nekim slučajevima argumenti poziva alata mogu stići u više dijelova unutar streama. Moraš ih rekonstruirati:

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

Ovaj pristup međuspremanja osigurava da ispravno rekonstruiraš svaki poziv alata, čak i ako podaci stižu fragmentirano.

Arhitektura za streaming s alatima

U stvarnoj aplikaciji moraš rukovati s dva istovremena streama:

  1. Prikaz u stvarnom vremenu: prikazuj tekst kako stiže
  2. Akumulacija poziva alata: prikupljaj pozive za izvršenje
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 alate, a zatim ponovno pokreni
            results = await execute_tools(tool_calls)
            yield {"type": "tool_results", "data": results}

Kašnjenje i korisničko iskustvo

Streaming s alatima uključuje prirodne pauze u tijeku:

  1. Korisnik postavlja pitanje
  2. Model počinje razmišljati (nema vidljivih tokena)
  3. Model odluči pozvati alat (primaš tool_call)
  4. Pauza — izvršavaš funkciju
  5. Šalješ natrag rezultat
  6. Model generira svoj odgovor (streama se progresivno)

Za korisničko iskustvo prikaži indikator tijekom 4. koraka:

🔍 Traženje vremenske prognoze za Pariz...

To sprječava da korisnik pomisli kako je aplikacija zamrznuta.

Server-Sent Events (SSE) za web aplikacije

Ako gradiš web API, upotrijebi SSE za prosljeđivanje streama:

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 točke

  • Pozivi alata stižu u jednom komadu, a ne streamaju se progresivno
  • Običan tekst i dalje se streama token po token
  • Rekonstruiraj fragmentirane pozive alata pomoću međuspremnika indeksiranog s index
  • Rukuj s dva streama paralelno: prikaz teksta + prikupljanje poziva alata
  • Prikaži indikator tijekom izvršavanja alata radi boljeg korisničkog iskustva
  • Upotrijebi SSE za web aplikacije