LangChain vs LlamaIndex: Framework RAG para Homelab (Guía Comparativa 2025)

📋 TL;DR

LangChain y LlamaIndex son los dos frameworks más populares para implementar RAG (Retrieval-Augmented Generation) en homelabs. LangChain destaca en orquestación de flujos complejos y gestión de memoria conversacional, mientras que LlamaIndex se especializa en indexación y recuperación eficiente de datos. Esta guía compara ambos frameworks técnicamente, incluye ejemplos funcionales con Qdrant y Ollama, y te ayuda a elegir el correcto según tu caso de uso.

Lo que conseguirás:

• ✅ Comparativa técnica detallada con benchmarks reales
• ✅ Ejemplos funcionales copy-paste para ambos frameworks
• ✅ Docker-2025/) Compose listos para producción
• ✅ Troubleshooting de errores comunes
• ✅ Recomendaciones claras: cuándo usar cada uno

Tiempo de lectura: ~25 minutos | Nivel: Intermedio-Avanzado

—

📚 Tabla de Contenidos

1. ¿Qué es RAG y Por Qué Necesitas un Framework?
2. LangChain: Características y Arquitectura
3. LlamaIndex: Características y Arquitectura
4. Comparativa Técnica Detallada
5. Instalación y Setup: [Docker Compose para Ambos](#instalacion)
6. Ejemplos Prácticos: RAG con Qdrant + Ollama
7. Benchmarks: Performance y Latencia
8. Mejores Prácticas y Recomendaciones
9. Troubleshooting Común
10. Preguntas Frecuentes
11. Conclusión y Próximos Pasos

—

> 📅 Última actualización: Diciembre 2025

> ✅ Verificado con: LangChain 0.1.0, LlamaIndex 0.10.0, Qdrant 1.7.0, Ollama 0.1.0

> 🔄 Próxima revisión: Marzo 2026

—

Introducción

Si estás construyendo un sistema RAG en tu homelab, probablemente te has preguntado: ¿LangChain o LlamaIndex? Ambos frameworks son populares, tienen comunidades grandes, y prometen simplificar la implementación de RAG. Pero tienen enfoques diferentes y cada uno brilla en casos de uso distintos.

El problema: Elegir el framework incorrecto puede resultar en semanas de desarrollo desperdiciadas, código innecesariamente complejo, o sistemas lentos que no escalan.

La solución: Esta guía compara ambos frameworks técnicamente, con benchmarks reales, ejemplos funcionales, y recomendaciones claras basadas en casos de uso reales en homelabs.

En esta guía completa aprenderás:

• Diferencias técnicas fundamentales entre LangChain y LlamaIndex
• Cuándo usar cada framework según tu caso de uso
• Cómo implementar RAG con Qdrant y Ollama en ambos frameworks
• Optimizaciones de rendimiento y mejores prácticas
• Troubleshooting de errores comunes
• Benchmarks reales de performance y latencia

Ya seas un desarrollador experimentado que busca la mejor herramienta para un proyecto específico, o un sysadmin de homelab que quiere implementar RAG por primera vez, esta guía te dará la información técnica necesaria para tomar la decisión correcta.

—

¿Qué es RAG y Por Qué Necesitas un Framework?

¿Qué es RAG (Retrieval-Augmented Generation)?

RAG (Retrieval-Augmented Generation) es una técnica que combina la recuperación de información relevante de una base de conocimientos con la generación de texto usando modelos de lenguaje. En lugar de que el LLM genere respuestas solo con su conocimiento pre-entrenado, RAG permite:

1. Recuperación: Buscar información relevante en documentos, bases de datos o APIs
2. Aumento: Inyectar esa información en el contexto del LLM
3. Generación: El LLM genera respuestas basadas en la información recuperada

Ventajas de RAG:

• ✅ Respuestas más precisas y actualizadas (no limitadas al conocimiento pre-entrenado)
• ✅ Reducción de alucinaciones (el LLM tiene acceso a información verificada)
• ✅ Capacidad de trabajar con datos privados o específicos del dominio
• ✅ No requiere re-entrenar el modelo (más económico y rápido)

¿Por Qué Necesitas un Framework RAG?

Implementar RAG desde cero requiere:

• Gestión de embeddings y vector stores (Qdrant, Pinecone, Weaviate)
• Chunking y procesamiento de documentos (dividir textos en fragmentos)
• Integración con múltiples LLMs (Ollama, OpenAI, Anthropic)
• Manejo de contexto y memoria (para conversaciones multi-turn)
• Optimización de queries y recuperación (top-k, re-ranking, filtros)

Los frameworks como LangChain y LlamaIndex abstraen esta complejidad, ofreciendo:

• ✅ APIs de alto nivel (menos código, más productividad)
• ✅ Integraciones pre-construidas (Qdrant, Ollama, etc.)
• ✅ Mejores prácticas implementadas (chunking óptimo, re-ranking)
• ✅ Optimizaciones de rendimiento (caché, batch processing)

Sin un framework, implementar RAG funcional puede tomar semanas. Con un framework, puedes tener un sistema básico funcionando en horas.

—

LangChain: Características y Arquitectura

Arquitectura Modular

LangChain está diseñado como un framework modular que permite construir aplicaciones complejas mediante la composición de componentes:

LangChain Components:
├── Models (LLMs, Chat Models, Embeddings)
├── Prompts (Prompt Templates, Output Parsers)
├── Chains (Sequential, Router, Custom)
├── Memory (Conversation Buffer, Summary)
├── Agents (ReAct, Plan-and-Execute)
└── Tools (Web Search, Calculator, Custom)

Esta arquitectura modular permite crear flujos de trabajo complejos combinando múltiples componentes según tus necesidades.

Características Principales

1. Modularidad y Flexibilidad

LangChain permite crear cadenas personalizadas combinando múltiples componentes. Puedes intercambiar fácilmente LLMs, vector stores y herramientas sin reescribir todo el código.

Ejemplo de flexibilidad:

# Cambiar de OpenAI a Ollama es trivial
from langchain_community.llms import Ollama
llm = Ollama(model="llama3")  # En lugar de OpenAI()

# Cambiar vector store también
from langchain_community.vectorstores import Qdrant
vector_store = Qdrant.from_documents(...)  # En lugar de Pinecone

2. Gestión de Memoria Avanzada

LangChain ofrece múltiples tipos de memoria para mantener contexto en conversaciones:

• ConversationBufferMemory: Mantiene todo el historial de conversación
• ConversationSummaryMemory: Resume conversaciones largas para evitar overflow de tokens
• ConversationBufferWindowMemory: Mantiene solo las últimas N interacciones
• EntityMemory: Recuerda entidades específicas mencionadas (personas, lugares, fechas)

Esta gestión de memoria es esencial para chatbots y aplicaciones conversacionales que requieren coherencia a lo largo de múltiples interacciones.

3. Agentes y Herramientas

LangChain permite crear agentes que pueden usar herramientas externas:

• Agentes ReAct: Razonan y actúan usando herramientas (web search, calculadoras, APIs)
• Agentes Plan-and-Execute: Planifican una secuencia de acciones antes de ejecutarlas
• Self-Ask-with-Search: Formulan sub-preguntas y buscan respuestas

Integración con más de 100 herramientas pre-construidas (APIs, bases de datos, calculadoras, etc.).

4. Integraciones Extensas

• LLMs: OpenAI, Anthropic, Cohere, Hugging Face, Ollama, LocalAI
• Vector Stores: Pinecone, Weaviate, Qdrant, ChromaDB, FAISS, Milvus
• Document Loaders: PDF, CSV, JSON, APIs, Databases, Notion, Slack

Ventajas de LangChain

✅ Flexibilidad máxima: Permite construir cualquier flujo de trabajo personalizado

✅ Gestión de contexto superior: Ideal para chatbots y aplicaciones conversacionales

✅ Ecosistema maduro: LangSmith (observabilidad), LangServe (deployment)

✅ Comunidad grande: Más de 100k estrellas en GitHub

✅ Documentación extensa: Tutoriales y ejemplos para todos los casos de uso

Desventajas de LangChain

❌ Curva de aprendizaje pronunciada: Requiere entender múltiples conceptos (chains, agents, memory)

❌ Mayor consumo de tokens: La flexibilidad puede llevar a prompts más largos

❌ Configuración compleja: Muchas opciones pueden abrumar a principiantes

❌ Overhead de rendimiento: Más capas de abstracción = más latencia

—

LlamaIndex: Características y Arquitectura

Arquitectura Centrada en Indexación

LlamaIndex se enfoca en la ingesta, indexación y recuperación eficiente de datos:

LlamaIndex Pipeline:
├── Data Connectors (LlamaHub)
│   ├── APIs, PDFs, Databases, Notion, Slack
│   └── 100+ conectores pre-construidos
├── Indexing
│   ├── Vector Store Index
│   ├── Keyword Table Index
│   ├── Tree Index
│   └── List Index
├── Query Engine
│   ├── Retrieval
│   ├── Synthesis
│   └── Response Generation
└── Storage (Persistent, Embedding)

Esta arquitectura está optimizada para tareas de recuperación de información, no para orquestación compleja.

Características Principales

1. LlamaHub – Conectores de Datos

LlamaIndex incluye LlamaHub, un ecosistema con más de 100 conectores para fuentes de datos comunes:

• APIs: REST, GraphQL, Twitter, Reddit
• Documentos: PDF, Word, Markdown, HTML
• Bases de datos: PostgreSQL-guia-completa-tutorial-2025/)-mongodb-guia-completa-tutorial-2025/), MongoDB, SQLite
• Servicios: Notion, Slack, Google Drive, Confluence

