Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Sécuriser les agents avec des garde-fous

Nodarbība 17 no 18 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. La sécurité des agents n’est pas optionnelle
  2. Le paramètre guardrails
  3. Instructions : ta première ligne de défense
  4. Le principe du moindre privilège
  5. Filtrer les transferts (handoffs)
  6. Ne stocke pas ce qui n’a pas besoin de l’être
  7. Modérer en amont
  8. Ajuster la génération
  9. Avant de passer en production
  10. Galvenās atziņas

Mis à jour le 3 novembre 2026. Les deux exemples précédents utilisaient guardrails={"enabled": True}, un format qui n’existe pas : le paramètre officiel est une liste de configurations moderation_llm_v2, avec un seuil par catégorie. Le texte précise également ce que stipule la documentation concernant leur portée : ils modèrent uniquement le message entrant. Sources : Moderation & Guardrailing · Agents & Conversations · SDK mistralai 3.7.0.

La sécurité des agents n’est pas optionnelle

Un agent autonome qui utilise des outils, accède à Internet et exécute du code présente un risque si ses actions ne sont pas contraintes. La différence avec un simple appel de complétion est fondamentale, pas seulement une question de degré : un modèle qui produit du texte peut être corrigé lors d’une relecture, mais un agent qui agit a déjà agi. Les garde-fous sont l’ensemble des mécanismes qui définissent les limites de ce qu’un agent peut et ne peut pas faire. Aucun d’eux n’est suffisant seul ; c’est leur empilement qui assure la protection.

Le paramètre guardrails

Le premier niveau est déclaré lors de la création de l’agent.

from mistralai.client import Mistral
import os

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="Secure Agent",
    description="Agent with guardrails enabled.",
    instructions="""You are a professional assistant.
- Never share personal information
- Never generate inappropriate content
- Refuse out-of-scope requests
- If in doubt, ask for clarification""",
    tools=[{"type": "web_search"}],
    guardrails=[
        {
            "block_on_error": True,
            "moderation_llm_v2": {
                "custom_category_thresholds": {
                    "sexual": 0.1,
                    "hate_and_discrimination": 0.1,
                    "violence_and_threats": 0.2,
                    "criminal": 0.1,
                    "selfharm": 0.1,
                    "pii": 0.2,
                    "jailbreaking": 0.2,
                },
                "action": "block",
            },
        }
    ],
)

Chaque catégorie listée reçoit un seuil de 0 à 1 : au-delà de ce point, le message de l’utilisateur est rejeté avec une erreur 403 avant d’atteindre le modèle, et block_on_error rejette également la requête si l’évaluation elle-même échoue. Selon la documentation, toutes les conversations pour l’agent héritent de ces garde-fous. Ils modèrent uniquement l’entrée : ni les résultats de la recherche web ni la réponse de l’agent ne sont vérifiés par eux.

Le même paramètre est accepté au niveau de la conversation, où il remplace la configuration de l’agent. Cela te permet de resserrer temporairement le comportement d’un agent partagé sans créer une seconde version de cet agent pour un cas d’usage unique.

response = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="Analyze this confidential document.",
    guardrails=[  # replaces the agent's guardrails for this conversation
        {
            "block_on_error": True,
            "moderation_llm_v2": {
                "custom_category_thresholds": {"pii": 0.05, "jailbreaking": 0.1},
                "action": "block",
            },
        }
    ],
)

Instructions : ta première ligne de défense

L’invite système reste le levier le plus efficace car elle agit avant toute décision du modèle. Une invite de sécurité bien construite sépare clairement le rôle, le périmètre, les interdictions et le format attendu.

instructions = """## Role
You are a legal assistant specializing in French labor law.

## Scope
- ONLY French labor law
- Refuse any out-of-scope questions (tax, real estate, criminal law, etc.)

## Strict Prohibitions
- NEVER give definitive legal advice
- NEVER draft legal documents without a disclaimer
- NEVER share information about other clients
- ALWAYS mention that a lawyer must validate

## Format
- Cite relevant legal articles
- Clearly state the limits of your response
- Always propose consulting a professional"""

Remarque ce que fait la section « Scope » : elle ne se contente pas de dire ce que l’agent traite ; elle nomme explicitement les domaines adjacents qu’il doit refuser. Sans cette énumération, une question fiscale liée à un licenciement pourrait passer car elle ressemble suffisamment au droit du travail pour que le modèle s’engage. La section « Strict Prohibitions » suit la même logique : elle formule des refus, pas des recommandations. Un agent invité à être « prudent » calibre sa propre prudence ; un agent interdit de rédiger sans avertissement applique une règle.

Le principe du moindre privilège

Chaque outil déclaré est une capacité que l’agent peut mobiliser au mauvais moment. Compare ces deux configurations.

# Too many tools — large attack surface
dangerous_agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="do-it-all-agent",
    tools=[
        {"type": "web_search"},
        {"type": "code_interpreter"},
        {"type": "image_generation"},
        {"type": "document_library", "library_ids": [lib.id]}
    ]
)

