# RAG 框架对比

在 Clore.ai GPU 服务器上为您的项目选择合适的检索增强生成（RAG）框架。

{% hint style="info" %}
**RAG（检索增强生成）** 让大模型使用您自己的文档来回答问题。本指南比较四个领先框架：LangChain、LlamaIndex、Haystack 和 RAGFlow——涵盖特性、性能以及何时使用每个框架。
{% endhint %}

***

## 快速决策矩阵

|               | LangChain | LlamaIndex | Haystack   | RAGFlow    |
| ------------- | --------- | ---------- | ---------- | ---------- |
| **适用场景**      | 通用大模型应用   | 文档问答       | 企业搜索       | 自托管 RAG    |
| **学习曲线**      | 高细节       | 低-中等       | 中等-高       | 低          |
| **灵活性**       | 非常高       | 高          | 高          | 高细节        |
| **内置 UI**     | 否         | 否          | 否          | 是          |
| **GitHub 星标** | 90K+      | 35K+       | 15K+       | 12K+       |
| **语言**        | Python    | Python     | Python     | Python     |
| **许可**        | MIT       | MIT        | Apache 2.0 | Apache 2.0 |

***

## 概览

### LangChain

LangChain 是最流行的大模型编排框架。它为 chains、agents、memory 和 RAG 管道提供统一接口。

**理念**：一切都是可组合组件的链。

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

# 用 5 行构建 RAG 管道
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("法国的首都是哪里？")
```

### LlamaIndex

LlamaIndex（前称 GPT Index）专为文档索引与检索而构建。它擅长将大模型连接到各种数据源。

**理念**：先建立索引，然后智能查询。

```python
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

# 加载并索引文档
documents = SimpleDirectoryReader("data/").load_data()
index = VectorStoreIndex.from_documents(documents)

# 查询
query_engine = index.as_query_engine()
response = query_engine.query("总结主要发现")
print(response)
```

### Haystack

Haystack（由 deepset 开发）是面向企业的 NLP 框架，专注于搜索和问答管道。它具有基于组件的架构和可视化管道构建器。

**理念**：具有企业可靠性的模块化管道。

```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="什么是机器学习？", params={"Retriever": {"top_k": 10}})
```

### RAGFlow

RAGFlow 是一个开源 RAG 引擎，带有内置 Web UI、文档解析和知识库管理。它被设计为可作为完整解决方案部署。

**理念**：开箱即用的 RAG 系统，无需编码。

```yaml
# RAGFlow 通过 Docker Compose 部署
# 在 localhost:80 的 Web UI 中进行配置
version: "3"
services:
  ragflow:
    image: infiniflow/ragflow:latest
    ports:
      - "80:80"
    volumes:
      - ./ragflow-data:/ragflow/data
