Définir sa politique de contenu
Mis à jour le 29 juillet 2026
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 : deux services de la même entreprise finissent par bloquer des contenus différents sans que personne ne sache pourquoi.
Une politique écrite vous permet de justifier vos décisions de modération auprès des utilisateurs comme des régulateurs, d’harmoniser les seuils entre les équipes et les applications, d’auditer la conformité de votre système, et d’itérer de manière structurée quand les besoins changent. Le jour où un utilisateur conteste un blocage, la différence entre « le seuil est à 0.1 » et « notre politique Grand Public v1.2 fixe ce seuil pour cette raison » est considérable.
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, et le meilleur moyen 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 grand public, la règle est simple : strict partout, priorité à la sécurité, parce que vous ne savez rien de la personne en face et que des mineurs peuvent s’y trouver.
# 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"
}Un assistant interne change la donne sur un point : les utilisateurs sont authentifiés, donc identifiables et responsables. Cela autorise des seuils plus souples, notamment sur financial et law à 0.6, puisqu’un employé qui interroge l’assistant sur un montage contractuel exerce son métier.
# 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"
}Un outil spécialisé — médical, juridique ou financier — pousse la logique à son terme : très permissif sur son domaine, strict partout ailleurs. Dans l’exemple médical, health monte à 0.85 parce que parler de diagnostic est précisément la fonction de l’outil, tandis que pii descend à 0.15 parce que les données de patients ne doivent en aucun cas circuler. S’y ajoutent deux éléments absents des politiques précédentes : un mode de blocage avec redirection et un disclaimer explicite.
# 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. En Python, cela se traduit par une classe qui porte le numéro de version et la date de révision au même titre que les seuils, et qui sait à la fois évaluer des scores et produire le message de blocage correspondant au mode déclaré.
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é."Notez que le résultat de evaluer embarque le nom et la version de la politique appliquée. C’est ce détail qui permettra, six mois plus tard, de rejouer une décision contestée en sachant sous quel régime elle avait été prise.
Gestion multi-applications
Si votre entreprise gère plusieurs applications, centralisez la gestion des politiques. Le gestionnaire ci-dessous fait deux choses utiles : il refuse explicitement de servir une application sans politique déclarée, ce qui évite les déploiements sans filet, et il produit un rapport de conformité listant pour chaque application sa version et sa date de dernière révision — exactement ce qu’un auditeur demandera.
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, et l’erreur la plus commune consiste à l’écrire une fois puis à l’oublier. Installez un rythme : chaque semaine, une analyse des faux positifs et des faux négatifs remontés par vos journaux ; chaque mois, un ajustement des seuils appuyé sur les métriques accumulées ; chaque trimestre, une révision complète avec les parties prenantes métier, juridiques et produit. À quoi s’ajoute la règle non négociable : à chaque incident, un post-mortem et une correction immédiate, sans attendre la prochaine échéance calendaire.
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