Modération de contenu avec l'API

Modération de contenu avec l’API

L’API de modération d’OpenAI permet de détecter automatiquement les contenus inappropriés. C’est un outil gratuit et essentiel pour toute application qui accepte du contenu utilisateur.

L’API Moderation

from openai import OpenAI
client = OpenAI()

# L'API de modération est GRATUITE
moderation = client.moderations.create(
    model="omni-moderation-latest",
    input="Bonjour, comment allez-vous ?"
)

result = moderation.results[0]
print(f"Contenu flaggé : {result.flagged}")
print(f"Catégories : {result.categories}")

# Résultat :
# Contenu flaggé : False
# Catégories : Categories(harassment=False, hate=False, ...)

Les catégories de modération

L’API détecte plusieurs catégories de contenu problématique :

def analyser_moderation(texte: str) -> dict:
    """Analyse détaillée de la modération."""
    moderation = client.moderations.create(
        model="omni-moderation-latest",
        input=texte
    )

    result = moderation.results[0]

    # Catégories disponibles
    categories = {
        "harassment": result.categories.harassment,
        "harassment_threatening": result.categories.harassment_threatening,
        "hate": result.categories.hate,
        "hate_threatening": result.categories.hate_threatening,
        "self_harm": result.categories.self_harm,
        "self_harm_instructions": result.categories.self_harm_instructions,
        "self_harm_intent": result.categories.self_harm_intent,
        "sexual": result.categories.sexual,
        "sexual_minors": result.categories.sexual_minors,
        "violence": result.categories.violence,
        "violence_graphic": result.categories.violence_graphic,
    }

    # Scores de confiance (0.0 a 1.0)
    scores = {
        "harassment": result.category_scores.harassment,
        "hate": result.category_scores.hate,
        "self_harm": result.category_scores.self_harm,
        "sexual": result.category_scores.sexual,
        "violence": result.category_scores.violence,
    }

    return {
        "flagged": result.flagged,
        "categories_detectees": [k for k, v in categories.items() if v],
        "scores_principaux": {k: round(v, 4) for k, v in scores.items()},
    }

# Test
resultat = analyser_moderation("Bonjour tout le monde !")
print(f"Flaggé : {resultat['flagged']}")
print(f"Scores : {resultat['scores_principaux']}")

Pipeline de modération complet

Modérer les entrées utilisateur

class ContentModerator:
    """Modérateur de contenu pour les applications."""

    def __init__(self, seuil_custom: float = 0.5):
        self.client = OpenAI()
        self.seuil = seuil_custom

    def moderer(self, texte: str) -> tuple[bool, dict]:
        """Modère un texte. Retourne (est_acceptable, détails)."""
        moderation = self.client.moderations.create(
            model="omni-moderation-latest",
            input=texte
        )

        result = moderation.results[0]

        if result.flagged:
            categories = []
            if result.categories.harassment:
                categories.append("harcèlement")
            if result.categories.hate:
                categories.append("discours haineux")
            if result.categories.sexual:
                categories.append("contenu sexuel")
            if result.categories.violence:
                categories.append("violence")
            if result.categories.self_harm:
                categories.append("automutilation")

            return False, {
                "raison": "Contenu inapproprié détecté",
                "categories": categories
            }

        return True, {"raison": "Contenu acceptable"}

    def moderer_conversation(self, messages: list[str]) -> list[dict]:
        """Modère une liste de messages."""
        resultats = []
        for msg in messages:
            acceptable, details = self.moderer(msg)
            resultats.append({
                "message": msg[:50] + "..." if len(msg) > 50 else msg,
                "acceptable": acceptable,
                **details
            })
        return resultats

# Utilisation
moderateur = ContentModerator()
acceptable, details = moderateur.moderer("Bonjour, comment puis-je vous aider ?")
print(f"Acceptable : {acceptable}")
print(f"Détails : {details}")

Intégration dans le pipeline API

def chatbot_modere(user_input: str) -> str:
    """Chatbot avec modération des entrées ET des sorties."""
    moderateur = ContentModerator()

    # 1. Modérer l'entrée
    input_ok, input_details = moderateur.moderer(user_input)
    if not input_ok:
        return (f"Votre message a été bloqué : "
                f"{', '.join(input_details['categories'])}")

    # 2. Générer la réponse
    response = client.responses.create(
        model="gpt-5.3",
        instructions="Répondez de manière professionnelle et sûre.",
        input=user_input
    )

    # 3. Modérer la sortie
    output_ok, output_details = moderateur.moderer(response.output_text)
    if not output_ok:
        return "Je ne suis pas en mesure de fournir cette réponse."

    return response.output_text

# Test
print(chatbot_modere("Quelle est la capitale de la France ?"))

Modération en batch

Pour modérer de gros volumes efficacement :

def moderer_batch(textes: list[str]) -> list[dict]:
    """Modère plusieurs textes en une seule requête."""
    resultats = []

    # L'API accepte un tableau d'inputs
    moderation = client.moderations.create(
        model="omni-moderation-latest",
        input=textes
    )

    for i, result in enumerate(moderation.results):
        resultats.append({
            "index": i,
            "texte_preview": textes[i][:50],
            "flagged": result.flagged,
        })

    flagged_count = sum(1 for r in resultats if r["flagged"])
    print(f"Modéré {len(textes)} textes : {flagged_count} flaggés")

    return resultats

# Utilisation
textes = [
    "Bonjour, comment allez-vous ?",
    "Super produit, je recommande !",
    "Le service client est excellent.",
]
resultats = moderer_batch(textes)

Logging de la modération

import json
import logging
from datetime import datetime

logger = logging.getLogger("moderation")

def moderer_avec_log(texte: str, user_id: str = "anonymous") -> bool:
    """Modère et logue le résultat pour audit."""
    moderation = client.moderations.create(
        model="omni-moderation-latest",
        input=texte
    )

    result = moderation.results[0]

    log_entry = {
        "timestamp": datetime.now().isoformat(),
        "user_id": user_id,
        "flagged": result.flagged,
        "text_preview": texte[:100],
        "scores": {
            "harassment": round(result.category_scores.harassment, 4),
            "hate": round(result.category_scores.hate, 4),
            "violence": round(result.category_scores.violence, 4),
        }
    }

    if result.flagged:
        logger.warning(json.dumps(log_entry))
    else:
        logger.info(json.dumps(log_entry))

    return not result.flagged

# Utilisation
est_ok = moderer_avec_log("Message de test", user_id="user-123")

Points clés à retenir

• L’API de modération est gratuite — utilisez-la systématiquement
• Modérez les entrées (contenu utilisateur) ET les sorties (réponses du modèle)
• Le modèle omni-moderation-latest couvre toutes les catégories de contenu
• Loguez toutes les décisions de modération pour l’audit
• Utilisez le batch pour modérer efficacement de gros volumes
• La modération est un complément aux instructions système, pas un remplacement