Agent智能体的定义

以前的Ai叫做AIGC如chatGpt，
核心能力：内容生成
交互模式：被动响应，依赖提示词。
输出结果： 建议，发难，内容，（一般还需要人工整合处理）
与外界交互：有限，主要通过文本。

现在AI应用叫AI Agent(如Manus)
核心能力：任务规划和自主执行
交互模式：主动规划，自主决策
输出结果：**可交付的最终结果**
与外界交互：强大，可通过很多tools调用，操作现实世界的系统。

2025年是 “Agent元年”！从思考，到行动的范式跃迁。

Agent本质式一个具备动态决策能力的智能执行框架，通过LLM作为大脑，协调调度各种工具完成复杂任务。与传动的预定义流程不同，Agent能根据实际情况自主作出决策，将单一的工具调用转为灵活的问题解决能力。
LLM Agent在循环中运行工具以实现目标，循环运行直到满足条件停止。形成一个决策-执行-反馈的循环系统。

通俗理解：Agent就是一个人或者一个项目管理，它能通过派给他的需求去拆分目标（Planner角色），根据目标决定调用某些工具执行（Router角色），调度工具按照步骤去执行（Executor角色），最终整合结果交付。

Agent 核心组件详解

• 模型（Model），Model是Agent的大脑，负责推理和决策过程。Model的核心职责是分析当前状态和用户请求，决策是否调用工具和哪些工具，解析工具返回结果形成最终响应，推理过程通常基于COT(Chain-of-Thought)模型，让我们一步一步分析，将复杂问题分解为多个思考步骤。
• 工具：Tools是Agent与外部世界交互的能力扩展接口，每个工具封装了一个特定工具，如搜索引擎查询，数据库操作等等。从架构角度看，工具将Agent的认知能力与具体执行能力分离，使得Agent可以专注于决策而非实现细节。
• 记忆: Memory为Agent提供上下文感知能力，使其能够记住之前的交互历史并基于上下文作出决策。
• AgentExecutor: AgentExecutor继续扮演执行协调器的作用，负责迭代运行代理直到满足停止条件。

Agent的工作流程和决策解析

• 输入解析：Agent首先接受用户输出，解析其意图和关键参数，输入解析器负责标准化用户请求，提取可供工具使用的结构化参数。
• LLM推理：解析后的输入与当前状态（包括记忆和历史记录），一起传递给LLM进行推理，LLM基于预设的提示词模版分析情况，决定下一步行动：直接回答还是调用工具
• 工具调用：如果LLM决定调用工具，AgentExecutor会执行相应的工具函数，并获取执行结构，工具调用可能涉及API访问，数据库查询，或者计算操作等。
• 观察与迭代：工具返回的结果作为观察被反馈给Agent，这些信息与之前的状态一起形成新的上下文，传递给LLM进行下一步推理，这个循环持续进行，直到LLM认为以获得足够多的信息来生成最终答案。
• 结果整合：当循环结束时，Agent整合所有获取的信息，生成格式化的最终答案返回给用户，同时，重要的交互信息可能被存储在记忆系统中，供未来绘画使用。

LangChain1.0

LangChain体系分为 LangChain，LangGraph，DeepAgents和LangSmith四个模块。

第一个LangChain

LangChain主要提供基础工具和构建基础智能体。

安装对应依赖
poetry add langchain langchain-openai langgraph deepagents
其中，langchain-openai就是Integration packages，提供的一套针对openai的连接工具。

最简单的就是直接连接llm去交互。
如图的agent就是在llm外面包一层，让其变成一个带有角色预设的智能体，让llm作为底层可以去做其他的事情，(把大语言模型的能力封装组合到一起，基于大语言模型的能力可以去解决额外的问题)

从这个案例可以看出，langChain体系当中的Agent，就是在于大模型交互的基础上，进一步封装补充各种信息，从而把大模型，从一个简单的工具，升级成能单独处理特定任务的Agent智能体。

比如这个create_agent

这就是langChain1.0的变化，可以传入tools，我们可以设置额外的工具给llm调用，比如发邮件，比如写代码，这就是llm所不具备的能力。简单理解：Agent = llm(大脑) + tools(手脚) +....
让llm可以做更多的事情。
langchain1.0将agent的概念前置到langchain，以前是langGraph的能力。

相比于之前我 们直接调用llm做一些简单的对话，这个agent可以做更多的东西，调用其他工具，这就是最基础的智能体的概念。

但这种智能体也很呆板，只能做一些简单的交互，如果想要处理一些复杂的任务(去小红书搜索一些信息，再去掘金搜索一些信息，过滤xx信息，整合一起，要实现的话，我们需要一行一行写业务逻辑)，比如要跟大模型做很多交互，如果用langChain，那么只能一行一行的写代码。这时候langGraph就出来了

第一个LangGraph

graph顾名思义，流程图。
看一个demo

# 定义复杂智能体全局状态细腻
class State(TypedDict):
    author: NotRequired[str];
    joke: NotRequired[str];

# 定义两个节点
 def author_node(self, state: State) -> State:
        promot = "帮我推荐一个受人们欢迎的作家，只需要给出作家的名字即可"
        author = self.client.invoke(promot)
        return {"author": author.content}
    
