Guide de modération de contenu par AI

Discuse analyse les textes et les images pour détecter le sentiment/la toxicité, le spam, les langues indésirables, les gros mots, les liens et les contenus visuels explicites, puis renvoie un résultat par catégorie afin que votre code puisse approuver, signaler ou rejeter automatiquement le contenu. Vous envoyez le contenu à un seul endpoint, POST https://api.discuse.com/api/v2/check, puis récupérez des scores structurés. Ce guide explique le fonctionnement des vérifications, les modèles de modération qui les entourent et la manière d’intégrer l’API Discuse à votre pipeline.

Qu’est-ce que la modération de contenu par AI ?

La modération de contenu par AI utilise des modèles de machine learning pour détecter et classer automatiquement les contenus potentiellement dangereux. Là où un modérateur humain examine les éléments un par un, ces modèles évaluent les contenus dès leur arrivée, afin que les soumissions puissent être vérifiées avant d’être vues par d’autres utilisateurs.

Comment ça fonctionne ?

Soumettre du contenu : envoyez du texte et/ou des URLs de médias à l’API de modération.
Exécuter les vérifications : l’API exécute les vérifications activées (sentiment, langue, spam, mots interdits, images, liens, antivirus).
Noter chaque catégorie : chaque vérification renvoie des scores et un indicateur hit précisant si le seuil que vous avez configuré a été dépassé.
Décider : lisez has_violations (ainsi que les scores de chaque vérification) pour approuver, signaler ou rejeter.

Avec Discuse, la requête ressemble à ceci :

const response = await fetch('https://api.discuse.com/api/v2/check', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-API-Key': process.env.DISCUSE_API_KEY
  },
  body: JSON.stringify({
    content: { text: 'message to check', image_urls: ['https://...'] },
    settings: { check_sentiment: true, check_spam: true, check_images: true }
  })
});
const result = await response.json(); // { has_violations, results: { sentiment, spamfinder, images, ... }, usage }

Que couvre chaque vérification Discuse ?

Vérification (option `settings`)	Ce qu’elle couvre	Champs de résultat clés
`check_sentiment`	Négativité, toxicité, grossièretés, menaces, insultes dans le texte	`sentiment.is_toxic`, `sentiment.toxicity`, `sentiment.score`, `sentiment.hit`
`check_spam`	Classification du texte comme spam	`spamfinder.label`, `spamfinder.confidence`, `spamfinder.is_spam`, `spamfinder.hit`
`check_language`	Vérifie si le texte correspond à la langue attendue	`language.language`, `language.confidence`, `language.hit`
`check_badwords`	Correspondances avec une liste personnalisée de mots interdits	`badwords.hit`, `badwords.matched_words`
`check_images`	Images explicites dans les URLs d’images	`images.porn`, `images.sexual`, `images.neutral`, `images.hit`
`check_links`	Réputation des liens	`links.status`, `links.hit`
`check_antivirus`	Logiciels malveillants dans les URLs de documents/fichiers	`antivirus.status`, `antivirus.hit`

Chaque option est un booléen. Les seuils numériques qui transforment un score en hit sont configurés par projet dans le tableau de bord, et non transmis à chaque requête — consultez le guide de configuration des seuils.

Avantages de la modération par AI

Passage à l’échelle

L’AI traite des volumes de contenu hors de portée des équipes humaines. Un seul appel API renvoie des résultats en quelques millisecondes, ce qui permet à la modération de suivre le rythme des soumissions au lieu de prendre du retard dans une file d’examen. Associez les vérifications automatisées à une file de traitement humaine pour les cas limites (abordés ci-dessous).

Rapidité

Les vérifications en temps réel vous permettent de filtrer le contenu avant sa publication :

// Pre-moderation: Check content before publishing
async function publishPost(content) {
  const moderation = await checkContent(content);

  if (moderation.has_violations) {
    return { published: false, reason: moderation.message };
  }

  // Content passes moderation
  return await saveAndPublish(content);
}

Cohérence

L’AI applique les mêmes règles de manière uniforme à tous les contenus, sans fatigue ni variation d’un réviseur à l’autre. Les décisions sont reproductibles : la même entrée, avec les mêmes seuils de projet, produit les mêmes indicateurs hit, ce qui rend l’application des règles vérifiable.

