铃阅
❌

普通视图

昨日接收 — 2026年11月16日 ⏭ AI大模型应用实践

你的 Agent 真的需要本体吗:深度拆解这 4 类轻量级的业务语义层方案。

2026年11月16日 09:00

原创 秋山墨客 2026-11-16 09:00 江苏

深度解读:你的 Agent 真的需要本体吗?

点击上方蓝字关注我们

在上一篇《从腾讯 DataBuddy 看企业级 Data Agent 设计:架构、本体与语义层》中,我们展示了如何借助统一的指标语义层,来提升分析型 Data Agent 的业务理解能力与准确性。

而说到语义,自然离不开火热的本体论(Ontology)。但要警惕的是:

语义不等于本体;Agent 需要理解业务语义,也并不代表要建设本体。

所以在尝试本体之前,我们首先要弄清的是:

你的 Agent 到底是需要一个基于语义网的重量级本体,还是只需要一些更轻量级的业务语义层解决方案?两者的工程代价天差地别。

本篇就来说说这个问题。

本文所探讨的“语义层”是广义上的抽象 - 凡是位于底层数据/系统之上,能够为 AI Agent 提供业务解释、助其理解业务规则与数据的抽象层或基础设施,均属于本文所说的语义层范畴;而非限定于 BI 语境下的“指标语义层”。

PART 01

理清概念:本体与轻量级的语义层

在 Agent 出现之前,构建传统的企业应用时,会有懂业务的人员来帮助补全业务知识。比如,财务上认可的收入是什么、什么是活跃客户、满足什么条件的客户允许订单加急,等等。

但 Agent 的核心特点是自主规划与任务推进 — 这意味着不再有人替它兜底。Agent 必须自己通过机器可读的信息去理解业务概念、调用 API、查询数据,并作出合理判断。

那么就需要一种手段,给 Agent 补齐这层缺失的“业务地图”,让 Agent 理解企业内复杂的业务与数据。

这就让“本体”再次火热了起来。

重量级的本体方案

通常所探讨的本体,是指一种基于形式化标准定义的、机器可读的业务领域说明,涵盖业务概念(实体)、属性、关系、分类层级以及一些逻辑公理、约束与业务规则。

比如,表示一个银行业务的典型概念和关系:

这份“业务说明”将被用来指导 Agent 理解深层业务关系、推导隐性知识、执行确定性的规则判断等。

再看一个更具体的案例:

我们用本体来表达“企业是客户的一种(继承关系);客户可以下订单;账户用来给订单付款;个人客户的订单不能加急(约束规则)”这样的业务定义;而业务数据库则存放了“张三下了订单0001”、“张三是个人客户”这样的事实。

那么当 Agent 收到加急申请时,就可以从数据库查出事实“注入”本体推理机,它就能自动给出“张三的订单不能加急”的确定性结论和依据。

【技术与工程代价】

本体通常依赖 RDF 三元组库、OWL 语言、SPARQL 图查询语言、SHACL 规则校验器、GraphDB 图数据库等来实现(或 Palantir Foundry 这类专有底座)。

本体工程代价较高,特别在前期,需要知识工程师、业务专家、系统架构师等投入大量时间做业务抽象建模、规则验证、解决冲突等。

轻量级的语义层方案

如果你在构建一个企业级 Agent,用来查数、自动调接口或回答咨询,为了防止 AI 臆造参数或搞错数据,大概率你只需要一个结构清晰的接口/数据层 Schema,再加上一些业务知识文档。

这就是一种轻量级的语义方案 — 不需要晦涩的 RDF、OWL、图数据库。

当然,这种方案之所以“轻”,在于它是按需定制,而非一套通用的业务模型。但通过这些轻量工具的组合,也能让 AI 懂业务、并有效减少幻觉。

以上篇文章的指标语义模型为例,这也是一种轻量级方案:

【技术与工程代价】

轻量级的语义层方案大多可以复用团队现有技术栈:Markdown、Wiki、Pydantic、SQL DDL、YAML 等,根据实际业务按需选用,通常可以快速上线并验证,用很小的代价,获得本体的大部分收益。

为什么大部分时候你并不需要本体?

我们看一个代表性的实验。data.world 与 dbt Labs 先后在包含十余张范式化表的保险公司业务模拟数据库上,针对高管的复杂业务问答进行了多次基准测试。

结果如下:

  • 2023年,GPT-4直接查询原始数据表时,回答正确率仅 16.7%;而如果将相同的数据表示为知识图谱,则正确率可达54.2%。

  • 2024年,添加了一个基于本体的检查与修正机制,结果显示,正确率达到了72.6%,另有 8% 的答案是“我不知道”,约 20% 回答错误。

  • 2026 年,使用 Sonnet 4.6 和 GPT-5.3-Codex 这两个模型再次测试。直接查询的准确率在两个模型上已经达到 64.5%;而增加轻量语义层后升至 72.7%;随后,测试团队仅仅添加了3张用于组织业务数据的中间表,再结合轻量语义层,准确率就飙升到98.2%甚至100%。

所以,有几个原因决定了我们大多数时候并不需要重量级的“本体”:

  • 重型本体的工程复杂度与维护周期难以承受:庞杂的协议栈(RDF/OWL/SPARQL/SHACL等)、跨部门的业务协调、漫长的验证周期

  • 大量的日常 Agent 场景用不上深层逻辑推演:智能咨询、串起 CRM/ERP 的自动化流程、代码 Agent 等,大部分 Agent 的痛点远没有达到“需要跨越 N 层概念去理解未知的关系和规则”的程度,轻易的上本体,就是杀鸡用牛刀。

  • 大模型自身理解与推理能力的飞跃:当前主流大模型的多步规划与上下文推理能力已经非常强,很多时候你给出干净的数据、清晰的 Schema 和业务文档,大模型会自己完成很多逻辑关联 — 无需借助沉重的符号推理机。

当然,这不代表本体没有存在的意义,我们会在最后一节阐述。

PART 02

轻量级的业务语义层方案

既然轻量级路线能够以低得多的工程成本让各类 Agent(问答、自动化流、编程、分析等)读懂业务,那么在实际落地中具体的方法有哪些?

本章为您梳理几种最核心的工程方法。注意,这些方法并非什么新技术,也非互斥的单选题,你需要根据业务痛点做组合。

方案一:知识库、图谱与规则引擎

这是最直观、最容易落地的一种业务学习方式:直接用文档、知识图谱、传统规则引擎等,把业务知识“教”给 Agent。

很多时候,业务语义本质上就是一套业务背景、经验与规则,而这些完全可以用一些轻量的方法来实现。

  • 业务知识库(Wiki 等):按主题分层整理概念、指标、经验与各种 SOP(标准操作流程)等。这种形式极便于业务人员直接参与维护,可读性强。

  • 传统规则引擎:本体经常宣传的是“确定性规则推导”。但很多场景中,传统的基于规则表达式或决策表的规则引擎,同样能实现确定性的逻辑判定。

  • Agent 技能(Skill):每一个封装良好的 Skill 本身就是一个内聚的“知识胶囊”。它把特定场景下的业务知识、操作流程、判断规则等打包在一起,Agent 加载 Skill 就自带了业务上下文 — 无需再去查本体。

【场景举例】

比如, Agent  需要处理“大客户订单加急与自动改单”的自动任务:

整个过程借助知识库 + Skill + 规则引擎,也能够让 Agent 遵守业务规矩。

【适用性】

这种方案适合智能问答类 Agent、整合现有应用实现自动化的 Agent(自动审批、工单流转)、内容与报告创作类 Agent,辅助编程 Agent等。

尽管知识库的组织、高效检索与规则维护仍有大量优化空间,但相对本体,这是一种更务实易行的方法。

【技术与工具】

  • 检索与图谱:传统 RAG、轻量级 GraphRAG(如 GraphRAG、LightRAG)

  • 规则与技能: JsonLogic、zen-engine、Drools 等开源规则库、Skills

方案二:Schema、业务词典、类型验证

当你的 Agent 需要与数据库或微服务 API 打交道时,一个基本的方法是:

通过对已有数据或接口的协议、结构、字段类型、主外键关系、甚至枚举值等做声明,让 AI 能够理解它们的用途。

常见的就是数据库 Schema、JSON Schema,它们本身可以承载丰富的约束与注释,自然也拥有了一定的语义能力。

但仅有结构,通常不足以消除歧义。

  • 一方面,同名概念在不同部门可能含义不同 — 比如“签约客户”究竟代表合同主体,还是实际使用产品的主体?这需要补充“业务词典”,明确术语定义、别名、适用范围及上下位层级关系。

  • 另一方面,很多企业遗留系统里往往充斥很多晦涩的物理缩写,比如 tuserdatanew,indata1等。如果直接把裸表或裸接口甩给模型,Agent 基本就是瞎猜,此时可以引入一些强类型验证的手段,让错误提前暴露。比如引入Pydantic 强类型验证模型:

    • 将底层缩写映射为语义清晰的业务字段,在代码的 Field(description="...")中内嵌业务语义说明与合法枚举值

    • 在 Agent 调用入口处强制类型校验 — 一旦模型推理错了字段或臆造参数值,就会在访问真实数据或 API 前被拦截,从而获得纠错的机会

【场景举例】

假设你的 Agent 需要判断“有多少签约客户买了软件”:

概念分类树可以帮助确定产品范围;而业务词典用来理解“签约客户”的含义;再加上数据库 Schema 负责映射到具体的表字段;外层的 Pydantic 模型则负责在执行之前校验查询参数(比如日期格式):

【适用性】

从上面的方案能够推测出,它比较适合以下场景:

  • 高频调用内部应用 API 的任务执行型 Agent

  • 结构化信息抽取与表单自动填写的 Agent

  • 通常查询固定字段与稳定表关系的轻量级数据问答 Agent

【技术与工具】

  • 代码级类型校验:Python 生态的 Pydantic、TypeScript 生态的 Zod

  • 数据与 API Schema:SQL DDL、JSON Schema 定义

  • 业务词典与分类标准:这个可以自定义,也可以借助 W3C 的 SKOS(简单知识组织系统),用于标准化描述概念术语及上下位层级(如定义“集团客户”是“客户”的下位概念),未来也可平滑演进为本体的一部分。

方案三:分析(指标)语义层

在 BI 报表 和企业 Data Agent 场景中,如果让大模型直接面对上百张底层数据表,自由编写 SQL,极易出错且不稳定。

一种标准的工程方案是构建独立的分析语义层:

一个位于数据仓库之上、将核心指标、分析维度、表映射与访问权限等集中定义的“度量标准化与SQL编译层”。它通常需要明确:指标的业务含义、计算公式、统计对象、时间字段、分析维度与数据粒度等。

详细的原理与技术可以参考我们上一篇文章,这里我们略过。

【场景举例】

例如,这是一个“月度订购总额”的标准化指标定义:

现在,运行时 Agent 不再从零手写裸 SQL,而是先根据问题选择相关的指标(不一定能直接回答问题)、确定过滤条件、分组维度等;再交给语义查询引擎确定性的编译成数据层查询语句(如SQL);由数据层执行计算。

在问数场景下的另一个实用的配套方法是数据查询视图(SQL Views):

通过视图预先把复杂的跨表 JOIN、隐含的过滤规则、基础计算公式等封装成更干净的“虚拟表”,并将晦涩的物理列名用直观的业务术语暴露给 Agent。

这种分析语义层的核心前提是要确保指标模型与视图被正确建模:若底层的主外键关联或聚合粒度定义有误,依然会导致计算偏差。

【适用性】

专为企业级 ChatBI/经营问数 Agent、财务 KPI 核算、多维归因分析以及自动化数据洞察生成 Agent 打造,核心是解决数据计算确定性与口径一致性问题。

【技术与工具】

很多数据智能供应商都有着自己的解决方案。推荐一些技术与工具包括:

  • MetricFlow 与 Cube :YAML 定义指标;语义查询引擎负责编译 SQL

  • Malloy:Looker 创始人打造的一套开源完整的数据建模与查询语言

  • 腾讯开源的 SuperSonic 项目:一个轻量级、较完整的分析语义层项目

  • 蚂蚁 AntV 团队的 AVA 框架:提供了针对字段的轻量语义标注、数据统计特征提取与智能洞察推荐能力(API),适合生成轻量级的语义上下文并注入给数据可视化分析的 Agent

方案四:元数据目录与血缘图谱

当企业内部的数据表成千上万、微服务与 ETL 加工链路盘根错节时,很多 Agent 面临的首要问题往往还不是业务,而是“哪张表才是权威数据源”,或者“修改这个数据字段会影响到哪些报表和接口”。

此时,我们需要构建的是元数据目录与血缘图谱:

  • 元数据目录:把分散的物理表、字段注释、ETL 任务、BI 报表、微服务接口、业务术语标签、数据质量评分以及资产负责人统一登记,形成可检索的企业数据资产目录(类似”黄页“)。

  • 血缘图谱:通过解析 SQL 日志、集成脚本与服务调用关系,把数据从哪个源库产生、经过哪些任务、最终流向哪里,组织成一张图谱(简单依赖可用映射表记录,跨系统、多跳则采用图结构存储)。

元数据与血缘图谱的绝大多数信息可以从现有系统借助工具和 AI 提取生成,不仅能帮 Agent 快速“寻源”,还可以与业务词典和分析语义层配合应用。

【场景举例】

比如,你的数仓里可能有 8 张名字都包含 customer_orders 的表(其中很多是历史遗留或个人测试表)。Agent 可以通过查询元数据目录中的信息(比如数据新鲜度、近期查询热度等),快速锁定核心的生产表。

再比如研发团队打算把底层表中的“支付金额”字段单位从“元”改为“分”。借助本方案,辅助的 Agent 可以快速列出需要复核的脚本和报表,并通知做改造。

【适用性】

这种方案适合数据工程的辅助 Agent 、企业数据治理 Agent 、以及在超大规模数仓中需要首先精准查表的复杂分析型 Agent。

【技术与工具】

  • 标杆是 DataHub(LinkedIn 开源的元数据与上下文平台):采用元数据图谱(Metadata Graph)架构,并针对 AI Agent 强化了上下文管理与检索能力,让 Agent 可以方便的查询数据资产与血缘关系。

  • 其他的项目推荐:OpenMetadata(数据资产目录管理)、Apache Atlas(元数据建模与大数据治理),OpenLineage(运行时血缘上报与采集的标准)。

PART 03

架构抉择:如何选择合适的方案?

在了解了这些不同的方案组合后,一个更现实的问题是:

我应该如何在这些方案间做抉择?而什么时候又应该考虑真正的“本体”呢?

一个建议的选择策略是:

兼顾交付速度与长期维护成本,默认从最简单快速的方案(组合)起步,随后按需扩展到复杂的方案。

我们把上面的方案做成一个三级阶梯图:

Level 1|结构契约与知识底座

用业务词典、Wiki/Skill、SQL 视图等,说清业务术语、查询口径、业务处理步骤与参数约束等,支撑常规问答、查数和自动化流程。

Level 2|统一指标与数据资产治理

当你面临的痛点转向跨部门口径不一、复杂的多维数据分析、海量数据资产管理和追踪时,考虑引入指标语义层,以及元数据目录与血缘图谱。

Level 3|共享本体模型

当多个系统需要共同维护一套业务语义与规则、需要复杂推导结论时,再考虑本体 — 先从核心业务域开始,看到收益、积累经验后再拓展。

最后总结成一个决策的“速查表”(实际应用中,仍然需要结合你真实的 Agent 需求做细分判断,不可生搬硬套):

痛点与业务特征

是否需要本体

首选方案

制度问答、SOP 自动化、异常经验判断

通常不需要,优先 Level 1

Wiki/RAG + 轻量规则引擎 + Skill