def joke_node(self, state: State) -> State:       
        prompt = f"请根据作家 {state['author']} 的风格，编一个笑话"
        joke = self.client.invoke(prompt)
        return {"joke": joke.content}


	  
		builder = StateGraph(State)
        # 添加节点
        builder.add_node(node=self.author_node, name="author_node")
        builder.add_node(node=self.joke_node, name="joke_node")

        # 添加边
        builder.add_edge(START, "author_node")
        builder.add_edge("author_node", "joke_node")
        builder.add_edge("joke_node", END)

        checkpointer = InMemorySaver()
        ## 创建一个graph
        graph = builder.compile(checkpointer=checkpointer)
        config = {
            "configurable": {
                "thread_id": str(uuid.uuid4()),
            } 
        }
        ## 调用
        state = graph.invoke({}, config)
        print(state)

如上，定义了一个全局状态，然后通过节点/边的形式，编排两个节点的逻辑。流程图的话就是

这就是graph的由来。我们看效果

如果我们用第一种，需要自己创建两个agent，然后将自己写代码，将两个agent的逻辑整合起来。但是在graph就提供了简便的方法。

通过这个图就将两次大模型的调用整合在一起，而LangGraph就是围绕这个图，再提供各种补充支持。比如你觉得这个结果不满意，你可以从图中的某一个节点重新开始，重新执行一次，直到过关。
或者你可以对图中的一些节点做if/else判断，让其走向不同的逻辑。

如果我觉得这个结果不满意

  # 查看所有checkpoint检查点
        states = list(graph.get_state_history(config))
        print(states)
        # 推荐作家那一步
        selected_state = states[1]
        # 重新设定config
        new_config = graph.update_state(selected_state.config, values={"author": "郭德纲"})
        # 重新执行Graph
        state1 = graph.invoke(None, new_config)
        print(state1)

可以重新回到某个节点，然后重新定义config，再执行一次

可以看到，这种Graph图的方式，就更适合构建一些复杂的多步骤的应用，在LangGraph中，Node和Edge都可以是一个自由定制的函数，这就极大提高了AI应用的灵活性。

但这种Graph图的逻辑再复杂，也是要由人来提前定制的，能不能把这个图的逻辑也由Ai来指定？于是就有了现在的deepagents,让大模型自己决定下一步该怎么走。

第一个DeepAgents应用

 deep_agent = create_deep_agent(
            self.client,
            tools=[
                {
                    "name": "get_date",
                    "function": get_date,
                    "description": "这个工具可以获取当前的日期和时间，返回格式为 'YYYY-MM-DD HH:MM:SS'。",
                },
                {
                    "name": "get_weather",
                    "function": get_weather,
                    "description": "这个工具可以获取指定城市和日期的天气简况信息。",
                },
            ],
            system_prompt="""
            你是一个助手，现在有以下一些工具可以使用，如果有提问天气的请调用相关tool，如果有提问日期的，请调用相关tool，不要自己回答：
            ## `get_date`: 获取当前日期
            ## `get_weather`: 获取城市的天气
            结合这些工具，完成用户的请求                               
            """,
        )
        response = deep_agent.invoke(
            {
                "messages": [
                    {"role": "user", "content": "明天星期几？这一天深圳的天气怎么样"}
                ]
            }
        )
        for message in response["messages"]:
            print(message)
            print("=====")

调用create_deep_agent，提供两个tools供其使用。
结果：
两个tools被调用了


第一次输出结果content为空，开始调用get_date函数，第二次调用get_weather，得到结果返回。

在这个案例中，访问大模型的时候，通过系统提示词预先提供了两个函数，一个是获取当前日期，一个是获取城市的天气，大模型会根据用户的问题自行判断要不要调用这些函数。
这就是DeepAgents的基础思想，结合大模型，构建更智能的Agent智能体，甚至这些tools工具，可以是其他的Agent，也可以是LangGraph构成的图，然后deepAgent再自己去判断调度哪个智能体。
围绕这种思路，目前DeepAgents提供了一些扩展组件，比如FilesystemBackend，实现了一些操作本地文件的工具

总结

回过头看这个图

整个Langchan体系：

• 基础智能体：其实就是跟大模型进行一些简单交互的Agent；
• 多智能体：把和大模型交互的多个步骤，整合到一起，形成一个完整的智能体，中间是以图的结构，有一个完整的业务流程。
• 复杂智能体：就是把任务的调度过程，交由智能体自己判断（智能体判断调用哪些工具/智能体）

以前0.x版本，LangChain最为经典的LCEL链式编程依然支持，不过从官网的文档中删除了。
看一下chain的demo

 const template = "这个 {test} 英文怎么说?";

  const prompt = new PromptTemplate({
    template: template,
    inputVariables: ["test"],
  });

  // 结果: 这个 香蕉 英文怎么说?

  // chain 将多个组件（如提示词模板、大语言模型、输出解析器等）链接在一起，形成一个完整的、可执行的任务流。
  const chain = new LLMChain({ llm: deepseek, prompt: prompt });

  const res = await chain.call({ test: "香蕉" });

  console.log(res);

其实就是写一个一个组件，然后形成这样的链条使用。不过现在这种思想不太够用了，现在也有langGraph，可以处理复杂流程，就不用自己手写一个一个复杂的流程了。

另一方面，DeepAgents模块，其实也是对更多AI模式的探索，从DeepAgents的演练过程就能看到一些claude code的影子。
先是生成一个文档，列举任务步骤，调用哪些agent，然后再根据这个文档一步一步执行。

langchain作为天生围绕Ai开发的一套框架，思维方法会越来越重要。比如之前力推的LCEL，现在也逐渐不再推荐，未来LangChain应该还有大的变动，尤其是DeepAgents，从模块名可以看出，其并没有放在LangChain和LangGraph体系当中，所以，思维方式会越来越重要，跟上世界的思维方式，才是LangChain新版本带来的最大感觉。