RAG框架对比：LangChain vs LlamaIndex vs Haystack

原创灵阙教研团队

A 推荐进阶 | 约 7 分钟阅读更新于 2026-02-28

AI 导读

RAG框架对比：LangChain vs LlamaIndex vs Haystack 三大 RAG 框架的架构设计、检索策略、生产化能力与社区生态对比 | 2026-02 一、RAG 框架的定位 RAG（Retrieval Augmented Generation）已成为大模型应用的标准范式。三大框架各有侧重：LangChain 定位为通用 LLM 编排框架，LlamaIndex...

RAG框架对比：LangChain vs LlamaIndex vs Haystack

三大 RAG 框架的架构设计、检索策略、生产化能力与社区生态对比 | 2026-02

一、RAG 框架的定位

RAG（Retrieval Augmented Generation）已成为大模型应用的标准范式。三大框架各有侧重：LangChain 定位为通用 LLM 编排框架，LlamaIndex 专注于数据连接与检索，Haystack 以搜索工程为根基。

本文从架构设计、检索策略、Chunking、评估体系、生产就绪度五个维度做深度对比。

二、架构设计

2.1 基础信息

维度	LangChain	LlamaIndex	Haystack
公司	LangChain Inc.	LlamaIndex Inc.	deepset
语言	Python / TypeScript	Python / TypeScript	Python
开源协议	MIT	MIT	Apache 2.0
GitHub Stars	100K+	40K+	18K+
核心定位	LLM 编排框架	数据框架	搜索/NLP 流水线
设计哲学	万物皆 Chain/Agent	万物皆 Index/Query	万物皆 Pipeline/Component

2.2 架构理念对比

LangChain Architecture:
  LCEL (LangChain Expression Language)
     |
  Prompt -> Model -> OutputParser
     |          |
  Retriever  Tools/Functions
     |
  VectorStore / BM25 / Multi-query

LlamaIndex Architecture:
  Documents -> Nodes -> Index -> Query Engine
     |            |         |          |
  Readers    Parsers   Embeddings  Response Synthesizer
     |                     |
  150+ data    Vector / Summary / Knowledge Graph
  connectors

Haystack Architecture:
  Pipeline = Component Graph (DAG)
     |
  Component -> Component -> Component
     |            |            |
  Retriever   Ranker      Generator
     |            |
  DocumentStore  Cross-encoder

2.3 核心抽象对比

抽象概念	LangChain	LlamaIndex	Haystack
最小执行单元	Runnable (LCEL)	QueryEngine	Component
流水线	Chain / RunnableSequence	QueryPipeline	Pipeline (DAG)
文档	Document	Document / Node	Document
检索器	Retriever	Retriever / Index	Retriever
生成器	ChatModel / LLM	LLM / ResponseSynth	Generator
记忆	Memory / History	ChatMemory	ChatMessageStore
Agent	Agent / AgentExecutor	Agent	Agent

三、数据处理与 Chunking

3.1 数据连接器

数据源	LangChain	LlamaIndex	Haystack
PDF	PyPDFLoader + 10种	SimpleDirectory + 插件	PDFToTextConverter
Web 页面	WebBaseLoader	BeautifulSoupReader	HTMLToDocument
数据库	SQLDatabase	DatabaseReader	社区组件
API	APIChain	自定义 Reader	自定义 Component
S3/GCS	S3Loader	S3Reader	社区组件
Notion	NotionDBLoader	NotionPageReader	社区组件
Confluence	ConfluenceLoader	插件	社区组件
总数	~80 种	~150 种（LlamaHub）	~40 种

3.2 Chunking 策略

# LangChain: Rich text splitter ecosystem
from langchain_text_splitters import (
    RecursiveCharacterTextSplitter,
    MarkdownHeaderTextSplitter,
    HTMLSectionSplitter,
    SemanticChunker,
)

# Basic recursive splitting (most common)
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    separators=["\n\n", "\n", ". ", " ", ""],
)

# Semantic chunking (embedding-based boundary detection)
from langchain_openai import OpenAIEmbeddings
semantic_splitter = SemanticChunker(
    embeddings=OpenAIEmbeddings(),
    breakpoint_threshold_type="percentile",
    breakpoint_threshold_amount=95,
)
chunks = semantic_splitter.split_text(long_document)

# LlamaIndex: Node-based parsing with metadata preservation
from llama_index.core.node_parser import (
    SentenceSplitter,
    SemanticSplitterNodeParser,
    HierarchicalNodeParser,
    MarkdownNodeParser,
)
from llama_index.core import Document

