Detecção de idioma

A Discuse identifica o idioma de uma mensagem para que você possa aplicar as regras de moderação corretas antes de agir sobre ela. Envie o texto para POST https://api.discuse.com/api/v2/check com check_language ativado e leia o código do idioma detectado em results.language.language. Adicione expected_language para sinalizar conteúdo que não esteja no idioma exigido por você.

Para que serve a detecção de idioma?

Detectar o idioma antecipadamente permite que você:

• Aplique limites de moderação específicos por idioma
• Encaminhe o conteúdo para os revisores ou a equipe de suporte certos
• Faça cumprir uma política de idioma da comunidade
• Filtre ou localize feeds por idioma

Como faço para detectar um idioma?

curl -X POST https://api.discuse.com/api/v2/check \
  -H "Content-Type: application/json" \
  -H "X-API-Key: YOUR_API_KEY" \
  -d '{
    "content": {
      "text": "Bonjour, comment allez-vous aujourd'\''hui?"
    },
    "settings": {
      "check_language": true
    }
  }'

Formato da resposta

{
  "has_violations": false,
  "cached": false,
  "results": {
    "language": {
      "language": "fr",
      "confidence": 0.99,
      "hit": false
    }
  }
}

O código do idioma detectado está em results.language.language. Quando a aplicação de expected_language estiver ativa, detected e expected também serão preenchidos (veja abaixo).

Quais campos o resultado de idioma retorna?

Campo	Tipo	Significado
language	string	Código do idioma detectado (por exemplo, en, fr, es)
confidence	number	Confiança da detecção (0.0–1.0)
expected	string	O código do idioma exigido, quando expected_language está definido
detected	string	Código detectado (alias de language, preenchido durante a aplicação)
hit	bool	True quando o idioma detectado não corresponde a expected
delete_only	bool	Quando true, a mensagem deve ser excluída sem punição adicional
error	string	Presente apenas quando a detecção falhou

Quais idiomas são compatíveis?

A Discuse retorna códigos de idioma no estilo ISO. Idiomas comumente detectados incluem:

Código	Idioma	Código	Idioma
en	Inglês	de	Alemão
es	Espanhol	fr	Francês
it	Italiano	pt	Português
nl	Holandês	pl	Polonês
ru	Russo	uk	Ucraniano
zh	Chinês	ja	Japonês
ko	Coreano	ar	Árabe
hi	Hindi	tr	Turco

Leia o valor diretamente de results.language.language, em vez de codificar uma lista fixa.

Como faço para exigir um idioma específico?

Defina expected_language como o código que você exige. Quando o idioma detectado for diferente, language.hit será true e expected/detected serão preenchidos:

Solicitação:

{
  "content": { "text": "Hola, cómo estás?" },
  "settings": {
    "check_language": true,
    "expected_language": "en"
  }
}

Resposta:

{
  "has_violations": true,
  "message": "Content is not in expected language",
  "results": {
    "hits": true,
    "language": {
      "language": "es",
      "detected": "es",
      "expected": "en",
      "confidence": 0.97,
      "hit": true
    }
  }
}

Casos de uso

Fóruns somente em inglês

async function validatePost(post) {
  const result = 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: post.content },
      settings: { check_language: true, expected_language: 'en' }
    })
  }).then(r => r.json());

  if (result.results.language.hit) {
    return {
      approved: false,
      reason: 'Posts must be in English',
      detected_language: result.results.language.language
    };
  }
  return { approved: true };
}

Roteamento multilíngue

async function routeContent(content) {
  const result = await checkLanguage(content.text);
  const language = result.results.language.language;

  const moderatorQueue = {
    en: 'english-moderation',
    es: 'spanish-moderation',
    fr: 'french-moderation',
    de: 'german-moderation',
    default: 'general-moderation'
  };

  const queue = moderatorQueue[language] || moderatorQueue.default;
  await addToQueue(queue, content);
  return { queued: true, language };
}

Combinação com moderação de conteúdo

Execute a detecção de idioma junto com sentimento e spam em uma única solicitação:

{
  "content": {
    "text": "User message in any language"
  },
  "settings": {
    "check_language": true,
    "check_sentiment": true,
    "check_spam": true
  }
}

O idioma detectado pode então orientar seus limites de sentimento por idioma:

const LANGUAGE_THRESHOLDS = {
  en: { toxicity: 0.7, profanity: 0.6 },
  de: { toxicity: 0.6, profanity: 0.5 },
  es: { toxicity: 0.7, profanity: 0.7 },
  default: { toxicity: 0.7, profanity: 0.6 }
};

async function moderateContent(text) {
  const result = await checkText(text); // check_language + check_sentiment
  const language = result.results.language.language;
  const thresholds = LANGUAGE_THRESHOLDS[language] || LANGUAGE_THRESHOLDS.default;
  const sentiment = result.results.sentiment;

  if (sentiment.toxicity > thresholds.toxicity) {
    return { action: 'block', reason: 'toxic_content' };
  }
  if (sentiment.profanity > thresholds.profanity) {
    return { action: 'flag', reason: 'profanity' };
  }
  return { action: 'allow' };
}

Boas práticas

Leve textos curtos em conta

A detecção é menos confiável em strings muito curtas. Ignore a verificação abaixo de um tamanho mínimo:

async function smartLanguageCheck(text) {
  if (text.length < 20) {
    return { language: 'unknown', confidence: 0 };
  }
  const result = await checkLanguage(text);
  return result.results.language;
}

Armazene resultados em cache

async function getLanguageWithCache(text, contentId) {
  const cached = await cache.get(`lang:${contentId}`);
  if (cached) return JSON.parse(cached);

  const result = await checkLanguage(text);
  const language = result.results.language;
  await cache.set(`lang:${contentId}`, JSON.stringify(language), 'EX', 3600);
  return language;
}

Limites de uso

A detecção de idioma consome sua cota de análise de texto:

Plano	Análises mensais
Basic	1.000
Gold	5.000
Platinum	15.000
Ultimate	30.000

Respostas em cache não contam para sua cota.

Exemplos de integração

Node.js

const checkLanguage = async (text, expectedLanguage = null) => {
  const settings = { check_language: true };
  if (expectedLanguage) settings.expected_language = expectedLanguage;

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

  return response.json();
};

Python

import os
import requests

def check_language(text, expected_language=None):
    settings = {'check_language': True}
    if expected_language:
        settings['expected_language'] = expected_language

    response = requests.post(
        'https://api.discuse.com/api/v2/check',
        headers={
            'Content-Type': 'application/json',
            'X-API-Key': os.environ['DISCUSE_API_KEY']
        },
        json={'content': {'text': text}, 'settings': settings}
    )
    return response.json()

Próximos passos

• Análise de texto - combine com detecção de sentimento e spam
• Detecção de spam - classifique conteúdo promocional e fraudulento
• Guia de início rápido - obtenha sua primeira chave de API