Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Définir ta politique de contenu

Lekcija 9 od 12 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  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. Ključne točke

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 : Moderation & Guardrailing · 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.

# Policy: Strict on everything, safety first
POLICY_PUBLIC = {
    "name": "Public-Facing",
    "description": "Chatbot accessible to all, including minors",
    "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.

# Policy: Balanced, identified users
POLICY_INTERNAL = {
    "name": "Internal B2B",
    "description": "Assistant for authenticated employees",
    "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.

# Policy: Permissive on domain, strict elsewhere
POLICY_MEDICAL = {
    "name": "Medical Assistant",
    "description": "Tool for healthcare professionals",
    "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,    # Very permissive: legitimate domain
        "financial": 0.3,
        "law": 0.4,
        "pii": 0.15,       # Strict: patient data
        "jailbreaking": 0.1,
    },
    "block_action": "detailed_message_with_redirect",
    "logging": "full_with_audit",
    "disclaimer": "This tool does not replace medical advice."
}

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:
    """Structured representation of a content policy."""

    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:
        """Evaluates scores against the policy."""
        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:
        """Generates an appropriate blocking message."""
        if self.block_action == "generic_message":
            return "This content cannot be processed."
        elif self.block_action == "detailed_message":
            cats = ", ".join(v["category"] for v in violations)
            return (f"Content blocked for the following reasons: "
                    f"{cats}. Please rephrase your request.")
        return "Content blocked."

    def to_guardrails(self) -> list[GuardrailConfigTypedDict]:
        """Translates the policy into the guardrails parameter for the Mistral API."""
        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 la source unique 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:
    """Manages content policies for multiple applications."""

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

    def register(self, app_id: str, policy: ContentPolicy):
        """Registers a policy for an application."""
        self.policies[app_id] = policy

    def get(self, app_id: str) -> ContentPolicy:
        """Retrieves the policy for an application."""
        if app_id not in self.policies:
            raise ValueError(f"No policy for {app_id}")
        return self.policies[app_id]

    def compliance_report(self) -> dict:
        """Generates a global compliance report."""
        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()
        }

# Usage
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 la rédiger 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 sur la base 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 implémente une correction immédiate, sans attendre la prochaine revue planifiée.

Ključne točke

  • 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