Ejemplo de uso:

from llama_index.readers import NotionPageReader

reader = NotionPageReader(integration_token="...")
documents = reader.load_data(page_ids=["page-1", "page-2"])

2. Múltiples Estrategias de Indexación

LlamaIndex ofrece diferentes métodos de indexación según el caso de uso:

• Vector Store Index: Búsqueda por similitud semántica (más común)
• Keyword Table Index: Búsqueda por palabras clave (BM25, útil para búsqueda exacta)
• Tree Index: Estructura jerárquica para documentos largos (resúmenes recursivos)
• List Index: Índice secuencial simple (para documentos pequeños)

3. Query Engines Avanzados

• Sub-Question Query Engine: Divide preguntas complejas en sub-preguntas y combina respuestas
• Multi-Document Query Engine: Consulta múltiples documentos simultáneamente
• Router Query Engine: Selecciona el mejor índice según el tipo de query
• Retriever Query Engine: Combina múltiples recuperadores (híbrido: vector + keyword)

4. Optimización de Rendimiento

• Caché de embeddings: Evita re-calcular embeddings de documentos ya indexados
• Batch processing: Procesa múltiples documentos en paralelo
• Compresión de índices: Reduce tamaño en memoria sin perder precisión
• Streaming de respuestas: Genera respuestas mientras el LLM procesa (mejor UX)

