Exécuter et retourner le résultat
På denna sida
L’étape que tu contrôles entièrement
Tu as reçu un tool_call du modèle. Il t’indique quelle fonction appeler et avec quels arguments—rien de plus. C’est maintenant ton code qui prend le relais : il exécute la fonction, récupère le résultat et le renvoie au modèle sous forme de message avec le rôle tool. Cette leçon couvre l’intégralité de cet aller-retour. C’est le seul moment du cycle où tu prends toutes les décisions.
Exécuter la fonction côté client
Revenons sur le dictionnaire de répartition de la leçon 4 et connectons-le à la réponse du modèle.
import json
from functools import partial
# Fonctions déjà définies
available_functions = {
"retrieve_payment_status": partial(retrieve_payment_status, df),
"retrieve_payment_date": partial(retrieve_payment_date, df),
}
# Le modèle a retourné un 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)
# Exécuter la fonction
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"})
Deux mécanismes sont à l’œuvre ici. Le premier est **function_params, qui dépaquette le dictionnaire issu du JSON en arguments nommés : si le modèle a généré {"transaction_id": "T1001"}, l’appel est strictement équivalent à retrieve_payment_status(transaction_id="T1001"). Le second est le bloc else. Moins spectaculaire, il est pourtant essentiel. Un modèle peut halluciner un nom de fonction qui n’existe pas dans ta répartition ; sans cette vérification, ton application lève une KeyError et la conversation s’arrête net. Avec elle, l’erreur devient une donnée que le modèle peut gérer gracieusement.
Construire le message outil
Le résultat doit retourner au modèle dans un format spécifique—un message avec le rôle "tool" :
tool_message = {
"role": "tool",
"name": function_name,
"content": result, # Doit être une chaîne de caractères
"tool_call_id": tool_call.id
}
| Champ | Rôle |
|---|---|
role | "tool"—identifie le message comme un résultat de fonction |
name | Le nom de la fonction exécutée |
content | Le résultat sous forme de chaîne JSON |
tool_call_id | L’ID du tool_call original—permet au modèle d’associer le résultat au bon appel |
Envoyer le résultat et obtenir la réponse finale
Le modèle n’a aucune mémoire d’un appel à l’autre : il ne se souvient pas t’avoir demandé quoi que ce soit. Tu dois donc reconstruire pour lui l’intégralité de la conversation, y compris sa propre demande d’appel d’outil, avant de lui présenter le résultat.
# 1. Ajouter le message de l'assistant (avec le tool_call)
messages.append(response.choices[0].message)
# 2. Ajouter le résultat de la fonction
messages.append({
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
})
# 3. Rappeler le modèle avec le contexte complet
final_response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools
)
# 4. Afficher la réponse finale
print(final_response.choices[0].message.content)
# → "Payment T1001 status is: paid."
L’ordre des deux opérations append est non négociable : le message de l’assistant portant le tool_call doit précéder le message tool qui y répond. Les intervertir crée un historique incohérent que l’API rejette.
Le flux complet en un seul bloc
Voici l’ensemble du processus, de la question de l’utilisateur à la réponse finale :
import os
import json
from mistralai.client import Mistral
from functools import partial
# Configuration
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
model = "mistral-large-latest"
# Fonctions et outils (définis plus tôt)
available_functions = {
"retrieve_payment_status": partial(retrieve_payment_status, df),
"retrieve_payment_date": partial(retrieve_payment_date, df),
}
# Étapes 1-2 : Question utilisateur + appel API
messages = [
{"role": "user", "content": "What is the status of payment T1001?"}
]
response = client.chat.complete(
model=model, messages=messages, tools=tools
)
# Étapes 3-4 : Extraire le tool_call et l'exécuter
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)
# Exécution côté client
result = available_functions[function_name](**function_params)
# Étape 5 : Renvoyer le résultat au modèle
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)
Structure des messages à chaque étape
Il vaut la peine d’inspecter la liste messages une fois le cycle terminé, car c’est le meilleur moyen de déboguer un appel de fonction défaillant. Elle contient quatre messages.
# Message 1 : La question de l'utilisateur
{"role": "user", "content": "What is the status of payment T1001?"}
# Message 2 : La réponse du modèle avec le tool_call
{"role": "assistant", "tool_calls": [{"id": "call_abc123", ...}]}
# Message 3 : Le résultat de la fonction
{"role": "tool", "name": "retrieve_payment_status",
"content": '{"status": "paid"}', "tool_call_id": "call_abc123"}
# Message 4 (implicite) : La réponse finale du modèle
# → "Payment T1001 status is: paid."
Suis l’ID call_abc123 : il naît dans le message 2 et réapparaît dans le message 3. Ce fil relie la demande à sa réponse. Cette structure est le motif fondamental de l’appel de fonction ; chaque variation que tu rencontreras plus tard, qu’elle soit multi-tour ou parallèle, ne fait que le répéter ou le dupliquer.
Surveille le format du contenu
Une erreur survient plus souvent que toutes les autres réunies, et elle tient au type du champ content : il doit toujours être une chaîne de caractères.
# Correct — chaîne JSON
{"content": '{"status": "paid"}'}
# Correct — texte brut
{"content": "The status is paid"}
# Incorrect — dictionnaire Python (provoquera une erreur)
{"content": {"status": "paid"}}
La différence entre le premier et le troisième exemple réside dans les guillemets qui entourent le JSON. Si ta fonction renvoie un dictionnaire, convertis-le avec json.dumps() avant l’envoi—c’est précisément pour cela que toutes les fonctions de la leçon 4 se terminaient par un json.dumps().
Viktiga punkter
- L’exécution de la fonction se déroule côté client, dans ton code—jamais par le modèle
- Le résultat est renvoyé dans un message avec le rôle
"tool"et letool_call_idcorrespondant - Le
contentdu message outil doit être une chaîne de caractères (une chaîne JSON) - Après avoir envoyé le résultat, tu rappelles
chat.complete()pour permettre au modèle de formuler la réponse finale - Vérifie toujours que la fonction demandée existe dans ton dictionnaire de répartition