RAG: el bot conoce tus documentos

"El modelo sabe de todo en general y de tu negocio en particular: nada. RAG es el puente entre los dos."

Qué vas a aprender en este capítulo

El bot ya maneja menú, pedidos y horarios con herramientas. Pero doña Carmen tiene un manual de políticas: entregas a domicilio, formas de pago, encargos para eventos, manejo de reclamos, programa de cliente frecuente... Son ~3 páginas de texto que cambian cada tanto, y el bot debería responder sobre ellas con precisión y citando de dónde sacó cada cosa (requisito R5).

¿Cómo le metemos ese conocimiento al bot? En este capítulo vas a aprender la respuesta estándar de la industria: RAG (Retrieval-Augmented Generation — generación aumentada por recuperación):

• Primero, la decisión honesta: cuándo conviene RAG y cuándo es más simple meter todo el documento al prompt (con caching). Spoiler: para 3 páginas, las dos opciones son defendibles — y entender por qué te hace mejor ingeniero.
• Embeddings: convertir texto en vectores donde "¿hacen delivery?" y "entregas a domicilio" quedan cerca aunque no compartan palabras.
• El pipeline completo: trocear (chunking con solapamiento) → indexar (sentence-transformers, local y gratis) → buscar (similitud coseno en numpy, top-k) → inyectar (etiquetas <contexto>) → citar.

4.1 El problema: ¿dónde metemos el manual?

4.2 Embeddings: el significado hecho vector

Instalá lo necesario y comprobá la magia en 20 líneas. Creá 01_probar_embeddings.py:

pip install sentence-transformers numpy

"""Ver la similitud semantica con tus propios ojos."""
import numpy as np
from sentence_transformers import SentenceTransformer

modelo = SentenceTransformer("paraphrase-multilingual-MiniLM-L12-v2")

frases = [
    "¿Hacen entregas a domicilio?",
    "¿Llevan la comida hasta mi casa?",
    "¿Puedo pagar con tarjeta de crédito?",
    "El cielo de San Miguel está despejado hoy",
]

vectores = modelo.encode(frases)          # matriz (4, 384)
print(f"Forma de la matriz: {vectores.shape}")


def coseno(a: np.ndarray, b: np.ndarray) -> float:
    return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))


print("\nSimilitud con la frase 0 ('¿Hacen entregas a domicilio?'):")
for i, frase in enumerate(frases[1:], start=1):
    print(f"  {coseno(vectores[0], vectores[i]):.3f}  {frase}")

Salida típica:

Forma de la matriz: (4, 384)

Similitud con la frase 0 ('¿Hacen entregas a domicilio?'):
  0.812  ¿Llevan la comida hasta mi casa?
  0.378  ¿Puedo pagar con tarjeta de crédito?
  0.135  El cielo de San Miguel está despejado hoy

"Entregas a domicilio" y "llevan la comida hasta mi casa" no comparten ninguna palabra clave y aun así el modelo las pone juntas (0.81). Eso es búsqueda semántica, y ningún LIKE '%delivery%' de SQL puede hacerlo.

4.3 El corpus: políticas y preguntas frecuentes de La Esquina

Guardá este documento como politicas_la_esquina.md — es el conocimiento que el bot va a "estudiar". Fijate que está organizado en secciones con títulos ##, porque vamos a trocear por sección:

# Políticas y preguntas frecuentes — La Esquina

## Entregas a domicilio
Hacemos entregas a domicilio desde la sucursal Centro y la sucursal Roosevelt,
en un radio de 3 kilómetros, todos los días de 11:00 a 19:00. El costo de
envío es 1.50 dólares dentro del radio. El pedido mínimo para entrega es
5.00 dólares.
La sucursal Metrocentro no hace entregas: solo para llevar o comer ahí.

## Formas de pago
Aceptamos efectivo en todas las sucursales. Las sucursales Centro y
Metrocentro también aceptan tarjeta de débito y crédito (Visa y Mastercard).
Aceptamos pagos por transferencia con confirmación previa para encargos
grandes. No aceptamos cheques ni dólares dañados o rotos.

## Encargos para eventos
Para encargos de más de 50 pupusas pedimos al menos 24 horas de anticipación
y un adelanto del 50%. Los encargos de eventos incluyen curtido y salsa en
envases familiares sin costo extra. Para encargos de más de 200 pupusas,
contactar directamente a la encargada de la sucursal Centro al
7777-0000 con 3 días de anticipación.

