LangChain 1.0 核心概念

一、LangChain 概述

LangChain 是一个用于开发大语言模型（LLM）驱动应用程序的框架，它通过将 LLM 与外部数据源、工具和环境连接起来，构建端到端的应用程序。其主要特性有以下：

组件化架构：提供可组合的模块
链式调用：将多个组件串联成工作流
代理系统：让 LLM 自主决策和调用工具
记忆管理：维护对话和上下文状态
检索增强：集成外部知识库

二、LangChain 1.0 核心定位与重大革新

2.1 核心定位

LangChain 1.0 的核心定位是"以智能体（Agent）为中心的生产级大模型应用开发框架"，核心价值在于解决大模型的三大核心痛点，实现"模型+工具+数据+流程"的高效协同：

打破"信息孤岛"：通过检索模块连接私有数据、互联网信息等外部资源，弥补大模型知识库滞后、领域性不足的问题；
补齐"行动能力缺失"：通过工具调用机制，让大模型能够执行数据库操作、代码运行、邮件发送等实际业务任务；
解决"上下文断裂"：通过记忆模块保存对话历史和任务中间状态，支持复杂多轮交互和长期任务的连贯执行。

2.2 三大核心革新（区别于旧版本）

2.2.1 编程范式与架构重构（旧版：组件并列串联 → 新版：Agent为核心）

核心差异：旧版需手动定义、串联所有组件；新版仅需围绕Agent构建，组件直接适配，框架自动处理协同逻辑，大幅减少冗余代码。

旧版本示例（LangChain 0.1.x 版本）：Chain、Agent、Retriever 三者并列，需手动串联逻辑，代码冗余、耦合度高，且需单独维护各组件关联关系。

python 复制代码

# 旧版本（0.1.x）：组件并列，手动串联
from langchain.agents import create_react_agent, AgentExecutor
from langchain import hub
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langchain.vectorstores import FAISS
from langchain_core.documents import Document
from langchain_openai import OpenAIEmbeddings

# 1. 手动定义Retriever（外部知识库）
documents = [Document(page_content="2025年Q4销售额1280万元")]
embeddings = OpenAIEmbeddings(api_key="你的API密钥")
vector_store = FAISS.from_documents(documents, embeddings)
retriever = vector_store.as_retriever()

# 2. 手动定义Tool（工具）
@tool
def query_sales(quarter: str):
    return "2025年Q4销售额1280万元"
tools = [query_sales]

# 3. 手动定义Chain（文本处理流程）
from langchain.chains import RetrievalQA
chain = RetrievalQA.from_chain_type(
    llm=ChatOpenAI(api_key="你的API密钥"),
    chain_type="stuff",
    retriever=retriever
)

# 4. 手动定义Agent（智能体），并串联Chain和Tool
prompt = hub.pull("hwchase17/react")  # 必须手动拉取提示词
agent = create_react_agent(ChatOpenAI(api_key="你的API密钥"), tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools)

# 5. 手动串联Agent和Chain，完成任务（冗余：需手动判断何时调用Chain/Agent）
chain_result = chain.invoke({"query": "2025年Q4销售额"})
agent_result = agent_executor.invoke({"input": "2025年Q4销售额"})

1.0版本示例：Agent为唯一核心，Retriever、Tool 直接传入Agent，无需手动串联，框架自动维护组件协同，代码简洁、耦合度低。

python 复制代码

# 1.0版本：Agent为核心，组件直接适配，无需手动串联
from langchain_core.agents import create_agent, AgentExecutor
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langchain.vectorstores import FAISS
from langchain_core.documents import Document
from langchain_openai import OpenAIEmbeddings

# 1. 定义Retriever（直接供Agent调用，无需单独串联）
documents = [Document(page_content="2025年Q4销售额1280万元")]
embeddings = OpenAIEmbeddings(api_key="你的API密钥")
vector_store = FAISS.from_documents(documents, embeddings)
retriever = vector_store.as_retriever()

# 2. 定义Tool（直接供Agent调用）
@tool
def query_sales(quarter: str):
    return "2025年Q4销售额1280万元"
tools = [query_sales]

# 3. 仅需创建Agent，传入所有组件，框架自动协同（无需手动串联Chain）
agent = create_agent(
    model=ChatOpenAI(api_key="你的API密钥"),
    tools=tools,
    retriever=retriever,  # 直接传入Retriever，Agent自主判断是否调用
    system_prompt="仅用提供的工具/检索结果回答，不编造信息"
)
agent_executor = AgentExecutor(agent=agent, tools=tools)

# 4. 直接调用Agent，完成所有任务（无需区分Chain/Agent调用场景）
result = agent_executor.invoke({"input": "2025年Q4销售额"})

2.2.2 统一Agent构建入口（旧版：多入口、需手动配模板 → 新版：create_agent() 统一入口）

核心差异：旧版多入口、需手动拉取/适配提示词模板；新版统一入口，仅需简单配置system_prompt，学习成本和配置成本大幅降低。

旧版本示例（LangChain 0.1.x 版本）：构建Agent需根据场景选择不同入口（如create_react_agent、create_self_ask_with_search_agent），且必须手动从LangChain Hub拉取提示词模板，配置繁琐。

python 复制代码

