Moderación de contenido a gran escala
En esta página
Lección actualizada el 3 de noviembre de 2026 según la documentación de OpenAI:
temperatureytop_psolo se aceptan con un esfuerzo de razonamiento (reasoning effort) denone, mientras que los modelos GPT-5.6 razonan por defecto (medium). Por tanto, las llamadas que establezcan estos parámetros deben especificarreasoning={"effort": "none"}(API de Responses) oreasoning_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