Wykonaj funkcję i zwróć wynik
Na tej stronie
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
}
| Pole | Rola |
|---|---|
role | "tool" – identyfikuje wiadomość jako wynik funkcji |
name | Nazwa wykonanej funkcji |
content | Wynik jako ciąg znaków JSON |
tool_call_id | ID 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ącymtool_call_id - Pole
contentwiadomoś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