Ventajas de LlamaIndex

✅ API simple y directa: Fácil de aprender para principiantes

✅ Eficiencia en tokens: Optimizado para usar menos tokens que LangChain

✅ Recuperación rápida: Especializado en búsqueda y recuperación de información

✅ LlamaHub extenso: 100+ conectores de datos listos para usar

✅ Rendimiento superior: Más rápido en tareas de RAG puras

Desventajas de LlamaIndex

❌ Menor flexibilidad: Más opinado, menos personalizable que LangChain

❌ Contexto limitado: Capacidades básicas de memoria, no ideal para chatbots complejos

❌ Agentes limitados: Soporte básico para sistemas multi-agente

❌ Ecosistema más pequeño: Menos herramientas de observabilidad y deployment

—

Comparativa Técnica Detallada

Tabla Comparativa de Características

Performance y Latencia

Benchmarks Típicos (documentos medianos, ~1000 chunks, hardware homelab estándar):

Nota importante: Estos números varían según:

• Tamaño del corpus (número de documentos)
• Modelo LLM usado (llama3 vs mistral vs neural-chat)
• Hardware disponible (CPU vs GPU, cantidad de RAM)
• Configuración de chunking y top-k

En general, LlamaIndex es más rápido en tareas de RAG puras, mientras que LangChain ofrece más flexibilidad a costa de mayor overhead.

—

Instalación y Setup: Docker Compose para Ambos

Prerrequisitos

• Docker y Docker Compose instalados
• GPU NVIDIA (opcional pero recomendado para Ollama)
• Al menos 8GB RAM libre
• 20GB espacio en disco (para modelos Ollama)

