Fundamentos de Retrieval-Augmented Generation (RAG)

Un curso práctico de 7 unidades para aprender a diseñar, implementar y evaluar sistemas Retrieval-Augmented Generation (RAG) desde cero. Construirás pipelines reales —localmente, con Ollama— que integran chunking semántico, embeddings, búsqueda híbrida, generación aumentada por recuperación y evaluación objetiva.

Fecha de creación: 2026-06-02 Stack principal: Python 3.11+ · LangChain · ChromaDB · FAISS · Sentence-Transformers · Ollama · DeepEval Duración estimada: 24–32 horas

---

Audiencia y prerrequisitos

Este curso está diseñado para:

• Estudiantes de ingeniería, ciencia de datos o carreras afines.
• Profesionales que quieran incorporar RAG en sus proyectos.
• Personas con conocimiento básico de Python (funciones, listas, pandas) y nociones introductorias de Machine Learning (qué es un vector, qué es un modelo de lenguaje). No se requiere experiencia previa con LLMs ni con sistemas de recuperación.

Prerrequisitos técnicos concretos:

---

Estructura del curso

fundamentos_rag/
├── README.md                  ← Este archivo
├── syllabus.md                ← Programa detallado con evidencias
├── course.brief.md            ← Brief pedagógico (para instructores)
├── course.plan.md             ← Plan de unidades (para instructores)
├── decisions.md               ← Decisiones de diseño (para instructores)
│
├── source/units/              ← Unidades del curso
│   ├── unit-1.md              → Unidad 1: Introducción a RAG (Markdown)
│   ├── unit-2.ipynb           → Unidad 2: Embeddings y Búsqueda Semántica
│   ├── unit-3.ipynb           → Unidad 3: Estrategias de Chunking
│   ├── unit-4.ipynb           → Unidad 4: Retrieval — Denso, Disperso e Híbrido
│   ├── unit-5.ipynb           → Unidad 5: Integración con LLMs
│   ├── unit-6.ipynb           → Unidad 6: Evaluación de Sistemas RAG
│   ├── unit-7.ipynb           → Unidad 7: Proyecto Final RAG
│   └── unit-7-report.md       → Plantilla de informe del proyecto final
│
├── data/                      ← Datos de ejemplo
│   └── manual-smartfridge-X200.txt
│
├── artifacts/notebooks/       ← Notebooks ejecutados (con outputs visibles)
│   ├── unit-2.executed.ipynb
│   ├── unit-3.executed.ipynb
│   ├── unit-4.executed.ipynb
│   ├── unit-5.executed.ipynb
│   ├── unit-6.executed.ipynb
│   └── unit-7.executed.ipynb
│
├── quality/                   ← Reportes de calidad y ejecución
│   ├── execution/             → Reportes de ejecución técnica
│   ├── reviews/               → Revisiones pedagógicas
│   └── claims/                → (futuro) Reclamaciones de calidad
│
└── research/                  ← Investigación del ecosistema RAG 2026
    ├── rag-ecosystem-2026.md
    ├── literature-notes.md
    └── sources/

---

Instalación y configuración

1. Requisitos del sistema

• Python 3.11 o superior
• pip (gestor de paquetes de Python)
• Ollama para ejecutar modelos de lenguaje localmente
• Conexión a internet (solo para descargas iniciales; los notebooks son 100% locales)

2. Instalar dependencias

Ejecuta estos comandos en una terminal:

# Clona o copia el repositorio del curso
cd fundamentos_rag

# Crea un entorno virtual (recomendado)
python -m venv .venv
source .venv/bin/activate  # En Windows: .venv\Scripts\activate

# Instala las dependencias principales
pip install --upgrade pip
pip install langchain langchain-community langchain-text-splitters
pip install chromadb
pip install faiss-cpu
pip install sentence-transformers
pip install rank-bm25
pip install jupyter
pip install deepeval

# Para la integración con OpenAI (opcional, Unidad 5)
pip install openai

3. Instalar y configurar Ollama

Ollama permite ejecutar modelos de lenguaje como Gemma 4 o Qwen 3 en tu máquina sin necesidad de API keys.

# Instalar desde https://ollama.com/download

# Descargar el modelo usado en el curso (~8 GB)
ollama pull gemma4

# Verificar que el modelo responde
ollama run gemma4 "Hola, ¿estás funcionando?"

