Detección de idioma

Discuse identifica el idioma de un mensaje para que puedas aplicar las reglas de moderación adecuadas antes de actuar sobre él. Envía texto a POST https://api.discuse.com/api/v2/check con check_language habilitado y lee el código de idioma detectado en results.language.language. Añade expected_language para marcar contenido que no esté en el idioma que necesitas.

¿Para qué sirve la detección de idioma?

Detectar el idioma de antemano te permite:

Aplicar umbrales de moderación específicos por idioma
Dirigir el contenido a los revisores o al equipo de soporte adecuados
Hacer cumplir una política de idioma en la comunidad
Filtrar o localizar feeds por idioma

¿Cómo detecto un 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 de respuesta

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

El código de idioma detectado está en results.language.language. Cuando la aplicación de expected_language está activada, detected y expected también se completan (ver más abajo).

¿Qué campos devuelve el resultado de idioma?

Campo	Tipo	Significado
`language`	string	Código de idioma detectado (p. ej., `en`, `fr`, `es`)
`confidence`	number	Confianza de la detección (0.0–1.0)
`expected`	string	El código de idioma exigido, cuando `expected_language` está configurado
`detected`	string	Código detectado (alias de `language`, completado durante la aplicación)
`hit`	bool	True cuando el idioma detectado no coincide con `expected`
`delete_only`	bool	Cuando es true, el mensaje debe eliminarse sin aplicar más sanciones
`error`	string	Presente solo cuando la detección falló

¿Qué idiomas son compatibles?

Discuse devuelve códigos de idioma de estilo ISO. Entre los idiomas detectados habitualmente se incluyen:

Código	Idioma	Código	Idioma
`en`	Inglés	`de`	Alemán
`es`	Español	`fr`	Francés
`it`	Italiano	`pt`	Portugués
`nl`	Neerlandés	`pl`	Polaco
`ru`	Ruso	`uk`	Ucraniano
`zh`	Chino	`ja`	Japonés
`ko`	Coreano	`ar`	Árabe
`hi`	Hindi	`tr`	Turco

Lee el valor directamente desde results.language.language en lugar de codificar una lista fija.

¿Cómo hago cumplir un idioma específico?

Configura expected_language con el código que necesitas. Cuando el idioma detectado es distinto, language.hit es true y expected/detected se completan:

Solicitud:

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

Respuesta:

{
  "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

Foros solo en 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 };
}

Enrutamiento multilingüe

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

Combinación con moderación de contenido

Ejecuta la detección de idioma junto con el análisis de sentimiento y spam en una sola solicitud:

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

El idioma detectado puede entonces determinar tus umbrales de sentimiento 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' };
}

Buenas prácticas

Ten en cuenta los textos cortos

La detección es menos fiable en cadenas muy cortas. Omite la comprobación por debajo de una longitud mínima:

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

Almacena resultados en caché

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

Límites de uso

La detección de idioma consume tu cuota de análisis de texto:

Plan	Análisis mensuales
Basic	1,000
Gold	5,000
Platinum	15,000
Ultimate	30,000

Las respuestas almacenadas en caché no cuentan para tu cuota.

Ejemplos de integración

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 pasos

Análisis de texto - combínalo con detección de sentimiento y spam
Detección de spam - clasifica contenido promocional y fraudulento
Guía de inicio rápido - consigue tu primera clave API