Opción 1: LangChain con Qdrant + Ollama

Crea docker-compose.langchain.yml:

version: '3.8'

services:
  qdrant:
    image: qdrant/qdrant:latest
    container_name: qdrant-langchain
    ports:
      - "6333:6333"
      - "6334:6334"
    volumes:
      - qdrant_data:/qdrant/storage
    environment:
      - QDRANT__SERVICE__GRPC_PORT=6334
    networks:
      - rag-network

  ollama:
    image: ollama/ollama:latest
    container_name: ollama-langchain
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    networks:
      - rag-network

  langchain-app:
    build:
      context: .
      dockerfile: Dockerfile.langchain
    container_name: langchain-rag
    depends_on:
      - qdrant
      - ollama
    environment:
      - QDRANT_URL=http://qdrant:6333
      - OLLAMA_URL=http://ollama:11434
      - OLLAMA_MODEL=llama3
      - EMBEDDING_MODEL=nomic-embed-text
    volumes:
      - ./scripts:/app/scripts
      - ./data:/app/data
    networks:
      - rag-network

volumes:
  qdrant_data:
  ollama_data:

networks:
  rag-network:
    driver: bridge

Levantar servicios:

docker-compose -f docker-compose.langchain.yml up -d

# Esperar a que Ollama descargue modelos (primera vez)
docker logs -f ollama-langchain

# Descargar modelos necesarios
docker exec -it ollama-langchain ollama pull llama3
docker exec -it ollama-langchain ollama pull nomic-embed-text

Opción 2: LlamaIndex con Qdrant + Ollama

Crea docker-compose.llamaindex.yml:

version: '3.8'

services:
  qdrant:
    image: qdrant/qdrant:latest
    container_name: qdrant-llamaindex
    ports:
      - "6333:6333"
      - "6334:6334"
    volumes:
      - qdrant_data:/qdrant/storage
    environment:
      - QDRANT__SERVICE__GRPC_PORT=6334
    networks:
      - rag-network

  ollama:
    image: ollama/ollama:latest
    container_name: ollama-llamaindex
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    networks:
      - rag-network

  llamaindex-app:
    build:
      context: .
      dockerfile: Dockerfile.llamaindex
    container_name: llamaindex-rag
    depends_on:
      - qdrant
      - ollama
    environment:
      - QDRANT_URL=http://qdrant:6333
      - OLLAMA_URL=http://ollama:11434
      - OLLAMA_MODEL=llama3
      - EMBEDDING_MODEL=nomic-embed-text
    volumes:
      - ./scripts:/app/scripts
      - ./data:/app/data
      - ./storage:/app/storage
    networks:
      - rag-network

volumes:
  qdrant_data:
  ollama_data:

networks:
  rag-network:
    driver: bridge

Levantar servicios:

docker-compose -f docker-compose.llamaindex.yml up -d

# Esperar a que Ollama descargue modelos (primera vez)
docker logs -f ollama-llamaindex

# Descargar modelos necesarios
docker exec -it ollama-llamaindex ollama pull llama3
docker exec -it ollama-llamaindex ollama pull nomic-embed-text

—

Ejemplos Prácticos: RAG con Qdrant + Ollama

Ejemplo 1: LangChain RAG Básico

from langchain_community.vectorstores import Qdrant
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.llms import Ollama
from langchain.chains import RetrievalQA
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import TextLoader

# 1. Cargar y dividir documentos
loader = TextLoader("documentos.txt")
documents = loader.load()
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
chunks = text_splitter.split_documents(documents)

# 2. Crear embeddings y vector store
embeddings = OllamaEmbeddings(
    model="nomic-embed-text",
    base_url="http://localhost:11434"
)
vector_store = Qdrant.from_documents(
    chunks,
    embeddings,
    url="http://localhost:6333",
    collection_name="documentos"
)

# 3. Crear chain de RAG
llm = Ollama(
    model="llama3",
    base_url="http://localhost:11434",
    request_timeout=120.0
)
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vector_store.as_retriever(
        search_kwargs={"k": 3}  # Top 3 chunks
    )
)

# 4. Hacer query
respuesta = qa_chain.run("¿Qué es RAG?")
print(respuesta)

Ejemplo 2: LangChain con Memoria Conversacional

