Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Streaming en tools

Les 9 van 14 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Streaming met function calling
  2. De fundamentele regel
  3. Streaming met tools implementeren
  4. Tool calls reconstrueren bij streaming
  5. Architectuur voor streaming met tools
  6. Latentie en gebruikerservaring
  7. Server-Sent Events (SSE) voor webapplicaties
  8. Belangrijkste punten

Streaming met function calling

Met streaming ontvangt u het antwoord van het model incrementeel, token voor token. Dit is essentieel voor responsieve gebruikersinterfaces. Maar hoe werkt streaming samen met function calling?

De fundamentele regel

Function calls worden in één chunk teruggegeven, niet progressief gestreamd. Dit is een groot verschil ten opzichte van normale tekst, die token voor token binnenkomt.

In de praktijk:

  • Antwoordtekst wordt progressief gestreamd
  • tool_calls komen allemaal tegelijk binnen in één gebeurtenis

Deze beperking bestaat om een goede reden: een tool call moet compleet zijn (naam + geldige JSON-argumenten) voordat u deze kunt uitvoeren. Gedeeltelijke JSON zou onbruikbaar zijn.

Streaming met tools implementeren

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

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

    # Tool calls (komen in één blok binnen)
    if delta.tool_calls:
        for tc in delta.tool_calls:
            collected_tool_calls.append(tc)

    # Controleer op einde van stream
    if chunk.choices[0].finish_reason == "tool_calls":
        # Model verwacht tool-resultaten
        break
    elif chunk.choices[0].finish_reason == "stop":
        # Antwoord voltooid, geen tool aangeroepen
        break

Tool calls reconstrueren bij streaming

In sommige gevallen kunnen de argumenten van een tool call in meerdere delen binnen de stream aankomen. U moet deze reconstrueren:

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

Deze bufferaanpak zorgt ervoor dat u elke tool call correct reconstrueert, zelfs als de gegevens gefragmenteerd binnenkomen.

Architectuur voor streaming met tools

In een echte applicatie moet u twee gelijktijdige streams verwerken:

  1. Realtime-weergave: toon tekst terwijl deze binnenkomt
  2. Tool call-accumulatie: verzamel calls voor uitvoering
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":
            # Voer tools uit en start opnieuw
            results = await execute_tools(tool_calls)
            yield {"type": "tool_results", "data": results}

Latentie en gebruikerservaring

Streaming met tools brengt natuurlijke pauzes in de flow met zich mee:

  1. De gebruiker stelt zijn vraag
  2. Het model begint na te denken (geen zichtbare tokens)
  3. Het model besluit een tool aan te roepen (u ontvangt de tool_call)
  4. Pauze — u voert de functie uit
  5. U stuurt het resultaat terug
  6. Het model genereert zijn antwoord (progressief gestreamd)

Toon voor de gebruikerservaring tijdens stap 4 een indicator:

🔍 Zoeken naar weer in Parijs...

Dit voorkomt dat de gebruiker denkt dat de applicatie is vastgelopen.

Server-Sent Events (SSE) voor webapplicaties

Als u een web-API bouwt, gebruikt u SSE om de stream door te geven:

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

Belangrijkste punten

  • Tool calls komen in één chunk binnen, niet progressief gestreamd
  • Normale tekst blijft token voor token gestreamd worden
  • Reconstructeer gefragmenteerde tool calls met een buffer geïndexeerd op index
  • Verwerk twee streams parallel: tekstweergave + tool call-verzameling
  • Toon een indicator tijdens tool-uitvoering voor een goede UX
  • Gebruik SSE voor webapplicaties