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

Arquitectura de seguridad completa

Lección 12 de 12 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. Ensamblaje de todas las piezas
  2. Visión general de la arquitectura
  3. Implementación completa
  4. Uso en producción
  5. Monitorización y alertas
  6. Resumen del curso
  7. Puntos clave
  8. Pon a prueba tus conocimientos

Actualizado el 3 de noviembre de 2026. La capa de generación utilizaba anteriormente un formato de barreras de seguridad inventado (enabled), y la política de producción empleaba categorías inexistentes (hate, violence, unpredictable). El código sigue ahora el formato oficial moderation_llm_v2 y las once claves de mistral-moderation-2603. Las puntuaciones, que son opcionales en el SDK, se leen con un valor de reserva. Código verificado frente a los tipos del SDK mistralai versión 3.7.0. Fuentes: Moderation & Guardrailing · Python SDK mistralai.

Ensamblaje de todas las piezas

A lo largo de este curso has explorado las barreras de seguridad, la API de Moderación, las 11 categorías, los umbrales, la detección de jailbreak, el cumplimiento del RGPD y las políticas de contenido. Esta última lección ensambla todos estos bloques de construcción en una arquitectura de seguridad completa lista para producción.

Visión general de la arquitectura

Existen cinco capas, impulsadas por un principio: ninguna de ellas es fiable por sí sola. Una barrera de seguridad puede sortearse mediante una formulación inesperada, un modelo de moderación tiene falsos negativos y una política de contenido nunca cubre todos los casos. Apilarlas funciona porque las lagunas no se solapan: lo que se cuela por la primera capa tiene buenas posibilidades de ser atrapado por la segunda.

La consecuencia práctica es un orden estricto: cada capa debe ser lo más económica posible antes de que se ejecute la siguiente. Validas el formato antes de llamar a una barrera de seguridad, y llamas a la barrera antes de generar, porque el contenido rechazado en el paso 1 consume cero tokens.

Usuario
    ↓
[1. Validación de entrada] → Regex, patrones, limitación de tasa
    ↓
[2. Barreras de seguridad de Mistral]  → Bloqueo previo a la generación (403)
    ↓
[3. Generación del LLM]      → safe_prompt + instrucciones seguras
    ↓
[4. Moderación de salida]   → API de Moderación post-generación
    ↓
[5. Registro y auditoría]     → Puntuaciones, decisiones, rastro de auditoría RGPD
    ↓
Respuesta al usuario

Implementación completa

from mistralai.client import Mistral
from mistralai.client.errors import SDKError
import os
import re
import json
import logging
from datetime import datetime, timezone
from enum import Enum

# Configuración
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("moderation")


class Decision(Enum):
    ALLOWED = "allowed"
    BLOCKED_INPUT = "blocked_input"
    BLOCKED_GUARDRAIL = "blocked_guardrail"
    BLOCKED_OUTPUT = "blocked_output"
    ERROR = "error"