# 旧版本（0.1.x）：多入口、手动配模板，学习成本高
from langchain.agents import create_react_agent, create_self_ask_with_search_agent, AgentExecutor
from langchain import hub
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI

# 1. 定义工具（固定步骤）
@tool
def get_weather(city: str):
    return f"{city}晴，10-22℃"
tools = [get_weather]

# 2. 必须手动拉取提示词模板（不同Agent入口，需拉取不同模板）
# 场景1：创建react类型Agent，需拉取react模板
react_prompt = hub.pull("hwchase17/react")  # 手动拉取，依赖网络
react_agent = create_react_agent(
    llm=ChatOpenAI(api_key="你的API密钥"),
    tools=tools,
    prompt=react_prompt  # 必须传入手动拉取的模板
)

# 场景2：创建搜索类型Agent，需拉取另一类模板（多入口适配繁琐）
search_prompt = hub.pull("hwchase17/self-ask-with-search")
search_agent = create_self_ask_with_search_agent(
    llm=ChatOpenAI(api_key="你的API密钥"),
    tools=tools,
    prompt=search_prompt
)

# 3. 分别初始化执行器（冗余）
react_executor = AgentExecutor(agent=react_agent, tools=tools)
search_executor = AgentExecutor(agent=search_agent, tools=tools)

1.0版本示例：仅用 create_agent() 统一入口，无需区分场景、无需手动拉取模板，仅需传入system_prompt，配置极简。

python 复制代码

# 1.0版本：统一入口create_agent()，无需手动配模板
from langchain_core.agents import create_agent, AgentExecutor
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI

# 1. 定义工具（固定步骤）
@tool
def get_weather(city: str):
    return f"{city}晴，10-22℃"
tools = [get_weather]

# 2. 统一入口创建Agent，适配所有场景（无需区分react/search类型）
# 无需拉取模板，仅传入简洁的system_prompt，框架自动生成完整提示词
agent = create_agent(
    model=ChatOpenAI(api_key="你的API密钥"),
    tools=tools,
    system_prompt="你是天气助手，仅用提供的工具查询天气，简洁回答"
)

# 3. 单一执行器，直接调用（无需重复初始化）
agent_executor = AgentExecutor(agent=agent, tools=tools)
result = agent_executor.invoke({"input": "北京天气"})

2.2.3 可插拔中间件机制（旧版：需改核心逻辑 → 新版：插件式集成，不碰核心）

核心差异：旧版需侵入式修改Agent核心逻辑，繁琐且易出错；新版中间件插件式集成，无需碰核心代码，可复用、可灵活切换，适配生产级场景。

旧版本示例（LangChain 0.1.x 版本）：无中间件机制，如需实现"敏感信息脱敏"，需修改Agent核心执行逻辑，易破坏原有流程，且无法复用。

python 复制代码

# 旧版本（0.1.x）：无中间件，需修改Agent核心逻辑实现脱敏
from langchain.agents import create_react_agent, AgentExecutor
from langchain import hub
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
import re  # 需手动导入脱敏工具

# 1. 手动编写脱敏函数（无法复用）
def desensitize(text: str):
    # 手动编写脱敏逻辑：遮盖邮箱、手机号
    text = re.sub(r'[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+', '[EMAIL]', text)
    text = re.sub(r'1[3-9]\d{9}', '[PHONE]', text)
    return text

# 2. 定义工具
@tool
def query_sales(name: str):
    return f"{name}负责的2025年Q4销售额1280万元"
tools = [query_sales]

# 3. 手动修改Agent核心逻辑，插入脱敏步骤（易破坏原有流程）
class CustomAgent:
    def __init__(self, agent):
        self.agent = agent
    def invoke(self, inputs):
        # 手动在Agent执行前，对输入进行脱敏（侵入式修改）
        inputs["input"] = desensitize(inputs["input"])
        # 手动在Agent执行后，对输出进行脱敏（侵入式修改）
        result = self.agent.invoke(inputs)
        result["output"] = desensitize(result["output"])
        return result

# 4. 初始化旧版Agent，并包装自定义逻辑（繁琐、易出错）
prompt = hub.pull("hwchase17/react")
original_agent = create_react_agent(ChatOpenAI(api_key="你的API密钥"), tools, prompt)
custom_agent = CustomAgent(original_agent)
agent_executor = AgentExecutor(agent=custom_agent, tools=tools)

# 调用（需通过自定义Agent，而非原生Agent）
result = agent_executor.invoke({"input": "我邮箱test@163.com，手机号13800138000，查小明的销售额"})

1.0版本示例：内置中间件机制，直接导入脱敏中间件，插件式集成，无需修改Agent核心逻辑，可直接复用、灵活切换。

python 复制代码

# 1.0版本：可插拔中间件，无需修改Agent核心逻辑
from langchain_core.agents import create_agent, AgentExecutor
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
# 直接导入内置脱敏中间件（可复用，无需手动编写）
from langchain_core.middleware import sanitize_message

# 1. 定义工具（无需任何修改）
@tool
def query_sales(name: str):
    return f"{name}负责的2025年Q4销售额1280万元"
tools = [query_sales]

# 2. 创建1.0版本Agent（原生逻辑，无需修改）
agent = create_agent(
    model=ChatOpenAI(api_key="你的API密钥"),
    tools=tools,
    system_prompt="仅用提供的工具查询销售额，不编造信息"
)
agent_executor = AgentExecutor(agent=agent, tools=tools)

