Strömning och verktyg
På denna sida
Strömning med funktionsanrop
Strömning låter dig ta emot modellens svar inkrementellt, token för token. Detta är avgörande för responsiva användargränssnitt. Men hur samverkar strömning med funktionsanrop?
Den grundläggande regeln
Funktionsanrop returneras i en enda chunk, inte progressivt strömmade. Detta är en stor skillnad jämfört med vanlig text, som anländer token för token.
I praktiken innebär det:
- Svarstext strömmas progressivt
- tool_calls anländer alla på en gång i en enda händelse
Denna begränsning finns av goda skäl: ett verktygsanrop måste vara komplett (namn + giltiga JSON-argument) för att du ska kunna exekvera det. Delvis JSON skulle vara oanvändbar.
Implementera strömning med verktyg
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
# Strömmad text
if delta.content:
collected_content += delta.content
print(delta.content, end="", flush=True)
# Verktygsanrop (anländer i ett enda block)
if delta.tool_calls:
for tc in delta.tool_calls:
collected_tool_calls.append(tc)
# Kontrollera slutet på strömmen
if chunk.choices[0].finish_reason == "tool_calls":
# Modellen förväntar sig verktygsresultat
break
elif chunk.choices[0].finish_reason == "stop":
# Svaret är klart, inget verktyg anropat
break
Återskapa verktygsanrop vid strömning
I vissa fall kan argument för verktygsanrop anlända i flera delar inom strömmen. Du behöver återskapa 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
Denna buffertmetod säkerställer att du återskapar varje verktygsanrop korrekt, även om datan anländer fragmenterad.
Arkitektur för strömning med verktyg
I en riktig applikation måste du hantera två samtidiga strömmar:
- Realtidsvisning: visa texten när den kommer in
- Ackumulering av verktygsanrop: samla anrop för exekvering
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":
# Exekvera verktyg och starta om
results = await execute_tools(tool_calls)
yield {"type": "tool_results", "data": results}
Latens och användarupplevelse
Strömning med verktyg innebär naturliga pauser i flödet:
- Användaren ställer sin fråga
- Modellen börjar tänka (inga synliga tokens)
- Modellen beslutar sig för att anropa ett verktyg (du receives tool_call)
- Paus — du exekverar funktionen
- Du skickar tillbaka resultatet
- Modellen genererar sitt svar (strömmas progressivt)
För användarupplevelsen bör du visa en indikator under steg 4:
🔍 Söker efter väder i Paris...
Detta förhindrar att användaren tror att applikationen har fryst.
Server-Sent Events (SSE) för webbapplikationer
Om du bygger ett webb-API använder du SSE för att vidarebefordra strömmen:
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")
Viktiga punkter
- Verktygsanrop anländer i en enda chunk, inte progressivt strömmade
- Normal text fortsätter att strömmas token för token
- Återskapa fragmenterade verktygsanrop med en buffert indexerad efter
index - Hantera två strömmar parallellt: textvisning + insamling av verktygsanrop
- Visa en indikator under verktygsexekvering för bra UX
- Använd SSE för webbapplikationer