RAG desde Cero: Dale Memoria a tu IA Local (Guía Completa 2025)

Tiempo de lectura estimado: 16 minutos

Has montado tu IA local con Ollama. Le preguntas cosas y responde bien… pero no recuerda conversaciones anteriores, no conoce tus documentos personales, y no puede responder sobre información que no estaba en su entrenamiento.

RAG (Retrieval-Augmented Generation) soluciona esto: le da a tu IA acceso a TUS documentos, TUS datos, y TU conocimiento. Es como darle una biblioteca personal de la que puede leer antes de responder.

⚡ TL;DR: RAG conecta tu LLM con una base de datos de documentos. Cuando preguntas algo, busca información relevante en tus docs y la incluye en el prompt. Tu IA responde con contexto específico, actualizado, y personalizado.

📋 Índice

1. ¿Qué es RAG y por qué lo necesitas?
2. ¿Cómo funciona? (Diagrama paso a paso)
3. Casos de uso reales
4. Componentes necesarios
5. Setup completo: Ollama + ChromaDB + Python
6. Implementación código (funcional)
7. Mejoras avanzadas
8. Troubleshooting común
9. Alternativas y comparativas

1. ¿Qué es RAG y Por Qué lo Necesitas?

🤔 El problema sin RAG:

Imagina que le preguntas a tu LLM local:

«¿Cuál fue el presupuesto del proyecto X que discutimos en la reunión del lunes?»

Respuesta del LLM sin RAG:
«No tengo información sobre proyectos específicos de tu empresa ni sobre reuniones recientes.»

Normal. El LLM solo sabe lo que aprendió en su entrenamiento (que terminó hace meses). No conoce TUS documentos, TUS reuniones, TU información.

✅ Con RAG:

El mismo LLM, con RAG implementado:

1. Busca en tu base de datos de documentos «reunión lunes proyecto X»
2. Encuentra tus notas de la reunión
3. Lee que el presupuesto era 50,000€
4. Responde: «Según las notas de la reunión del lunes, el presupuesto del proyecto X es de 50,000€»

Magia. Pero no es magia, es RAG.

¿Por qué RAG y no fine-tuning?

Veredicto: Para el 90% de casos, RAG es mejor opción.

2. ¿Cómo Funciona? (Diagrama Paso a Paso)

🔄 Flujo completo de RAG:

Fase 1: Indexación (preparación, haces una vez)

1. [Tus documentos] (PDFs, Markdown, TXT, etc.)
      ↓
2. [Chunking] → Divide en fragmentos (~500 tokens)
      ↓
3. [Embedding Model] → Convierte texto en vectores numéricos
      ↓
4. [Vector Database] → Guarda vectores + metadata
      (ChromaDB, Qdrant, Pinecone, etc.)

Fase 2: Query (cada vez que preguntas)

1. Usuario: "¿Presupuesto proyecto X?"
      ↓
2. [Embedding Model] → Convierte pregunta en vector
      ↓
3. [Búsqueda semántica] → Encuentra chunks similares en DB
      (Ej: top 3 chunks más relevantes)
      ↓
4. [Construcción prompt] → LLM + contexto recuperado
      "Basándote en estos documentos: [chunks]
       Responde: ¿Presupuesto proyecto X?"
      ↓
5. [LLM] → Genera respuesta con contexto
      ↓
6. Usuario recibe respuesta informada

🔑 Conceptos clave:

Embeddings: Representación numérica de texto. Textos similares tienen vectores cercanos en espacio multidimensional.

Ejemplo simple (2D para visualizar):

"gato"     → [0.8, 0.2]
"perro"    → [0.7, 0.3]
"automóvil"→ [0.1, 0.9]

«Gato» y «perro» están cerca (animales). «Automóvil» está lejos (vehículo).

Chunking: Dividir docs grandes en fragmentos manejables. LLMs tienen límite de contexto (4k-128k tokens).

Búsqueda semántica: No busca keywords exactas, sino significado. «presupuesto» encuentra también «coste», «inversión», «financiación».

3. Casos de Uso Reales

📚 1. Chat con tus PDFs

Escenario: Tienes 50 PDFs de investigación, manuales técnicos, papers.

Con RAG:

• «Resume el paper sobre transformers»
• «¿Qué dice el manual sobre configuración avanzada?»
• «Compara las conclusiones de estos 3 estudios»

El LLM lee los PDFs relevantes y responde basándose en ellos.

💼 2. Asistente interno de empresa

