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

Exemple concret : Suivi des paiements

Lektion 12 av 14 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Un projet complet de bout en bout
  2. Les données
  3. Fonctions métier
  4. Spécifications JSON
  5. Le dictionnaire d’aiguillage
  6. La boucle de conversation
  7. Ce que révèle la conversation
  8. Viktiga punkter

Un projet complet de bout en bout

Les leçons précédentes ont isolé chaque mécanisme : définition des outils, cycle d’appel, gestion des erreurs et sécurité. Il est temps de tout assembler. Tu vas construire un suivi conversationnel des paiements complet où les utilisateurs posent des questions en langage naturel et le système interroge un DataFrame Pandas via l’appel de fonctions. Ce cas d’usage s’inspire directement de la documentation officielle de Mistral. Il tient en une centaine de lignes tout en exposant les cinq briques fondamentales d’une application réelle : les données, les fonctions métier, les spécifications JSON, l’aiguillage et la boucle de conversation.

Les données

Un DataFrame contenant cinq transactions couvre les scénarios intéressants : un client avec plusieurs paiements, un paiement en attente et un paiement échoué.

import pandas as pd
import json
import os
from mistralai.client import Mistral
from functools import partial

# Transactions DataFrame
data = {
    "transaction_id": ["T1001", "T1002", "T1003", "T1004", "T1005"],
    "customer_id": ["C001", "C002", "C003", "C002", "C001"],
    "payment_amount": [125.50, 89.99, 350.00, 45.00, 210.75],
    "payment_date": ["2026-03-15", "2026-03-16", "2026-03-17", "2026-03-17", "2026-03-18"],
    "payment_status": ["paid", "paid", "pending", "paid", "failed"]
}
df = pd.DataFrame(data)

Fonctions métier

Quatre fonctions couvrent les besoins typiques de suivi des paiements. Les trois premières opèrent sur une seule transaction et diffèrent par leur granularité : statut seul, date seule ou détails complets. Cette redondance apparente est délibérée : elle permet au modèle de ne demander que ce dont il a besoin, réduisant ainsi les données inutiles dans le contexte. La quatrième change de perspective et opère par client.

Note le contrat commun : toutes renvoient une chaîne JSON, même en cas d’échec, et toutes gèrent les identifiants manquants au lieu de laisser Pandas lever une exception sur un index vide.

def retrieve_payment_status(df: pd.DataFrame, transaction_id: str) -> str:
    """Retrieves the status of a payment."""
    if transaction_id in df["transaction_id"].values:
        row = df[df["transaction_id"] == transaction_id].iloc[0]
        return json.dumps({
            "transaction_id": transaction_id,
            "status": row["payment_status"]
        })
    return json.dumps({"error": f"Transaction {transaction_id} not found"})


def retrieve_payment_date(df: pd.DataFrame, transaction_id: str) -> str:
    """Retrieves the date of a payment."""
    if transaction_id in df["transaction_id"].values:
        row = df[df["transaction_id"] == transaction_id].iloc[0]
        return json.dumps({
            "transaction_id": transaction_id,
            "date": row["payment_date"]
        })
    return json.dumps({"error": f"Transaction {transaction_id} not found"})


def retrieve_payment_details(df: pd.DataFrame, transaction_id: str) -> str:
    """Retrieves all details of a payment."""
    if transaction_id in df["transaction_id"].values:
        row = df[df["transaction_id"] == transaction_id].iloc[0]
        return json.dumps({
            "transaction_id": transaction_id,
            "customer_id": row["customer_id"],
            "amount": float(row["payment_amount"]),
            "date": row["payment_date"],
            "status": row["payment_status"]
        })
    return json.dumps({"error": f"Transaction {transaction_id} not found"})


def list_customer_transactions(df: pd.DataFrame, customer_id: str) -> str:
    """Lists all transactions for a given customer."""
    customer_df = df[df["customer_id"] == customer_id]
    if customer_df.empty:
        return json.dumps({"error": f"Customer {customer_id} not found"})

    transactions = []
    for _, row in customer_df.iterrows():
        transactions.append({
            "transaction_id": row["transaction_id"],
            "amount": float(row["payment_amount"]),
            "date": row["payment_date"],
            "status": row["payment_status"]
        })
    return json.dumps({"customer_id": customer_id, "transactions": transactions})

La conversion float(row["payment_amount"]) mérite un second regard : sans elle, json.dumps échoue sur les types NumPy. C’est le genre de détail que tu ne repères qu’à l’exécution.

Spécifications JSON

Le modèle ne voit aucun du code ci-dessus. Il ne connaît que ces descriptions. Lister explicitement les statuts possibles dans retrieve_payment_status et rappeler au modèle le format T1001 dans chaque description de paramètre lui permet de choisir la bonne fonction et d’extraire l’identifiant correctement.

