企业级 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)
- [坑一:在 Tool 函数内部 `interrupt()`](#坑一:在 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 子智能体的三个触发条件(满足任一即可)
- 需要自主规划路径:「分析为什么上月销售额下降」------先查库、再查竞品、再查客服记录,顺序无法预先写死。
- 需要独立的多轮上下文 / 长期记忆:面试助手要追问、要记住前面的回答,且不能污染主对话。
- 任务大到需要拆解委托:写行业报告 = 研究员收集 + 写手成文。
3.4 Tool(封装 Graph)的三个条件(建议全满足)
- 流程是 SOP,步骤固定;
- 需要强合规与审计;
- 追求低延迟低成本(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 的终极形态。
写在最后
这套架构不追求「看起来更智能」,追求的是:流程可控、状态可查、断点可续、故障可修。