Streaming en tools
Op deze pagina
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:
- Realtime-weergave: toon tekst terwijl deze binnenkomt
- 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:
- De gebruiker stelt zijn vraag
- Het model begint na te denken (geen zichtbare tokens)
- Het model besluit een tool aan te roepen (u ontvangt de tool_call)
- Pauze — u voert de functie uit
- U stuurt het resultaat terug
- 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