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

Wywołania funkcji równoległych

Lekcja 8 z 14 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Kiedy model potrzebuje wielu informacji jednocześnie
  2. Odczytywanie odpowiedzi z wieloma wywołaniami
  3. Zwracanie każdego wyniku do oryginalnego wywołania
  4. Przejście od pozornej równoległości do prawdziwej równoległości
  5. Odzyskanie kontroli dzięki parallel_tool_calls
  6. Co tak naprawdę zmienia równoległość
  7. Kluczowe wnioski

Kiedy model potrzebuje wielu informacji jednocześnie

Do tej pory każda tura rozmowy skutkowała pojedynczym wywołaniem funkcji. Wiele pytań ze świata rzeczywistego nie pasuje do tego schematu. Wyobraź sobie użytkownika, który pyta: „Jaki jest status i data płatności T1001?“. Model potrzebuje dwóch fragmentów informacji, które znajdują się w dwóch odrębnych funkcjach: retrieve_payment_status oraz retrieve_payment_date. Mógłby żądać ich po kolei, oczekując na Twoją odpowiedź między nimi. Jednak w tym przypadku stwierdza, że żadna z nich nie zależy od drugiej, więc generuje wiele wywołań tool_calls w jednej odpowiedzi. Otrzymujesz cały pakiet zadań naraz i to Ty decydujesz, jak je wykonać.

Odczytywanie odpowiedzi z wieloma wywołaniami

Praktyczny wniosek jest prosty: message.tool_calls nie jest już listą zawierającą jeden element. Musisz iterować po tej liście, zamiast chwytać tool_calls[0], co jest odruchem typowym przy nauce wywoływania funkcji na przykładach z jedną funkcją.

response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

message = response.choices[0].message

# Wiele wywołań tool_calls w tej samej odpowiedzi
for tc in message.tool_calls:
    print(f"Function: {tc.function.name}")
    print(f"Arguments: {tc.function.arguments}")
    print(f"ID: {tc.id}")
    print("---")

# Możliwy wynik:
# Function: retrieve_payment_status
# Arguments: {"transaction_id": "T1001"}
# ID: call_abc123
# ---
# Function: retrieve_payment_date
# Arguments: {"transaction_id": "T1001"}
# ID: call_def456

Zauważ, że oba wywołania używają tego samego argumentu, T1001, ale mają różne identyfikatory: call_abc123 i call_def456. Te identyfikatory to jedyny sposób, w jaki model wie, który wynik odpowiada któremu żądaniu.

Zwracanie każdego wyniku do oryginalnego wywołania

Zasada jest ścisła: musisz wykonać każdą funkcję i zwrócić każdy wynik w osobnej wiadomości typu tool, zawierającej odpowiedni tool_call_id. Jeśli zapomnisz lub pomylisz identyfikator, model może przypisać datę do pola statusu lub odmówić udzielenia odpowiedzi.

message = response.choices[0].message
messages.append(message)

# Wykonaj wszystkie zażądane funkcje
for tool_call in message.tool_calls:
    function_name = tool_call.function.name
    function_params = json.loads(tool_call.function.arguments)

    # Wykonaj funkcję
    result = available_functions[function_name](**function_params)

    # Dodaj wynik z poprawnym tool_call_id
    messages.append({
        "role": "tool",
        "name": function_name,
        "content": result,
        "tool_call_id": tool_call.id
    })

# Wyślij wszystkie wyniki z powrotem do modelu
final_response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

print(final_response.choices[0].message.content)
# → "Payment T1001 was made on March 15, 2026, and its status is: paid."

Model następnie scala te dwa fragmenty w jedno zdanie, tak jakby informacje pochodziły z jednego źródła. To dokładnie taki efekt, jaki chcesz osiągnąć z perspektywy użytkownika.

Przejście od pozornej równoległości do prawdziwej równoległości

Jeden szczegół często umyka czytelnikom przy pierwszym czytaniu: w powyższej pętli for funkcje wykonują się jedna po drugiej. Model zażądał swoich wywołań równolegle, ale Twój kod pozostaje sekwencyjny. Dopóki Twoje funkcje odczytują DataFrame znajdujący się w pamięci, nie ma to znaczenia. Jednak gdy zaczną odpytywać zewnętrzne API lub bazę danych, dwa wywołania trwające po 300 ms zamienią się w 600 ms postrzeganego opóźnienia, a korzyść z równoległości zniknie. Jeśli Twoje funkcje są asynchroniczne, asyncio.gather uruchomi je jednocześnie i poczeka na cały zestaw.

