Meilleures pratiques et mise en production
Na ovoj stranici
- De la preuve de concept à la production
- Checklist de déploiement
- Rédiger des descriptions qui font travailler le modèle
- Choisir le bon modèle
- Structurer le message système
- Gérer les coûts en production
- Tester l’appel de fonctions
- Surveillance en production
- Prochaines étapes
- Ključne točke
- Teste tes connaissances
De la preuve de concept à la production
Tu disposes désormais de tous les éléments pour construire des systèmes d’appel de fonctions avec Mistral. Ce qui sépare ton prototype d’un service prêt pour la production, ce ne sont pas des fonctionnalités manquantes, mais une série de vérifications et d’étapes de réglage que tu découvres généralement lors d’un incident. Cette dernière leçon rassemble les meilleures pratiques, les pièges courants et une checklist pour passer en production en toute confiance.
Checklist de déploiement
C’est le seul endroit de ce cours où un format de liste est impératif : avant la mise en ligne, tu coches des cases. Quatre domaines doivent être couverts, chacun répondant à une question différente.
L’Architecture garantit que la mécanique tient la route. Renvoyer des chaînes JSON dans la chaîne d’exécution et disposer d’un dictionnaire de dispatch complet sont les deux causes les plus fréquentes de plantage lors du premier appel réel.
- Toutes les fonctions renvoient des chaînes JSON (jamais d’objets Python bruts)
- Le dictionnaire de dispatch est complet et à jour
- Les fonctions gèrent les cas d’erreur et renvoient des messages utilisables
- Le message système est clair, précis et testé
- La boucle de conversation gère les appels séquentiels et parallèles
La Sécurité part du principe que les arguments proviennent d’un utilisateur, jamais de ton application.
- Les arguments sont validés avant exécution (format, type, valeurs)
- Les requêtes SQL utilisent des paramètres (pas de concaténation)
- Une liste blanche limite les fonctions disponibles
- Les actions destructrices nécessitent une confirmation
- Une limitation de débit (rate limiting) est en place par fonction et par utilisateur
- Les résultats sont assainis (aucune donnée sensible renvoyée au modèle)
La Fiabilité gère ce qui échoue sans que personne ne soit en faute.
- Les erreurs sont renvoyées au modèle dans un format structuré
- Un mécanisme de nouvelle tentative avec backoff est implémenté pour les erreurs transitoires
- Des délais d’attente (timeouts) sont configurés pour chaque fonction externe
- La taille de l’historique est limitée pour éviter le dépassement de tokens
La Surveillance, enfin, est ce qui te permet de diagnostiquer sans deviner.
- Chaque appel de fonction est journalisé (nom, arguments, résultat, durée)
- Les erreurs déclenchent des alertes (Slack, PagerDuty, etc.)
- Les métriques sont collectées (taux de réussite, latence, coût API)
Rédiger des descriptions qui font travailler le modèle
La qualité des descriptions a un impact direct sur la précision, et c’est souvent le levier le moins coûteux à actionner. Trois modèles récurrents apparaissent chez les équipes ayant des taux d’appels corrects élevés. Le premier ancre la description dans le contexte métier : au lieu de paraphraser le nom de la fonction, liste les valeurs de retour possibles et indique explicitement quand l’appeler. Le second glisse des exemples de format dans la description des paramètres, ce qui corrige la plupart des erreurs d’extraction d’ID. Le troisième remplace une instruction en langage naturel par un enum, le seul moyen d’interdire véritablement une valeur hors liste.
# Modèle 1 : Description avec contexte métier
{
"description": "Récupère le statut du paiement. "
"Statuts possibles : paid, pending, failed, refunded. "
"Utilise cette fonction lorsque l'utilisateur demande "
"le statut d'un paiement ou s'il a été reçu."
}
# Modèle 2 : Paramètres avec exemples
{
"transaction_id": {
"type": "string",
"description": "ID unique au format T suivi de 4 chiffres (ex. : T1001, T2345)"
}
}
# Modèle 3 : Enum pour des valeurs limitées
{
"status": {
"type": "string",
"enum": ["paid", "pending", "failed", "refunded"],
"description": "Filtrer par statut de paiement"
}
}
Choisir le bon modèle
Le choix du modèle arbitre entre précision et coût, et il n’y a pas de réponse universelle : cela dépend du nombre de fonctions exposées et de la complexité de leurs schémas. Un cas complexe avec de nombreuses fonctions et des paramètres imbriqués justifie Mistral Large 3, plus fiable pour la sélection de fonctions mais plus cher. Un cas standard avec quelques fonctions simples dans une production à haut débit fonctionne très bien sur Mistral Small 4, qui est rapide et économique. Pour le prototypage et les tests, Mistral Medium 3.5 offre un bon compromis.
# Cas complexes : nombreuses fonctions, paramètres imbriqués
# -> Mistral Large 3 (plus fiable, plus cher)
model = "mistral-large-latest"
# Cas standards : quelques fonctions simples, production à haut débit
# -> Mistral Small 4 (rapide, économique)
model = "mistral-small-latest"
# Cas de développement : prototypage, tests
# -> Mistral Medium 3.5 (bon compromis)
model = "mistral-medium-latest"
La méthode compte autant que le résultat : en production, commence par le modèle le plus capable, mesure ton taux d’appels corrects, puis descends progressivement pour trouver le meilleur rapport coût/performance. L’inverse — commencer par le modèle le moins cher — te prive de la ligne de base nécessaire pour savoir si la dégradation vient du modèle ou de tes descriptions.
Structurer le message système
Un bon message système fait la différence entre un assistant médiocre et un excellent. Celui-ci illustre une structure éprouvée : une déclaration de rôle, un bloc de règles impératives, puis un rappel des outils disponibles. Les deux règles les plus rentables ici sont „Si l’utilisateur ne fournit pas un ID requis, demande-le poliment“ et „Ne devine jamais un ID de transaction“ ; ensemble, elles éliminent le comportement le plus dommageable qui soit : appeler une fonction avec un ID inventé.
system_message = {
"role": "system",
"content": """Tu es un assistant de gestion des paiements pour Acme Corporation.
Règles :
- Réponds toujours en français
- Formate les montants en euros avec le symbole et 2 décimales
- Si l'utilisateur ne fournit pas un ID requis, demande-le poliment
- Ne devine jamais un ID de transaction
- Lorsqu'une transaction échoue, propose de vérifier les détails
Outils disponibles :
- retrieve_payment_status : pour vérifier le statut d'un paiement
- retrieve_payment_date : pour vérifier la date d'un paiement
- retrieve_payment_details : pour obtenir tous les détails d'une transaction
- list_customer_transactions : pour voir toutes les transactions d'un client"""
}
Gérer les coûts en production
Chaque appel d’appel de fonction consomme des tokens, et la facture grimpe via deux canaux sous-estimés : les définitions d’outils sont envoyées à chaque requête, et l’historique grossit à chaque tour. Filtrer les fonctions par contexte résout le premier point : inutile d’envoyer les douze outils lorsque la question porte clairement sur les paiements. Tronquer l’historique au-delà d’un seuil résout le second. Et lorsque toutes les données nécessaires sont déjà dans le contexte, tool_choice="none" évite un aller-retour supplémentaire.
# 1. Limiter le nombre de fonctions par requête
# Passer uniquement les fonctions pertinentes pour le contexte
def get_relevant_tools(user_input: str, all_tools: list) -> list:
"""Filtre les outils en fonction du contexte."""
if "payment" in user_input.lower() or "transaction" in user_input.lower():
return [t for t in all_tools if "payment" in t["function"]["name"]]
if "contact" in user_input.lower() or "customer" in user_input.lower():
return [t for t in all_tools if "contact" in t["function"]["name"]]
return all_tools
# 2. Limiter la taille de l'historique
MAX_HISTORY = 20 # messages
# 3. Utiliser tool_choice="none" lorsque les données sont déjà disponibles
Tester l’appel de fonctions
Les tests sont essentiels pour éviter les régressions, et ici ils ciblent un objet inhabituel : tu ne vérifies pas la valeur de retour de ta fonction, mais la décision du modèle. Deux familles de tests couvrent l’essentiel. La première vérifie qu’une question métier déclenche la bonne fonction avec les bons arguments extraits. La seconde, tout aussi importante et souvent oubliée, vérifie qu’une salutation ne déclenche aucun appel ; ce test attrape les descriptions trop larges qui poussent le modèle à appeler une fonction en toute circonstance.
def test_payment_status():
"""Teste que le modèle appelle la bonne fonction."""
messages = [{"role": "user", "content": "Statut du paiement T1001 ?"}]
response = client.chat.complete(
model=model, messages=messages, tools=tools
)
message = response.choices[0].message
assert message.tool_calls is not None
assert len(message.tool_calls) == 1
assert message.tool_calls[0].function.name == "retrieve_payment_status"
args = json.loads(message.tool_calls[0].function.arguments)
assert args["transaction_id"] == "T1001"
def test_no_function_for_greeting():
"""Teste que le modèle n'appelle pas de fonction pour une salutation."""
messages = [{"role": "user", "content": "Bonjour !"}]
response = client.chat.complete(
model=model, messages=messages, tools=tools
)
message = response.choices[0].message
assert message.tool_calls is None or len(message.tool_calls) == 0
assert message.content is not None
Surveillance en production
Maintenant, tu dois savoir ce que fait ton système une fois lancé dans la nature. La classe ci-dessous agrège trois signaux qui, ensemble, racontent presque toute l’histoire : taux de réussite global, latence moyenne et répartition par fonction. Ce dernier est le plus parlant en pratique : une fonction dont le compteur d’erreurs dérive de manière isolée pointe vers un problème spécifique, tandis qu’un taux global dégradé ne t’indique pas où chercher.
import time
import logging
logger = logging.getLogger("fc_monitor")
class FunctionCallingMonitor:
def __init__(self):
self.metrics = {
"total_calls": 0,
"successful_calls": 0,
"failed_calls": 0,
"total_latency_ms": 0,
"calls_by_function": {}
}
def record(self, function_name: str, success: bool, latency_ms: float):
self.metrics["total_calls"] += 1
self.metrics["total_latency_ms"] += latency_ms
if success:
self.metrics["successful_calls"] += 1
else:
self.metrics["failed_calls"] += 1
if function_name not in self.metrics["calls_by_function"]:
self.metrics["calls_by_function"][function_name] = {
"count": 0, "errors": 0
}
self.metrics["calls_by_function"][function_name]["count"] += 1
if not success:
self.metrics["calls_by_function"][function_name]["errors"] += 1
def get_success_rate(self) -> float:
if self.metrics["total_calls"] == 0:
return 0.0
return self.metrics["successful_calls"] / self.metrics["total_calls"]
def get_avg_latency(self) -> float:
if self.metrics["total_calls"] == 0:
return 0.0
return self.metrics["total_latency_ms"] / self.metrics["total_calls"]
monitor = FunctionCallingMonitor()
Prochaines étapes
Maintenant que tu maîtrises l’appel de fonctions avec Mistral, plusieurs directions s’ouvrent à toi. La plus naturelle est la construction d’agents autonomes, combinant l’appel de fonctions avec une boucle d’agent qui planifie et exécute des tâches complexes ; l’API Mistral Agents et sa méthode client.beta.agents.create() vont plus loin en proposant des agents persistants avec état. Un autre axe combine RAG et appel de fonctions : le modèle décide lui-même quand interroger une base de données vectorielle, au lieu que la recherche ne soit déclenchée systématiquement en amont. Côté expérience utilisateur, le streaming te permet d’afficher les réponses en temps réel pendant l’exécution des fonctions, changeant la perception de la latence sur les longues chaînes d’appels. Enfin, le multimodal ouvre l’appel de fonctions à la vision pour l’analyse de documents.
Ključne točke
- La checklist de déploiement couvre l’architecture, la sécurité, la fiabilité et la surveillance
- Des descriptions précises avec exemples et enums améliorent la précision du modèle
- Choisis le bon modèle selon la complexité et le budget (Large pour la fiabilité, Small pour le débit)
- Le message système est un levier puissant pour guider le comportement
- Teste systématiquement les appels de fonctions et les comportements sans appel
- Surveille le taux de réussite, la latence et les coûts en production
Teste tes connaissances
Appel de fonctions de bout en bout : cinq vérifications.
1. Quelles sont les cinq étapes de l'appel de fonctions ?
Réponse : Définir les fonctions (schémas), les fournir à l’API, le modèle demande un appel avec ses arguments, ton code exécute et renvoie le résultat, le modèle produit la réponse finale.
2. Qu'est-ce qui fait un bon schéma de fonction ?
Réponse : Des types stricts et des descriptions opérationnelles — nom clair, quand l’utiliser, format de chaque paramètre : c’est le texte que le modèle lit pour décider et remplir.
3. Que permettent les appels parallèles ?
Réponse : Le modèle demande plusieurs fonctions dans une seule réponse lorsqu’elles sont indépendantes — moins d’allers-retours, à condition d’apparier chaque résultat à son appel.
4. À quoi sert tool_choice ?
Réponse : À définir la liberté du modèle : auto (il décide), any (il doit utiliser un outil), ou un outil forcé — ce dernier étant clé pour une extraction structurée fiable.
5. Quelles règles de sécurité pour les fonctions exposées ?
Réponse : Valider les arguments reçus, limiter le champ d’action de chaque fonction, journaliser les appels, et garder une validation humaine pour les actions engageantes — le modèle propose, ton code dispose.
Les deux exemples travaillés dans ce cours (suivi des paiements, CRM) appliquent exactement ces règles — tes propres intégrations suivront le même moule.