Guía de moderación de contenido con AI

Discuse analiza texto e imágenes para detectar sentimiento/toxicidad, spam, lenguaje no deseado, malas palabras, enlaces e imágenes explícitas; luego devuelve un resultado por categoría para que tu código pueda aprobar, marcar o rechazar contenido automáticamente. Envías el contenido a un único endpoint, POST https://api.discuse.com/api/v2/check, y recibes puntuaciones estructuradas. Esta guía explica cómo funcionan las comprobaciones, los patrones de moderación que las rodean y cómo integrar la API de Discuse en tu flujo de trabajo.

¿Qué es la moderación de contenido con AI?

La moderación de contenido con AI utiliza modelos de aprendizaje automático para detectar y clasificar automáticamente contenido potencialmente dañino. Mientras que un revisor humano lee un elemento a la vez, estos modelos puntúan el contenido a medida que llega, de modo que los envíos pueden revisarse antes de que lleguen a otros usuarios.

¿Cómo funciona?

Enviar contenido: Envía texto y/o URLs de medios a la API de moderación.
Ejecutar comprobaciones: La API ejecuta las comprobaciones habilitadas (sentimiento, idioma, spam, palabras prohibidas, imágenes, enlaces, antivirus).
Puntuar cada categoría: Cada comprobación devuelve puntuaciones y una marca hit que indica si ha superado el umbral configurado.
Decidir: Consulta has_violations (y las puntuaciones de cada comprobación) para aprobar, marcar o rechazar.

Con Discuse, la solicitud se ve así:

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 }

¿Qué cubre cada comprobación de Discuse?

Comprobación (interruptor de `settings`)	Qué cubre	Campos clave del resultado
`check_sentiment`	Negatividad, toxicidad, lenguaje ofensivo, amenazas e insultos en texto	`sentiment.is_toxic`, `sentiment.toxicity`, `sentiment.score`, `sentiment.hit`
`check_spam`	Clasificación de spam en texto	`spamfinder.label`, `spamfinder.confidence`, `spamfinder.is_spam`, `spamfinder.hit`
`check_language`	Si el texto coincide con el idioma esperado	`language.language`, `language.confidence`, `language.hit`
`check_badwords`	Coincidencias con la lista personalizada de palabras prohibidas	`badwords.hit`, `badwords.matched_words`
`check_images`	Imágenes explícitas en URLs de imágenes	`images.porn`, `images.sexual`, `images.neutral`, `images.hit`
`check_links`	Reputación de enlaces	`links.status`, `links.hit`
`check_antivirus`	Malware en URLs de documentos/archivos	`antivirus.status`, `antivirus.hit`

Cada interruptor es un booleano. Los umbrales numéricos que convierten una puntuación en un hit se configuran por proyecto en el panel de control, no se pasan en cada solicitud; consulta la guía de configuración de umbrales.

Ventajas de la moderación con AI

Escala

La AI procesa volúmenes de contenido que los equipos humanos no pueden asumir. Una sola llamada a la API devuelve resultados en milisegundos, por lo que la moderación sigue el ritmo de los envíos en lugar de quedarse atrasada en una cola de revisión. Combina las comprobaciones automatizadas con una cola humana para los casos dudosos (que se tratan más adelante).

Velocidad

Las comprobaciones en tiempo real te permiten revisar el contenido antes de que se publique:

// 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);
}

Coherencia

La AI aplica las mismas reglas de forma uniforme a todo el contenido, sin cansancio y sin variaciones entre revisores. Las decisiones son reproducibles: la misma entrada con los mismos umbrales del proyecto produce los mismos indicadores hit, lo que permite auditar la aplicación de las normas.

Arquitectura de moderación

Flujo de premoderación

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

Flujo de posmoderación

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

Enfoque híbrido (recomendado)

La respuesta de Discuse establece has_violations cuando cualquiera de las comprobaciones habilitadas supera su umbral configurado, y expone las puntuaciones subyacentes por categoría para que puedas añadir tu propia franja de confianza encima:

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' };
}

Implementar la moderación con AI

Paso 1: Define tu política

Decide qué contenido es aceptable y cómo actuar ante cada categoría antes de llamar a la API. En Discuse, el punto de corte numérico de cada categoría se configura en los ajustes de tu proyecto (el panel), por lo que la política de tu aplicación asigna un resultado de la API a una acción, en lugar de volver a decidir el umbral:

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'
  }
};

Paso 2: Integra la API

Envía el contenido y las comprobaciones que quieres habilitar para esta solicitud. Cada conmutador check_* es un booleano opcional que sobrescribe el valor predeterminado del proyecto para esta llamada:

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();
}

Paso 3: Aplica las decisiones

Asigna cada comprobación que indique un hit a la acción que definiste:

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' };
}

Paso 4: Gestiona los casos límite

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;
  }
}

Buenas prácticas

Empieza de forma conservadora y ajusta con el tiempo

Comienza con umbrales de proyecto más estrictos y flexibilízalos a medida que midas los falsos positivos. En Discuse, estos umbrales son ajustes del proyecto, por lo que la configuración se realiza en el panel de control (o mediante la API de actualización de ajustes), no en cada solicitud. Consulta la guía de configuración de umbrales para ver el flujo de trabajo.

Mantén una cola de revisión humana

La AI debe complementar, no sustituir, el criterio humano en los casos límite:

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);
  }
}

Supervisa y mejora

Haz seguimiento de métricas clave para mejorar tu sistema de moderación:

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'
};

Gestiona las apelaciones con cuidado

Cuando un usuario apele, envía el elemento a un revisor humano en lugar de volver a decidirlo automáticamente. Proporciona al revisor las puntuaciones originales de Discuse y el historial del usuario como contexto:

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' };
}

La API en sí no tiene ningún parámetro de "contexto" o "historial del autor" por solicitud: el contexto es algo que aplicas de tu lado al elegir umbrales y dirigir contenido a revisión.

Errores comunes

Depender demasiado de la AI

Automatizar cada decisión significa automatizar cada error. Mantén siempre a una persona involucrada para:

Decisiones contextuales complejas
Contenido de alto riesgo (legal, seguridad)
Apelaciones y casos límite

Ignorar el contexto

Las mismas palabras pueden ser dañinas o aceptables según el contexto:

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

Discuse evalúa cada mensaje de forma aislada; no tiene un parámetro de "context" a nivel de solicitud. Aplica el contexto de tu lado: elige umbrales de proyecto más estrictos o más flexibles según la superficie (publicación pública frente a mensaje directo) y deriva los hits dudosos a revisión humana.

Configurarlo y olvidarse

La moderación de contenido requiere ajustes continuos:

Supervisa las tasas de falsos positivos y falsos negativos
Actualiza los umbrales según los datos
Revisa nuevos patrones de contenido
Vuelve a entrenar o actualiza los modelos

Aplicación incoherente

Aplica la política según reglas, no según quién haya publicado. Define los umbrales a partir de un nivel de confianza documentado, en lugar de excepciones improvisadas:

// 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];

Próximos pasos

Configurar umbrales - Ajusta con precisión tu moderación
Escalar la moderación de contenido - Gestiona grandes volúmenes
Análisis de texto - Profundiza en la moderación de texto
Detección de NSFW en imágenes - Protección del contenido visual