字段缩写晦涩、API 传参报错或越界

通常不需要,优先 Level 1

Schema + 业务词典+ Pydantic

跨部门BI报表与KPI核算、复杂 JOIN 问题

通常不需要,优先 Level 2

SQL 视图 + 分析语义层

海量表中寻找权威源、评估字段变更影响

通常不需要,优先 Level 2

资产目录 + 血缘图谱

跨系统概念分类与组合推理、异构库虚拟整合

可评估 Level 3 形式化本体

OWL + 推理机;按需结合 SHACL 校验等

业务状态冲突检查、跨系统受控操作与写回

可评估 Level 3 操作型本体

状态推理机、Palantir式操作型本体

以上探讨了构建广义“业务语义层”的几种轻量级方法,也梳理了我们对“本体”热的一些思考。

归根结底,业务语义层的价值在于帮助 Agent 理解业务、消除歧义,并提供明确的业务契约,支撑它在企业场景中可靠运行。

对多数 Agent 场景和团队而言,轻易的投入重量级 RDF/OWL 本体建设,可能带来超出期望收益的工程负担。

特别是在 AI 技术日新月异的今天,先用轻量级方案,以较小的投入尽快收获实战价值,再按需拓展,或许是更务实和明智的选择。

Image

感谢阅读,交流与合作请后台留言

喜欢就关注哦

Image

动动小手点个赞

Image

点在看最好看

Image

跳转微信打开

从腾讯 DataBuddy 看企业级 Data Agent 设计:架构、本体与语义层。

2026年11月9日 09:00

原创 曾经的毛毛 2026-11-09 09:00 江苏

构建业务语义层,让大数据 Agent 从演示走向真正可用。

点击上方蓝字加入我们

自从大模型诞生,其在大数据领域的应用一直被寄予厚望。特别是如何让决策者能够跨越技术鸿沟,快速地问数与分析,而不是等待技术部门的加班结果。

企业级的分析型 Data Agent 的代表性方案是 NL2SQL(自然语言转 SQL) — 但行业知识门槛、复杂的数据模型与分析需求,都会让 LLM 的幻觉率极高。

本篇将站在腾讯的 DataBuddy 这款 Data+AI 产品的“肩膀上”,探讨企业级数据 Agent 系统的架构设计,特别是业务语义层在 ChatBI 这类场景的应用。

01

DataBuddy 能力与架构初探

DataBuddy 是供企业数据团队与业务人员共同使用的大数据 + AI 云端工作台。在这个工作台,数据团队可以准备好各类数据源;定义业务模型、指标与口径;业务人员通过自然语言对话做问数与分析 — 所有这些工作,都有 Agent 的辅助。

三个层次看架构

如果抛开 DataBuddy 一些绑定腾讯云设施的部分,它的核心架构具有一定的普适性,大概长这样:

文章插图 1

  • 业务交付层

提供了面向不同角色的具体任务能力 — 由对应的工程、治理和分析 Agent 做 AI 赋能,可以执行数据集成工作流,开展数据质量治理,提供交互式分析能力。

  • 能力平台层

负责多层数仓的加工与创建(从 ODS 到 DW 的各级明细与汇总)、数据资产的目录管理。这一层还有一个重要的任务,也是本文关注的重点:业务语义层 — 包括业务本体和数据指标、维度、血缘关系等语义的定义。

DataBuddy 中用“本体”定义业务对象、属性及关系;用“语义模型”定义业务指标等。两者都表达语义,侧重点不同。本文将两者统称为“业务语义层”。

  • 存储计算层

负责保存原始数据和提供批量计算引擎 — 来自于企业生产系统的各种形态的数据,RDBMS、NoSQL、SaaS、消息、事件、文档等等。

  • 身份与权限

借助数据安全标签、风险识别、SQL 防护、身份管理与授权、Agent 跟踪审计等手段,实现企业级数据的纵向防御。

理解架构中的三类 AI Agent

我们更关注 AI 在整个架构中的角色与职责,它们代表了典型的大数据系统中的三类常见任务:

  • 数据工程 Agent:数据的加工、集成与开发

涵盖数据同步、增量接入、SQL 架构、数据工作流的开发与定期执行。如原始数据的清洗与标准化;主题事实数据生成与汇总;定时的数据挖掘模型更新。

  • 数据治理 Agent:发现数据质量等问题并修复

通过唯一性校验、数据剖析、血缘分析和分布变化检查发现数据质量问题并处理。比如,检查重复数据、数据更新的一致性、数据同步的及时性等。

  • 数据分析 Agent:把自然语言提问变成分析结果

结合业务语义层的模型、LLM 的推理能力、数据分析 Skill、确定性的代码与工具等,将自然语言的分析要求转化成数据层可以执行的查询语句,并执行。

这里的数据分析 Agent 是我们关注的焦点。特别是如何借助业务语义层来控制传统 NL2SQL 方法的语义幻觉、口径混乱等问题。

文章插图 2

腾讯:有语义层与无语义层的准确率测试结果

02

本体与语义模型如何让 AI 分析更准确

我们用 DataBuddy 中的一个电商零售行业智能体来做测试,研究本体与语义模型是如何参与到 Agent 的分析任务中 — LLM 负责什么、语义层又是如何参与、整个任务过程是怎样展开的。

先看下业务本体的定义,大致关系如下:

文章插图 3

同时,定义了一个面向卖家经营与品类表现分析的语义模型:

文章插图 4

那么,现在有一个简单的分析问题:

2016 年 9 月至 2018 年 10 月,平台每月的 GMV 和订单数分别是多少,整体呈什么走势?

传统方法,AI 为什么容易出错

上面问题如果直接交给大模型,当然有可能回答正确,但也有很大概率会出错,这来自于一些潜在的问题:

  • 口径歧义:比如 GMV 是否计入运费、哪些订单状态参与统计?

  • 时间条件歧义:比如按月统计,那么是按照下单日期还是送达日期?

  • 多种问法的归一:交易额、销售额、GMV 是一个东西还是三个东西?

  • 其他可能的错误:比如把订单与商品明细 JOIN 后导致重复计算。

这就会导致潜在的不确定性:

同一个问题多次提问,可能会得到完全不同的答案。

DataBuddy 如何把问题变成确定性的结果

根据我们的测试,可以把 DataBuddy 的处理过程拆成这样的步骤:

其做法是:

借助 LLM 的理解能力,把自然语言问题通过语义层(本体与语义模型),找到相关的指标、维度等;并生成一种语义“SQL”语句,再通过工具将其转化为数据层的物理 SQL 并执行;最后由 LLM 对执行结果做分析、总结与可视化。

以下是详细的步骤解释: 

1. 意图解析,识别其中的候选概念和要求,例如“GMV”“订单数”“月度统计”,以及时间范围等。

2. 获取相关的业务本体定义,借助本体理解:企业如何定义“订单”,订单与商品之间有什么关系、哪些名称实际指向同一个业务概念等。

3. 读取语义模型的定义,获得企业已经发布的 GMV、订单数等指标清单,核对其具体定义。比如“GMV”指标,从下图你可以有更具体的认识:

文章插图 6

LLM 根据需要,选择到相关的业务指标、确定统计维度等。

4. 此时,如果指标定义中还有需要解释的业务条件,比如用户要求同比、环比、贡献分析等,LLM 还可以调用知识查询工具,获取相关的指南和约束。 

对于更复杂的分析需求,如果仍然存在缺失条件或者会影响结果的歧义,还可以通过用户澄清、扩大知识库查询等做进一步消除。

5. 现在,LLM 已经把用户的意图对应到明确的企业业务含义,并确定了本次要使用的指标(GMV、去重订单数)、统计粒度、时间范围和筛选条件等。

这时候需要“语义 SQL 查询工具”出场,它的作用是把类似这样的查询:

编译成数据层可执行的确定性查询语句(比如 SQL),并提交执行,获得结果:

文章插图 7

6. 在获取到结果数据后,根据用户的分析意图,做进一步的整理、解释、报告生成、图表配置生成,完成输出。

由于有了足够的业务理解、指标口径等知识,Agent 可以给出充分的数据来源的解释,帮助用户理解数字的含义。

当然,对于复杂的分析需求,Agent 有可能要经过多次 Loop,继续调用更多次的语义模型、指标和工具,获取更多数据做进一步解读。

以上就是 DataBuddy 如何把一个自然语言的问数需求,借助业务语义层,转化为确定性的查询结果,而不是简单的 NL2SQL。

这里“确定性”的提高主要来自于:

业务含义经过本体确认,指标口径被语义模型固定。模型并不生成直接查询的语句,而是生成一种中间态的“语义 SQL“。

各个组件,分别负责什么

总结下在上面的过程中各个组件的分工:

所以,为什么业务语义层对于构建企业级的数据智能体至关重要?

  • 统一口径,让不同入口的结果能够对得上:当多个 Agent、报表和应用使用同一套指标时,用户改变提问方式,或者换一个应用,计算规则就能保持一致。

  • 集中维护业务知识,减少每次任务的临时判断:确认后的语义层可以持续复用(即使底层结构变化),Agent 可以把更多精力放在理解意图、优化流程上。

  • 让结果“可解释”,把数据访问规则落实到执行过程:系统可以保留指标版本、查询条件和执行记录,帮助准确地回答“这个数是怎么算出来的”。

03

构建企业自己的 Data Agent 系统

DataBuddy 在架构上的参考意义在于:如何借助企业受治理的业务本体与语义层,让 Data+AI 的应用能够从 Demo 真正走向生产级决策。

特别对于已经有了自己的数仓、报表与身份系统的企业来说,如果希望构建这样的 Agent 系统,把数据分析能力留在内部,你必须对此有清晰的思路。

大数据 Agent 整体架构

从一个端到端的场景链路开始:

用户从应用入口或办公智能体(如 WorkBuddy)提出问题,Data Agent(分析型)加载技能,在权限范围内读取并理解业务与相关指标,调用语义 SQL 查询工具,并转化为数仓的执行输入,最后将结果组织成图表、解释、分析报告。

基于这个场景,设计这样的系统架构:

文章插图 8

  • 数据底座

使用已有数仓或独立建设,本质上还是属于传统企业数仓层:生产系统经过同步、清洗和质量检查,形成明细、维度、汇总等主题数据层。查询引擎(分布式)承担筛选、关联和聚合,已有的数据开发与集成平台可以继续运行。

  • 业务语义服务

这是最核心的增强。保存已发布的本体、指标等语义数据(借助图数据库);结合 BM25、向量等索引,向上层提供语义模型的检索与读取接口;提供语义 SQL 引擎:将基于语义的查询转化为底层数据库的语言并执行。

  • Agent 运行层

这是 Agent 的应用层。Harness 负责管理任务状态、上下文、加载 Skills 和工具调用;LLM 提供理解、规划与解释能力,借助模型网关连接自部署模型或获准的公开模型,统一管理调用范围、配额与日志。

  • 用户交互层

前端应用层,提供交互入口并呈现结果。可以是原生 ChatBI 应用;也可以是嵌入的 Copilot;甚至可以集成到办公智能体如 WorkBuddy 中,真正让决策者无缝与 Data Agent 协作。

  • 身份、权限与审计

贯穿多层的数据安全。在应用入口验证员工身份;在语义层过滤不可见模型;在执行侧要落实可访问的数据源、甚至行列限制;并记录详细的 Trace 用于审计。

下面对架构中的几个重点做深入。

业务语义层的建设

业务语义层的核心任务可以抽象为:语义建模、模型存储与查询、语义 SQL 引擎三个部分。实际建设中,这是难度最大的部分,比较理想的方式是借助 AI 以及开源项目来降低复杂度:

  • 开发“建模 Agent”,让 AI 辅助建模

面对存量的数仓表,完全靠人工梳理本体与指标语义不太现实。因此开发一个语义建模的 Agent 是必须的,以实现这样的建模过程:

通过自动扫描(或者人工指定)数仓元数据、对象与文档,起草跨源本体的对象、关系与指标草案(比如声明式的 YAML 语义模型),然后交给人工查看、审阅甚至试运行验证;经过数据团队确认后的模型才可以正式发布上线。

这里推荐两个可学习的 GitHub 开源项目 Helix Foundry 和 Cube。

  • 模型存储与索引,提供模型召回能力

建模 Agent 发布的本体与语义模型,需要存储、索引,并发布给上层 Data Agent 使用。通常的方法是将这些模型的实体、关系、指标口径、维度定义、血缘关系等落盘至图数据库与元数据中心(数据目录)。

同时结合图遍历、BM25 关键词与向量索引等,提供统一的语义模型检索工具给上层 Agent,按任务意图召回最小的模型子集。

  • 语义 SQL 引擎

将带参数的语义 SQL 编译为数据层语言执行。这是消除大模型幻觉的关键防线:大模型不再直接生成底层语句,而是生成面向语义层的逻辑查询。比如:

语义 SQL 引擎先校验语法,再将其“编译”成目标数仓的物理 SQL 执行。

这种语义 SQL 引擎的实现可以去看另一个腾讯早期的开源项目 SuperSonic,它提供了一个从语义检索映射,到语义 SQL 生成、编译执行的完整参考实现,即“自然语言 → Semantic SQL → 物理 SQL”。

构建分析型 Data Agent

有了可靠的语义层底座,数据分析 Agent 就不再是简单地把任务交给 LLM 做 NL2SQL 转换,而应该是一个能够自主规划、学习语义、并调用工具的分析型智能体:

  • 数据分析 Workflow

一种方法是借助 LangGraph、Google ADK 这样带工作流编排能力的开发框架,构建属于自己的 Harness。

另一种方式是基于已有开源 Harness(如 DSH、Codex-Harness)做个性化,结合自定义的数据分析 Skill 与工具来完成。

无论哪种方式,上图中的核心工作流是一致的。

  • 核心的受控工具

无论查询语义层的模型和指标,还是调用语义 SQL 引擎,Agent 都需要借助工具。以下是一些主要的工具:

  • 语义召回:输入任务意图,调用语义层的检索接口,按需召回本体与指标语义的子集(实体、关系、指标口径、维度定义等);目的是避免把全量的语义层输入 LLM。实际应用中,可能还需要配合一些其他的知识库查询工具。

  • 语义 SQL 查询:基于上一步锁定的相关指标口径,结合输入任务,组装结构化的参数与语义 SQL,由语义 SQL 引擎完成物理 SQL 的编译与执行。

  • 图表渲染:根据分析任务的需要,生成并校验结构化的图表配置(如 ECharts ),并随查询到的数据与结论一起返回,交给客户端做渲染。

  • 分析沙箱:这是供 Agent 在必要的时候使用的隔离沙箱,用于对取回的数据做进一步的本地分析或挖掘(借助代码),如相关性、归因、预测等。

在办公智能体中集成 Data Agent 

把 Data Agent 能力集成到日常使用的办公智能体(如 WorkBuddy),可以更好地缩短使用路径,结合本地数据与工具,实现团队协作等。

以 WorkBuddy 为例,常见的集成方式有几种:

  • 基于 MCP 连接器实现工具即插即用

可以将语义层的指标检索、本体查询、图表生成配置、甚至 Data Agent 的分析与问数等,都封装为标准的 MCP 工具;WorkBuddy 挂载该 MCP 的连接器,可以在对话中自然调用 Data Agent 能力(需考虑身份与权限问题)做数据分析。

  • 采用 Skill + CLI 沉淀标准化分析技能

针对一些固定分析套路,比如周报复盘、漏斗归因等,也可以借鉴 Cube 项目的 cube-agent-skills,将取数规范与分析 SOP 编写为可复用 Skill,并配套轻量级的 CLI 工具,交给 WorkBuddy 按需使用(相比 MCP 更节约上下文)。

  • 利用 MCP Apps 交付数据看板