tools = [
    {
        "type": "function",
        "function": {
            "name": "retrieve_payment_status",
            "description": "Retrieves the status of a payment (paid, pending, failed)",
            "parameters": {
                "type": "object",
                "properties": {
                    "transaction_id": {
                        "type": "string",
                        "description": "Transaction identifier (e.g., T1001)"
                    }
                },
                "required": ["transaction_id"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "retrieve_payment_date",
            "description": "Retrieves the date of a payment",
            "parameters": {
                "type": "object",
                "properties": {
                    "transaction_id": {
                        "type": "string",
                        "description": "Transaction identifier (e.g., T1001)"
                    }
                },
                "required": ["transaction_id"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "retrieve_payment_details",
            "description": "Retrieves all details of a payment: amount, date, status, customer",
            "parameters": {
                "type": "object",
                "properties": {
                    "transaction_id": {
                        "type": "string",
                        "description": "Transaction identifier (e.g., T1001)"
                    }
                },
                "required": ["transaction_id"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "list_customer_transactions",
            "description": "Lists all transactions for a given customer",
            "parameters": {
                "type": "object",
                "properties": {
                    "customer_id": {
                        "type": "string",
                        "description": "Customer identifier (e.g., C001)"
                    }
                },
                "required": ["customer_id"]
            }
        }
    }
]

Le dictionnaire d’aiguillage

Voici le piège : tes fonctions attendent df comme premier argument, mais le modèle ne le fournira jamais — il ignore son existence, et c’est très bien ainsi. functools.partial résout cela élégamment en liant préalablement le DataFrame, de sorte que chaque entrée du dictionnaire devient appelable avec uniquement les arguments produits par le modèle.

available_functions = {
    "retrieve_payment_status": partial(retrieve_payment_status, df),
    "retrieve_payment_date": partial(retrieve_payment_date, df),
    "retrieve_payment_details": partial(retrieve_payment_details, df),
    "list_customer_transactions": partial(list_customer_transactions, df),
}

La boucle de conversation

Le message système définit le rôle, la langue et le formatage attendu pour les montants. La fonction chat orchestre le reste, et sa structure mérite une attention particulière : la boucle while message.tool_calls gère un appel unique, plusieurs appels parallèles, ou une chaîne où le modèle demande une autre fonction après avoir vu le premier résultat. La boucle interne exécute tous les appels pour le tour actuel ; la boucle externe réinvoque le modèle tant qu’il continue de demander des outils.

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

messages = [
    {
        "role": "system",
        "content": "You are a payment tracking assistant. "
                   "Respond in English. Use the available tools "
                   "to answer questions about transactions. "
                   "Format amounts in euros with 2 decimal places."
    }
]


def chat(user_input: str) -> str:
    """Complete conversation turn with tool_calls handling."""
    messages.append({"role": "user", "content": user_input})

    response = client.chat.complete(
        model=model, messages=messages, tools=tools
    )
    message = response.choices[0].message

    # Loop while the model wants to call functions
    while message.tool_calls:
        messages.append(message)

        for tool_call in message.tool_calls:
            fn_name = tool_call.function.name
            fn_params = json.loads(tool_call.function.arguments)

            if fn_name in available_functions:
                result = available_functions[fn_name](**fn_params)
            else:
                result = json.dumps({"error": f"Unknown function {fn_name}"})

            messages.append({
                "role": "tool",
                "name": fn_name,
                "content": result,
                "tool_call_id": tool_call.id
            })

        response = client.chat.complete(
            model=model, messages=messages, tools=tools
        )
        message = response.choices[0].message

    messages.append(message)
    return message.content

Ce que révèle la conversation

Teste ceci avec quatre tours consécutifs. Le deuxième est le plus instructif : « cette transaction » ne contient aucun identifiant, pourtant le modèle appelle retrieve_payment_details avec T1001. Il a résolu l’anaphore grâce à l’historique conservé dans messages, ce qui serait impossible si tu réinitialisais la liste à chaque appel. Le quatrième tour montre l’autre facette : aucune fonction ne recherche les paiements échoués, mais le modèle interroge le client concerné et filtre lui-même le résultat.

# Turn 1
print(chat("What is the status of payment T1001?"))
# -> "Payment T1001 has status: paid."

# Turn 2
print(chat("Give me all the details for this transaction."))
# -> "Here are the details for payment T1001:
#     - Customer: C001
#     - Amount: 125.50 euros
#     - Date: March 15, 2026
#     - Status: paid"

# Turn 3
print(chat("What are all the transactions for customer C002?"))
# -> "Customer C002 has 2 transactions:
#     - T1002: 89.99 euros (paid, March 16, 2026)
#     - T1004: 45.00 euros (paid, March 17, 2026)"

# Turn 4
print(chat("Are there any failed payments?"))
# -> "Yes, payment T1005 for customer C001 (210.75 euros) failed."

Le formatage des montants avec un point décimal et des dates écrites en toutes lettres ne provient d’aucune ligne de code : il découle du prompt système. C’est l’enseignement le plus utile de ce chapitre : la moitié de la qualité perçue se joue dans les descriptions et le message système, pas dans la mécanique d’appel.

Viktiga punkter

  • Un suivi complet des paiements nécessite 4 fonctions couvrant les principaux cas d’usage
  • functools.partial lie le DataFrame aux fonctions pour un aiguillage propre
  • La boucle while message.tool_calls gère automatiquement les appels séquentiels et parallèles
  • Le message système guide le modèle sur le ton, la langue et le formatage
  • Teste avec des conversations multi-tours pour vérifier que le modèle maintient le contexte