# Principle of least privilege — only what is necessary
secure_agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="documentation-agent",
    tools=[{"type": "document_library", "library_ids": [lib.id]}]
)

Le second agent ne peut pas aller en ligne chercher des informations manquantes dans tes documents, ni exécuter du code sur du contenu que tu n’as pas revu. Ce n’est pas une limitation que tu subis ; c’est la garantie que ses réponses proviennent de ta base de connaissances et de nulle part ailleurs. Pose-toi la question outil par outil : si tu ne trouves pas de scénario où l’agent en a besoin, supprime-le.

Filtrer les transferts (handoffs)

Dans un système multi-agents, le mode client te donne un droit de veto sur chaque transfert. Une liste blanche suffit à empêcher un agent d’en atteindre un autre via un chemin que tu n’avais pas anticipé.

response = client.beta.conversations.start(
    agent_id=router.id,
    inputs=user_query,
    handoff_execution="client"
)

ALLOWED_AGENTS = {research.id, analyst.id}  # Whitelist

for entry in response.outputs:
    if entry.type == "agent.handoff":
        if entry.next_agent_id not in ALLOWED_AGENTS:
            print(f"BLOCKED: unauthorized handoff to {entry.next_agent_id}")
            continue
        # Continue with the authorized agent

La liste blanche réside dans ton code, pas dans la configuration de l’agent : elle reste valide même si quelqu’un ajoute une cible de transfert au routeur sans te prévenir.

Ne stocke pas ce qui n’a pas besoin de l’être

Pour les données sensibles, la meilleure protection est de ne rien stocker.

response = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="Confidential data: Q1 2026 financial report...",
    store=False  # Nothing persists
)

Ce paramètre est décidé par conversation, ce qui te permet de conserver l’historique des échanges ordinaires tout en traitant le contenu confidentiel en mode éphémère.

Modérer en amont

Une variante élégante consiste à placer un agent de modération en tête de chaîne : il examine la requête et ne la transfère au spécialiste que si elle est acceptable.

moderator = client.beta.agents.create(
    model="mistral-large-latest",
    name="moderator",
    description="Checks that requests are appropriate.",
    instructions="""Analyze the user request:
- If appropriate: transfer to the specialist
- If inappropriate: politely reply that the request is not supported
- If ambiguous: ask for clarification"""
)

specialist = client.beta.agents.create(
    model="mistral-large-latest",
    name="specialist",
    description="Handles validated requests.",
    tools=[{"type": "web_search"}]
)

moderator = client.beta.agents.update(
    agent_id=moderator.id,
    handoffs=[specialist.id]
)

La valeur de ce motif réside dans la séparation des rôles : le modérateur n’a aucun outil et ne fait qu’une seule chose, ainsi une requête malveillante qu’il rejette n’atteint jamais l’agent qui sait agir.

Ajuster la génération

Les paramètres de complétion contribuent également à la sécurité pour une raison simple : une réponse hallucinée est un risque, et la créativité en est le terreau.

agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="Factual Agent",
    description="Factual and conservative agent.",
    completion_args={
        "temperature": 0.1,   # Very low creativity
        "top_p": 0.85,        # Restricted nucleus
        "max_tokens": 1024    # Short responses
    }
)

Une température de 0,1 couplée à un top_p de 0,85 laisse très peu de latitude au modèle : pour une question dont la réponse figure dans tes documents, il la récupère au lieu de broder une variante. La limite de 1024 jetons joue un rôle similaire, car une réponse qui devient trop longue finit par s’éloigner du périmètre documenté et produit du remplissage. Ces paramètres ne conviennent évidemment pas à un agent créatif, mais ils constituent la configuration par défaut pour tout agent censé énoncer des faits : assistant juridique, support technique, expert produit.

Avant de passer en production

Ces mécanismes ne sont valables que lorsqu’ils sont empilés, et la vérification finale se résume à quelques contrôles. Les instructions doivent définir explicitement le périmètre et les interdictions, et l’agent ne doit disposer que des outils strictement nécessaires à sa tâche. Vérifie que les garde-fous sont activés et que les flux de travail critiques s’exécutent en mode client afin qu’aucun transfert ne s’exécute sans ton approbation. Assure-toi que store=False accompagne toute conversation impliquant des données sensibles et que la température reste faible partout où l’agent est censé rester factuel. Enfin, place un agent de modération devant la chaîne pour que les requêtes inacceptables n’atteignent jamais les agents qui savent agir.

Galvenās atziņas

  • Les garde-fous sont configurés au niveau de l’agent et/ou de la conversation
  • Les instructions sont ta première ligne de défense : sois explicite sur les interdictions
  • Applique le principe du moindre privilège : donne uniquement les outils nécessaires
  • Le mode client te permet de valider et de bloquer les transferts non autorisés
  • En production : modération en amont, journalisation, liste blanche d’agents, store=False pour les données sensibles