Comparación de frameworks RAG

Elige el marco de Generación Aumentada por Recuperación (RAG) adecuado para tu proyecto en los servidores GPU de Clore.ai.

RAG (Generación Aumentada por Recuperación) permite a los LLM responder preguntas usando tus propios documentos. Esta guía compara los cuatro marcos principales: LangChain, LlamaIndex, Haystack y RAGFlow — cubriendo características, rendimiento y cuándo usar cada uno.

---

Matriz de decisión rápida

	LangChain	LlamaIndex	Haystack	RAGFlow
Mejor para	Aplicaciones generales de LLM	Preguntas y respuestas sobre documentos	Búsqueda empresarial	RAG autoalojado
Curva de aprendizaje	Medio	Baja-Media	Media-Alta	Bajo
Flexibilidad	Muy alta	Alta	Alta	Medio
Interfaz integrada	No	No	No	Sí
Estrellas en GitHub	90K+	35K+	15K+	12K+
Idioma	Python	Python	Python	Python
Licencia	MIT	MIT	Apache 2.0	Apache 2.0

---

Resumen

LangChain

LangChain es el marco de orquestación de LLM más popular. Proporciona una interfaz unificada para cadenas, agentes, memoria y pipelines RAG.

Filosofía: Todo es una cadena de componentes componibles.

from langchain.chains import RetrievalQA
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
from langchain.llms import OpenAI