借助最新的 MCP Apps(MCP-UI 标准扩展),可以实现“带 UI”的 MCP 工具:后端的 Data Agent 直接向 WorkBuddy 返回运行在沙箱 iframe 中的交互式前端UI;用户在 WorkBuddy 里能直接看到可视化分析结果并做交互探索。

04

总结

以上是我们对自建 Data Agent 架构的简单设计与关键技术思考。当然,在实际建设中,都需要根据现有系统的状态、数据分析的真实需要、自身的技术能力、投入成本、部署条件等,综合衡量,选择最适合自己的方案与技术。

最好从一个受控范围开始,比如客户与订单经营这样的数据相对完整的业务域,建立起最核心的业务语义层,并把相关的问数与分析能力做到最佳。

在累积了足够的经验、看到收益后逐步扩展:扩大建模范围,增强 Agent 能力,最终构建出真正“懂业务”的企业级 Data + AI 智能体系统。

Image

感谢阅读,交流与合作请后台留言

喜欢就关注哦

动动小手点个赞

点在看最好看

跳转微信打开

拆解与体验 DeepSeek Super-agent 架构:从个人助手到主动工作的团队伙伴

2026年11月2日 08:30

原创 曾经的毛毛 2026-11-02 08:30 江苏

详解 DeepSeek 新发布的 Super-agent 架构。

点击上方蓝字加入我们

主流的编程 Agent 与模型已经具备极强的任务交付能力,但在企业团队开发环境下,或许你会有更高的期望。想象下这些场景:

开发同事在群里提需求,测试者在 GitHub 上建 Issue,评审反馈 PR 问题 — 这些都能被一个 Agent  ”伙伴“看到,并按需生成任务,持续推进,并在合适的渠道给你反馈。

DeepSeek 最近发布的 Super-agent 设计和原型插件,关注的就是这件事:

一个能够真正放进开发团队、随时在线、主动响应的编程 Agent — 自动组织任务、会话和上下文,让团队少做搬运和催办,把注意力留给决策与验收。

一、Super-agent:始终在线的团队 Agent

企业的团队协作开发中,一件事很少能在某个开发者的一个对话里结束。

某个改动要求可能最开始出现在群聊,开发时有人再补充个边界,代码提交后又会收到来自 Review 的意见。与此同时,某一个 Issue 又在等修复.....

每件事都有自己的进度,也都可能被一条新的消息推动。

一般情况下,这些工作会交给多个 Agent:辨别优先级、依赖关系、加补充说明、提醒它继续,再把结果反馈给团队讨论的地方。任务越多,需要记住的细节也越多。

而且,这些 Agent 会话上下文不共享 — 会话关闭、上下文压缩,或者换一位同事接手,之前的决定可能又得解释一遍。

DeepSeek Super-agent 针对的,正是这层持续的任务组织与协同工作。

团队继续使用群聊、GitHub Issue 和代码评审继续使用,Super-agent 则负责在后台发现任务,把新任务交给合适的执行者;每个任务有自己的工作上下文和 Worktree;一个任务在进行,其他任务仍有机会继续;任务完成后,也会反馈结果给团队。

团队通过飞书和GitHub与Super-agent协作,后台分别处理修复、评审和测试任务

用一个场景举例说明:

字体设置从群聊需求进入GitHub代码评审,修改同一PR后把结果回到群聊

  • 产品同事先在飞书群里提出:软件正文、代码和终端的字体,希望分别配置

  • 维护者在原飞书话题中 @Super-agent,请它实现

  • Super-agent 接到消息、评估、启动任务、修改代码,提交 PR,反馈到群里

  • 同事可以接着 PR 进行追问,Super-agent 也可以自动回答

  • 设计师对 PR 实现提出建议,要求调整设置的布局

  • Super-agent 识别并沿用已有的需求做改动,合并 PR,并通知到群内

在这段协作发生时,另一个执行会话可以修复某个系统 Bug,第三个会话也可以做接口测试 — 它们共享必要的项目背景,但各自保存任务细节。

团队不需要给每个会话补充需求讨论细节,也不用因为一个任务耗时暂停其他工作。

Super-agent 就像团队里面一个随时在线、工作主动的小伙伴:

记住谁提出了什么要求、哪些技术决策已经确定、代码改在哪里、还在等谁的反馈;并负责把开发者们分散的问题接入,形成工作任务,并持续推进完成。

二、整体架构:协调(路由)器 + 执行器

作为团队“一员”的Super-agent,需要应对来自不同渠道的连续交互与多任务的高效处理,这需要基础架构的改进 — 不能是单一会话的排队处理,也不能简单的一对一的派生新会话。前者虽然上下文最连续但效率太低,后者并发能力强但资源占用大,且会话之间太割裂。

Super-agent 用两层逻辑架构与职责组织这个流程:

  • 协调(路由)层:承接外部消息(GitHub/飞书等),判断该接什么任务、交给谁

  • 执行层:负责在隔离上下文中执行具体任务,修改代码、测试、验证

两层之间通过任务“工单”连接,工单保存任务身份和授权依据等;执行会话则持有任务所需的上下文。

消息先检查来源范围,已订阅讨论直达所属执行会话,新工作通过准入后由主会话协调,持久状态支撑过程

参考 DeepSeek 官方介绍与原型实现,其整体流程大致为:

  • 入口检查来源范围,属于已讨论的补充(比如已处理的工单),就送回原任务

  • 否则检查发起人与“接单”规则,主会话安排工单、分派执行会话和工作目录

  • 执行会话处理“工单“,报告进展,系统保存结果,再将答复送回合适的对话

单个工单可以经历多轮执行,可以关联多个讨论事件(比如,围绕“字体独立配置”的多轮讨论);这样换一轮执行,不需要重新定义需求和补充上下文。

这套架构与我们熟知的“编排者+工作者”的 Multi-Agent 模式很相似。但 Super-agent 对协调层的定位更“轻” — 一般不介入单个任务内部的拆解;而 Multi-Agent 中的编排者更专注“将复杂任务拆给多个 Agent 并协调它们完成”。

三、五个设计要点

现在来关注 Super-agent 两层架构背后一些更具体的设计细节(有可能在未来 DeepSeek 正式产品中出现变化):

1. 两层架构:是逻辑分层,并非物理限制

需要注意的是,Super-agent 的两层架构是逻辑分工,并不一定是单个 Agent、单个Session。比如,一个复杂任务工单的执行,完全可以由一个 Agent + 多个 Subagent 的Agent Team 来完成 — 执行器内部仍可派生并调用 Subagent 以拆解复杂工作。

即使是很轻的协调层,在输入事件量较大可能导致拥堵时,也可能需要切分成多个协调器,牺牲连续性,提高吞吐量。

2. 事件驱动:核心是过滤和路由

群消息、GitHub Issues 评论、PR 和自动 CI 的结果,都可以转成 Super-agent 的事件。很显然,这些事件不必全部转成真正的任务,所以首先需要的是过滤。

过滤可以分为确定性的规则过滤和语义过滤:

  • 对来源、身份、群机器人白名单等确定性条件先由程序检查。

  • 程序检查后的候选事件,交给 LLM 做语义过滤 — 规则来自提示词定义的策略。

如果说过滤解决“是否进入任务流”,路由则解决“由谁继续处理任务”:

哪些是已处理任务的后续消息,可以直接送回负责该工单的执行器;哪些需要派生新的工作任务交给执行器来处理;哪些是没有工作价值的日常讨论,应直接忽略。

“话题续接“:

一个 Issue/PR或群聊话题下的连续消息构成的事件流被称作 Thread;同一 Thread 的后续事件会被直接送到已订阅该 Thread 的执行会话(Worker)。

3. 异步执行循环:长工具不占住整段对话

一次任务的执行,通常是一次 Agent ReAct 循环:推理、调用工具、观察结果、继续推理,即每次需要等待工具执行完毕,才会进入下一次推理。

那么这里的问题是,较慢的工具调用会阻塞对后续用户消息的响应 — 比如,上一次提出的修改需求正在处理中,此时用户又补充了某个消息,此时会话就无法响应。

DeepSeek Harness 目前其实已经内置了针对这种情况的“异步 ReAct”任务机制:

ReAct 循环启动工具后立刻返回,不再等待完成;工具执行完成后,再把工具结果作为新事件送回会话即可。

这样就解决了会话被长工具调用卡住的问题,更快的响应用户输入。

4. 按需组织上下文,让会话能找回完整事实

作为一个服务于团队不同任务的 Agent,管理好任务的上下文至关重要。

Super-agent 上下文管理的整体策略可以概括为:

不让每一个会话窗口永远装着全部历史,而是将近期相关内容直接放入窗口,而把长日志、完整报告等低频信息留在窗口之外,并保留摘要与引用。在需要细节时,模型沿消息、事件链(Thread)、执行会话等之间的关联关系,顺着引用展开更多上下文。

这样既减少重复塞入长上下文,也让压缩后的会话仍有机会回到原始记录。总体上有点类似一些 Memory 产品机制,但管理上更复杂。

5. 分离计算、状态和环境:重启才有依据接续

如果将本地 Agent 作为 Super-agent 接入团队,一个面临的问题是一旦设备离线, Agent 就会停止运行。那么如何让 Super-agent 持久在线? DeepSeek 提出的方法是将 Agent 的计算、持久化状态、工具等执行环境做分离。其设想是:

  • Agent Loop(推理循环) 运行在云端的无状态容器中

  • 持久化状态(任务进度、消息等)存入数据库

  • 工具调用执行(Git 访问、写文件、回复消息)则放在端侧

四、实践:把 GitHub 和飞书接到同一个 Super-agent

以上是 DeepSeek 对 Super-agent 的架构设计,目前尚未完全产品化。但 DeepSeek 发布了一个轻量级的原型项目,我们可以借此一探未来的 Super-agent。你可以在 GitHub 搜索 dsh-superagent-prototype 项目(基于 DSH 的插件)。

我们用这个项目做简单演示:

步骤 1:让 AI 按官方说明安装配置

官方项目的 SETUP.md 是面向 Agent 的部署指南,所以我们可以让 AI 帮忙部署,并给出明确的说明,剩下的就交给 AI 吧。比如:

请按 dsh-superagent-prototype 的 SETUP.md 部署。
使用独立的 superagent 配置,保留我已有的环境。
接入我的 GitHub项目 pingcy/xxxxx 和专用飞书测试群。
先检查依赖、模型和账号;安全凭据由我在本机输入。
使用短允许名单,默认不自动合并、不发布。

AI 会完成 DSH 与依赖安装、构建、启动、独立配置创建和插件注册等,并完成官方的检查、构建和基础测试。过程中可能会有若干需要你配合确认的问题。

步骤 2:检查与配置来源、规则等

在第一步完成后,大部分的配置会自动设置好。但你也可以在完成后进入 Super-agent的设置界面:

以 GitHub 为例,这里可以配置以下常见项目:

  • 来源:指定一个代码仓库、访问GitHub的 CLI;接收的事件(Issue、PR、CI等)

  • 接单规则:哪些账号可发起工作;如何处理;接单规则(接收什么,忽略什么)

  • 执行环境:任务工单 Git 工作树的根目录、状态目录;执行器用的模型等

  • 提示词:一般不建议改动,即 Super-agent 工作中用到的各种提示词

Super-agent 需要一个 GitHub 仓库的执行账号,需要仓库读写权限,并核验命令入口的实际登录身份。

后续你可以在 GitHub Issue 等 @ 这个执行账号,Super-agent 就会接收到事件,并开始“工作”。

步骤 3:创建一个 Issue,触发一次修复任务

一切准备就绪后,现在我们来创建一个演示的 GitHub Issue。

在仓库的 Issues 页面新建一个 Issue,随后用另一个账号增加评论:

@pingcy 请修复上面超时预算接受 NaN、Infinity 等非有限值的问题。
只修改预算模块与回归测试,运行相关测试,提交 PR,不合并。

现在,你无需做任何动作,等待一段时间后,将可以在 DSH 面板看到 Super-agent 的协调器和执行器的工作区启动;同时进入 Superagent 插件面板的“执行” 区,可以看到授权的工单,记录请求者、范围和原讨论链等:

GitHub明确请求形成带授权范围的工单

任务完成后,你会在 GitHub Issue 里看到 Super-agent 的回复:

步骤 4:沿原任务补充新的要求

现在我们有了一个待审的 PR。假设此时有其他的同事想起来有新的补充,怎么办?

他只需要在同一个 Issue 中继续追加要求,而且此时无需 @ 执行账号:

现在,Super-agent 将会开始一次新的执行。但是这一次的执行不会开启新的会话任务,而是进入原任务,这是合理的 — 因为本来就是在同一个 Issue 的处理过程中:

原执行会话在同一PR追加回归测试,报告90项测试通过

同之前一样,任务完成后 Super-agent 会自动回复到 Issue,注意,此时并没有创建新的 PR  — 这也正是我们的要求:

步骤 5:创建飞书机器人,接入聊天群

目前 Super-agent 还支持的一个接入渠道是飞书群。

最简单的方法是让 AI 帮你将 Super-agent 接入飞书群(需要登录飞书平台):经过自建应用和机器人、设置权限、生成并绑定安全凭据、创建测试群并邀请机器人等步骤后,AI 会查询群和用户标识,写入 Super-agent 策略并启用飞书来源:

飞书和GitHub来源均显示运行中

步骤 6:从飞书群接单,再在原话题追问

现在你可以用类似上面 GitHub Issue 的方式与 Super-agent 进行沟通,发起任务、查看结果、追加任务等:

同样,你可以在 DSH 的 Super-agent 面板看到任务的执行。

上面也可以看到,由于两个入口现在都接入了同一套 Super-agent,所以两个渠道之间实现了无缝协作 — 飞书群接到任务,在 GitHub 执行,再到飞书群回复,这是完全可行的(具体的行为可能会受到 GitHub 和飞书机器人的授权限制):

最后

以上是对 DeepSeek 的 Super-agent 架构的介绍,及其原型项目的体验。

尽管正式产品尚未发布,不过已能看到:企业级编程 Agent 的关注重心,正从更强的模型生成能力、更长更复杂的任务,逐渐转向团队协作背景下的持续、高效、主动的工作推进,或许未来不仅是人人都有自己的 Agent,团队也将拥有自己的 Super Agent。

Image

感谢阅读,交流与合作请后台留言

喜欢就关注哦

Image

动动小手点个赞

Image

点在看最好看

Image

跳转微信打开

一篇讲透:RAG / GraphRAG / LLM-Wiki / PageIndex 在企业知识系统的融合应用

2026年10月26日 08:30

原创 曾经的毛毛 2026-10-26 08:30 江苏

如何构建企业 Agent 系统的融合知识底座?

点击上方蓝字加入我们

知识工程是企业 Agent 系统构建的重要基石之一。

大型企业内部的知识以各种形态分散在不同的部门与系统里。它们可以用来协助构建业务本体;但更多时候,我们要让知识能够被 Agent 检索和查阅,以构建必要的上下文,进而提供问答、探索、创作等任务能力。

从经典的向量 RAG,到后来的 GraphRAG,再到 PageIndex、LLM-Wiki,知识的组织与检索模式不断革新。但面对复杂多变、难以预测的任务,很多时候不应该多选一,而是将它们融合应用。

读完本文,相信你对此应该有更清晰与深入的认识。

PART 01

理解知识的四种模式

企业构建知识底座,是为了让上层应用(在当前语境下,更多指 AI 智能体应用)更加高效、精准地查询到必要的相关知识。

不过,在大量非结构化文档为主的知识世界里,同时做到这三点并不容易。