Escenario: Base de conocimiento de la empresa (políticas, procedimientos, FAQs).

Con RAG:

• Empleados preguntan «¿Cómo solicito vacaciones?»
• RAG busca en políticas de RRHH
• Responde con procedimiento exacto + enlace a formulario

Ahorro: cientos de horas de RRHH respondiendo lo mismo.

🏥 3. Soporte técnico con historial

Escenario: Tickets de soporte, documentación técnica, soluciones previas.

Con RAG:

• «Error 500 en módulo de pagos»
• RAG busca tickets similares resueltos
• Sugiere solución que funcionó antes

📖 4. Chatbot de documentación

Escenario: Docs de tu producto/servicio (guías, API reference, tutoriales).

Con RAG:

• Usuarios preguntan en lenguaje natural
• RAG encuentra sección relevante
• Explica + da link a docs

🎓 5. Tutor personal

Escenario: Tus apuntes de curso, libros de texto, ejercicios.

Con RAG:

• «Explícame el teorema X con ejemplo»
• RAG busca en tus apuntes
• Usa TUS ejemplos y TU forma de explicar

4. Componentes Necesarios

🧩 Stack completo:

1. LLM (Modelo de lenguaje)

• Recomendado: Ollama (local, gratis, fácil)
• Modelos: Llama 3.1, Mistral, Qwen
• Alternativas: OpenAI API, Anthropic Claude

👉 Guía instalación: Servidor IA Casero

2. Embedding Model

• Recomendado: all-MiniLM-L6-v2 (384 dimensiones, rápido)
• Alternativa potente: BGE-large (1024 dim, más preciso)
• Via sentence-transformers (Python library)

3. Vector Database

• Principiantes: ChromaDB (Python, simple, local)
• Producción: Qdrant (más features, escalable)
• Cloud: Pinecone, Weaviate

4. Framework RAG (opcional pero recomendado)

• LangChain: Más popular, ecosistema gigante
• LlamaIndex: Especializado en RAG
• Haystack: Open source completo

Vamos a usar LangChain porque tiene mejor documentación y comunidad.

💻 Requisitos técnicos:

• CPU: Cualquiera moderna
• RAM: 8GB mínimo (16GB+ recomendado)
• GPU: Opcional (acelera LLM, no necesaria para RAG básico)
• Disco: Depende de tus docs (10-100GB)
• OS: Linux, macOS, Windows

5. Setup Completo: Ollama + ChromaDB + Python

📦 Paso 1: Instalar Ollama

# Linux / macOS
curl -fsSL https://ollama.com/install.sh | sh

# Descargar modelo
ollama pull llama3.1:8b

# Verificar
ollama run llama3.1:8b "Hola, ¿funcionas?"

🐍 Paso 2: Crear entorno Python

# Crear proyecto
mkdir rag-project && cd rag-project
python3 -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate

# Instalar dependencias
pip install langchain langchain-community chromadb sentence-transformers ollama

📁 Paso 3: Preparar documentos

# Crear carpeta docs
mkdir docs

# Agregar tus documentos (PDF, TXT, MD)
# Ej: docs/manual.pdf, docs/notas.txt

6. Implementación Código (Funcional)

🔧 Script completo RAG básico:

Archivo: rag_simple.py

#!/usr/bin/env python3
"""
RAG simple con Ollama local + ChromaDB
"""

from langchain_community.document_loaders import DirectoryLoader, TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_community.llms import Ollama
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate

# 1. Cargar documentos
print("📚 Cargando documentos...")
loader = DirectoryLoader('./docs', glob="**/*.txt", loader_cls=TextLoader)
documents = loader.load()
print(f"   ✅ {len(documents)} documentos cargados")

# 2. Dividir en chunks
print("\n✂️  Dividiendo en chunks...")
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50
)
texts = text_splitter.split_documents(documents)
print(f"   ✅ {len(texts)} chunks creados")

# 3. Crear embeddings
print("\n🧠 Generando embeddings...")
embeddings = HuggingFaceEmbeddings(
    model_name="sentence-transformers/all-MiniLM-L6-v2"
)

# 4. Crear/cargar vector store
print("\n💾 Creando base de datos vectorial...")
vectorstore = Chroma.from_documents(
    documents=texts,
    embedding=embeddings,
    persist_directory="./chroma_db"
)
print("   ✅ Base de datos lista")

# 5. Configurar LLM (Ollama local)
print("\n🤖 Conectando con Ollama...")
llm = Ollama(
    model="llama3.1:8b",
    temperature=0.2
)

