Comparación de frameworks RAG

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

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

---

Matriz rápida de decisión

	LangChain	LlamaIndex	Haystack	RAGFlow
Ideal para	Aplicaciones generales de LLM	Preguntas y respuestas sobre documentos	Búsqueda empresarial	RAG autohospedado
Curva de aprendizaje	Medio	Baja-media	Media-alta	Baja
Flexibilidad	Muy alta	Alto	Alto	Medio
Interfaz de usuario 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

---

Descripción general

LangChain

LangChain es el marco de orquestación de LLM más popular. Proporciona una interfaz unificada para cadenas, agentes, memoria y canalizaciones 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 una canalización 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 la indexación y recuperación de documentos. Sobresale al conectar los LLM con diversas fuentes de datos.

Filosofía: Indexa primero, consulta de forma inteligente.

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

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

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

Haystack

Haystack (de deepset) es un marco de NLP de nivel empresarial centrado en canalizaciones de búsqueda y preguntas y respuestas. Tiene una arquitectura basada en componentes con un constructor visual de canalizaciones.

Filosofía: Canalizaciones 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 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 requiere programación.

# RAGFlow se despliega mediante Docker Compose
# Configuración mediante la interfaz 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

Funciones principales de RAG

Función	LangChain	LlamaIndex	Haystack	RAGFlow
Compatibilidad con almacén vectorial	50+	30+	20+	Integrado
Cargadores de documentos	100+	50+	30+	Integrado
Búsqueda híbrida	✅	✅	✅	✅
Reordenamiento	✅	✅	✅	✅
Multimodal	✅	✅	Parcial	✅
Transmisión	✅	✅	✅	✅
Compatibilidad asíncrona	✅	✅	✅	✅
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 documento	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

Funciones avanzadas de RAG

Función	LangChain	LlamaIndex	Haystack	RAGFlow
Descomposición de consultas	✅	✅	✅	✅
HyDE (Embeddings hipotéticos de documentos)	✅	✅	❌	❌
Recuperación de múltiples saltos	✅	✅	Parcial	✅
Compresión contextual	✅	✅	✅	✅
Self-RAG	✅	✅	❌	❌
GraphRAG	✅	✅ (PropertyGraph)	❌	✅
Seguimiento de citas	Parcial	✅	Parcial	✅

---

Puntos de referencia de rendimiento

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

Los puntos de referencia varían significativamente según el conjunto de datos y la configuración. Estas son cifras aproximadas de evaluaciones de la comunidad.

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

Los resultados dependen en gran medida del LLM elegido, del modelo de incrustación y del tamaño de los fragmentos

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

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

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

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

Framework	P50	P99	Notas
LangChain	450 ms	1,2 s	Sin reordenamiento
LlamaIndex	400 ms	1.0s	Sin reordenamiento
Haystack	500 ms	1.5s	Con sobrecarga de la canalización
RAGFlow	600ms	2.0 s	Incluye sobrecarga de UI/API

---

LangChain: Análisis en profundidad

Fortalezas

✅ Mayor ecosistema — 50+ integraciones, comunidad masiva ✅ Agentes y herramientas — construye agentes de IA autónomos ✅ LangSmith — excelente observabilidad y depuración ✅ LCEL — Lenguaje de Expresión de LangChain para componer cadenas ✅ Sistemas de memoria — historial de conversación, memoria de entidades

Debilidades

❌ Complejidad — puede estar sobrediseñado para tareas simples ❌ Cambios disruptivos frecuentes — migraciones de v0.1 vs v0.2 vs v0.3 ❌ Dependencia pesada — gran tamaño de instalación ❌ Fugas de abstracción — a veces más difícil de depurar

Mejores casos de uso

• Canalizaciones de LLM de varios pasos 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()

# Indexa 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"
)

# Construye la 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 — ideal para indexación compleja de documentos ✅ 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 consultas enrutador — dirige de forma inteligente al índice correcto

Debilidades

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

Mejores casos de uso

