Código

Acompaña al artículo sobre prompt injection y jailbreaking

Guardrails para asistentes con LLM

Siete ataques reales que se escriben en un chat, y las capas que los detienen.

Python 98%TOML 2%13 archivos558 líneas de código 21/21 pruebas
"""Composición de las capas en un solo punto de control.

    entrada ─▶ normalizar ─▶ inyección ─▶ alcance ─▶ (LLM) ─▶ datos personales ─▶ sustento ─▶ salida

Cada decisión devuelve sus razones para poder auditarla y monitorearla.
Lo que este módulo NO hace, a propósito: autorizar acciones o acceso a datos.
Eso se decide en el backend con la identidad real del usuario.
"""

from __future__ import annotations

from dataclasses import dataclass, field

from .grounding import check_grounding
from .injection import assess
from .normalize import normalize
from .pii import redact
from .scope import TELECOM_SCOPE, IntentClassifier


@dataclass
class Verdict:
    allowed: bool
    reasons: list[str] = field(default_factory=list)
    signals: list[str] = field(default_factory=list)
    text: str = ""


class Guardrails:
    def __init__(self, classifier: IntentClassifier = TELECOM_SCOPE, refusal: str | None = None):
        self._classifier = classifier
        self.refusal = refusal or (
            "Solo puedo ayudarte con temas de tu servicio: facturación, soporte técnico y contratación."
        )

    def check_input(self, message: str) -> Verdict:
        norm = normalize(message)
        signals = list(norm.flags)

        injection = assess(norm.text)
        signals += [f"inyeccion:{s}" for s in injection.signals]
        if injection.is_suspicious:
            return Verdict(False, [f"Posible manipulación (riesgo {injection.score})"], signals, self.refusal)

        scope = self._classifier.classify(norm.text)
        if not scope.in_scope:
            return Verdict(False, [scope.reason], signals, self.refusal)

        return Verdict(True, [scope.reason], signals, norm.text)

    def check_output(self, answer: str, cited_sources: dict[str, str] | None = None) -> Verdict:
        reasons: list[str] = []
        text, findings = redact(answer)
        signals = [f"pii:{f.kind}" for f in findings]
        if findings:
            reasons.append(f"Se ocultaron {len(findings)} datos personales")

        if cited_sources:
            report = check_grounding(text, cited_sources)
            if report.weak_sources:
                return Verdict(False, reasons + [f"Fuentes citadas sin relación: {', '.join(report.weak_sources)}"],
                               signals + ["sin_sustento"], self.refusal)
            if not report.is_grounded:
                return Verdict(False, reasons + [f"Solo {report.supported_ratio:.0%} de la respuesta tiene sustento"],
                               signals + ["sin_sustento"], self.refusal)

        return Verdict(True, reasons, signals, text)