# 6. Crear prompt template
template = """Eres un asistente útil. Usa el contexto para responder.

Contexto: {context}

Pregunta: {question}

Respuesta (en español, basándote SOLO en el contexto):"""

PROMPT = PromptTemplate(
    template=template,
    input_variables=["context", "question"]
)

# 7. Crear chain RAG
print("\n⛓️  Creando RAG chain...")
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3}),
    chain_type_kwargs={"prompt": PROMPT}
)

print("\n✅ RAG listo! Haz preguntas (escribe 'salir' para terminar)\n")

# 8. Loop de preguntas
while True:
    query = input("🗣️  Pregunta: ")

    if query.lower() in ['salir', 'exit', 'quit']:
        print("👋 ¡Hasta luego!")
        break

    print("\n🤔 Pensando...")
    result = qa_chain.invoke({"query": query})
    print(f"\n💡 Respuesta:\n{result['result']}\n")
    print("-" * 60 + "\n")

▶️ Ejecutar:

python rag_simple.py

🎯 Ejemplo de uso:

🗣️  Pregunta: ¿Qué es RAG?

🤔 Pensando...

💡 Respuesta:
RAG (Retrieval-Augmented Generation) es una técnica que combina
búsqueda de información con generación de texto. Permite que un
modelo de lenguaje acceda a documentos externos para responder
preguntas con información actualizada y específica.

------------------------------------------------------------

🗣️  Pregunta: Resume el contenido principal

🤔 Pensando...

💡 Respuesta:
Según los documentos, el contenido principal trata sobre...
[respuesta basada en TUS documentos]

7. Mejoras Avanzadas

🚀 1. Soportar PDFs

from langchain_community.document_loaders import PyPDFLoader

# En lugar de DirectoryLoader
loader = PyPDFLoader("./docs/manual.pdf")
documents = loader.load()

Instalar: pip install pypdf

🎨 2. Interfaz web con Streamlit

Archivo: app.py

import streamlit as st
from rag_simple import qa_chain  # Importa tu chain

st.title("🤖 RAG Chat - Pregúntale a tus documentos")

query = st.text_input("Tu pregunta:")

if query:
    with st.spinner("Pensando..."):
        result = qa_chain.invoke({"query": query})
        st.success(result['result'])

Ejecutar: streamlit run app.py

📊 3. Mostrar fuentes (transparencia)

# Modificar chain para retornar sources
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=vectorstore.as_retriever(),
    return_source_documents=True  # ← Agregar esto
)

# Al consultar
result = qa_chain.invoke({"query": query})
print(f"Respuesta: {result['result']}")
print(f"\nFuentes:")
for doc in result['source_documents']:
    print(f"- {doc.metadata['source']}")

🔍 4. Reranking (mejorar relevancia)

Usar modelo de reranking DESPUÉS de búsqueda inicial:

from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import CohereRerank

compressor = CohereRerank()
compression_retriever = ContextualCompressionRetriever(
    base_compressor=compressor,
    base_retriever=vectorstore.as_retriever()
)

💾 5. Actualizar docs sin reindexar todo

# Cargar vectorstore existente
vectorstore = Chroma(
    persist_directory="./chroma_db",
    embedding_function=embeddings
)

# Agregar nuevos documentos
new_docs = [...]  # Cargar nuevos docs
vectorstore.add_documents(new_docs)
vectorstore.persist()

8. Troubleshooting Común

❌ Problema 1: «Respuestas genéricas, no usa mis docs»

Causas:

• Chunks muy pequeños (no hay contexto)
• k muy bajo (busca solo 1-2 chunks)
• Embeddings malos

Soluciones:

• Aumenta chunk_size a 800-1000
• Aumenta k a 5-7 chunks
• Usa embedding model mejor (BGE-large)
• Verifica que docs se cargaron: print(documents)

❌ Problema 2: «Muy lento»

Causas:

• LLM grande (70B params)
• Muchos chunks recuperados
• Embedding model pesado

Soluciones:

• Usa modelo más pequeño (7B-13B)
• Reduce k a 3
• Usa all-MiniLM en lugar de BGE
• Considera GPU para LLM

❌ Problema 3: «Respuestas contradictorias»

Causa: Chunks de diferentes docs con info contradictoria.

Soluciones:

• Implementa metadata filtering (solo ciertos docs)
• Usa reranking
• Pide al LLM que señale contradicciones en prompt

❌ Problema 4: «No encuentra info que SÉ que está»