# Construye un pipeline RAG en 5 líneas
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(docs, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
chain = RetrievalQA.from_chain_type(llm=OpenAI(), retriever=retriever)
result = chain.run("¿Cuál es la capital de Francia?")

LlamaIndex

LlamaIndex (anteriormente GPT Index) está diseñado específicamente para indexación y recuperación de documentos. Sobresale en conectar LLM con diversas fuentes de datos.

Filosofía: Indexar primero, consultar inteligentemente.

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

# Cargar e indexar documentos
documents = SimpleDirectoryReader("data/").load_data()
index = VectorStoreIndex.from_documents(documents)

# Consulta
query_engine = index.as_query_engine()
response = query_engine.query("Resume los hallazgos principales")
print(response)

Haystack

Haystack (de deepset) es un marco NLP de nivel empresarial centrado en pipelines de búsqueda y Q&A. Tiene una arquitectura basada en componentes con constructor visual de pipelines.

Filosofía: Pipelines modulares con fiabilidad empresarial.

from haystack.nodes import DensePassageRetriever, FARMReader
from haystack.pipelines import ExtractiveQAPipeline

retriever = DensePassageRetriever(document_store=document_store)
reader = FARMReader(model_name_or_path="deepset/roberta-base-squad2")
pipeline = ExtractiveQAPipeline(reader, retriever)
result = pipeline.run(query="¿Qué es el aprendizaje automático?", params={"Retriever": {"top_k": 10}})

RAGFlow

RAGFlow es un motor RAG de código abierto con una interfaz web integrada, análisis de documentos y gestión de bases de conocimiento. Está diseñado para desplegarse como una solución completa.

Filosofía: Sistema RAG listo para usar, no se requiere programación.

# RAGFlow se despliega mediante Docker Compose
# Configuración vía UI web en localhost:80
version: "3"
services:
  ragflow:
    image: infiniflow/ragflow:latest
    ports:
      - "80:80"
    volumes:
      - ./ragflow-data:/ragflow/data

---

Comparación de características

Características principales de RAG

Característica	LangChain	LlamaIndex	Haystack	RAGFlow
Soporte de almacén vectorial	50+	30+	20+	Integrado
Cargadores de documentos	100+	50+	30+	Integrado
Búsqueda híbrida	✅	✅	✅	✅
Re-ordenación	✅	✅	✅	✅
Multimodal	✅	✅	Parcial	✅
Streaming	✅	✅	✅	✅
Soporte asíncrono	✅	✅	✅	✅
Agentes	✅	✅	✅	❌

Ecosistema de integraciones

Tipo de integración	LangChain	LlamaIndex	Haystack	RAGFlow
Proveedores de LLM	50+	30+	20+	10+
Bases de datos vectoriales	Chroma, Pinecone, Weaviate, Qdrant, 40+ más	Chroma, Pinecone, Weaviate, 25+ más	Weaviate, Elasticsearch, 15+ más	InfiniFlow integrado
Tipos de documentos	PDF, Web, CSV, JSON, 80+	PDF, Web, CSV, DB, 40+	PDF, TXT, HTML, 20+	PDF, Word, Excel, PPT, Web
Almacenamiento en la nube	S3, GCS, Azure	S3, GCS, Azure	S3, GCS	S3

Características avanzadas de RAG

Característica	LangChain	LlamaIndex	Haystack	RAGFlow
Descomposición de consultas	✅	✅	✅	✅
HyDE (Embeddings de Documentos Hipotéticos)	✅	✅	❌	❌
Recuperación multi-hop	✅	✅	Parcial	✅
Compresión contextual	✅	✅	✅	✅
Self-RAG	✅	✅	❌	❌
GraphRAG	✅	✅ (PropertyGraph)	❌	✅
Seguimiento de citas	Parcial	✅	Parcial	✅

---

Benchmarks de rendimiento

Precisión de recuperación (RAG-Bench, 2024)

Los benchmarks varían significativamente según el conjunto de datos y la configuración. Estas son cifras aproximadas de benchmarks comunitarios.

Framework	HotpotQA (F1)	Natural Questions (EM)	TriviaQA (Acc)
LangChain (RAG)	~68%	~42%	~72%
LlamaIndex (RAG)	~71%	~45%	~74%
Haystack (RAG)	~69%	~43%	~71%
RAGFlow (por defecto)	~65%	~40%	~68%

Los resultados dependen en gran medida del LLM elegido, el modelo de embeddings y el tamaño de los fragmentos

Velocidad de indexación (10K documentos, ~1KB cada uno)

Framework	Solo CPU	Embeddings en GPU
LangChain	~120 seg	~18 seg
LlamaIndex	~110 seg	~15 seg
Haystack	~130 seg	~20 seg
RAGFlow	~150 seg	~25 seg

Con equivalente a text-embedding-ada-002 (1536 dims)

Latencia de consulta (P50/P99, con índice preconstruido)

Framework	P50	P99	Notas
LangChain	450ms	1.2s	Sin re-ordenación
LlamaIndex	400ms	1.0s	Sin re-ordenación
Haystack	500ms	1.5s	Con sobrecarga de pipeline
RAGFlow	600ms	2.0s	Incluye sobrecarga de UI/API

---

LangChain: Análisis en profundidad

Fortalezas

✅ Ecosistema más grande — 50+ integraciones, comunidad masiva ✅ Agentes y herramientas — construir agentes de IA autónomos ✅ LangSmith — excelente observabilidad y depuración ✅ LCEL — LangChain Expression Language para componer cadenas ✅ Sistemas de memoria — historial de conversaciones, memoria de entidades

Debilidades

❌ Complejidad — puede sobreingenierizarse para tareas simples ❌ Cambios frecuentes que rompen compatibilidad — migraciones v0.1 vs v0.2 vs v0.3 ❌ Dependencia pesada — gran tamaño de instalación ❌ Fuga de abstracción — a veces más difícil de depurar

Mejores casos de uso

• Pipelines de LLM multi-paso con lógica compleja

• Agentes de IA que usan herramientas (búsqueda web, ejecución de código, APIs)

• Aplicaciones que necesitan memoria de conversación

• Proyectos que necesitan máxima flexibilidad

Ejemplo: RAG avanzado con fuentes

from langchain.chains import RetrievalQAWithSourcesChain
from langchain_community.vectorstores import Chroma
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter

# Configuración
llm = ChatOpenAI(model="gpt-4", temperature=0)
embeddings = OpenAIEmbeddings()

# Indexar documentos con metadatos
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = splitter.split_documents(documents)

vectorstore = Chroma.from_documents(
    chunks, 
    embeddings,
    persist_directory="./chroma_db"
)

# Construir cadena con atribución de fuentes
chain = RetrievalQAWithSourcesChain.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 5}),
    return_source_documents=True
)

result = chain({"question": "¿Cuáles son los principales riesgos?"})
print(result["answer"])
print("Fuentes:", result["sources"])

---

LlamaIndex: Análisis en profundidad

Fortalezas

✅ Diseño centrado en documentos — mejor para indexación de documentos complejos ✅ Tipos de índice — Vector, Grafo de Conocimiento, SQL, Palabra clave ✅ Motor de subpreguntas — descompone automáticamente consultas complejas ✅ Salidas estructuradas — integración con Pydantic ✅ Motor de consulta enrutador — enruta inteligentemente al índice correcto

Debilidades