from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationalRetrievalChain

# Crear memoria
memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True
)

# Crear chain con memoria
conversational_chain = ConversationalRetrievalChain.from_llm(
    llm=llm,
    retriever=vector_store.as_retriever(),
    memory=memory
)

# Conversación multi-turn
respuesta1 = conversational_chain.run("¿Qué es RAG?")
respuesta2 = conversational_chain.run("¿Y cómo funciona?")  # Recuerda contexto anterior

Ejemplo 3: LlamaIndex RAG Básico

from llama_index import VectorStoreIndex, ServiceContext, StorageContext
from llama_index.vector_stores import QdrantVectorStore
from llama_index.embeddings import OllamaEmbedding
from llama_index.llms import Ollama
from llama_index.readers import SimpleDirectoryReader

# 1. Configurar LLM y embeddings
llm = Ollama(
    model="llama3",
    base_url="http://localhost:11434",
    request_timeout=120.0
)
embed_model = OllamaEmbedding(
    model_name="nomic-embed-text",
    base_url="http://localhost:11434"
)

service_context = ServiceContext.from_defaults(
    llm=llm,
    embed_model=embed_model
)

# 2. Cargar documentos
documents = SimpleDirectoryReader("data").load_data()

# 3. Crear vector store
vector_store = QdrantVectorStore(
    url="http://localhost:6333",
    collection_name="documentos"
)

storage_context = StorageContext.from_defaults(
    vector_store=vector_store
)

# 4. Crear índice
index = VectorStoreIndex.from_documents(
    documents,
    storage_context=storage_context,
    service_context=service_context
)

# 5. Crear query engine
query_engine = index.as_query_engine(
    similarity_top_k=3  # Top 3 chunks
)

# 6. Hacer query
respuesta = query_engine.query("¿Qué es RAG?")
print(respuesta)

Ejemplo 4: LlamaIndex con Sub-Question Query Engine

from llama_index.query_engine import SubQuestionQueryEngine
from llama_index.tools import QueryEngineTool

# Crear múltiples índices
index1 = VectorStoreIndex.from_documents(docs1)
index2 = VectorStoreIndex.from_documents(docs2)

# Crear query engines
query_engine1 = index1.as_query_engine()
query_engine2 = index2.as_query_engine()

# Crear herramientas
tool1 = QueryEngineTool.from_defaults(
    query_engine1,
    name="docs1"
)
tool2 = QueryEngineTool.from_defaults(
    query_engine2,
    name="docs2"
)

# Sub-question query engine divide preguntas complejas
sub_question_engine = SubQuestionQueryEngine.from_defaults(
    query_engine_tools=[tool1, tool2]
)

respuesta = sub_question_engine.query(
    "Compara las características de LangChain y LlamaIndex"
)

—

Benchmarks: Performance y Latencia

Test Setup

• Hardware: CPU Intel i7-12700K, GPU NVIDIA RTX 3090 (24GB VRAM), 32GB RAM
• Corpus: 100 documentos PDF (~50MB total, ~10,000 chunks)
• Modelo LLM: llama3 (8B parámetros)
• Embeddings: nomic-embed-text (768 dimensiones)
• Vector Store: Qdrant (local, sin replicación)

Resultados

Análisis

LlamaIndex es significativamente más rápido en tareas de RAG puras debido a:

• Menos capas de abstracción
• Optimizaciones específicas para recuperación
• Menor overhead en prompts

LangChain ofrece más flexibilidad pero a costa de:

• Mayor latencia por capas adicionales
• Más tokens por query (prompts más largos)
• Mayor uso de memoria

Recomendación: Si tu caso de uso es RAG puro (búsqueda, Q&A sobre documentos), LlamaIndex es la mejor opción. Si necesitas agentes, memoria conversacional o flujos complejos, LangChain es necesario.

—

Mejores Prácticas y Recomendaciones

Para LangChain

1. Usar ConversationBufferWindowMemory para chats largos (evita overflow de tokens)
2. Configurar retriever con search_kwargs para controlar número de chunks recuperados
3. Usar chain_type="map_reduce" para documentos muy largos (>4000 tokens)
4. Implementar caching de embeddings para reducir costos
5. Monitorear con LangSmith en producción (observabilidad)

