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，喜欢用智能体，所以我尽量讲究老板们。

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

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 的…

如何学习大模型 AI ？

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

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

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

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

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

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

第一阶段（10天）：初阶应用

该阶段让大家对大模型 AI有一个最前沿的认识，对大模型 AI 的理解超过 95% 的人，可以在相关讨论时发表高级、不跟风、又接地气的见解，别人只会和 AI 聊天，而你能调教 AI，并能用代码将大模型和业务衔接。

• 大模型 AI 能干什么？
• 大模型是怎样获得「智能」的？
• 用好 AI 的核心心法
• 大模型应用业务架构
• 大模型应用技术架构
• 代码示例：向 GPT-3.5 灌入新知识
• 提示工程的意义和核心思想
• Prompt 典型构成
• 指令调优方法论
• 思维链和思维树
• Prompt 攻击和防范
• …

第二阶段（30天）：高阶应用

该阶段我们正式进入大模型 AI 进阶实战学习，学会构造私有知识库，扩展 AI 的能力。快速开发一个完整的基于 agent 对话机器人。掌握功能最强的大模型开发框架，抓住最新的技术进展，适合 Python 和 JavaScript 程序员。

• 为什么要做 RAG
• 搭建一个简单的 ChatPDF
• 检索的基础概念
• 什么是向量表示（Embeddings）
• 向量数据库与向量检索
• 基于向量检索的 RAG
• 搭建 RAG 系统的扩展知识
• 混合检索与 RAG-Fusion 简介
• 向量模型本地部署
• …

第三阶段（30天）：模型训练

恭喜你，如果学到这里，你基本可以找到一份大模型 AI相关的工作，自己也能训练 GPT 了！通过微调，训练自己的垂直大模型，能独立训练开源多模态大模型，掌握更多技术方案。

到此为止，大概2个月的时间。你已经成为了一名“AI小子”。那么你还想往下探索吗？

• 为什么要做 RAG
• 什么是模型
• 什么是模型训练
• 求解器 & 损失函数简介
• 小实验2：手写一个简单的神经网络并训练它
• 什么是训练/预训练/微调/轻量化微调
• Transformer结构简介
• 轻量化微调
• 实验数据集的构建
• …

第四阶段（20天）：商业闭环

对全球大模型从性能、吞吐量、成本等方面有一定的认知，可以在云端和本地等多种环境下部署大模型，找到适合自己的项目/创业方向，做一名被 AI 武装的产品经理。

• 硬件选型
• 带你了解全球大模型
• 使用国产大模型服务
• 搭建 OpenAI 代理
• 热身：基于阿里云 PAI 部署 Stable Diffusion
• 在本地计算机运行大模型
• 大模型的私有化部署
• 基于 vLLM 部署大模型
• 案例：如何优雅地在阿里云私有部署开源大模型
• 部署一套开源 LLM 项目
• 内容安全
• 互联网信息服务算法备案
• …

学习是一个过程，只要学习就会有挑战。天道酬勤，你越努力，就会成为越优秀的自己。

如果你能在15天内完成所有的任务，那你堪称天才。然而，如果你能完成 60-70% 的内容，你就已经开始具备成为一名大模型 AI 的正确特征了。

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】