# 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 访问权限。