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 pas à filtrer les prompts — il faut protéger chaque étape de son raisonnement.

Dans cette leçon, vous apprendrez à appliquer les guardrails aux Conversations et Agents de l’API Mistral.

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.

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
    }
)

Avantage clé : configuration unique

Vous définissez les guardrails une seule fois à la création de la conversation. Tous les messages suivants héritent automatiquement de la même protection :

# 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

Gestion des erreurs dans une conversation

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.

Créer un agent sécurisé

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}")

L’héritage des guardrails

Quand un agent a des guardrails, toutes les conversations créées avec cet agent héritent automatiquement de la même protection :

# 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

Quand un agent utilise des outils (function calling), les guardrails protègent aussi les appels d’outils :

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
    }
)

Le guardrail vérifie :

• Le message de l’utilisateur (entrée)
• Les arguments passés aux outils
• Le contexte global de la conversation

Architecture recommandée pour les agents en production

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