Ejemplo de optimización:

from langchain.cache import InMemoryCache
from langchain.globals import set_llm_cache

# Cachear embeddings
set_llm_cache(InMemoryCache())

# Usar window memory para chats largos
from langchain.memory import ConversationBufferWindowMemory
memory = ConversationBufferWindowMemory(
    k=5,  # Solo últimas 5 interacciones
    return_messages=True
)

Para LlamaIndex

1. Elegir el índice correcto: Vector para búsqueda semántica, Keyword para búsqueda exacta
2. Usar ServiceContext para configurar LLM y embeddings globalmente
3. Persistir índices en disco para evitar re-indexación
4. Usar SubQuestionQueryEngine para preguntas complejas
5. Configurar similarity_top_k en query engine para balancear relevancia vs velocidad

Ejemplo de optimización:

# Persistir índice
index.storage_context.persist(persist_dir="./storage")

# Cargar índice persistido (evita re-indexación)
from llama_index import load_index_from_storage
storage_context = StorageContext.from_defaults(
    persist_dir="./storage"
)
index = load_index_from_storage(storage_context)

Cuándo Usar Cada Framework

Usa LangChain si:

• ✅ Necesitas agentes que usen herramientas externas
• ✅ Requieres memoria conversacional avanzada
• ✅ Construyes flujos de trabajo multi-paso complejos
• ✅ Necesitas integración con múltiples APIs y servicios
• ✅ Priorizas flexibilidad sobre velocidad

Usa LlamaIndex si:

• ✅ Tu caso de uso es RAG puro (búsqueda, Q&A)
• ✅ Priorizas velocidad y eficiencia
• ✅ Necesitas ingesta de múltiples fuentes de datos (LlamaHub)
• ✅ Quieres una API simple y directa
• ✅ Tienes documentos grandes que requieren indexación eficiente

Usa ambos si:

• ✅ Necesitas recuperación eficiente (LlamaIndex) + orquestación compleja (LangChain)
• ✅ Puedes combinar ambos en un pipeline híbrido

—

Troubleshooting Común

Error 1: «Connection refused» al conectar con Qdrant

Síntomas:

qdrant_client.exceptions.UnexpectedResponse: Connection refused

Solución:

# Verificar que Qdrant esté corriendo
docker ps | grep qdrant

# Si no está corriendo:
docker run -p 6333:6333 qdrant/qdrant

# En código, usar URL correcta:
vector_store = Qdrant.from_documents(
    chunks,
    embeddings,
    url="http://localhost:6333",  # URL explícita
    collection_name="documentos"
)

Error 2: «Model not found» en Ollama

Síntomas:

OllamaError: model 'llama3' not found

Solución:

# Listar modelos disponibles
ollama list

# Descargar modelo si no existe
ollama pull llama3
ollama pull nomic-embed-text

# Verificar que Ollama esté corriendo
curl http://localhost:11434/api/tags

Error 3: «Out of memory» al indexar documentos grandes

Síntomas:

RuntimeError: CUDA out of memory

Solución:

# LangChain: Procesar en batches
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,  # Chunks más pequeños
    chunk_overlap=100
)

# Procesar documentos en lotes
batch_size = 100
for i in range(0, len(chunks), batch_size):
    batch = chunks[i:i+batch_size]
    vector_store.add_documents(batch)

# LlamaIndex: Usar persistencia
index = VectorStoreIndex.from_documents(
    documents,
    persist_dir="./storage"  # Persistir en disco
)

Error 4: «Empty response» de Ollama

Síntomas:

Respuesta vacía o timeout

Solución:

# Aumentar timeout
llm = Ollama(
    model="llama3",
    request_timeout=300.0,  # 5 minutos
    temperature=0.7
)

# Verificar que Ollama responda
import requests
response = requests.get("http://localhost:11434/api/tags")
print(response.json())

Error 5: «Embedding dimension mismatch» con Qdrant

Síntomas:

qdrant_client.exceptions.ResponseHandlingException: Dimension mismatch

Solución:

# Verificar dimensión de embeddings
embeddings = OllamaEmbeddings(model="nomic-embed-text")
test_embedding = embeddings.embed_query("test")
print(f"Dimension: {len(test_embedding)}")  # Debe ser 768