Nota: Si tu máquina tiene menos de 16 GB de RAM, puedes usar modelos más ligeros como llama3.2:3b o qwen3:7b. Los notebooks permiten cambiar el modelo fácilmente.

4. Verificar la instalación

Desde la raíz del curso, abre un terminal Python y prueba:

from sentence_transformers import SentenceTransformer
modelo = SentenceTransformer("BAAI/bge-small-en-v1.5")
vector = modelo.encode("RAG combina recuperación y generación")
print(f"Dimensión del embedding: {len(vector)}")  # Debe mostrar 384

---

Cómo usar el material

Progresión recomendada

Las unidades deben ejecutarse en orden secuencial. Cada una construye sobre la anterior:

Para unidades en formato Markdown (U1)

Abre source/units/unit-1.md con cualquier editor de texto o visualizador Markdown. Contiene toda la teoría, diagramas de arquitectura, ejemplos y actividades.

Para unidades en formato Notebook (U2–U7)

# Inicia Jupyter
jupyter notebook

# Navega a source/units/ y abre:
#   unit-2.ipynb, unit-3.ipynb, ..., unit-7.ipynb

# Ejecuta las celdas en orden (Shift+Enter)
# Lee las explicaciones en las celdas Markdown (texto)
# Modifica las celdas de código para experimentar

Cada notebook combina:

• Celdas de texto (Markdown) — explicaciones conceptuales, diagramas, instrucciones.
• Celdas de código — implementaciones listas para ejecutar.
• Actividades — espacios para que escribas tu propio código.

Para el proyecto final (U7)

Después de completar el notebook de la Unidad 7, usa la plantilla source/units/unit-7-report.md para documentar:

1. Descripción del corpus que elegiste.
2. Decisiones de chunking y embedding.
3. Pipeline de retrieval y resultados.
4. Evaluación con métricas (faithfulness, relevancy, precision, recall).
5. Reflexión sobre lo aprendido.

Consulta de notebooks ejecutados

Si solo quieres ver los resultados sin ejecutar, abre los archivos en artifacts/notebooks/ — contienen todas las salidas visibles.

---

Lo que lograrás al finalizar

• Explicar la arquitectura RAG y distinguirla de búsqueda tradicional, prompting largo y fine-tuning.
• Construir embeddings y usar similitud vectorial para recuperar fragmentos relevantes.
• Diseñar estrategias de chunking y analizar su efecto sobre la recuperación.
• Implementar retrieval denso, disperso e híbrido con FAISS, BM25 y fusión de resultados.
• Integrar un retriever con un LLM para producir respuestas aumentadas por contexto.
• Evaluar un sistema RAG con métricas de fidelidad, relevancia y calidad del contexto recuperado.
• Construir y documentar un asistente RAG funcional sobre un corpus real.

Stack tecnológico del curso

---

Alcance y no-alcance

✅ Este curso cubre

• El pipeline completo de RAG: ingestión → chunking → embeddings → retrieval → reranking → generación → evaluación.
• Implementaciones 100% locales con Ollama.
• Técnicas de chunking (fijo, recursivo, semántico).
• Retrieval híbrido (FAISS + BM25 + RRF).
• Evaluación con métricas objetivas (faithfulness, relevancy, precision, recall).
• Comparación LLM puro vs RAG.
• Proyecto final integrador con corpus propio.

❌ Este curso NO cubre

• Fine-tuning de modelos de lenguaje o embeddings.
• Sistemas RAG multimodales (imagen, audio, video).
• Despliegue en producción o arquitecturas serverless.
• RAG sobre grafos de conocimiento (GraphRAG).
• Agentes autónomos complejos (aunque se menciona Agentic RAG como optativo).
• Frameworks alternativos en profundidad (LlamaIndex, Haystack, DSPy).

---

Referencias

• Syllabus detallado: [syllabus.md](./syllabus.md)
• Brief pedagógico: [course.brief.md](./course.brief.md)
• Plan de unidades: [course.plan.md](./course.plan.md)
• Decisiones de diseño: [decisions.md](./decisions.md)
• Investigación del ecosistema RAG 2026: [research/rag-ecosystem-2026.md](./research/rag-ecosystem-2026.md)
• Notas bibliográficas: [research/literature-notes.md](./research/literature-notes.md)

---

Curso generado el 2026-06-02. Todo el contenido ha sido verificado contra ejecución real en el runtime del curso. Si encuentras errores o tienes sugerencias, por favor repórtalos para mantener la calidad del material.