LangChain 与 LlamaIndex 框架选型与协同实战

一、两个框架，两种哲学

在大模型应用开发领域，LangChain和LlamaIndex是两个绕不开的框架。很多初学者会问："我应该学哪个？"但这个问题本身就错了——它们不是竞争关系，而是互补关系。

用一个比喻来理解：

如果你要开一家餐厅，LangChain就像一个全能的厨房管理系统——它帮你设计菜品的制作流程（调用链）、协调不同厨师（工具）、管理食材储备（记忆），整个烹饪流程由它来编排。

而LlamaIndex更像一个专业的食材供应链系统——它专注于帮你把各种原材料（数据）清洗、分类、存储，并在需要时快速精准地找到你要的食材（检索）。

一个管流程，一个管数据。两者结合，才能构建完整的大模型应用。

二、LangChain 深度解析

2.1 核心设计理念

LangChain的核心理念是"链式编排"——将LLM、Prompt、工具、记忆、外部数据源等各种组件像乐高积木一样组合在一起，构建复杂的LLM应用流程。

它的设计原则包括：

• 模块化设计：每个功能独立封装，可插拔替换
• 链式组合：通过管道式连接实现复杂逻辑
• 工具优先：将外部能力（API、数据库、函数）工具化
• 标准化接口：统一输入输出格式，降低集成成本

2.2 核心组件

Chain（链）：LangChain最基本的抽象，将多个组件串联起来。

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-5", temperature=0.7)

prompt = PromptTemplate(
    input_variables=["topic"],
    template="请用三句话总结{topic}的核心概念。"
)

chain = LLMChain(llm=llm, prompt=prompt)
result = chain.invoke({"topic": "量子计算"})

Tool（工具）：Agent可调用的外部能力。

from langchain.tools import Tool

def search_knowledge_base(query: str) -> str:
    """在知识库中搜索"""
    results = vector_store.similarity_search(query, k=5)
    return "\n".join([doc.page_content for doc in results])

search_tool = Tool(
    name="search_knowledge_base",
    func=search_knowledge_base,
    description="在内部知识库中搜索相关信息。输入搜索关键词，返回相关文档内容。"
)

Memory（记忆）：让应用维持对话状态。

from langchain.memory import ConversationBufferMemory, ConversationSummaryMemory

# 缓冲区记忆：保留最近N轮对话
buffer_memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True,
    max_token_limit=2000
)

# 摘要记忆：自动压缩历史对话
summary_memory = ConversationSummaryMemory(
    llm=llm,
    memory_key="chat_history",
    return_messages=True
)

Agent（智能体）：自主决策和执行任务。

from langchain.agents import create_react_agent, AgentExecutor

agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    memory=memory,
    max_iterations=10,
    verbose=True
)

result = agent_executor.invoke({
    "input": "帮我查找关于微服务的文档，并总结关键点"
})

2.3 LangGraph：状态图工作流

LangGraph是LangChain生态中的进阶框架，专门处理有状态、可循环的复杂流程：

from langgraph.graph import StateGraph, END
from typing import TypedDict

class GraphState(TypedDict):
    query: str
    search_results: list
    analysis: str
    final_answer: str

def search(state: GraphState) -> GraphState:
    results = search_tool(state["query"])
    return {"search_results": results}

def analyze(state: GraphState) -> GraphState:
    analysis = llm.invoke(f"分析以下内容：{state['search_results']}")
    return {"analysis": analysis}

def generate_answer(state: GraphState) -> GraphState:
    answer = llm.invoke(f"基于分析生成回答：{state['analysis']}")
    return {"final_answer": answer}

workflow = StateGraph(GraphState)
workflow.add_node("search", search)
workflow.add_node("analyze", analyze)
workflow.add_node("generate", generate_answer)

workflow.set_entry_point("search")
workflow.add_edge("search", "analyze")
workflow.add_edge("analyze", "generate")
workflow.add_edge("generate", END)

app = workflow.compile()

三、LlamaIndex 深度解析

3.1 核心设计理念

LlamaIndex的核心理念是"数据优先"——一切围绕如何高效组织、索引和检索数据。它的设计原则包括：

• 以数据为中心：专注于构建外部知识到LLM的桥梁
• 检索优化导向：强调召回率和准确率的平衡
• 查询模式多样化：支持语义检索、关键词检索、混合检索
• 轻量级封装：对LLM保持透明，不强制绑定特定模型

3.2 核心组件

Document（文档）：数据的基本单元。

from llama_index.core import Document

doc = Document(
    text="这是一段文档内容...",
    metadata={
        "source": "技术文档",
        "author": "张三",
        "date": "2026-07-01"
    }
)

Index（索引）：数据的组织结构。

from llama_index.core import VectorStoreIndex, SummaryIndex

# 向量索引：适合语义搜索
vector_index = VectorStoreIndex.from_documents(documents)

# 摘要索引：适合生成文档摘要
summary_index = SummaryIndex.from_documents(documents)

QueryEngine（查询引擎）：统一的查询接口。

# 基础查询
query_engine = vector_index.as_query_engine()
response = query_engine.query("什么是RAG？")

# 带自定义Prompt的查询
from llama_index.core.prompts import PromptTemplate

qa_prompt = PromptTemplate(
    "基于以下上下文回答问题：\n"
    "上下文：{context_str}\n"
    "问题：{query_str}\n"
    "回答："
)

query_engine = vector_index.as_query_engine(
    text_qa_template=qa_prompt,
    similarity_top_k=5
)

Router（路由器）：根据查询类型自动选择处理引擎。

from llama_index.core.tools import QueryEngineTool, ToolMetadata
from llama_index.core.selectors import LLMSingleSelector