# Si la colección existe con otra dimensión, crear nueva:
vector_store = Qdrant.from_documents(
    chunks,
    embeddings,
    collection_name="documentos_nuevo"  # Nombre diferente
)

—

Preguntas Frecuentes

¿Cuál framework es mejor para principiantes?

LlamaIndex es más fácil para principiantes debido a su API simple y directa. LangChain tiene una curva de aprendizaje más pronunciada porque requiere entender múltiples conceptos (chains, agents, memory).

Recomendación: Empieza con LlamaIndex si tu caso de uso es RAG puro. Si necesitas agentes o memoria conversacional, aprende LangChain.

¿Puedo usar ambos frameworks juntos?

Sí, es posible y a veces recomendable. Puedes usar LlamaIndex para indexación y recuperación eficiente, y LangChain para orquestación y memoria conversacional.

Ejemplo híbrido:

# LlamaIndex para recuperación
llamaindex_index = VectorStoreIndex.from_documents(docs)
retriever = llamaindex_index.as_retriever()

# LangChain para orquestación y memoria
from langchain.memory import ConversationBufferMemory
memory = ConversationBufferMemory()
chain = ConversationalRetrievalChain.from_llm(
    llm=llm,
    retriever=retriever,  # Usar retriever de LlamaIndex
    memory=memory
)

¿Cuál consume menos tokens?

LlamaIndex consume menos tokens (~35% menos según benchmarks) porque está optimizado para prompts más cortos. LangChain usa más tokens debido a su flexibilidad y capas adicionales.

Impacto: Si usas APIs pagas (OpenAI, Anthropic), LlamaIndex será más económico. Si usas Ollama local, la diferencia es menos relevante.

¿Cuál es más rápido?

LlamaIndex es más rápido en tareas de RAG puras:

• Indexación: ~33% más rápido
• Query latency: ~50% más rápido
• Throughput: ~78% más queries por minuto

LangChain es más lento pero ofrece más flexibilidad y funcionalidades (agentes, memoria avanzada).

¿Cuál tiene mejor soporte para producción?

LangChain tiene mejor ecosistema para producción:

• LangSmith: Observabilidad, debugging, evaluación
• LangServe: Deployment como API REST
• LangChain Templates: Plantillas pre-construidas

LlamaIndex tiene herramientas básicas pero menos maduras para producción.

Recomendación: Para producción, considera LangChain si necesitas observabilidad y deployment fácil. Si solo necesitas RAG simple, LlamaIndex es suficiente.

¿Puedo cambiar de un framework a otro fácilmente?

No es trivial, pero es posible. Los conceptos son similares (embeddings, vector stores, retrieval), pero las APIs son diferentes.

Migración típica:

1. Mantener vector store (Qdrant, Pinecone) – compatible con ambos
2. Re-escribir código de indexación y queries
3. Ajustar configuración de chunking y retrieval

Recomendación: Elige el framework correcto desde el inicio basándote en tus necesidades a largo plazo.

¿Cuál framework es mejor para documentos grandes?

LlamaIndex tiene mejor soporte para documentos grandes:

• Tree Index: Estructura jerárquica para documentos largos
• Compresión de índices: Reduce memoria sin perder precisión
• Batch processing: Procesa múltiples documentos eficientemente

LangChain puede manejar documentos grandes con chain_type="map_reduce", pero es menos eficiente.

¿Cuál tiene mejor integración con Ollama?

Ambos tienen buena integración con Ollama, pero con diferencias:

LangChain:

from langchain_community.llms import Ollama
llm = Ollama(model="llama3", base_url="http://localhost:11434")

LlamaIndex:

from llama_index.llms import Ollama
llm = Ollama(model="llama3", base_url="http://localhost:11434")

Ambos funcionan igual de bien. La diferencia está en cómo usas el LLM (chains vs query engines).

¿Cuál es mejor para chatbots?

LangChain es mejor para chatbots debido a su gestión avanzada de memoria:

• ConversationBufferMemory: Mantiene todo el historial
• ConversationSummaryMemory: Resume conversaciones largas
• EntityMemory: Recuerda entidades específicas

LlamaIndex tiene capacidades básicas de memoria, adecuadas para Q&A simple pero no para chatbots complejos.

¿Cuál framework es más activo en desarrollo?

