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

Définir ta politique de contenu

Lektion 9 av 12 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Pourquoi tu as besoin d’une politique de contenu formelle
  2. Adapter les seuils au contexte de l’application
  3. Formaliser la politique en tant que document
  4. Gestion multi-applications
  5. Révision et mises à jour
  6. Viktiga punkter

Mis à jour le 3 novembre 2026. Les politiques précédentes utilisaient trois catégories inexistantes (hate, violence, unpredictable) et omettaient dangerous. Elles s’alignent désormais sur les onze clés de mistral-moderation-2603. Une méthode convertit maintenant une politique au format officiel du paramètre guardrails, garantissant l’application de seuils cohérents avant la génération. Sources : Modération et garde-fous · SDK mistralai 3.7.0.

Pourquoi tu as besoin d’une politique de contenu formelle

Les seuils de modération ne sont pas des choix techniques arbitraires. Ils reflètent une politique de contenu : un ensemble de règles définissant ce que ton application autorise et interdit. Sans politique formelle, chaque développeur prend ses propres décisions, et ton système de sécurité perd en cohérence : deux services au sein d’une même entreprise finissent par bloquer des contenus différents, sans que personne ne sache pourquoi.

Une politique écrite te permet de justifier les décisions de modération auprès des utilisateurs et des régulateurs, d’harmoniser les seuils entre les équipes et les applications, d’auditer la conformité du système et d’itérer de manière structurée selon l’évolution des besoins. Le jour où un utilisateur conteste un blocage, la différence entre « le seuil est fixé à 0,1 » et « notre Politique Publique v1.2 fixe ce seuil pour telle raison » est énorme.

Adapter les seuils au contexte de l’application

Un même contenu peut être acceptable dans un contexte et dangereux dans un autre. Ta politique doit refléter ces nuances. La meilleure façon d’y parvenir est de décrire chaque profil comme un objet nommé, daté et documenté, plutôt que comme un dictionnaire anonyme perdu dans le code.

Pour un chatbot ouvert au public, la règle est simple : strict partout, la sécurité avant tout. Tu ne connais rien de la personne en face, et des mineurs peuvent être présents.

# Politique : Strict sur tout, sécurité avant tout
POLICY_PUBLIC = {
    "name": "Public-Facing",
    "description": "Chatbot accessible à tous, y compris aux mineurs",
    "thresholds": {
        "sexual": 0.1,
        "hate_and_discrimination": 0.1,
        "violence_and_threats": 0.1,
        "dangerous": 0.1,
        "criminal": 0.1,
        "selfharm": 0.1,
        "health": 0.2,
        "financial": 0.2,
        "law": 0.2,
        "pii": 0.1,
        "jailbreaking": 0.1,
    },
    "block_action": "generic_message",
    "logging": "full"
}

Un assistant interne change la donne sur un point : les utilisateurs sont authentifiés, donc identifiables et responsables. Cela permet des seuils plus flexibles, notamment sur financial et law fixés à 0,6, car un employé qui interroge l’assistant sur la structure d’un contrat fait simplement son travail.

# Politique : Équilibrée, utilisateurs identifiés
POLICY_INTERNAL = {
    "name": "Internal B2B",
    "description": "Assistant pour les employés authentifiés",
    "thresholds": {
        "sexual": 0.2,
        "hate_and_discrimination": 0.15,
        "violence_and_threats": 0.3,
        "dangerous": 0.2,
        "criminal": 0.15,
        "selfharm": 0.15,
        "health": 0.5,
        "financial": 0.6,
        "law": 0.6,
        "pii": 0.3,
        "jailbreaking": 0.15,
    },
    "block_action": "detailed_message",
    "logging": "full"
}

Un outil spécialisé — médical, juridique ou financier — pousse cette logique à son terme : très permissif dans son domaine, strict partout ailleurs. Dans l’exemple médical, health monte à 0,85 car discuter de diagnostics est précisément la fonction de l’outil, tandis que pii descend à 0,15 car les données patients ne doivent jamais circuler. Deux éléments absents des politiques précédentes sont ajoutés ici : un mode de blocage avec redirection et un avertissement explicite.

# Politique : Permissif sur le domaine, strict ailleurs
POLICY_MEDICAL = {
    "name": "Medical Assistant",
    "description": "Outil pour les professionnels de santé",
    "thresholds": {
        "sexual": 0.2,
        "hate_and_discrimination": 0.1,
        "violence_and_threats": 0.3,
        "dangerous": 0.1,
        "criminal": 0.1,
        "selfharm": 0.3,
        "health": 0.85,    # Très permissif : domaine légitime
        "financial": 0.3,
        "law": 0.4,
        "pii": 0.15,       # Strict : données patients
        "jailbreaking": 0.1,
    },
    "block_action": "detailed_message_with_redirect",
    "logging": "full_with_audit",
    "disclaimer": "Cet outil ne remplace pas un avis médical."
}