# 3. 插件式集成脱敏中间件（无需修改Agent核心逻辑）
def invoke_with_middleware(input_text):
    # 1. 应用脱敏中间件处理输入（前置钩子）
    from langchain_core.messages import HumanMessage
    msg = HumanMessage(content=input_text)
    sanitized_msg = sanitize_message(msg)  # 一行代码应用脱敏
    # 2. 调用Agent（原生Agent，无任何修改）
    result = agent_executor.invoke({"input": sanitized_msg.content})
    # 3. 应用脱敏中间件处理输出（后置钩子）
    result["output"] = sanitize_message(HumanMessage(content=result["output"])).content
    return result

# 调用（直接使用原生Agent+中间件，灵活可复用）
result = invoke_with_middleware("我邮箱test@163.com，手机号13800138000，查小明的销售额")

2.2.4 LangGraph深度集成

旧版本：Agent执行流程不可中断，报错需从头运行；

1.0版本：借助LangGraph检查点能力，可中断、可恢复，示例如下（极简）：

python 复制代码

# 1.0版本：LangGraph集成，支持中断/恢复
from langchain_core.agents import create_agent, AgentExecutor
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI

@tool
def query_sales(quarter: str):
    return "2025年Q4销售额1280万元"
tools = [query_sales]

# 创建Agent（默认集成LangGraph，支持检查点）
agent = create_agent(
    model=ChatOpenAI(api_key="你的API密钥"),
    tools=tools,
    system_prompt="仅用工具查询销售额"
)
agent_executor = AgentExecutor(agent=agent, tools=tools, checkpointer=True)  # 开启检查点

# 1. 执行任务，中途中断（模拟报错/人工干预）
run = agent_executor.begin_invoke({"input": "查2025年Q4销售额"})
run.interrupt()  # 中断执行

# 2. 恢复执行（无需从头运行，沿用之前的状态）
resumed_result = run.resume()
print(resumed_result["output"])

三、LangChain 1.0 核心概念

LangChain 1.0 的核心概念围绕"Agent 生命周期"展开，各组件可独立使用、灵活组合，核心概念包括：智能体（Agent）、模型 I/O、工具（Tools）、检索（Retrieval）、记忆（Memory）、中间件（Middleware）、LCEL 表达式语言、消息（Message），其中Agent是核心，其他组件均为Agent提供支撑。

3.1 智能体（Agent）------ 框架核心

Agent 是LangChain 1.0 的唯一核心，本质是"具备自主决策能力的大模型驱动系统"，核心作用是：根据用户指令，自主规划执行步骤、选择合适工具、处理异常情况、整合执行结果，最终完成复杂任务，无需开发者手动定义每一步执行逻辑。

LangChain 1.0 中的Agent基于LangGraph引擎运行，具备三大核心能力：

自主决策：判断用户需求是否需要调用工具、调用哪种工具、调用顺序如何；
工具使用：根据决策结果，调用对应的工具执行具体操作（如查询数据库、调用API）；
结果反思与迭代：接收工具返回的结果，判断是否满足用户需求，若不满足则调整策略、重新调用工具，直至完成任务。

智能体（Agent）简单代码示例：

python 复制代码

# 导入核心依赖（LangChain 1.0 统一接口）
from langchain_core.agents import create_agent, AgentExecutor
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI

# 1. 定义简单工具（Agent可调用的工具）
@tool
def query_sales_data(quarter: str) -> str:
    """查询指定季度的销售额数据，quarter参数格式为"2025年Q4"."""
    # 模拟工具执行逻辑（实际可替换为真实数据库查询）
    if quarter == "2025年Q4":
        return "2025年Q4销售额为1280万元，同比增长15.3%"
    return f"未查询到{quarter}的销售额数据"

# 2. 初始化模型（适配create_agent()入口）
model = ChatOpenAI(model="gpt-4o", api_key="你的API密钥")

# 3. 用LangChain 1.0 统一入口创建Agent
agent = create_agent(
    model=model,
    tools=[query_sales_data],  # 传入工具列表
    system_prompt="你是数据分析助手，仅使用提供的工具查询销售额，不编造信息。"
)

# 4. 初始化Agent执行器（执行Agent流程）
agent_executor = AgentExecutor(agent=agent, tools=[query_sales_data], verbose=True)

# 5. 调用Agent执行任务
result = agent_executor.invoke({"input": "帮我查询2025年Q4的销售额数据"})
print("Agent执行结果：", result["output"])

3.2 模型 I/O（模型输入/输出）

模型 I/O 是LangChain 1.0 连接大模型的"统一接口层"，核心作用是屏蔽不同厂商大模型的API差异，为上层组件（Agent、Tools等）提供标准化的模型调用能力，无需开发者针对不同模型编写适配代码，大幅降低模型替换成本，适配所有主流大模型（OpenAI、Anthropic、通义千问、DeepSeek等）。其核心功能包括：

