Skip to main content
Documentação
CENTRO DE APRENDIZAGEM

Domine a moderação de conteúdo com guias completos, tutoriais e documentação da API

Links rápidos

Guia de Moderação de Conteúdo com AI

Discuse verifica textos e imagens em busca de sentimento/toxicidade, spam, idioma indesejado, palavrões, links e imagens explícitas; em seguida, retorna um resultado por categoria para que seu código possa aprovar, sinalizar ou rejeitar conteúdo automaticamente. Você envia o conteúdo para um único endpoint, POST https://api.discuse.com/api/v2/check, e recebe de volta pontuações estruturadas. Este guia explica como as verificações funcionam, os padrões de moderação relacionados a elas e como integrar a Discuse API ao seu pipeline.

O que é moderação de conteúdo com AI?

A moderação de conteúdo com AI usa modelos de machine learning para detectar e classificar automaticamente conteúdos potencialmente nocivos. Enquanto um revisor humano analisa um item por vez, esses modelos atribuem pontuações ao conteúdo assim que ele chega, permitindo que os envios sejam verificados antes de serem exibidos a outros usuários.

Como funciona?

  1. Enviar conteúdo: Envie texto e/ou URLs de mídia para a API de moderação.
  2. Executar verificações: A API executa as verificações ativadas (sentimento, idioma, spam, palavrões, imagens, links, antivírus).
  3. Pontuar cada categoria: Cada verificação retorna pontuações e uma flag hit indicando se o limite configurado foi ultrapassado.
  4. Decidir: Leia has_violations (e as pontuações de cada verificação) para aprovar, sinalizar ou rejeitar.

Com o Discuse, a solicitação fica assim:

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 }

O que cada verificação do Discuse cobre?

Verificação (settings toggle) O que ela cobre Principais campos de resultado
check_sentiment Negatividade, toxicidade, profanidade, ameaças e insultos no texto sentiment.is_toxic, sentiment.toxicity, sentiment.score, sentiment.hit
check_spam Classificação de spam no texto spamfinder.label, spamfinder.confidence, spamfinder.is_spam, spamfinder.hit
check_language Se o texto corresponde ao idioma esperado language.language, language.confidence, language.hit
check_badwords Correspondências com uma lista personalizada de palavrões badwords.hit, badwords.matched_words
check_images Imagens explícitas em URLs de imagem images.porn, images.sexual, images.neutral, images.hit
check_links Reputação de links links.status, links.hit
check_antivirus Malware em URLs de documentos/arquivos antivirus.status, antivirus.hit

Cada toggle é um booleano. Os limites numéricos que transformam uma pontuação em um hit são configurados por projeto no painel, não enviados em cada solicitação — consulte o guia de configuração de limites.

Benefícios da moderação por AI

Escala

A AI processa volumes de conteúdo que equipes humanas não conseguem. Uma única chamada de API retorna resultados em milissegundos, então a moderação acompanha o ritmo dos envios em vez de ficar presa em uma fila de análise. Combine verificações automatizadas com uma fila humana para casos limítrofes (abordados abaixo).

Velocidade

Verificações em tempo real permitem filtrar conteúdo antes da publicação:

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

Consistência

A AI aplica as mesmas regras de forma uniforme a todo o conteúdo, sem fadiga e sem variação entre avaliadores. As decisões são reproduzíveis: a mesma entrada com os mesmos limites do projeto produz as mesmas flags hit, o que torna a aplicação das regras auditável.

Arquitetura de moderação

Fluxo de pré-moderação

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

Fluxo de pós-moderação

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

Abordagem híbrida (recomendada)

A resposta do Discuse define has_violations assim que qualquer verificação habilitada ultrapassa o limite configurado e expõe as pontuações subjacentes por categoria para que você possa adicionar sua própria faixa de confiança por cima:

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

Implementando moderação com AI

Etapa 1: Defina sua política

Decida quais conteúdos são aceitáveis e como agir em cada categoria antes de chamar a API. No Discuse, o limite numérico de cada categoria fica nas configurações do seu projeto (o painel), portanto a política da sua aplicação mapeia um resultado da API para uma ação, em vez de redefinir o limite:

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

Etapa 2: Integre a API

Envie o conteúdo e as verificações que você quer habilitar para esta solicitação. Cada alternância check_* é um booleano opcional que substitui o padrão do projeto para esta chamada:

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

Etapa 3: Aplique as decisões

Mapeie cada verificação que relata um hit para a ação que você definiu:

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

Etapa 4: Trate casos extremos

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

Melhores práticas

Comece de forma conservadora e ajuste ao longo do tempo

Comece com limites de projeto mais rígidos e afrouxe-os conforme você mede falsos positivos. No Discuse, esses limites são configurações do projeto, então o ajuste é feito no painel (ou pela API de atualização de configurações), não em cada solicitação. Consulte o guia de configuração de limites para ver o fluxo de trabalho.

Mantenha uma fila de revisão humana

A AI deve complementar, não substituir, o julgamento humano em casos limítrofes:

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

Monitore e melhore

Acompanhe as principais métricas para aprimorar seu sistema de moderação:

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

Trate recursos com cuidado

Quando um usuário recorrer, encaminhe o item para um revisor humano em vez de tomar uma nova decisão automaticamente. Dê ao revisor as pontuações originais do Discuse e o histórico do usuário 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' };
}

A API em si não tem um parâmetro de "contexto" ou "histórico do autor" por solicitação — contexto é algo que você aplica do seu lado ao escolher limites e encaminhar para revisão.

Armadilhas comuns

Dependência excessiva de AI

Automatizar todas as decisões significa automatizar todos os erros. Mantenha uma pessoa no processo para:

  • Decisões contextuais complexas
  • Conteúdos de alto risco (jurídico, segurança)
  • Recursos e casos excepcionais

Ignorar o contexto

As mesmas palavras podem ser prejudiciais ou aceitáveis dependendo do contexto:

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

Discuse avalia cada mensagem isoladamente; não há um parâmetro de "contexto" no nível da solicitação. Aplique o contexto do seu lado: escolha limites de projeto mais rigorosos ou mais flexíveis para cada superfície (publicação pública vs. mensagem direta) e encaminhe hits limítrofes para revisão humana.

Configurar e esquecer

A moderação de conteúdo exige ajustes contínuos:

  • Monitore as taxas de falsos positivos/negativos
  • Atualize os limites com base nos dados
  • Revise novos padrões de conteúdo
  • Retreine ou atualize modelos

Aplicação inconsistente

Aplique a política por regra, não com base em quem publicou. Defina limites a partir de um nível de confiança documentado, em vez de exceções ad hoc:

// 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 passos

Escrito por Equipe Discuse · Última atualização em June 2026

Artigos relacionados

Configuração de limites de detecção

Equilibre falsos positivos e negativos para seu caso de uso

Escalonamento da moderação de conteúdo

Padrões de arquitetura para moderação de conteúdo em alto volume