Formaliser la politique en tant que document

Ta politique de contenu doit être un document versionné accessible à toutes les équipes. En Python, cela se traduit par une classe qui porte le numéro de version et la date de révision aux côtés des seuils, et qui peut à la fois évaluer les scores et générer le message de blocage correspondant au mode déclaré.

from mistralai.client.models import GuardrailConfigTypedDict


class ContentPolicy:
    """Représentation structurée d'une politique de contenu."""

    def __init__(self, config: dict):
        self.name = config["name"]
        self.description = config["description"]
        self.thresholds = config["thresholds"]
        self.block_action = config["block_action"]
        self.logging = config["logging"]
        self.version = config.get("version", "1.0.0")
        self.revision_date = config.get("revision_date", "2026-04-01")

    def evaluate(self, scores: dict) -> dict:
        """Évalue les scores par rapport à la politique."""
        violations = []
        for cat, threshold in self.thresholds.items():
            score = scores.get(cat, 0)
            if score > threshold:
                violations.append({
                    "category": cat,
                    "score": round(score, 3),
                    "threshold": threshold
                })

        return {
            "policy": self.name,
            "version": self.version,
            "allowed": len(violations) == 0,
            "violations": violations
        }

    def block_message(self, violations: list) -> str:
        """Génère un message de blocage approprié."""
        if self.block_action == "generic_message":
            return "Ce contenu ne peut pas être traité."
        elif self.block_action == "detailed_message":
            cats = ", ".join(v["category"] for v in violations)
            return (f"Contenu bloqué pour les raisons suivantes : "
                    f"{cats}. Veuillez reformuler votre demande.")
        return "Contenu bloqué."

    def to_guardrails(self) -> list[GuardrailConfigTypedDict]:
        """Traduit la politique dans le paramètre guardrails pour l'API Mistral."""
        return [
            {
                "block_on_error": True,
                "moderation_llm_v2": {
                    "custom_category_thresholds": self.thresholds,
                    "ignore_other_categories": False,
                    "action": "block",
                },
            }
        ]

La méthode to_guardrails fait de la politique l’unique source de vérité pour les garde-fous : client.chat.complete(..., guardrails=policy.to_guardrails()) ou client.beta.agents.create(..., guardrails=policy.to_guardrails()). Les seuils appliqués avant et après la génération ne peuvent plus diverger.

Note également que le résultat de evaluate inclut le nom et la version de la politique appliquée. Ce détail te permet, six mois plus tard, de rejouer une décision contestée en sachant exactement sous quel régime elle a été prise.

Gestion multi-applications

Si ton entreprise gère plusieurs applications, centralise la gestion des politiques. Le gestionnaire ci-dessous fait deux choses utiles : il refuse explicitement de servir une application sans politique déclarée, empêchant ainsi les déploiements sans filets de sécurité, et il produit un rapport de conformité listant la version et la date de dernière révision de chaque application — exactement ce qu’un auditeur demandera.

class PolicyManager:
    """Gère les politiques de contenu pour plusieurs applications."""

    def __init__(self):
        self.policies = {}

    def register(self, app_id: str, policy: ContentPolicy):
        """Enregistre une politique pour une application."""
        self.policies[app_id] = policy

    def get(self, app_id: str) -> ContentPolicy:
        """Récupère la politique pour une application."""
        if app_id not in self.policies:
            raise ValueError(f"Aucune politique pour {app_id}")
        return self.policies[app_id]

    def compliance_report(self) -> dict:
        """Génère un rapport de conformité global."""
        return {
            app_id: {
                "name": pol.name,
                "version": pol.version,
                "revision_date": pol.revision_date,
                "categories_covered": len(pol.thresholds)
            }
            for app_id, pol in self.policies.items()
        }

# Utilisation
manager = PolicyManager()
manager.register("chatbot-public",
    ContentPolicy(POLICY_PUBLIC))
manager.register("assistant-medical",
    ContentPolicy(POLICY_MEDICAL))

Révision et mises à jour

Ta politique n’est pas gravée dans le marbre. L’erreur la plus courante est de l’écrire une fois puis de l’oublier. Établis un rythme : chaque semaine, analyse les faux positifs et faux négatifs signalés dans tes journaux ; chaque mois, ajuste les seuils en fonction des métriques accumulées ; chaque trimestre, mène une révision complète avec les parties prenantes métier, juridiques et produit. Ajoute à cela une règle non négociable : après chaque incident, réalise un post-mortem et mets en œuvre un correctif immédiat, sans attendre la prochaine revue planifiée.

Viktiga punkter

  • Une politique de contenu traduit tes seuils techniques en règles métier
  • Adapte les seuils au contexte : ouvert au public, interne, spécialisé
  • Formalise la politique dans un document versionné
  • Centralise la gestion si tu as plusieurs applications
  • Révise régulièrement — la politique doit évoluer avec ton produit