统一模型抽象：将大模型分为LLM（文本输入→文本输出，适用于传统补全任务）和ChatModel（消息列表输入→消息输出，适用于对话、工具调用场景）两类，提供一致的调用接口；
提示词管理：支持提示词模板（Prompt Template）、系统提示词（system_prompt）的灵活配置，可动态注入对话历史、工具信息等上下文，提升提示词复用性和效果；
结构化输出：支持将模型输出解析为JSON、列表等结构化格式，避免手动解析文本的繁琐操作，便于与后续业务逻辑对接；
标准化内容块：为不同模型厂商的输出定义统一规范，解决模型替换带来的解析与兼容性问题。

模型 I/O 简单代码示例：

python 复制代码

# 导入核心依赖
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI, OpenAI  # 分别对应ChatModel和LLM

# 1. ChatModel用法（消息列表输入，适配对话/工具调用场景，LangChain 1.0 主推）
chat_model = ChatOpenAI(model="gpt-4o", api_key="你的API密钥")
# 定义提示词模板（动态注入上下文）
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是简洁的助手，仅回答用户问题，不添加多余内容。"),
    ("human", "用户问题：{question}")
])
# 组合提示词+模型+输出解析（LCEL表达式，简洁高效）
chain = prompt | chat_model | StrOutputParser()
# 调用模型
chat_result = chain.invoke({"question": "LangChain 1.0 的核心革新是什么？"})
print("ChatModel输出：", chat_result)

# 2. LLM用法（文本输入→文本输出，适用于传统补全场景）
llm = OpenAI(model="gpt-3.5-turbo-instruct", api_key="你的API密钥")
llm_result = llm.invoke("简述LangChain 1.0 的核心定位")
print("LLM输出：", llm_result)

3.3 消息（Message）------ 组件交互的核心载体

消息（Message）是LangChain 1.0 中贯穿所有组件的"数据交互载体"，本质是标准化的信息封装格式，用于在智能体（Agent）、模型I/O、记忆（Memory）、中间件（Middleware）等组件之间传递信息，是实现组件协同、上下文连贯的核心基础，所有组件的输入输出均以消息格式为标准，彻底解决了旧版本组件间数据格式不统一、交互繁琐的问题。

3.3.1 消息的核心特性

标准化结构：所有消息均包含固定核心字段（角色、内容、元数据），角色用于区分消息来源，内容为消息核心信息，元数据用于存储附加信息（如消息时间戳、来源组件、工具调用ID等），确保组件间可快速解析识别；
全组件兼容：无论是模型I/O的输入输出、Memory的存储读取，还是中间件的拦截处理、Agent的决策依据，均采用统一消息格式，实现"消息一处生成，多组件复用"；
可扩展性强：支持自定义消息类型和元数据字段，可根据业务需求扩展消息承载的信息，适配复杂业务场景（如携带工具调用参数、检索结果标识等）；
与上下文深度绑定：消息天然支持上下文关联，可通过元数据或内容关联历史消息，为Agent的自主决策、Memory的上下文保存提供基础支撑。

3.3.2 核心消息类型及应用场景

LangChain 1.0 提供了多种内置消息类型，覆盖所有组件交互场景，开发者可直接使用，也可基于内置类型自定义，核心类型分为以下4类：

人类消息（HumanMessage）
- 核心作用：承载用户输入的信息，是Agent接收用户需求的主要载体，角色固定为"human"。
- 应用场景：贯穿所有用户交互环节，例如用户发送的查询指令、对话提问、任务要求等，前文中间件示例中"我的邮箱是test@163.com，手机号13800138000，帮我查询销售额"即通过HumanMessage封装，确保Agent能准确识别用户意图。
AI消息（AIMessage）
- 核心作用：承载Agent或大模型的输出结果，角色固定为"ai"，是Agent向用户反馈信息、传递执行结果的核心载体。
- 应用场景：包括Agent的回答、任务执行反馈、工具调用结果汇总等，例如记忆模块示例中AI回复的"2025年Q4销售额为1280万元"，会自动封装为AIMessage，便于Memory模块保存和后续上下文关联。
系统消息（SystemMessage）
- 核心作用：传递系统级配置和指令，角色固定为"system"，是约束Agent的行为逻辑、配置模型参数、提供全局上下文信息。
- 应用场景：主要是初始化Agent时设置行为准则，例如create_agent()中传入的system_prompt，本质就是通过SystemMessage传递给模型，告知Agent"仅用提供的工具查询，不编造信息"等核心规则。
工具消息（ToolMessage）
- 核心作用：用于承载工具调用的相关信息，角色固定为"tool"，是Agent与工具之间交互的唯一载体，分为工具调用请求和工具返回结果两类。
- 应用场景：为Agent调用工具的全流程：Agent决策调用某工具时，会生成ToolMessage（请求类型），携带工具名称、调用参数等信息；工具执行完成后，其返回结果也会封装为ToolMessage（响应类型），回传给Agent，供Agent整合分析，实现"Agent→工具"的双向交互闭环。

3.3.3 消息的核心流转逻辑

LangChain 1.0 中，消息贯穿Agent生命周期的全流程，核心流转逻辑如下（结合前文组件，形成完整闭环）：

