UD3 · Integracion con fuentes, herramientas y sistemas (RAG)

Objetivos de la unidad

Al finalizar esta unidad el alumno sera capaz de:

• Identificar y habilitar fuentes de informacion adecuadas para alimentar un sistema RAG.
• Implementar la indexacion y recuperacion de documentos usando embeddings y busqueda semantica.
• Incorporar la informacion recuperada al contexto del modelo verificando su pertinencia y vigencia.
• Integrar herramientas externas, APIs y canales de comunicacion en la solucion LLM.
• Validar la comunicacion con sistemas externos mediante pruebas especificas.

1 · Habilitacion de fuentes de informacion

Caracterizacion de las fuentes

Antes de indexar cualquier fuente, se debe caracterizar:

Una fuente de mala calidad produce un sistema RAG de mala calidad. El trabajo de preparacion de fuentes es tan critico como el diseno del sistema.

1 · Habilitacion de fuentes de informacion (cont.)

Pipeline de ingestion de documentos

Fuente original
     |
     v
[Extraccion de texto]
 PDF → pdfplumber / pymupdf
 Word → python-docx
 HTML → BeautifulSoup
 Tablas → pandas
     |
     v
[Limpieza]
 Eliminar cabeceras/pies de pagina redundantes
 Normalizar espacios y saltos de linea
 Eliminar paginas en blanco o con solo imagenes
     |
     v
[Metadatos]
 Origen, titulo, fecha, version, autor, seccion
     |
     v
[Fragmentacion]   →   [Generacion de embeddings]   →   [Base de datos vectorial]

2 · Recuperacion de informacion: fragmentacion (I)

Estrategias de fragmentacion (chunking)

La fragmentacion divide los documentos en unidades recuperables. La estrategia afecta directamente a la calidad de las respuestas:

Parametros clave:

• chunk_size: numero maximo de tokens por fragmento (tipicamente 256-512)
• chunk_overlap: solapamiento entre fragmentos contiguos para preservar contexto (tipicamente 10-20% del chunk_size)

2 · Recuperacion de informacion: fragmentacion (II)

Implementacion con LangChain

from langchain.text_splitter import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=512,
    chunk_overlap=64,
    separators=["\n\n", "\n", ". ", " ", ""]
)

# Cargar y dividir un documento
with open("manual_operaciones.txt", "r", encoding="utf-8") as f:
    texto = f.read()

fragmentos = splitter.create_documents(
    texts=[texto],
    metadatas=[{"origen": "manual_operaciones", "version": "2025-Q1"}]
)

print(f"Total fragmentos: {len(fragmentos)}")
print(f"Fragmento 0: {fragmentos[0].page_content[:200]}...")

2 · Recuperacion de informacion: embeddings y busqueda (I)

Representaciones vectoriales (embeddings)

Un embedding es la representacion numerica de un texto en un espacio de alta dimension. Textos semanticamente similares tienen vectores cercanos.

Proceso de indexacion:

from openai import OpenAI

client = OpenAI()

def generar_embedding(texto: str) -> list[float]:
    respuesta = client.embeddings.create(
        model="text-embedding-3-small",
        input=texto
    )
    return respuesta.data[0].embedding

2 · Recuperacion de informacion: embeddings y busqueda (II)

Bases de datos vectoriales y busqueda hibrida

Busqueda hibrida (vectorial + lexica):

# Busqueda semantica (vectorial)
resultados_vectoriales = vector_db.similarity_search(
    query=consulta_usuario,
    k=5
)

# Busqueda lexica (BM25)
resultados_bm25 = bm25_index.search(query=consulta_usuario, k=5)

# Fusion con Reciprocal Rank Fusion (RRF)
resultados_finales = rrf_fusion(resultados_vectoriales, resultados_bm25)

3 · Incorporacion de informacion al contexto

Verificacion de pertinencia y vigencia

No todos los fragmentos recuperados son utiles. Se debe filtrar antes de incluirlos en el contexto:

Criterios de pertinencia:

• Puntuacion de similitud superior a un umbral (ej. similitud coseno > 0.75)
• El fragmento responde a la pregunta y no solo comparte palabras clave

Criterios de vigencia:

• Fecha del documento dentro del periodo valido
• Version del documento coincide con la version activa

def filtrar_fragmentos(fragmentos: list[dict], umbral_similitud: float = 0.75) -> list[dict]:
    return [
        f for f in fragmentos
        if f["score"] >= umbral_similitud
        and not f["metadata"].get("obsoleto", False)
    ]

