Asistente RAG sobre regulación financiera

"""#14 Asistente RAG sobre regulación financiera mexicana (recuperación con citas).

Corpus: tres leyes públicas de la Cámara de Diputados — Ley para la Transparencia y Ordenamiento de los
Servicios Financieros (LTOSF), Ley de Protección y Defensa al Usuario de Servicios Financieros (LPDUSF,
CONDUSEF) y Ley Federal de Protección de Datos Personales en Posesión de los Particulares (LFPDPPP).

La parte crítica de un RAG es la RECUPERACIÓN: si no encuentra el artículo correcto, el LLM inventa. Se evalúa
con 33 preguntas escritas en lenguaje de cliente (sin copiar la redacción legal), cada una con su artículo
correcto. La generación de la respuesta (con cita) corre en `llm_rag.py` cuando hay API key; sin ella, el sitio
muestra la respuesta extractiva: los artículos recuperados.
"""
import json
import re
import unicodedata

import numpy as np
import pandas as pd
from pypdf import PdfReader
from rank_bm25 import BM25Okapi

from common import RAW, SEED, SITE_DATA, bars, download, export, line, table
from validacion import model_card

LEYES = {"LTOSF": "Ley de Transparencia y Ordenamiento de los Servicios Financieros",
         "LPDUSF": "Ley de Protección y Defensa al Usuario de Servicios Financieros",
         "LFPDPPP": "Ley Federal de Protección de Datos Personales en Posesión de los Particulares"}
URL = "https://www.diputados.gob.mx/LeyesBiblio/pdf/{}.pdf"
MODELOS_EMB = {  # nombre corto → (modelo, prefijo de consulta, prefijo de documento)
    "MiniLM multilingüe": ("sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2", "", ""),
    "E5-large multilingüe": ("intfloat/multilingual-e5-large", "query: ", "passage: "),
}

# Preguntas de prueba (lenguaje de cliente) → artículo que las responde
PREGUNTAS = [
    ("¿Me pueden cobrar los intereses de un préstamo por adelantado?", "LTOSF 10"),
    ("¿Quién define cómo se calcula el CAT de un crédito?", "LTOSF 8"),
    ("¿El banco me puede obligar a contratar otro producto para darme el crédito?", "LTOSF 23 Bis"),
    ("Firmé un contrato y me arrepentí, ¿cuántos días tengo para cancelarlo sin costo?", "LTOSF 11 Bis 1"),
    ("¿Es legal que me cobren comisión por pasarme del límite de mi tarjeta?", "LTOSF 18 Bis 8"),
    ("¿Quién decide cuánto es el pago mínimo de la tarjeta de crédito?", "LTOSF 18 Bis 7"),
    ("¿El cajero automático tiene que avisarme cuánto me va a cobrar?", "LTOSF 5"),
    ("Quiero que mi sueldo se deposite en otro banco, ¿el banco de nómina me lo debe permitir?", "LTOSF 18"),
    ("¿Cómo sé qué despacho de cobranza tiene mi deuda y cómo localizarlo?", "LTOSF 17 Bis 1"),
    ("¿Qué cuenta como discriminación por parte de una entidad financiera?", "LTOSF 17"),
    ("¿En cuántos años prescribe la facultad de la autoridad para multar a un banco?", "LTOSF 24"),
    ("Si le di una tarjeta adicional a mi hijo, ¿él responde por mi deuda?", "LTOSF 11 Bis"),
    ("¿Puedo liquidar y terminar mi crédito de consumo cuando yo quiera?", "LTOSF 10 Bis 1"),
    ("¿Pueden llamarme a mi trabajo para ofrecerme créditos?", "LTOSF 10 Bis 2"),
    ("¿Sobre qué saldo me calculan los intereses de la tarjeta?", "LTOSF 18 Bis 6"),
    ("¿El banco debe revisar si puedo pagar antes de darme una tarjeta de crédito?", "LTOSF 18 Bis 1"),
    ("¿Para qué existe la CONDUSEF?", "LPDUSF 5o"),
    ("¿Qué es el Buró de Entidades Financieras?", "LPDUSF 8o Bis"),
    ("¿Las financieras deben tener un área para atender mis quejas?", "LPDUSF 50 Bis"),
    ("¿Hasta cuándo puedo presentar una queja ante la CONDUSEF?", "LPDUSF 65"),
    ("¿La CONDUSEF me ayuda si me suben la tasa de interés que acordé?", "LPDUSF 61"),
    ("Si presento mi reclamación, ¿se detiene el plazo para demandar?", "LPDUSF 66"),
    ("¿La CONDUSEF me puede dar un abogado gratis?", "LPDUSF 85"),
    ("Si gano el arbitraje, ¿en cuánto tiempo me tiene que pagar la institución?", "LPDUSF 81"),
    ("¿Qué pasa si no me presento a la audiencia de conciliación?", "LPDUSF 69"),
    ("¿Cada cuánto se reúne la Junta de Gobierno de la CONDUSEF?", "LPDUSF 19"),
    ("¿Qué principios debe seguir una empresa que usa mis datos personales?", "LFPDPPP 5"),
    ("Para usar mis datos de salud, ¿qué tipo de permiso necesitan?", "LFPDPPP 8"),
    ("¿Qué debe decir un aviso de privacidad?", "LFPDPPP 15"),
    ("¿En qué casos pueden usar mis datos sin pedirme permiso?", "LFPDPPP 9"),
    ("¿Qué medidas deben tomar las empresas para proteger mis datos?", "LFPDPPP 18"),
    ("Hubo un hackeo y se filtraron mis datos, ¿la empresa debe avisarme?", "LFPDPPP 19"),
    ("¿Quién puede pedir acceso, corrección o cancelación de mis datos?", "LFPDPPP 21"),
]
STOP = set("de la el los las un una y o a en por para con que se su sus del al lo es mi me mis le les como "
           "qué cuál cuáles cuándo cuánto cuántos quién puedo pueden puede debe deben tiene tienen si no".split())