用户输入需求，生成HumanMessage，传递给Agent；
Agent结合开发者配置的SystemMessage（行为约束）和Memory中存储的历史消息（上下文），进行决策；
若Agent决策需要调用工具，会生成工具调用请求（隐含工具调用标识），触发工具执行；
工具执行完成后，生成ToolMessage（携带工具调用标识），返回给Agent；
Agent解析ToolMessage的内容，结合上下文消息，生成AIMessage（响应结果）；
AIMessage一方面返回给用户，另一方面存入Memory，作为后续交互的历史上下文；
若存在中间件（如脱敏、消息修剪），则在消息流转的各个节点（如HumanMessage传入前、AIMessage返回前）对消息进行拦截处理，不改变核心流转逻辑。

3.3.4 各消息类型极简代码示例

python 复制代码

# 导入核心依赖（所有消息类型均需导入）
from langchain_core.messages import HumanMessage, AIMessage, SystemMessage, ToolMessage

# 1. 人类消息（HumanMessage）：承载用户输入
# 核心用法：传入content参数，封装用户需求
human_msg = HumanMessage(
    content="帮我查询2025年Q4销售额，并脱敏我的手机号13800138000",
    metadata={"timestamp": "2025-12-01 10:00"}  # 扩展元数据：消息时间戳
)
print("人类消息：", human_msg.content)
print("人类消息元数据：", human_msg.metadata)

# 2. AI消息（AIMessage）：承载Agent/模型输出
# 核心用法：传入content参数，封装模型响应结果
ai_msg = AIMessage(
    content="2025年Q4销售额为1280万元，同比增长15.3%",
    metadata={"source": "Agent执行结果"}  # 扩展元数据：消息来源
)
print("\nAI消息：", ai_msg.content)

# 3. 系统消息（SystemMessage）：承载系统指令
# 核心用法：传入content参数，约束Agent行为（对应create_agent()的system_prompt）
system_msg = SystemMessage(
    content="仅使用提供的工具查询数据，不编造信息，同时对用户输入的敏感信息进行脱敏"
)
print("\n系统消息：", system_msg.content)

# 4. 工具消息（ToolMessage）：承载工具调用相关信息（请求/响应）
# 用法1：工具响应消息（工具执行后，回传给Agent的结果）
tool_response_msg = ToolMessage(
    content="2025年Q4销售额：1280万元，同比增长15.3%",
    tool_call_id="tool_001",  # 关键：关联工具调用ID，便于Agent追踪
    metadata={"tool_name": "query_sales_data"}  # 扩展元数据：工具名称
)
print("\n工具响应消息：", tool_response_msg.content)

# 用法2：工具调用请求消息（Agent决策后，调用工具的指令，简化示例）
tool_request_msg = ToolMessage(
    content='{"name": "query_sales_data", "parameters": {"quarter": "2025年Q4"}}',
    tool_call_id="tool_001",
    metadata={"action": "tool_call"}  # 标记为工具调用请求
)
print("\n工具调用请求消息：", tool_request_msg.content)

# 补充：消息列表（多消息组合，适配多轮对话/Agent执行流程）
message_list = [system_msg, human_msg, ai_msg, tool_response_msg]
print("\n消息列表（多组件协同用）：", [msg.content for msg in message_list])

3.4 工具（Tools）------ Agent的"行动手脚"

工具是Agent能够与外部世界交互、执行具体任务的"手脚"，本质是可被Agent调用的函数/接口，LangChain 1.0 提供了丰富的内置工具，同时支持开发者自定义工具，所有工具均需遵循标准化接口，确保能够被create_agent()入口统一调用，适配Agent的自主决策逻辑。

核心工具类型分为三类：

内置通用工具：涵盖搜索工具（Google、Bing）、数据库工具（SQL查询）、代码执行工具（Python解释器）、文件操作工具（读取/写入文档）、邮件发送工具等，可直接调用；
第三方API工具：通过接口适配，将第三方服务（如天气查询API、支付API、地图API）封装为工具，扩展Agent的业务能力；
自定义工具：开发者可根据自身业务需求，编写函数并封装为LangChain工具格式，实现特定业务逻辑（如内部系统查询、订单处理）。

工具的核心价值是让Agent跳出"只生成文本"的局限，具备实际操作能力，实现"思考+行动"的闭环（如：用户要求"分析本季度销售额并生成图表"，Agent可自主调用SQL工具查询数据、调用Python工具生成图表、调用文件工具保存图表）。

工具（Tools）简单代码示例：

python 复制代码

# 导入核心依赖
from langchain_core.tools import tool
from langchain.tools import PythonREPLTool  # 内置工具：Python代码执行工具

# 1. 自定义工具（最常用，贴合业务场景）
@tool(return_direct=True)  # return_direct=True：直接返回工具结果，不经过Agent二次处理
def get_weather(city: str) -> str:
    """查询指定城市的天气，city为城市名称（如北京、上海）。"""
    # 模拟第三方天气API调用（实际可替换为真实API请求）
    weather_data = {"北京": "晴，10-22℃", "上海": "阴，8-18℃"}
    return f"{city}当前天气：{weather_data.get(city, '未查询到该城市天气')}"

# 2. 内置工具调用（Python代码执行工具，可执行简单Python代码）
python_tool = PythonREPLTool()
# 直接调用内置工具（测试用法）
python_result = python_tool.invoke("print(100+200)")
print("Python工具执行结果：", python_result)

# 3. 工具列表（供Agent调用，统一格式）
tools = [get_weather, python_tool]
# 查看工具结构化描述（Agent将基于此判断是否调用工具）
for tool in tools:
    print("工具描述：", tool.name, tool.description)