Causa: Búsqueda semántica no coincide con keywords.

Soluciones:

• Hybrid search (semántica + keyword BM25)
• Ajusta embedding model
• Mejora chunking (preserva contexto)

❌ Problema 5: «Out of memory»

Causa: Demasiados docs o modelo muy grande.

Soluciones:

• Indexa por lotes
• Usa modelo quantizado (4-bit, 8-bit)
• Limpia vectorstore periódicamente

9. Alternativas y Comparativas

🗄️ Vector Databases:

🧠 Embedding Models:

🔗 Frameworks:

🎯 Conclusión

RAG transforma tu LLM de un modelo genérico en un asistente personalizado con acceso a TU conocimiento. La implementación básica es sorprendentemente simple (50 líneas de Python), pero hay espacio infinito para mejoras.

Recap de beneficios:

• ✅ IA con contexto actualizado
• ✅ Respuestas basadas en tus docs
• ✅ Transparencia (muestra fuentes)
• ✅ Más barato que fine-tuning
• ✅ Fácil de actualizar (añades docs)
• ✅ 100% local (privacidad)

Roadmap de implementación:

1. Día 1: Setup Ollama + script básico con 2-3 docs de prueba
2. Día 2: Indexa tus docs reales, ajusta chunks
3. Día 3: Implementa interfaz web (Streamlit)
4. Semana 2: Mejoras (reranking, sources, metadata)
5. Futuro: Multi-modal (imágenes), agents, fine-tuning selectivo

«RAG no es el futuro de la IA, es el presente. Y está al alcance de cualquiera con Python y un PC decente.»

❓ FAQ

¿Necesito GPU?
No para RAG básico. Embeddings corren en CPU rápido. GPU ayuda para el LLM (Ollama), pero modelos 7B corren OK en CPU.

¿Cuántos documentos puedo indexar?
ChromaDB local: miles de docs sin problema. Para millones, usa Qdrant o Pinecone cloud.

¿Funciona con idiomas no-inglés?
Sí. Usa embeddings multilingües (paraphrase-multilingual-MiniLM) y LLM que soporte tu idioma.

¿Es mejor que ChatGPT con «Custom GPTs»?
Depende. Custom GPTs son más fáciles. RAG local te da privacidad total, sin costes recurrentes, y control completo.

¿Puedo combinarlo con fine-tuning?
Sí! RAG para conocimiento específico + fine-tuning para comportamiento/estilo = combo perfecto.

¿Qué pasa con la privacidad de mis docs?
Con Ollama local + ChromaDB local: 100% privado. Nada sale de tu máquina.

📚 Recursos relacionados:

• Servidor IA Casero con GPU – Setup Ollama completo
• Guía n8n v2 – Automatiza workflows RAG
• Homelab desde Cero – Infraestructura para correr RAG

¿Listo para darle memoria a tu IA? Empieza con el script básico, 3 documentos de prueba, y expande desde ahí. En 1 hora tendrás tu primer RAG funcional. 🚀

Preguntas Frecuentes sobre RAG (Retrieval Augmented Generation)

¿Qué es RAG exactamente?

RAG combina búsqueda de documentos + LLM. Busca información relevante en tu knowledge base y la inyecta como contexto al prompt. Resultado: respuestas basadas en tus datos, no solo conocimiento del modelo.

¿RAG es difícil de implementar?

Básico: 50 líneas Python (LangChain + ChromaDB + OpenAI). Producción robusta: 200-300 líneas. Más simple que fine-tuning y más flexible que prompt engineering puro.

¿Necesito GPU para RAG?

No para embeddings básicos (sentence-transformers corre en CPU). Sí si usas LLM local (Llama, Mistral). Alternativa: API externa (OpenAI, Claude) = zero GPU.

¿Cuántos documentos puedo indexar con RAG?

ChromaDB (local): millones de documentos. Pinecone (cloud): hasta 100M+ vectores. Límite real: calidad de chunks y embeddings, no cantidad. Prioriza relevancia sobre volumen.

¿RAG funciona en español?

Sí, usa modelos multilingües como paraphrase-multilingual-mpnet-base-v2 para embeddings. LLMs como GPT-4, Claude, Gemini manejan español nativamente. Calidad igual que inglés.

¿Cómo mejoro la precisión de RAG?

5 técnicas clave: 1) Chunks más pequeños (200-400 tokens), 2) Metadata filtering, 3) Re-ranking con Cohere, 4) Hybrid search (keyword + vector), 5) Parent document retrieval.