比如,把所有知识都通读一遍,虽然读取的信息范围更广,但效率太低;用向量做语义检索,速度很快,但召回的精度和上下文完整性又会受到文档切分等影响。

这也是为什么会有多种知识组织与检索模式:本质是为了解决不同要求的知识问题。

快速理解四种模式

我们用图书馆做例子,对这四种模式建立一个快速认识。

  • 向量 RAG:片段检索。把每本书的段落做成资料卡,可按语义查找。比如问“公司报销制度”,先找出意思接近的资料卡,再找到对应的原文段落。

  • GraphRAG:图增强检索。为每本书的章节、人物、机构和事件等建立“关系网”。比如查“谁影响了谁”,可以先找到对象,再沿着关系网追查。

  • PageIndex:文档树导航。拿到一本厚手册,为它建立分章节的目录和摘要。查找内容时,先看目录选章节,再逐层翻到正文读取内容。

  • LLM-Wiki:知识编纂。像图书管理员读过相关书籍后,编写一部持续修订的专题百科。后来的人先看百科目录,再找到专题阅读,必要时才回到原书。

需要注意,这四种能力的层次不完全相同:有的侧重检索结构,有的侧重知识组织 — 这也决定了它们并非水火不容。

广义的 RAG 是通过外部知识来增强 LLM 输出准确性的一种架构,并不局限于向量数据库;Graph、PageIndex 都能进入 RAG 链路。本文的“经典 RAG”,特指以文本切块、向量召回为核心的常见实现。

PART 02

经典 RAG 与 GraphRAG:
从找片段到找关系

这是两种最为熟知的 RAG 模式,我们做一个简单回顾。

经典 RAG:按意思查资料卡

经典 RAG 把原文片段(Chunk)作为检索单元。与精确匹配不同,向量索引按语义相似程度查找内容。可以把向量粗略理解为文本在“语义地图”上的坐标:意思相近的内容,更有机会被一起发现(但不保证事实/内容相同)。其准备与应用过程一般为:

  • 索引阶段:解析文档、按章节或语义切块,计算向量,连同来源等元数据写入向量库

  • 检索阶段:把用户问题也转成向量,通过向量库检索到相近片段,再交给模型回答

实际应用中,向量检索可以与关键词搜索 / 过滤配合使用。

比如查“iPhone18 的保修条款”:向量帮助理解“保修条款”的问法,关键词帮助匹配具体型号 iPhone18。两路候选进行合并、重排等,得到更加精准的召回。这可以借助多路融合检索、元数据过滤、或混合检索数据库等技术实现。

【适用性与特点】

经典 RAG 适合客服、产品资料、内部制度等大规模文档中的局部事实性问答。生态成熟,容易建立基线,检索性能较高。

最大的问题是“相似不代表完整”:找到主条款的 Chunk,可能漏掉例外;找到某个项目,可能漏掉它依赖的系统;Chunk 过小容易丢上下文,而过大又容易带入噪声。

这是一些早期 RAG 系统在快速上线后很快无人问津的原因之一:

原理与实现简单,但能解决的问题有限。上线很快,优化很慢。

GraphRAG:沿着关系追查线索

“供应商甲停供,会影响到哪些大客户?”,这个问题不会有直接的答案,可能需要沿“供应商—零件—产品—订单—客户”查找线索,且分散在多份材料甚至数据库中。

这需要借助 Graph 这种结构。Graph 把实体(比如一个供应商)作为节点,把关系(比如供应商与零件的供应关系)作为边,大量节点和边就构成了一张更大的 Graph。

GraphRAG 就是利用知识图谱增强检索的一类方法。微软的 GraphRAG 是代表性实现:

  • 构建阶段:从文本抽取实体与关系,聚合成图,再识别联系紧密的社区(关系密切的节点组成的“小团体”),并生成社区摘要。

  • 检索阶段:先通过向量找到相关实体,再结合邻居、关系与原文补充上下文;而总结性问题则可汇总社区报告,再输入模型。

工程上,GraphRAG 的难点在于准确的抽取实体与关系、消歧、原文映射、Graph 数据的存储、更新和查询等,特别是一些垂直行业,要建立起完备的 Graph 并不容易。

【适用性与特点】

GraphRAG 适合跨文档关系的多跳问题与主题归纳。比如,可以追查“供应商停供会影响哪些客户”;也可以回答“这批材料主要讨论什么内容”等总结性问题。

相比单一的向量 RAG,它能沿着关系补充上下文,但准备过程更复杂(通常借助 LLM),成本也更高,当然也可能出错。你应该只在知识具有明显的关系特征、而任务确实需要关系探索时才考虑 GraphRAG。

最后,GraphRAG 的使用也可能需要向量。比如,先用向量找到与问题相关的 N 个实体,再沿 Graph 的关系补充线索。

PART 03

PageIndex:
先看目录再翻阅原文

向量检索帮助找到相关内容,Graph 则帮助补齐关系。它们在回答事实性问题时可能很有用,比如从一份数百页的软件帮助文档中查询“单点登录支持哪些认证协议?”,通常比较容易定位答案。但你如果问:

“为什么配置了单点登录,部分用户仍无法登录?这与权限设置或版本有关系吗?”

处理这类问题时,RAG 甚至 GraphRAG 方案都可能遇到一个难点:上下文读不全。

一份复杂软件的帮助文档中,单点登录配置、权限设置、版本限制、常见问题分散在不同章节,彼此相隔几十页。如果只召回与问题相似的段落,就容易漏掉前置条件、配置依赖和注意事项中的重要信息。

PageIndex 为这类需要长文档跨章节查证的问题,提供了另一条路径。

核心方法:建立原文档的导航树

PageIndex 的核心思想是解析文档,利用目录、标题版式或正文识别文档的章节层级,将节点与页码或正文范围关联,并按配置生成节点摘要,形成一棵原文档的“导航树”。

这里的节点就是一个索引节点,它告诉模型:这一节讲什么、上下层是什么,以及去哪里读。它不依赖向量,但仍按章节层级组织索引,并保留原文定位信息。

而到了查询阶段,模型从查看这棵“导航树”开始:

  • 首先根据问题选择相关章节与页码范围

  • 调用读取工具取得对应页的原文内容

  • 如果模型认为上下文不足,可能要求继续补充其他章节

在上面的例子中,可能要先读单点登录配置,再补上权限设置、版本限制和常见问题中的相关内容。当然是否读全,很大部分取决于导航树的质量和模型的选择。

技术实现:借助 PageIndex SDK

借助开源 PageIndex,可以快速上手。以下为本地调用的示例:

from pageindex import PageIndexClient
client = PageIndexClient(
    index="gpt-6-luna",  # 建树模型
    chat="gpt-6-sol",    # 查询模型
)
doc_id = client.submit_document(
"report.pdf"
)["doc_id"]
answer = client.chat(
"2023 年的营业利润率是多少?",
    doc_id=doc_id,
)

PageIndex SDK 提供索引创建、结构读取、检索与问答等接口,目前主要处理文本型 PDF 或 Markdown 文件(OCR、视觉解析等能力需另行集成)。

适用性与特点

从原理看,PageIndex 更适合年报、合同、手册等章节清晰、需要跨章节核对的长文档。如果有很多长文档,通常需要先发现候选文档。

PageIndex 的优势是先了解全文脉络,然后取证,大大减少可能的上下文遗漏。

缺点是适用场景相对受限,所以在大型项目中可能更适合作为“副手”。其代价是查询的延迟及额外成本,毕竟结构解析、摘要生成、检索时判断都需要借助 LLM,本身也存在不准确的可能。

PART 04

LLM-Wiki:
把知识按主题编纂和查询

LLM-Wiki 是 Andrej Karpathy 在今年提出的一种模式。它的核心思想是:

LLM 不再在查询时从原始文档中检索信息,而是先将知识编译成一个持久的、相互关联的 Wiki,并保持其更新  — 就像一部持续修订的专题百科,按主题把原始知识文档整理成概念页(Page),保留关键结论,并在 Page 之间建立交叉链接。

核心方法:LLM 的编译与持续更新

初次构建时,先把原始目录(比如 raw)中的文档编纂成可复用的知识页。 LLM 读取 raw 中的文档,识别实体、概念和关键事实、规划 Wiki 的页面结构、再按主题整合材料、生成概念页 / 实体页 / 专题总结等,最后建立交叉链接、来源回链和索引页。

同一主题可以汇总多个来源,一份原文也可能贡献给多个页面。

初次构建后,后续再围绕变化持续维护。 当新材料进入,或知识源发生变化,借助 LLM 识别受影响的 Wiki 页,进行补充、修订或删除,并标注尚未解决的问题,最好还能定期检查过期内容、断链和知识缺口等。

 使用时,Agent 沿着索引页与内部链接,根据任务找到自己需要读取的内容:

  1. 先看索引页:比如  index.md,了解知识库有哪些主题,判断从哪里开始。
  2. 进入相关概念页:沿目录链接打开页面,阅读已经整理好的知识。
  3. 按需延伸阅读:沿交叉链接查阅相关概念,补齐必要知识。
  4. 用于当前任务:依据这些知识回答问题、分析方案、撰写文档或编写代码。

可以看到,读取时不依赖于向量索引或相似度排名。你可以根据需要定义自己的知识加载策略,比如在 AGENTS.md 或 Skill 中设定读取流程和约束。

OKF:将 LLM-Wiki 标准化的知识格式

这里还有一个概念:OKF(开放知识格式)。它是 Google 发布的开放知识格式规范,可用于表达和交换 LLM-Wiki 等方式整理出的知识。在这个规范中,一个 Wiki 页面通常表示为带 YAML 元数据的 Markdown。比如:

基于 OKF 规范的 LLM-Wiki 一般长这样:

适用性与特点

LLM-Wiki 适合沉淀领域术语、指标口径、操作规程、编程上下文等:既能直接浏览,也能为 Agent 组织任务所需的上下文。

它的难点在于规模化与长期维护,这源自它有一个独立的“中间层” Wiki。

当你的 Wiki 拥有成千上万的页面后,一旦知识源发生变化,需要定位受影响的页面,处理更新、冲突和错误等,这需要付出较大的时间与 Token 成本。

所以,在企业应用中,不宜急着把所有资料编成 Wiki。优先沉淀反复使用、相对稳定的核心知识;而海量工单、会议纪要这类知识,可以在发现复用价值后再整理。

当然,更合适的方法是与其他模式进行协作与融合应用。

PART 05

四种模式的融合应用

在探讨几种模式的融合之前,我们做一个简单的总结:

模式

擅长任务

工程负担与主要局限

向量 RAG

海量资料中的局部事实

召回精准度;可能遗漏上下文

GraphRAG

关系探索与全局主题

抽取与消歧;错误关系会扩散

PageIndex

长文档内跨章节取证

建树与阅读;多步查询较慢

LLM-Wiki

复用知识、探索与创作

规模化维护量大;更新与读取成本

注意,这只是一般的工程分析,并非排名。每种模式都有代价:向量需要嵌入,图需要抽取关系,树导航要建树,Wiki 则需要整理和持续维护。所以在真实应用中,往往需要组合使用它们:按任务路由或串联使用不同模式与工具。

下面来探讨一些可能的融合应用模式。

融合一:向量找到入口,用 Graph 做关系扩展

先用关键词与语义向量检索,找到相关实体或片段;再借助图沿有来源的关系扩展,返回相关上下文,必要时用重排模型筛选。

也可以将片段与 Graph 检索并行召回,再合并重排(也可以结合关键词检索):

基于 Graph 的扩展应限制关系类型与跳数,避免把过多的“远亲近邻”全塞进上下文。

融合二:向量定位文档,用 PageIndex 做增强阅读

先通过 RAG 管道或 GraphRAG 检索定位候选文档,再根据需要补充上下文。较短的文档可以直接读全文;复杂的长文档则调用 PageIndex,定位相关章节并补充。

这里需要结合向量块的元数据、Graph 节点属性等信息,确认读取的文档及其树索引的身份与版本一致,避免搜索与读取的不一致。

融合三:Wiki 存核心知识,PageIndex 读长文,RAG 连接长尾

这是一种分工合作的方式:不同任务/子任务可以路由到不同的知识服务管道。

  • 企业中核心、稳定、经常被引用的知识,整理成 Wiki/OKF ,比如业务规则、管理制度、指标解释、参考手册和 SOP(标准操作流程)

  • 复杂的长文档可以建立 PageIndex,便于在长文中阅读、定位、补充上下文

  • 其他大量非结构化、快速变化、偶尔被查询的信息,仍可由 RAG 管道提供快速服务,必要时结合图增强检索

使用时,Agent 可以借助 LLM 路由器选择工具;或者动态的把大任务拆成子任务,分别从不同的服务管道查询、整理、再补充、合成结果等。

以 AI 编程上下文的应用为例

假设为一个行业应用构建 AI 编程知识库:已有整理过的 Wiki、向量 RAG 管道,以及借助语法树构建的代码图谱(一种不借助 LLM 构建的代码 Graph )。那么,在一次新需求的设计开发过程中,可能同时发生以下动作:

  1. 从 Wiki 的索引入口进入,读取相关的业务术语、规则、流程;理解系统架构等

  2. 为核对一个指标口径或 API 变更,通过向量 RAG 快速检索到相关的知识与事实

  3. 借助代码图谱发现模块与代码间的关联性,用来分析本次开发的影响范围

  4. 通过 PageIndex 在一个上百页的接口文档中定位到使用方法、开发注意点等

最终,你可以生成带有出处、引用甚至页码的待确认设计草稿。必要时你也可以将经过核验、可复用的设计决策与解释再回写 Wiki,实现知识积累。

当然,并非每个任务都需要走遍所有通道。

你可以在 AGENTS.md 设定路由与组合规则,让 Agent 按需选择;也可以定义 Skill 或借助  LangGraph 等框架编排,来固化标准的检索过程。

融合四:Wiki 可以成为其他模式的输入

查询管道不一定都从原始文档构建。整理后的 LLM-Wiki/OKF 本身就是有结构、且质量更高的 Markdown 文档集,恰好就是 RAG/GraphRAG 的理想输入。所以,你可以在此基础上建立起向量 RAG 的查询加速层,并验证分块和召回效果;只在必要时才回到最原始的文档查询。

此外,相互链接的 Wiki 页面本身就构成一个文档的 Graph;你可以在此基础上进一步做实体与关系抽取,以支持更深入的关系探索。

关于以上的几种融合应用模式,最后需要说明的是:

融合扩展了可覆盖的检索需求,但也带来了知识更新与治理的复杂性:当原始内容或访问权限变化时,相关片段、Graph、Wiki 页和文档树都需要相应更新或失效,这非常考验工程能力。

以上我们梳理了面向 Agent 系统的企业知识底座的构建模式。根据知识特点、任务需要和工程条件,企业可以从最紧急的任务入手,建立起基线,再在业务发展中补齐更复杂的能力。

实际构建时,可以借助一些开源项目来降低工程复杂度:

  • Microsoft GraphRAG:实体关系抽取、社区识别、局部检索与全局归纳
  • LightRAG:融合图与向量检索,支持增量维护
  • PageIndex:文档树导航,提供索引、检索与问答 SDK
  • OpenWiki(LangChain):编纂、维护 Wiki,支持 OKF 输出
  • RAGFlow:很强大的文档解析能力;提供 RAG、Wiki、PageIndex 等模式
  • WeKnora:来自腾讯的知识工程基座,支持 RAG、Graph、Wiki 等知识模式

后续我们将分享基于这些开源项目的实践,欢迎继续关注。

Image

END

喜欢就关注哦

Image

动动小手点个赞

Image

点在看最好看

Image

跳转微信打开

手把手教你:用 MCP Apps 把企业应用 UI 接入 WorkBuddy。

2026年10月19日 08:30