3.5 检索（Retrieval）------ Agent的"外部知识库"

检索（Retrieval）是LangChain 1.0 解决大模型"知识滞后、领域性不足"的核心模块，核心作用是"将外部数据（私有文档、行业数据、实时数据）转化为Agent可调用的知识"，实现"大模型+私有数据"的高效结合，让Agent能够回答基于特定数据的问题，无需重新训练大模型。

检索模块的核心流程（Retrieval Pipeline）分为4步：

数据加载（Load）：通过文档加载器（Document Loader）读取外部数据，支持PDF、Word、Excel、网页、数据库等多种格式；
数据拆分（Split）：将加载的文档拆分为小块（Chunk），避免因文本过长导致的嵌入（Embedding）失效和检索精度下降；
嵌入与索引（Embed & Index）：通过嵌入模型（Embedding Model）将文本小块转化为向量，存储到向量数据库（如FAISS、Milvus）中，构建检索索引；
检索查询（Retrieve）：Agent根据用户需求，从向量数据库中检索出最相关的文本片段，作为上下文传入大模型，辅助生成回答。

LangChain 1.0 对检索模块进行了优化，提升了检索精度和效率，同时与Agent深度协同，Agent可自主判断是否需要检索外部数据，无需开发者手动触发检索流程。

检索（Retrieval）简单代码示例：

python 复制代码

# 导入核心依赖（需提前安装 faiss-cpu、langchain-openai）
from langchain_core.documents import Document
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain_core.retrievers import BaseRetriever

# 1. 模拟外部数据（私有文档内容，实际可通过文档加载器加载PDF/Word等）
documents = [
    Document(
        page_content="LangChain 1.0 于2025年发布，与LangGraph 1.0同步推出，核心是Agent为中心。",
        metadata={"source": "LangChain官方文档"}
    ),
    Document(
        page_content="LangChain 1.0 推出了统一的Agent构建入口create_agent()，简化了Agent开发流程。",
        metadata={"source": "LangChain官方文档"}
    )
]

# 2. 数据拆分（拆分为小块，提升检索精度）
text_splitter = RecursiveCharacterTextSplitter(chunk_size=100, chunk_overlap=10)
splits = text_splitter.split_documents(documents)

# 3. 嵌入与索引（用FAISS向量库，轻量易上手，适合测试）
embeddings = OpenAIEmbeddings(api_key="你的API密钥")
vector_store = FAISS.from_documents(splits, embeddings)

# 4. 创建检索器（供Agent调用）
retriever = vector_store.as_retriever(search_kwargs={"k": 1})  # k=1：检索最相关的1条数据

# 5. 检索查询（模拟Agent调用检索器获取外部知识）
query = "LangChain 1.0 的统一Agent构建入口是什么？"
retrieved_docs = retriever.invoke(query)
print("检索到的相关内容：", retrieved_docs[0].page_content)

3.6 记忆（Memory）------ Agent的"记忆力"

记忆（Memory）是LangChain 1.0 让Agent具备"连贯交互能力"的核心模块，核心作用是"保存Agent与用户的对话历史、任务执行过程中的中间状态"，让Agent能够"记住"之前的交互内容，避免上下文断裂，支持复杂多轮对话和长期任务的连贯执行（如：多轮对话中，Agent可记住用户之前提到的偏好、任务进度，无需用户重复说明）。

LangChain 1.0 中的记忆模块已下沉至langchain-core核心层，支持多种记忆类型，可按需选择：

短期记忆（Short-Term Memory）：仅保存当前对话会话的历史记录，适用于简单多轮对话，会话结束后记忆清除；
长期记忆（Long-Term Memory）：通过数据库（如Redis、PostgreSQL）持久化保存对话历史和任务状态，支持跨会话记忆（如：用户隔天继续之前的任务，Agent可记住之前的进度）；
专用记忆：如摘要记忆（将长对话历史汇总为摘要，减少记忆占用）、实体记忆（专门保存对话中提到的实体信息，如人名、地名、产品名）。

记忆（Memory）简单代码示例（短期+长期）：

bash 复制代码

# 导入核心依赖（需提前安装 redis 用于长期记忆）
from langchain_core.memory import SimpleMemory, ConversationBufferMemory
from langchain_core.agents import AgentExecutor, create_agent
from langchain_openai import ChatOpenAI
from langchain_community.cache import RedisCache
import redis

# 1. 短期记忆（SimpleMemory，适用于简单场景，存储键值对）
short_term_memory = SimpleMemory()
# 保存上下文
short_term_memory.save_context(
    inputs={"human": "我叫小明"},
    outputs={"ai": "你好小明，很高兴为你服务！"}
)
# 读取记忆
print("短期记忆内容：", short_term_memory.load_memory_variables({}))

# 2. 短期记忆（ConversationBufferMemory，适用于多轮对话，保存完整对话历史）
conv_memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
# 模拟多轮对话，保存记忆
conv_memory.save_context({"human": "帮我查询2025年Q4销售额"}, {"ai": "2025年Q4销售额为1280万元"})
conv_memory.save_context({"human": "同比增长多少？"}, {"ai": "同比增长15.3%"})
# 读取对话历史
print("多轮对话记忆：", conv_memory.load_memory_variables({}))

