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

九、混合使用策略

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

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

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

Maurice | [email protected]