> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/comparaciones/rag-frameworks-comparison.md).

# 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.

{% hint style="info" %}
**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.
{% endhint %}

***

## 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.

```python
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.

```python
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.

```python
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.

```yaml
# 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)

{% hint style="info" %}
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.
{% endhint %}

| 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

```python
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

```python
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

```python
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

```yaml
# 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:
```

```bash
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    |

{% hint style="warning" %}
**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.
{% endhint %}

***

## Enlaces útiles

* [Documentación de LangChain](https://python.langchain.com)
* [Documentación de LlamaIndex](https://docs.llamaindex.ai)
* [Documentación de Haystack](https://docs.haystack.deepset.ai)
* [GitHub de RAGFlow](https://github.com/infiniflow/ragflow)
* [Artículo de encuesta sobre RAG (arXiv)](https://arxiv.org/abs/2312.10997)

***

## 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](https://clore.ai/bare-metal) |

> 💡 Todos los ejemplos de esta guía pueden desplegarse en [Clore.ai](https://clore.ai/marketplace) servidores GPU. Explora las GPUs disponibles y alquila por hora: sin compromisos, acceso root completo.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/comparaciones/rag-frameworks-comparison.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.