Le Processus en 5 Étapes — Function Calling et Appel d'Outils

Un protocole clair entre vous et le modèle

Le function calling avec Mistral suit un processus en 5 étapes bien définies. Chaque étape a un responsable clair — soit vous (le développeur), soit le modèle, soit l’utilisateur. Comprendre ce flux est essentiel avant d’écrire la moindre ligne de code.

Définir les fonctions (Développeur)

Vous décrivez chaque fonction disponible avec un schéma JSON : nom, description, paramètres, types et champs requis. Le modèle ne voit que cette spécification, pas votre code.

Interroger le modèle (Utilisateur)

L'utilisateur pose sa question en langage naturel. Vous envoyez cette requête au modèle Mistral accompagnée de la liste des outils disponibles.

Générer les arguments (Modèle)

Le modèle analyse la requête, choisit la fonction appropriée et génère les arguments au format JSON. Il ne l'exécute pas — il vous dit simplement quoi appeler et avec quels paramètres.

Exécuter la fonction (Développeur)

Votre code extrait le nom de la fonction et les arguments de la réponse du modèle, exécute la fonction correspondante et récupère le résultat.

Générer la réponse finale (Modèle)

Vous renvoyez le résultat de la fonction au modèle. Il l'intègre dans le contexte de la conversation et formule une réponse naturelle pour l'utilisateur.

Le flux en détail

Voici comment ces 5 étapes se traduisent concrètement dans le code. Prenons l’exemple d’un utilisateur qui demande le statut d’un paiement.

Étape 1 : Vous définissez les outils

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_payment_status",
            "description": "Récupère le statut d'un paiement à partir de son identifiant de transaction",
            "parameters": {
                "type": "object",
                "properties": {
                    "transaction_id": {
                        "type": "string",
                        "description": "L'identifiant unique de la transaction (ex: T1001)"
                    }
                },
                "required": ["transaction_id"]
            }
        }
    }
]

Étape 2 : L’utilisateur pose sa question

messages = [
    {"role": "user", "content": "Quel est le statut du paiement T1001 ?"}
]

Étape 3 : Le modèle génère les arguments

from mistralai import Mistral

client = Mistral(api_key="votre-clé-api")
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

# Le modèle retourne un tool_call :
# function.name = "get_payment_status"
# function.arguments = '{"transaction_id": "T1001"}'

Étape 4 : Vous exécutez la fonction

import json

tool_call = response.choices[0].message.tool_calls[0]
args = json.loads(tool_call.function.arguments)
result = get_payment_status(**args)
# → {"status": "payé", "date": "2026-03-15"}

Étape 5 : Le modèle formule la réponse

messages.append(response.choices[0].message)
messages.append({
    "role": "tool",
    "name": "get_payment_status",
    "content": json.dumps(result),
    "tool_call_id": tool_call.id
})

final = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)
print(final.choices[0].message.content)
# → "Le paiement T1001 a été effectué le 15 mars 2026."

Les patterns de flux

Selon la complexité de la requête, le flux peut prendre différentes formes :

Sans fonction : l’utilisateur pose une question générale, le modèle répond directement sans appeler de fonction
Appel simple : une seule fonction est appelée, un seul résultat est retourné
Appels séquentiels : le modèle appelle une première fonction, utilise le résultat pour en appeler une deuxième
Appels parallèles : le modèle demande l’exécution de plusieurs fonctions en même temps

Ces patterns seront détaillés dans les leçons suivantes.

Points clés à retenir

Le function calling suit un processus en 5 étapes avec des responsabilités claires
Le modèle ne peut jamais exécuter de fonction directement — il génère uniquement les arguments
Votre code est le gardien : c’est lui qui décide d’exécuter ou non la fonction
Le résultat de la fonction est renvoyé au modèle pour qu’il formule une réponse naturelle
Le flux peut être simple (un appel) ou complexe (séquentiel, parallèle)