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

Wykonaj funkcję i zwróć wynik

Lekcja 6 z 14 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Krok, nad którym masz pełną kontrolę
  2. Wykonaj funkcję po stronie klienta
  3. Zbuduj wiadomość typu Tool
  4. Wyślij wynik i uzyskaj końcową odpowiedź
  5. Pełny przepływ w jednym bloku
  6. Struktura wiadomości na każdym etapie
  7. Uważaj na format treści
  8. Kluczowe wnioski

Krok, nad którym masz pełną kontrolę

Otrzymałeś od modelu wywołanie tool_call. Informuje ono, którą funkcję wywołać i z jakimi argumentami – nic więcej. Teraz Twój kod przejmuje stery: wykonuje funkcję, pobiera wynik i odsyła go z powrotem do modelu jako wiadomość z rolą tool. Ta lekcja omawia całą tę pętlę zwrotną. To jedyny moment w cyklu, w którym to Ty podejmujesz wszystkie decyzje.

Wykonaj funkcję po stronie klienta

Wróćmy do słownika dyspozytorskiego z Lekcji 4 i połączmy go z odpowiedzią modelu.

import json
from functools import partial

# Funkcje już zdefiniowane
available_functions = {
    "retrieve_payment_status": partial(retrieve_payment_status, df),
    "retrieve_payment_date": partial(retrieve_payment_date, df),
}

# Model zwrócił tool_call
tool_call = response.choices[0].message.tool_calls[0]
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)

# Wykonaj funkcję
if function_name in available_functions:
    result = available_functions[function_name](**function_params)
    print(f"Result: {result}")
    # → '{"status": "paid"}'
else:
    result = json.dumps({"error": f"Function {function_name} not available"})

Działają tu dwa mechanizmy. Pierwszy to **function_params, który rozpakowuje słownik z JSON-a na argumenty nazwane: jeśli model wygenerował {"transaction_id": "T1001"}, wywołanie jest dokładnie równoważne z retrieve_payment_status(transaction_id="T1001"). Drugim mechanizmem jest blok else. Jest mniej efektowny, ale kluczowy. Model może halucynować nazwę funkcji, której nie ma w Twoim słowniku dyspozytorskim; bez tego sprawdzenia Twoja aplikacja zgłosi błąd KeyError i konwersacja zostanie przerwana. Dzięki niemu błąd staje się danymi, które model może obsłużyć w sposób bezpieczny.

Zbuduj wiadomość typu Tool

Wynik musi wrócić do modelu w określonym formacie – jako wiadomość z rolą "tool":

tool_message = {
    "role": "tool",
    "name": function_name,
    "content": result,  # Musi być ciągiem znaków (string)
    "tool_call_id": tool_call.id
}
PoleRola
role"tool" – identyfikuje wiadomość jako wynik funkcji
nameNazwa wykonanej funkcji
contentWynik jako ciąg znaków JSON
tool_call_idID oryginalnego tool_call – pozwala modelowi dopasować wynik do właściwego wywołania

Wyślij wynik i uzyskaj końcową odpowiedź

Model nie posiada pamięci między kolejnymi wywołaniami: nie pamięta, że o coś Cię prosił. Dlatego musisz odbudować dla niego całą historię konwersacji, łącznie z jego własnym żądaniem wywołania narzędzia, zanim przedłożysz mu wynik.

# 1. Dodaj wiadomość asystenta (z tool_call)
messages.append(response.choices[0].message)

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

# 3. Wywołaj model ponownie z pełnym kontekstem
final_response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

# 4. Wyświetl końcową odpowiedź
print(final_response.choices[0].message.content)
# → "Payment T1001 status is: paid."

Kolejność dwóch operacji append jest niepodważalna: wiadomość asystenta zawierająca tool_call musi pojawić się przed wiadomością tool, która na nią odpowiada. Ich zamiana tworzy niespójną historię, którą API odrzuci.

Pełny przepływ w jednym bloku