原创 秋山墨客 2026-10-19 08:30 江苏

在 WorkBuddy 里操作企业应用:MCP Apps 接入实战。

点击上方蓝字加入我们

最近,腾讯把 WorkBuddy 和企业微信打通了。

大厂们对办公 Agent 的期待,显然不止于处理个人邮件和文档,还希望它深入企业业务流程,发挥更大的作用。毕竟,个人提效不等于组织提效。

一种新的协作方式是:Agent 负责理解意图、规划步骤;业务应用提供上下文、执行任务;人负责必要的审查和接管。

那么,如何把企业应用的业务能力,甚至操作界面接入 WorkBuddy?本篇就来探讨与演示其中的一种集成方式 — MCP Apps。

01

为什么把企业系统接入 WorkBuddy

其中的核心逻辑是:让员工手头的 AI 工具,在组织授权和管理下接入企业系统,参与业务协作、承担实际任务。

从一项工作任务说起

以客户拜访为例,销售需要查询 CRM 商机、了解未结的售后工单、翻阅每周的会议纪要,再整理下一步行动。过去,这些信息分散在不同的系统和文件中,你经常需要切换系统与页面、复制内容,甚至重复录入。

但未来,你可以和 WorkBuddy 说:

查询我目前跟进的商机,翻阅下这周的会议纪要,制定我本周的跟进计划。

WorkBuddy 就可以调用相关业务工具,汇总资料、整理计划,供你核对。

随后,你可以接着说:

帮我准备明天的客户拜访材料,并把跟进计划录入到 CRM。

经过你的确认,Agent 再通过 CRM 接口写入跟进计划。

在这里,值得集成的环节,往往是那些需要跨系统收集材料、结合上下文判断,再继续执行的工作(相比传统模式有明显的效率提升)。WorkBuddy 负责组织任务执行,企业系统负责保存事实、执行业务规则与专业操作,两者按各自擅长的方式配合。

与自建 Agent 系统的区别

那么,接入 WorkBuddy,与自建共享 Agent 服务有什么区别?

自建共享的 Agent 系统,更适合围绕组织的统一业务流程持续运行。

例如,持续接收销售线索,按统一规则分配给员工,并在跟进超期时触发提醒。这类任务需要统一流程、管理状态、调度和运行环境,即使某位员工离线、换岗,也不影响任务继续。

企业也可以按需设计 UI、编排流程,同时承担全部的开发和运维工作。

接入 WorkBuddy,则更贴近员工手头的具体日常任务。

例如,销售可以把 CRM 客户资料、自己电脑上的方案和企业微信中的会议纪要交给 Agent,结合当前任务整理材料、给出建议。复用已有的对话和任务入口后,开发重点可以放在业务能力、权限和操作界面的适配上。

我们对两者做一个对比总结:

对比维度

自建共享 Agent 服务

接入桌面端 WorkBuddy

工作重心

围绕组织流程,共享 Agent

围绕手头任务的个人Agent

上下文

企业数据、共享知识

获准使用的个人资料为主

运行流程

服务端运行,支持多人协作

本地执行,以个人为主

开发重点

Harness、UI、会话、编排、调度及业务服务

业务系统的连接与适配

典型任务

跨系统的企业业务流程、共享的 Agent 能力

文档处理、资料分析、个人相关工作事务

两种方式也可以结合。例如,共享 Agent 统一完成市场调研和商机生成,员工在 WorkBuddy 中推进具体客户的跟进。专业 Agent 还可以封装成服务,通过 API 与 MCP 接入 WorkBuddy。

WorkBuddy 新推出的“项目”功能也支持共享上下文和团队协作,项目配置等内容会保存在云端。因此,桌面 Agent 能访问本地环境,但不等于所有数据都一定留在本机。

02

企业应用的三种接入方式

把企业应用接入 WorkBuddy 这样的桌面智能体,需要两端配合:智能体支持相应的调用协议;企业应用提供可用的接口或操作入口。

根据企业系统的能力选择接法

根据企业系统已有的接口和工具,通常可以考虑几种接入方式:

  • Skill 配合 CLI / 脚本

    把操作方法写进 Skill,让 Agent 按说明调用 CLI 工具或脚本,访问业务系统、执行操作。

  • MCP 工具与 MCP Apps

    将应用 API 封装成 MCP 工具,供 Agent 调用;需要交互界面时,再配合 MCP Apps。其他 Agent 也可以封装成工具,通过 MCP 接入。

  • 浏览器自动化

    旧系统暂时没有可用接口时,可以通过浏览器自动化访问页面、完成操作。例如,在 WorkBuddy 中使用 Agent Browser 技能。

MCP Apps:带交互的工具

对于已有 API 的企业系统,可以优先考虑 MCP。若系统提供标准 OpenAPI 描述,还可以借助开源工具直接生成 MCP 封装,再按需求调整。

比如,将查询客户、读取商机、登记跟进等能力,封装成用途明确、参数清晰的工具,供 WorkBuddy 等支持 MCP 的 Agent 调用。

WorkBuddy 已经支持通过连接器调用 MCP 工具。接入后,员工可以在同一个任务中使用企业应用的业务能力,减少在多个应用之间切换。

但面临的一个问题是交互体验。

比如,筛选数据、比较方案、填写跟进表单时,如果每一步都靠自然语言交互,往往需要多轮沟通,操作也不够方便。

这时,你可以为 MCP 工具配套开发 MCP Apps 界面,把表单等 UI 带进 WorkBuddy。员工可以在可视面板中查看数据与完成操作,推进当前任务。

下面来详细了解这种接入方式。

03

如何用 MCP Apps 补齐交互界面

前两篇我们详细介绍过 MCP Apps,这里我们直接进入正题。

给业务工具配上可操作的界面

MCP 让 Agent 调用工具,MCP Apps 则为这些工具配上交互界面。

例如,可以为客户查询工具关联一个 UI 组件,用来展示返回的客户信息、商机和工单,并提供可填写、可提交的跟进表单。

通常把这类围绕具体任务构建的交互组件称为 Widget。负责加载组件、承接交互的应用称为宿主(Host),在这里就是 WorkBuddy。

Widget 可以复用企业应用已有的部分前端代码,也可以单独开发。除了展示 界面,还要处理交互和状态变化,比如,筛选条件改变、或者提交完成后,界面上要给出相应反馈。

实际接入还涉及登录认证、授权和跨域访问等细节问题,这里先不展开。

一次交互是如何完成的?

大致过程如下:

  1. 你向 WorkBuddy 发起任务,例如:“帮我登记xx客户的跟进计划。”

  2. WorkBuddy 规划步骤,识别 CRM 工具描述中关联的 UI 资源,并通过连接器调用相应的 MCP 工具。

  3. 读取 UI 资源,在沙箱(ifram额)中加载 Widget,再把客户基本信息等工具结果交给界面渲染。

  4. 员工填写并确认。Widget 通过宿主的通信桥接(AppBridge)调用 MCP 工具,提交数据,并根据返回结果更新界面。

  5. 交互完成后,Workbuddy 可以结束任务或者推进后续步骤。

这样,员工可以在提交前核对信息、修改输入;在提交后查看结果。交互界面显示在 WorkBuddy 中,业务规则、数据校验和写入仍由企业应用负责。

你可以在 WorkBuddy 的侧边栏看到 MCP Apps 的类似交互界面:

交互的过程和你直接在 CRM 系统中操作保持一致,但现在变化是:

现在,员工依然可以沿用熟悉的系统操作方式。但现在的变化是:

相关数据和界面会随着任务执行而变化,无需在多个应用之间反复切换。

04

以 CRM 为例接入一项业务能力

我们以“登记客户跟进计划”为例,演示如何用 MCP Apps 将企业应用的 UI 接入 WorkBuddy。

定义任务,封装 MCP 工具

先明确工具的输入、输出与职责。查询工具接收客户标识,返回客户信息、商机和未结事项等,并关联登记表单;销售填写后,再由另一个工具负责提交。

这里实现三个工具:

  • crmcustomerworkspace :查询并关联工作台 UI

  • crmcreatefollowup:创建客户跟进计划

  • crmlistfollowups:查询跟进计划列表

以第一个带有 UI 的工具为例,核心代码:

const uri = 'ui://crm-demo/customer-workspace.html';
registerAppTool(server, 'crm_customer_workspace', {
  inputSchema: { customerId },
  _meta: { ui: { resourceUri: uri } }
}, async args => ({
  content: [{ type: 'text', text: '客户工作台' }],
  structuredContent: await workspace(args.customerId)
}));

structuredContent 返回结构化的业务数据,由宿主传给 UI 渲染。_meta.ui.resourceUri 则声明与工具关联的 UI 资源,告诉支持 MCP Apps 的宿主(WorkBuddy):调用这个工具时,可以加载对应的 UI 组件。

编写界面,提供 UI 资源

把客户摘要和跟进表单组织成一个 Widget:上半部分用于核对业务背景,下半部分用于登记跟进计划。大致骨架如下:

<h3 id="customer-name"></h3>
<form id="followup-form">
<input name="title"placeholder="跟进事项">
<input name="owner"placeholder="负责人">
<input name="dueDate"type="date">
<button>保存跟进计划草稿</button>
</form>

将 HTML、样式和交互脚本打包后,需要在 MCP Server 中注册资源,让 WorkBuddy 可以根据前面声明的 uri 读取界面:

registerAppResource(server, '客户 UI', uri, {
  mimeType: RESOURCE_MIME_TYPE
}, async () => ({
  contents: [{
    uri, mimeType: RESOURCE_MIME_TYPE,
    text: html
  }]
}));

这里的 html 就是构建后的完整 HTML 内容;

RESOURCE_MIME_TYPE 的值为 text/html;profile=mcp-app,用于标识 MCP Apps 界面资源。注意 uri 必须与前面的工具注册中一致。

绑定交互,让表单能够提交

接下来,要让表单真正完成业务操作。

销售填写并提交后,要由 WorkBuddy 转发工具调用,把跟进计划写入 CRM。这使用 MCP SDK 的 callServerTool 来完成:

import { App } from'@modelcontextprotocol/ext-apps';
const app = new App({ name: 'CRM', version: '1.0.0' }, {});
app.ontoolresult = result => consume(result);
await app.connect();
form.onsubmit = async event => {
  event.preventDefault();
// 从当前表单组装 argumentsValue,过程省略
  consume(await app.callServerTool({
    name: 'crm_create_followup',
arguments: argumentsValue
  }));
};

这里的 form 就是上面的表单;提交时,从 UI 表单组装 argumentsValue。callServerTool 会把保存动作交给 WorkBuddy 转发工具调用请求(MCP Apps 必须通过宿主应用转发请求),获得返回后再更新前端界面。

在 WorkBuddy 中跑通

在工具和 UI 资源准备好后,就可以启动 MCP Server,通过 Streamable HTTP 提供远程服务。

在WorkBuddy 中添加对应的 MCP 连接器,填写服务地址,例如 https://crm.example.com/mcp(可能需要完成认证)。

连接成功后,可以发起测试:

查询某客户的信息,并帮我登记跟进计划。

工作台加载后,你可以查看客户信息和历史跟进,填写并提交新计划,再核对 CRM 返回的保存结果。整个过程都在 WorkBuddy 中完成。

结合企业微信等工作入口和 WorkBuddy 的项目协作,这种方法可以把分散在多个系统中的数据和操作串在一项任务中:员工提出目标、核对信息并完成交互,企业应用负责具体的业务处理。

05

总结与展望

桌面 Agent 可以把个人资料、协同办公和企业应用连接起来,减少系统切换和重复操作。这可以从一项高频任务、一组业务工具和一个交互组件开始:

Agent 规划步骤、准备材料;员工核对确认;企业应用执行业务操作。

上文以 CRM 为例,演示了如何用 MCP Apps 把业务能力和 UI 接入 Agent 工作流。这种方式当然也可以延伸到更多场景。比如:

报销凭证核对、采购报价比较、运维排障的证据追踪、合同条款确认、经营指标下钻,以及招聘材料整理等。

当办公 Agent 真正接入企业应用时,未来还需要完善几类问题:

  • 应用(比如已有 SaaS)的开放,以及对商业模式的影响

  • 身份认证、工具授权与操作审核

  • 长任务的进度管理、中断恢复、幂等与补偿等技术问题

  • 连接器的统一分发、版本管理和执行追踪等

随着这些能力逐步完善,办公 Agent 有望成为未来企业日常业务的重要入口。

Image

感谢阅读,交流与合作请后台留言

喜欢就关注哦

Image

动动小手点个赞

Image

点在看最好看

Image

跳转微信打开

Agent 时代,前端怎么变?AG-UI、A2UI 与 MCP Apps 的协同模式(下)

2026年10月12日 08:30

原创 曾经的毛毛 2026-10-12 08:30 江苏

AG-UI、A2UI 与 MCP Apps 之间如何协同与选择?

点击上方

蓝字

关注我们

上篇中我们拆开介绍了三个 Agent 时代 UI 相关的标准:

AG-UI 负责运行时交互;A2UI 描述 UI;MCP Apps 则让工具带上交互 UI。

到了实际项目里,它们可以出现在同一个应用中。比如:一个退款的卡片 Widget(A2UI)可以随着 Agent 的进度发送到前端(AG-UI);卡片(A2UI)里也可以嵌着物流工具的操作面板(MCP Apps)。

本篇我们看看这几个标准之间的常见协同场景。演示代码在文末。

01

AG-UI x A2UI :把 UI 描述放进事件里

分工:一个负责交互,一个描述界面

继续上篇的客户服务的 Agent 演示应用,仍然以订单退款为场景。

我们可以用 AG-UI 来把 Agent 的事件和状态同步给前端,由其自行管理 UI;也可以基于 A2UI 协议,由后端告诉前端要用哪些 UI 组件和数据。

但实际上两者可以同时使用:

保留 AG-UI 的通信方式;同时把 A2UI 描述也放进运行事件中。

比如,后端查到订单后,既返回任务状态;也发出退款卡 UI 的组件描述与订单数据。

前端通过 AG-UI 收到这个事件流后,按内容分别处理:任务状态用来更新进度、A2UI 消息则交给渲染器,由它绘制 UI。

大致原理如下:

实现方法

AG-UI 项目为此提供了 A2UIMiddleware 的适配代码。其作用是:从 Agent 的工具输出中识别 A2UI 内容,并将其封装成 AG-UI 事件,和文字、状态消息一起传给前端。

简单说,就是帮你把 A2UI 的消息“包装成” AG-UI 的事件,加一层外壳:外层标明消息类型,里面保留具体的 UI 描述。 前端应用再按标识取出内容,交给 A2UI 渲染器。

下面是一个把 UI 描述装进 AG-UI 事件的例子(显示商品信息和确认按钮)。

{
"type": "ACTIVITY_SNAPSHOT",
"messageId": "a2ui-refund",
"activityType": "a2ui-surface",
"content": {
"a2ui_operations": [
      {
"version": "v0.9",
"createSurface": {
"surfaceId": "refund",
"catalogId": "https://refund-demo.local/catalog/v1"
        }
      },
      {
"version": "v0.9",
"updateComponents": {
"surfaceId": "refund",
"components": [
            {
"id": "root",
"component": "Column",
"children": ["product", "confirm"]
            },
            ...
          ]
        }
      }
    ]
  },
"replace": true
}

在这个例子中,外层是一个 AG-UI 的事件消息格式,类型为ACTIVITY_SNAPSHOT;然后用 activityType: "a2ui-surface" 标识出这是一个 A2UI 的描述。

通过这种方式,A2UI 描述的 UI 与其他 AG-UI 的事件消息(状态更新、工具调用等)一起,被源源不断地“输送”到前端应用。

02

A2UI x MCP:三种组合方式