import asyncio
import json

async def execute_tools_parallel(tool_calls, available_functions):
    """Executes tool_calls in parallel and returns the results."""

    async def execute_one(tool_call):
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)
        # If your functions are async:
        result = await available_functions[function_name](**function_params)
        return {
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        }

    # Execute all functions in parallel
    tasks = [execute_one(tc) for tc in tool_calls]
    return await asyncio.gather(*tasks)

Większość istniejących baz kodu udostępnia funkcje synchroniczne, których nie będziesz chciał przepisywać na async tylko z tego powodu. Pulą wątków (thread pool) osiągniesz ten sam efekt bez dotykania logiki biznesowej.

from concurrent.futures import ThreadPoolExecutor

def execute_tools_threaded(tool_calls, available_functions):
    """Executes tool_calls using a thread pool."""
    def execute_one(tool_call):
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)
        result = available_functions[function_name](**function_params)
        return {
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        }

    with ThreadPoolExecutor(max_workers=5) as executor:
        results = list(executor.map(execute_one, tool_calls))

    return results

Odzyskanie kontroli dzięki parallel_tool_calls

Równoległość nie zawsze jest pożądana. Parametr parallel_tool_calls pozwala na jej zezwolenie lub zablokowanie. Gdy ustawiony jest na True (wartość domyślna), model sam decyduje, czy grupować swoje wywołania. Gdy ustawiony jest na False, może wygenerować tylko jedno tool_call na odpowiedź.

# Zezwól na wywołania równoległe (domyślnie)
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Model decyduje
)

# Wymuś wywołania sekwencyjne
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=False  # Tylko jedno tool_call na odpowiedź
)

Istnieją trzy sytuacje uzasadniające ustawienie tej wartości na False. Pierwsza to taka, w której kolejność wykonywania ma znaczenie: rozliczenie przed sprawdzeniem stanu magazynowego daje inny wynik niż odwrotnie. Druga dotyczy zależności danych, gdzie wynik jednej funkcji jest wymagany do wywołania następnej – na przykład znalezienie kontaktu w celu uzyskania jego identyfikatora przed modyfikacją jego rekordu. Trzecia sytuacja wiąże się po prostu z potrzebą finernej kontroli nad przepływem, zazwyczaj podczas debugowania, gdy chcesz obserwować każde wywołanie w izolacji, zanim otworzysz floodgates.

Co tak naprawdę zmienia równoległość

Zysk nie dotyczy tylko wątków; chodzi przede wszystkim o liczbę rund komunikacji z API, które dominują w całkowitym opóźnieniu.

# Sekwencyjnie (2 wywołania API do modelu)
user → assistant(fc.1) → tool(r.1) → assistant(fc.2) → tool(r.2) → assistant(response)

# Równolegle (tylko 1 dodatkowe wywołanie API)
user → assistant(fc.1, fc.2) → tool(r.1), tool(r.2) → assistant(response)

W wzorcu sekwencyjnym model musi zakończyć dwa pełne cykle rozumowania przed udzieleniem ostatecznej odpowiedzi. W wzorcu równoległym pojedyncze żądanie pobiera wszystkie tool_calls, a do uzyskania odpowiedzi potrzebne jest tylko jedno dodatkowe żądanie. W przypadku pytania obejmującego dwie lub trzy funkcje często oszczędza to użytkownikowi kilku sekund.

Kluczowe wnioski

  • Model może generować wiele wywołań tool_calls w jednej odpowiedzi
  • Każdy wynik musi być zwrócony z poprawnym tool_call_id
  • Dla funkcji sieciowych użyj asyncio lub ThreadPoolExecutor, aby uzyskać prawdziwe wykonanie równoległe
  • Parametr parallel_tool_calls kontroluje to zachowanie (domyślnie True)
  • Wzorzec równoległy redukuje liczbę żądań API i poprawia opóźnienia