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
"""Capa 5b: sustento de la respuesta en sus fuentes.

Un asistente que cita como fuente un documento que no dice lo que afirma
genera respuestas con apariencia oficial y sin respaldo. Esta verificación
léxica es deliberadamente simple (no requiere otro modelo) y atrapa el caso
más común: citar un documento que no tiene nada que ver.
"""

from __future__ import annotations

import re
from dataclasses import dataclass

from .normalize import normalize

_STOPWORDS = set(
    "a al algo ante como con de del desde donde el ella en entre es esta este esto fue ha hay la las le lo los "
    "mas me mi muy no o para pero por que se si sin sobre su sus te tu un una uno y ya the of and to in is are".split()
)
_WORD = re.compile(r"[a-z0-9ñ]{3,}")
_SENTENCE = re.compile(r"(?<=[.!?])\s+|\n+")


@dataclass(frozen=True)
class GroundingReport:
    supported_ratio: float
    unsupported_sentences: list[str]
    weak_sources: list[str]

    @property
    def is_grounded(self) -> bool:
        return self.supported_ratio >= 0.6 and not self.weak_sources


def _terms(text: str) -> set[str]:
    return {w for w in _WORD.findall(normalize(text).text) if w not in _STOPWORDS}


def check_grounding(answer: str, sources: dict[str, str], min_overlap: float = 0.35) -> GroundingReport:
    """`sources` mapea el identificador de cada fuente citada a su texto."""
    source_terms = {sid: _terms(text) for sid, text in sources.items()}
    all_terms = set().union(*source_terms.values()) if source_terms else set()

    sentences = [s.strip() for s in _SENTENCE.split(answer) if len(_terms(s)) >= 3]
    unsupported = [s for s in sentences if len(_terms(s) & all_terms) / len(_terms(s)) < min_overlap]
    ratio = 1.0 if not sentences else 1 - len(unsupported) / len(sentences)

    answer_terms = _terms(answer)
    weak = [sid for sid, terms in source_terms.items()
            if answer_terms and len(answer_terms & terms) / len(answer_terms) < 0.1]

    return GroundingReport(round(ratio, 2), unsupported, weak)