Oto cały proces, od pytania użytkownika do końcowej odpowiedzi:

import os
import json
from mistralai.client import Mistral
from functools import partial

# Konfiguracja
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
model = "mistral-large-latest"

# Funkcje i narzędzia (zdefiniowane wcześniej)
available_functions = {
    "retrieve_payment_status": partial(retrieve_payment_status, df),
    "retrieve_payment_date": partial(retrieve_payment_date, df),
}

# Kroki 1-2: Pytanie użytkownika + wywołanie API
messages = [
    {"role": "user", "content": "What is the status of payment T1001?"}
]

response = client.chat.complete(
    model=model, messages=messages, tools=tools
)

# Kroki 3-4: Wyodrębnij tool_call i wykonaj go
message = response.choices[0].message

if message.tool_calls:
    tool_call = message.tool_calls[0]
    function_name = tool_call.function.name
    function_params = json.loads(tool_call.function.arguments)

    # Wykonanie po stronie klienta
    result = available_functions[function_name](**function_params)

    # Krok 5: Odeślij wynik z powrotem do modelu
    messages.append(message)
    messages.append({
        "role": "tool",
        "name": function_name,
        "content": result,
        "tool_call_id": tool_call.id
    })

    final_response = client.chat.complete(
        model=model, messages=messages, tools=tools
    )
    print(final_response.choices[0].message.content)
else:
    print(message.content)

Struktura wiadomości na każdym etapie

Warto przyjrzeć się liście messages po zakończeniu cyklu, ponieważ jest to najlepszy sposób na debugowanie nieprawidłowo działającego wywoływania funkcji. Zawiera ona cztery wiadomości.

# Wiadomość 1: Pytanie użytkownika
{"role": "user", "content": "What is the status of payment T1001?"}

# Wiadomość 2: Odpowiedź modelu z tool_call
{"role": "assistant", "tool_calls": [{"id": "call_abc123", ...}]}

# Wiadomość 3: Wynik funkcji
{"role": "tool", "name": "retrieve_payment_status",
 "content": '{"status": "paid"}', "tool_call_id": "call_abc123"}

# Wiadomość 4 (niejawna): Końcowa odpowiedź modelu
# → "Payment T1001 status is: paid."

Śledź ID call_abc123: rodzi się w Wiadomości 2 i pojawia ponownie w Wiadomości 3. Ten wątek łączy żądanie z jego odpowiedzią. Ta struktura stanowi fundamentalny wzorzec wywoływania funkcji; każda odmiana, na którą natkniesz się później, czy to w wielu turach, czy równolegle, po prostu go powtarza lub duplikuje.

Uważaj na format treści

Jeden błąd pojawia się częściej niż wszystkie inne i sprowadza się do typu pola content: musi ono zawsze być ciągiem znaków (stringiem).

# Poprawnie — ciąg JSON
{"content": '{"status": "paid"}'}

# Poprawnie — zwykły tekst
{"content": "The status is paid"}

# Niepoprawnie — słownik Pythona (spowoduje błąd)
{"content": {"status": "paid"}}

Różnica między pierwszym a trzecim przykładem polega na cudzysłowach otaczających JSON. Jeśli Twoja funkcja zwraca słownik, przekonwertuj go za pomocą json.dumps() przed wysłaniem – właśnie dlatego wszystkie funkcje w Lekcji 4 kończyły się wywołaniem json.dumps().

Kluczowe wnioski

  • Wykonanie funkcji odbywa się po stronie klienta, w Twoim kodzie – nigdy przez model
  • Wynik jest odsyłany w wiadomości z rolą "tool" i pasującym tool_call_id
  • Pole content wiadomości tool musi być ciągiem znaków (stringiem JSON)
  • Po wysłaniu wyniku ponownie wywołujesz chat.complete(), aby model mógł sformułować końcową odpowiedź
  • Zawsze weryfikuj, czy żądana funkcja istnieje w Twoim słowniku dyspozytorskim