Key Takeaways
- RAG = subir documentos + dejar que el modelo responda preguntas sobre ellos citando fuentes.
- Open WebUI tiene el RAG integrado más sencillo. Sube un PDF, haz preguntas. Configuración en 5 minutos.
- LlamaIndex es el framework más flexible para construir pipelines de RAG.
- LangChain es el framework profesional más utilizado, con un ecosistema masivo.
- Chroma y Qdrant son las principales bases de datos vectoriales para almacenar chunks de documentos.
- En abril de 2026, el RAG local es maduro y está listo para producción.
¿Qué es RAG (Retrieval-Augmented Generation)?
RAG es una técnica que permite a tu LLM responder preguntas sobre tus propios documentos sin necesidad de hacer fine-tuning al modelo.
El proceso: (1) Sube tus documentos (PDFs, archivos de texto), (2) divídelos en chunks, (3) convierte los chunks en embeddings (vectores numéricos), (4) almacena los embeddings en una base de datos vectorial, (5) cuando hagas una pregunta, recupera los chunks relevantes de la base de datos, (6) pasa los chunks + la pregunta al LLM, (7) el LLM responde basándose en los chunks.
RAG es preferible al fine-tuning cuando tus documentos cambian con frecuencia (el fine-tuning es un entrenamiento único) y necesitas atribución de fuentes (RAG muestra qué documentos se usaron).
Las 8 mejores herramientas RAG locales en 2026
| Herramienta | Tipo | Ideal para | Base de datos vectorial | Curva de aprendizaje |
|---|---|---|---|---|
| Open WebUI | Aplicación web (Docker) | Principiantes, configuración más sencilla | Integrada | Ninguna |
| LlamaIndex | Framework Python | Pipelines flexibles | Cualquiera (Chroma, Qdrant, Pinecone) | Media |
| LangChain | Framework Python | Sistemas de producción | Cualquiera | Media |
| Chroma | Base de datos vectorial | RAG sencillo | Chroma (embebida) | Baja |
| Qdrant | Base de datos vectorial | RAG escalable | Qdrant (distribuida) | Media |
| Weaviate | Base de datos vectorial | Consultas GraphQL | Weaviate | Media |
| Milvus | Base de datos vectorial | Gran escala | Milvus | Alta |
| Text-Generation-WebUI RAG | Extensión | Integrado con el modelo | Integrada | Baja |
¿Cómo usar Open WebUI RAG (la opción más sencilla)?
Open WebUI tiene RAG integrado. Sin configuración adicional más allá de Docker. Solo sube documentos y haz preguntas.
# 1. Ejecutar Open WebUI con Docker
docker run -d -p 3000:8080 \
-e OLLAMA_BASE_URL=http://host.docker.internal:11434 \
ghcr.io/open-webui/open-webui:latest
# 2. Abre http://localhost:3000
# 3. Haz clic en "+" junto al campo de mensaje → "Subir archivos"
# 4. Selecciona PDFs o archivos de texto
# 5. Haz preguntas -- Open WebUI recupera los chunks relevantes
# 6. El modelo responde basándose en los documentos, con citas¿Cómo construir RAG con LlamaIndex?
LlamaIndex es un framework que gestiona la carga de documentos, chunking, embedding y recuperación. Flexible, compatible con cualquier base de datos vectorial.
# 1. Instalar
pip install llama-index
pip install llama-index-embeddings-ollama # usar embeddings de Ollama en local
pip install llama-index-vector-stores-chroma # usar Chroma para almacenamiento
# 2. Pipeline RAG sencillo
from llama_index.core import SimpleDirectoryReader, VectorStoreIndex
from llama_index.embeddings.ollama import OllamaEmbedding
# Cargar documentos
documents = SimpleDirectoryReader("./documents").load_data()
# Crear índice con embeddings locales
embedding_model = OllamaEmbedding(model_name="nomic-embed-text")
index = VectorStoreIndex.from_documents(
documents,
embed_model=embedding_model
)
# Consulta
query_engine = index.as_query_engine()
response = query_engine.query("What does the document say about X?")
print(response)¿Cómo construir RAG con LangChain?
LangChain es el framework más utilizado para sistemas RAG en producción. Compatible con todas las bases de datos vectoriales y proveedores de LLM.
# pip install langchain langchain-community langchain-chroma
from langchain.document_loaders import DirectoryLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OllamaEmbeddings
from langchain.vectorstores import Chroma
from langchain.chat_models import ChatOllama
from langchain.chains import RetrievalQA
# Cargar documentos
loader = DirectoryLoader("./documents")
docs = loader.load()
# Dividir en chunks
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
chunks = splitter.split_documents(docs)
# Crear embeddings y vector store
embeddings = OllamaEmbeddings(model="nomic-embed-text")
vectorstore = Chroma.from_documents(chunks, embeddings)
# Crear cadena QA
llm = ChatOllama(model="llama3.2:8b")
qa = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=vectorstore.as_retriever()
)
# Responder preguntas
result = qa.run("What does the document say about X?")
print(result)¿Qué bases de datos vectoriales son mejores para RAG local?
Chroma (la más sencilla): Base de datos vectorial en proceso. Sin configuración de servidor. Ideal para proyectos RAG pequeños (< 1M documentos).
Qdrant (escalable): Auto-alojada o en la nube. Mejor para RAG a gran escala. Más funcionalidades que Chroma.
Weaviate: Basada en GraphQL. Buena para consultas complejas sobre embeddings.
Milvus: De nivel empresarial. Para RAG masivo (100M+ documentos).
Para la mayoría de los despliegues locales, Chroma es suficiente y la más sencilla.
¿Deberías usar RAG o fine-tuning?
Usa este criterio:
- Usa RAG si: tus documentos cambian con frecuencia, necesitas atribución de fuentes, quieres cero entrenamiento del modelo, o tienes menos de 100K documentos.
- Usa fine-tuning si: tu base de conocimiento es fija, quieres que el modelo realmente "entienda" el dominio, o necesitas velocidad de inferencia (los modelos con fine-tuning son más rápidos).
- Combina ambos: Haz fine-tuning de un modelo en tu dominio y luego añade RAG encima para Q&A de muy alta calidad.
Errores comunes con RAG local
- Usar el tamaño de chunk incorrecto. Muy pequeño (100 tokens) = demasiadas piezas pequeñas. Muy grande (2000 tokens) = poco específico. El óptimo es 500-1000 tokens.
- Olvidar usar embeddings. No puedes hacer RAG sin convertir los chunks en embeddings. Usa `nomic-embed-text` (el mejor para inglés) o `bge-m3` (multilingüe).
- No evaluar la calidad de la recuperación. Que RAG funcione no significa que recupere los documentos correctos. Prueba con preguntas conocidas y verifica que los chunks recuperados sean relevantes.
- Tratar RAG como sustituto del fine-tuning. RAG es recuperación + aprendizaje en contexto. El fine-tuning es adaptación real del modelo. Son herramientas distintas para usos distintos.
Preguntas frecuentes sobre RAG local
¿Cuántos documentos puede gestionar el RAG local?
Depende de la base de datos vectorial. Chroma gestiona 100K-1M documentos fácilmente en hardware de consumo. Más de 1M, usa Qdrant o Milvus.
¿Puede RAG funcionar con imágenes?
Solo si extraes texto primero (OCR). Para una comprensión real de imágenes, usa modelos multimodales como Llama 3.2 Vision con RAG.
¿Es RAG más lento que el fine-tuning?
RAG requiere recuperación (milisegundos) + paso de contexto (tokens añadidos al prompt). Típicamente más lento que la inferencia con fine-tuning, pero mucho más rápido de configurar.
¿Puedo usar embeddings en la nube con LLMs locales?
Sí. Usa embeddings en la nube (OpenAI, Cohere) para la recuperación y LLMs locales para las respuestas. El enfoque híbrido es habitual.
Fuentes
- Documentación de LlamaIndex -- docs.llamaindex.ai
- Documentación de LangChain -- python.langchain.com
- Documentación de Chroma -- docs.trychroma.com
- Documentación de Qdrant -- qdrant.tech/documentation
- Artículo RAG -- arxiv.org/abs/2005.11401