Streaming og værktøjer
På denne side
Streaming med funktionskald
Streaming giver dig mulighed for at modtage modellens svar inkrementelt, token for token. Dette er afgørende for responsive brugergrænseflader. Men hvordan interagerer streaming med funktionskald?
Den fundamentale regel
Funktionskald returneres i en enkelt blok, ikke streamet progressivt. Dette er en væsentlig forskel fra almindelig tekst, som ankommer token for token.
I praksis:
- Svartekst streames progressivt
- tool_calls ankommer samlet i en enkelt begivenhed
Denne begrænsning findes af en god grund: Et værktøjskald skal være komplet (navn + gyldige JSON-argumenter), før du kan udføre det. Delvis JSON ville være ubrugelig.
Implementering af streaming med værktøjer
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
# Streamet tekst
if delta.content:
collected_content += delta.content
print(delta.content, end="", flush=True)
# Værktøjskald (ankommer i en enkelt blok)
if delta.tool_calls:
for tc in delta.tool_calls:
collected_tool_calls.append(tc)
# Tjek for slutning af stream
if chunk.choices[0].finish_reason == "tool_calls":
# Modellen forventer værktøjsresultater
break
elif chunk.choices[0].finish_reason == "stop":
# Svaret er afsluttet, intet værktøj kaldt
break
Rekonstruktion af værktøjskald ved streaming
I nogle tilfælde kan argumenter til værktøjskald ankomme i flere dele inden for streamen. Du skal rekonstruere dem:
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
Denne buffer-tilgang sikrer, at du rekonstruerer hvert værktøjskald korrekt, selv hvis dataene ankommer fragmenteret.
Arkitektur for streaming med værktøjer
I en rigtig applikation skal du håndtere to samtidige streams:
- Realtidsvisning: vis tekst, efterhånden som den kommer ind
- Akkumulering af værktøjskald: saml kald til udførelse
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":
# Udfør værktøjer og genstart
results = await execute_tools(tool_calls)
yield {"type": "tool_results", "data": results}
Latens og brugeroplevelse
Streaming med værktøjer indebærer naturlige pauser i flowet:
- Brugeren stiller sit spørgsmål
- Modellen begynder at tænke (ingen synlige tokens)
- Modellen beslutter at kalde et værktøj (du modtager tool_call)
- Pause — du udfører funktionen
- Du sender resultatet tilbage
- Modellen genererer sit svar (streamet progressivt)
For brugeroplevelsens skyld skal du vise en indikator under trin 4:
🔍 Søger efter vejr i Paris...
Dette forhindrer brugeren i at tro, at applikationen er frosset.
Server-Sent Events (SSE) til webapplikationer
Hvis du bygger en web-API, skal du bruge SSE til at videresende streamen:
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")
Vigtige pointer
- Værktøjskald ankommer i en enkelt blok, ikke streamet progressivt
- Almindelig tekst fortsætter med at blive streamet token for token
- Rekonstruer fragmenterede værktøjskald med en buffer indekseret efter
index - Håndtér to streams parallelt: tekstvisning + indsamling af værktøjskald
- Vis en indikator under udførelse af værktøjer for bedre UX
- Brug SSE til webapplikationer