Limites de inclusion:

• Nunca superar el 60-70% de la ventana de contexto con documentos recuperados
• Reservar espacio para el historial y la respuesta del modelo

4 · Integracion de herramientas y APIs externas (I)

Function calling y tool use

La integracion de herramientas permite al modelo invocar funciones externas cuando necesita informacion o acciones que no puede resolver por si mismo:

herramientas = [
    {
        "name": "buscar_pedido",
        "description": "Busca el estado de un pedido por su numero en el sistema ERP",
        "input_schema": {
            "type": "object",
            "properties": {
                "numero_pedido": {
                    "type": "string",
                    "description": "Numero de pedido en formato PED-XXXXX"
                }
            },
            "required": ["numero_pedido"]
        }
    }
]

respuesta = client.messages.create(
    model="claude-opus-4-5",
    max_tokens=1024,
    tools=herramientas,
    messages=[{"role": "user", "content": "¿Donde esta mi pedido PED-12345?"}]
)

4 · Integracion de herramientas y APIs externas (II)

Gestion de credenciales y permisos

Las credenciales de acceso a APIs externas nunca deben codificarse en el codigo fuente:

Validacion de permisos antes de ejecutar una herramienta:

PERMISOS_USUARIO = {"buscar_pedido", "consultar_catalogo"}

def ejecutar_herramienta(nombre: str, args: dict, permisos: set) -> dict:
    if nombre not in permisos:
        return {"error": f"Accion '{nombre}' no permitida para este usuario"}
    # ejecutar la herramienta...

5 · Integracion con canales de comunicacion

Despliegue en canales corporativos y web

Gestion de sesion:

import uuid

sesiones = {}  # En produccion: Redis o base de datos

def obtener_o_crear_sesion(session_id: str | None) -> dict:
    if not session_id or session_id not in sesiones:
        session_id = str(uuid.uuid4())
        sesiones[session_id] = {"historial": [], "metadata": {}}
    return sesiones[session_id], session_id

6 · Validacion de las integraciones

Pruebas especificas para sistemas RAG

# Evaluacion de recuperacion: Recall@5
def recall_at_k(fragmentos_esperados: list[str], fragmentos_recuperados: list[str], k: int = 5) -> float:
    recuperados_k = set(fragmentos_recuperados[:k])
    esperados = set(fragmentos_esperados)
    return len(recuperados_k & esperados) / len(esperados) if esperados else 0.0

Actividad practica · UD3

Construccion de un sistema RAG basico

Enunciado:

Construye un sistema RAG que permita responder preguntas sobre un conjunto de tres documentos PDF de tu eleccion (pueden ser manuales tecnicos, normativas o articulos).

Tareas:

1. Extrae el texto de los PDFs y aplica limpieza basica.
2. Fragmenta los documentos con chunk_size=400 y chunk_overlap=50. Registra el numero de fragmentos generados.
3. Genera embeddings con el modelo de tu eleccion e indexalos en ChromaDB.
4. Implementa la funcion de recuperacion con busqueda semantica (top-5 fragmentos).
5. Construye el prompt final combinando los fragmentos recuperados con la pregunta del usuario.
6. Prueba el sistema con cinco preguntas: tres cuya respuesta esta en los documentos y dos fuera del corpus.
7. Registra los fragmentos recuperados y la puntuacion de similitud en cada prueba.

Entregable: notebook Jupyter con el pipeline completo + tabla de resultados de las cinco pruebas.

Puntos clave · UD3

• La calidad de las fuentes determina la calidad del sistema RAG; la preparacion de datos es critica.
• La fragmentacion debe preservar la coherencia semantica: solapamiento adecuado y respetar la estructura del documento.
• Los embeddings traducen el significado del texto a un espacio vectorial; modelos distintos producen espacios incompatibles.
• La busqueda hibrida (vectorial + lexica) supera a cualquiera de las dos por separado en la mayoria de casos reales.
• Los fragmentos recuperados deben filtrarse por pertinencia y vigencia antes de incluirlos en el contexto.
• Las credenciales de APIs externas deben gestionarse con variables de entorno o gestores de secretos, nunca en el codigo.

Criterios de evaluacion · UD3

Navegación

← UD2 · Componentes de interaccion co…  ·  Volver al módulo  ·  UD4 · Comportamientos agenticos →