## Reclamos y devoluciones
Si un pedido llegó incompleto o con errores, lo reponemos sin costo
presentando el comprobante, dentro de las 2 horas siguientes a la compra.
No hacemos devoluciones de dinero, solo reposición del producto. Para
reclamos, el cliente puede hablar con el encargado de turno en cualquier
sucursal o escribir al 7777-0000.

## Cliente frecuente
El programa "Esquina de Oro" da una pupusa gratis por cada 10 compradas.
La tarjeta se pide en caja, es gratuita y se sella con cada compra mínima
de 3.00 dólares. Los sellos no vencen. La tarjeta llena se canjea en cualquier
sucursal. No aplica para encargos de eventos ni entregas a domicilio.

## Higiene y alérgenos
Todas nuestras pupusas se preparan en comales donde también se cocina queso
y chicharrón, por lo que no podemos garantizar ausencia de trazas de lácteos
o cerdo en ninguna pupusa. El aceite que usamos es 100% vegetal. Quien tenga
alergias severas debe avisar en caja antes de ordenar.

4.4 El pipeline RAG completo

Paso 1: chunking con solapamiento

¿Por qué trocear? Porque la unidad de recuperación importa: si indexás el documento entero como un solo vector, toda búsqueda devuelve "el documento" (inútil); si indexás oración por oración, cada chunk pierde su contexto. El punto dulce: fragmentos de 1-3 párrafos con algo de solapamiento entre consecutivos.

Nuestro corpus ya viene seccionado con ##, así que troceamos por sección — y si una sección fuera muy larga, la partimos con solapamiento:

def trocear(texto: str, max_caracteres: int = 800, solape: int = 150) -> list[dict]:
    """Parte el documento en chunks por seccion '## ', con solapamiento
    si una seccion excede max_caracteres.

    Devuelve [{"fuente": titulo_seccion, "texto": chunk}, ...]
    """
    chunks = []
    secciones = texto.split("\n## ")
    for seccion in secciones[1:]:           # [0] es el titulo del documento
        lineas = seccion.split("\n", 1)
        titulo = lineas[0].strip()
        cuerpo = lineas[1].strip() if len(lineas) > 1 else ""
        contenido = f"{titulo}\n{cuerpo}"

        if len(contenido) <= max_caracteres:
            chunks.append({"fuente": titulo, "texto": contenido})
            continue

        # Seccion larga: ventanas deslizantes CON solapamiento.
        inicio = 0
        while inicio < len(contenido):
            fin = inicio + max_caracteres
            chunks.append({"fuente": titulo, "texto": contenido[inicio:fin]})
            if fin >= len(contenido):
                break
            inicio = fin - solape          # ← el solape: retrocedemos 150 chars
    return chunks

Paso 2 y 3: indexar y buscar

Creá rag.py — el módulo completo de RAG, listo para importar desde el bot:

"""RAG para La Esquina: chunking, indexado y busqueda semantica top-k."""
from pathlib import Path

import numpy as np
from sentence_transformers import SentenceTransformer

MODELO_EMBEDDINGS = "paraphrase-multilingual-MiniLM-L12-v2"


def trocear(texto: str, max_caracteres: int = 800, solape: int = 150) -> list[dict]:
    """Parte el documento en chunks por seccion '## ', con solapamiento."""
    chunks = []
    secciones = texto.split("\n## ")
    for seccion in secciones[1:]:
        lineas = seccion.split("\n", 1)
        titulo = lineas[0].strip()
        cuerpo = lineas[1].strip() if len(lineas) > 1 else ""
        contenido = f"{titulo}\n{cuerpo}"
        if len(contenido) <= max_caracteres:
            chunks.append({"fuente": titulo, "texto": contenido})
            continue
        inicio = 0
        while inicio < len(contenido):
            fin = inicio + max_caracteres
            chunks.append({"fuente": titulo, "texto": contenido[inicio:fin]})
            if fin >= len(contenido):
                break
            inicio = fin - solape
    return chunks