Architecture de modération

Flux de pré-modération

User Submits → AI Check → Decision
                 ↓
    ┌───────────┼───────────┐
    ↓           ↓           ↓
  Allow      Review       Block
    ↓           ↓           ↓
 Publish   Human Queue   Reject

Flux de post-modération

User Submits → Publish → AI Check → Action
                           ↓
              ┌────────────┼────────────┐
              ↓            ↓            ↓
            Safe       Borderline    Violation
              ↓            ↓            ↓
           Keep       Flag/Review    Remove

Approche hybride (recommandée)

La réponse de Discuse définit has_violations dès qu’une vérification activée dépasse son seuil configuré, et expose les scores sous-jacents par catégorie afin que vous puissiez ajouter votre propre intervalle de confiance par-dessus :

async function moderateContent(content) {
  const result = await checkContent(content);

  // Build a confidence figure from the scores you care about.
  // e.g. the toxicity score and the spam classifier confidence.
  const confidence = Math.max(
    result.results?.sentiment?.toxicity ?? 0,
    result.results?.spamfinder?.confidence ?? 0,
    result.results?.images?.porn ?? 0
  );

  // High confidence: automate.
  if (confidence > 0.95) {
    return result.has_violations
      ? { action: 'auto_remove', reason: result.message }
      : { action: 'auto_approve' };
  }

  // Medium confidence: route to a human.
  if (confidence > 0.5) {
    await addToReviewQueue(content, result);
    return { action: 'pending_review' };
  }

  // Low confidence: approve, keep watching.
  return { action: 'approve_with_monitoring' };
}

Mettre en œuvre la modération par AI

Étape 1 : Définir votre politique

Décidez quel contenu est acceptable et quelle action appliquer à chaque catégorie avant d’appeler l’API. Dans Discuse, le seuil numérique de chaque catégorie se trouve dans les paramètres de votre projet (le tableau de bord). Ainsi, la politique de votre application associe un résultat d’API à une action, au lieu de redéfinir le seuil :

const MODERATION_POLICY = {
  // What to do when a given Discuse check reports a hit.
  // Thresholds themselves are configured per project in the dashboard.
  actions: {
    sentiment: 'block',   // toxic / threatening text
    spam: 'block',
    badwords: 'flag',
    images: 'block',      // explicit imagery
    links: 'flag'
  }
};

Étape 2 : Intégrer l’API

Envoyez le contenu ainsi que les vérifications que vous souhaitez activer pour cette requête. Chaque option check_* est un booléen facultatif qui remplace la valeur par défaut du projet pour cet appel :

async function checkContent(content) {
  const response = await fetch('https://api.discuse.com/api/v2/check', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-API-Key': process.env.DISCUSE_API_KEY
    },
    body: JSON.stringify({
      content: {
        text: content.text,
        image_urls: content.images
      },
      settings: {
        check_sentiment: true,
        check_spam: true,
        check_images: true
      }
    })
  });

  if (!response.ok) {
    throw new Error(`Discuse API returned ${response.status}`);
  }
  return response.json();
}

Étape 3 : Appliquer les décisions

Associez chaque vérification qui signale un hit à l’action que vous avez définie :

function applyModerationDecision(result) {
  const r = result.results || {};

  if (r.sentiment?.hit) return { action: MODERATION_POLICY.actions.sentiment, category: 'sentiment' };
  if (r.spamfinder?.hit) return { action: MODERATION_POLICY.actions.spam, category: 'spam' };
  if (r.images?.hit)    return { action: MODERATION_POLICY.actions.images, category: 'images' };
  if (r.badwords?.hit)  return { action: MODERATION_POLICY.actions.badwords, category: 'badwords' };
  if (r.links?.hit)     return { action: MODERATION_POLICY.actions.links, category: 'links' };

  return { action: 'allow' };
}

Étape 4 : Gérer les cas particuliers

async function handleModerationResult(content, result) {
  switch (result.action) {
    case 'block':
      await notifyUser(content.author, 'content_blocked', result);
      await logModeration(content, result);
      return false;

    case 'flag':
      await addToReviewQueue(content, result);
      await publishWithWarning(content);
      return true;

    case 'allow':
      await publish(content);
      return true;

    default:
      // Unknown action - fail safe by blocking
      await logError('unknown_moderation_action', result);
      return false;
  }
}

