Strumieniowanie i narzędzia
Na tej stronie
Strumieniowanie z wywoływaniem funkcji
Strumieniowanie pozwala otrzymywać odpowiedź modelu przyrostowo, token po tokenie. Jest to kluczowe dla responsywnych interfejsów użytkownika. Ale w jaki sposób strumieniowanie współdziała z wywoływaniem funkcji?
Zasada podstawowa
Wywołania funkcji są zwracane w jednym fragmencie, a nie przesyłane stopniowo. To zasadnicza różnica w porównaniu do zwykłego tekstu, który dociera token po tokenie.
W praktyce:
- Tekst odpowiedzi jest przesyłany stopniowo
- tool_calls docierają wszystkie naraz w jednym zdarzeniu
To ograniczenie istnieje z dobrego powodu: wywołanie narzędzia musi być kompletne (nazwa + poprawny argument JSON), abyś mógł je wykonać. Częściowy JSON byłby bezużyteczny.
Implementacja strumieniowania z narzędziami
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
# Strumieniowany tekst
if delta.content:
collected_content += delta.content
print(delta.content, end="", flush=True)
# Wywołania narzędzi (docierają w jednym bloku)
if delta.tool_calls:
for tc in delta.tool_calls:
collected_tool_calls.append(tc)
# Sprawdzenie końca strumienia
if chunk.choices[0].finish_reason == "tool_calls":
# Model oczekuje wyników narzędzi
break
elif chunk.choices[0].finish_reason == "stop":
# Odpowiedź zakończona, nie wywołano narzędzia
break
Rekonstrukcja wywołań narzędzi w strumieniu
W niektórych przypadkach argumenty wywołania narzędzia mogą docierać w kilku częściach w ramach strumienia. Musisz je zrekonstruować:
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
Takie podejście z buforowaniem zapewnia poprawną rekonstrukcję każdego wywołania narzędzia, nawet jeśli dane docierają fragmentarycznie.
Architektura strumieniowania z narzędziami
W rzeczywistej aplikacji musisz obsłużyć dwa równoległe strumienie:
- Wyświetlanie w czasie rzeczywistym: pokazywanie tekstu w miarę jego napływania
- Akumulacja wywołań narzędzi: zbieranie wywołań do wykonania
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":
# Wykonaj narzędzia, a następnie uruchom ponownie
results = await execute_tools(tool_calls)
yield {"type": "tool_results", "data": results}
Opóźnienia i doświadczenia użytkownika
Strumieniowanie z narzędziami wiąże się z naturalnymi przerwami w przepływie:
- Użytkownik zadaje pytanie
- Model zaczyna „myśleć“ (brak widocznych tokenów)
- Model decyduje się wywołać narzędzie (otrzymujesz tool_call)
- Przerwa — wykonujesz funkcję
- Wysyłasz wynik z powrotem
- Model generuje swoją odpowiedź (przesyłaną stopniowo)
Dla lepszego doświadczenia użytkownika wyświetl wskaźnik podczas kroku 4:
🔍 Wyszukiwanie pogody w Paryżu...
Zapobiega to wrażeniu u użytkownika, że aplikacja się zawiesiła.
Server-Sent Events (SSE) dla aplikacji webowych
Jeśli budujesz API webowe, użyj SSE do przesyłania strumienia:
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")
Kluczowe wnioski
- Wywołania narzędzi docierają w jednym fragmencie, a nie są przesyłane stopniowo
- Zwykły tekst nadal jest przesyłany token po tokenie
- Rekonstruuj fragmentaryczne wywołania narzędzi za pomocą bufora indeksowanego przez
index - Obsługuj dwa strumienie równolegle: wyświetlanie tekstu i zbieranie wywołań narzędzi
- Wyświetlaj wskaźnik podczas wykonywania narzędzia dla lepszej UX
- Używaj SSE w aplikacjach webowych