A2UI 与 MCP Apps 都能带来动态的 UI。一个是生成 UI 描述送到前端渲染;一个是提供可交互的 HTML 页面,由宿主在隔离的 iframe 中加载。

那么两者组合的意义在哪里?又是如何组合应用呢?

Google 官方给出了三种组合方式。理解它们时,可以盯住两个位置:A2UI 的渲染器在哪里,MCP App 又在哪里。

A2UI over MCP:用 MCP 传 A2UI

如果企业已经有统一的 UI 组件体系与渲染器,并希望订单、库存、审批这些 MCP Tool 返回的界面都保持一致统一,可以用 A2UI over MCP。

它的方法是:

MCP Tools 返回 A2UI JSON 描述,宿主(如 Agent 应用)获得描述后,用渲染器绘制 UI。

在这个机制中,MCP 不返回独立的 Web 页面,宿主也不需要 iframe。这里只需要 MCP 的基础工具与资源能力,并不要求 MCP Apps。前提是宿主应用能够支持 A2UI — 前端能够渲染出 UI 组件。

基于 MCP 的 A2UI 服务端实现方法:

  • 通过 MCP Resource 提供 A2UI 描述的 UI 模板

  • 通过 MCP Tool 提供数据及更新

MCP 的工具元数据(_meta.ui)中需要定义一个 A2UI 的资源描述与类型:

"_meta": {
"ui": {
"resourceUri": "a2ui://recipe-card",
"mimeType": "application/a2ui+json"
  }
}

宿主应用在调用 MCP Tool 时,除了获得数据之外,检查_meta信息,进而通过 resources/read 的调用获得 A2UI 的 UI 模板,从而能够完成最终 UI 组件的渲染和数据展示。

以前面的 Demo 为例,订单查询的 Tool 在 application/a2ui+json 内嵌资源中返回完整 UI 描述,前端据此绘制退款卡片并展示:

而在进行操作后(比如点击“确认退款”),宿主应用再次发起 MCP Tool 调用,将相关数据发送到 MCP Server,并同时获得更新后的 A2UI 结果。

MCP Apps in A2UI:A2UI 里嵌入 MCP App

如果你的 Agent 系统本身采用了 A2UI 来实现前端的动态界面;但同时需要嵌入一些外部的 MCP Apps 界面,就可以使用 MCP Apps in A2UI。

比如,如果你自己掌握了售后门户(A2UI 实现),但又不想把外部物流商的时段选择、地图和校验逻辑全部重写,就可以考虑把物流工具的“面板” Widget(MCP Apps)嵌入到自己的 UI 中。

其实现机制是:

外层仍由 A2UI 组织 UI 区域,但在组件目录中增加一个“MCP App 容器”。渲染器遇到它,就加载 MCP Apps 关联的 HTML 资源,在 iframe 中运行。

企业维护外层 UI ,工具团队维护内部交互,两边通过消息通信。

继续以前面的订单退款 Demo 为例,外层的订单和金额由 A2UI 绘制,但这里紫色取件面板是一个独立 MCP App(假设是物流提供的 MCP):

如果简单的理解,就是把 MCP Apps 看作是 A2UI 支持的组件目录中的一种组件类型(MCPApp),类似一个 Form。

A2UI in MCP Apps:把 A2UI 渲染器装进 MCP App

上面的模式是:我们使用别人开发的 MCP Tool,从而将其带有的 UI 集成到我们的 A2UI 界面中。

但如果反过来,我们开发的是要接入别人平台的工具,无法改造宿主应用。对方支持 MCP Apps,却没有 A2UI 渲染器,就可以采用 A2UI in MCP Apps:

把渲染器、组件目录和业务代码一起打包进 MCP App。宿主负责加载 MCP App,App 自己负责绘制 A2UI,界面在 iframe 的隔离视图内生成。

与模式一的差异在于:

MCP Apps 负责渲染 A2UI 负载,而不是宿主应用的前端负责渲染 — UI 渲染器从宿主应用搬进了隔离运行的 MCP Apps。因此宿主应用不必理解这份 A2UI 描述,UI 组件版本和显示效果也由 MCP App 自己维护。

在上面的 Demo 中,你可以用这种方式达到完全一致的效果。

03

三种协议:按需选择,也可以一起出现

上面我们总结了AG-UI、A2UI、MCP Apps的四种协同场景。在实际应用中,当然需要根据解决的问题来选择:

应用场景

可采用哪种组合

选择前提

持续显示任务进度,按需出现 UI,不依赖MCP

AG-UI  +A2UI

前端接好事件分发和 A2UI 渲染器

宿主渲染 UI;基于 MCP 返回动态的 UI 描述信息

A2UI over MCP

宿主支持 A2UI,不要求 MCP Apps和iframe

宿主渲染 UI;局部嵌入 MCP App的专业工具

MCP Apps in A2UI

宿主能渲染 A2UI,并实现 App 容器

宿主加载 MCP App;App内负责渲染动态 UI

A2UI in MCP Apps

MCP App 自带渲染器,宿主无需接入 A2UI

这些接法可以按需组合,也不必一次引入全部协议。比如,现有前端应用只缺 Agent 的进度与反馈,就可以先接 AG-UI;而如果需要给 MCP Tool 添加固定页面,使用 MCP Apps 就行,不一定需要 A2UI。

事实上,这三个协议甚至可以同时出现。以前面 Demo 中的退款场景为例:

  • AG-UI 持续传递 Agent 的回复和处理进度;

  • A2UI 描述外层订单卡片、金额和确认按钮;

  • MCP Apps 承载卡片里的物流取件面板;

而用户看到的是一个工作台,背后的界面却由不同部分负责:

当然,这种多协议的融合,交互过程会比界面的组合更复杂一些:比如,取件面板保存了新时间,外层订单卡和 Agent 怎么知道?这些更新需要应用衔接起来,并不会因为用了三个协议就自动完成。

以前面的 Demo 为例,大致过程如下:

  • 用户选好取件时段并点击保存,App 通过宿主调用 MCP 工具

  • MCP Server 校验并保存安排,结果经宿主返回,取件面板更新

  • 宿主确认 MCP 面板保存成功后,再向 Agent 发送新的请求

  • Agent 读取最新安排,通过 AG-UI 返回回复、进度,以及封装在事件里的 A2UI 更新,前端根据新的 A2UI 消息刷新外层 A2UI 卡片

  • 用户点击“确认退款”,再次发送 Agent 请求,继续后续的任务,更新 UI

这里面涉及到的一些交互的过程、SDK等,可以参考 A2UI 官方文档。

回看上下篇,Agent 时代并没有让前端 UI 消失。

自然语言适合表达任务,但表单、卡片和按钮等仍然有着天然的交互优势 — 负责让使用者更便捷的查看信息、补充条件和作出确认。所不同的是,Agent 时代 UI 出现的时机与内容,更多地需要围绕着任务而变化。

了解每种协议的动机、场景与原理,有助于我们做出架构与设计上的最佳选择;而更具体的开发,当然可以交给 AI Coding 来完成。

本文 Demo :

https://github.com/pingcy/agent-ui-lab

Image

感谢阅读,交流与合作请后台留言

喜欢就关注哦

Image

动动小手点个赞

Image

点在看最好看

Image

跳转微信打开

ChatGPT Intelligent UI

2026年10月8日 16:30

AI大模型应用实践 2026-10-08 16:30 江苏

10 月 7 日,OpenAI 随 GPT-6 发布了 Intelligent UI。

ChatGPT 会根据问题,把文字、图解、图表和交互元素放进同一条回复,适合边看边试的小任务。

比如,自行车图解。

你可以点选传动或刹车系统,相应部件高亮、说明切换;调整滑块,零件从展开状态逐渐靠拢。

目前功能正在分批开放,账号是否已经可用要看实际入口。

跳转微信打开

Agent 时代,前端怎么变?读懂 AG-UI、A2UI 与 MCP Apps 的分工与协同(上)

2026年10月8日 09:00

原创 曾经的毛毛 2026-10-08 09:00 江苏

Agent 时代,前端怎么变?读懂 AG-UI、A2UI 与 MCP Apps 的分工与协同(上)

点击上方蓝字加入我们

在生产级的 Agent 系统中,完成任务的那套引擎和 Harness 固然重要,但大部分系统中,设计良好的前端 UI 应用仍然是不可或缺的重要一环 — 特别是对很多直接面向用户的 AI Native 应用,它关系到最直接的用户体验。

围绕 Agent UI 的构建,之前我们曾经有过一些零散的介绍。

本文将聚焦到 AG-UI、A2UI、MCP Apps 这三种常见标准及其开发,彻底带你看懂各自的定位、能力与区别(上),并探讨它们之间的协同使用(下)。

01 

Agent 时代的 UI 有什么不一样

首先我们来思考下,Agent 系统的 UI 到底有什么不一样?

【自然语言不能取代传统 UI】

在早期 Agent 出现时,很多人认为自然语言就是 Agent 的 UI。

但很可惜,自然语言并不能解决所有的交互问题 — 最简单不代表效率最高。

自然语言很适合表达需求和任务:“把我昨天的订单做退款处理”,这比在菜单与按钮之间反复跳转简单省事。

但如果要看十几个订单,列表显然更清晰;要调整订购数量,用输入框或者滑块也会更方便;而如果需要做二次确认,点个按钮要比输入“我确定”更快捷。

所以 Agent UI 往往是自然语言与传统图形化界面(如 Web UI)的“结合体”。

售后工作台中的流式答复与持续状态更新

当 Agent 与人类需要多次做复杂信息的交互时,HTML 的视觉表达与交互效率要强于干巴巴的文字和 Markdown。

【Agent 需要更加动态的 UI】

传统应用的 UI 大多提前设计,用户按导航与路由逐步推进(比如,搜索页面->订单列表->订单详情->二次确认->操作成功)。

而 Agent 接收任务后,它的任务步骤和路径并不固定 — 先用哪个工具、缺什么信息、什么时候需要人类介入,未必能在开始前确定。

所以,Agent 系统的 UI 很多时候要随着任务更新而呈现(比如,缺少地址,就出现地址选择;涉及付款,就出现金额核对),既要跟上 Agent 的执行,又要给人留出查看、修改和决策的交互入口。

【更多的复杂性】

除了上面的问题,Agent 的交互由于其任务特征还有更多的复杂性。

Agent 的任务可能持续几分钟,甚至更久。所以,Agent 的前端 UI 很多时候除了逐步显示回复,还需要同步当前状态与进度信息:正在调用某个工具、已经处理的任务进度、生成某个产物等等。

而当 Agent 通过 MCP 接入外部系统时,一个问题是:如果这个接口需要持续交互而非简单的一次数据获取(比如查询附近餐厅并订购),那么操作的 UI 从哪里来?如果完全在客户端定制,很显然又会产生极大的耦合性。

而 AG-UI、A2UI、MCP Apps 正是为了解决这些实际的 UI 挑战而诞生。

02 

AG-UI:给交互定义一套共同的表达

AG-UI 全称 Agent-User Interaction Protocol,最早由 CopilotKit(一个 Agent UI开发框架)团队发起,2025 年 5 月公开发布,2026 年 9 月发布的 1.0 已有稳定规范。

【解决什么问题】

如果用一句话介绍 AG-UI 协议:

为 AI 智能体(Agent)与用户界面(UI)之间的实时、双向、结构化通信制定的一个开放事件标准 。

想象一下,前端的 UI 应用需要和后端 Agent 持续通信和交互 — 发送请求、获得回复、了解进度等等,这其中存在大量的交互事件,AG-UI 就是用来统一这些交互的约定:协议、事件、格式等。

需要注意的是:

AG-UI 并不定义 UI 本身 — Agent 事件返回给 UI 后,怎么呈现、卡片长啥样,仍然由前端应用自行决定。

【运作原理】

前端应用提交任务请求后(通常是 HTTP Post),交给 Agent 接收;

由 AG-UI 协议适配层把 Agent 输出转为标准事件持续推送到前端(通常是 HTTP SSE);常见的事件类型比如:任务开始、任务结束、步骤开始、步骤结束、文本回复、文本增量、状态快找、工具调用开始等等;

同样,前端的用户确认事件,也会反馈到 Agent。

【实战开发】

官方 1.0 SDK 支持 TypeScript、Python、.NET。针对不同的 Agent 框架(比如 LangChain),使用对应的适配器即可快速实现 AG-UI 标准的事件输出。

前端可以选 CopilotKit,也可以直接用@ag-ui/client,无须更换整套 UI 框架,因为 AG-UI 并不定义 UI 组件及渲染机制。

我们用一个小案例来演示 AG-UI 的应用(后面将一直沿用这个例子):一个客户服务 Agent,假设在处理一笔订单退款的任务,在二次确认这个环节中,希望用一个更直观的图形 UI 来展示确认信息,并获得反馈。

在这里的例子中,模拟 Agent 调用后,会出现这样的退款确认界面:

注意这里的 UI 仍然是客户端自行实现,但 UI 与后端 Agent 之间的通信则是基于 AG-UI 标准进行。

我们把 Agent 返回前端的 AG-UI 事件打印出来,就可以理解这一点:

可以看到,这里的事件中并没有 UI 元素的信息 — 它们仍然由你自己定义;

它只告诉你 Agent 当前发生了哪些事件,及其携带的必要数据。

03 

A2UI:Agent 描述 UI,前端再渲染

A2UI 全称 Agent-to-User Interface,是 Google 发起、2025 年 12 月公开的声明式 UI 协议;AG-UI 的提出者 CopilotKit 与社区参与贡献。

【解决什么问题】

如果用一句话来介绍 A2UI 诞生的动机:

让后端 AI 以安全、可控、跨平台的方式,动态驱动前端交互 UI 的生成与更新。

所以,A2UI 解决的就是我们第一节所说的动态 UI 的问题。当 Agent 任务需要的 UI 并不遵循固定的交互过程与界面,A2UI 可以传递“前端需要哪些控件、怎样组织、绑定什么数据”,然后由前端用自己认可的组件绘制 UI。

Agent 决定 UI 如何显示;前端应用保留对渲染、样式和可用能力的控制。

【运作原理】

A2UI 的基本运作过程是:

后端发送 JSON 消息给前端“描述” UI — 界面区域(Surface)、组件和数据;

前端的渲染器按组件目录(Catalog)校验、映射到本地控件,并完成渲染;

用户点击产生 Action,经前端应用传回后端,再接收 UI 的更新消息;

  • 为什么有组件目录(Catalog)?

    这是一种安全机制:所有可渲染的 UI 组件(如 Button、Card、Text 等),都需要事先在目录中注册。Agent 只能“请求使用”这些白名单组件,而无法注入任意脚本或超出范围的元素。

  • 同一份描述可以跨端复用。

    前提是双方支持相同的组件版本与 Catalog,但不保证像素级的一致。

  • A2UI 是一种动态 UI 描述协议,所以其传输可以基于简单的 HTTP ;也可以基于前面的 AG-UI 或 A2A 协议来承载。

【实战开发】

继续上面的例子。我们可以用 A2UI 的方法来实现与前面 AG-UI 方法相同的效果。区别在于:

  • AG-UI 是后端只发送任务过程中的事件和数据;UI 如何展现完全由前端负责

  • A2UI 则是由前后端选定支持的组件目录,然后 Agent 直接返回 UI 描述消息

在这个例子中,我们使用了 Column、Text、Image、Button 等几个主要组件。跟踪 Agent 返回的消息可以看到结构如下(部分):

