Ir al contenido principal
Español— Elegir un idioma
Menú

Moderación de contenido a gran escala

Lección 19 de 20 Actualizado el 3 de noviembre de 2026 Avanzado
En esta página
  1. Protección de tus usuarios en producción
  2. La primera capa: la API de Moderations
  3. Gestión de la carga
  4. Mantener un registro defendible
  5. Puntos clave

Lección actualizada el 3 de noviembre de 2026 según la documentación de OpenAI: temperature y top_p solo se aceptan con un esfuerzo de razonamiento (reasoning effort) de none, mientras que los modelos GPT-5.6 razonan por defecto (medium). Por tanto, las llamadas que establezcan estos parámetros deben especificar reasoning={"effort": "none"} (API de Responses) o reasoning_effort="none" (Chat Completions). Fuentes: Uso de GPT-6 · GPT-5.6 Terra.

Protección de tus usuarios en producción

En cuanto tu aplicación se pone en marcha, debes gestionar el contenido inapropiado, tanto en la entrada (prompts maliciosos) como en la salida (respuestas problemáticas). Este requisito bidireccional suele pillar desprevenidos a los equipos. La mayoría piensa primero en filtrar lo que envían los usuarios, pero el riesgo reputacional se concentra en lo que tu aplicación publica bajo tu nombre. Un modelo bien alineado rara vez genera contenido impactante por sí solo, pero puede hacerlo si se le presiona, y tu marca aparecerá en la parte superior de la captura de pantalla.

Pasaremos de una única llamada a la API a un canal asíncrono de alto rendimiento, escalando paso a paso.

La primera capa: la API de Moderations

La API de Moderations clasifica el texto en varias categorías de riesgo y devuelve tanto un veredicto binario como puntuaciones detalladas. Es rápida y gratuita, lo que la convierte en el primer filtro natural para cualquier aplicación pública. La función siguiente solo muestra las categorías con puntuaciones superiores a 0,3, un umbral deliberadamente bajo. En esta fase, quieres ver qué se acerca a la línea, no solo qué la cruza.

import openai

client = openai.OpenAI()

def moderate_content(text: str) -> dict:
    """Comprueba si el texto contiene contenido inapropiado."""
    response = client.moderations.create(
        model="omni-moderation-latest",
        input=text,
    )

    result = response.results[0]
    return {
        "flagged": result.flagged,
        "categories": {
            cat: score
            for cat, score in result.category_scores.__dict__.items()
            if score > 0.3
        },
    }

# Ejemplo
result = moderate_content("How do I bake a chocolate cake?")
print(f"Flagged: {result['flagged']}")

En producción, un veredicto binario no es suficiente. Dependiendo del contenido y del contexto, es posible que quieras permitirlo, reescribirlo, bloquearlo o escalarlo a un humano: cuatro decisiones distintas que debes nombrar explícitamente en el código en lugar de improvisar con booleanos. El siguiente canal formaliza estas acciones, aplica umbrales por categoría y añade una segunda capa para la detección de inyección de prompts.

from enum import Enum
from dataclasses import dataclass

class ModerationAction(Enum):
    ALLOW = "allow"
    MODIFY = "modify"
    BLOCK = "block"
    ESCALATE = "escalate"

@dataclass
class ModerationResult:
    action: ModerationAction
    reason: str | None = None
    modified_content: str | None = None

class ModerationPipeline:
    """Canal de moderación multicapa."""

    def __init__(self, thresholds: dict | None = None):
        self.thresholds = thresholds or {
            "harassment": 0.7,
            "hate": 0.7,
            "self-harm": 0.5,
            "sexual": 0.7,
            "violence": 0.7,
        }

    def moderate_input(self, text: str) -> ModerationResult:
        """Modera el contenido de entrada (prompt del usuario)."""
        moderation = client.moderations.create(
            model="omni-moderation-latest",
            input=text,
        )

        result = moderation.results[0]
        if result.flagged:
            problematic_categories = [
                cat for cat, flagged in result.categories.__dict__.items()
                if flagged
            ]
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason=f"Contenido inapropiado: {', '.join(problematic_categories)}",
            )

        # Detección de inyección de prompts
        if self._detect_injection(text):
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason="Intento de inyección de prompt detectado",
            )

        return ModerationResult(action=ModerationAction.ALLOW)

    def moderate_output(self, response: str) -> ModerationResult:
        """Modera el contenido de salida (respuesta del LLM)."""
        moderation = client.moderations.create(
            model="omni-moderation-latest",
            input=response,
        )

        if moderation.results[0].flagged:
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason="La respuesta generada contiene contenido inapropiado",
            )

        return ModerationResult(action=ModerationAction.ALLOW)

    def _detect_injection(self, text: str) -> bool:
        """Detecta intentos de inyección de prompts."""
        markers = [
            "ignore previous instructions",
            "ignore your instructions",
            "forget your guidelines",
            "you are now",
            "new role",
            "system prompt",
            "jailbreak",
        ]
        text_lower = text.lower()
        return any(m in text_lower for m in markers)

El umbral de 0,5 para self-harm, más estricto que el 0,7 utilizado para otras categorías, ilustra el razonamiento que debes aplicar a cada umbral. Aquí, el coste de un falso positivo no se acerca ni de lejos al coste de un falso negativo, por lo que bajas el listón. Realiza esta compensación categoría por categoría, en función de tu audiencia, en lugar de aplicar un valor uniforme.

La detección de inyecciones basada en marcadores tiene un pero. Detecta intentos ingenuos, que representan la mayor parte del volumen, y nada más: una formulación ligeramente diferente o una versión traducida se cuela. Trátala como un filtro de ruido, no como una defensa. La protección real contra la inyección es arquitectónica: nunca des al modelo capacidades que un prompt secuestrado pueda explotar.