def normalizar(t: str) -> str:
    t = unicodedata.normalize("NFKD", t.lower())
    return "".join(c for c in t if not unicodedata.combining(c))


def tokens(t: str) -> list[str]:
    return [w for w in re.findall(r"[a-z0-9]+", normalizar(t)) if w not in STOP and len(w) > 2]


def articulos() -> pd.DataFrame:
    filas = []
    patron = r"Art[íi]culo\s+(\d+)\s*([oº°]?)\.?\s*((?:Bis(?:\s*\d+)?|Ter|Qu[áa]ter|Quinquies)?)"
    for ley in LEYES:
        texto = "\n".join(p.extract_text() for p in PdfReader(download(URL.format(ley), f"ley_{ley}.pdf")).pages)
        # Quitar encabezados y pies de página del PDF de la Cámara de Diputados
        for patron_ruido in [r"LEY (PARA LA|DE PROTECCI|FEDERAL DE PROTECCI)[^\n]*\n?",
                             r"CÁMARA DE DIPUTADOS DEL H\.\s*CONGRESO DE LA UNIÓN", r"Secretaría General",
                             r"Secretaría de Servicios Parlamentarios", r"Últimas? [Rr]eformas? (publicadas? )?DOF[^\n]*",
                             r"Nueva Ley (publicada|DOF)[^\n]*", r"\n\s*\d+\s+de\s+\d+\s*\n"]:
            texto = re.sub(patron_ruido, "\n", texto)
        for bloque in re.split(r"\n\s*(?=Art[íi]culo\s+\d+)", texto)[1:]:
            m = re.match(patron, bloque)
            if not m:
                continue
            num = m.group(1) + m.group(2).replace("º", "o").replace("°", "o")
            sufijo = re.sub(r"\s+", " ", m.group(3)).strip().replace("Quáter", "Quater")
            art = f"{ley} {num}{(' ' + sufijo) if sufijo else ''}"
            limpio = re.sub(r"\s+", " ", bloque).strip()
            if "Se deroga" in limpio[:60]:
                continue
            filas.append({"id": art, "ley": ley, "texto": limpio[:4000]})
    return pd.DataFrame(filas).drop_duplicates("id")


