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

Barreras de seguridad: validación de entradas y salidas

Lección 6 de 14 Actualizado el 28 de julio de 2026 Avanzado
En esta página
  1. ¿Qué es una barrera de seguridad?
  2. Una arquitectura de canalización
  3. Tres barreras de seguridad típicas
  4. Ensamblaje completo
  5. Cuando la regla no puede escribirse con expresiones regulares
  6. Puntos clave

¿Qué es una barrera de seguridad?

Una barrera de seguridad (guardrail) es una capa de validación que se sitúa entre el usuario y el modelo en la entrada, o entre el modelo y el usuario en la salida. La distinción respecto a la moderación tratada en el capítulo anterior es nítida y debes mantenerla: la moderación responde a la pregunta «¿Es este contenido ofensivo?», una cuestión universal cuya respuesta no depende de tu negocio. Las barreras de seguridad responden a preguntas que solo tú puedes formular: ¿El mensaje está dentro del ámbito esperado? ¿La respuesta contiene información prohibida? ¿La acción solicitada está autorizada para este rol? Un asistente bancario y un asistente de librería comparten la misma moderación, pero no tienen ninguna barrera de seguridad en común.

Para 2026, las barreras de seguridad se han convertido en un componente estándar de las arquitecturas de agentes de IA, indispensables siempre que un modelo tenga acceso a herramientas o datos sensibles.

Una arquitectura de canalización

La elección estructural consiste en tratar cada barrera de seguridad como un objeto independiente con una única responsabilidad y encadenarlos en un orden determinado. La ventaja se manifiesta durante el mantenimiento: añadir una regla de negocio no requiere cambios en el código existente, y una regla que genera demasiado ruido puede eliminarse en una sola línea.

Un tercer veredicto se suma a permitir y bloquear: modificar. Esto cambia la naturaleza del ejercicio. Muchas situaciones del mundo real no justifican un rechazo; una respuesta que contiene una ruta interna de servidor sigue siendo útil una vez que dicha ruta se ha ocultado. Bloquear supondría perder la información; modificar la preserva eliminando lo que plantea un problema.

from dataclasses import dataclass
from enum import Enum

class Decision(Enum):
    ALLOW = "allow"
    BLOCK = "block"
    MODIFY = "modify"

@dataclass
class ValidationResult:
    decision: Decision
    reason: str
    modified_content: str | None = None

class Guardrail:
    """Clase base para una barrera de seguridad."""

    def validate(self, content: str, context: dict) -> ValidationResult:
        raise NotImplementedError

class GuardrailPipeline:
    """Encadena múltiples barreras de seguridad en secuencia."""

    def __init__(self):
        self.input_guardrails: list[Guardrail] = []
        self.output_guardrails: list[Guardrail] = []

    def add_input(self, guardrail: Guardrail):
        self.input_guardrails.append(guardrail)

    def add_output(self, guardrail: Guardrail):
        self.output_guardrails.append(guardrail)

    def validate_input(self, message: str, context: dict) -> ValidationResult:
        for g in self.input_guardrails:
            result = g.validate(message, context)
            if result.decision == Decision.BLOCK:
                return result
            if result.decision == Decision.MODIFY:
                message = result.modified_content
        return ValidationResult(Decision.ALLOW, "Todas las validaciones superadas")

    def validate_output(self, response: str, context: dict) -> ValidationResult:
        for g in self.output_guardrails:
            result = g.validate(response, context)
            if result.decision == Decision.BLOCK:
                return result
            if result.decision == Decision.MODIFY:
                response = result.modified_content
        return ValidationResult(Decision.ALLOW, "OK", response)

Tres barreras de seguridad típicas

La barrera de ámbito mantiene la conversación dentro de su dominio. Sirve tanto para la seguridad como para la reputación: un asistente de atención al cliente formado para responder preguntas sobre entregas no tiene nada que ganar comentando noticias políticas, y una captura de pantalla de tal respuesta circula rápidamente. La lista de temas prohibidos debe debatirse con la parte de negocio, nunca redactarla únicamente el equipo técnico.

class ScopeGuardrail(Guardrail):
    """Comprueba que el mensaje se mantiene dentro del ámbito autorizado."""

    def __init__(self, allowed_topics: list[str], forbidden_topics: list[str]):
        self.allowed_topics = allowed_topics
        self.forbidden_topics = forbidden_topics

    def validate(self, content: str, context: dict) -> ValidationResult:
        content_lower = content.lower()

        # Comprobar temas prohibidos
        for topic in self.forbidden_topics:
            if topic.lower() in content_lower:
                return ValidationResult(
                    Decision.BLOCK,
                    f"Tema fuera de ámbito detectado: {topic}"
                )

        return ValidationResult(Decision.ALLOW, "Dentro del ámbito")

La barrera de formato parece trivial, pero aporta el mayor valor diario. Cuesta unos pocos microsegundos, no depende de llamadas a la red y corta de raíz los mensajes sobredimensionados utilizados para inyecciones volumétricas e intentos de agotamiento del presupuesto. Colócala la primera en la cadena: no tiene sentido pagar una moderación por API por un mensaje de 200.000 caracteres que vas a rechazar de todos modos.

