如何用LangChain开发一个Agent，20分钟包教包会！

只不过这东西可能由于 AI Coding 的成熟，由给人看变成给 AI 看的。

LangChain 既是一个开源的AI应用开发框架，也是其背后同名公司LangChain的统称。

该公司围绕AI应用开发构建了一套完整的产品矩阵，包括广受欢迎的开源框架LangChain、用于构建复杂状态机的LangGraph，以及企业级调试与监控平台LangSmith等。

其中，LangChain和LangGraph是社区中最活跃的两个开源项目。

需要特别说明的是，在LangChain 1.0版本之后，这两个框架的定位发生了重要变化：LangGraph 成为底层的智能体编排引擎，专注于有状态、多轮、高度定制化的智能体流程控制；

而LangChain 则在此基础上演变为上层应用开发框架，提供了更高阶的抽象、丰富的工具集成和便捷的智能体构建能力。

简单来说，LangChain 封装了 LangGraph 的复杂性，让开发者能够快速搭建标准智能体；而LangGraph 则为需要深度控制流程、自定义逻辑的场景提供了灵活的图式编程能力。

对于大多数智能体应用，比如本文将要构建的旅行智能助手，LangChain 已足够胜任，它简洁的API和开箱即用的组件能让我们更专注于业务逻辑本身：

注意1，本文中的langchain 的版本>=1.0

注意2，案例很简单，但一定要和前几篇文章对照阅读，才知道Agent是什么，才知道LangChain的意义

unsetunset如何开发一个Agentunsetunset

PS：有些老板不喜欢用Agent，喜欢用智能体，所以我尽量讲究老板们。

在上文中我们说了，开发智能体的核心，其实就三件事：模型 + 工具 + 记忆。

1. 模型负责核心的推理决策；
2. 工具用来落地执行具体的业务操作；
3. 记忆则负责留存历史对话，给模型的推理提供足够的上下文支撑。

如果有同学还没搞懂什么是 AI Agent，或者不知道该怎么设计、开发一个 AI Agent，建议先回看我们上一篇文章《小白版：如何做一个Agent》。

接下来，咱们就实操起来 ，看看怎么用 LangChain 实现模型调用、工具封装、会话记忆保存这些基础功能，最终完整开发出一个能跑起来的 AI Agent。

模型调用

lagnchain 提供了很多标准的方法来调用各个厂商的模型，官网给出了完成整的集成列表：

https://docs.langchain.com/oss/python/integrations/providers/overview 

可以进入官网。查看支持的模型厂商具体是如何使用。这里我们用deepseek举例：

这个是langchain 支持deepseek模型的集成包，可以直接使用：

from langchain_deepseek import ChatDeepSeek
model = ChatDeepSeek(
    model="...",
    temperature=0,
    max_tokens=None,
    timeout=None,
    max_retries=2,
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    # other params...
)

其他模型提供商也有对应的集成包，大家可以自行去官网寻找，也可以使用 openAI的标准格式，基本上所有模型都支持这种方式：