❌ Menos enfocado en agentes que LangChain ❌ Ecosistema más pequeño que LangChain ❌ Documentación puede ser inconsistente

Mejores casos de uso

• Sistemas de Q&A sobre documentos (PDFs, informes, wikis)

• Razonamiento complejo entre múltiples documentos

• Construcción de grafos de conocimiento

• Puentes de datos a LLM (bases de datos, APIs)

Ejemplo: Motor de consulta multi-documento

from llama_index.core import (
    VectorStoreIndex, 
    SimpleDirectoryReader,
    StorageContext,
    Settings
)
from llama_index.core.query_engine import RouterQueryEngine
from llama_index.core.tools import QueryEngineTool
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding

# Configurar globalmente
Settings.llm = OpenAI(model="gpt-4")
Settings.embed_model = OpenAIEmbedding()

# Crear índices separados para diferentes conjuntos de documentos
annual_reports = SimpleDirectoryReader("./annual_reports").load_data()
tech_docs = SimpleDirectoryReader("./tech_docs").load_data()

index_reports = VectorStoreIndex.from_documents(annual_reports)
index_tech = VectorStoreIndex.from_documents(tech_docs)

# Construir enrutador que seleccione el índice correcto
tools = [
    QueryEngineTool.from_defaults(
        query_engine=index_reports.as_query_engine(),
        description="Informes financieros anuales y métricas de negocio"
    ),
    QueryEngineTool.from_defaults(
        query_engine=index_tech.as_query_engine(),
        description="Documentación técnica y referencias de API"
    )
]

router = RouterQueryEngine.from_defaults(query_engine_tools=tools)
response = router.query("¿Cuál fue el crecimiento de ingresos el año pasado?")

---

Haystack: Análisis en profundidad

Fortalezas

✅ De nivel empresarial — fiabilidad para producción ✅ Constructor visual de pipelines — Haystack Studio ✅ Herramienta de anotación — UI de etiquetado integrada ✅ Fuerte en NLP — QA extractivo, resumen ✅ deepset Cloud — opción de despliegue gestionado

Debilidades

❌ Curva de aprendizaje más pronunciada que los competidores ❌ Comunidad más pequeña que LangChain/LlamaIndex ❌ Menos flexible para arquitecturas novedosas

Mejores casos de uso

• Búsqueda empresarial de documentos y Q&A

• Proyectos que necesitan registros de auditoría y observabilidad

• Equipos que desean diseño visual de pipelines

• Despliegues de producción con requisitos de SLA

Ejemplo: Pipeline de búsqueda híbrida

from haystack import Pipeline
from haystack.components.retrievers import InMemoryBM25Retriever, InMemoryEmbeddingRetriever
from haystack.components.joiners import DocumentJoiner
from haystack.components.rankers import MetaFieldRanker
from haystack.components.generators import OpenAIGenerator
from haystack.components.builders import RAGPromptBuilder

# Construir pipeline de búsqueda híbrida
pipeline = Pipeline()
pipeline.add_component("bm25_retriever", InMemoryBM25Retriever(document_store=store, top_k=10))
pipeline.add_component("embedding_retriever", InMemoryEmbeddingRetriever(document_store=store, top_k=10))
pipeline.add_component("joiner", DocumentJoiner(join_mode="reciprocal_rank_fusion"))
pipeline.add_component("ranker", MetaFieldRanker(meta_field="score"))
pipeline.add_component("prompt_builder", RAGPromptBuilder())
pipeline.add_component("llm", OpenAIGenerator(model="gpt-4"))

# Conectar componentes
pipeline.connect("bm25_retriever", "joiner.documents")
pipeline.connect("embedding_retriever", "joiner.documents")
pipeline.connect("joiner", "ranker")
pipeline.connect("ranker", "prompt_builder.documents")
pipeline.connect("prompt_builder", "llm")

result = pipeline.run({"bm25_retriever": {"query": "deep learning"}, 
                       "embedding_retriever": {"query": "deep learning"}})

---

RAGFlow: Análisis en profundidad

Fortalezas

✅ Despliegue sin código — UI completa incluida ✅ Análisis avanzado de documentos — tablas, imágenes, gráficos ✅ Gestión de base de conocimiento — interfaz visual ✅ API incluida — API REST lista para usar ✅ RAG agentivo — agentes integrados

Debilidades

