Guardrails pour les agents Mistral

Sécuriser les agents autonomes

Les agents IA représentent un niveau de risque supérieur aux simples chatbots. Un agent peut appeler des outils, exécuter du code, et enchaîner des actions de manière autonome. Sécuriser un agent ne se limite donc pas à filtrer les prompts — il faut protéger chaque étape de son raisonnement, y compris celles que l’utilisateur ne voit jamais.

Dans cette leçon, vous apprendrez à appliquer les guardrails aux Conversations et Agents de l’API Mistral, et à comprendre comment la protection se propage de l’un à l’autre.

Guardrails sur les Conversations

L’API Conversations de Mistral permet de gérer des échanges multi-tours avec persistance côté serveur. Les guardrails attachés à une conversation s’appliquent à tous les messages de la session, ce qui déplace la sécurité du site d’appel vers l’objet conversation lui-même.

from mistralai import Mistral

client = Mistral(api_key="votre-clé")

# Créer une conversation avec guardrails
conversation = client.beta.conversations.start(
    model="mistral-large-latest",
    instructions="Vous êtes un assistant RH professionnel.",
    guardrails={
        "enabled": True,
        "custom_category_thresholds": {
            "sexual": 0.1,
            "hate": 0.1,
            "violence": 0.2,
            "pii": 0.15,
            "jailbreaking": 0.1
        },
        "action": "block",
        "block_on_error": True
    }
)

L’avantage se mesure au premier échange un peu long. Vous définissez les guardrails une seule fois à la création de la conversation, et tous les messages suivants héritent automatiquement de la même protection — y compris ceux écrits six mois plus tard par un développeur qui n’a jamais lu cette configuration.

# Chaque message est automatiquement filtré
response1 = conversation.send("Quels sont les congés disponibles ?")
# → OK, réponse normale

response2 = conversation.send("Donne-moi les numéros de sécu des employés")
# → 403, bloqué par le seuil PII

response3 = conversation.send("Comment licencier quelqu'un illégalement ?")
# → 403, bloqué par les seuils criminal + law

Observez le contraste entre ces trois messages : le premier relève du métier de l’assistant RH, les deux autres franchissent une limite sans jamais changer de ton. C’est exactement le scénario où un filtre placé au niveau de la session vaut mieux qu’une vigilance humaine. Côté application, il reste à traduire le 403 en message compréhensible.

def envoyer_message_securise(conversation, message: str) -> str:
    """Envoie un message dans une conversation sécurisée."""
    try:
        response = conversation.send(message)
        return response.choices[0].message.content
    except Exception as e:
        if "403" in str(e):
            return ("Je ne peux pas traiter cette demande. "
                    "Elle enfreint notre politique de sécurité.")
        raise

Guardrails sur les Agents

Les agents Mistral sont des entités persistantes avec des instructions, des outils et des guardrails intégrés. C’est le niveau de protection le plus robuste, parce que la politique de sécurité devient un attribut de l’agent et non une convention de code.

agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="Agent Support Client",
    description="Agent de support client sécurisé",
    instructions="""Vous êtes un agent de support client.
    Règles strictes :
    - Ne jamais divulguer d'informations personnelles
    - Ne pas donner de conseils médicaux ou juridiques
    - Rediriger vers un humain si le sujet est sensible
    """,
    guardrails={
        "enabled": True,
        "custom_category_thresholds": {
            "sexual": 0.1,
            "hate": 0.1,
            "violence": 0.15,
            "criminal": 0.1,
            "selfharm": 0.1,
            "health": 0.3,
            "financial": 0.3,
            "law": 0.3,
            "pii": 0.15,
            "jailbreaking": 0.1,
            "unpredictable": 0.2
        },
        "action": "block",
        "block_on_error": True
    }
)

print(f"Agent créé : {agent.id}")

