Define tu política de contenidos
En esta página
Actualizado el 3 de noviembre de 2026. Las políticas anteriores utilizaban tres categorías inexistentes (
hate,violence,unpredictable) y omitíandangerous. Ahora se alinean con las once claves demistral-moderation-2603. Se ha añadido un método para convertir una política al formato oficial del parámetroguardrails, garantizando que se apliquen umbrales coherentes antes de la generación. Fuentes: Moderation & Guardrailing · SDKmistralai3.7.0.
Por qué necesitas una política de contenidos formal
Los umbrales de moderación no son elecciones técnicas arbitrarias. Reflejan una política de contenidos: un conjunto de normas que define qué permite y qué prohíbe tu aplicación. Sin una política formal, cada desarrollador toma sus propias decisiones y tu sistema de seguridad pierde coherencia: dos servicios dentro de la misma empresa acaban bloqueando contenidos distintos sin que nadie sepa por qué.
Una política escrita te permite justificar las decisiones de moderación tanto ante los usuarios como ante los reguladores, armonizar los umbrales entre equipos y aplicaciones, auditar el cumplimiento del sistema e iterar de forma estructurada a medida que cambian las necesidades. El día que un usuario impugne un bloqueo, la diferencia entre «el umbral está fijado en 0,1» y «nuestra Política de Cara al Público v1.2 establece este umbral por esta razón» es abismal.
Adaptar los umbrales al contexto de la aplicación
El mismo contenido puede ser aceptable en un contexto y peligroso en otro. Tu política debe reflejar estos matices. La mejor forma de lograrlo es describir cada perfil como un objeto con nombre, fecha y documentación, en lugar de un diccionario anónimo perdido en el código.
Para un chatbot de cara al público, la regla es simple: estricto en todo, con la seguridad como prioridad. No sabes nada de la persona al otro lado y puede haber menores presentes.
# Política: Estricto en todo, seguridad primero
POLICY_PUBLIC = {
"name": "Public-Facing",
"description": "Chatbot accesible para todos, incluidos menores",
"thresholds": {
"sexual": 0.1,
"hate_and_discrimination": 0.1,
"violence_and_threats": 0.1,
"dangerous": 0.1,
"criminal": 0.1,
"selfharm": 0.1,
"health": 0.2,
"financial": 0.2,
"law": 0.2,
"pii": 0.1,
"jailbreaking": 0.1,
},
"block_action": "generic_message",
"logging": "full"
}
Un asistente interno cambia las reglas del juego en un punto: los usuarios están autenticados, lo que significa que son identificables y responsables. Esto permite umbrales más flexibles, especialmente en financial y law, fijados en 0,6, ya que un empleado que consulta al asistente sobre la estructura de un contrato simplemente está haciendo su trabajo.
# Política: Equilibrada, usuarios identificados
POLICY_INTERNAL = {
"name": "Internal B2B",
"description": "Asistente para empleados autenticados",
"thresholds": {
"sexual": 0.2,
"hate_and_discrimination": 0.15,
"violence_and_threats": 0.3,
"dangerous": 0.2,
"criminal": 0.15,
"selfharm": 0.15,
"health": 0.5,
"financial": 0.6,
"law": 0.6,
"pii": 0.3,
"jailbreaking": 0.15,
},
"block_action": "detailed_message",
"logging": "full"
}
Una herramienta especializada (médica, legal o financiera) lleva esta lógica hasta sus últimas consecuencias: muy permisiva dentro de su dominio, estricta en todo lo demás. En el ejemplo médico, health sube a 0,85 porque discutir diagnósticos es precisamente la función de la herramienta, mientras que pii baja a 0,15 porque los datos de los pacientes nunca deben circular. Aquí se añaden dos elementos ausentes en políticas anteriores: un modo de bloqueo con redirección y un descargo de responsabilidad explícito.
# Política: Permisiva en el dominio, estricta en el resto
POLICY_MEDICAL = {
"name": "Medical Assistant",
"description": "Herramienta para profesionales de la salud",
"thresholds": {
"sexual": 0.2,
"hate_and_discrimination": 0.1,
"violence_and_threats": 0.3,
"dangerous": 0.1,
"criminal": 0.1,
"selfharm": 0.3,
"health": 0.85, # Muy permisiva: dominio legítimo
"financial": 0.3,
"law": 0.4,
"pii": 0.15, # Estricta: datos de pacientes
"jailbreaking": 0.1,
},
"block_action": "detailed_message_with_redirect",
"logging": "full_with_audit",
"disclaimer": "Esta herramienta no sustituye el consejo médico."
}
Formalizar la política como documento
Tu política de contenidos debe ser un documento versionado accesible para todos los equipos. En Python, esto se traduce en una clase que lleva el número de versión y la fecha de revisión junto con los umbrales, y que puede tanto evaluar puntuaciones como generar el mensaje de bloqueo correspondiente al modo declarado.
from mistralai.client.models import GuardrailConfigTypedDict
class ContentPolicy:
"""Representación estructurada de una política de contenidos."""
def __init__(self, config: dict):
self.name = config["name"]
self.description = config["description"]
self.thresholds = config["thresholds"]
self.block_action = config["block_action"]
self.logging = config["logging"]
self.version = config.get("version", "1.0.0")
self.revision_date = config.get("revision_date", "2026-04-01")
def evaluate(self, scores: dict) -> dict:
"""Evalúa las puntuaciones frente a la política."""
violations = []
for cat, threshold in self.thresholds.items():
score = scores.get(cat, 0)
if score > threshold:
violations.append({
"category": cat,
"score": round(score, 3),
"threshold": threshold
})
return {
"policy": self.name,
"version": self.version,
"allowed": len(violations) == 0,
"violations": violations
}
def block_message(self, violations: list) -> str:
"""Genera un mensaje de bloqueo apropiado."""
if self.block_action == "generic_message":
return "Este contenido no puede procesarse."
elif self.block_action == "detailed_message":
cats = ", ".join(v["category"] for v in violations)
return (f"Contenido bloqueado por las siguientes razones: "
f"{cats}. Por favor, reformula tu solicitud.")
return "Contenido bloqueado."
def to_guardrails(self) -> list[GuardrailConfigTypedDict]:
"""Traduce la política al parámetro guardrails para la API de Mistral."""
return [
{
"block_on_error": True,
"moderation_llm_v2": {
"custom_category_thresholds": self.thresholds,
"ignore_other_categories": False,
"action": "block",
},
}
]
El método to_guardrails convierte la política en la única fuente de verdad para los guardarraíles: client.chat.complete(..., guardrails=policy.to_guardrails()) o client.beta.agents.create(..., guardrails=policy.to_guardrails()). Los umbrales aplicados antes y después de la generación ya no pueden divergir.
Observa también que el resultado de evaluate incluye el nombre y la versión de la política aplicada. Este detalle te permite, seis meses después, reproducir una decisión impugnada sabiendo exactamente bajo qué régimen se tomó.
Gestión multiaplicación
Si tu empresa gestiona varias aplicaciones, centraliza la gestión de políticas. El gestor siguiente hace dos cosas útiles: rechaza explícitamente servir a una aplicación sin una política declarada, evitando despliegues sin redes de seguridad, y produce un informe de cumplimiento que lista la versión y la fecha de la última revisión de cada aplicación, exactamente lo que pedirá un auditor.
class PolicyManager:
"""Gestiona políticas de contenidos para múltiples aplicaciones."""
def __init__(self):
self.policies = {}
def register(self, app_id: str, policy: ContentPolicy):
"""Registra una política para una aplicación."""
self.policies[app_id] = policy
def get(self, app_id: str) -> ContentPolicy:
"""Recupera la política para una aplicación."""
if app_id not in self.policies:
raise ValueError(f"No hay política para {app_id}")
return self.policies[app_id]
def compliance_report(self) -> dict:
"""Genera un informe de cumplimiento global."""
return {
app_id: {
"name": pol.name,
"version": pol.version,
"revision_date": pol.revision_date,
"categories_covered": len(pol.thresholds)
}
for app_id, pol in self.policies.items()
}
# Uso
manager = PolicyManager()
manager.register("chatbot-public",
ContentPolicy(POLICY_PUBLIC))
manager.register("assistant-medical",
ContentPolicy(POLICY_MEDICAL))
Revisión y actualizaciones
Tu política no está escrita en piedra. El error más común es redactarla una vez y olvidarla. Establece un ritmo: cada semana, analiza los falsos positivos y falsos negativos reportados en tus registros; cada mes, ajusta los umbrales basándote en las métricas acumuladas; cada trimestre, realiza una revisión completa con las partes interesadas de negocio, legales y producto. Añade a esto una regla innegociable: tras cada incidente, realiza un análisis post-mortem e implementa una corrección inmediata, sin esperar a la siguiente revisión programada.
Puntos clave
- Una política de contenidos traduce tus umbrales técnicos en reglas de negocio
- Adapta los umbrales al contexto: de cara al público, interno, especializado
- Formaliza la política en un documento versionado
- Centraliza la gestión si tienes múltiples aplicaciones
- Revisa periódicamente: la política debe evolucionar con tu producto