企业级 AI Agent 架构知识点讲解(一):从知识型到业务型,从 LangGraph 到生产落地

企业级 AI Agent 架构知识点讲解:从知识型到业务型,从 LangGraph 到生产落地

文章目录

  • [企业级 AI Agent 架构知识点讲解:从知识型到业务型,从 LangGraph 到生产落地](#企业级 AI Agent 架构知识点讲解:从知识型到业务型,从 LangGraph 到生产落地)
    • 前言
    • [一、问题的起点:知识型 Agent 撑不起业务流程](#一、问题的起点:知识型 Agent 撑不起业务流程)
      • [1.1 两类智能体的本质差异](#1.1 两类智能体的本质差异)
      • [1.2 为什么不能硬塞进 ReAct](#1.2 为什么不能硬塞进 ReAct)
    • [二、概念澄清:Tool / MCP / Skill / Plugin](#二、概念澄清:Tool / MCP / Skill / Plugin)
      • [2.1 逐个说清](#2.1 逐个说清)
      • [2.2 选型公式](#2.2 选型公式)
    • [三、决策树:什么做 Tool,什么做子智能体](#三、决策树:什么做 Tool,什么做子智能体)
      • [3.1 判断口诀](#3.1 判断口诀)
      • [3.2 业务属性矩阵](#3.2 业务属性矩阵)
      • [3.3 子智能体的三个触发条件(满足任一即可)](#3.3 子智能体的三个触发条件(满足任一即可))
      • [3.4 Tool(封装 Graph)的三个条件(建议全满足)](#3.4 Tool(封装 Graph)的三个条件(建议全满足))
    • [四、LangGraph 底层认知纠偏(三个关键结论)](#四、LangGraph 底层认知纠偏(三个关键结论))
      • [4.1 结论一:StateGraph 不能直接运行](#4.1 结论一:StateGraph 不能直接运行)
      • [4.2 结论二:Agent 不是节点,Agent 本身就是图](#4.2 结论二:Agent 不是节点,Agent 本身就是图)
      • [4.3 结论三:自定义业务图当然可以调工具](#4.3 结论三:自定义业务图当然可以调工具)
    • [五、100 个业务流程怎么管](#五、100 个业务流程怎么管)
      • [5.1 两个必须避开的反模式](#5.1 两个必须避开的反模式)
      • [5.2 正确姿势:注册中心 + 按需加载](#5.2 正确姿势:注册中心 + 按需加载)
      • [5.3 配置驱动的变体(可视化编排场景)](#5.3 配置驱动的变体(可视化编排场景))
      • [5.4 入口路由:别用大模型硬猜 100 个意图](#5.4 入口路由:别用大模型硬猜 100 个意图)
    • 六、人工审批(HITL)完整落地方案
      • [6.1 需求描述](#6.1 需求描述)
      • [6.2 核心机制:Checkpointer + Interrupt](#6.2 核心机制:Checkpointer + Interrupt)
      • [6.3 完整闭环](#6.3 完整闭环)
      • [6.4 三个致命坑(重点)](#6.4 三个致命坑(重点))
        • [坑一:在 Tool 函数内部 `interrupt()`](#坑一:在 Tool 函数内部 interrupt())
        • [坑二:把含 interrupt 的子图包成 Tool,在函数里 `sub.invoke()`](#坑二:把含 interrupt 的子图包成 Tool,在函数里 sub.invoke())
        • [坑三:异步「点火即走」的黑盒 Tool](#坑三:异步「点火即走」的黑盒 Tool)
      • [6.5 生产必备的四个工程细节](#6.5 生产必备的四个工程细节)
    • [七、langgraph.json 逐字段详解](#七、langgraph.json 逐字段详解)
      • [7.1 字段说明](#7.1 字段说明)
      • [7.2 两个值得展开的设计](#7.2 两个值得展开的设计)
      • [7.3 `disable_mcp: true` 到底禁了什么](#7.3 disable_mcp: true 到底禁了什么)
    • [八、生产环境的真相:90% 是「单大脑 + 强工具」](#八、生产环境的真相:90% 是「单大脑 + 强工具」)
      • [8.1 Multi-Agent 为什么在企业遇冷](#8.1 Multi-Agent 为什么在企业遇冷)
      • [8.2 那剩下的 10% 在哪](#8.2 那剩下的 10% 在哪)
      • [8.3 一个务实的提醒](#8.3 一个务实的提醒)
    • 九、总结:架构铁律清单
      • [9.1 分层架构](#9.1 分层架构)
      • [9.2 八条铁律](#9.2 八条铁律)
      • [9.3 一句话收尾](#9.3 一句话收尾)
    • 写在最后

前言

做大模型应用开发时,社区里满屏都是 ReAct、Multi-Agent、MCP、Skill 这些概念。但当你真的要把它们搬进企业生产环境------面对几十个标准业务流程、需要人工审批、需要断点恢复、需要可审计------你会发现大部分 Demo 级架构直接崩掉。

本文把我在架构选型过程中踩过的坑和想通的问题,系统整理成一篇。核心回答这几个问题:

  • 知识型智能体和业务型智能体,到底该不该用同一套架构?
  • 50 个、100 个业务流程,难道要写 100 个 Agent?
  • Tool / MCP / Skill / Plugin 的边界在哪?
  • LangGraph 里,Agent 到底是图还是节点?
  • 人工审批怎么做到「挂起 → 通知 → 审批 → 自动续跑」?
  • 为什么 Tool 内部不能 interrupt()?
  • 真实生产环境里,到底有多少项目在用 Multi-Agent?

全文基于 LangGraph,代码为架构示意,重在讲清原理与边界。


一、问题的起点:知识型 Agent 撑不起业务流程

1.1 两类智能体的本质差异

维度 知识型智能体 业务型智能体
核心模式 ReAct / Plan-and-Execute Workflow / DAG / 状态机
路径确定性 低,由 LLM 临场决定 高,遵循 SOP
AI 的角色 主导者:负责思考与决策 辅助者:只在个别节点做抽取/判断/生成
典型场景 文档检索、开放问答、方案调研 请假、报销、入职、订单处理
扩展方式 调 Prompt、扩知识库 加流程配置
出错代价 答错可以重来 涉及资金/合规,不可接受

1.2 为什么不能硬塞进 ReAct

一个典型的业务流程长这样:

text 复制代码
开始 → 拉数据 → AI 分析 → 人工审核 → 发邮件 → 结束

这是确定的流程图,不是「让 AI 想想下一步干嘛」。如果交给 ReAct:

  • 不可控:LLM 可能跳过审核直接发邮件;
  • 低效:每步都重新规划,5~10 次 LLM 调用起步;
  • 无法暂停:ReAct 是一口气跑完的循环,天然不支持挂起几天等人审批。

核心原则:不要让 ReAct 去「理解」业务流程的每一步,而是让它把整个流程当成一个黑盒来调用。


二、概念澄清:Tool / MCP / Skill / Plugin

这四个词经常混用,但它们根本不在同一个层级。

概念 本质 粒度 类比
Tool 一个函数 / API 原子级 一把菜刀
MCP 一套通信协议 管道级 标准化插座
Skill Prompt + 工具组合 + 使用经验 业务级 做宫保鸡丁的手艺
Plugin 平台化封装(UI + 鉴权 + 后端) 产品级 预制菜料理包

2.1 逐个说清

Tool:最小执行单元。输入参数、返回结果、瞬间完成。它就是一个 Python 函数,没有任何神秘之处。

MCP :它不是工具,是工具的运输管道 。价值在于标准化发现(tools/list)与调用(tools/call),从而实现热插拔、跨语言。你的业务逻辑用 Java 写、用 Go 写都行,只要符合协议。

Skill :能力组合包。比如「数据分析技能」= SQL 工具 + 绘图工具 + 一段告诉 AI「先查数、再画图、最后用大白话解释趋势」的 Prompt。Skill 的核心是使用经验,不是代码。

Plugin:平台依赖强、黑盒化。自研架构里基本可以用 MCP + Skill 替代,除非你要直接接 Coze / Dify 生态。

2.2 选型公式

text 复制代码
原子操作 / 简单 API / 本地封装   →  Tool
固定流程 / SOP / 跨系统对接      →  MCP Server(内部包 Tool 或 Graph)
领域能力 / 复杂逻辑 / 使用经验   →  Skill
开放探索 / 创意 / 路径不确定     →  Sub-Agent(独立 ReAct 循环)

三、决策树:什么做 Tool,什么做子智能体

3.1 判断口诀

步骤是死的、错了会出大事(合规 / 资金)→ 做成 Tool(内部是 Graph)

需要动脑子、找线索、没有标准答案 → 交给子智能体(ReAct)

3.2 业务属性矩阵

业务类型 示例 方案 理由
事务型 请假、报销、订会议室 Tool(Graph) 流程固定,需审批断点
查询型 查订单、查物流、查余额 Tool(API 封装) 纯查询,连 Graph 都不用
分析型 销售异常归因、用户画像 子智能体 需动态决定分析角度
创作型 营销文案、周报撰写 子智能体 无标准答案,需迭代
混合型 智能客服 Tool + 子智能体 简单走 RAG,复杂走 ReAct

3.3 子智能体的三个触发条件(满足任一即可)

  1. 需要自主规划路径:「分析为什么上月销售额下降」------先查库、再查竞品、再查客服记录,顺序无法预先写死。
  2. 需要独立的多轮上下文 / 长期记忆:面试助手要追问、要记住前面的回答,且不能污染主对话。
  3. 任务大到需要拆解委托:写行业报告 = 研究员收集 + 写手成文。

3.4 Tool(封装 Graph)的三个条件(建议全满足)

  1. 流程是 SOP,步骤固定;
  2. 需要强合规与审计;
  3. 追求低延迟低成本(1~2 次 LLM 调用 vs 子智能体的 5~10 次)。

四、LangGraph 底层认知纠偏(三个关键结论)

这一节是全文最重要的部分,很多人在这里认知错位。

4.1 结论一:StateGraph 不能直接运行

必须区分两种形态:

形态 是什么 能否运行
StateGraph 蓝图:定义了节点和边 ❌ 不能
CompiledGraph 引擎:.compile() 后的产物 ✅ 可以 .invoke()
python 复制代码
from langgraph.graph import StateGraph, START, END

# 1. 蓝图(不可运行)
builder = StateGraph(dict)
builder.add_node("node_a", my_func)
builder.add_edge(START, "node_a")
builder.add_edge("node_a", END)

# 2. 编译成引擎(可运行)
engine = builder.compile(checkpointer=checkpointer)

# 3. 真正执行
result = engine.invoke({"input": "hello"}, config)

类比:StateGraph 是设计图纸,.compile() 是造出真车,.invoke() 是踩油门。

顺带纠正一个常见误用词:不存在「运行时动态编译代码」。图的逻辑结构是事先写死的静态定义 ,所谓「动态」只是指运行时按业务编码加载对应引擎、注入执行上下文。

4.2 结论二:Agent 不是节点,Agent 本身就是图

在 LangGraph 里,Agent = 带有循环和条件边的 CompiledGraph。

ReAct 的「思考 → 行动 → 观察」循环,是被显式拆解成节点和边的:

python 复制代码
from langgraph.graph import StateGraph, START, END

agent = StateGraph(AgentState)

# 节点1:LLM 思考
agent.add_node("call_llm", call_model)
# 节点2:执行工具
agent.add_node("execute_tool", tool_node)

agent.add_edge(START, "call_llm")

# 条件边:LLM 输出里有没有 tool_calls?
agent.add_conditional_edges(
    "call_llm",
    should_continue,
    {
        "continue": "execute_tool",
        "end": END,
    },
)

# 关键:工具执行完,强制回到 LLM ------ 这个环就是 ReAct
agent.add_edge("execute_tool", "call_llm")

my_agent = agent.compile(checkpointer=checkpointer)

看懂这个环,就看懂了 Agent 的本质:它不是黑盒大脑,它是一个显式的、可观测、可打断的状态机。

4.3 结论三:自定义业务图当然可以调工具

「调工具」不是 Agent 的特权。工具就是普通函数,任何节点里都能直接调。

python 复制代码
# 一个普通工具函数
def get_leave_balance(employee_id: str) -> int:
    return hr_api.query_balance(employee_id)

# 业务图的普通节点
def check_balance_node(state):
    # 直接调用,没有任何 LLM 决策
    balance = get_leave_balance(state["employee_id"])
    return {"leave_balance": balance}

两者的差别只在决策者是谁:

维度 Agent 图 自定义业务图
谁决定调哪个工具 LLM 临场决定 开发者写代码时定死
实现方式 ToolNode + 条件边 + 环 节点函数里直接调
路径 不确定 确定
是否有环 有(ReAct 循环) 通常无(DAG / 状态机)

五、100 个业务流程怎么管

5.1 两个必须避开的反模式

反模式 A:写 100 个 Agent 类。

100 套 Prompt、100 套工具绑定、100 套测试用例,运维直接爆炸。

反模式 B:把 100 个子图 add_node 进一个主图。

主图臃肿到无法维护,每加一个业务都要改主图代码,彻底失去扩展性。

5.2 正确姿势:注册中心 + 按需加载

图的定义事先写好,启动时统一编译注册,运行时按 biz_code 取用。

python 复制代码
# ========== 启动阶段:编译并注册 ==========
GRAPH_REGISTRY = {
    "leave":     build_leave_graph().compile(checkpointer=checkpointer),
    "reimburse": build_reimburse_graph().compile(checkpointer=checkpointer),
    "onboard":   build_onboard_graph().compile(checkpointer=checkpointer),
    # ... 其余 97 个
}

# ========== 运行阶段:按需取用 ==========
async def handle_request(biz_code: str, payload: dict, thread_id: str):
    engine = GRAPH_REGISTRY.get(biz_code)
    if engine is None:
        raise ValueError(f"未注册的业务流程: {biz_code}")

    config = {"configurable": {"thread_id": thread_id}}
    return await engine.ainvoke(payload, config)

收益 :主入口极轻量;新增第 101 个业务,只需新增一个 build_xxx_graph() 并注册,主流程代码零改动。

5.3 配置驱动的变体(可视化编排场景)

如果流程不是代码写死,而是业务人员在前端拖拽生成、存进数据库的 JSON:

python 复制代码
class WorkflowEngine:
    def __init__(self, checkpointer, registry):
        self.checkpointer = checkpointer
        self.registry = registry

    async def start(self, biz_code: str, payload: dict, thread_id: str):
        # 1. 取图定义(JSON / DSL)
        definition = self.registry.get(biz_code)
        # 2. 按定义组装 StateGraph 并 compile(这才是真正的"运行时构建")
        engine = build_graph_from_definition(definition, self.checkpointer)
        # 3. 执行
        config = {"configurable": {"thread_id": thread_id}}
        return await engine.ainvoke(payload, config)

注意术语:这里做的是实例化(instantiation) ,不是把字符串编译成代码。别用 eval。

5.4 入口路由:别用大模型硬猜 100 个意图

业务少于 5 个时,LLM 路由还行;到了 50~100 个,纯 LLM 意图分类准确率会很难看(「查工资」和「查绩效」极易混淆)。

工程上的务实做法:

  • 显式入口优先:对话框旁边给快捷菜单 / 卡片,点「请假」直接进专属流程,上下文隔离;
  • 隐式路由兜底:用户非要打字,先走规则 / 关键词 / 轻量分类模型 / 向量召回,命中后再进流程;
  • 大模型只做最后一步确认,不做 100 选 1。

六、人工审批(HITL)完整落地方案

这是从「玩具 Agent」走向「企业级 Agent」的分水岭。

6.1 需求描述

  • 流程跑到审批节点,不能让用户在页面上干等;
  • 需要一个独立审批中心,所有待办集中展示;
  • 审批人可能明天才批,批完流程要自动从断点续跑;
  • 中间服务器重启也不能丢状态。

6.2 核心机制:Checkpointer + Interrupt

机制 作用
Checkpointer 每个节点执行后把 State 持久化到数据库
interrupt() 在节点内主动挂起,线程状态置为 interrupted
Command(resume=...) 注入人工决策,从断点继续

生产环境务必用持久化 checkpointer(Postgres / Redis),不要用 InMemorySaver,进程一重启状态就没了。

python 复制代码
# 开发调试
from langgraph.checkpoint.memory import InMemorySaver
checkpointer = InMemorySaver()

# 生产环境
from langgraph.checkpoint.postgres import PostgresSaver
checkpointer = PostgresSaver.from_conn_string(DB_URL)

6.3 完整闭环

第一步:节点内挂起
python 复制代码
from langgraph.types import interrupt

def manager_approval_node(state):
    # 组装给审批人看的结构化表单
    form = {
        "applicant": state["applicant"],
        "amount": state["amount"],
        "reason": state["reason"],
    }

    # 挂起!State 落库,invoke 立即返回,HTTP 不阻塞
    decision = interrupt(form)

    # 恢复时,decision 就是外部注入的审批结果
    if decision["action"] == "approved":
        return {"approval_status": "passed", "approver": decision["user"]}
    return {"approval_status": "rejected", "reject_reason": decision.get("comment")}

此时 invoke 的返回里会带 __interrupt__,前端据此把会话置为「等待审批」,请求正常结束,不卡死。

第二步:生成待办,推送审批中心

监听到线程进入 interrupted,往业务库插一条待办:

sql 复制代码
CREATE TABLE biz_approval_task (
    id            BIGINT PRIMARY KEY,
    biz_code      VARCHAR(64)  NOT NULL COMMENT '业务编码',
    thread_id     VARCHAR(128) NOT NULL COMMENT 'LangGraph 线程ID,恢复的唯一钥匙',
    biz_no        VARCHAR(64)  COMMENT '业务单号',
    applicant     VARCHAR(64),
    approver      VARCHAR(64),
    form_data     JSON         COMMENT '审批表单快照',
    status        VARCHAR(16)  DEFAULT 'PENDING' COMMENT 'PENDING/APPROVED/REJECTED/TIMEOUT',
    tenant_id     VARCHAR(64),
    created_at    DATETIME,
    expired_at    DATETIME     COMMENT '超时时间',
    UNIQUE KEY uk_thread (thread_id)
);

最关键的一条:thread_id 必须和业务单号强绑定。 审批页面点「同意」时,后端全靠它找回那条挂起的流程。

第三步:审批后恢复
python 复制代码
from langgraph.types import Command

async def handle_approval(thread_id: str, biz_code: str, action: str, user: str, comment: str = ""):
    engine = GRAPH_REGISTRY[biz_code]
    config = {"configurable": {"thread_id": thread_id}}

    resume_value = {"action": action, "user": user, "comment": comment}

    # 从 Checkpointer 加载 State,注入决策,从 interrupt 处继续
    result = await engine.ainvoke(Command(resume=resume_value), config)

    # 更新待办状态
    await update_task_status(thread_id, action)
    return result
第四步:自动跑完后续节点

引擎从断点无缝续跑「财务打款 → 发邮件 → 归档」,全程无需人工干预。

6.4 三个致命坑(重点)

坑一:在 Tool 函数内部 interrupt()

做不到。 原因:

  • Tool 对引擎是黑盒,引擎不知道它执行到了第几行;
  • Checkpointer 保存的是Graph 节点的 State,不是 Python 函数的调用栈和局部变量;
  • 在 Tool 里阻塞等待,会把主图的节点一起卡死。

正确做法:把长 Tool 拆成多个节点。

python 复制代码
# ❌ 错误
def process_and_pay_tool():
    prepare()
    interrupt(...)   # 无效
    pay()

# ✅ 正确:需要审批 = 它不是原子工具,是流程
wf.add_node("prepare", prepare_node)   # 内部调 Tool 1
wf.add_node("approve", approval_node)  # 这里 interrupt()
wf.add_node("pay", pay_node)           # 内部调 Tool 2
wf.add_edge("prepare", "approve")
wf.add_edge("approve", "pay")
坑二:把含 interrupt 的子图包成 Tool,在函数里 sub.invoke()

同样做不到。 子图挂起 → invoke() 不返回 → 主图当前节点卡住 → 主图 Checkpointer 因为「节点未完成」而无法保存 → 整个请求超时。

正确做法:子图作为节点,而不是作为 Tool。 LangGraph 原生支持图嵌套,Checkpointer 能穿透保存主图 + 子图的完整状态。

python 复制代码
sub_engine = build_sub_graph().compile()

main = StateGraph(dict)
main.add_node("business", sub_engine)   # 直接塞编译好的子图
main.add_node("final", final_node)
main.add_edge(START, "business")
main.add_edge("business", "final")
main.add_edge("final", END)

main_engine = main.compile(checkpointer=checkpointer)

恢复时用主图的 thread_id 发 Command(resume=...),会从子图断点续跑,跑完再回主图。

⚠️ 但这个方案只适合少量、固定的嵌套。100 个业务请走第五节的注册中心方案,别硬塞节点。

坑三:异步「点火即走」的黑盒 Tool
python 复制代码
# 危险:Tool 立刻返回"已启动",但后台执行失败用户完全无感知
asyncio.create_task(run_graph_in_background(...))
return "流程已启动"

这不符合企业级对强一致性和可干预性 的要求。要么用 interrupt() 精确挂起(推荐),要么必须配套:任务状态表 + 失败告警 + 重试入口 + 人工干预面板。

6.5 生产必备的四个工程细节

细节 做法
超时催办 定时扫描 expired_at,超时自动 Command(resume={"action":"timeout"}),走催办或升级分支
幂等 审批接口按 thread_id 加锁 / 状态机校验,防止重复点击导致重复打款
驳回回流 resume 传 rejected,图走「生成补充提问」分支,推送给发起人,补充后重新回到审批节点
失败可干预 节点报错时 State 已落库,运维可查该 thread_id 的 State 定位问题,修正后重新触发恢复

七、langgraph.json 逐字段详解

一个企业级 LangGraph Runtime 的典型配置:

json 复制代码
{
  "$schema": "https://langgra.ph/schema.json",
  "python_version": "3.13",
  "dependencies": ["."],
  "http": {
    "app": "./src/runtime_service/webapp.py:app",
    "disable_mcp": true
  },
  "graphs": {
    "reference_agent": {
      "path": "./src/runtime_service/graphs/reference_agent.py:get_agent",
      "description": "Runtime-aware create_agent reference service."
    },
    "workflow_demo": {
      "path": "./src/runtime_service/graphs/workflow_demo.py:get_agent",
      "description": "Model-backed workflow Agent with human confirmation interrupt."
    }
  },
  "env": ".env",
  "thread_lifecycle": {
    "before_delete": "./src/runtime_service/thread_lifecycle.py:before_delete",
    "after_delete": "./src/runtime_service/thread_lifecycle.py:after_delete",
    "tombstone_metadata_keys": ["project_id", "tenant_id"]
  },
  "webhooks": {
    "terminal": {
      "projector": "./src/runtime_service/run_completion/projector.py:project_terminal_outcome"
    }
  },
  "auth": {
    "path": "./src/runtime_service/auth/platform.py:auth",
    "openapi": {
      "securitySchemes": {
        "RuntimeBearer": {
          "type": "http",
          "scheme": "bearer",
          "bearerFormat": "JWT"
        }
      },
      "security": [{ "RuntimeBearer": [] }]
    }
  }
}

7.1 字段说明

字段 作用
$schema JSON Schema 声明,IDE 补全与校验
python_version 运行时 Python 版本约束
dependencies "." 表示把当前目录作为可安装包,src 下代码被当作核心依赖加载
http.app FastAPI 入口,语法 文件路径:变量名
graphs 核心:注册本服务对外提供的所有图(智能体 / 工作流)
env 环境变量文件,放 API Key、DB 连接串
thread_lifecycle 会话删除前后钩子 + 墓碑元数据
webhooks.terminal 图到达终态(完成/失败/取消)时触发的结果投影器
auth 自定义鉴权入口 + OpenAPI 安全声明

7.2 两个值得展开的设计

tombstone_metadata_keys(墓碑机制)

企业合规要求数据不能物理删除,只能逻辑删除。这里声明软删除时必须保留 project_id / tenant_id,用于后续审计、计费、满足数据合规要求。

webhooks.terminal.projector(终态投影)

长耗时任务不能让 HTTP 连接挂着等。图跑完后由 projector 把结果写库 / 推 Redis / 发 WebSocket / 钉钉通知。这是长任务异步化的标准做法。

7.3 disable_mcp: true 到底禁了什么

这是个高频误解,必须澄清:

问题 答案
禁止本项目作为 MCP Server 对外暴露? ✅ 是的,关闭内置 MCP 端点
禁止本项目作为 MCP Client 连别人? ❌ 不是 ,业务代码照样能 import mcp 去连外部服务

它的作用域是「本服务的对外暴露方式」,管不到你业务代码内部。

企业为什么常这么配?

  • 安全:MCP(尤其 STDIO 模式)源于本地开发场景,内网随意暴露接入面不可控;
  • 标准化:微服务间调用仍是 REST / gRPC 主场,监控、限流、熔断生态成熟;
  • 职责单一:这个服务定位是「业务执行引擎」,对外暴露交给 API 网关。

八、生产环境的真相:90% 是「单大脑 + 强工具」

8.1 Multi-Agent 为什么在企业遇冷

问题 说明
延迟与成本 A 思考 → B 思考 → C 思考,Token 翻倍,用户等到超时
幻觉放大 A 的幻觉传给 B,B 基于错误信息继续推理,错误被逐级放大
运维噩梦 出错时难以定位是哪个 Agent 在哪一轮做了错误决策
不可控 无法保证最终结果符合业务规范

而单 Agent + 丰富 Tools:日志链路清晰(输入 → 思考 → 调 Tool → 返回 → 总结),复杂逻辑下沉到代码里,用代码的确定性锁死 LLM 的概率性。

再加上现代模型原生 Function Calling 已经很强,一个上下文里精准调度十几个工具完全没问题,不需要再套一层 Manager Agent。

8.2 那剩下的 10% 在哪

真正用多智能体自主协作的场景,通常具备这些特征:容错率高、对延迟不敏感、无严格合规要求。

  • 自动化代码生成与自我修复(写码 / 跑测试 / review)
  • 长篇创意内容生成(需要不同角色设定碰撞)
  • 研究探索类项目

8.3 一个务实的提醒

企业里所谓的「子智能体」,在代码层面往往不是一个独立 Agent 实例,而只是一个封装好的函数,内部调了一次 LLM 做抽取或判断。

企业需要的不是「全自主智能体」,而是「能被 AI 赋能的、具备强一致性与可审计性的业务系统」。


九、总结:架构铁律清单

9.1 分层架构

text 复制代码
┌──────────────────────────────────────────────────────┐
│ 应用接入层                                            │
│ 统一对话框 + 快捷入口卡片 + 独立审批中心                │
├──────────────────────────────────────────────────────┤
│ 决策与路由层                                          │
│ 主 Agent(单大脑):意图识别 → 路由 → 调工具 → 总结     │
│ 规则/轻量分类优先,LLM 兜底                            │
├──────────────────────────────────────────────────────┤
│ 能力执行层                                            │
│ RAG Tool │ 业务 Graph(注册中心) │ 子智能体(探索类)   │
├──────────────────────────────────────────────────────┤
│ 基础设施层                                            │
│ Checkpointer(Postgres) │ 待办表 │ 消息队列 │ API 网关   │
└──────────────────────────────────────────────────────┘

9.2 八条铁律

# 铁律
1 不要为每个业务写一个 Agent 类,用 1 个引擎 + N 个图定义
2 固定流程封装成 Tool(内部是 Graph),开放探索才交给子智能体
3 生产环境 90% 是「单大脑 + 强工具」,别迷信 Multi-Agent
4 Tool 内部不能 interrupt,需要审批就拆成 Graph 节点
5 含 interrupt 的子图要作为 Node ,不能作为 Tool 里 invoke
6 100 个业务用注册中心按需加载,不要全塞进主图节点
7 StateGraph 是蓝图,.compile() 才是引擎;Agent 就是带环的图
8 自定义业务图完全可以调工具,节点函数里直接调即可

9.3 一句话收尾

Graph 管流程控制(含中断与恢复),Tool 管具体执行(原子操作)。

用代码的确定性锁死 LLM 的概率性,才是企业级 Agent 的终极形态。


写在最后

这套架构不追求「看起来更智能」,追求的是:流程可控、状态可查、断点可续、故障可修。

相关推荐
得物技术35 分钟前
从研发经验到团队知识:Akashic知识工程实践|得物技术
数据库·程序员·架构
Cosolar39 分钟前
从 50ms 到 3 分钟:淘特动线 Agent 如何把 LLM 塞进一个有预算约束的实时系统
人工智能·后端·agent
Cosolar1 小时前
拆开「研发数字人」:一个 Agent 系统真正的护城河,是被结构化的判断力
人工智能·后端·架构
艾莉丝努力练剑1 小时前
【QT】系统相关:TCP的API介绍
开发语言·前端·c++·人工智能·qt·学习·tcp/ip
AI英德西牛仔1 小时前
智谱清言导出word指令失效?PC端深度用户正在用“AI导出鸭”重构内容归档流
人工智能·重构·word·excel·deepseek·ai导出鸭
安心联-车辆监控管理系统2 小时前
以事实为基础,详解车辆主动安全相关功能
大数据·人工智能·安全
BioTender2 小时前
OpenAI 发布 BioBasicsBench:GPT-6 开始接受真实湿实验数据的检验
人工智能·ai制药
AAA修煤气灶刘哥2 小时前
一个人用 Agent 写代码,和整个团队一起用,差在哪?拆解腾讯 LoopForge
架构