# Hierarchical chunking (parent-child relationships)
parser = HierarchicalNodeParser.from_defaults(
    chunk_sizes=[2048, 512, 128],  # Large -> Medium -> Small
)
nodes = parser.get_nodes_from_documents([Document(text=content)])
# Each node knows its parent and children -> enables auto-merging retrieval

3.3 Chunking 策略对比

策略	LangChain	LlamaIndex	Haystack
固定大小	RecursiveCharText	SentenceSplitter	DocumentSplitter
语义切分	SemanticChunker	SemanticSplitter	社区
层级切分	否	HierarchicalParser	否
Markdown 感知	MarkdownHeaderSplitter	MarkdownParser	MarkdownConverter
HTML 感知	HTMLSectionSplitter	HTMLNodeParser	HTMLConverter
代码感知	Language(code)	CodeSplitter	否
自动合并	否	AutoMergingRetriever	否

四、检索策略

4.1 检索方法支持

检索方法	LangChain	LlamaIndex	Haystack
向量搜索	是	是	是
BM25	是（BM25Retriever）	是	是（原生强项）
混合搜索	EnsembleRetriever	内置	内置
Multi-query	MultiQueryRetriever	是	否
HyDE	是	是	社区
Parent-Document	ParentDocRetriever	AutoMerging	否
Contextual Compression	是	是	是（Ranker）
Self-Query	SelfQueryRetriever	否	否
Recursive	否	RecursiveRetriever	否
Knowledge Graph	GraphRetriever	KGIndex	否
Reranking	是（Cohere/BGE）	是	是（Cross-encoder）

4.2 高级 RAG 实现对比

# LangChain: Multi-query + Rerank pipeline
from langchain.retrievers import MultiQueryRetriever, ContextualCompressionRetriever
from langchain.retrievers.document_compressors import CrossEncoderReranker
from langchain_community.cross_encoders import HuggingFaceCrossEncoder

# Step 1: Multi-query generates 3 variations of the question
multi_retriever = MultiQueryRetriever.from_llm(
    retriever=vectorstore.as_retriever(search_kwargs={"k": 20}),
    llm=llm,
)

# Step 2: Rerank with cross-encoder
reranker = CrossEncoderReranker(
    model=HuggingFaceCrossEncoder(model_name="BAAI/bge-reranker-v2-m3"),
    top_n=5,
)
compression_retriever = ContextualCompressionRetriever(
    base_compressor=reranker,
    base_retriever=multi_retriever,
)

# Step 3: Generate
docs = compression_retriever.invoke("What is the refund policy?")

# LlamaIndex: Auto-merging retrieval (hierarchical)
from llama_index.core import VectorStoreIndex, StorageContext
from llama_index.core.node_parser import HierarchicalNodeParser, get_leaf_nodes
from llama_index.core.retrievers import AutoMergingRetriever
from llama_index.core.query_engine import RetrieverQueryEngine

# Build hierarchical nodes
parser = HierarchicalNodeParser.from_defaults(chunk_sizes=[2048, 512, 128])
nodes = parser.get_nodes_from_documents(documents)

# Index only leaf nodes, but store all
leaf_nodes = get_leaf_nodes(nodes)
storage_context = StorageContext.from_defaults()
storage_context.docstore.add_documents(nodes)

index = VectorStoreIndex(leaf_nodes, storage_context=storage_context)

# Auto-merging retriever: if enough leaf nodes from same parent match,
# automatically merges up to parent node for better context
retriever = AutoMergingRetriever(
    index.as_retriever(similarity_top_k=12),
    storage_context,
    simple_ratio_thresh=0.4,  # Merge if 40%+ children match
)
query_engine = RetrieverQueryEngine.from_args(retriever)

五、评估体系

5.1 内置评估能力

维度	LangChain	LlamaIndex	Haystack
评估框架	LangSmith Evals	内置 Evaluator	Haystack Eval
忠实度	是（FaithfulnessEval）	FaithfulnessEvaluator	是
相关性	是（RelevanceEval）	RelevancyEvaluator	是
回答正确性	是	CorrectnessEvaluator	是
检索质量	MRR/MAP	HitRate/MRR	MRR/MAP/NDCG
LLM 评判	是	是	是
人工标注	LangSmith UI	否	否
RAGAS 集成	是	是	是

5.2 评估代码对比

# LlamaIndex built-in evaluation
from llama_index.core.evaluation import (
    FaithfulnessEvaluator,
    RelevancyEvaluator,
    BatchEvalRunner,
)

faithfulness = FaithfulnessEvaluator(llm=eval_llm)
relevancy = RelevancyEvaluator(llm=eval_llm)

runner = BatchEvalRunner(
    {"faithfulness": faithfulness, "relevancy": relevancy},
    workers=4,
)