# 3. 长期记忆（Redis，持久化存储，跨会话可用）
# 连接Redis（本地Redis需提前启动）
redis_client = redis.Redis(host="localhost", port=6379, db=0)
long_term_memory = RedisCache(redis_client=redis_client)
# 保存记忆（持久化，重启程序后仍可读取）
long_term_memory.set("user_preference", "小明偏好简洁的回答")
# 读取长期记忆
print("长期记忆内容：", long_term_memory.get("user_preference"))

3.7 中间件（Middleware）------ Agent的"流程控制器"

中间件是LangChain 1.0 新增的核心工程化组件，本质是围绕模型调用点的拦截器，可插入前置（before_model）、后置（after_model）、包裹（wrap_model_call）三类钩子，无需改动Agent核心逻辑即可实现流程治理与策略控制，是LangChain 1.0 适配生产级场景的关键特性之一。

LangChain 1.0 提供了多个内置中间件，同时支持自定义中间件，常见应用场景包括：

人机交互中间件：工具执行前暂停流程，让用户批准、编辑或拒绝工具调用请求，适用于转账、发送邮件等敏感操作场景；
脱敏中间件：自动识别并遮盖对话中的电子邮件、电话号码、身份证等敏感信息，保障数据安全；
消息治理中间件：修剪旧消息、删除指定类型消息、生成对话摘要，控制token占用量；
动态模型路由中间件：根据输入规模、关键词或预算，自动切换不同模型（如简单任务用轻量模型，复杂任务用高性能模型）。

中间件（Middleware）简单代码示例（脱敏+消息治理）：

python 复制代码

# 导入核心依赖
from langchain_core.middleware import (
    run_middleware,
    sanitize_message  # 内置脱敏中间件
)
from langchain_core.messages import HumanMessage
from langchain_openai import ChatOpenAI
from langchain_core.middleware.message import trim_messages  # 内置消息治理中间件

# 1. 脱敏中间件（内置，自动遮盖敏感信息：邮箱、手机号）
model = ChatOpenAI(model="gpt-4o", api_key="你的API密钥")
# 模拟包含敏感信息的用户消息
human_msg = HumanMessage(content="我的邮箱是test@163.com，手机号13800138000，帮我查询销售额")

# 应用脱敏中间件（前置钩子，处理消息后再传入模型）
sanitized_msg = sanitize_message(human_msg)
print("脱敏后消息：", sanitized_msg.content)  # 输出：我的邮箱是[EMAIL]，手机号[PHONE]，帮我查询销售额

# 2. 消息治理中间件（内置，修剪旧消息，控制token）
# 模拟长对话消息列表
messages = [
    HumanMessage(content="你好"),
    HumanMessage(content="帮我介绍LangChain 1.0"),
    HumanMessage(content="介绍下模型I/O"),
    HumanMessage(content="介绍下工具"),
    HumanMessage(content="现在帮我查询销售额")
]
# 应用消息治理中间件（保留最近2条消息，修剪旧消息）
trimmed_messages = trim_messages(
    messages,
    max_tokens=100,
    strategy="last",  # 保留最后n条
    n=2
)
print("修剪后消息数量：", len(trimmed_messages))  # 输出：2

# 3. 组合中间件+模型调用
final_msg = sanitize_message(trimmed_messages[-1])  # 脱敏+修剪
result = model.invoke([final_msg])
print("模型最终响应：", result.content)

3.8 LCEL（LangChain Expression Language）------ 组件编排语言

LCEL 是LangChain 1.0 确立的核心抽象层，中文名为"LangChain 表达式语言"，核心作用是"标准化组件的交互与编排方式"，让开发者能够通过简洁的表达式，将模型、工具、检索、记忆等组件灵活组合，构建复杂的执行流程（如：Agent调用流程、检索-生成流程），无需编写大量冗余的串联代码。

LCEL 的核心优势的是"声明式编排"，开发者只需声明"组件如何组合"，无需关注组件之间的底层交互细节，支持组件的动态替换和流程的灵活调整，同时具备可观测性、容错性和并发性，进一步降低了复杂AI应用的开发难度。例如，通过LCEL可快速定义"检索→模型生成→输出解析"的固定流程，或"Agent决策→工具调用→结果反思"的动态流程。

LCEL 简单代码示例（组件编排）：

python 复制代码

# 导入核心依赖
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain_core.documents import Document

# 1. 定义各个组件（检索、提示词、模型、输出解析）
# 检索组件（复用前面的检索逻辑）
documents = [Document(page_content="LangChain 1.0 核心是Agent，统一入口为create_agent()")]
embeddings = OpenAIEmbeddings(api_key="你的API密钥")
vector_store = FAISS.from_documents(documents, embeddings)
retriever = vector_store.as_retriever()

# 提示词组件
prompt = ChatPromptTemplate.from_messages([
    ("system", "结合检索到的内容，简洁回答用户问题，不添加多余信息。"),
    ("human", "用户问题：{question}"),
    ("human", "检索参考：{context}")
])

# 模型组件
model = ChatOpenAI(model="gpt-4o", api_key="你的API密钥")

# 输出解析组件
output_parser = StrOutputParser()