```

***

## 功能比较

### 核心 RAG 功能

| 功能         | LangChain | LlamaIndex | Haystack | RAGFlow |
| ---------- | --------- | ---------- | -------- | ------- |
| 向量存储支持     | 50+       | 30+        | 20+      | 内置      |
| 文档加载器      | 100+      | 50+        | 30+      | 内置      |
| 混合检索       | ✅         | ✅          | ✅        | ✅       |
| 重排序        | ✅         | ✅          | ✅        | ✅       |
| 多模态        | ✅         | ✅          | 部分支持     | ✅       |
| 流式传输       | ✅         | ✅          | ✅        | ✅       |
| 异步支持       | ✅         | ✅          | ✅        | ✅       |
| Agents（代理） | ✅         | ✅          | ✅        | ❌       |

### 集成生态

| 集成类型   | LangChain                                 | LlamaIndex                         | Haystack                         | RAGFlow               |
| ------ | ----------------------------------------- | ---------------------------------- | -------------------------------- | --------------------- |
| 大模型提供商 | 50+                                       | 30+                                | 20+                              | 10+                   |
| 向量数据库  | Chroma、Pinecone、Weaviate、Qdrant、以及 40+ 其他 | Chroma、Pinecone、Weaviate、以及 25+ 其他 | Weaviate、Elasticsearch、以及 15+ 其他 | 内置 InfiniFlow         |
| 文档类型   | PDF、网页、CSV、JSON、以及 80+                    | PDF、网页、CSV、数据库、以及 40+              | PDF、TXT、HTML、以及 20+              | PDF、Word、Excel、PPT、网页 |
| 云存储    | S3、GCS、Azure                              | S3、GCS、Azure                       | S3、GCS                           | S3                    |

### 高级 RAG 功能

| 功能               | LangChain | LlamaIndex | Haystack | RAGFlow |
| ---------------- | --------- | ---------- | -------- | ------- |
| 查询分解             | ✅         | ✅          | ✅        | ✅       |
| HyDE（假设性文档嵌入）    | ✅         | ✅          | ❌        | ❌       |
| 多跳检索             | ✅         | ✅          | 部分支持     | ✅       |
| 上下文压缩            | ✅         | ✅          | ✅        | ✅       |
| 自我 RAG（Self-RAG） | ✅         | ✅          | ❌        | ❌       |
| GraphRAG（图形 RAG） | ✅         | ✅（属性图）     | ❌        | ✅       |
| 引用追踪             | 部分支持      | ✅          | 部分支持     | ✅       |

***

## 性能基准

### 检索准确性（RAG-Bench，2024）

{% hint style="info" %}
基准在不同数据集和配置间差异很大。以下为来自社区基准的大致数值。
{% endhint %}

| 框架              | HotpotQA（F1） | Natural Questions（EM） | TriviaQA（准确率） |
| --------------- | ------------ | --------------------- | ------------- |
| LangChain（RAG）  | \~68%        | \~42%                 | \~72%         |
| LlamaIndex（RAG） | \~71%        | \~45%                 | \~74%         |
| Haystack（RAG）   | \~69%        | \~43%                 | \~71%         |
| RAGFlow（默认）     | \~65%        | \~40%                 | \~68%         |

*结果在很大程度上取决于所选的大模型、嵌入模型和分块大小*

### 索引速度（10K 文档，每个约 1KB）

| 框架         | 仅 CPU  | GPU 嵌入 |
| ---------- | ------ | ------ |
| LangChain  | 〜120 秒 | 〜18 秒  |
| LlamaIndex | 〜110 秒 | 〜15 秒  |
| Haystack   | 〜130 秒 | 〜20 秒  |
| RAGFlow    | 〜150 秒 | 〜25 秒  |

*采用与 text-embedding-ada-002 等效（1536 维）*

### 查询延迟（P50/P99，使用预构建索引）

| 框架         | P50    | P99   | 说明           |
| ---------- | ------ | ----- | ------------ |
| LangChain  | 450 毫秒 | 1.2 秒 | 无重排序         |
| LlamaIndex | 400 毫秒 | 1.0 秒 | 无重排序         |
| Haystack   | 500 毫秒 | 1.5 秒 | 包含管道开销       |
| RAGFlow    | 600 毫秒 | 2.0 秒 | 包含 UI/API 开销 |

***

## LangChain：深入解析

### 优势

✅ **最大的生态系统** — 50+ 集成，庞大的社区\
✅ **代理与工具** — 构建自主 AI 代理\
✅ **LangSmith** — 出色的可观测性和调试功能\
✅ **LCEL** — 用于组合 chains 的 LangChain 表达式语言\
✅ **记忆系统** — 会话历史、实体记忆

### 弱点

❌ **复杂性** — 对于简单任务可能过度设计\
❌ **频繁的破坏性变更** — v0.1 对比 v0.2 对比 v0.3 的迁移\
❌ **依赖繁重** — 安装体积大\
❌ **抽象泄露** — 有时更难调试

### 最佳使用场景

* 具有复杂逻辑的多步大模型管道
* 使用工具（网页搜索、代码执行、API）的 AI 代理
* 需要会话记忆的应用
* 需要最大灵活性的项目

### 示例：带来源的高级 RAG

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

# 设置
llm = ChatOpenAI(model="gpt-4", temperature=0)
embeddings = OpenAIEmbeddings()

# 使用元数据为文档建立索引
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = splitter.split_documents(documents)

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

# 构建带来源归属的链
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": "主要风险是什么？"})
print(result["answer"])
print("来源：", result["sources"])
```

***

## LlamaIndex：深入解析

### 优势

✅ **以文档为先的设计** — 最适合复杂文档索引\
✅ **索引类型** — 向量、知识图、SQL、关键词\
✅ **子问题引擎** — 自动分解复杂查询\
✅ **结构化输出** — Pydantic 集成\
✅ **路由查询引擎** — 智能地路由到正确的索引

### 弱点

❌ **较少聚焦代理** 相比 LangChain\
❌ **生态较小** 相比 LangChain\
❌ **文档** 可能不够一致

### 最佳使用场景

* 文档问答系统（PDF、报告、维基）
* 复杂的多文档推理
* 知识图构建
* 数据到大模型的桥接（数据库、API）

### 示例：多文档查询引擎

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

# 全局配置
Settings.llm = OpenAI(model="gpt-4")
Settings.embed_model = OpenAIEmbedding()

# 为不同的文档集合创建单独的索引
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)

# 构建路由器以选择正确的索引
tools = [
    QueryEngineTool.from_defaults(
        query_engine=index_reports.as_query_engine(),
        description="年度财务报告和业务指标"
    ),
    QueryEngineTool.from_defaults(
        query_engine=index_tech.as_query_engine(),
        description="技术文档和 API 参考"
    )
]