eval_results = await runner.aevaluate_queries(
    query_engine,
    queries=test_queries,
    reference=ground_truth,
)

# Output: per-query scores + aggregate metrics
for query, results in eval_results.items():
    print(f"Q: {query}")
    print(f"  Faithfulness: {results['faithfulness'].score}")
    print(f"  Relevancy: {results['relevancy'].score}")

六、生产就绪度

6.1 生产化特性对比

特性	LangChain	LlamaIndex	Haystack
流式输出	是（LCEL原生）	是	是
异步支持	是（完整）	是（完整）	是
并发控制	是（RateLimiter）	是	是
重试机制	是（内置）	是	是
缓存	是（多种后端）	是	否
可观测性	LangSmith / Callbacks	Callbacks	Pipeline logs
部署方式	LangServe / API	FastAPI 示例	Hayhooks
Docker	官方支持	社区	官方支持
Kubernetes	LangServe + Helm	社区	deepset Cloud

6.2 错误处理与回退

能力	LangChain	LlamaIndex	Haystack
Fallback 链	with_fallbacks()	否	否
重试策略	with_retry()	否	组件级
超时控制	是	是	是
速率限制	InMemoryRateLimiter	否	否
错误回调	on_chain_error	on_event	否

# LangChain: Production-grade error handling
from langchain_core.runnables import RunnableWithFallbacks

# Primary model with fallback
primary = ChatOpenAI(model="gpt-4o", request_timeout=30)
fallback = ChatAnthropic(model="claude-sonnet-4-20250514", request_timeout=30)

robust_llm = primary.with_fallbacks([fallback])

# Add retry and rate limiting
from langchain_core.rate_limiters import InMemoryRateLimiter

rate_limiter = InMemoryRateLimiter(
    requests_per_second=10,
    check_every_n_seconds=0.1,
    max_bucket_size=20,
)

production_llm = robust_llm.with_retry(
    stop_after_attempt=3,
    wait_exponential_jitter=True,
).bind(rate_limiter=rate_limiter)

七、社区与生态

7.1 生态规模

维度	LangChain	LlamaIndex	Haystack
GitHub Stars	100K+	40K+	18K+
月活贡献者	200+	80+	30+
NPM/PyPI 下载量	5M+/月	1.5M+/月	300K+/月
Discord 成员	30K+	10K+	3K+
集成数量	800+	300+	100+
教程/博客	极多	多	中等

7.2 学习曲线

Learning Curve (Time to Production)

Complexity
    |
    |         LangChain
    |        /
    |       /    LlamaIndex
    |      /    /
    |     /    /     Haystack
    |    /    /     /
    |   /    /     /
    |  /    /     /
    | /    /     /
    |/    /     /
    +----/-----/-------> Time
    PoC      Production

Notes:
- LangChain: Fast PoC due to many examples, but complexity ramps up
- LlamaIndex: Moderate start, cleaner path to production
- Haystack: Steeper start (pipeline thinking), but predictable scaling

八、选型决策

8.1 按场景推荐

场景	首选	理由
通用 LLM 应用	LangChain	最大生态，最多集成
纯 RAG 系统	LlamaIndex	专注数据检索，策略丰富
企业搜索	Haystack	搜索工程基因，BM25 原生强
快速 PoC	LangChain	示例最多，上手最快
复杂数据管道	LlamaIndex	150+ 连接器，层级解析
Agent 系统	LangChain (LangGraph)	Agent 生态最完整
生产稳定性	LangChain / Haystack	错误处理和部署最成熟

8.2 综合评分

维度（权重）	LangChain	LlamaIndex	Haystack
检索策略丰富度（25%）	9.0	9.5	7.5
生产就绪度（25%）	9.0	7.5	8.5
开发者体验（20%）	8.5	8.5	7.0
生态/社区（15%）	9.5	8.0	6.5
数据连接能力（15%）	8.0	9.5	6.5
加权总分	8.8	8.6	7.3

九、混合使用策略

在生产实践中，不必拘泥于单一框架。常见的混合策略：

LlamaIndex 管数据 + LangChain 管编排：用 LlamaIndex 的 Reader/Parser 做数据处理，导出为 LangChain Document，在 LangChain 中做 Agent 和工作流编排
LangChain 做原型 + Haystack 做生产：用 LangChain 快速验证 RAG 方案，然后用 Haystack 的 Pipeline 重写核心检索链路
框架无关的向量层：直接使用向量数据库 SDK（Qdrant/Milvus），在上层选择轻量编排

核心原则：框架是手段，不是目的。当框架的抽象成为负担时，直接用底层 SDK。

Maurice | maurice_wen@proton.me