class IndiceRAG:
    """Indice semantico en memoria: chunks + matriz de embeddings."""

    def __init__(self):
        self.modelo = SentenceTransformer(MODELO_EMBEDDINGS)
        self.chunks: list[dict] = []
        self.matriz: np.ndarray | None = None   # (n_chunks, 384), normalizada

    def indexar(self, ruta_documento: str) -> None:
        """Trocea el documento y calcula el embedding de cada chunk."""
        texto = Path(ruta_documento).read_text(encoding="utf-8")
        self.chunks = trocear(texto)
        textos = [c["texto"] for c in self.chunks]
        vectores = self.modelo.encode(textos)
        # Normalizamos una sola vez: el coseno se vuelve un producto punto.
        normas = np.linalg.norm(vectores, axis=1, keepdims=True)
        self.matriz = vectores / normas
        print(f"📚 Indexados {len(self.chunks)} chunks de {ruta_documento}")

    def buscar(self, pregunta: str, k: int = 3, umbral: float = 0.30) -> list[dict]:
        """Devuelve los k chunks mas similares a la pregunta.

        Filtra los que queden bajo el umbral: si nada es relevante,
        mejor devolver poco (o nada) que basura.
        """
        if self.matriz is None:
            raise RuntimeError("El índice está vacío: llamá a indexar() primero.")
        q = self.modelo.encode([pregunta])[0]
        q = q / np.linalg.norm(q)
        similitudes = self.matriz @ q            # (n_chunks,) — cosenos
        orden = np.argsort(similitudes)[::-1][:k]
        return [
            {**self.chunks[i], "similitud": float(similitudes[i])}
            for i in orden
            if similitudes[i] >= umbral
        ]


if __name__ == "__main__":
    indice = IndiceRAG()
    indice.indexar("politicas_la_esquina.md")
    for pregunta in ["¿llevan comida a la casa?",
                     "quiero encargar 100 pupusas para un cumpleaños",
                     "¿aceptan Bitcoin?"]:
        print(f"\n❓ {pregunta}")
        for r in indice.buscar(pregunta):
            print(f"   {r['similitud']:.3f}  [{r['fuente']}]")

Corrélo (python rag.py) y mirá los resultados: "¿llevan comida a la casa?" recupera Entregas a domicilio con la mayor similitud; "encargar 100 pupusas" recupera Encargos para eventos; y "¿aceptan Bitcoin?" recupera Formas de pago (relevante: ahí está la respuesta de qué SÍ se acepta).

Paso 4 y 5: inyectar el contexto y citar

¿Cómo le pasamos los chunks al modelo? Envueltos en etiquetas que separen claramente datos recuperados de instrucciones y de pregunta del usuario. Esta es la integración con el bot — el método nuevo para bot_v4.py (extiende el Chatbot del capítulo 3):

"""bot_v4.py — Esquinita con herramientas + RAG sobre las politicas."""
from bot_v3 import Chatbot, SYSTEM_PROMPT as SYSTEM_V3
from rag import IndiceRAG

SYSTEM_PROMPT = SYSTEM_V3 + """
# Conocimiento de políticas
Cuando el mensaje venga acompañado de un bloque <contexto>, ahí van fragmentos
oficiales de las políticas de La Esquina, cada uno con su fuente entre
corchetes. Reglas:
- Respondé usando SOLO la información del contexto para temas de políticas.
- Mencioná la fuente de forma natural: "según nuestra política de entregas...".
- Si el contexto no contiene la respuesta, decí que vas a consultarlo con un
  encargado. NO completés con suposiciones.
"""


class ChatbotConRAG(Chatbot):
    """Esquinita v4: el loop agentico del cap. 3 + recuperacion de politicas."""

    def __init__(self, system_prompt: str, ruta_politicas: str,
                 model: str = "claude-opus-4-8"):
        super().__init__(system_prompt, model)
        self.indice = IndiceRAG()
        self.indice.indexar(ruta_politicas)

    def _armar_mensaje_con_contexto(self, mensaje_usuario: str) -> str:
        """Busca chunks relevantes y los antepone al mensaje del usuario."""
        recuperados = self.indice.buscar(mensaje_usuario, k=3)
        if not recuperados:
            return mensaje_usuario          # nada relevante: mensaje tal cual
        contexto = "\n\n".join(
            f"[Fuente: {r['fuente']}]\n{r['texto']}" for r in recuperados
        )
        return (
            f"<contexto>\n{contexto}\n</contexto>\n\n"
            f"<pregunta_del_cliente>\n{mensaje_usuario}\n</pregunta_del_cliente>"
        )

    def enviar(self, mensaje_usuario: str) -> str:
        # Recuperamos ANTES de agregar al historial: el turno user que viaja
        # ya lleva el contexto adentro.
        mensaje_aumentado = self._armar_mensaje_con_contexto(mensaje_usuario)
        return super().enviar(mensaje_aumentado)