def embeddings(textos: list[str], modelo: str, nombre: str) -> np.ndarray:
    from fastembed import TextEmbedding
    cache = RAW / f"rag_emb_{modelo.split('/')[-1]}_{nombre}_{len(textos)}.npy"
    if cache.exists():
        return np.load(cache)
    E = np.array(list(TextEmbedding(modelo).embed(textos, batch_size=16)))
    E /= np.linalg.norm(E, axis=1, keepdims=True)
    np.save(cache, E)
    return E


def metricas(rankings: list[list[str]], oro: list[str]) -> dict:
    pos = [r.index(o) + 1 if o in r else None for r, o in zip(rankings, oro)]
    return {"Recall@1": np.mean([p == 1 for p in pos]), "Recall@3": np.mean([p is not None and p <= 3 for p in pos]),
            "Recall@5": np.mean([p is not None and p <= 5 for p in pos]),
            "MRR": np.mean([1 / p if p else 0 for p in pos])}


def puntajes_densos(arts: pd.DataFrame, qs: list[str], corto: str) -> np.ndarray:
    """Similitud pregunta × artículo con embeddings. Se indexa por fragmentos de ~700 caracteres y cada artículo
    toma el puntaje de su mejor fragmento (los artículos largos no se diluyen). La usa también `llm_rag.py`."""
    frag_txt, frag_art = [], []
    for a, t in zip(arts.id, arts.texto):
        for i in range(0, len(t), 600):
            frag_txt.append(t[i:i + 700])
            frag_art.append(a)
    frag_art = np.array(frag_art)
    modelo, pq, pd_ = MODELOS_EMB[corto]
    sim = embeddings([pq + q for q in qs], modelo, "preg") @ embeddings([pd_ + t for t in frag_txt], modelo, "frag").T
    return np.array([[sim[k][frag_art == a].max() for a in arts.id] for k in range(len(qs))])


def aciertos_top3(S: np.ndarray, ids: list[str], oro: list[str]) -> np.ndarray:
    return np.array([o in [ids[j] for j in np.argsort(-fila)[:3]] for fila, o in zip(S, oro)], dtype=float)