Ambos son muy activos:

• LangChain: ~100k estrellas en GitHub, actualizaciones frecuentes
• LlamaIndex: ~30k estrellas, también muy activo

LangChain tiene una comunidad más grande y más contribuidores, pero ambos están bien mantenidos.

¿Cuál consume menos memoria RAM?

LlamaIndex consume menos memoria (~34% menos según benchmarks) debido a:

• Menos capas de abstracción
• Optimizaciones de almacenamiento
• Compresión de índices

Impacto: Si tienes hardware limitado (homelab pequeño), LlamaIndex es mejor opción.

¿Puedo usar Qdrant con ambos frameworks?

Sí, ambos soportan Qdrant:

• LangChain: langchain_community.vectorstores.Qdrant
• LlamaIndex: llama_index.vector_stores.QdrantVectorStore

Ambos funcionan igual de bien con Qdrant. Puedes incluso compartir la misma colección Qdrant entre ambos frameworks (aunque no es recomendado por diferencias en estructura de datos).

¿Cuál es mejor para integración con n8n?

LangChain tiene mejor integración con n8n debido a:

• Soporte para herramientas externas (APIs, webhooks)
• Agentes que pueden interactuar con workflows de n8n
• Integración más flexible con sistemas externos

LlamaIndex es más limitado para integraciones complejas.

¿Cuál framework tiene mejor documentación?

LangChain tiene documentación más extensa:

• Tutoriales para todos los casos de uso
• Ejemplos numerosos
• Guías de mejores prácticas

LlamaIndex tiene buena documentación pero menos ejemplos y tutoriales.

Recomendación: Ambos tienen documentación suficiente. LangChain tiene más recursos para aprender.

—

📦 Descargar Ejemplos

Todos los ejemplos de código, Docker Compose files y configuraciones están disponibles en GitHub:

🔗 Descargar Ejemplos Completos

Incluye:

• docker-compose.langchain.yml – Stack completo LangChain
• docker-compose.llamaindex.yml – Stack completo LlamaIndex
• scripts/langchain_rag_example.py – Ejemplo funcional LangChain
• scripts/llamaindex_rag_example.py – Ejemplo funcional LlamaIndex
• configs/rag_config.yaml – Configuración compartida
• README.md – Guía de uso detallada

—

Enlaces Relacionados

• Vector Databases para RAG: Qdrant vs Pinecone vs Weaviate vs ChromaDB
• Ollama muy lento: 10 trucos para acelerarlo 3X
• Open WebUI Avanzado: Personalización, Plugins e Integraciones
• Memoria de Agentes de IA: Persistencia y Contexto para Sistemas Agénticos

—

Conclusión y Próximos Pasos

LangChain y LlamaIndex son frameworks complementarios con fortalezas diferentes:

• LangChain: Ideal para aplicaciones complejas que requieren orquestación, memoria conversacional y agentes
• LlamaIndex: Ideal para sistemas RAG puros que priorizan recuperación eficiente y velocidad

La elección depende de:

1. Complejidad del flujo de trabajo: Simple RAG → LlamaIndex, Complejo → LangChain
2. Necesidad de memoria conversacional: Sí → LangChain, No → LlamaIndex
3. Prioridad en velocidad vs flexibilidad: Velocidad → LlamaIndex, Flexibilidad → LangChain
4. Experiencia del equipo: Principiantes → LlamaIndex, Experimentados → Cualquiera

Para homelabs, recomendación general:

• LlamaIndex es más adecuado para la mayoría de casos RAG simples (búsqueda interna, Q&A sobre documentos)
• LangChain es mejor para aplicaciones que requieren agentes, chatbots complejos o flujos multi-paso

Próximos pasos:

1. Descarga los ejemplos de GitHub y prueba ambos frameworks
2. Implementa un caso de uso simple con cada uno
3. Mide performance en tu hardware específico
4. Elige el framework que mejor se adapte a tus necesidades

¿Necesitas ayuda? Consulta los ejemplos en GitHub o revisa la documentación oficial de LangChain y LlamaIndex.

—

¿Te resultó útil esta guía? Comparte tus experiencias con LangChain y LlamaIndex en los comentarios o únete a nuestra comunidad Discord para discutir casos de uso específicos.