class FormatGuardrail(Guardrail):
    """Valida el formato y la longitud del mensaje."""

    def __init__(self, max_tokens: int = 4000, max_lines: int = 100):
        self.max_tokens = max_tokens
        self.max_lines = max_lines

    def validate(self, content: str, context: dict) -> ValidationResult:
        # Estimación aproximada de tokens (1 token ~ 4 caracteres en inglés)
        estimated_tokens = len(content) // 4
        if estimated_tokens > self.max_tokens:
            return ValidationResult(
                Decision.BLOCK,
                f"Mensaje demasiado largo: ~{estimated_tokens} tokens (máx. {self.max_tokens})"
            )

        line_count = content.count("\n") + 1
        if line_count > self.max_lines:
            return ValidationResult(
                Decision.BLOCK,
                f"Demasiadas líneas: {line_count} (máx. {self.max_lines})"
            )

        return ValidationResult(Decision.ALLOW, "Formato válido")

La tercera supervisa la salida e ilustra el uso del veredicto «modificar». Las cuatro familias que busca comparten una propiedad conveniente: tienen una forma reconocible independiente del significado. Una clave de API, una dirección interna, una IP privada o una ruta de servidor se identifican por su estructura, sin necesidad de entender la frase que las contiene.

import re

class AntiExfiltrationGuardrail(Guardrail):
    """Previene la fuga de datos sensibles en las salidas."""

    def __init__(self):
        self.sensitive_patterns = {
            "api_key": r"(sk|pk|api[_-]?key)[_-][a-zA-Z0-9]{16,}",
            "internal_email": r"[a-zA-Z0-9.]+@(company|internal|corp)\.\w+",
            "private_ip": r"\b(10\.\d{1,3}\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3})\b",
            "server_path": r"(/data/|/etc/|/home/|C:\\Users\\)",
        }

    def validate(self, content: str, context: dict) -> ValidationResult:
        for data_type, pattern in self.sensitive_patterns.items():
            if re.search(pattern, content):
                # Ocultar en lugar de bloquear
                cleaned_content = re.sub(pattern, "[REDACTED]", content)
                return ValidationResult(
                    Decision.MODIFY,
                    f"Datos sensibles ocultados: {data_type}",
                    cleaned_content,
                )
        return ValidationResult(Decision.ALLOW, "No se ha detectado fuga")

Ensamblaje completo

El ensamblaje completo muestra dónde encajan las piezas. La asimetría salta a la vista: dos barreras en la entrada, solo una en la salida. Esto es frecuente y saludable: filtras intensamente antes de llamar al modelo porque ahí es donde los costes son evitables, y mantienes lo mínimo necesario en la salida para no dañar respuestas correctas. El mensaje devuelto al bloquear en la salida sigue la misma cautela: intencionadamente vago, no dice qué se ha detectado, información que serviría principalmente a quien intentara mapear tus defensas.

from openai import OpenAI

def create_secure_assistant():
    """Crea un asistente con una canalización completa de barreras de seguridad."""
    client = OpenAI()
    pipeline = GuardrailPipeline()

    # Barreras de entrada
    pipeline.add_input(FormatGuardrail(max_tokens=2000))
    pipeline.add_input(ScopeGuardrail(
        allowed_topics=["products", "orders", "delivery", "returns"],
        forbidden_topics=["politics", "religion", "competitors"],
    ))

    # Barreras de salida
    pipeline.add_output(AntiExfiltrationGuardrail())

    def process(message: str) -> str:
        context = {"user_role": "customer"}

        # Validación de entrada
        input_check = pipeline.validate_input(message, context)
        if input_check.decision == Decision.BLOCK:
            return f"No puedo procesar esta solicitud: {input_check.reason}"

        valid_message = input_check.modified_content or message

        # Llamada al modelo
        response = client.chat.completions.create(
            model="gpt-5.6-sol",
            messages=[
                {"role": "system", "content": "Asistente de atención al cliente de Acme Corp."},
                {"role": "user", "content": valid_message},
            ],
        )
        reply = response.choices[0].message.content

        # Validación de salida
        output_check = pipeline.validate_output(reply, context)
        if output_check.decision == Decision.BLOCK:
            return "No puedo responder a esta pregunta."

        return output_check.modified_content or reply

    return process

Cuando la regla no puede escribirse con expresiones regulares

Algunas reglas de negocio resisten cualquier formalización mediante patrones. «La respuesta no debe constituir asesoramiento de inversión», «el mensaje no debe contener datos de salud»: ninguna expresión regular captura esto. Un segundo modelo, rápido y económico, puede actuar entonces como juez, con una respuesta restringida al formato JSON para seguir siendo utilizable por el código llamador. La compensación es explícita: ganas precisión a costa de latencia y determinismo, lo que reserva este enfoque para reglas que realmente lo justifiquen.

def llm_guardrail(message: str, rule: str) -> ValidationResult:
    """Utiliza un modelo rápido para validar el cumplimiento."""
    client = OpenAI()
    response = client.chat.completions.create(
        model="gpt-5.6-terra",
        messages=[
            {"role": "system", "content": f"""Eres un validador de cumplimiento.
Regla a comprobar: {rule}
Responde ÚNICAMENTE con JSON: {{"compliant": true/false, "reason": "..."}}"""},
            {"role": "user", "content": f"Mensaje a validar:\n{message}"},
        ],
    )
    import json
    result = json.loads(response.choices[0].message.content)
    if result["compliant"]:
        return ValidationResult(Decision.ALLOW, result["reason"])
    return ValidationResult(Decision.BLOCK, result["reason"])

Puntos clave

  • Las barreras de seguridad validan el cumplimiento del negocio, no solo el contenido ofensivo
  • La arquitectura de canalización permite combinar múltiples capas de validación
  • Cada barrera tiene una única responsabilidad: ámbito, formato, exfiltración, etc.
  • Las barreras de salida son tan importantes como las de entrada
  • Para casos complejos, un LLM rápido puede servir como validador