def run():
    arts = articulos()
    ids = arts.id.tolist()
    faltan = [o for _, o in PREGUNTAS if o not in ids]
    assert not faltan, f"Artículos de prueba no encontrados en el corpus: {faltan}"
    qs, oro = [q for q, _ in PREGUNTAS], [o for _, o in PREGUNTAS]

    # 1) BM25 (léxico): coincidencia de palabras, el estándar de los buscadores
    bm25 = BM25Okapi([tokens(t) for t in arts.texto])
    s_bm = np.array([bm25.get_scores(tokens(q)) for q in qs])
    # 2) Denso: embeddings multilingües (capturan sinónimos: "hackeo" ≈ "vulneración de seguridad").
    densos = {corto: puntajes_densos(arts, qs, corto) for corto in MODELOS_EMB}

    # 3) Híbridos con Reciprocal Rank Fusion (no requiere calibrar escalas entre puntajes)
    def rangos(S):
        return np.argsort(np.argsort(-S, axis=1), axis=1) + 1
    rrf = lambda A, B: 1 / (60 + rangos(A)) + 1 / (60 + rangos(B))

    def top(S, k=10):
        return [[ids[j] for j in np.argsort(-fila)[:k]] for fila in S]
    sistemas = {"BM25 (léxico)": s_bm, "Denso: MiniLM multilingüe": densos["MiniLM multilingüe"],
                "Híbrido RRF: BM25 + MiniLM": rrf(s_bm, densos["MiniLM multilingüe"]),
                "Denso: E5-large multilingüe": densos["E5-large multilingüe"],
                "Híbrido RRF: BM25 + E5-large": rrf(s_bm, densos["E5-large multilingüe"])}
    res = pd.DataFrame([{"Sistema": k, **{m: round(v, 3) for m, v in metricas(top(S), oro).items()}}
                        for k, S in sistemas.items()])
    # Con 33 preguntas la incertidumbre es grande: IC bootstrap de Recall@3 y diferencias PAREADAS
    # (mismas preguntas remuestreadas para ambos sistemas), que son mucho más precisas que comparar IC sueltos.
    rng = np.random.default_rng(SEED)
    idx = rng.integers(0, len(qs), (2000, len(qs)))
    hits = {k: aciertos_top3(S, ids, oro) for k, S in sistemas.items()}
    res["IC 95 % Recall@3"] = [f"{np.percentile(h[idx].mean(1), 2.5):.2f}–{np.percentile(h[idx].mean(1), 97.5):.2f}"
                               for h in hits.values()]
    mejor = res.loc[res.MRR.idxmax(), "Sistema"]
    pareadas = []
    for otro in sistemas:
        if otro == mejor:
            continue
        d = (hits[mejor] - hits[otro])[idx].mean(1)
        pareadas.append({"Comparación": f"{mejor} − {otro}", "Δ Recall@3": round(float((hits[mejor] - hits[otro]).mean()), 3),
                         "IC 95 %": f"{np.percentile(d, 2.5):+.2f} a {np.percentile(d, 97.5):+.2f}",
                         "P(Δ ≤ 0)": round(float((d <= 0).mean()), 3)})
    pareadas = pd.DataFrame(pareadas)
    S_best = sistemas[mejor]
    rk = top(S_best)
    detalle = pd.DataFrame([{"Pregunta": q, "Artículo correcto": o, "Top 3 recuperados": " · ".join(r[:3]),
                             "¿Acierto top 3?": "Sí" if o in r[:3] else "No"} for q, o, r in zip(qs, oro, rk)])
    # Curva Recall@k
    curva = {k: [[kk, round(float(np.mean([o in r[:kk] for o, r in zip(oro, top(S, 10))])) * 100, 1)]
                 for kk in range(1, 11)] for k, S in sistemas.items()}
    por_ley = detalle.assign(ley=detalle["Artículo correcto"].str.split().str[0]).groupby("ley")["¿Acierto top 3?"] \
        .apply(lambda s: (s == "Sí").mean() * 100)
    ejemplos = [{"pregunta": q, "oro": o, "recuperados": [{"id": a, "texto": arts.set_index("id").loc[a, "texto"][:700]}
                                                         for a in r[:3]]}
                for q, o, r in list(zip(qs, oro, rk))[:6]]
    llm_path = SITE_DATA / "llm" / "p14-rag-regulatorio.json"
    llm = json.loads(llm_path.read_text(encoding="utf-8")) if llm_path.exists() else None
    if llm:   # la respuesta generada (con citas) se muestra junto a lo recuperado
        resp = {f["pregunta"]: f for f in llm["respuestas"]}
        for e in ejemplos:
            if e["pregunta"] in resp:
                e["respuesta"], e["citados"] = resp[e["pregunta"]]["respuesta"], resp[e["pregunta"]]["citados"]
    r = res.set_index("Sistema")
    vs_bm = pareadas.set_index("Comparación").loc[f"{mejor} − BM25 (léxico)"]
    seg = pareadas.loc[pareadas["Δ Recall@3"].idxmin()]
    result = {
        "title": "Asistente RAG sobre regulación financiera",
        "summary": [
            f"Corpus: {len(arts)} artículos vigentes de 3 leyes (LTOSF, LPDUSF/CONDUSEF y LFPDPPP), extraídos de los PDF "
            f"oficiales y separados por artículo. Prueba: {len(qs)} preguntas en lenguaje de cliente con su artículo correcto.",
            f"Mejor recuperación: {mejor} — el artículo correcto aparece en el top 3 en {r.loc[mejor, 'Recall@3']:.0%} de las "
            f"preguntas (MRR {r.loc[mejor, 'MRR']:.2f}); BM25 {r.loc['BM25 (léxico)', 'Recall@3']:.0%}, MiniLM "
            f"{r.loc['Denso: MiniLM multilingüe', 'Recall@3']:.0%}, híbrido BM25 + MiniLM {r.loc['Híbrido RRF: BM25 + MiniLM', 'Recall@3']:.0%}.",
            "Lección: con un modelo de embeddings débil, mezclarlo con BM25 ayuda; con uno fuerte (E5-large, entrenado para "
            "búsqueda con prefijos query/passage) el léxico mete ruido y el híbrido empeora. La arquitectura correcta depende "
            "del modelo, y solo se sabe midiendo.",
            f"Incertidumbre: con {len(qs)} preguntas el IC 95 % de Recall@3 del mejor es {r.loc[mejor, 'IC 95 % Recall@3']}. "
            f"La ventaja pareada sobre BM25 ({vs_bm['IC 95 %']}) "
            + ("excluye el cero" if vs_bm['P(Δ ≤ 0)'] < 0.025 else "no excluye el cero")
            + f"; frente al segundo mejor ({seg['Comparación'].split(' − ')[1]}, {seg['IC 95 %']}) "
            + ("también" if seg['P(Δ ≤ 0)'] < 0.025 else "la diferencia no es concluyente") + ". El conjunto de prueba también se usó para "
            "elegir, así que la cifra es algo optimista.",
            (f"Generación con {llm['modelo']}: cita el artículo correcto en {llm['cita_correcta'] or 0:.0%} de las preguntas "
             f"donde fue recuperado; cuando no lo fue, se abstiene en {llm['abstencion_correcta'] or 0:.0%} de los casos y en "
             "los demás responde apoyándose en otro artículo recuperado (a veces defendible, a veces no). Riesgo a "
             "controlar: en producción se exige cita y un umbral de similitud mínimo antes de responder."
             if llm else
             "Generación con LLM y citas: lista en `llm_rag.py`; corre en cuanto haya una API key de LLM (Groq, Gemini, "
             "OpenRouter, Hugging Face o Anthropic; ver `llm_cliente.py`). Regla de "
             "cumplimiento: el LLM solo puede responder con los artículos recuperados y debe citarlos; si no están, "
             "debe abstenerse."),
        ],
        "metrics": [
            {"label": "Recall@3 (mejor)", "value": f"{r.loc[mejor, 'Recall@3']:.0%}"},
            {"label": "MRR (mejor)", "value": f"{r.loc[mejor, 'MRR']:.2f}"},
            {"label": "Artículos indexados", "value": f"{len(arts)}"},
            {"label": "Preguntas de prueba", "value": f"{len(qs)}"},
        ],
        "charts": [
            line("recall", "Recall@k: ¿aparece el artículo correcto entre los primeros k?", curva,
                 x_label="k (artículos recuperados)", y_label="% de preguntas", fmt="pct"),
            bars("mrr", "MRR por sistema de recuperación", res.Sistema, res.MRR.values, fmt="dec"),
            bars("ley", f"Recall@3 por ley ({mejor})", por_ley.index, por_ley.values.round(1), fmt="pct"),
        ],
        "tables": [table("Comparación de sistemas de recuperación", res),
                   table(f"Diferencias pareadas de Recall@3 contra {mejor} (bootstrap por pregunta)", pareadas),
                   table("Detalle por pregunta (mejor sistema)", detalle)],
        "ejemplos": ejemplos,
        "card": model_card(
            "Recuperación BM25, densa (MiniLM y E5-large multilingües, ONNX local) e híbrida por Reciprocal Rank Fusion sobre "
            "artículos de ley; generación con LLM condicionada a los artículos recuperados.",
            [f"{len(qs)} preguntas de prueba escritas a mano con su artículo correcto, en lenguaje de cliente.",
             "Recall@1/3/5 y MRR; desglose por ley y detalle de cada pregunta."],
            ["La respuesta correcta está en un solo artículo (algunas preguntas tienen respuestas repartidas)."],
            ["El conjunto de prueba es pequeño y lo escribió el autor: hay que ampliarlo con preguntas reales de clientes.",
             "Las leyes cambian: el índice debe regenerarse con cada reforma publicada en el DOF."]),
    }
    corpus = arts.assign(texto=arts.texto.str.slice(0, 1200))
    export("p14-rag-regulatorio", result, corpus)
    return result


if __name__ == "__main__":
    run()