def main():
    bot = ChatbotConRAG(SYSTEM_PROMPT, "politicas_la_esquina.md")
    print("🫓 Esquinita v4 (herramientas + RAG) — 'salir' para terminar.\n")
    while True:
        entrada = input("Vos: ").strip()
        if entrada.lower() in ("salir", "exit", "quit"):
            print("¡Que le vaya bien!")
            break
        if not entrada:
            continue
        print(f"\nBot: {bot.enviar(entrada)}\n")


if __name__ == "__main__":
    main()

Probálo:

Vos: ¿Hacen delivery? Vivo por la Roosevelt
Bot: ¡Sí! Según nuestra política de entregas, desde la sucursal Roosevelt
     llevamos a domicilio en un radio de 3 km, de 11:00 a 19:00. El envío
     cuesta 1.50 y el pedido mínimo es de 5.00 dólares 😊

Vos: ¿Y si me llega incompleto el pedido?
Bot: Según nuestra política de reclamos, se lo reponemos sin costo si
     presenta el comprobante dentro de las 2 horas. No hacemos devolución
     de dinero, solo reposición del producto.

El bot está citando la fuente y respondiendo solo con lo que el documento dice. Y como ChatbotConRAG hereda de Chatbot, las herramientas del capítulo 3 siguen funcionando: podés preguntar las políticas de entrega y en el mismo chat encargar tus pupusas.

Resumen visual

Estado del proyecto — R5 (políticas) ✅. Con R1-R7 cumplidos, Esquinita ya hace todo lo que doña Carmen pidió... en tu terminal. Falta lo que falta siempre: ponerlo en la web, que no se caiga, que no te fundas en costos y que nadie lo hackee. Capítulo 5: a producción.

Ejercicios

- Toda respuesta que use el contexto debe terminar con una línea final:
  📋 Fuente: <nombre de la fuente usada>
  Si usaste varias fuentes, listalas separadas por coma. Si no usaste el
  contexto, no agregués esa línea.

TOOL_BUSCAR = {
    "name": "buscar_politicas",
    "description": ("Busca en las políticas oficiales de La Esquina (entregas, "
                    "pagos, encargos, reclamos, cliente frecuente, alérgenos). "
                    "Usala SIEMPRE que pregunten por reglas o políticas del "
                    "negocio. No sirve para precios del menú: para eso está "
                    "consultar_menu."),
    "input_schema": {"type": "object",
                     "properties": {"pregunta": {"type": "string",
                                    "description": "La duda del cliente, reformulada como pregunta clara."}},
                     "required": ["pregunta"]},
}

def buscar_politicas(pregunta: str) -> str:
    import json
    resultados = INDICE.buscar(pregunta, k=3)
    if not resultados:
        return json.dumps({"resultados": [], "nota": "Nada relevante en las políticas."},
                          ensure_ascii=False)
    return json.dumps({"resultados": resultados}, ensure_ascii=False)

Para profundizar

• sentence-transformers — sbert.net: documentación oficial; mirá la tabla de modelos preentrenados para elegir según idioma, tamaño y calidad.
• Embeddings y RAG en el libro de IA — LLMs y transformers, secciones 6.2 y 6.5: la teoría detrás de lo que acá implementaste.
• numpy — numpy.org/doc: si argsort, broadcasting o normas te resultaron oscuros, el quickstart oficial lo aclara en una tarde.
• Documentación de Anthropic sobre RAG — platform.claude.com/docs: guías de RAG con citas y de cuándo preferir contexto largo + caching (la misma decisión de la sección 4.1, con benchmarks).
• Bases vectoriales (Chroma, pgvector, Qdrant): el siguiente paso cuando numpy en memoria se quede corto — misma matemática, con persistencia e índices aproximados.