# 定义多个查询引擎
vector_tool = QueryEngineTool(
    query_engine=vector_index.as_query_engine(),
    metadata=ToolMetadata(
        name="vector_search",
        description="用于语义搜索和概念性问题"
    )
)

summary_tool = QueryEngineTool(
    query_engine=summary_index.as_query_engine(),
    metadata=ToolMetadata(
        name="summary_search",
        description="用于生成文档摘要和概述"
    )
)

# 创建路由器
from llama_index.core.router import RouterQueryEngine
router = RouterQueryEngine(
    selector=LLMSingleSelector.from_defaults(),
    query_engine_tools=[vector_tool, summary_tool]
)

3.3 高级检索策略

递归检索：先检索大纲，再定位具体内容。

from llama_index.core.node_parser import HierarchicalNodeParser

# 层级解析
parser = HierarchicalNodeParser.from_defaults(
    chunk_sizes=[2048, 512, 128]  # 大→中→小
)
nodes = parser.get_nodes_from_documents(documents)

# 构建层级索引
from llama_index.core import StorageContext
storage_context = StorageContext.from_defaults()
storage_context.docstore.add_documents(nodes)

混合检索：结合语义和关键词。

from llama_index.core.retrievers import VectorIndexRetriever, BM25Retriever

# 语义检索器
vector_retriever = VectorIndexRetriever(
    index=vector_index,
    similarity_top_k=10
)

# 关键词检索器
bm25_retriever = BM25Retriever.from_defaults(
    nodes=nodes,
    similarity_top_k=10
)

# 混合检索（RRF融合）
from llama_index.core.retrievers import QueryFusionRetriever
fusion_retriever = QueryFusionRetriever(
    retrievers=[vector_retriever, bm25_retriever],
    similarity_top_k=5,
    mode="reciprocal_rerank"  # RRF融合算法
)

四、LangChain vs LlamaIndex：场景化选型

4.1 什么时候用 LangChain

• 复杂Agent流程：需要多步骤推理、工具调用、条件分支
• 多模型编排：需要同时使用多个LLM，或动态切换模型
• 对话系统：需要复杂的对话管理和记忆机制
• 工作流自动化：需要定义和执行复杂的业务流程

4.2 什么时候用 LlamaIndex

• 知识库问答：基于私有文档的问答系统
• 数据检索增强：需要高效、精准的数据检索
• 文档分析：需要对大量文档进行索引和分析
• 结构化数据查询：需要对结构化/半结构化数据进行自然语言查询

4.3 两者结合使用

在实际项目中，LangChain和LlamaIndex经常一起使用：

# LlamaIndex负责数据层
from llama_index.core import VectorStoreIndex
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine()

# LangChain负责编排层
from langchain.tools import Tool
from langchain.agents import create_react_agent, AgentExecutor

# 将LlamaIndex查询引擎包装为LangChain工具
def query_knowledge_base(query: str) -> str:
    response = query_engine.query(query)
    return str(response)

kb_tool = Tool(
    name="knowledge_base",
    func=query_knowledge_base,
    description="查询内部知识库，输入问题，返回答案"
)

# 在LangChain Agent中使用
agent = create_react_agent(llm, [kb_tool, other_tools], prompt)

这种组合模式充分发挥了两个框架的优势：LlamaIndex处理数据索引和检索，LangChain处理流程编排和工具集成。

五、框架生态与未来趋势

5.1 当前生态格局

2026年的大模型框架生态已经形成了清晰的分工：

数据层（LlamaIndex）
    ↓ 提供检索能力
编排层（LangChain / LangGraph）
    ↓ 提供流程控制
推理层（vLLM / TensorRT-LLM）
    ↓ 提供模型服务
应用层（自定义业务逻辑）

5.2 框架融合趋势

LangChain和LlamaIndex正在相互渗透：

• LangChain增强了数据处理能力（VectorStore、Document Loaders）
• LlamaIndex增强了Agent能力（ReAct Agent、OpenAI Agent）
• 两者都在向"全栈框架"演进

5.3 新兴框架

除了LangChain和LlamaIndex，还有一些值得关注的新兴框架：

• DSPy：声明式编程框架，自动优化Prompt
• CrewAI：专注于多Agent协作的框架
• AutoGen：微软的多Agent对话框架
• Semantic Kernel：微软的轻量级AI编排SDK

六、实战建议

6.1 学习路径

1. 先学LlamaIndex：从构建一个简单的知识库问答系统开始，理解RAG的基本原理
2. 再学LangChain：掌握Chain、Tool、Memory、Agent等核心概念
3. 最后学LangGraph：处理复杂的多步骤工作流

6.2 项目实践

• 入门项目：用LlamaIndex构建个人知识库问答
• 进阶项目：用LangChain构建多工具Agent
• 高级项目：用LangGraph构建多Agent协作系统

6.3 常见陷阱

• 过度抽象：不要为了用框架而用框架，简单场景直接用API
• 版本兼容：LangChain和LlamaIndex的API变化较快，注意版本锁定
• 性能开销：框架的抽象层会带来性能开销，生产环境需要评估

七、总结

LangChain和LlamaIndex不是竞争对手，而是大模型应用开发的两个互补维度。LangChain解决"如何编排流程"的问题，LlamaIndex解决"如何接入数据"的问题。

在实际项目中，最佳实践是将两者结合使用：LlamaIndex负责数据层，LangChain负责编排层。这种组合能够覆盖从数据接入到业务落地的完整技术闭环。

选择框架时，不要被"哪个更好"的问题困扰。应该问自己："我的项目需要什么能力？"然后选择最适合的框架组合。