❌ Menos personalizable que los marcos centrados en código ❌ Requisitos de recursos altos (Elasticsearch + Infinity DB) ❌ Soporte limitado de LLM vs LangChain ❌ Proyecto más reciente — comunidad más pequeña

Mejores casos de uso

• No desarrolladores que necesitan RAG sin codificar

• Equipos que quieren un producto completo de base de conocimiento

• Wikis internas empresariales y búsqueda de documentación

• Prototipado rápido de aplicaciones RAG

Despliegue en Clore.ai

# docker-compose.yml para RAGFlow
version: "3"
services:
  ragflow:
    image: infiniflow/ragflow:v0.12.0
    container_name: ragflow
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./ragflow-logs:/ragflow/logs
      - ./ragflow-data:/ragflow/data
    depends_on:
      - elasticsearch
      - infinity

  elasticsearch:
    image: elasticsearch:8.11.3
    environment:
      - discovery.type=single-node
      - ES_JAVA_OPTS=-Xms1g -Xmx1g
      - xpack.security.enabled=false
    volumes:
      - es_data:/usr/share/elasticsearch/data

  infinity:
    image: infiniflow/infinity:v0.3.0
    volumes:
      - infinity_data:/var/infinity

volumes:
  es_data:
  infinity_data:

docker compose up -d
# Accede a la UI web en http://<server-ip>:80

---

Cuándo usar cada uno

Elige LangChain si:

• Construyes agentes de IA con herramientas (búsqueda web, ejecución de código, APIs)

• Necesitas la máxima flexibilidad del ecosistema

• Construyes pipelines complejos de múltiples pasos

• Integración con muchos LLM y fuentes de datos diferentes

• El equipo está cómodo con Python

Elige LlamaIndex si:

• El caso de uso principal es Q&A sobre documentos

• Trabajas con estructuras de documentos complejas (tablas, contenido anidado)

• Necesitas grafos de conocimiento o enrutamiento multi-índice

• Quieres la mejor ingesta de documentos

• Construyes sobre datos estructurados (bases de datos, APIs)

Elige Haystack si:

• Entorno empresarial con requisitos de cumplimiento

• Necesitas herramientas visuales para construir pipelines

• Construyes sobre Elasticsearch

• Quieres QA extractivo (no solo generativo)

• El equipo necesita observabilidad del pipeline NLP

Elige RAGFlow si:

• Un equipo no técnico necesita RAG de autoservicio

• Quieres un producto completo, no un framework

• El despliegue rápido es prioridad sobre la personalización

• Construyendo una base de conocimiento interna

• No quieres escribir código Python

---

Ejecución en Clore.ai: Requisitos de recursos

Framework	RAM mínima	VRAM mínima	GPU recomendada
LangChain	8GB	8GB (LLM local)	RTX 3080
LlamaIndex	8GB	8GB (LLM local)	RTX 3080
Haystack	16GB	8GB (LLM local)	RTX 3090
RAGFlow	32GB (¡RAM!)	16GB	A6000 / A100

RAGFlow necesita más RAM: Ejecuta Elasticsearch + InfinityDB + la propia aplicación. Planea al menos 32GB de RAM del sistema. Haystack con Elasticsearch también se beneficia de 16GB+ de RAM.

---

Enlaces útiles

• Documentación de LangChain

• Documentación de LlamaIndex

• Documentación de Haystack

• RAGFlow en GitHub

• Artículo de encuesta sobre RAG (arxiv)

---

Recomendación resumida

Q&A simple sobre documentos → LlamaIndex
Agentes de IA complejos → LangChain
Búsqueda empresarial → Haystack
Producto RAG sin código → RAGFlow
Flexibilidad máxima → LangChain
Mejor entendimiento de documentos → LlamaIndex

Los cuatro marcos son excelentes opciones — el correcto depende de tus requisitos específicos, habilidades del equipo y restricciones de despliegue. En caso de duda, comienza con LlamaIndex para casos de uso centrados en documentos o LangChain si necesitas el ecosistema más amplio posible.

---

Recomendaciones de GPU en Clore.ai

Caso de uso	GPU recomendada	Coste estimado en Clore.ai
Desarrollo/Pruebas	RTX 3090 (24GB)	~$0.12/gpu/hr
Producción	RTX 4090 (24GB)	~$0.70/gpu/hr
Gran escala	A100 80GB	~$1.20/gpu/hr

💡 Todos los ejemplos en esta guía pueden desplegarse en Clore.ai servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo.