LangChain 框架完全指南：从入门到精通

🤖 LangChain 框架完全指南：从入门到精通

一、什么是 LangChain？

LangChain 是一个开源的 Python/JS 框架，用于开发基于大语言模型（LLM）的应用程序。它由 Harrison Chase 于 2022 年创建，现已成为构建生成式 AI 应用的事实标准工具。

核心定位：LangChain 不是 LLM 本身，而是 LLM 的"胶水"——它将模型、数据源、工具链整合成可复用、可编排的工作流。

---

二、LangChain 生态系统全景

LangChain 生态采用三层架构设计，形成完整的 AI 应用开发闭环：

┌─────────────────────────────────────────────────────────┐
│  运营层：LangSmith                                        │
│  → 生产监控、调试追踪、性能分析、A/B测试、成本优化          │
├─────────────────────────────────────────────────────────┤
│  编排层：LangGraph                                        │
│  → 复杂状态管理、多智能体协作、图结构工作流                 │
├─────────────────────────────────────────────────────────┤
│  开发层：LangChain (核心)                                  │
│  → 组件标准化、链式编排 (LCEL)、快速原型开发               │
└─────────────────────────────────────────────────────────┘

三大核心产品对比

产品	核心功能	适用场景	复杂度
LangChain	组件库 + LCEL 链式编排	简单线性工作流、快速原型	⭐⭐
LangGraph	图结构状态管理、多智能体	复杂分支逻辑、循环、人工介入	⭐⭐⭐⭐
LangSmith	全生命周期可观测性平台	生产环境监控、调试优化	⭐⭐⭐

---

三、LangChain 核心组件详解

1. Models（模型接口）

LangChain 提供统一接口，支持 100+ 种模型提供商：

from langchain_openai import ChatOpenAI, OpenAI
from langchain_anthropic import ChatAnthropic
from langchain_huggingface import HuggingFacePipeline

# 聊天模型（推荐用于对话）
chat_model = ChatOpenAI(
    model="gpt-4",
    temperature=0.7,      # 创造性 vs 确定性 (0-1)
    max_tokens=2000,      # 最大生成长度
    top_p=0.9,           # 核采样
    streaming=True        # 流式输出
)

# 传统 LLM（文本补全）
llm = OpenAI(model="gpt-3.5-turbo-instruct")

支持的提供商：OpenAI、Anthropic (Claude)、Google (Gemini)、Azure、AWS Bedrock、Hugging Face、Cohere、本地模型 (Ollama/llama.cpp) 等。

---

2. Prompts（提示词工程）

提示词模板（Prompt Templates）

from langchain_core.prompts import (
    PromptTemplate,           # 基础模板
    ChatPromptTemplate,       # 聊天消息模板
    FewShotPromptTemplate,    # 少样本学习
    SystemMessagePromptTemplate,
    HumanMessagePromptTemplate
)

# 基础模板
template = PromptTemplate.from_template(
    "将以下文本翻译成{language}：\n{text}"
)
prompt = template.invoke({"language": "中文", "text": "Hello World"})

# 聊天模板（结构化消息）
chat_template = ChatPromptTemplate.from_messages([
    ("system", "你是一位专业的{role}，擅长{skill}。"),
    ("human", "请帮我{task}"),
    ("ai", "好的，我将..."),
    ("human", "{input}")
])

管道提示词（PipelinePrompt）

组合多个模板，实现复杂提示词结构：

from langchain_core.prompts import PipelinePromptTemplate

# 分解为多个子模板
introduction_template = """你是{person}，擅长{skill}..."""
example_template = """示例：\n输入：{input}\n输出：{output}"""
start_template = """现在开始处理：\n{input}"""

full_template = """{introduction}\n\n{example}\n\n{start}"""
pipeline_prompt = PipelinePromptTemplate(
    final_prompt=PromptTemplate.from_template(full_template),
    pipeline_prompts=[
        ("introduction", PromptTemplate.from_template(introduction_template)),
        ("example", PromptTemplate.from_template(example_template)),
        ("start", PromptTemplate.from_template(start_template)),
    ]
)

---

3. Chains（链式工作流）

传统链（Legacy）

from langchain.chains import LLMChain, SimpleSequentialChain

# 简单链
chain = LLMChain(llm=llm, prompt=prompt)
result = chain.predict(input="你好")

# 顺序链（多步骤）
overall_chain = SimpleSequentialChain(chains=[chain1, chain2, chain3])

LCEL（LangChain Expression Language）⭐ 推荐

LCEL 是 LangChain 的现代编排语法，使用管道符 | 组合组件：

from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnableLambda, RunnableParallel

# 基础 LCEL 链
chain = (
    prompt 
    | chat_model 
    | StrOutputParser()
)

# 执行
result = chain.invoke({"question": "什么是量子计算？"})

# 更复杂的例子：并行处理 + 自定义函数
def count_words(text: str) -> dict:
    return {"word_count": len(text.split())}

complex_chain = (
    RunnableParallel({  # 并行执行多个分支
        "summary": prompt | chat_model | StrOutputParser(),
        "original": RunnableLambda(lambda x: x["text"])
    })
    | RunnableLambda(lambda x: f"摘要：{x['summary']}\n原文：{x['original']}")
)

LCEL 核心优势：

• 统一接口：所有组件都实现 Runnable 接口，支持 .invoke()、.batch()、.stream()
• 自动优化：并行执行独立步骤，自动批处理
• 类型安全：支持 Pydantic 模型验证
• 可观测性：自动追踪执行过程

---

4. Indexes（索引与检索）

RAG（检索增强生成）的核心组件：

from langchain_community.document_loaders import PyPDFLoader, WebBaseLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_chroma import Chroma
from langchain_core.runnables import RunnablePassthrough

# 1. 加载文档
loader = PyPDFLoader("document.pdf")
docs = loader.load()

# 2. 文本分割
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    separators=["\n\n", "\n", " ", ""]
)
splits = text_splitter.split_documents(docs)

# 3. 向量化存储
vectorstore = Chroma.from_documents(
    documents=splits,
    embedding=OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

# 4. 构建 RAG 链
template = """基于以下上下文回答问题：
{context}

问题：{question}
"""
rag_prompt = ChatPromptTemplate.from_template(template)

rag_chain = (
    {"context": retriever | (lambda docs: "\n\n".join(d.page_content for d in docs)), 
     "question": RunnablePassthrough()}
    | rag_prompt
    | chat_model
    | StrOutputParser()
)

# 使用
result = rag_chain.invoke("这份文档的主要观点是什么？")

支持的向量数据库：Chroma、Pinecone、Weaviate、Milvus、FAISS、Qdrant、PostgreSQL (pgvector) 等。

---

5. Memory（记忆管理）

解决 LLM 无状态问题，维护对话上下文：

from langchain.memory import (
    ConversationBufferMemory,           # 全量记忆
    ConversationBufferWindowMemory,     # 窗口记忆（最近k轮）
    ConversationSummaryMemory,          # 摘要记忆
    ConversationKGMemory,              # 知识图谱记忆
    VectorStoreRetrieverMemory         # 向量检索记忆
)

from langchain.chains import ConversationChain

# 基础记忆
memory = ConversationBufferMemory(
    memory_key="history",
    return_messages=True  # 返回消息对象而非字符串
)

# 带记忆的对话链
conversation = ConversationChain(
    llm=chat_model,
    memory=memory,
    verbose=True
)

# 多轮对话
conversation.predict(input="你好，我是张三")
conversation.predict(input="我叫什么名字？")  # 能记住"张三"

高级：摘要记忆（节省 Token）

summary_memory = ConversationSummaryMemory(
    llm=chat_model,  # 用于生成摘要
    max_token_limit=1000
)

# 自动将历史对话压缩为摘要，而非保留完整原文

---

6. Agents（智能代理）

赋予 LLM"决策"和"工具使用"能力：

from langchain.agents import (
    Tool, 
    AgentExecutor, 
    create_react_agent,
    create_openai_functions_agent
)
from langchain_community.tools import DuckDuckGoSearchRun, WikipediaQueryRun
from langchain import hub

# 定义工具
tools = [
    Tool(
        name="搜索",
        func=DuckDuckGoSearchRun().run,
        description="用于搜索互联网上的实时信息"
    ),
    Tool(
        name="维基百科",
        func=WikipediaQueryRun().run,
        description="用于查询百科知识"
    ),
    Tool(
        name="计算器",
        func=lambda x: eval(x),  # 简单示例，生产环境需安全沙箱
        description="用于执行数学计算"
    )
]

# 获取预定义的 ReAct 提示词模板
prompt = hub.pull("hwchase17/react")

# 创建 Agent
agent = create_react_agent(chat_model, tools, prompt)
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,           # 查看思考过程
    max_iterations=10,      # 防止无限循环
    handle_parsing_errors=True
)

# 运行（Agent 会自动决定使用哪些工具）
agent_executor.invoke({
    "input": "2024年诺贝尔物理学奖得主是谁？他出生在哪一年？"
})

Agent 执行流程：

1. 思考（Thought）：分析当前状态和任务
2. 行动（Action）：选择工具并执行
3. 观察（Observation）：获取工具返回结果
4. 循环：直到得出最终答案

---

四、LangGraph：复杂工作流编排

当应用需要循环、条件分支、人工介入时，使用 LangGraph：

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

# 定义状态结构
class AgentState(TypedDict):
    messages: Annotated[list, operator.add]  # 自动累加
    next_step: str
    iteration_count: int

# 定义节点函数
def retrieve(state: AgentState):
    # 检索逻辑
    return {"messages": ["检索结果..."], "iteration_count": state.get("iteration_count", 0) + 1}

def generate(state: AgentState):
    # 生成逻辑
    return {"messages": ["生成内容..."], "next_step": "end"}

def should_continue(state: AgentState) -> str:
    # 路由逻辑
    if state["iteration_count"] > 3:
        return "end"
    return "continue"

# 构建图
workflow = StateGraph(AgentState)

# 添加节点
workflow.add_node("retrieve", retrieve)
workflow.add_node("generate", generate)

# 添加边（普通边和条件边）
workflow.set_entry_point("retrieve")
workflow.add_edge("retrieve", "generate")
workflow.add_conditional_edges(
    "generate",
    should_continue,
    {
        "continue": "retrieve",  # 循环回检索
        "end": END              # 结束
    }
)

# 编译执行
app = workflow.compile()
result = app.invoke({"messages": [], "iteration_count": 0})

LangGraph 核心特性：

• 持久化状态：支持检查点（checkpoint），可暂停/恢复
• 人工介入：在关键节点等待人工审核
• 多智能体：多个 Agent 协作，通过图结构通信

---

五、LangSmith：生产级可观测性

import os
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "ls-xxxx"
os.environ["LANGCHAIN_PROJECT"] = "my-project"

# 自动追踪所有链的执行
# 在 LangSmith 平台查看：
# - 完整的调用链（Trace）
# - Token 消耗和成本
# - 延迟分析
# - 输入输出对比
# - 数据集评估

---

六、技术选型决策树

开始项目评估
│
是否需要复杂状态管理？（循环/条件分支/人工介入）
├─────┴─────┐
否           是
│           │
使用 LangChain    是否需要生产监控？
（LCEL 编排）    ├─────┴─────┐
│           否           是
│           │           │
│     LangChain+LangGraph  完整生态（+LangSmith）
│
└─ 简单 RAG/聊天/单步任务

性能对比参考

指标	LangChain	LangGraph	LangSmith
简单查询延迟	800ms-1.2s	1.2s-1.8s	<50ms 开销
复杂查询延迟	2-5s（串行）	1.5-3s（并行优势）	监控无影响
并发用户支持	<50	100-500	纯监控层
内存管理	线性增长	优化管理	20-50MB

---

七、完整实战示例：智能客服系统

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_chroma import Chroma
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnableParallel, RunnablePassthrough
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain.tools import tool
import os

# 初始化
os.environ["OPENAI_API_KEY"] = "sk-xxx"
llm = ChatOpenAI(model="gpt-4o")

# 1. RAG 知识库
vectorstore = Chroma.from_texts(
    texts=["产品A价格：100元", "产品B价格：200元", "退换货政策：7天无理由"],
    embedding=OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever()

# 2. 自定义工具
@tool
def check_order_status(order_id: str) -> str:
    """查询订单状态"""
    # 实际应查询数据库
    return f"订单 {order_id} 已发货，预计明天送达"

@tool
def transfer_to_human() -> str:
    """转接人工客服"""
    return "正在为您转接人工客服，请稍候..."

# 3. Agent 提示词
prompt = ChatPromptTemplate.from_messages([
    ("system", """你是智能客服助手。按以下规则处理：
    1. 先检索知识库回答产品问题
    2. 订单查询使用 check_order_status 工具
    3. 投诉或复杂问题转人工
    当前对话历史：{history}"""),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}")
])

# 4. 构建 Agent
tools = [check_order_status, transfer_to_human]
agent = create_openai_tools_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 5. 带记忆的封装
from langchain.memory import ConversationBufferMemory
memory = ConversationBufferMemory(return_messages=True)

def chat(input_text: str):
    history = memory.load_memory_variables({})["history"]
    result = agent_executor.invoke({
        "input": input_text,
        "history": history
    })
    memory.save_context({"input": input_text}, {"output": result["output"]})
    return result["output"]

# 测试
print(chat("产品A多少钱？"))
print(chat("我订单 12345 的状态？"))
print(chat("我要投诉！"))

---

八、学习资源推荐

1. 官方文档：python.langchain.com/docs/introd…
2. LangChain Academy（免费课程）：academy.langchain.com/
3. GitHub 示例：github.com/langchain-a…
4. 生态工具：
   • LangServe：将链部署为 REST API
   • LangGraph Platform：托管 LangGraph 应用
   • LangSmith：调试与监控平台

---

总结

LangChain 通过组件化设计和分层架构，解决了 LLM 应用开发中的核心痛点：

痛点	LangChain 解决方案
模型切换成本高	统一接口，一行代码切换提供商
提示词管理混乱	PromptTemplate + 版本控制
上下文长度限制	Memory 模块自动管理
幻觉问题	RAG 检索增强 + 工具调用
复杂流程难编排	LCEL / LangGraph 灵活编排
生产环境难监控	LangSmith 全链路追踪

最佳实践建议：

• 简单应用：直接使用 LCEL（prompt | llm | parser）
• 复杂状态：升级到 LangGraph（图结构 + 持久化）
• 生产部署：接入 LangSmith（监控 + 评估 + 优化）