¿Qué es el patrón Guardrails (Barandillas de seguridad) en IA?

Guardrails (barandillas de seguridad) es un patrón de arquitectura que envuelve las llamadas a un LLM con reglas de validación, filtros y restricciones tanto en el input del usuario como en el output del modelo. Sin guardrails, un LLM puede producir contenido dañino, alucinar datos sensibles, desviarse del tema o generar formatos incorrectos — todo eso en producción y frente a usuarios reales. Con guardrails, defines un perímetro de seguridad que el modelo no puede cruzar.

Tip Pro: Si estás poniendo un LLM en producción, guardrails debería estar en tu lista antes que cualquier feature cool. Un modelo sin guardrails es un riesgo legal y de reputación esperando materializarse.

¿Qué es?

El patrón guardrails se compone de dos capas principales que actúan en momentos distintos del ciclo de vida de una petición:

1. Input guardrails: se ejecutan antes de enviar el prompt al LLM. Revisan que el usuario no esté haciendo prompt injection, pidiendo contenido prohibido, o desviándose del tema permitido. Si algo no pasa, bloquean la petición y devuelven un mensaje predefinido.

2. Output guardrails: se ejecutan después de que el LLM genera una respuesta. Verifican que el contenido no contenga tóxicos, datos personales (PII), alucinaciones factuales, o que el formato estructurado sea válido. Si algo falla, pueden reintentar, censurar partes o devolver un fallback.

Adicionalmente existen guardrails de comportamiento (monitorean el tono del asistente), guardrails de tema (restringen a un dominio, ej: solo responder sobre productos de una empresa), y guardrails de ejecución (controlan cuántas herramientas llama el modelo o cuántos pasos da antes de responder).

Nota: Guardrails no reemplazan la moderación de contenido del proveedor del modelo (OpenAI Moderation, etc.). Son una capa adicional que tú controlas y adaptas a tu caso de uso.

Modelo mental

Imagina un edificio con seguridad en la entrada y en la salida. Los input guardrails son el guardia en la puerta que revisa identificación y pregunta "¿a qué vienes?". Si no tienes permiso o vas a robar, no entras. Los output guardrails son el detector de metales a la salida: aunque hayas entrado, verifican que no te lleves nada que no debas.

Usuario → [Input Guardrail] → LLM → [Output Guardrail] → Respuesta final
              ❌ bloquea         |         ❌ rechaza
              si es riesgoso     |        si es inválido

Entre los dos filtros, el LLM opera dentro de un perímetro controlado. Puede generar libremente, pero siempre con supervisión.

¿Cómo se usa?

Hay frameworks especializados y también puedes implementar guardrails caseros con validación programática. Aquí veremos ambas aproximaciones.

Opción 1: Guardrails con código manual

Para casos simples, puedes escribir validadores directamente:

import json
 
# Input guardrail: detecta prompt injection básico
def input_guardrail(user_input: str) -> bool:
    patrones_bloqueados = ["ignora las instrucciones", "olvida tu prompt",
                           "actúa como administrador", "> /"]
    for patron in patrones_bloqueados:
        if patron in user_input.lower():
            return False
    return True
 
# Output guardrail: valida que la respuesta sea JSON válido
def output_guardrail(response: str) -> bool:
    try:
        data = json.loads(response)
        return "answer" in data and "confidence" in data
    except json.JSONDecodeError:
        return False
 
# Pipeline
def chat_with_guardrails(user_input: str) -> str:
    if not input_guardrail(user_input):
        return "Lo siento, no puedo procesar esa solicitud."
 
    raw_response = llm_call(user_input)
 
    if not output_guardrail(raw_response):
        return "El asistente no pudo generar una respuesta válida. Intenta de nuevo."
 
    return raw_response

Opción 2: Guardrails AI (framework)

La librería guardrails-ai permite definir reglas como "validadores" reutilizables:

pip install guardrails-ai

Instala un validador del Guardrails Hub y conéctalo a un Guard:

from guardrails import Guard
from guardrails.hub import ValidJSON  # guardrails hub install hub://guardrails/valid_json
 
# Conecta uno o más validadores al Guard
guard = Guard().use(ValidJSON(on_fail="exception"))
 
# Valida el output del LLM: relanza o reintenta si no es JSON válido
result = guard.parse(llm_output)
print(result.validation_passed)

Si el output falla el validador, Guardrails AI puede reintentar automáticamente la llamada al LLM con un mensaje de corrección hasta agotar un límite.

Advertencia: Los reintentos automáticos consumen tokens y aumentan la latencia. Pon un límite razonable (3-5 reintentos máximo) y monitorea cuántas correcciones ocurren.

Opción 3: NeMo Guardrails (NVIDIA)

NeMo Guardrails de NVIDIA está diseñado para flujos conversacionales complejos con "colang", un lenguaje específico para definir diálogos:

# Definir un rail de tema
define user ask about politics
  "¿Qué opinas de [política]?"
 
define bot refuse politics
  "No tengo opiniones sobre temas políticos."
 
# Conectar rail
when user ask about politics
  bot refuse politics

from nemoguardrails import LLMRails, RailsConfig
 
config = RailsConfig.from_path("config.yml")
rails = LLMRails(config)
 
response = rails.generate(
    messages=[{"role": "user", "content": "¿Qué opinas del nuevo presidente?"}]
)
# El modelo responderá con el mensaje definido, no con su opinión real

Tip Pro: NeMo brilla cuando necesitas control conversacional fino (diálogos con ramas, topics prohibidos, roles). Guardrails AI es mejor para validación de formato de datos (JSON, XML, tipos).

¿Cuándo usarlo / cuándo no?

Tip Pro: Empieza con guardrails mínimos (solo output validation) y agrega capas según veas fallos en producción. No sobreingenierices desde el día uno.

Historia y evolución