Définir sa politique de contenu

Pourquoi une politique de contenu formalisée

Les seuils de modération ne sont pas des choix techniques arbitraires. Ils traduisent une politique de contenu — un ensemble de règles qui définissent ce que votre application autorise et interdit. Sans politique formalisée, chaque développeur fait ses propres choix, et la cohérence de votre système de sécurité en souffre.

Une politique de contenu bien définie vous permet de :

• Justifier vos décisions de modération auprès des utilisateurs et régulateurs
• Harmoniser les seuils entre les équipes et les applications
• Auditer la conformité de votre système
• Itérer de manière structurée quand les besoins changent

Adapter les seuils au contexte applicatif

Le même contenu peut être acceptable dans un contexte et dangereux dans un autre. Votre politique doit refléter ces nuances.

Chatbot grand public

# Politique : stricte sur tout, priorité à la sécurité
POLITIQUE_GRAND_PUBLIC = {
    "nom": "Grand Public",
    "description": "Chatbot accessible à tous, mineurs possibles",
    "seuils": {
        "sexual": 0.1,
        "hate": 0.1,
        "violence": 0.1,
        "criminal": 0.1,
        "selfharm": 0.1,
        "health": 0.2,
        "financial": 0.2,
        "law": 0.2,
        "pii": 0.1,
        "jailbreaking": 0.1,
        "unpredictable": 0.2
    },
    "action_blocage": "message_generique",
    "logging": "complet"
}

Assistant interne entreprise

# Politique : équilibrée, utilisateurs identifiés
POLITIQUE_INTERNE = {
    "nom": "Interne B2B",
    "description": "Assistant pour employés authentifiés",
    "seuils": {
        "sexual": 0.2,
        "hate": 0.15,
        "violence": 0.3,
        "criminal": 0.15,
        "selfharm": 0.15,
        "health": 0.5,
        "financial": 0.6,
        "law": 0.6,
        "pii": 0.3,
        "jailbreaking": 0.15,
        "unpredictable": 0.4
    },
    "action_blocage": "message_detaille",
    "logging": "complet"
}

Outil spécialisé (médical, juridique, financier)

# Politique : permissive sur le domaine, stricte ailleurs
POLITIQUE_MEDICAL = {
    "nom": "Assistant Médical",
    "description": "Outil pour professionnels de santé",
    "seuils": {
        "sexual": 0.2,
        "hate": 0.1,
        "violence": 0.3,
        "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,
        "unpredictable": 0.4
    },
    "action_blocage": "message_detaille_avec_redirection",
    "logging": "complet_avec_audit",
    "disclaimer": "Cet outil ne remplace pas un avis médical."
}

Formaliser la politique en document

Votre politique de contenu doit être un document versionné, consultable par toutes les équipes :

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

    def __init__(self, config: dict):
        self.nom = config["nom"]
        self.description = config["description"]
        self.seuils = config["seuils"]
        self.action_blocage = config["action_blocage"]
        self.logging = config["logging"]
        self.version = config.get("version", "1.0.0")
        self.date_revision = config.get("date_revision", "2026-04-01")

    def evaluer(self, scores: dict) -> dict:
        """Évalue les scores contre la politique."""
        violations = []
        for cat, seuil in self.seuils.items():
            score = scores.get(cat, 0)
            if score > seuil:
                violations.append({
                    "categorie": cat,
                    "score": round(score, 3),
                    "seuil": seuil
                })

        return {
            "politique": self.nom,
            "version": self.version,
            "autorise": len(violations) == 0,
            "violations": violations
        }

    def message_blocage(self, violations: list) -> str:
        """Génère un message de blocage adapté."""
        if self.action_blocage == "message_generique":
            return "Ce contenu ne peut pas être traité."
        elif self.action_blocage == "message_detaille":
            cats = ", ".join(v["categorie"] for v in violations)
            return (f"Contenu bloqué pour les raisons suivantes : "
                    f"{cats}. Reformulez votre demande.")
        return "Contenu bloqué."

Gestion multi-applications

Si votre entreprise gère plusieurs applications, centralisez la gestion des politiques :

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

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

    def enregistrer(self, app_id: str, politique: PolitiqueContenu):
        """Enregistre une politique pour une application."""
        self.politiques[app_id] = politique

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

    def rapport_conformite(self) -> dict:
        """Génère un rapport de conformité global."""
        return {
            app_id: {
                "nom": pol.nom,
                "version": pol.version,
                "date_revision": pol.date_revision,
                "categories_couvertes": len(pol.seuils)
            }
            for app_id, pol in self.politiques.items()
        }

# Utilisation
gestionnaire = GestionnairePolitiques()
gestionnaire.enregistrer("chatbot-public",
    PolitiqueContenu(POLITIQUE_GRAND_PUBLIC))
gestionnaire.enregistrer("assistant-medical",
    PolitiqueContenu(POLITIQUE_MEDICAL))

Révision et mise à jour

Votre politique n’est pas figée. Planifiez des révisions régulières :

• Hebdomadaire : analyser les faux positifs et faux négatifs
• Mensuelle : ajuster les seuils selon les métriques
• Trimestrielle : réviser la politique complète avec les parties prenantes
• À chaque incident : post-mortem et correction immédiate

Points clés à retenir

• Une politique de contenu traduit vos seuils techniques en règles business
• Adaptez les seuils au contexte : grand public, interne, spécialisé
• Formalisez la politique dans un document versionné
• Centralisez la gestion si vous avez plusieurs applications
• Révisez régulièrement — la politique doit évoluer avec votre produit