{
"version": "v0.9",
"createSurface": {
"surfaceId": "refund",
"catalogId": "https://refund-demo.local/catalog/v1"
  }
} {
"version": "v0.9",
"updateComponents": {
"surfaceId": "refund",
"components": [{
"id": "root",
"component": "Column",
"appearance": "refund-card",
"children": ["eyebrow", "heading", "status-badge", "product", "details", "amount", "labelhint", "actions", "footer"]
    }, {
"id": "eyebrow",
"component": "Text",
"appearance": "eyebrow",
"text": "REFUND REVIEW / 退款确认"
    }, {
"id": "heading",
"component": "Column",
"appearance": "card-heading",
"children": ["title", "subtitle"]
    }, {
"id": "confirm",
"component": "Button",
"variant": "primary",
"child": "confirm-label",
"action": {
"event": {
"name": "confirm_refund",
"context": {
"taskId": "0eebb393-201d-4e59-9dde-b739341e996d"
          }
        }
      }
    }, {
"id": "cancel",
"component": "Button",
"variant": "secondary",
"child": "cancel-label",
"action": {
"event": {
"name": "cancel_refund",
"context": {
"taskId": "0eebb393-201d-4e59-9dde-b739341e996d"
          }
        }
      }
    }]
  }
}

很显然,与 AG-UI 相比,大家都传递了消息,但一个是用来给前端更新 UI 的事件;一个则是直接的 UI 描述。两者区别很明显。

04

MCP Apps:让工具带着交互 UI

MCP Apps 是 MCP 的官方 UI 扩展,由 Anthropic、OpenAI 等团队共同推动,吸收了 MCP-UI 和 OpenAI Apps SDK 的实践。2025 年 11 月公布提案,2026 年 1 月正式发布。

【解决什么问题】

想象一下,基于 MCP 来连接到企业的 CRM 系统。传统的方法是构建查询数据的 Tool,前端 Agent 将工具返回的数据自定义呈现并实现交互。但问题是:

简单的 Markdown 文本与表格表现力有限,且交互能力薄弱,如数据过滤、下钻、动态面板、非文本数据等,只能通过多轮来回对话实现。

而这就是 MCP Apps 试图解决的问题:

允许 MCP Server 不仅能返回普通文本、代码、JSON等;更能同时返回一个已经设计好的 HTML 前端 UI。

【运作原理】

相比普通的 MCP Tool,MCP Apps 需要的工具会多出一个 ui:// 的资源地址标签(在工具元数据中关联)。

当前端宿主应用发现工具带有 UI 关联后,就会读取对应的 UI 资源(HTML);然后在前端隔离加载到一个 “App” 视图中(运行在 iframe 内);再把工具结果交给 App 进行呈现。

在需要后端 MCP Server 进行交互时,iframe 内的 App 首先通过 AppBridge 与 MCP Client 进行消息通讯(通过浏览器原生 API - postMessage);MCP Client 再调用 MCP Server 中的工具(通过 MCP 标准协议)。

基于安全原因,iframe 内的“App”不能直接与MCP Server通信,必须通过 AppBridge 代理与“中转。

【实战开发】

MCP Apps 可以借助官方的@modelcontextprotocol/ext-apps一系列的开发 SDK 进行 MCP Server 与客户端的开发。

在服务端通过 registerAppTool,registerAppResource 注册工具与UI资源,声明“这是一个带 UI 的工具”,并实现这个工具和页面。

这里的页面最终是运行在前端的 iframe “沙盒”内,除了视觉组件与数据的渲染呈现外,最主要是的是实现动态交互能力。

比如在点击这个 MCP App 的“确认退款”按钮,此时需要调用 Server 端的工具:

...
const result = await app.callServerTool({
  name: "decide_refund",
arguments: { taskId, decision: "confirm" }
});
render(result);
...

 并在完成调用后,根据返回结果更新前端 UI 即可:

当然,开发 MCP Apps 更简单的方法是让 AI 编程工具代你完成。

借助 MCP 官方的几个 Skill ,可以让 AI 快速获得架构指导与最佳实践:

  • create-mcp-app:从零到一个 MCP App项目的脚手架

  • add-app-to-server:给已有的 MCP Server 增加交互式 UI

  • convert-web-app:普通 Web App 转化成 MCP App,快速与 Agent 集成

05 

总结:区别与选择

尽管这三种面向 Agent UI 的标准都与 UI 相关,但各自的定位完全不同:

三种标准解决的是不同环节的问题,我们在选型时可以先看项目缺失了哪部分:

  • 已有前端 UI 页面,需要接入 Agent 的回复、进度和状态,优先考虑 AG-UI,界面仍由前端设计。

  • 需要按任务动态组合表单、卡片,考虑 A2UI;但前提是客户端具备匹配的组件目录与渲染器。

  • 外部工具需要配套地图、编辑器等交互界面,希望随工具一起复用,考虑 MCP Apps,但宿主必须支持该扩展。

需要注意的是,三者可以独立采用,但也可以组合使用。

下篇我们重点来关注它们的组合应用与协同:继续拆解 AG-UI 如何传递 A2UI 消息,以及 A2UI 与 MCP Apps 又如何配合。欢迎继续关注。

感谢阅读,交流与合作请后台留言

喜欢就关注哦

Image

动动小手点个赞

Image

点在看最好看

Image

跳转微信打开

上手体验 OpenAI DevDay 新玩意:Dots、Decisions API、开源 Codex Harness 更新

2026年10月3日 09:00

原创 秋山墨客 2026-10-03 09:00 江苏

OpenAI DevDay 更新不少,哪些真好用?一起来上手体验。

点击上方蓝字加入我们

长假期间,让我们关注些轻松的话题,一起来体验一下前两天 OpenAI DevDay 发布的新玩意。

除了热议的 500 刀新计划、GPT-6.1 Sol 这些不痛不痒的更新,我更关注的是:

  • 云端助手 Dots

  • 用于决策的 Decisions API

  • 开源 Codex-Harness 的更新

  • 协作空间 ChatGPT Space

这些更新,有的给 ChatGPT 用户提供了全新的工作与协同方式,有的给开源项目带来了福利。下面我们一个个看看这些新能力能帮我们做些什么,又能怎样融入自己的应用。

一、Dots:一个能持续跟进的云端助手

本次推出的 Dots,是常驻云端的个人 Agent,由 GPT-6 Astra 驱动。

没错,对标的就是最近火爆的 Muse。

每个 Dot 有自己的电脑和浏览器,可以查资料、处理文件、记住工作背景,并在必要时委派给 GPT Work 或 Codex 任务。

最重要的是,你离开对话后,它仍能推进你交给它的工作任务。

  • 如何使用

使用很简单。将 ChatGPT 更新到最新版本,如果账号已获开放,就能看到 Your Dot 的入口。

你可以定制 Dot 的形象和昵称,这样就拥有了一个随时可以召唤的云端助手:

这里可以看到 Dot 拥有两个电脑:云端电脑可以独立工作;但要处理本机文件、代码和应用,则要在上图中的 Computers 中授权连接本地电脑;使用时本机需保持在线、ChatGPT 应用也需打开,一人只能连接一台个人电脑。

这样,Dot 在工作时可以按需创建本地 Work/Codex 任务,也可以继续指定的本地 Codex 任务(但两边浏览器登录不互通)。

  • “打电话”派任务

你可以在对话中随时“拨打电话”给 Your Dot;接通后,直接布置任务、讨论取舍或追问进度,还能一边说话一边补充文字资料。

比如你可以直接口头吩咐:“替我筹备一个 DevDay 的线上分享会,准备议程和讲解稿,完成后通知我。”(是不是有一种牛马翻身的感觉?)

  • 任务实测

现在我们来让 Dot 完成一个真实的任务,我给它的要求是:

筹备一场 DevDay 的分享会。参考 OpenAI 官方文档,最后交付一份议程 Excel 和一份可以打开阅读的 HTML 讲解材料,一共三个主题,要有茶歇....

然后大概喝杯茶的时间,Dot 会完成任务,并等待你审核:

Dots 实际生成并打开的 HTML:原版 90 分钟议程、演示脚本、环境条件、替代方案和校验程序。

你可以接着在与 Dot 的对话界面中要求进行修改或者调整,这一切和你在本地 ChatGPT中交互并无太大区别 — 只是这些任务都是在云端完成,包括搜索、Web 访问、文档生成、核查;生成的产物默认也会保留在云端(可以下载)。

如果任务需要本机资源,Dot 则可以通过前面连接的本地电脑协同完成。

最后:Dots 目前还只向 Pro 等部分账户开放,且与 Dot 的对话不占用套餐用量。

二、Decisions API:新的决策型接口

前面两篇文章刚介绍过 JEV — 面向高性能场景的决策模型,这不决策API就来了。

Decisions API,顾名思义,就是面向分类、分流和下一步动作选择等场景的决策接口:

你提供文字或图片的上下文、定义问题和有限的候选答案、由 API 做选择。其目标很单一且明确:让 Agent 更直接、快速地拿到判断结果,而不是在“思考”后的长篇大论。

  • 与 Chat API 区别在哪里

传统的 Chat API 通常用来生成回复和解释(虽然也能用结构化输出与提示词限定答案),它很灵活,但如果每个小的控制决策都使用这种 API ,可能带来不必要的延迟和成本。比如:

  • 分类,把邮件归为咨询、投诉或其他

  • 分流,把工单交给售后、技术支持或人工复核

  • 下一步选择,让 Agent 在继续检索、核验结果、询问用户之间选一个

Decisions API 的重点,就是把这类有限选择做成专门的接口。

但不要把 Decisions API 理解成换个名字的Chat API JSON 输出模式。

决策 API 在判断时,有着更短的答案生成路径:它的“答案空间“在推理生成之前就被限定;而不是在文本生成之后再通过 JSON 输出再加以限定。

当然,写长文、规划任务等仍要用通用模型;而明确的 if/else 规则也应该继续写代码,而不是简单的倒向 Decisions API。

  • Decisions API 的使用

目前 Decisions API 尚处于有限预览阶段,下面用一个概念示例说明它的用法,并非官方请求格式:

{
"context": {
"ticket": "The customer was charged twice.",
"account_tier": "business",
"recent_events": ["payment_succeeded", "payment_succeeded"]
  },
"question": {
"name": "route",
"prompt": "Which approved workflow owns this case?",
"answers": ["refund_review", "technical_support", "account_security"]
  }
}

基本思路是:给定一个上下文(context),提出自己的问题(prompt),同时给出候选的答案(answers),然后由 Decisions API 输出最后的决策结果(通常还会结合一个置信度)。

  • Decisions API 对比 JEV

尽管两者都同样面向决策场景,但一个是专用 API,一个是决策模型及其配套接口,不能完全画等号。

  • Decisions API 的背后是 GPT-6 Luna 模型;而 JEV 则是全新的独立决策模型

  • Decisions API 有一个重要的能力 — 支持多模态输入;而 JEV 尚未支持

  • JEV 模型的强化训练方法上采用了不同的 RLCD,即“面向校准决策的强化学习”

  • Decisions API 目前支持的问题形式是 Choice(从候选答案中选择);但 JEV 支持 Choice(选择)、Score(评分)、Noul(是否)三种问题形式

相比传统大模型,两者都有着极高的响应性能(Decisions API 号称比 GPT-6 Luna 快十倍)和更低的成本;不过 Decisions API 还处于局部预览阶段,很可能在正式版会有更多增强。

三、开源 Codex Harness:不影响任务的即时打断

前面主要体验的是 OpenAI 提供的产品和接口,而开源 Codex Harness 的更新,则关系到我们自己的 Agent 系统。