router = RouterQueryEngine.from_defaults(query_engine_tools=tools)
response = router.query("What was the revenue growth last year?")
```

***

## Haystack：深入解析

### 优势

✅ **企业级** — 生产可靠性\
✅ **可视化管道构建器** — Haystack Studio\
✅ **标注工具** — 内置标注界面\
✅ **强大的 NLP** — 抽取式问答、摘要\
✅ **deepset 云** — 托管部署选项

### 弱点

❌ **学习曲线比竞争对手更陡峭** ❌ **社区规模较小** 相比 LangChain/LlamaIndex\
❌ **灵活性较低** 用于新颖架构时

### 最佳使用场景

* 企业文档搜索与问答
* 需要审计记录与可观测性的项目
* 希望可视化管道设计的团队
* 具有 SLA 要求的生产部署

### 示例：混合搜索管道

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

# 构建混合搜索管道
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"))

# 连接组件
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：深入解析

### 优势

✅ **零代码部署** — 包含完整 UI\
✅ **高级文档解析** — 表格、图像、图表\
✅ **知识库管理** — 可视化界面\
✅ **包含 API** — 开箱即用的 REST API\
✅ **具代理能力的 RAG** — 内置代理

### 弱点

❌ **可定制性较低** 相比以代码为先的框架\
❌ **资源需求高** (Elasticsearch + Infinity DB)\
❌ **有限的 LLM 支持** 与 LangChain 相比\
❌ **较新的项目** — 社区较小

### 最佳使用场景

* 非开发人员需要无代码 RAG
* 希望一个完整知识库产品的团队
* 企业内部维基和文档搜索
* RAG 应用的快速原型开发

### 在 Clore.ai 上部署

```yaml
# RAGFlow 的 docker-compose.yml
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
# 在 http://<server-ip>:80 访问 Web 界面
```

***

## 何时使用哪个

### 如果符合以下情况请选择 LangChain：

* 构建带有工具的 AI 代理（网页搜索、代码执行、API）
* 需要最大的生态系统灵活性
* 构建复杂的多步骤管道
* 与多种不同的 LLM 和数据源集成
* 团队熟悉使用 Python

### 如果符合以下情况请选择 LlamaIndex：

* 主要用例是文档问答
* 处理复杂文档结构（表格、嵌套内容）
* 需要知识图谱或多索引路由
* 希望获得一流的文档摄取能力
* 在结构化数据（数据库、API）之上构建

### 如果符合以下情况请选择 Haystack：

* 具有合规性要求的企业环境
* 需要可视化管道构建工具
* 基于 Elasticsearch 构建
* 需要抽取式（不仅仅是生成式）问答
* 团队需要 NLP 管道的可观测性

### 如果符合以下情况请选择 RAGFlow：

* 非技术团队需要自助式 RAG
* 想要一个完整的产品，而不是一个框架
* 快速部署优先于可定制性
* 构建内部知识库
* 不想编写 Python 代码

***

## 在 Clore.ai 上运行：资源需求

| 框架         | 最小内存      | 最低显存        | 开发/测试        |
| ---------- | --------- | ----------- | ------------ |
| LangChain  | 8GB       | 8GB（本地 LLM） | RTX 3080     |
| LlamaIndex | 8GB       | 8GB（本地 LLM） | RTX 3080     |
| Haystack   | 16GB      | 8GB（本地 LLM） | RTX 3090     |
| RAGFlow    | 32GB（内存！） | 16GB        | A6000 / A100 |

{% hint style="warning" %}
**RAGFlow 需要更多内存**：它运行 Elasticsearch + InfinityDB + 应用本身。请计划至少 32GB 系统内存。使用 Elasticsearch 的 Haystack 也受益于 16GB+ 内存。
{% endhint %}

***

## 有用的链接

* [LangChain 文档](https://python.langchain.com)
* [LlamaIndex 文档](https://docs.llamaindex.ai)
* [Haystack 文档](https://docs.haystack.deepset.ai)
* [RAGFlow GitHub](https://github.com/infiniflow/ragflow)
* [RAG 调查论文（arxiv）](https://arxiv.org/abs/2312.10997)

***

## 总结建议

```
简单的文档问答          → LlamaIndex
复杂的 AI 代理            → LangChain
企业搜索                → Haystack
无代码 RAG 产品          → RAGFlow
最大灵活性              → LangChain
最佳的文档理解          → LlamaIndex
```

这四个框架都是出色的选择——合适的框架取决于您的具体需求、团队技能和部署限制。如有疑问，可从 **LlamaIndex** 用于文档密集型用例或 **LangChain** 如果您需要尽可能广泛的生态系统。

***

## Clore.ai 的 GPU 建议

| 在 Clore.ai 上的预估费用 | 开发/测试             | RTX 3090（24GB） |
| ----------------- | ----------------- | -------------- |
| \~$0.12/每 GPU/每小时 | 生产                | RTX 4090（24GB） |
| \~$0.70/每 GPU/每小时 | 大规模               | A100 80GB      |
| \~$1.20/每 GPU/每小时 | 💡 本指南中的所有示例均可部署在 | Clore.ai       |

> GPU 服务器上。浏览可用 GPU 并按小时租用 — 无需承诺，提供完整的 root 访问权限。 [Clore.ai](https://clore.ai/marketplace) GPU 服务器。浏览可用 GPU 并按小时租用 — 无需承诺，提供完整的 root 访问权限。


---

# 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-zh/dui-bi/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.