当前位置：首页 > news >正文

如何用LangChain开发一个Agent，20分钟搞定！

news 2026/4/17 19:34:59

26年一定是一个 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的意义

如何开发一个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"])

运行效果如下：

结语

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

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

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

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

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

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