大概总结下,最新版本 Codex Harness 的更新主要有:

    • 即时打断:开启后可以在任务过程中追加要求、调整目标。甚至可以在 Code Mode 的工具调用中让模型先接话,后台继续运行,稍后再收取结果。

    • 历史锚点分页:以某轮任务中的一条记录为“书签”,读取它前后的一段历史。应用可以据此实现“点击某个报错,展开附近的执行过程”这样的功能。

    • CLI 等体验优化:欢迎页更紧凑,等待确认计划时也能翻看历史;Mermaid 图表支持更丰富,复制记录时能保留表格和排版。

    • 权限与运行稳定性修复:批准命令后仍保留明确禁止访问文件的规则,并修复 macOS 沙箱中的 TLS 网络访问、Windows 后台进程闪窗等问题。

    下面来体验下新的即时打断功能(instant_interrupt)。

    • 真实体验 instant_interrupt

    现在用我本地构建的一个 Agent 演示应用 - Forge 做简单测试。Forge 前端通过对话交互,展示消息、工具调用以及输出产物;后端则通过 JSON-RPC 连接 Codex Harness(app-server模式)构建,并可通过适配接入第三方模型(比如我这里接入 MiniMax):

    实测一:打断,修改任务目标

    做一个简单演示:让 Agent 等待一段时间(以留出时间窗口追加指令)后写个 90 分钟提纲;然后我追加指令“改成 45 分钟”。最终 Agent 按照我的追加要求完成了任务:

    MiniMax 的实际交付与追加要求。这里核验的是时间和变更采纳,提纲中的产品表述仍需人工审阅。

    实测二:打断,要求临时先响应

    前一个测试是属于临时修改任务目标和要求,现在来测一个复杂点的场景:

    如果 Agent 的工具调用还没跑完,它是否能够临时“跳出来”先回应我?

    我让 Forge 先启动一个 40 秒的计时任务,随后追加:“先回复已收到变更,再继续等计时结果。” 可以看到,Agent 先回复了“已收到变更,后台计时继续”,然后会接着等待原来的计时任务。计时结束后,它取回了结果。

    也就是说,它先接住了我的话,原来的任务仍在后台继续,没有被停止或重新执行。

    就像同事手上正忙着,听到你补充要求,先应一声,再接着把事情做完。

    四、Space 和 Page:共同工作空间

    在最新的ChatGPT 侧边栏会看到一个 Space 按钮,这就是最新的 ChatGPT Space。

    Space 把页面(page)、文件和共享工作成果放在一起,你可以和 ChatGPT 一起编辑维护其中的内容。

    它解决了工作成果散落在聊天记录里、不方便查找的问题。比如你让 AI 生成的图片、用 Astra 制作的 3D 交互站点等,保存到 Space 后,下次就不用再翻聊天记录,可以直接在这里查找和打开。

    在 Space 中,你可以创建多个空间,按照某个主题、项目或者团队进行组织;并为每个空间设置团队与协作者的访问权限(企业用户)。

    Space 中的一个重要新功能是Page:

    一种支持分块编辑的 MD 协作文档(类似 Obsidian 笔记),供你、同事与ChatGPT共同编辑,可以写作、研究、制作图表、甚至评论。

    Page 最特别的是它与 ChatGPT 的深度集成 — 用斜杠 / 随时唤出 AI 帮助你编辑页面、生成内容。

    比如,唤起 ChatGPT 插入一段内容:

    或者选择 Visualize,插入一个交互式可视化内容:

    你还可以用@命令来链接你的某个历史聊天、其他页面和文件;甚至 @ 你的 Dot 或 ChatGPT,让它们参与页面修改和评论。


    整个体验下来,本次 DevDay 的更新量很足,但真正让人眼前一亮的并不算多。

    有点像当年的苹果,在 iPhone 惊艳亮相后,逐渐转向更稳妥的迭代路线:Dots 让人想到 Muse,Decisions API 则让人联想到 JEV。

    不过尽管方向相近,最终还是要看用起来怎么样。

    对我来说,Dots 能把云端任务与本地工作接起来;Codex Harness 的更新为构建自己的 Agent 系统提供了更强大的 Harness 基座;Space 也让平时的 AI 成果有了一个可以继续整理、修改和协作的空间。这些都有实际价值,也期待它们在后续迭代中变得更成熟、更好用。

    -- END --

    感谢阅读,交流与合作请后台留言

    喜欢就关注哦

    Image

    动动小手点个赞

    Image

    点在看最好看

    Image

    跳转微信打开

    拆解爆火的 JEV(下):在 Agent 系统中的 8 类典型应用场景。

    2026年9月28日 08:30

    原创 曾经的毛毛 2026-09-28 08:30 江苏

    详解 Agent 系统中 JEV 模型的典型应用。

    点击上方蓝字关注我们

    首先祝各位爱好学习的朋友,中秋国庆双节快乐!

    上篇我们认识了 JEV:一个专注于快速判断与决策的“协处理”模型 — 

    给它当前状态;再问“选哪个”“程度多少”“是不是”;它返回结果和概率。

    它精准的针对当前 Agent 系统中普遍存在的“大炮打蚊子”的问题 — 用复杂的推理来完成大量需要高速甚至实时的判断。

    因此,把“JEV 们”放入 Agent,比较合适的位置就是这类决策环节:要不要继续任务、点哪个控件、工具是否安全等;并和 LLM 、确定性程序实现分工合作:

    本篇对 Agent 系统中 JEV (包括其他类似模型)的典型应用场景做拆解。

    01|ReAct 行动循环

    常见的 ReAct Agent 是一种推理与行动交替进行、自主完成任务的系统。其核心的 Agent Loop 会不断的做出类似的判断与决策:

    • 目标任务是否已经完成?

    • 我是否应该重试刚才的工具调用?

    • 我是否需要进入HITL的环节,把控制交给人类?

    • 下一步应该调用哪个工具?

    这些都是代表性的 Choice 或者 Noul 类型的问题。

    通常,这些决定都交给擅长推理的 LLM,很多调用只是在有限”菜单“里选一项。

    现在,这正是 JEV 可以尝试的地方:

    Agent 保存任务目标、每轮输出和更新状态;JEV 负责从当前可选动作(如结束任务、询问用户、调用某个工具等)中判断下一步动作:

    当然, JEV 的答案只是动作建议,完成与否仍然由程序验证;循环上限也由 Agent 代码控制;而遇到要分析复杂状态、生成解决方案的情况,仍需要 LLM。

    你可以用一个简单的自定义 Agent Loop 来验证可行性:

    给 Agent 设定一个任务,以及一些可用的工具,然后让 Agent 根据当前状态(包括目标、 配置、历史消息等)、候选工具来判断下一步动作,直到完成。模拟如下:

    def agent_run(client):
    ...
    try:
    for_in range(8):
                state = env.observe()
                action = client.choose(state, env.instructions, env.criteria)
                env.step(action) 
    if env.done:
    ...

    在这里, “choose”的动作就是交给 JEV 模型来完成的判断。

    实际测试中,如果发现在延时上并没有体现出 JEV 的优势,很可能是网络延迟导致;解决方法是使用本地的开源平替,比如 Laya。

    在这个场景中,JEV 的主要价值是:用毫秒级的决策模型来让 Agent Loop 控制成本更低,速度更快;也因此可以引入更多的检查环节。

    02|Computer Use(Web 自动化)

    Web/GUI Agent 已经成为 AI 应用的重要形态。但常见的问题是:消耗资源且延时较大,特别是使用视觉模型辅助的这类 Agent。

    这类 Agent 的传统做法都是让 LLM 反复读取页面(DOM 或者截图)、生成下一步操作,长页面和多步任务会不断消耗时间与上下文。

    那么,是否可以这样改进:

    把当前页面能做的 UI 操作先整理成一个“菜单”(Choices),用 JEV 这类高速决策模型来回答“操作哪个元素、做什么动作”,以指导 Agent 下一步的动作。

    著名的开源项目 Browser Use 已经提供了这样一个开发库:jev-ultrafast。让你可以借助 JEV 来使用 Browser Use 框架实现 Web Agent:

    from jev_ultrafast import Agent
    with Agent(
    "...web agent 任务“
    ) as agent:
    for state in agent.run():
    print(state["elapsed_ms"], state["status"])

    小编用 jev-ultrafast 做了一个简单演示,完成一个酒店搜索的任务:

    GOAL = ("Search for hotels in Hangzhou. Set the nightly budget filter to CNY 500 or less "
    "and enable the breakfast-included-only filter, then apply the filters. "
    "Open the matching hotel's details and verify that its city is Hangzhou, "
    "its nightly price is at most CNY 500, and breakfast is included. "
    "Stop on that details page. Do not make any booking.")

    这里使用 jev-ultrafast 的 Agent 等相关 API 来完成任务,对其每一步的选择(choose)进行了跟踪,并输出最后的停留页面:

    当然,这种方案目前并不完美:

    遇到未暴露为可选元素的控件、需复杂视觉识别的场景或开放文本等,仍需要浏览器能力和多模态的 LLM 配合。不过这也让我们更加期待多模态的“JEV”们的出现。

    03|工具与技能路由

    工具(Tool)和技能(Skill)体系是 Agent Harness 最重要的组成之一。

    传统 Agent 把每个工具的描述和技能都塞进模型上下文,然后让模型判断并生成工具调用;工具目录越大,描述越长,相近工具越容易混淆,且 Token 消耗越大。

    借助 JEV 这样的决策模型,Agent 可以:

    把“需要哪些工具”变成一个 Choice 问题:基于“分层路由”(Hierarchical routing)的模式,实现像医院分诊一样的工具选择路径 — 尤其当工具集稳定、用途清晰时。

    先选医院(工具大类),再选科室(激活工具集),再找医生(本轮工具)。

    这对于平台级的 Agent 来说(工具目录经常动态变化),可以让模型看到一个更小、更相关的工具范围,减少干扰,提高推理准确性。比如:

    第一层让 JEV 从“公共、财务、编程、检索、管理”等类别做选择。选中“财务”后,程序再加载这个分支;让第二个 Choice 从“查询余额、开发票、退款、对账”中再选一个。

    当然,在具体实现时,需要做更精细化的控制和评估:

    • 结合confidence(置信度):拿不准就保留多个候选继续比较,或让用户澄清;每层也要有“不匹配”的出口,避免第一步选错就一路错到底。

    • 分层能缩小选择范围,但代价是增加误选或遗漏;使用决策模型后是否真的更快、更准,需要在上线前做批量评估。

    JEV 的 Choice 单题最多支持 255 个选项,并非有几十个工具就必须分层。

    04|工具安全守卫

    随着各种通用 Agent 的盛行,给这些 Agent 的工具执行设置安全“门禁”至关重要。常见的方法有:

    • 给工具设置安全级别:严重的要求人工审核,但容易被“忽视“

    • 关键词拦截:根据工具、参数等识别关键词,但容易“误伤”

    • 交给 LLM 判断:频繁审查增加延迟和成本,而且同一模型审查意义不大

    更稳妥的架构,是在工具执行之前设一道语义守卫:

    根据本次调用和对话状态判断工具风险,据此放行或拦截;当风险不确定或后果严重时,也可以转入人工环节。

    这个工作就很适合 JEV 这样的快速模型。比如提出 Noul 类型且有明确标准的问题:“是否包含提示注入?”、“是否泄露敏感信息?”、“输出是否违反约定?”等,然后返回概率,再由程序决定放行、拦截或交人类复核:

    LangChain 已经把这个模式用中间件(一种类似钩子的机制)进行了封装:AutoModeMiddleware。它在工具执行前调用 JEV,风险达到阈值就返回拦截消息:

    guard = AutoModeMiddleware(tools=tools)
    agent = create_agent(planner, tools=tools, middleware=[guard])
    result = agent.invoke({"messages": [HumanMessage(content=task)]})

    你也可以自定义一个工具门禁:实现一个 Middleware,然后在 wrap_tool_call 中借助 JEV/Laya 做判断处理。比如:

    class LLMAutoMode(AgentMiddleware):
        ......
    defwrap_tool_call(self, request, handler):
            answer = self.judge.invoke(...);
    if answer.risk_estimate >= 0.5:
    return ToolMessage(
                    content=(f"The tool call `{request.tool_call['name']}` was blocked because "
    f"it was classified as risky (LLM estimate: {answer.risk_estimate:.2f}). "
    "The tool was not executed."),
                    tool_call_id=request.tool_call["id"], name=request.tool_call["name"], status="error")
    return handler(request)

    在这里,借助决策模型的优势是 — 

    你可以在一次任务中做很多这样细小的风险检查,而不用担心延迟与成本。

    但正如我们之前强调的,JEV 们宣传的“无幻觉”不代表不会决策错误,所以结合使用其他的一些风控机制,仍然是必要的。

    05|Agent 任务评估与观测

    当 Agent 报告任务已经完成,大部分时候我们会选择“信任”它 — 再通过人工审查、代码测试等方法来评估其完成度。

    还有一个常见做法是请另一个 LLM 当“评委”:

    读取 Agent 的执行轨迹,并给出评估结果。不过这种评估大多缓慢且结果非结构化。

    现在,借助 JEV 这类模型可以把评估拆分成更具体的问题:

    用 Noul 检查任务是否完成、是否违规、是否需要人工复核;用 Score 评估任务完整程度、问题紧急程度;用 Choice 告诉你是完成、重试、放弃还是人工复核。

    这种方案可以很好的用于监控 Agent 任务完成情况与质量,并指导后续改进。

    比如,分析客服 Agent 中的详细跟踪日志 — 如果你对每天成千上万次 Agent 的运行生成这样的分析结果,就可以用来监控服务质量、做A/B对比、失败分析、甚至做自己的训练样本筛选。

    考虑到 JEV 这类模型的性能与成本,你可以让这种评估真正的融入到 Agent 的日常监控与观测,而无需担心 Token 爆表。

    06|模型与 Agent 路由

    在 Agent 任务中,让 LLM 写一封邮件,与在多约束条件下进行一次规划,需要的能力并不相同。但大部分时候(特别是单 Agent 系统),我们会倾向于使用统一的模型。问题是,如果全用强模型则造成浪费;而全用小模型,则任务质量下降甚至返工。

    一种方法是让 LLM 先做模型分流,但这个动作本身又是开销。

    而 JEV 就更适合回答这种边界清楚的路由题:

    给定请求、候选模型以及判断标准(各模型擅长的任务),让 JEV 帮你选择合适的处理者,给出建议与概率。

    你还可以结合任务难度、风险与不确定性等制定分流标准。

    当然,如果把候选从 LLM 换成“研究、编程、数据分析”等专业 Agent,同样可以用于 Agent 任务的分派与交接(意图识别)。

    在具体的实现中,结合 Confidence 置信度进行一些保护也是必要的,而不是简单的选取概率最高者 — 路由错误导致的返工或质量的代价,要远大于一次路由的代价。

    LangChain 官方也实现了这样一个 Middleware:ModelRouterMiddleware,可以很方便的让 Agent 具有根据复杂度选择合适模型的能力:

    router = ModelRouterMiddleware(choices={
    "fast": ModelChoice(model=fast, criteria="单笔查询"),
    "powerful": ModelChoice(model=powerful, criteria="多约束规划"),
    }, instructions="选择能完成任务且成本最低的模型")
    agent = create_agent(fast, tools=tools, middleware=[router])

    这里的 criteria 参数告诉路由器各模型适合的任务,也就是分流的判断标准。其目前的机制是:在一次 Agent Loop 运行开始时根据最新的用户消息选择模型,后续则复用。

    07|RAG 与上下文管理

    RAG 管道的价值大部分时候并不取决于模型,而是数据或知识的质量,以及检索的相关性与完备性。而基于向量相似性的语义检索并不足以解决这个问题,这也是出现众多高级 RAG 方法(C-RAG,Self-RAG等)的根本原因。

    一种常见的优化思路是用 LLM 对语义检索的结果进行相关性判断,并根据结果进行必要的知识筛选、补充(比如 Web 搜索),或 Query Rewrite。

    现在你可以借助 JEV 等决策模型:

    让它充当检索知识进入上下文前的“筛选员”,对知识相关度进行评估与过滤。

    很显然,JEV 模型非常适合回答这类问题:

    • Noul:这段知识是否能够支持回答输入问题?

    • Score:这段知识与输入问题的相关程度如何?

    • Noul :这些知识是否足够回答用户的输入问题?

    根据这些问题的答案,你可以选择废弃不相关知识,或补充更多知识:

    大致的程序处理逻辑如下:

    ...
    def rag(question, retrieve, llm_answer, client):
    # jev判断是否相关
    def judge(instructions, **state):
    return client.system_one(
                state=state,
                questions={"ok": Noul(instructions=instructions)},
            ).nouls["ok"].noul
        kept, seen = [], set()
    for _ in range(3): # 最多三轮检索
    for chunk in retrieve(question, exclude=seen):
                seen.add(chunk.id)
    if judge("片段包含回答问题所需的信息吗?",
                         question=question, chunk=chunk.text) > 0.5:
                    kept.append(chunk)
    # jev判断知识是否足够
    if kept and judge("这些知识足够回答问题的所有要点吗?",
                              question=question,
                              evidence=[c.text for c in kept]) > 0.8:
    return llm_answer(question, kept)
    return"资料仍不足,需要补充信息"

    所以,现在你可以构建一个两阶段的检索策略:

    先做更宽泛的检索(比如 Top_k=10);然后借助决策模型做低成本的筛选;最后将选中的知识用来生成答案。

    另外,你可以使用决策模型输出的概率来实现类似排序模型(Rerank)的能力:

    这里的评分可以使用 Noul 输出的概率,也可以使用 Score 评分并结合置信度。

    这套思路也能用于 Agent 的上下文管理。方法很简单:

    让 JEV 判断旧的对话记录是否仍有用,再由程序来执行保留或废弃;而不是直接让 LLM 去做历史对话的摘要 — 容易带来上下文丢失。

    GitHub 上有一个 Claude Code 插件fast-jev-compaction ,其通过评分来废弃无用的工具调用及结果,只保留重要内容,从而达到精简上下文的目的。

    08|实时动态决策

    最后是一个收益最大的场景:实时决策。

    在游戏、仿真、机器人等环境里的 AI 需要极其快速的反应(毫秒级):下一步应该怎么做?因为每走完一步,下一步的“路”可能就变了。

    如果让 LLM 每轮从头推理,则性能无法满足要求(想象下,游戏里的 NPC 每次要思考 5 秒才有反应);而使用固定规则又不够智能。

    现在你可以让 JEV 们和 LLM 们来配合:

    LLM 负责长期的目标规划 。比如完成任务的主要步骤;JEV 负责在每一步骤中,根据环境状态做出可能需要的快速判断;

    举一个例子:

    一个仓库配送机器人要完成“把某个包裹送到打包台”。

    LLM 可以拆解并规划出路径:确认包裹 → 前往货架 → 取件 → 运到打包台。

    但是执行到一半,通道被货物挡住,此时则由 JEV 来根据当前环境、位置、可选动作来判断下一步怎么做。

    这里的状态(State)可以来自游戏引擎、环境传感器或 API 接口等;而程序的执行通常由专用的控制系统负责。

    不过由于当前的决策模型还不支持视觉理解,这也在很大程度限制了其应用;相信随着未来多模态能力的解锁,将带来这类快速反应系统能力上的突破。

    总结

    以上是我们为大家拆解的 JEV (包括其他类似的开源模型)在 Agent 系统中的一些典型应用场景。

    总结来说,JEV 很适合 Agent 里高频、高性能、答案有限的判断与决策。

    更多应用层面的场景,如意图识别、邮件分类、工单分流、内容打标等,都能沿用这套思路 — LLM 做规划生成,JEV 做高速判断,程序则负责确定性执行;以减少不必要的 Token 开销,提高决策速度,并由此产生更多收益。

    -- END --

    感谢阅读,交流与合作请后台留言

    喜欢就关注哦

    Image

    动动小手点个赞

    Image

    点在看最好看

    Image

    跳转微信打开

    ❌