Gestión de la carga

En una aplicación con mucho tráfico, la moderación síncrona se convierte en un cuello de botella: cada mensaje espera su veredicto antes de procesarse. Un moderador asíncrono desacopla estos pasos poniendo el contenido en una cola para que lo consuman varios trabajadores, al tiempo que rastrea estadísticas útiles por el camino.

import asyncio

class AsyncModerator:
    """Modera contenido de forma asíncrona para alto rendimiento."""

    def __init__(self, num_workers: int = 10):
        self.pipeline = ModerationPipeline()
        self.queue: asyncio.Queue = asyncio.Queue()
        self.num_workers = num_workers
        self.stats = {"allowed": 0, "blocked": 0, "escalated": 0}

    async def worker(self):
        while True:
            task = await self.queue.get()
            try:
                result = self.pipeline.moderate_input(task["text"])
                task["callback"](result)

                match result.action:
                    case ModerationAction.ALLOW:
                        self.stats["allowed"] += 1
                    case ModerationAction.BLOCK:
                        self.stats["blocked"] += 1
                    case ModerationAction.ESCALATE:
                        self.stats["escalated"] += 1
            finally:
                self.queue.task_done()

    async def start(self):
        for _ in range(self.num_workers):
            asyncio.create_task(self.worker())

    def report(self) -> str:
        total = sum(self.stats.values())
        if total == 0:
            return "No se ha moderado ningún contenido."
        return (
            f"Total: {total} | "
            f"Permitidos: {self.stats['allowed']} ({self.stats['allowed']/total:.1%}) | "
            f"Bloqueados: {self.stats['blocked']} ({self.stats['blocked']/total:.1%})"
        )

La tasa de bloqueo que produce report es tu métrica principal de calibración. Si salta repentinamente al 15 % después de funcionar al 0,5 %, solo hay dos explicaciones: estás bajo un ataque coordinado o acabas de romper tus umbrales. En cualquier caso, querrás saberlo en la hora, no en la próxima revisión mensual.

Cabe mencionar una limitación final: la API de Moderations no sabe nada de tu negocio. Un mensaje perfectamente aceptable en general puede violar tus propias normas: solicitar asesoramiento médico a un asistente bancario, intentar obtener una tarifa fuera de red o saltarse un procedimiento. La moderación contextual añade esta capa enviando el mensaje a un modelo con tus normas explícitas, pero solo después de que el filtro estándar lo haya dejado pasar.

def contextual_moderation(
    text: str,
    app_context: str,
    business_rules: list[str],
) -> ModerationResult:
    """Moderación consciente del contexto adaptada a la aplicación."""
    pipeline = ModerationPipeline()
    standard_result = pipeline.moderate_input(text)

    if standard_result.action == ModerationAction.BLOCK:
        return standard_result

    verification_prompt = (
        f"Contexto de la aplicación: {app_context}\n\n"
        f"Normas empresariales a verificar:\n"
        + "\n".join(f"- {r}" for r in business_rules)
        + f"\n\nMensaje del usuario: {text}\n\n"
        "¿Cumple el mensaje con todas las normas? "
        "Responde sí o no con una breve justificación."
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requiere effort none
        input=verification_prompt,
        max_output_tokens=100,
        temperature=0.0,
    )

    if "no" in response.output_text.lower()[:10]:
        return ModerationResult(
            action=ModerationAction.BLOCK,
            reason=response.output_text,
        )

    return ModerationResult(action=ModerationAction.ALLOW)

El orden de estas dos comprobaciones importa. El filtro gratuito y rápido se ejecuta primero, y la llamada al modelo de pago solo ocurre para los mensajes que lo superan. Con tráfico real, esto cubre casi todos los mensajes. Hacer lo contrario, pagar por una llamada al modelo para contenido que la API de Moderations habría rechazado en milisegundos, sería un desperdicio.

Mantener un registro defendible

Una decisión de moderación es una decisión de la que tendrás que rendir cuentas, de un modo u otro. Necesitas un registro, pero uno que no se convierta en un problema en sí mismo. El comentario en el código destaca la línea más importante del archivo: registra la acción, el motivo y la longitud, nunca el texto crudo. Almacenar mensajes de usuario en un archivo de registro te expone a obligaciones de protección de datos mucho más pesadas que el servicio prestado.

import json
import time
from pathlib import Path

class ModerationLog:
    """Registra todas las decisiones de moderación para fines de auditoría."""

    def __init__(self, log_path: str = "logs/moderation.jsonl"):
        self.path = Path(log_path)
        self.path.parent.mkdir(parents=True, exist_ok=True)

    def record(
        self,
        text: str,
        result: ModerationResult,
        source: str = "input",
    ):
        entry = {
            "timestamp": time.time(),
            "source": source,
            "action": result.action.value,
            "reason": result.reason,
            "text_length": len(text),
            # NO registrar el texto crudo por privacidad
        }

        with open(self.path, "a") as f:
            f.write(json.dumps(entry) + "\n")

Si aun así necesitas poder recuperar un mensaje específico durante una disputa, registra un hash del texto en lugar del texto en sí. Esto te permite confirmar que un contenido dado coincide con una decisión registrada sin retener el contenido en tu lado.

Puntos clave

  • Modera tanto las entradas (prompts) como las salidas (respuestas)
  • Usa la API de Moderations como tu primera capa, rápida y gratuita
  • Ajusta los umbrales categoría por categoría en función del coste real de un falso negativo
  • Añade detección de inyecciones sabiendo que solo captura intentos ingenuos
  • Registra todas las decisiones para auditoría sin almacenar contenido crudo