# 2. 用LCEL表达式编排组件（检索→提示词→模型→输出解析）
# 流程：用户问题→检索相关内容→注入提示词→模型生成→解析输出
chain = (
    {
        "context": lambda x: retriever.invoke(x["question"])[0].page_content,
        "question": lambda x: x["question"]
    }
    | prompt
    | model
    | output_parser
)

# 3. 执行编排流程
result = chain.invoke({"question": "LangChain 1.0 的核心是什么？"})
print("LCEL编排流程输出：", result)  # 输出：LangChain 1.0 核心是Agent，统一入口为create_agent()

四、进阶核心概念

4.1 多智能体（Multi-Agents）与子智能体（Subagents）

LangChain 1.0 基于LangGraph的状态图能力，原生支持多智能体协同架构，解决单一Agent无法处理复杂多领域任务的痛点。多智能体（Multi-Agents）是指多个独立Agent协同工作，各自负责不同细分领域，通过消息流转实现任务分工与结果汇总。

子智能体（Subagents）是主智能体拆分出的细分智能体，由主智能体调度，负责处理主Agent的细分任务（如数据清洗、格式转换），本质是多智能体的简化实现。

核心应用场景：复杂业务任务拆解（如"生成季度销售分析报告"可拆分为"数据查询Agent""数据分析Agent""报告生成Agent"）、多领域协同（如结合金融Agent+法务Agent处理合规性业务）。

多智能体（Multi-Agents）简单代码示例：

示例说明：演示3个细分Agent协同完成"查询-分析-生成报告"的完整任务，体现多智能体的分工与协同逻辑，贴合生产级任务拆解场景，可直接参考复用并扩展更多Agent。

python 复制代码

# 导入核心依赖（LangChain 1.0 原生支持多Agent调度）
from langchain_core.agents import create_agent, AgentExecutor
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessage
from langchain_core.runnables import RunnableLambda

# 1. 定义细分领域工具（对应不同Agent）
# 工具1：数据查询工具（供数据查询Agent使用）
@tool
def query_sales_data(quarter: str) -> str:
    """查询指定季度销售额数据，quarter格式为"2025年Q4"."""
    return f"{quarter}销售额为1280万元，同比增长15.3%"

# 工具2：数据分析工具（供数据分析Agent使用）
@tool
def analyze_sales_data(sales_info: str) -> str:
    """分析销售额数据，输入为销售额字符串，输出分析结论."""
    if "同比增长15.3%" in sales_info:
        return "销售额同比增长显著，高于行业平均增速（10%），业务发展态势良好"
    return "销售额无明显增长，需关注业务优化方向"

# 工具3：报告生成工具（供报告生成Agent使用）
@tool
def generate_report(analysis_result: str, sales_info: str) -> str:
    """生成销售分析报告，输入为分析结论和原始销售额数据."""
    return f"""# 季度销售分析报告
## 一、销售额数据
{sales_info}
## 二、数据分析结论
{analysis_result}
## 三、总结
基于数据显示，本季度业务发展态势良好，建议持续优化现有业务模式，巩固增长优势。"""

# 2. 初始化模型（所有Agent可共用一个模型，也可按需切换）
model = ChatOpenAI(model="gpt-4o", api_key="你的API密钥")

# 3. 创建3个细分Agent（数据查询、数据分析、报告生成）
#  Agent1：数据查询Agent
query_agent = create_agent(
    model=model,
    tools=[query_sales_data],
    system_prompt="你是数据查询助手，仅使用提供的工具查询销售额数据，不进行任何分析或生成操作，直接返回查询结果。"
)
query_executor = AgentExecutor(agent=query_agent, tools=[query_sales_data], verbose=False)

#  Agent2：数据分析Agent
analyze_agent = create_agent(
    model=model,
    tools=[analyze_sales_data],
    system_prompt="你是数据分析助手，仅使用提供的工具分析销售额数据，输入为原始销售额信息，输出分析结论，不进行查询或报告生成。"
)
analyze_executor = AgentExecutor(agent=analyze_agent, tools=[analyze_sales_data], verbose=False)

#  Agent3：报告生成Agent
report_agent = create_agent(
    model=model,
    tools=[generate_report],
    system_prompt="你是报告生成助手，仅使用提供的工具生成报告，输入为分析结论和原始销售额数据，输出规范报告格式。"
)
report_executor = AgentExecutor(agent=report_agent, tools=[generate_report], verbose=False)

# 4. 多Agent协同调度（主逻辑：串联3个Agent，实现任务闭环）
def multi_agent_pipeline(input_text):
    # 步骤1：调用数据查询Agent，获取原始数据
    query_result = query_executor.invoke({"input": input_text})["output"]
    print("数据查询结果：", query_result)
    
    # 步骤2：调用数据分析Agent，分析原始数据
    analyze_result = analyze_executor.invoke({"input": query_result})["output"]
    print("数据分析结论：", analyze_result)
    
    # 步骤3：调用报告生成Agent，生成最终报告
    report_result = report_executor.invoke({"input": f"分析结论：{analyze_result}，销售额数据：{query_result}"})["output"]
    return report_result

# 调用多智能体协同完成任务
final_report = multi_agent_pipeline("查询2025年Q4销售额并生成分析报告")
print("最终销售分析报告：", final_report)