Notez la cohérence entre les instructions et les seuils : les règles écrites en langage naturel demandent de ne pas donner de conseils médicaux ou juridiques, et les seuils health et law à 0.3 rendent cette consigne opposable même si le modèle l’oublie. Les instructions persuadent, les guardrails contraignent.

Quand un agent a des guardrails, toutes les conversations créées avec cet agent héritent automatiquement de la même protection. Vous n’avez plus rien à passer au démarrage d’une session.

# Créer une conversation avec l'agent
conv = client.beta.conversations.start(
    agent_id=agent.id
)

# Les guardrails de l'agent s'appliquent automatiquement
response = conv.send("Comment puis-je retourner un produit ?")
# → Réponse normale, guardrails évalués en arrière-plan

Agents avec outils : double protection

Un agent qui appelle des outils ouvre une seconde surface d’attaque : les arguments transmis à ces outils. Un utilisateur ne peut pas exécuter votre fonction directement, mais il peut tenter d’amener le modèle à l’appeler avec des paramètres qu’il n’aurait jamais dû produire. Les guardrails couvrent aussi ce chemin.

tools = [
    {
        "type": "function",
        "function": {
            "name": "rechercher_client",
            "description": "Recherche un client par numéro de commande",
            "parameters": {
                "type": "object",
                "properties": {
                    "order_id": {
                        "type": "string",
                        "description": "Numéro de commande"
                    }
                },
                "required": ["order_id"]
            }
        }
    }
]

agent_avec_outils = client.beta.agents.create(
    model="mistral-large-latest",
    name="Agent Support avec Outils",
    instructions="Assistant support avec accès aux commandes.",
    tools=tools,
    guardrails={
        "enabled": True,
        "custom_category_thresholds": {
            "pii": 0.15,
            "jailbreaking": 0.1,
            "criminal": 0.1
        },
        "action": "block",
        "block_on_error": True
    }
)

Concrètement, le guardrail vérifie le message de l’utilisateur en entrée, les arguments passés aux outils, et le contexte global de la conversation. Ces trois points de contrôle expliquent pourquoi un seuil pii bas est ici prioritaire : la fonction rechercher_client manipule des données clients, et c’est par ses arguments qu’une extraction abusive tenterait de passer.

Architecture recommandée pour les agents en production

En production, encapsulez l’agent dans une classe qui centralise la création des conversations, l’envoi des messages et le comptage des blocages. Le compteur n’est pas cosmétique : une hausse soudaine des 403 signale soit une attaque, soit un seuil mal calibré, et vous voulez le voir sans fouiller vos journaux.

class AgentSecurise:
    """Wrapper pour un agent Mistral avec gestion de sécurité."""

    def __init__(self, client, agent_id: str):
        self.client = client
        self.agent_id = agent_id
        self.blocked_count = 0

    def nouvelle_conversation(self):
        """Crée une nouvelle conversation sécurisée."""
        return self.client.beta.conversations.start(
            agent_id=self.agent_id
        )

    def envoyer(self, conversation, message: str) -> dict:
        """Envoie un message avec gestion complète."""
        try:
            response = conversation.send(message)
            return {
                "status": "ok",
                "content": response.choices[0].message.content,
                "guardrails": getattr(response, "guardrails", {})
            }
        except Exception as e:
            if "403" in str(e):
                self.blocked_count += 1
                return {
                    "status": "blocked",
                    "content": "Requête bloquée par la politique "
                               "de sécurité.",
                    "blocked_total": self.blocked_count
                }
            return {"status": "error", "content": str(e)}

Inline vs Conversation vs Agent : récapitulatif

Points clés à retenir

• Les guardrails sur les Conversations s’appliquent à tous les messages de la session
• Les guardrails sur les Agents s’appliquent à toutes les conversations de l’agent
• L’héritage automatique simplifie la configuration en production
• Les agents avec outils bénéficient d’une protection sur les entrées ET les appels d’outils
• Utilisez le niveau Agent pour toute application en production