class SecureArchitecture:
    """Arquitectura de seguridad completa para aplicaciones de IA."""

    def __init__(self, policy: dict, model: str = "mistral-large-latest"):
        self.policy = policy
        self.model = model
        self.stats = {d.value: 0 for d in Decision}

    # --- Capa 1: Validación de entrada ---

    def validate_input(self, text: str) -> dict:
        """Validación rápida antes de cualquier llamada a la API."""
        # Longitud máxima
        if len(text) > 10000:
            return {"valid": False, "reason": "Mensaje demasiado largo"}

        # Caracteres sospechosos (inyecciones Unicode)
        if re.search(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", text):
            return {"valid": False, "reason": "Caracteres no válidos"}

        # Patrones obvios de jailbreak
        patterns = [
            r"ignore\s+(all\s+)?(previous|prior|above)",
            r"you\s+are\s+now\s+(DAN|unfiltered)",
            r"oublie\s+(toutes?\s+)?(tes|vos)\s+instructions",
            r"system\s*prompt",
        ]
        for pattern in patterns:
            if re.search(pattern, text, re.IGNORECASE):
                return {
                    "valid": False,
                    "reason": "Patrón de inyección detectado"
                }

        return {"valid": True}

    # --- Capa 2: Moderación de entrada ---

    def moderate_input(self, text: str) -> dict:
        """Moderación del prompt mediante API."""
        response = client.classifiers.moderate(
            model="mistral-moderation-2603",
            inputs=[text]
        )
        scores = response.results[0].category_scores or {}
        violations = self._check_thresholds(scores)

        return {
            "allowed": len(violations) == 0,
            "scores": scores,
            "violations": violations
        }

    # --- Capa 3: Generación segura ---

    def generate(self, messages: list) -> str:
        """Generación con barreras de seguridad y safe_prompt."""
        response = client.chat.complete(
            model=self.model,
            messages=messages,
            safe_prompt=True,
            guardrails=[
                {
                    "block_on_error": True,
                    "moderation_llm_v2": {
                        "custom_category_thresholds": self.policy["thresholds"],
                        "action": "block",
                    },
                }
            ],
        )
        content = response.choices[0].message.content
        return content if isinstance(content, str) else ""

    # --- Capa 4: Moderación de salida ---

    def moderate_output(self, prompt: str, response_text: str) -> dict:
        """Moderación de la respuesta en contexto."""
        response = client.classifiers.moderate_chat(
            model="mistral-moderation-2603",
            inputs=[[
                {"role": "user", "content": prompt},
                {"role": "assistant", "content": response_text}
            ]]
        )
        scores = response.results[0].category_scores or {}
        violations = self._check_thresholds(scores)

        return {
            "allowed": len(violations) == 0,
            "scores": scores,
            "violations": violations
        }

    # --- Capa 5: Registro ---

    def log_decision(self, decision: Decision, data: dict):
        """Registra la decisión para auditoría."""
        self.stats[decision.value] += 1
        entry = {
            "timestamp": datetime.now(timezone.utc).isoformat(),
            "decision": decision.value,
            "policy": self.policy["name"],
            **data
        }
        logger.info(json.dumps(entry, ensure_ascii=False))

    # --- Canalización principal ---

    def process(self, user_message: str,
                system_prompt: str | None = None) -> dict:
        """Canalización de procesamiento seguro completa."""

        # Capa 1: Validación
        validation = self.validate_input(user_message)
        if not validation["valid"]:
            self.log_decision(Decision.BLOCKED_INPUT, {
                "reason": validation["reason"]
            })
            return {
                "status": Decision.BLOCKED_INPUT.value,
                "message": "No se puede procesar tu mensaje."
            }

        # Capa 2: Moderación de entrada
        check_input = self.moderate_input(user_message)
        if not check_input["allowed"]:
            self.log_decision(Decision.BLOCKED_INPUT, {
                "violations": check_input["violations"]
            })
            return {
                "status": Decision.BLOCKED_INPUT.value,
                "message": "Este contenido infringe nuestra política."
            }

        # Capa 3: Generación
        messages = []
        if system_prompt:
            messages.append({"role": "system",
                           "content": system_prompt})
        messages.append({"role": "user",
                        "content": user_message})

        try:
            response_text = self.generate(messages)
        except SDKError as e:
            if e.status_code == 403:
                self.log_decision(Decision.BLOCKED_GUARDRAIL, {})
                return {
                    "status": Decision.BLOCKED_GUARDRAIL.value,
                    "message": "Solicitud bloqueada por las barreras de seguridad."
                }
            raise

        # Capa 4: Moderación de salida
        check_output = self.moderate_output(user_message, response_text)
        if not check_output["allowed"]:
            self.log_decision(Decision.BLOCKED_OUTPUT, {
                "violations": check_output["violations"]
            })
            return {
                "status": Decision.BLOCKED_OUTPUT.value,
                "message": "La respuesta ha sido filtrada."
            }

        # Éxito
        self.log_decision(Decision.ALLOWED, {
            "input_max_score": max(check_input["scores"].values(), default=0.0),
            "output_max_score": max(check_output["scores"].values(), default=0.0),
        })

        return {
            "status": Decision.ALLOWED.value,
            "content": response_text,
            "moderation": {
                "input": check_input["scores"],
                "output": check_output["scores"]
            }
        }

    # --- Utilidades ---

    def _check_thresholds(self, scores: dict) -> list:
        """Comprueba las puntuaciones frente a los umbrales de la política."""
        violations = []
        for cat, threshold in self.policy["thresholds"].items():
            score = scores.get(cat, 0)
            if score > threshold:
                violations.append({
                    "category": cat,
                    "score": round(score, 3),
                    "threshold": threshold
                })
        return violations

    def report(self) -> dict:
        """Genera un informe de estadísticas."""
        total = sum(self.stats.values())
        return {
            "policy": self.policy["name"],
            "total_requests": total,
            "decisions": self.stats,
            "block_rate": round(
                (self.stats["blocked_input"] +
                 self.stats["blocked_guardrail"] +
                 self.stats["blocked_output"]) / max(total, 1),
                3
            )
        }

Uso en producción

# Definir la política
prod_policy = {
    "name": "Production v1.2",
    "thresholds": {
        "sexual": 0.15, "hate_and_discrimination": 0.1, "violence_and_threats": 0.2,
        "dangerous": 0.1, "criminal": 0.1, "selfharm": 0.1, "health": 0.4,
        "financial": 0.4, "law": 0.4, "pii": 0.15,
        "jailbreaking": 0.1
    }
}

# Instanciar la arquitectura
arch = SecureArchitecture(prod_policy)

# Procesar solicitudes
result = arch.process(
    "Explain how transformers work",
    system_prompt="You are an AI instructor."
)
print(result["status"])   # esperado: "allowed"
print(result["content"])

# Consultar estadísticas
print(arch.report())

Monitorización y alertas

Dos métricas bastan para dirigir un sistema de moderación, y debes vigilarlas en direcciones opuestas. La tasa de bloqueo debe permanecer estable: un pico repentino señala bien un ataque o bien un umbral demasiado estricto que empieza a obstaculizar a usuarios legítimos. La distribución de puntuaciones importa igual de mucho: si tu contenido se agrupa justo por debajo del umbral, el umbral está mal situado y el siguiente ajuste de tus usuarios lo romperá.

def configure_alerts(arch: SecureArchitecture):
    """Configura alertas para la monitorización."""
    report = arch.report()

    # Alerta si la tasa de bloqueo es anómala
    if report["block_rate"] > 0.15:
        logger.warning(
            f"Tasa de bloqueo alta: "
            f"{report['block_rate']:.1%}"
        )

    # Alerta si se producen picos de jailbreak
    # Integrar con Prometheus, Grafana, Datadog, etc.

Resumen del curso

Al finalizar este curso, has dominado:

  • Barreras de seguridad personalizadas: Bloquear prompts peligrosos antes de la generación, configurar umbrales por categoría, aplicar a agentes.
  • API de Moderación: Clasificar contenido con Mistral Moderation 2, interpretar puntuaciones en las 11 categorías, tomar decisiones automatizadas.
  • Seguridad en producción: Definir políticas de contenido, detectar inyecciones de prompt, garantizar el cumplimiento del RGPD.
  • Arquitectura completa: Ensamblar barreras de seguridad + moderación + monitorización en una canalización robusta.

Ahora dispones de todo el código necesario para desplegar un sistema completo de moderación de IA con la API de Mistral.

Puntos clave

  • La arquitectura de seguridad incluye 5 capas: validación, barreras de seguridad, generación, moderación, registro.
  • Cada capa compensa las debilidades de las demás: esto es defensa en profundidad.
  • Monitoriza la tasa de bloqueo y las puntuaciones en producción.
  • Mantén tu política actualizada con revisiones periódicas.
  • El código completo de esta lección es un punto de partida: adáptalo a tu contexto.

Pon a prueba tus conocimientos

¿Barreras de seguridad, moderación, inyección: tienes clara la arquitectura defensiva?

1. ¿Dónde intervienen las barreras de seguridad personalizadas?

Respuesta: Antes del modelo: filtran las entradas según tus reglas (temas prohibidos, formatos); es la primera capa, que evita incluso realizar la llamada cuando la solicitud está fuera de alcance.

2. ¿Qué cubre la API de Moderación de Mistral?

Respuesta: Once categorías de contenido de riesgo, con una puntuación por categoría: tus umbrales deciden si bloquear, marcar o permitir, convirtiendo la política de contenido en código.

3. ¿Cómo se define una buena política de contenido?

Respuesta: Por caso de uso: qué es aceptable para la aplicación, umbrales por categoría, acciones asociadas (bloqueo, reescritura, escalado); documentada y probada, no implícita.

4. ¿Cómo detectas intentos de inyección de prompt?

Respuesta: Tratando todo el contenido externo como sospechoso: detectando patrones de instrucción en los datos, aislando instrucciones de datos, validando salidas y ejecutando pruebas ofensivas periódicas.

5. ¿Cuál es el aspecto de la arquitectura de seguridad completa?

Respuesta: Capas: barreras de seguridad de entrada, moderación de contenido, controles de salida, cumplimiento del RGPD (minimización, derechos) y trazabilidad; ninguna capa es perfecta, pero apilarlas compensa.

La defensa en profundidad no es un eslogan: cada capa de este curso atrapa lo que la anterior deja pasar.