• Sistemas de preguntas y respuestas sobre documentos (PDF, informes, wikis)

• Razonamiento complejo con múltiples documentos

• Construcción de grafos de conocimiento

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

Ejemplo: motor de consultas para múltiples documentos

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()

# Crea í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)

# Construye un enrutador que seleccione el índice correcto
tools = [
    QueryEngineTool.from_defaults(
        query_engine=index_reports.as_query_engine(),
        description="Informes financieros anuales y métricas del 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 los ingresos el año pasado?")

---

Haystack: Análisis en profundidad

Fortalezas

✅ Nivel empresarial — fiabilidad de producción ✅ Constructor visual de pipelines — Haystack Studio ✅ Herramienta de anotación — interfaz de etiquetado integrada ✅ NLP potente — preguntas y respuestas extractivas, resumen ✅ deepset Cloud — opción de despliegue gestionado

Debilidades

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

Mejores casos de uso

• Búsqueda y preguntas y respuestas de documentos empresariales

• Proyectos que necesitan trazabilidad de auditoría y observabilidad

• Equipos que quieren diseño visual de pipelines

• Despliegues en producción con requisitos de SLA

Ejemplo: canalización 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

# Construye una canalización 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"))

# Conecta los 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": "aprendizaje profundo"}, 
                       "embedding_retriever": {"query": "aprendizaje profundo"}})

---

RAGFlow: Análisis en profundidad

Fortalezas

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

Debilidades

❌ Menos personalizable que los marcos basados en código ❌ Alto consumo de recursos (Elasticsearch + Infinity DB) ❌ Compatibilidad limitada con LLM frente a LangChain ❌ Proyecto más reciente — comunidad más pequeña

Mejores casos de uso

• No desarrolladores que necesitan RAG sin programar

• Equipos que desean un producto completo de base de conocimiento

• Wikis empresariales internas 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 interfaz 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 canalizaciones complejas de varios pasos

• Te integras con muchos LLM y fuentes de datos diferentes

• El equipo se siente cómodo con Python

Elige LlamaIndex si:

• El caso de uso principal es preguntas y respuestas sobre documentos

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

• Necesitas grafos de conocimiento o enrutamiento multiíndice

• Quieres una ingesta de documentos de primera clase

• Construyendo sobre datos estructurados (bases de datos, API)

Elige Haystack si:

• Entorno empresarial con requisitos de cumplimiento

• Necesitas herramientas visuales para crear flujos

• Construyendo sobre Elasticsearch

• Quieres QA extractiva (no solo generativa)

• El equipo necesita observabilidad del pipeline de NLP

Elige RAGFlow si:

• Un equipo no técnico necesita RAG de autoservicio

• Quieres un producto completo, no un framework

• La implementación rápida es prioritaria sobre la personalización

• Construyendo una base de conocimiento interna

• No quieres escribir código Python

---

Ejecutándose en Clore.ai: requisitos de recursos

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

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

---

Enlaces útiles

• Documentación de LangChain

• Documentación de LlamaIndex

• Documentación de Haystack

• GitHub de RAGFlow

• Artículo de encuesta sobre RAG (arXiv)

---

Recomendación resumida

Preguntas y respuestas simples de documentos          → LlamaIndex
Agentes de IA complejos            → LangChain
Búsqueda empresarial            → Haystack
Producto RAG sin código          → RAGFlow
Máxima flexibilidad          → LangChain
Mejor comprensión de documentos  → LlamaIndex

Los cuatro frameworks son excelentes opciones — el adecuado depende de tus requisitos específicos, las habilidades de tu equipo y las limitaciones de implementación. En caso de duda, empieza con LlamaIndex para casos de uso con muchos documentos o LangChain si necesitas el ecosistema más amplio posible.

---

Recomendaciones de GPU para Clore.ai

Caso de uso	GPU recomendada	Costo estimado en Clore.ai
Desarrollo/Pruebas	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
Producción	RTX 4090 (24GB)	$0.14–0.42/gpu/hr
Gran escala	A100 80GB	bare metal

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