Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Processus en 5 étapes

Lektion 2 av 14 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Un protocole clair entre toi et le modèle
  2. Le flux en détail
  3. Modèles de flux
  4. Viktiga punkter

Un protocole clair entre toi et le modèle

L’appel de fonctions Mistral suit un processus bien défini en cinq étapes. Ce qui rend ce protocole lisible, c’est que chaque étape a un seul propriétaire : soit toi (le développeur), soit le modèle, soit l’utilisateur. Aucune étape n’est partagée, aucune n’est ambiguë. Prends le temps de mémoriser cette répartition des tâches avant d’écrire la moindre ligne de code : la plupart des bugs liés à l’appel de fonctions surviennent lorsqu’un développeur s’attend à ce que le modèle gère une étape qui relève en réalité de sa responsabilité.

1

Définir les fonctions (Développeur)

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

2

L'utilisateur pose une question (Utilisateur)

L'utilisateur pose sa question en langage naturel. Tu envoies cette demande au modèle Mistral accompagnée de la liste des outils disponibles.

3

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

Le modèle analyse la demande, sélectionne la fonction appropriée et génère les arguments au format JSON. Il n'exécute pas la fonction : il se contente de t'indiquer quoi appeler et avec quels paramètres.

4

Exécuter la fonction (Développeur)

Ton 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.

5

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

Tu renvoies le résultat de la fonction au modèle. Celui-ci intègre le résultat dans le contexte de la conversation et formule une réponse naturelle pour l'utilisateur.

Le flux en détail

Ces cinq étapes correspondent directement au code. Parcours-les à l’aide d’un exemple unique, volontairement minimal : un utilisateur souhaite connaître le statut du paiement T1001. Nous utiliserons ce même exemple comme fil conducteur jusqu’à la fin du bloc « Implémentation en Python », alors familiarise-toi dès maintenant avec ses identifiants.

Étape 1 : Tu définis les outils

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_payment_status",
            "description": "Retrieves the status of a payment given its transaction ID",
            "parameters": {
                "type": "object",
                "properties": {
                    "transaction_id": {
                        "type": "string",
                        "description": "The unique transaction identifier (e.g., T1001)"
                    }
                },
                "required": ["transaction_id"]
            }
        }
    }
]

Rien ici n’est du code exécutable : c’est une description. Le modèle apprend qu’une fonction nommée get_payment_status existe, ce qu’elle fait et qu’elle nécessite un transaction_id de type chaîne de caractères. Il n’apprend jamais comment la fonction est implémentée.

Étape 2 : L’utilisateur pose sa question

messages = [
    {"role": "user", "content": "What is the status of payment T1001?"}
]

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

from mistralai.client import Mistral

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

# The model returns a tool_call:
# function.name = "get_payment_status"
# function.arguments = '{"transaction_id": "T1001"}'

Le modèle a extrait « T1001 » de la phrase et l’a placé dans le champ approprié. Note que arguments arrive sous forme de chaîne de caractères, pas de dictionnaire : tu devras gérer ce détail à l’étape suivante.

Étape 4 : Tu exécutes 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": "paid", "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)
# → "Payment T1001 was made on March 15, 2026."

Deux messages sont ajoutés à l’historique, jamais un seul : le message de l’assistant portant la demande d’appel, suivi du message portant le résultat. Le tool_call_id relie les deux. Omets-en un seul et l’API rejettera la demande, ou le modèle répondra hors sujet.

Modèles de flux

Selon la complexité de la demande, ce flux peut prendre différentes formes. Le cas le plus simple est celui où aucune fonction n’est impliquée : l’utilisateur pose une question générale – « Que sais-tu faire ? » – et le modèle répond directement sans jamais toucher aux outils. Vient ensuite l’appel simple que nous venons de parcourir : une fonction, un résultat, une réponse.

Les deux formes suivantes sont plus intéressantes. Dans une chaîne séquentielle, le modèle appelle une première fonction, lit le résultat et l’utilise pour décider d’un second appel – typiquement pour récupérer un identifiant client avant d’interroger ses factures. Dans un appel parallèle, il demande l’exécution de plusieurs fonctions simultanément car aucune ne dépend de l’autre. Nous consacrerons des leçons entières à ces deux modèles ; pour l’instant, retiens que tous deux reposent exactement sur les cinq étapes ci-dessus, simplement répétées.

Viktiga punkter

  • L’appel de fonctions suit un processus en 5 étapes avec des responsabilités claires
  • Le modèle ne peut jamais exécuter une fonction directement : il se contente de générer des arguments
  • Ton 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 afin qu’il puisse formuler une réponse naturelle
  • Le flux peut être simple (un appel) ou complexe (séquentiel, parallèle)