model=ChatOpenAI(
  model="deepseek-chat",
  api_key=os.getenv("DEEPSEEK_API_KEY"),
  base_url="https://api.deepseek.com",
  temperature=0.7

通过上面的方法，我们就能得到一个模型实例 model，接下来就可以调用这个 model 实例，使用invoke或者stream方法向模型发起请求并获取它的返回结果了：

model = ChatOpenAI(
        model="deepseek-chat",
        api_key=os.getenv("DEEPSEEK_API_KEY"),
        base_url="https://api.deepseek.com",
        temperature=0.7
    )

    messages = [
        {"role": "system", "content": "你是一个有用的助手。"},
        {"role": "user", "content": "你是谁"}
    ]

result = model.invoke(messages)
print(result.content)
# 流失输出
result = model.stream(messages)
for chunk in result:
    print(chunk.content)

声明工具

在 LangChain 里定义工具函数特别简单，用 @tool 装饰器就能快速搞定 ，这也是最常用、最便捷的方式：

# 定义工具函数
@tool
def get_weather(destination, date):
    # 实际调用天气 API
    return f"{destination} {date} 天气晴朗"
@tool
def get_attractions(destination):
    return f"{destination} 的热门景点有故宫、颐和园..."
# ... 其他函数

模型调用工具的关键，是靠工具名称和描述来判断该不该用这个工具。

如果只是写个普通函数给 LangChain 用，它会默认把函数名当工具名、函数的文档字符串当描述。但这种默认写法往往描述得不够精准，模型很可能理解错工具用途，导致调用出错。

所以想让模型 “精准识别、正确调用” 工具，最好的方式是显式定义：给工具指定清晰的名称、详细的描述，还要给每个参数也加上说明。

推荐的做法就是用 @tool 装饰器，搭配 Annotated 和 Field 来补充这些详细的元数据，让模型完全明白工具的作用和用法：

from langchain_core.tools import tool
from typing import Annotated
from pydantic import Field

@tool(name_or_callable="get_weather", description="获取指定城市指定日期的天气信息")
def get_weather(
    destination: Annotated[str, Field(description="城市名称，如'西安'")],
    date: Annotated[str, Field(description="日期，格式 YYYY-MM-DD，如'2025-05-20'")]
) -> str:
    return f"{destination} {date} 天气晴朗"

@tool(name_or_callable="get_attractions", description="获取指定城市的景点推荐")
def get_attractions(
    destination: Annotated[str, Field(description="城市名称，如'北京'")]
) -> str:
    # 实际开发中，这里应调用景点 API
    return f"{city} 的热门景点有：故宫、颐和园、天坛。"

定义智能体

在 LangChain 中，开发一个智能体非常简单。框架提供了标准方法 create_agent，所有智能体都可以通过该方法快速定义。

我们只需要传入几个核心参数，即可完成一个智能体的创建：

1. 模型：通过 LangChain 的模型调用接口得到的大模型实例。
2. 工具：声明好的工具列表。

下面是一个完整的示例，演示如何创建一个最简单的智能体并使用它：

from langchain_openai import ChatOpenAI
from langchain.agents import create_react_agent
from langchain_core.tools import tool
import os
# 定义工具（假设已有 get_weather, get_attractions）
# 示例工具函数已在前文定义，此处略
# 初始化模型
model = ChatOpenAI(
    model="deepseek-chat",
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url="https://api.deepseek.com",
    temperature=0.7
)
# 工具列表
tools = [get_weather, get_attractions]
# 创建智能体
agent = create_agent(model=model, tools=tools)
# 准备输入消息
messages = {
    "messages": [
        {"role": "system", "content": "你是一个有用的助手。"},
        {"role": "user", "content": "我想去北京玩，能帮我看看天气和景点吗？"}
    ]
}
# 调用智能体
result = agent.invoke(messages)
# 输出最终答案
print(result["messages"][-1].content) 

这样，我们就完成了一个最简单的智能体。LangChain 的 create_agent 方法默认采用 ReAct 模式（Reasoning + Acting）运行智能体，其工作流程如下：

• 模型接收用户消息，进行推理，判断是否需要调用工具。
• 如果需要工具，模型输出工具调用指令，框架自动执行对应工具，并将结果作为新的消息添加到对话中。
• 更新后的消息再次输入给模型，重复上述步骤，直到模型认为信息收集完毕，给出最终答案。
• 整个流程完全由框架自动管理，开发者只需提供模型和工具，即可获得一个具备自主决策能力的智能体。

添加记忆

上一节，我们构建了一个能够调用工具的智能体，它目前还没有记忆能力，每次对话都是独立的，无法记住之前的对话历史。

为了让智能体具备多轮对话的能力，LangChain 提供了完善的记忆（Memory）模块，记忆分为两类：短期记忆和长期记忆，接下来我们一起使用langchain提供的方法来实现他们：

短期记忆：通常指模型上下文窗口内的对话历史。由于大模型的上下文窗口有限，我们无法将无限长的对话历史全部发送给模型。因此，短期记忆通常采用“滑动窗口”或“摘要总结”的方式，只保留最近的几轮对话或关键信息。

在 LangChain中，短期记忆的持久化是通过 Checkpointer 机制实现的。

Checkpointer 机制

在构建智能体时，我们通常希望它能够记住之前的对话内容。LangGraph 通过 checkpointer 来保存每一轮交互后的状态（State）：

• Checkpointer: 负责在每一步（Step）结束后，将当前的状态（包括消息历史、变量等）保存起来。
• thread_id: 当我们需要继续之前的对话时，只需要提供相同的 thread_id，Checkpointer 就会加载之前的状态，从而实现“记忆”功能。

InMemorySaver 是一个基于内存的检查点保存器：

1. 原理：它将状态数据保存在 Python 的字典（内存）中。
2. 特点：速度快，无需额外依赖（如数据库）。
3. 局限性：程序重启后数据会丢失。因此仅适用于开发调试或不需要持久化的场景。
4. 生产环境替代方案：在生产环境中，通常会使用 PostgresSaver (基于 PostgreSQL) 或 SqliteSaver 等持久化方案，以确保服务重启后记忆不丢失。

from langgraph.checkpoint.memory import InMemorySaver
# ...
agent = create_agent(
    # ...
    checkpointer=InMemorySaver()
)
# 调用时指定 thread_id
config = {"configurable": {"thread_id": "1"}}
result = agent.invoke(input=messages, config=config)

长期记忆：为了解决上下文窗口的限制，我们需要将历史对话持久化存储（如数据库、向量库）。

在需要时，通过检索算法（如语义相似度搜索）找到与当前问题最相关的历史记录，注入到 Prompt 中。

这也就是 RAG（检索增强生成）在记忆模块中的应用。

下面我们以一个基于向量数据库的长期记忆实现为例

向量化存储实现

我们使用 Chroma 作为向量数据库，配合 DashScope 的 Embedding 模型来实现记忆的存储与检索。

首先，我们需要初始化 Embedding 模型和向量数据库：

import os
from langchain_community.embeddings import DashScopeEmbeddings
from langchain_chroma import Chroma
from langchain_core.documents import Document
# 初始化向量模型
embeddings = DashScopeEmbeddings(
    model="text-embedding-v4", 
    dashscope_api_key=os.getenv("DASHSCOPE_API_KEY")
)
# 初始化向量存储
# persist_directory 指定数据持久化目录
vectorstore = Chroma(
    embedding_function=embeddings, 
    persist_directory="./chroma_db", 
    collection_name="chat_history"
)

保存记忆

当对话发生时，我们需要将用户的输入和 AI 的回复保存下来。为了区分不同用户和会话，我们在 metadata 中记录 user_id 和 session_id：

def save_messages(messages: str, user_id: int, session_id: int):
    """
    保存用户输入和AI输出的会话记录
    """
    # 将对话内容封装为 Document 对象，并添加元数据
    doc = Document(
        page_content=messages, 
        metadata={"user_id": user_id, "session_id": session_id}
    )
    # 添加到向量数据库
    vectorstore.add_documents([doc])

检索记忆

在进行新一轮对话前，我们可以根据用户的输入（Query），在向量库中检索相关的历史记录，作为上下文提供给模型。这里我们还支持根据 user_id 和 session_id 进行过滤，确保只检索当前用户或会话的记忆：

def load_messages(query: str, user_id: int, session_id: int):
    """
    加载用户输入和AI输出的会话记录
    """
    # 构建过滤条件
    filters = []
    if user_id:
        filters.append({"user_id": user_id})
    if session_id:
        filters.append({"session_id": session_id})

    if len(filters) > 1:
        filter_dict = {"$and": filters}
    elif len(filters) == 1:
        filter_dict = filters[0]
    else:
        filter_dict = None

    # 执行相似度搜索，返回最相关的 top-k 记录
    if filter_dict:
        docs = vectorstore.similarity_search(query=query, k=3, filter=filter_dict)
    else:
        docs = vectorstore.similarity_search(query=query, k=3)

    return docs

这里就做好了 长期记忆的保存和检索，接下来让我们在智能体中增加消息的保存和检索。

在短期记忆中 可以在create_agent中 加入一个 checkpointer=InMemorySaver()就可以实现 短期记忆，langchain就会将历史对话消息添加到提示词中，那么我们如何把长期记忆添加到提示词中呢，这里就不得不提到langchain的中间件Middleware了：

通过middleware添加长期记忆

Middleware 提供了强大的生命周期钩子，允许我们在模型调用前后、工具执行前后进行深度干预。

中间件生命周期钩子：

我们需要自己定义一个中间件 add_long_memory 使用wrap_model_call在模型调用前 通过 load_messages 方法 查询 长期记忆 ，并将消息追加到messages中：

@wrap_model_call
def add_long_memory(request: ModelRequest, handler: Callable[[ModelRequest], ModelResponse]) -> ModelResponse:
    print(f"Model call: {request}")

    message = request.messages[-1]
    if message.type == "human":
        embedding_docs = load_messages(message.content, config["configurable"]["user_id"],
                                       config["configurable"]["session_id"])
        embedding_message = "n".join([doc.page_content for doc in embedding_docs])
        request.messages.append(ChatMessage(content=embedding_message, role="system"))
    return handler(request)

现在我们可以给agent添加长期记忆了，只需要在create_agent中 添加一个参数

middleware=[add_long_memory()]

Agent就会在调用模型前 调用add_long_memory 方法 将load_messages 查询到的历史消息，添加到提示词中。

完整的智能体代码如下：

config: RunnableConfig = {"configurable": {"thread_id": "1", "user_id": 1, "session_id": 1}}
 llm = ChatOpenAI(
      model="deepseek-chat",
      api_key=os.getenv("DEEPSEEK_API_KEY"),
      base_url="https://api.deepseek.com",
      temperature=0.7
  )
  messages = {
      "messages": [
          {"role": "system", "content": "你是一个旅游规划助手。"},
          {"role": "user", "content": user_message}
      ]
  }
  tools = [get_weather, get_attractions]
  agent = create_agent(llm,
                       tools=tools,
                       middleware=[add_long_memory()],
                       checkpointer=InMemorySaver())

  result = agent.invoke(input=messages, config=config)
  ai_message = result["messages"][-1].content
  save_messages(messages=user_message + ai_message, user_id=config["configurable"]["user_id"], session_id=config["configurable"]["session_id"])

运行效果如下：

unsetunset结语unsetunset

好了，聊了这么多，我们快速来回顾一下。用 LangChain 做一个智能体，其实依旧是围绕三个核心：模型、工具、记忆。

1. 模型：不管你想用 DeepSeek 还是 OpenAI，LangChain 都给你封装好了，一行代码换模型，不用操心各家 API 的差异。
2. 工具：把你要做的事写成函数，加个 @tool 装饰器，再写清楚它是干什么的、参数是什么，模型就能看懂、会调用。整个过程你会发现其实挺简单的。
3. 记忆：分两类。短期记忆用 checkpointer，设个 thread_id 就能让智能体记住刚才的对话；长期记忆稍微费点功夫，得借助向量数据库存历史，再在模型调用前把相关的旧聊天翻出来塞给它。我们中间件那里演示的就是这个思路。

把这些一组合，一个能自己琢磨、会查天气、能聊天的旅行助手就搭起来了。

而且 LangChain 这套设计还挺贴心的，你要是想快速实现功能，就用它的高层封装；要是想精细控制每一步，底下还有 LangGraph 和中间件让你折腾。

最后想说，LangChain 确实把智能体开发的门槛拉低了不少。不管是做个简单的问答，还是想玩复杂的工作流，你都可以从今天聊的这几个组件开始，慢慢往上添东西。

有空的话，不妨自己动手搭一个试试，代码跑起来的后，还是挺有成就感的。

只不过，我们团队做 Agent 应该是不会使用 LangChain 的…