Bonnes pratiques

Commencez prudemment, puis ajustez au fil du temps

Commencez avec des seuils de projet plus stricts, puis assouplissez-les à mesure que vous évaluez les faux positifs. Dans Discuse, ces seuils sont des paramètres de projet : l’ajustement se fait donc dans le tableau de bord (ou via l’API de mise à jour des paramètres), et non dans chaque requête. Consultez le guide de configuration des seuils pour connaître le processus.

Conservez une file de revue humaine

L’AI doit compléter le jugement humain, et non le remplacer, pour les cas limites :

async function processReviewQueue() {
  const items = await getReviewQueue();

  for (const item of items) {
    // Present to human reviewer with AI context
    const reviewUI = {
      content: item.content,
      ai_scores: item.moderation_result,
      similar_decisions: await getSimilarPreviousDecisions(item)
    };

    // Human makes final decision
    const decision = await presentToReviewer(reviewUI);

    // Log for model improvement
    await logHumanDecision(item, decision);
  }
}

Surveillez et améliorez

Suivez les indicateurs clés afin d’améliorer votre système de modération :

const METRICS = {
  // Accuracy metrics
  false_positive_rate: 'Content incorrectly blocked',
  false_negative_rate: 'Harmful content missed',

  // Operational metrics
  average_response_time: 'API latency',
  review_queue_depth: 'Human review backlog',

  // User impact
  appeal_rate: 'Users appealing decisions',
  appeal_success_rate: 'Appeals overturned'
};

Gérez les appels avec souplesse

Lorsqu’un utilisateur conteste une décision, transmettez l’élément à un réviseur humain plutôt que de le réévaluer automatiquement. Fournissez au réviseur les scores Discuse d’origine ainsi que l’historique de l’utilisateur comme contexte :

async function handleAppeal(contentId, userId) {
  const original = await getContentWithModeration(contentId);

  await addToReviewQueue(contentId, {
    type: 'appeal',
    original_decision: original.moderation, // Discuse `results` saved at decision time
    author_history: await getAuthorHistory(userId)
  });

  return { status: 'pending', message: 'Under review' };
}

L’API elle-même ne dispose pas de paramètre « contexte » ou « historique de l’auteur » par requête : le contexte est quelque chose que vous appliquez de votre côté lorsque vous choisissez les seuils et organisez l’orientation vers la revue.

Pièges courants

Trop s’appuyer sur l’AI

Automatiser chaque décision, c’est aussi automatiser chaque erreur. Gardez une intervention humaine pour :

Les décisions contextuelles complexes
Les contenus à fort enjeu (juridique, sécurité)
Les recours et les cas limites

Ignorer le contexte

Les mêmes mots peuvent être nuisibles ou acceptables selon le contexte :

"I'm going to kill it at this interview!" // Positive
"I'm going to kill you"                    // Threat

Discuse évalue chaque message individuellement ; il ne dispose pas de paramètre de « contexte » au niveau de la requête. Appliquez le contexte de votre côté : choisissez des seuils de projet plus stricts ou plus souples selon la surface (publication publique ou message direct), et orientez les hits limites vers une revue humaine.

Configurer puis oublier

La modération de contenu nécessite des ajustements continus :

Surveiller les taux de faux positifs et de faux négatifs
Mettre à jour les seuils en fonction des données
Examiner les nouveaux schémas de contenu
Réentraîner ou mettre à jour les modèles

Application incohérente des règles

Appliquez la politique selon des règles, et non selon l’auteur du contenu. Faites dépendre les seuils d’un niveau de confiance documenté plutôt que d’exceptions au cas par cas :

// Avoid: per-person exceptions
if (user.isInfluencer) { /* lenient */ }

// Prefer: thresholds keyed to a documented trust level,
// configured the same way for everyone in that level.
const action = MODERATION_POLICY.actions[category];

Prochaines étapes

Configurer les seuils - Affinez votre modération
Faire évoluer la modération de contenu - Gérez des volumes élevés
Analyse de texte - Exploration approfondie de la modération de texte
Détection NSFW dans les images - Protection du contenu visuel