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

关注

原创最新推荐文章于 2026-10-27 23:07:06 发布 419 阅读 AI 写同款· GEO 优化 ›

LangChain入门指南 LangChain是一个强大的框架，旨在帮助开发人员使用语言模型构建端到端的应用程序。它提供了一套工具、组件和接口，可简化创建由大型语言模型 (LLM) 和聊天模型提供支持的应用程序的过程。LangChain 可以轻松管理与语言模型的交互，将多个组件链接在一起，并集成额外的资源，例如 API 和数据库。官方文档：https://python.langchain.com/en/latest/ 阅读详情

26年一定是一个 Agent 大年，我这边持续出系列文章，帮助大家更好的落地 Agent，今天的重点是程序员最常用的 Agent 框架 LangChain。

只不过这东西可能由于 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，喜欢用智能体，所以我尽量讲究老板们。

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

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

如果有同学还没搞懂什么是 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，所有智能体都可以通过该方法快速定义。

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

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

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

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 是一个基于内存的检查点保存器：

**原理：**它将状态数据保存在 Python 的字典（内存）中。
**特点：**速度快，无需额外依赖（如数据库）。
**局限性：**程序重启后数据会丢失。因此仅适用于开发调试或不需要持久化的场景。
**生产环境替代方案：**在生产环境中，通常会使用 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 做一个智能体，其实依旧是围绕三个核心：模型、工具、记忆。

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

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

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

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

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

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

如何学习大模型 AI ？

由于新岗位的生产效率，要优于被取代岗位的生产效率，所以实际上整个社会的生产效率是提升的。

但是具体到个人，只能说是：

“最先掌握AI的人，将会比较晚掌握AI的人有竞争优势”。

这句话，放在计算机、互联网、移动互联网的开局时期，都是一样的道理。

我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。