Przejdź do głównej treści
Polski— Wybierz język
Menu

Strumieniowanie i narzędzia

Lekcja 9 z 14 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Strumieniowanie z wywoływaniem funkcji
  2. Zasada podstawowa
  3. Implementacja strumieniowania z narzędziami
  4. Rekonstrukcja wywołań narzędzi w strumieniu
  5. Architektura strumieniowania z narzędziami
  6. Opóźnienia i doświadczenia użytkownika
  7. Server-Sent Events (SSE) dla aplikacji webowych
  8. Kluczowe wnioski

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:

  1. Wyświetlanie w czasie rzeczywistym: pokazywanie tekstu w miarę jego napływania
  2. 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:

  1. Użytkownik zadaje pytanie
  2. Model zaczyna „myśleć“ (brak widocznych tokenów)
  3. Model decyduje się wywołać narzędzie (otrzymujesz tool_call)
  4. Przerwa — wykonujesz funkcję
  5. Wysyłasz wynik z powrotem
  6. 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