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

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

***

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

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

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

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

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

{% hint style="info" %}
Los benchmarks varían significativamente según el conjunto de datos y la configuración. Estas son cifras aproximadas de benchmarks comunitarios.
{% endhint %}

| 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

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

# 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

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

# 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

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

# 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

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

{% hint style="warning" %}
**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.
{% 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)
* [RAGFlow en GitHub](https://github.com/infiniflow/ragflow)
* [Artículo de encuesta sobre RAG (arxiv)](https://arxiv.org/abs/2312.10997)

***

## 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](https://clore.ai/marketplace) servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo.


---

# Agent Instructions: 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:

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

The question should be specific, self-contained, and written in natural language.
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.