铃阅
❌

普通视图

AI X Engineering:Harness 工程

2026年11月15日 23:26

原创 半吊子全栈工匠 2026-11-15 23:26 哈萨克斯坦

Harness 不是一个已解决的问题,也不是一个商品化层。它是工程所在——将上下文作为稀缺资源管理、设计在失败复合前捕获它们的验证循环、构建提供连续性而不产生幻觉的记忆系统、以及在搭建多少脚手架与留多少给模型之间做架构决策......

【引】Prompt Engineering,Context Engineering,Harness Engineering,Loop Engineering,Graph Engineering....... 我把他们临时称为AI X Engineering,他们各是什么?有什么区别和联系呢? 老码农希望通过系列文章把他们弄清楚。

Harness Engineering:当模型不再稀缺,真正的工作才刚刚开始

同样的模型,同样的权重,仅仅更换了支持它的基础设施,Agent 的效能就有了飞跃式的提升。这个事实把Agent Harness工程推到了台前。

Agent 的能力边界不由模型单独决定。 自主软件工程能力是从「模型-Harness-环境」系统中涌现的,而非仅从模型中产生。在模型能力趋于同质化的 2026 年,Harness 是系统之间最主要的差异来源。Harness 工程是提示工程与上下文工程之后的工程演进。它把编排循环、工具、记忆、上下文管理、状态持久化、错误处理、权限、验证与可观测性整合为一个完整的运行时系统,其角色类似于 Agent 的操作系统。

Harness 与模型是协同进化的关系,而非静态的外壳。 一方面,模型改进应当允许 Harness 变薄;另一方面,对 Harness 本身的自动化迭代(工具、中间件、记忆)带来的性能提升,已经超过了对提示词的优化。

本文尝试对这个正在成形的工程方法做一次系统性的梳理——它是什么、由什么构成、如何演进,以及它为什么会成为 AI 工程的核心议题。

一、两个实验与一个被命名的对象

先看两个可查证的事实。

第一个来自 LangChain。他们没有更换底层模型,只改进了包裹 LLM 的基础设施,如编排方式、工具设计、上下文管理,就曾在 TerminalBench 2.0 基准上从 30 名开外上升至第 5 名。另一个项目则更进一步:让 LLM 自行优化这套基础设施,最终达到 76.4% 的通过率,超过了人工设计的系统。

第二个来自一篇 2026 年的工程报告。OpenAI 描述了一个内部实验:Codex Agent 从一个空仓库出发,逐步生成并塑造出一个生产级软件产品——仓库结构、CI 配置、格式化规则、包管理器设置、应用框架,甚至包括引导后续 Agent 在仓库内工作的初始AGENTS.md文件。这个实验的关键启示不在于模型写了代码,而在于仓库、文档、测试、工具和反馈回路共同构成了一个 Agent 可以工作的环境。

这两个事实指向同一个结论:Agent 不是在真空中运行的。围绕模型存在一套完整的软件基础设施,它决定模型看到什么、能做什么、失败后如何恢复、输出如何被验证。这套基础设施在 2026 年初被正式命名为Agent Harness。

Anthropic 在 Claude Code 的文档中说得相当直白:其 SDK 就是「驱动 Claude Code 的 agent harness」。LangChain 的 Vivek Trivedy 给出了一个更彻底的表述:“如果你不是模型,那你就是Harness。”

换言之,我们通常说的「Agent」是一种涌现行为,那个用户与之交互的、目标导向的、使用工具的、能够自我纠正的实体。而 Harness 是产生这种行为的机器。当有人说“我构建了一个 Agent”时,更准确的说法是:他构建了一个 Harness,并将它指向了某个模型。

二、Harness 是什么

从工程角度,可以给出一个工作定义:

Harness 是包裹 LLM 的完整软件基础设施,包括编排循环、工具接口、记忆系统、上下文管理、状态持久化、错误处理、权限控制和安全护栏。

这个定义没有争议的部分是“包裹”;有争议的是“包裹到什么程度”。为此,Beren Millidge 在 2023 年提出过一个影响深远的类比,把裸 LLM 映射为一台缺少外围系统的计算机:

计算机组件

Agent 系统中的对应物

工程含义

CPU

裸 LLM(模型权重)

只负责计算,本身不构成可用系统

RAM

上下文窗口

快速但有限,断电即失

硬盘

外部数据库 / 向量库

大容量但访问慢,需检索机制

设备驱动

工具集成

标准化地连接外部能力

操作系统Agent Harness

调度资源、管理进程、提供安全边界

应用程序

Agent(涌现行为)

用户实际感知到的产品形态

这个类比的高明之处在于:没有人会认为 CPU 的频率决定了一台计算机的全部价值,同样,也不应该认为模型的 benchmark 分数决定了 Agent 系统的全部价值。裸 LLM 是一颗没有 RAM、没有磁盘、没有 I/O 的 CPU,而Harness 是让它可用的操作系统。

值得说明的是,“Harness”一词源自马具(马的挽具)与测试工程中的 test harness,两层含义在这里恰好都成立:它既是对模型这匹“马”的约束与引导,也是一组标准化的执行与观测设施。

三、三层工程,从提示词到运行时

围绕大模型存在三个同心层级的工程,它们的边界需要弄清楚:

层级

名称

工程对象

典型问题

第一层

提示工程(Prompt Engineering)

模型接收的指令文本

怎么说,模型才照做?

第二层

上下文工程(Context Engineering)

模型在每一步看到什么信息

什么信息、何时、以何种形式进入窗口?

第三层

驾驭工程(Harness Engineering)

模型周围的整个应用基础设施

系统如何可靠地完成工作并证明自己完成了?

Anthropic 将上下文工程描述为提示工程之上的进展,专注于策展和管理推理期间 Agent 可用的信息。Harness 工程则更进一步,它要回答的问题包括:Agent 应该知道什么?Agent 能做什么?Agent 永远不该做什么?Agent 如何记忆、如何验证、如何恢复?人类如何审计它?系统如何在失败后改进?

这些问题已经不属于提示词的范畴,而属于系统工程的范畴。用一句概括:提示工程让 AI 有用,上下文工程让 AI 更相关,Harness 工程让 AI 可运营。

四、能力从「模型-Harness-环境」系统中涌现

如果要把 Harness 工程从经验总结提升为一个具有学术色彩的研究方向,2026 年出现的三份文献值得关注。这里按其主张的激进程度依次介绍。

  1. 《AI Harness Engineering: A Runtime Substrate for Foundation-Model Software Agents》。这篇论文的核心论点是:自主软件工程能力从模型-Harness-环境系统中涌现,而非仅从模型中产生。论文给出了 Harness 的职责清单:任务规约、上下文选择、工具访问、项目记忆、任务状态、可观测性、失败归因、验证、权限、熵审计与干预记录。这份清单的意义在于,它把 Harness 从工程最佳实践提升为「运行时基座(runtime substrate),一个有明确职责边界的系统层。

  2. 《Code as Agent Harness》。这篇论文论证了代码在 Agentic 系统中的角色正在变化:它不再仅是 LLM 的输出,而是越来越多地充当推理、行动、环境建模和基于执行的验证的操作基础。提示词是指令,文档是知识,工具是能力,追溯是证据,但代码是操作结构——工作流、工具、测试、策略、状态机、验证器、沙箱、审批门,最终都以代码的形式定义。由此推出的推论是:AI 原生工程团队会把代码、文档、测试和追溯视为一个组合的 Agent 环境,仓库成为工作空间,文档成为记忆,测试成为验证,CI 管道成为反馈。

  3. 《Agentic Harness Engineering》。这篇论文引入了一个可观测性驱动的闭环,用于自动进化编码 Agent 的 Harness。实验结果相当具体:十次迭代将 TerminalBench 2 上的 pass@1 从 69.7% 提升到 77.0%,且实验把收益定位到工具、中间件和长期记忆,而非系统提示词。这为“改进 Harness 比改进提示词更有效”提供了直接的实证支持。

三个来源、三种路径(架构论、代码论、进化论),结论指向一致:更好的系统 = 更好的模型 + 更好的 Harness + 更好的环境,而不是旧思维中的“更好的模型 = 更好的系统”。

从产业侧看,Theory Ventures 的风险投资人给出了一个与学术界呼应的判断:软件工程的核心已经从“构建用户界面、管理数据”转向“搭建将大模型转化为可靠智能代理的框架、运行时、约束与可靠性层”。他们把围绕 LLM 的这套体系概括为七个组件:

组件

回答的问题

关键要素

Context & Memory

模型看到什么

工作记忆、长期存储、检索与 RAG 管道、提示组装

Tools & Action

模型如何行动

工具注册表(MCP)、分发与参数验证、外部 API、权限与审批门

Orchestration & Loop

模型如何思考

思考→行动→观察循环、规划与分解、子 Agent 与委派、重试/预算/停止条件

State & Persistence

模型记住什么

文件系统与工作空间、检查点与恢复、会话持久化、工件与快照

Sandbox & Compute

模型在哪里运行

隔离的 Unix 工作空间、受控网络出口、独立于模型的凭证管理

Observability & Governance

如何信任模型

追踪与结构化日志、评估与回归套件、护栏与策略、人在回路

Cost & Workflow Optimization

如何选择在哪运行

确定性 vs 非确定性逻辑、模型分级选用、技能 vs 记忆编码、Token 与延迟预算

这张表值得与后文的十一组件解剖对照阅读:产业视角的七组件与工程视角的十一组件,覆盖的是同一个对象,只是切分粒度不同。

五、生产级 Harness的11个组件

综合 Anthropic、OpenAI、LangChain 与更广泛的从业者实践,一个生产级 Agent Harness 包含十一个独立组件。

1. 编排循环(Orchestration Loop)

这是 Harness 的心跳。它实现「思考-行动-观察」(TAO)循环,也称 ReAct 循环:组装提示词 → 调用 LLM → 解析输出 → 执行工具调用 → 反馈结果 → 重复直到完成。

机制上它通常只是一个while循环——复杂性不在循环本身,而在循环所管理的一切。Anthropic 将其运行时描述为一个「笨循环」(dumb loop):所有智能都在模型中,Harness 只管轮次。

2. 工具(Tools)

工具是 Agent 的双手,以模式(名称、描述、参数类型)的形式注入上下文。工具层负责注册、模式验证、参数提取、沙箱执行、结果捕获,以及将结果格式化为模型可读的观察。

Claude Code 提供六大类工具:文件操作、搜索、执行、网络访问、代码智能和子 Agent 生成;OpenAI 的 Agents SDK 则区分函数工具、托管工具(WebSearch、CodeInterpreter、FileSearch)与 MCP 服务器工具。工程上需要特别注意:套件的质量很大程度上取决于安全暴露工具的数量与处理工具故障的能力,而非工具的总数。

3. 记忆(Memory)

记忆在多个时间尺度上运作。短期记忆是单会话内的对话历史;长期记忆跨会话持久化——Anthropic 使用CLAUDE.md项目文件与自动生成的MEMORY.md,LangGraph 使用按命名空间组织的 JSON 存储,OpenAI 支持由 SQLite 或 Redis 支撑的 Sessions。

Claude Code 实现了三层层级:轻量级索引(每条约 150 字符,始终加载)、按需拉取的详细主题文件、以及仅通过搜索访问的原始记录。这一设计的动机是成本与信号的平衡:把总是需要的信息常驻,把偶尔需要的信息按需加载。

4. 上下文管理(Context Management)

这是许多 Agent 静默失败的地方。核心问题是上下文腐化(context rot):当关键内容落在窗口中间位置时,模型性能可能会下降超过 30%;即使是百万 Token 的窗口,随着上下文增长也会出现指令遵循能力退化(这与 Liu et al. 2023 年的「lost in the middle」发现一致)。

生产级策略有四类:

  1. 压缩(Compaction):接近窗口限制时总结对话历史,Claude Code 的做法是保留架构决策和未解决的 Bug,丢弃冗余工具输出;
  2. 观察遮蔽(Observation Masking):JetBrains 的 Junie 隐藏旧工具输出,同时保持工具调用本身可见;
  3. 即时检索(Just-in-time Retrieval):维护轻量级标识符并动态加载数据,Claude Code 使用grep、glob、head、tail而非加载完整文件;
  4. 子 Agent 委派:每个子 Agent 大量探索,但只向父 Agent 返回 1,000 到 2,000 Token 的精炼摘要。

Anthropic 的上下文工程指南把目标概括为一句话:找到最小的高信号 Token 集,最大化期望结果的可能性。ACON 研究为这个方向提供了量化支持:通过优先保留推理轨迹而非原始工具输出,可在保持 95% 以上准确率的同时减少 26%–54% 的 Token。

5. 提示词构建(Prompt Construction)

这一步组装模型在每一步实际看到的内容,它是分层的:系统提示词、工具定义、记忆文件、对话历史、当前用户消息。

OpenAI 的 Codex 使用严格的优先级栈:服务器控制的系统消息(最高优先级)→ 工具定义 → 开发者指令 → 用户指令(级联AGENTS.md文件,总量 32 KB 限制)→ 对话历史。优先级栈的意义在于,当不同来源的指令冲突时,系统行为是可预测的。

6. 输出解析(Output Parsing)

现代 Harness 依赖原生工具调用:模型返回结构化的tool_calls对象,而非需要正则解析的自由文本。Harness 的判定逻辑很简单——有工具调用就执行并循环,没有就给出最终答案。

对于结构化输出,OpenAI 与 LangChain 都支持通过 Pydantic 模型进行模式约束。旧的方法如RetryWithErrorOutputParser(将原始提示词、失败补全和解析错误一起喂回模型)仍可用于边缘情况。

7. 状态管理(State Management)

LangGraph 将状态建模为流经图节点的类型化字典,使用 reducer 合并更新,检查点发生在超步边界处,支持中断后恢复和时间旅行调试。

OpenAI 提供四种互斥策略:应用内存、SDK 会话、服务端 Conversations API、或轻量级previous_response_id链接。

Claude Code 则采取了一种更朴素的方式:以 git 提交作为检查点,以进度文件作为结构化草稿本。

三种做法的共同点是:状态必须外置于模型——模型本身是无状态的,这是后文“协同进化”的物理基础。

8. 错误处理(Error Handling)

这里有一个每个架构师都该记住的算术:一个 10 步流程,每步 99% 的成功率,端到端成功率只有约90.4%——因为错误会复合。步骤越长,对单步可靠性的要求就越苛刻,这是 Agent 系统与单轮问答在工程上的本质区别。

LangGraph 区分四种错误类型:瞬时错误(带退避重试)、LLM 可恢复错误(将错误作为 ToolMessage 返回,让模型自行调整)、用户可修复错误(中断并请求人工输入)、意外错误(上抛供调试)。Anthropic 的做法是在工具处理器内捕获失败并作为错误结果返回,保持循环不中断;Stripe 的生产级 Harness 则将重试次数上限设为两次。

9. 安全护栏(Guardrails and Safety)

OpenAI 的 SDK 实现了三个层级:输入护栏(在第一个 Agent 上运行)、输出护栏(在最终输出上运行)、工具护栏(在每次工具调用上运行),并以「绊线」机制在触发时立即停止 Agent。

Anthropic 在架构上做了一个重要区分:权限执行与模型推理分离——模型决定尝试什么,工具系统决定允许什么。Claude Code 独立门控约 40 个离散工具能力,分三个阶段执行:项目加载时的信任建立、每次工具调用前的权限检查、高风险操作的显式用户确认。

10. 验证循环(Verification Loops)

这是区分玩具演示与生产级 Agent 的关键。Anthropic 推荐了三种方法:基于规则的反馈(测试、lint、类型检查器)、视觉反馈(通过 Playwright 截图用于 UI 任务)和LLM-as-judge(由独立的子 Agent 评估输出)。Claude Code 的创造者 Boris Cherny 的经验数据是:给模型一种验证自己工作的方式,可以将质量提升2 到 3 倍。

验证机制也可以按 Thoughtworks 团队的方式分为两类——引导(feedforward,行动前引导)与传感器(feedback,行动后观察),前者如 lint 与类型检查,后者如测试与评审。

11. 子 Agent 编排(Subagent Orchestration)

Claude Code 支持三种执行模型:

(1)Fork:父上下文的字节级相同副本

(2)Teammate:独立终端窗格,基于文件的邮箱通信

(3)Worktree:独立 git worktree,每个 Agent 一个隔离分支

OpenAI 的 SDK 支持 agents-as-tools(专家处理有界子任务)与 handoffs(专家接管完全控制)两种模式;LangGraph 则将子 Agent 实现为嵌套状态图。三种方案的共同设计约束是:子任务需要隔离的上下文,结果必须以受控的方式回流。

六、一次循环的逐步走查

组件清单是静态视角,要看 Harness 如何工作,需要追踪一次完整的循环,整个过程可以概括为七步:

  1. 提示词组装:Harness 构建完整输入——系统提示词 + 工具模式 + 记忆文件 + 对话历史 + 当前用户消息。重要上下文被放置在提示词的开头和结尾(依据「迷失在中间」的发现)。
  2. LLM 推理:组装好的提示词发送给模型 API,模型生成输出 Token:文本、工具调用请求,或两者兼有。
  3. 输出分类:不含工具调用的文本意味着循环结束;请求了工具调用则进入执行;请求了交接(handoff)则更新当前 Agent 并重启。
  4. 工具执行:对每个工具调用,验证参数、检查权限、在沙箱环境中执行并捕获结果。只读操作可并发执行,变更操作串行执行。
  5. 结果打包:工具结果被格式化为模型可读的消息;错误被捕获并作为错误结果返回,让模型可以自我纠正。
  6. 上下文更新:结果追加到对话历史;若接近窗口限制,触发压缩。
  7. 循环:返回第 1 步,重复直到满足终止条件。

用伪代码表达,这个循环的骨架大致如下:

while True:
    prompt = assemble(system_prompt, tools, memory, history, user_msg)
    response = llm.call(prompt)                # 步骤 1-2
    if not response.tool_calls:                # 步骤 3
        return response.text                   # 终止:任务完成
    for call in response.tool_calls:           # 步骤 4
        if not guardrail.check(call):          # 权限检查(此处被门控)
            result = ToolError("permission denied")
        else:
            result = sandbox.execute(call)     # 沙箱执行
    history.append(pack(results))              # 步骤 5-6
    if near_limit(history):                    # 上下文压缩
        history = compact(history)

循环部分确实简单,但每个步骤背后都有大量基础设施在支撑。终止条件是分层的:模型产生不含工具调用的响应、超过最大轮次限制、Token 预算耗尽、护栏绊线触发、用户中断、或安全拒绝返回。一个简单问题可能只需 1–2 轮;一个复杂重构任务可能跨多轮链式调用数十个工具。

对于跨越多个上下文窗口的长运行任务,Anthropic 开发了一个两阶段的Ralph Loop模式:先由一个初始化 Agent搭建环境(初始化脚本、进度文件、功能列表、初始 git 提交),此后每次会话中的编码 Agent读取 git 日志和进度文件来定位自己,选择最高优先级的未完成功能,处理它,提交,并写摘要。这个模式的精髓在于:文件系统提供了跨上下文窗口的连续性,上下文窗口会清空,但仓库不会。

七、十二层参考架构:从组件到栈

当 Agent 系统从单机脚本演进为企业基础设施时,组件清单需要重新组织为分层架构。下面这份 2026 年的参考技术栈把前述组件扩展为十二层:

┌──────────────────────────────────────────────────────┐
│           12. Self-Evolving Harness Layer            │
│          自进化层(基于追踪和结果改进自身)             │
├──────────────────────────────────────────────────────┤
│           11. Observability Layer                     │
│          可观测性层(模型调用/工具调用/追溯/成本)       │
├──────────────────────────────────────────────────────┤
│           10. Verification Layer                      │
│          验证层(测试/评估/模式检查/验收标准)           │
├──────────────────────────────────────────────────────┤
│           9. Safety & Security Layer                  │
│          安全层(最小权限/沙箱/审计日志/熔断开关)       │
├──────────────────────────────────────────────────────┤
│           8. Identity & Permission Layer              │
│          身份权限层(OAuth/作用域/角色/审计)            │
├──────────────────────────────────────────────────────┤
│           7. Memory Layer                             │
│          记忆层(短期状态 + 长期知识)                   │
├──────────────────────────────────────────────────────┤
│           6. Runtime & State Layer                    │
│          运行时层(会话/重试/中断恢复/审批/交接)         │
├──────────────────────────────────────────────────────┤
│           5. A2A Agent Gateway                        │
│          Agent 间网关(跨框架/跨厂商安全通信)            │
├──────────────────────────────────────────────────────┤
│           4. MCP Tool Gateway                         │
│          工具网关(文件/数据库/API/CRM/代码仓库)        │
├──────────────────────────────────────────────────────┤
│           3. Knowledge Layer (Obsidian-Style)         │
│          知识层(Markdown 仓库 = Agent 长期记忆)        │
├──────────────────────────────────────────────────────┤
│           2. Context Router                           │
│          上下文路由器(每步决定什么信息进入窗口)          │
├──────────────────────────────────────────────────────┤
│           1. Model Layer                              │
│          模型层(LLM/VLM/编码模型/嵌入模型)             │
└──────────────────────────────────────────────────────┘

与前面的11组件相比,这个技术栈新增或强化了四个层,值得单独说明。

上下文路由器(第 2 层)被提升为独立的一层,因为「每一步决定什么信息进入窗口」是贯穿全流程的持续决策,而非一次性配置。原则很朴素:Demo Agent 接收一切,生产 Agent 接收正确的东西——太多上下文制造噪音,旧上下文制造矛盾,无关上下文分散注意力,敏感上下文制造安全风险。

知识层(第 3 层)的主张是:Agent 的长期记忆应当以 Markdown 纯文本文件为载体,放在可版本化的仓库中。Obsidian 的 vault 架构为此提供了原型——Markdown 文件人类可读、Agent 可读、可在 Git 中版本化、可成为 RAG 源、可成为项目记忆与执行上下文。一个企业级知识库通常包括AGENTS.md、ARCHITECTURE.md、DECISIONS.md、WORKFLOWS.md、EVALS.md、PLAYBOOKS.md等文件。这不只是文档,而是操作记忆:如果 Agent 无法访问知识,知识就不存在。

MCP 工具网关与 A2A Agent 网关(第 4、5 层)分别解决两类连接问题。MCP是 AI 应用与外部数据源、工具集成的标准化开放协议,遵循客户端-主机-服务器模型,在支持跨应用集成的同时维护安全边界。A2A则是一个使独立 AI Agent 系统之间能够通信和互操作的开放标准——即使它们由不同框架、不同语言、不同厂商构建。三者的分工可以概括为:MCP 管工具,A2A 管 Agent,Harness 管控制。

运行时与状态层(第 6 层)是一个常被低估的现实:真实工作流可能耗时五分钟、五小时或五天,可能需要人工审批,可能半途失败、暂停恢复、交接给另一个专家 Agent。这些需求无法用简单提示处理,需要一个管理轮次、状态、会话、重试、中断、可恢复性、交接与审批的运行时。

至于其余各层,记忆、身份权限(OAuth 2.0 作用域与角色边界)、安全(OWASP Agentic Applications Top 10 所列的提示注入、工具滥用、记忆投毒、过度自主等风险)、验证、可观测性等。在第五节已有对应组件的工程细节,需要强调的只有一条架构原则:在云架构中,控制面管理编排、策略、安全、配置和运营;Agentic AI 需要同样的控制面。这就是 Harness 被称为「Agent 操作系统」的由来。

八、同一个模式,不同框架的设计哲学

主流框架已经收敛到同一个核心模式,但在设计哲学上各有取舍。下表是对五个代表性实现的横向比较:

维度

Claude Agent SDK

OpenAI Agents SDK

LangGraph

CrewAI

AutoGen

循环

笨循环 + 聪明模型

Runner 类(异步/同步/流式)

显式状态图

顺序/层级式

对话驱动

状态

git 提交作检查点

四种策略

类型化字典 + 检查点

任务结果

消息历史

多 Agent

Fork / Teammate / Worktree

agents-as-tools / handoffs

嵌套状态图

Agent-Task-Crew

5 种编排模式

哲学

薄 Harness,信任模型

代码优先

图式显式控制

角色化协作

对话即协议

Anthropic 的 Claude Agent SDK 通过单个query()函数暴露整个 Harness,返回异步迭代器流式传输消息,运行时遵循“收集-行动-验证”循环:收集上下文(搜索文件、读取代码)→ 采取行动(编辑文件、运行命令)→ 验证结果(运行测试、检查输出)→ 重复。

OpenAI 走代码优先路线:工作流逻辑用原生 Python 表达而非图 DSL;其 Codex Harness 以三层架构扩展——Codex Core(Agent 代码 + 运行时)、App Server(双向 JSON-RPC API)与客户端界面(CLI、IDE、Web),所有界面共享同一 Harness,这也是Codex 模型在 Codex 界面上的表现优于通用聊天窗口的原因。

LangGraph 从 LangChain 的 AgentExecutor 演化而来(后者因难以扩展且缺乏多 Agent 支持而在 v0.2 中被弃用),其 Deep Agents 明确使用了agent harness一词。CrewAI 则在角色化协作之上增加了 Flows 层,实现确定性骨干加关键位置智能。

对框架的技术选型而言,没有普适的正确答案,只有权衡。框架差异本质上是把多少逻辑放在 Harness 中、多少留给模型这个根本问题的不同回答。

九、Harness 架构师的七个决策

无论使用哪个框架,Harness 架构师都面临七个设计决策。这是整个设计空间的结构化表达:

决策

选项 A

选项 B

工程证据与判断依据

1. Agent 数量

单 Agent

多 Agent

两者都建议先最大化单 Agent;工具超过约 10 个且明显分域时才拆分

2. 推理策略

ReAct(逐步交替)

计划-执行(规划分离)

LLMCompiler 报告计划-执行相比顺序 ReAct 有 3.6 倍加速

3. 上下文策略

压缩/清除/遮蔽

结构化笔记/子 Agent

ACON:优先保留推理轨迹可减少 26–54% Token 且保持 95%+ 准确率

4. 验证设计

计算验证(测试/lint,确定性)

推理验证(LLM-as-judge,语义)

前者提供确定性真值,后者捕获语义问题但增加延迟

5. 权限架构

宽松(快但有风险)

严格(安全但缓慢)

取决于部署上下文与操作后果的可逆性

6. 工具范围

全量工具

每步最小集

Vercel 从 v0 移除 80% 的工具反而获得更好结果;Claude Code 惰性加载实现 95% 上下文减少

7. Harness 厚度

薄(信任模型)

厚(代码编码控制)

见下一节的协同进化讨论

其中第 4 项可以借用 Martin Fowler 的框架重新表述:验证机制分为引导与传感器。一个成熟的 Harness 两者兼有,并在成本与覆盖之间寻找平衡。

第 6 项值得展开说明,“更多工具往往意味着更差性能”是一个反直觉但被反复验证的结论:工具定义本身占据上下文,与任务无关的工具会分散模型注意力并增加选错工具的概率。原则是暴露当前步骤所需的最小工具集。

十、Harness 会消失吗

建筑行业的脚手架是一种临时基础设施,使工人能够建造他们原本无法触及的结构。脚手架不做建造,但没有它,工人到不了上层,无法施工。这个隐喻的关键在后半句:建筑完成后,脚手架会被拆除。

Manus 的实践为这个隐喻提供了实证:他们在六个月内把产品重建了五次,而每一次重写都在移除复杂性,复杂的工具定义退化为通用 shell 执行,管理 Agent的专门机制退化为简单的结构化交接。随着模型改进,Harness 的复杂性确实在下降。

但这不等于 Harness 会消失,因为存在一个反向的耦合:协同进化原则(co-evolution principle)。模型如今是在特定 Harness 环路的情况下进行后训练的。Claude Code 的模型学会了使用它被训练时的特定 Harness,更改工具实现可能因这种紧密耦合而降低性能。这解释了为什么 Anthropic 会定期从 Claude Code 的 Harness 中删除规划步骤:不是 Harness 设计变差了,而是新模型版本已经内化了那种能力,继续保留反而冗余。

于是, Harness 的厚度成为一个动态的架构押注:薄 Harness(Anthropic 路线)押注模型持续改进,Harness 只保留工具、上下文与权限;厚 Harness(图框架路线)押注显式控制,把路由、规划、多步策略编码进代码。

一个实用的面向未来的设计检验标准是:如果性能随更强大的模型而提升,且不需要增加 Harness 复杂性,那这个设计就是合理的。 换言之,Harness 应当为模型的下一步改进预留下降空间,而不是把当前模型的能力短板用硬编码固化下来。

十一、成熟度模型:H0 到 H5

对企业而言,需要一个尺度来评估自己的 Agent 系统处于什么位置。以下六级成熟度模型可以直接作为评估框架使用:

等级

名称

描述

主要风险

H0

纯提示 Agent

有系统提示和一些指令,适合 demo

幻觉、不一致、无验证、无记忆

H1

工具连接 Agent

能调用工具,但未权限化/日志化/验证

工具滥用、不安全操作、恢复差

H2

有状态 Agent

有短期状态、记忆与工作流连续性,可恢复任务

记忆漂移、上下文过时、归属不清

H3

可观测且经验证的 Agent

有追溯、评估、测试、审批门、失败归因

实施成本高、治理复杂

H4

多 Agent 操作系统

MCP 网关、A2A 通信、身份、权限、验证、可观测性齐备

架构复杂、安全面大、运营开销

H5

自进化 Harness

基于追溯和结果改进自身工具、中间件、记忆、路由和评估

不受控进化、回归、治理挑战

一个符合行业现状的判断是:大多数公司今天处于 H0 到 H2 之间,在企业级 AI 应用中胜出的团队将向 H3、H4 移动,最终抵达 H5。这个模型的价值不在分级本身,而在于它把“我们的 Agent 为什么不可靠”这个问题,转化为“我们缺哪几层”的可诊断形式。

值得单独说明的是 H5。前面引用的《Agentic Harness Engineering》实验(十次迭代将 pass@1 从 69.7% 提升到 77.0%,收益来自工具、中间件与长期记忆)表明,自进化 Harness 并非概念炒作,而是已有量化结果的方向。它意味着 AI 系统第一次在**基础设施层面**实现自我改进——不只是自改进的模型,而是自改进的 Harness。

十二、工程检查清单与常见反模式

将部署前的检查动作压缩为10个需要回答的问题:

维度

关键问题

上下文

Agent 在正确时间收到正确上下文吗?能移除过时/无关上下文吗?需要时能检索到更深文档吗?

知识

公司知识是否结构化、版本化、Agent 可读?还是困在聊天工具、邮件和人脑里?

工具

工具是否经标准化网关接入?有类型、文档、权限和日志吗?危险工具能被沙箱或阻止吗?

Agent

Agent 能通过受控接口协作吗?能防止不必要的记忆或工具暴露吗?

记忆

短期状态和长期记忆是否分离?中断后能恢复吗?记忆能被审计、编辑或删除吗?

身份

每个 Agent 有身份吗?权限能被撤销吗?操作能被审计吗?

安全

是否防御提示注入、记忆投毒、过度自主和不安全工具执行?有熔断开关吗?

验证

Agent 如何证明成功?失败能复现吗?

可观测性

能追溯每个模型调用、工具调用、交接、护栏触发和审批事件吗?

改进

Agent 失败时,你只修复输出,还是改进 Harness?

最后一个问题最重要:最好的团队不仅纠正 Agent 的错误,而是把每次失败转化为更好的工具、记忆、验证和运行时设计。

同样,值得警惕的是反复出现的反模式:

反模式

直接后果

纠正方向

用提示词堆砌本应由系统保证的行为

行为不可复现,回归无法测试

把约束下沉到 Harness 层(验证、权限、状态)

全量暴露工具

上下文被工具定义挤占,选错工具率上升

按步骤惰性加载最小工具集

单一记忆池,不分短期长期

幻觉被持久化,错误经验被反复复用

分层记忆 + 审计与编辑能力

失败后无条件重试

错误复合,成本失控

区分四类错误,重试设上限

无追溯的黑箱运行

失败不可归因,无法改进

全流程追踪与结构化日志先行

把 Harness 当静态外壳

模型升级后 Harness 冗余甚至冲突

定期瘦身,遵循协同进化原则

结束语:Harness 就是产品

使用相同模型的两个产品,仅因 Harness 设计不同,就可以有天壤之别的性能。这不是模型的问题,也不是提示词的问题,而是系统工程的问题。

Harness 不是一个已解决的问题,也不是一个可以轻易商品化的层。它是工程所在:将上下文作为稀缺资源管理,设计在错误复合之前捕获它们的验证循环,构建提供连续性而不产生幻觉的记忆系统,并“在搭建多少脚手架”与“留多少能力给模型”之间做出持续的架构决策。

当前的趋势是向更薄的 Harness 演进,因为模型在改进。但 Harness 本身不会消失:即使是最强大的模型,也需要有内容来管理它的上下文窗口、执行它的工具调用、持久化它的状态、验证它的工作。模型能推理,Harness 让它能工作;模型能生成,Harness 让它能执行;模型能建议,Harness 让它能验证。

当模型不再稀缺,胜负手就转移到模型周围。下次你的 Agent 失败时,别急着怪模型,先看看 Harness。

ps: 作译者群的作品推荐——

    【参考资料与关联阅读】

    • Liu, N. F. et al. (2023).Lost in the Middle: How Language Models Use Long Contexts. TACL.

    • Millidge, B. (2023).LLM OS: LLMs as the Kernel of an Emerging Operating System.

    • AI Harness Engineering: A Runtime Substrate for Foundation-Model Software Agents. 2026.
    • Agentic Harness Engineering. 2026.(Terminal-Bench 2 自进化实验)
    • Code as Agent Harness. 2026.
    • ACON:Context Compression for LLM Agents. 2026.

    • Anthropic.Claude Code document

    • OpenAI. Agents SDK document.

    • Theory Ventures.The Seven Components of an AI Agent Harness. 2026.

    • OWASP.Agentic Applications Top 10 (2026).

    • Google Cloud.Agent2Agent (A2A) Protocol ;Anthropic.Model Context Protocol (MCP) .

    跳转微信打开

    看一看Palantir 面向本体的软件开发

    2026年11月10日 20:26

    原创 半吊子全栈工匠 2026-11-10 20:26 北京

    为什么软件越造越多,企业却没有变快?这不是模型问题、不是算法问题,甚至不是 AI 问题,而是一个架构问题——怎么组织知识、怎么把几百个系统的私有表示翻译成共享的概念模型......

    【引】他山之石,对Palantir而言,他们用本体(Ontology)重新定义企业软件的构建方式。本文是对《本体驱动的AI大模型:方法与实践》的解读与补充,看一看本体对软件开发的影响。


    这些年软件代码量、服务器数量、系统个数都在翻着倍地涨,但有个问题始终没解决:系统越多,业务反而越慢。

    一个订单要改价格,得动交易系统、营销系统、结算系统、风控系统,四个团队排期,联调两周。一个新功能上线,最大的工作量不是写逻辑,而是搞清楚"这个东西的数据在哪个库、接口找谁要、改了会不会把别处弄挂"。

    这不是哪家公司的毛病,是整个行业的通病。Palantir 在一篇叫《Ontology-Oriented Software Development》的文章里,把这个现象说得很透:

    我们这个行业正在用越来越快的速度生产软件,但这些软件对实际生产力的提升微乎其微。原因是:绝大部分人力都花在开发一个个独立组件上,而不是把它们组装成能真正影响业务的系统。组件越做越好,组装越来越难——孤立地优化每个零件,反而让跨系统的协作变得寸步难行。

    这个过程是这样的。第一阶段,系统简单,潜力性能和实际性能差距不大;第二阶段,组件变多,厂商之间互相竞争、各搞各的,系统开始碎片化;第三阶段,每个组件都"变好了",但实际系统性能离潜力越来越远——全是集成债务。也就是说,中台建了,烟囱还在。

    这个问题不能靠再买一个新组件来解决,得换一种架构思路。他们给出的答案叫本体,配套的开发工具叫 Ontology SDK(OSDK)。这篇文章要讲的,就是这套东西到底是什么、解决什么问题,以及为什么它和这两年 AI Agent 的落地困境,居然是同一个问题。


    一、一架飞机引发的连锁反应

    看 Palantir 的用例,一家航空公司要减少飞机停场时间。场景很简单,飞机起飞前的例行检查中,一个警示灯亮了。这时候整个公司的人都要动起来,回答三个问题:

    1. 这架飞机还能不能飞?需不需要停飞?

    2. 哪些机场有替换零件、有持证的机械师能修?

    3. 怎么换飞机,能让乘客影响最小?

    客机一次飞行能产生 200 多万个数据点。数据科学家要先跑预测性维护模型,估算飞机剩余寿命;运营团队要查哪些机场有零件库存,再跟维修排班交叉比对,找到能干活的人;最后在几个可行方案里挑一个损失最小的。

    比如算出来两个选项:去 DFW,零件和机械师都有,但机型座椅布局不同,得给三名乘客改签,损失 5000 美元外加一堆投诉;去 IAD,零件和机库都有,但机械师不在班上,得付 2000 美元加班费连夜修。

    哪个划算?这背后牵扯到客户满意度、安全、成本的真实权衡。

    注意,这个决策不是某一个系统的功能。它需要把一堆东西捏在一起:

    • 数据:机场运营数据库、航班计划、库存系统、人员排班系统
    • 逻辑:寿命预测模型、成本模型、客户影响模型
    • 动作:改签乘客、调整维修工单、给相关的人发通知

    这三类东西,Palantir 分别叫做数据元素、逻辑元素、动作元素。本体做的事,就是把全公司的这三类元素统一管理起来。

    这张图就是航空公司的本体:飞机、机场、零件、机械师,都是本体里的对象,它们之间的关联(哪架飞机能换到哪个机场、哪个零件在哪个仓库)清清楚楚。业务决策就是在这个对象网络上跑一遍约束和成本计算。


    二、没有本体时,代码长什么样

    那不用本体,程序员怎么实现这套流程呢?大概率是这样:找到每个系统的负责人,要 API 文档,学每个系统的数据格式,然后用胶水代码把它们粘起来。

    Palantir 给了一个示例(虚构的 Skyframe 航空):

    const mysql = require('mysql');
    const nodemailer = require('nodemailer');
    const fetch = require('node-fetch');
    // 库存数据库连接配置
    const dbConfig = {
      host: 'skyframe-internal',
      user: 'db_admin',
      password: process.env.DB_PASSWORD,
      database: 'skyframe'
    };
    // 邮件服务器配置(示例使用 Gmail)
    const transporter = nodemailer.createTransport({
      service: 'gmail',
      auth: {
        user: 'swapbot@skyframe.com',
        pass: process.env.EM_PASSWORD
      }
    });
    // 连接库存数据库并查询有库存的机场
    async function findAirportsWithInventory(parts) {
      const connection = mysql.createConnection(dbConfig);
      const query = "SELECT airport_code FROM inventory WHERE part_number IN (?)";
      return new Promise((resolve, reject) => {
        connection.query(query, [parts.map(part => part.partNumber)], (error, results) => {
          connection.end();
          if (error) return reject(error);
          resolve(results.map(row => new Airport(row.airport_code)));
        });
      });
    }
    // 连接数据库并查询可更换的航班
    async function findSwappableFlights(flightToSwap, aircraft, targetAirports) {
      const connection = mysql.createConnection(dbConfig);
      const query = `SELECT * FROM flights
                     WHERE departure_airport_code = ? AND aircraft_id = ? AND destination_airport_code IN (?)
                     ORDER BY departure_time ASC`;
      return new Promise((resolve, reject) => {
        connection.query(query, [flightToSwap.departureAirportCode, aircraft.id, targetAirports.map(airport => airport.id)], (error, results) => {
          connection.end();
          if (error) return reject(error);
          resolve(results.map(row => new ScheduledFlight(row)));
        });
      });
    }
    // 调用外部 REST 端点计算最优更换方案
    async function calculateOptimalSwaps(flightToSwap, swappableFlights) {
      const requestBody = {
        flightToSwap: flightToSwap,
        swappableFlights: swappableFlights
      };
      const response = await fetch('https://skyframe-internal-gateway/api/calculateOptimalSwaps', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': 'Bearer Ym9zY236Ym9zY28'
        },
        body: JSON.stringify(requestBody)
      });
      if (!response.ok) {
        const error = await response.text();
        throw new Error(`Failed to calculate optimal swaps: ${error}`);
      }
      const swapOptions = await response.json();
      return swapOptions;
    }
    // 调用外部 REST 端点计算维修和客户影响成本
    async function calculateImpactCosts(swapOptions) {
      const requestBody = {
        swapOptions: swapOptions
      };
      const response = await fetch('https://skyframe-internal-gateway/api/calculateImpactCosts', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': 'Bearer Ym9zY236Ym9zY28'
        },
        body: JSON.stringify(requestBody)
      });
      if (!response.ok) {
        const error = await response.text();
        throw new Error(`Failed to calculate impact costs: ${error}`);
      }
      const impactCosts = await response.json();
      return impactCosts;
    }
    // 执行飞机更换操作
    async function swapAircraft(targetAircraft, aircraft) {
      const requestBody = {
        targetAircraft: targetAircraft,
        aircraft: aircraft
      };
      const response = await fetch('https://skyframe-internal-gateway/api/swapAircraft', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': 'Bearer Ym9zY236Ym9zY28'
        },
        body: JSON.stringify(requestBody)
      });
      if (!response.ok) {
        const error = await response.text();
        throw new Error(`Failed to swap aircraft: ${error}`);
      }
      console.log(`Swapping aircraft ${targetAircraft.id} with ${aircraft.id}`);
    }
    // 发送邮件请求更换审批(使用 nodemailer)
    async function emailSwapsForApproval(swapOptions) {
      const mailOptions = {
        from: 'swapbot@skyframe.com',
        to: 'ground-control@skyframe.com',
        subject: 'Flight Swap Approval Required',
        text: `Approval is required for the following swap options: ${JSON.stringify(swapOptions)}`
      };
      return transporter.sendMail(mailOptions);
    }
    // 主函数:安排预防性维护
    async function schedulePreventativeMaintenance(aircraft, parts) {
      try {
        const schedule = await aircraft.getSchedule();
        const flightToSwap = await schedule.getNextFlight();
        const targetAirports = await findAirportsWithInventory(parts);
        const swappableFlights = await findSwappableFlights(flightToSwap, aircraft, targetAirports);
        const swapOptions = await calculateOptimalSwaps(flightToSwap, swappableFlights);
        const impactCosts = await calculateImpactCosts(swapOptions);
        const cheapestOption = impactCosts.reduce((cheapest, option) =>
          option.cost < cheapest.cost ? option : cheapest,
          { cost: Number.MAX_VALUE }
        );
        // 选项的护栏
        if (cheapestOption.cost < 1000) {
          await swapAircraft(cheapestOption.swapOption.targetAircraft, aircraft);
        } else {
          await emailSwapsForApproval(swapOptions);
        }
      } catch (error) {
        console.error('Failed to schedule preventative maintenance:', error);
      }
    }

    这还是个刻意简化的例子。即便如此,大部分代码都在干一件事:连接底层系统、处理认证、拼请求、处理错误。真正干业务活的那个主函数,只占代码量的一小部分。

    更麻烦的是,这些"怎么连系统、怎么拼数据"的知识,全都锁死在这一个应用里。下个团队要做类似的事,从头再来一遍。写过公司内部系统的人应该都懂这种痛:每个应用里都埋着一份自己的一套对接逻辑,谁也不敢动。

    在国内互联网公司,这个问题有个更广为人知的变体。同样是"商品"这个词,交易系统里的商品、推荐系统里的商品、客服系统里的商品,字段、ID、状态机各是各的。每做一个新应用,都要把这些系统特定的表示重新"翻译"一遍。API 网关能帮你找到接口,但翻译工作一点没少。


    三、有了本体,代码长什么样

    Palantir 的思路是把"翻译"这件事只做一次。全公司的数据、逻辑、动作,统一放进一个共享的本体里。飞机就是 Aircraft对象,机场就是 

    Airport 对象,"更换飞机"就是一个带权限和护栏的动作。所有应用都基于这套共享概念来写代码,不再各自对接底层数据库。

    于是上面那段胶水代码,用 OSDK 写出来是这样的:

    async function schedulePreventativeMaintenance(aircraft: Aircraft, parts: AircraftComponent[]) {
      const schedule: FlightSchedule = await aircraft.getSchedule();
      const flightToSwap: ScheduledFlight = await schedule.getNextFlight();
      const targetAirports: Airport[] = await OntologyClient.search()
        .airports()
        .filter(a => a.inventory.containsAll(parts))
        .all();
      // 查找从同一出发地到有库存机场的可更换航班
      const swappableFlights: ScheduledFlight[] = await flightToSwap.getDepartureAirport()
        .scheduledFlights()
        .filter(f => f.aircraft.airframe.exactMatch(aircraft.airframe))
        .filter(f => f.destination.isOneOf(targetAirports))
        .orderBy(f => f.departureTime.asc())
        .all();
      const swapOptions: FlightSwapOption[] = await OntologyClient.calculateOptimalSwaps(flightToSwap, swappableFlights);
      const impactCosts: SwapOptionCost[] = await OntologyClient.calculateImpactCosts(swapOptions);
      const cheapestOption = impactCosts.reduce((cheapestOption, option) =>
        option.cost < cheapestOption.cost ? option : cheapestOption,
        { cost: Number.MAX_VALUE },
      );
      // 选项的护栏
      if (cheapestOption.cost < 1000)
        await OntologyClient.action.swapAircraft(cheapestOption.flight, aircraft);
      else
        await OntologyClient.action.emailSwapsForApproval(swapOptions);

    对比一下就很明显:代码里不再有 MySQL 连接串、Bearer token、REST 端点。程序员操作的是 Aircraft、Airport、ScheduledFlight——用业务的语言写代码,而不是用数据库的行列写代码。

    Brooks 在《没有银弹》里说过,系统集成里的复杂性是本质复杂性,只能管理、不能消除。本体没有消灭这些复杂性——底层的数据库、API、逻辑模型都还在——而是把它们封装进了本体这一层。就像高级语言让程序员不用关心寄存器和内存地址,本体让程序员不用关心每个 SaaS 的 API 长什么样。

    Palantir 官方那句话说得挺准:OSDK 不是给他们的产品提供一个通用 API,而是给你提供一个工具包,用你业务自己的语言给业务构建 API。

    整个架构可以画成这样:

    左边是碎片化企业:每个新应用都要跟一堆核心系统、SaaS、内部系统重新建立连接;中间是本体:各家系统特定的集成工作,沉淀成一个共享的概念模型;右边是 OSDK:开发者不再各自对接底层,而是共用一套以决策为中心的 API。

    这种模式的好处会复利。因为集成工作只做一次、沉淀在本体里,之后每接入一个新组件、每做一个新应用,边际成本都在下降。Palantir 的目标很直白:把定制企业软件开发的边际成本推向零。


    四、应用的一致方向

    看到这里你可能会觉得,本体是 Palantir 这种做国防、军工客户的公司才需要的东西,跟做 C 端互联网、做大模型应用的没什么关系。但仔细看这几年的技术演进,会发现大家殊途同归。

    第一个例子:数据中台

    2015 年前后阿里提出"大中台、小前台",核心动作之一就是把全集团的数据打通,统一"商品"、"用户"、"订单"这些核心概念的口径。这在本质上就是在建一个粗糙的本体——只是它侧重"数据元素",对"逻辑元素"和"动作元素"的统一比较弱,所以后来出现了"中台建了但业务还是慢"的反思。反过来这也印证了 Palantir 的观点:光统一数据不够,得把逻辑和动作也统一进同一个模型,业务决策才能真正跑得起来。

    第二个例子:Anthropic 的 MCP(Model Context Protocol)

    2024 年底 Anthropic 发布 MCP,一年之内成了 AI 圈的事实标准。它解决什么问题?每个 AI 应用要对接每个数据源、每个工具,都得写一次定制集成,M×N 的组合爆炸。MCP 把工具和数据源封装成统一协议的服务,一次封装,所有支持 MCP 的 AI 应用都能用。这个"把集成工作做一次、沉淀成共享层"的思路,和本体如出一辙——MCP 是协议层面的版本,本体是语义层面的版本。

    第三个例子:Function Calling 和 Agent 的落地困境

    用过 OpenAI function calling 或者做过 Agent 开发的人都知道,大模型要可靠地调用企业系统,前提是工具的描述足够清晰:参数是什么、返回什么、什么能做、什么不能做。但企业的现实是,同一个"客户"概念散落在 CRM、工单、客服系统里,各有各的口径。Agent 不是不够聪明,是没有一个干净的、机器可读的业务概念层可挂靠。这就是为什么 Palantir 敢说下面这句话——在企业语境里做运营 AI,瓶颈不是模型,是架构。

    第四个例子:GraphRAG

    微软提出的 GraphRAG,在向量检索之外引入知识图谱,用实体和关系来组织文档,让 LLM 能回答"全局性"的问题。知识图谱正是本体的经典技术形态之一。RAG 从"检索文本片段"进化到"查询概念网络",方向和本体是一致的:让 AI 面对的不再是碎片,而是结构化的概念模型。

    这几条线——数据中台、MCP、Agent、GraphRAG——都是同一个诉求的不同表达:在杂乱的底层系统和上层的应用/智能之间,需要一层共享的、以业务概念为中心的模型。 Palantir 只不过是把这一层做到了极致,而且早做了十年。


    五、三种界面,一种语言

    本体还有一个不太显眼但可能最重要的好处:它是 AI 和人共享的"地基"。Palantir 的AIP之所以能快速落地,他们的解释是:从某个角度看,AI 系统更像应用而不是用户——它们直接和 API 交互。

    过去几十年,人机界面从打孔卡到命令行到图形界面,一直在优化"人类可用性"。但当 AI 开始替人干活,"可用性"的定义得扩展:系统不光要人能用,还得让自主的 AI 能用。

    这张图是 OSDK 的核心结构:底层是数据源(交易数据、IoT 传感器、关系型数据库)、逻辑源(预测模型、优化模型、规则逻辑)、动作系统(ERP、SCM、排班系统),中间统一收进本体,上层的各种应用——Web 应用、移动应用、桌面应用、边缘设备上的应用——全部通过 OSDK 访问同一个本体。

    而这张图更进一步:上层的应用和 AI 是交替出现的。同一个本体,通过三种界面暴露出来:

    • 图形界面(GUI):给业务人员的可视化操作界面

    • 编程接口(API):给程序员和 AI 系统的直接访问通道

    • 自然语言界面(NLI):人和语言模型都能用大白话查数据、下指令

    关键在于,这三种界面背后是同一个模型。运营人员在 GUI 上看到"3 号航班更换方案,成本 2000 美元",和 Agent 通过 API 拿到的、和分析师用自然语言问出来的,是同一份数据、同一套逻辑、同样的权限护栏。不存在"AI 那边一套口径,人这边另一套"。

    J. C. R. Licklider 在 1960 年的《人机共生》里写过:"人类语言和计算机语言之间的根本差异,可能是真正人机共生的最大障碍。" Palantir 给出的答案是:不要给每种界面发明一种新语言,用本体表达一种语言,让它能以图形、程序、自然语言三种形式说出来。

    这解释了为什么 Agent 在很多公司落不了地,而在有本体的企业里能干活:Agent 需要的不只是一个大模型,而是一个它能够理解、查询、并且安全操作的业务世界模型。本体就是那个世界模型。


    小结

    为什么软件越造越多,企业却没有变快?Palantir 的回答是:这不是模型问题、不是算法问题,甚至不是 AI 问题,而是一个架构问题——怎么组织知识、怎么把几百个系统的私有表示翻译成共享的概念模型。

    答案是把这种翻译从"每做一个应用重复一遍"变成"一次做完,永久复用"。低代码工具、专业代码、AI 系统,都通过同一个本体访问同一个企业模型——只是界面不同。

    当集成的边际成本趋近于零,定制化企业软件不再是上市公司的奢侈品;当业务知识可以复利,数字化转型才第一次有了看得见的终点。

    【关联阅读】

    跳转微信打开

    从 Text2SQL 到语义层 BI

    2026年11月8日 20:26

    原创 半吊子全栈工匠 2026-11-08 20:26 北京

    语义层这件事,技术只占一半,另一半是把公司到底怎么算这笔账从人脑里搬到一个机器能读、能审、能版本化的地方。搬的过程很枯燥,要开会、要吵架、要让业务方签字,一点都不酷。但它是唯一能让 agent 的输出变得可信的办法。

    【引】模型没有骗你。它老老实实把「上个月的客户流失率」翻译成了一段能跑的 SQL,只是它不知道你们公司是怎么定义流失的。缺的那一层,才是这两年 BI 领域真正在抢的东西。本文是对《本体驱动AI大模型:方法与实践》一书的补充与解读。

    Text2SQL 解决的是「翻译」,不是「理解」。翻译可以做到零语法错误,答案照样可以是错的。错的代价变了。有人在会议室里盯着大屏的时候,错一个数最多被同事当场指出来;agent 直接调工作流的时候,错一个数就可能是五万块广告预算。

    补这个洞的办法不是换个更强的模型,而是在模型和数据库中间加一层能被版本控制、能被审计、能被所有工具共用的业务定义。这层东西就是语义层。

    语义层不是什么新发明,它只是从 BI 工具的一个附赠功能,变成了 agent 时代的基础设施。

    一、Text2SQL 到底在做什么

    这件事的定义干净得不能再干净:给一个问题,给一个数据库的表结构,让模型输出一段能执行、且能答对问题的 SQL。

    学术界的标准例子长这样:

    -- 问题:What cartoons were written by Joseph Kuhr?
    SELECT * FROM Cartoon WHERE Written_by = "Joseph Kuhr";

    配上表结构一起喂给模型:Cartoon表有Title、Directed_by、Written_by、Production_code、Channel几列,Channel外键指向TV_Channel。模型输出上面那句 SQL,数据库跑出「Batman Series」,问题答完了。

    为什么这件事值得做?Stack Overflow 2023 年的开发者调查里有个数字:51.52% 的专业开发者日常在用 SQL,但只有 35.29% 受过系统训练。也就是说,绝大多数人是在工作中边查边写边出错的。让不会写 SQL 的人能用自然语言问数,动机一直都很充分。

    2023 年之后,这个任务的主流做法分成两条线。

    一条是不改模型、只改 prompt 的 in-context learning。DIN-SQL 把任务拆成四步——schema linking、问题分类与拆解、SQL 生成、自我纠错;MAC-SQL 拆成选择器、分解器、精修器三个角色;CHESS 先做实体和证据检索再写 SQL。共同点是承认一步到位很难,用流程换准确率。

    另一条是微调。拿开源模型在领域数据上继续训练,比如 DTS-SQL 用 7B 的模型在 Spider 上做到了接近大模型的成绩,代价是你要有标注数据、有 GPU、还要接受它只在你的方言上表现好。

    学术数据集上的进展很漂亮。Spider 这类库小、问题规整的基准,执行准确率早就做到 90% 上下。但换到 BIRD——95 个真实企业的数据库、1.2 万条问题、平均每个库 7.3 张表、54.9 万行数据、跨领域还带外部知识——最好的方法长期在 50% 到 70% 这个区间里打转。

    一个 90%,一个 60%。差的那 30 个百分点,不是模型突然变笨了,是真实数据库里塞满了模型没见过的业务约定。

    二、语法完美,语义全错

    先把这条失败路径画出来,整条链路只有四步:

    用户输入Show customer churn。模型没有任何业务上下文,只能猜表和过滤条件,于是写出了这个:

    SELECT u.id AS user_id,
           COUNT(o.id) AS orers_count
    FROM orders o
    JOIN users u ON o.user_id = u.id
    WHERE o.activity_date >= DATE_SUB(CURDATE(), INTERVAL 90 DAY)
    GROUP BY u.id
    HAVING COUNT(o.id) = 0;

    数据库很配合,执行成功,返回一串user_id和order_count = 0。界面显示:这些用户流失了。

    但这不是流失。这只是「最近 90 天没有下单的用户」。

    中间隔着好几层东西:有人退了款但还在订阅期,有人是年付只在年初下一单,有人是测试账号本来就不该算,还有些订单在支付确认里有几天延迟,昨天的单今天才落库。这些规则一条都不在表结构里,模型一条都猜不到。

    顺便说个细节,这张图其实还暴露了另一件事。上面那段 SQL 照抄下去跑,大概率返回空集:INNER JOIN加上WHERE o.activity_date >= ...,已经把 90 天内没有订单的用户全过滤掉了,剩下的每一行COUNT(o.id)至少是 1,HAVING COUNT(o.id) = 0永远不成立。要写成LEFT JOIN才是图上那个结果。连列别名都拼成了orers_count。

    数据库不检查语义,只检查语法。别名拼错它不管,join 逻辑自相矛盾它也不管,只要语句合法就执行、就返回、就用一个漂亮的表格显示出来。语法正确这件事,比大多数人以为的要廉价得多。

    2.1 模型不是不懂 SQL,是不懂你们公司

    Sergey Gromov 那段话我一直记着,说得比我准:

    语言模型在精确地执行它被设计来做的事:把人类的措辞翻译成可能的数据查询。它不需要理解业务含义……公司期望得到一位分析师,结果得到了一位翻译。把问题翻译成 SQL 不是分析,只是事实检索。分析从事实被解释的那一刻才开始。

    一个干了三年的分析师听到流失率,脑子里会自动跑一遍公司口径;模型听到同一个词,脑子里跑的是 token 概率。它找到last_activity_date,套一个时间间隔,数人头。查询完美运行,数字完全错误。

    学术上把这类问题归成三类:自然语言本身的歧义(「上个月」是自然月还是滚动 30 天)、schema 理解(表和列的名字跟业务词对不上)、罕见 SQL 操作(嵌套子查询、外连接、窗口函数在训练数据里出现得少)。再加上一个更现实的问题,提问的人往往说不清楚,同义词、错别字、模糊表达混在一起,靠字面匹配做 schema linking 很容易被带偏。

    2.2 那些指标数字,会骗人

    Text2SQL 有一套挺成熟的评估指标,整理出来是这样一张表:

    指标

    全称

    在衡量什么

    会漏掉什么

    EM

    Exact Match

    生成的 SQL 和标准答案是否逐字等价

    写法不同但结果相同,一律判错

    EX

    Execution Accuracy

    两边执行结果集是否一致

    口径错但恰好撞对结果,判对

    VES

    Valid Efficiency Score

    结果对的前提下,执行效率如何

    与业务正确性无关

    TS

    Test-Suite Accuracy

    多种等价 SQL 下结果是否都稳定

    构造成本高

    FLEX

    False-Less Execution

    严格校验执行结果,压误报

    极端保守

    Answer Accuracy

    用 GPT 判断答案是否回答了问题

    更贴近人的判断

    引入另一个模型的主观性

    企业里最常用的是 EX,因为它最接近「对不对」这个直觉。但 EX 有个隐蔽的坑:它只比较结果集,不检查口径。

    举个具体场景。测试集里问上月收入,标准答案用的是含税口径,模型生成的是不含税口径。某个月公司没有任何折扣和退单,两个口径算出来的数完全一样,EX 判它正确。等这个模型上线,遇到第一个打折月,数字就飘了。而你在测试报告上看到的是 90 分。

    这也是为什么学术界还在提新指标,包括语义匹配率、查询复杂度、字面值检索准确率、schema 对齐度、多正确答案场景等。指标越加越多,恰恰说明“SQL 对不对”和“答案对不对”是两件事。

    三、错的代价,已经从会议室转移到了预算表

    再看一组对照,比讲道理直观得多:

    传统 BI 的错误链条是这样的:指标定义过期(比如 MRR 错误地把折扣算进去了)→ 图表画出一个漂亮的上升曲线 → 周会上有人皱眉头说“这个数不对吧”→ 当场核对,改掉,没造成损失。人是最后一道校验,而且这道校验是免费的。

    Agent 的错误链条是这样的:LLM 编了一条 join 路径,把收入重复计算了一遍 → LTV 算出来 1250 美元,真实值 620 美元,高估 102% → agent 判断“高价值用户值得加投”,自动触发优化决策、开广告计划 → 五万元预算出去了。

    两条链条的差别不在错误大小,在人还在不在环路。

    这也是为什么语义层这两年从治理上的一个加分项变成了上线前的准入条件。在人工看图的时代,语义碎了顶多是两个部门在季度会上报出不同的销售额,争执一下午也就过去了;在 agent 直接连着工作流的时代,语义碎了就是自动化系统拿着错数字做决策,而且做得又快又坚决。

    四、语义层不是新东西,是位置变了

    把时间线拉开看,这层东西挪过三次位置:

    阶段

    语义逻辑待在哪

    谁维护

    谁能用

    典型毛病

    单体 BI(1990s–2010s)

    BusinessObjects 的 Universe、SSAS 的 cube、MicroStrategy 的元数据库

    集中的语义架构师团队

    只有这家 BI 工具

    锁死在工具里,出了这个门就得重写 SQL

    现代数据栈(2010s–2020s)

    dbt 模型里,直接编译成物理表和视图

    分析工程师

    所有能连仓库的工具

    语义被压平成表,动态逻辑丢了,各工具各自重新定义指标

    无头语义层(现在)

    独立的、代码化的、版本控制的定义层

    数据工程 + 业务共同维护

    仪表盘、笔记本、agent、应用,同一个 API

    建设成本真实存在,冷启动慢

    第一代的问题是好用但封闭。分析师想在 Python Notebook里跑个模型,或者把数据拉到 Excel 里做点临时测算,只能绕过语义层直接写裸 SQL——绕过去的那一刻,治理就失效了。

    第二代的问题是开放但散装。dbt 把转换逻辑变成了代码,仓库干净了,可指标定义也跟着被拍成了物理表。Maxime Beauchemin(Apache Superset 的作者)有个比喻我特别喜欢:

    过去十年我们一直在开自助餐。自助餐适合大规模喂养数据饥渴的组织,但菜会变质,食物中毒也会发生。没人引导的时候,人们会做出很可疑的搭配——小孩一定会把果冻和意面放在一个盘子里。

    自助餐的后果是数据无政府状态:三四个 BI 工具,各自在同样的干净表上重新定义一遍「活跃用户」,然后开会吵架。

    第三代就是现在这波。逻辑从可视化层里抽出来,也从物理表里抽出来,做成一个独立的服务,通过一个统一接口同时喂仪表盘、喂 notebook、喂 agent。所谓“无头”,说的就是这个——它自己没有界面。

    推动这次搬家的是 agent。人看图的时候,语义稍微有点出入还能靠常识兜住;agent 没有常识,它只有接口。

    五、语义层里到底存了什么

    一个完整的语义引擎,拆开是四个零件:

    第一个零件是对象图。声明实体、维度和它们之间的关系,本质上是在数据库之上画一张有向图,把 join 路径写死在图里,而不是留给客户端现编。

    这件事听起来像洁癖,其实是在防一类非常具体的错误:扇出。orders一对多order_items,再一对多payments,三张表一 join,一行订单变成 3 乘 2 等于 6 行,金额翻六倍。SQL 完全合法,结果毫无意义。人类工程师踩过这个坑所以会警惕,模型不会——它看到orders和payments有个共同的主键,join 上去很合理。

    第二个零件是声明式指标。指标不写成硬编码的数字,写成一个表达式:gross_profit = revenue - cogs,revenue再去引用它自己的定义和过滤条件。好处是只有一处定义。无论这个指标最后是 agent 调的、Power BI 画的,还是某个 Python 脚本临时算的,出来的数一定是同一个。

    第三个零件是编译引擎。它把上层的抽象请求翻译成具体方言的 SQL。同一个请求打到 Snowflake、Databricks、BigQuery 还是 DuckDB,生成的 SQL 不一样,但逻辑必须一致。多遍聚合、窗口函数、同比环比这类时间智能,都在这一层处理掉,不往上抛。

    第四个零件是性能与安全核心。在 SQL 打到数据库之前,把当前用户的行级权限、列级脱敏规则追加进去;把重复的查询路由到预聚合表或缓存,别每次都去扫原始分区。

    四层架构在 agent 时代格外重要,原因很朴素:agent 是迭代型的。它制定一个计划可能要问十几次、几十次,人问一次它问二十次,算力账单也是二十倍。

    六、Agent 该拿到的接口,长什么样

    现在大多数 Text2SQL 的做法是:把表结构塞进 prompt,让模型写 SQL,执行,看结果。这个做法在小库上能用,在大库上必死。算个账就明白:一个中等规模的企业仓库,2000 张表,每张 30 列,光 DDL 文本就是几十万 token,任何上下文窗口都装不下。就算用向量检索只挑出 50 张「相关」表,也有一万多 token;而这 50 张里挑错一张,join 就错了,答案就废了,你还看不出来。

    语义层的做法是换一个方向:不把表结构给模型,把业务对象给模型。

    {
      "metric": "customer_lifetime_value",
      "dimensions": ["region", "cohort_year"],
      "filters": {
        "region": "EMEA",
        "cohort_year": 2025
      }
    }

    模型要做的只有一件事:把EMEA 地区 2025 年这批客户的 LTV 是多少翻译成上面这个 JSON。它不需要知道 LTV 背后有哪几张表、要不要剔除退款、跨币种怎么换算、订阅和一次性付费怎么合并——这些都在语义层里写好了。

    语义层收到请求之后做的活是:解析customer_lifetime_value的定义,沿着对象图找到customers → orders → subscriptions → fx_rates的 join 路径,套上当前用户的 EMEA 行级权限,注入时间窗口和币种换算,编译成目标方言的 SQL,执行,返回一个确定的结果。

    这个分工的关键在于模型的输出空间被收窄了。它不再有自由写任意 SQL 的权力,只能从受治理的指标和维度里做选择。选错了口径也会被定义本身拦住,选错了维度最多是看得不细。这跟「让一个实习生随便写 SQL」完全是两种风险结构。

    行业老兵 Andrew Brust 的说法很到位:

    「语义」这个词以前是理想化的,现在它变得字面化了。如果 AI 不理解你的数据是什么意思,它只能猜或者幻觉……AI 很积极,它想取悦你。没有护栏,它会返回看起来很权威、其实不是那么回事的结果。

    5.1 一份真实的最小实现

    有一套基于 MCP 的开源实现值得拆开看,因为它正好卡在 Text2SQL 和语义层的分界线上。

    它暴露了三个工具:retrieve_schema、list_tables、execute_sql_query。

    """
    src/tools/mcp_tools.py: Defines tools for text-to-SQL operations.
    - Uses direct function calls instead of fastmcp for simplicity.
    - Includes a LangChain-compatible SchemaRetrievalTool with Pydantic fields.
    """
    from langchain_core.tools import BaseTool
    from pydantic import Field
    from src.config.config import CONFIG
    from src.core import schema_retrieval
    from src.utils.logging import setup_logging
    logger = setup_logging(__name__)
    def execute_sql_query(query: str, db) -> str:
        """Execute a SQL query and return results or error message."""
        try:
            result = db.run(query)
            return str(result)
        except Exception as e:
            return f"Error: {str(e)}"
    def list_tables(db) -> str:
        """List available tables in the database."""
        return str(db.get_usable_table_names())
    def retrieve_schema_tool(query: str, vector_store) -> str:
        """Retrieve relevant schema from ChromaDB."""
        if vector_store is None:
            # Fallback: Use schema from config if vector_store is not provided
            logger.info("Using fallback schema from CONFIG")
            return CONFIG["schema"]
        return schema_retrieval.retrieve_schema(vector_store, query)
    class MCPClient:
        def call_tool(self, tool_name: str, args: dict):
            """Mock MCP client to call tools directly."""
            if tool_name == "execute_sql_query":
                return execute_sql_query(args["query"], args["db"])
            elif tool_name == "list_tables":
                return list_tables(args["db"])
            elif tool_name == "retrieve_schema":
                return retrieve_schema_tool(args["query"], args.get("vector_store"))
            raise ValueError(f"Unknown tool: {tool_name}")
    def initialize_mcp_tools(db, vector_store):
        """Initialize mock MCP client."""
        return MCPClient()
    class SchemaRetrievalTool(BaseTool):
        name: str = "schema_retrieval"
        description: str = "Retrieve relevant database schema for a given query."
        mcp_client: object = Field(description="MCP client for schema retrieval")
        def __init__(self, mcp_client):
            super().__init__(mcp_client=mcp_client)
        def _run(self, query: str) -> str:
            """Synchronous execution of schema retrieval."""
            return self.mcp_client.call_tool("retrieve_schema", {"query": query, "vector_store": None})
        async def _arun(self, query: str) -> str:
            """Asynchronous execution (not used, but required by BaseTool)."""
            return self._run(query)

    外层是一个 LangChain 的 ReAct agent,循环里明确了「想—做—看—验」四步,并且限制最多五轮:

    """
    src/agents/agent.py: Initializes and runs the LangChain ReAct agent for text-to-SQL.
    - Uses tools for SQL execution, table listing, and schema retrieval.
    - Executes generated queries and returns accurate results.
    - Supports self-correction via error analysis and retries.
    """
    from langchain.agents import create_react_agent, AgentExecutor
    from langchain_community.tools.sql_database.tool import (
        QuerySQLDataBaseTool,
        ListSQLDatabaseTool,
    )
    from langchain_core.prompts import PromptTemplate
    from src.tools.mcp_tools import SchemaRetrievalTool
    from src.utils.logging import setup_logging
    from src.config.config import CONFIG
    from langchain_community.utilities import SQLDatabase
    logger = setup_logging(__name__)
    def initialize_agent(llm, db, mcp_client):
        """Initialize LangChain ReAct agent."""
        # LangChain tools
        query_tool = QuerySQLDataBaseTool(db=db)
        list_tables_tool = ListSQLDatabaseTool(db=db)
        schema_tool = SchemaRetrievalTool(mcp_client)
        # ReAct-compatible prompt template
        SQL_PROMPT = PromptTemplate.from_template(
            """
            You are an expert SQL assistant tasked with answering user questions by generating and executing SQL queries based on the provided database schema.
            Your goal is to:
            1. Generate a syntactically correct SQL query to answer the question.
            2. Execute the query using the sql_db_query tool to retrieve the result.
            3. Verify the result makes sense given the schema and question.
            If the query fails or the result seems incorrect, analyze the error, correct the query, and retry.
            Question: {question}
            Schema: {schema}
            Available tools:
            {tools}
            Tool names: {tool_names}
            Follow this process:
            Thought: [Explain your reasoning for the query]
            Action: sql_db_query
            Input: [The SQL query to execute]
            After execution:
            Observation: [The result returned by the tool]
            Thought: [Verify if the result answers the question correctly]
            Final Answer: [The query result, e.g., [(3)]]
            If the question explicitly asks for only the query, return:
            Final Answer: [SQL query]
            Scratchpad for intermediate steps:
            {agent_scratchpad}
            """
        )
        # Create agent
        agent = create_react_agent(
            llm=llm,
            tools=[query_tool, list_tables_tool, schema_tool],
            prompt=SQL_PROMPT,
        )
        # Create executor
        executor = AgentExecutor(
            agent=agent,
            tools=[query_tool, list_tables_tool, schema_tool],
            verbose=True,
            max_iterations=5,
            handle_parsing_errors=True,
        )
        logger.info("Initialized LangChain agent")
        return executor
    def process_text_to_sql(executor, mcp_client, question: str) -> dict:
        """Process a user query and return SQL query/result."""
        try:
            schema = mcp_client.call_tool("retrieve_schema", {"query": question, "vector_store": None})
            logger.info(f"Retrieved schema: {schema}")
            result = executor.invoke({"question": question, "schema": schema})
            logger.info(f"Agent result: {result}")
            output = result.get("output", "No result returned.")
            # Extract query and result from output
            query = None
            query_result = output
            # If output contains a query, extract it
            if "SELECT" in output:
                # Try to find the query in the agent's reasoning steps
                for step in result.get("intermediate_steps", []):
                    if step[0].tool == "sql_db_query":
                        query = step[0].tool_input
                        query_result = step[1] if step[1] else output
                        break
            # Verify result by re-executing the query
            if query and query_result and query_result != "No result returned.":
                db = SQLDatabase.from_uri(CONFIG["database_uri"])
                try:
                    verified_result = db.run(query)
                    if verified_result != query_result:
                        logger.warning(f"Agent result {query_result} differs from verified result {verified_result}")
                        query_result = verified_result
                except Exception as e:
                    logger.error(f"Verification failed: {str(e)}")
                    query_result = f"Error verifying result: {str(e)}"
            return {
                "question": question,
                "sql_query": query,
                "result": query_result
            }
        except Exception as e:
            logger.error(f"Error processing query: {str(e)}")
            return {"question": question, "error": str(e)}

    这段代码写得挺实在,几个工程细节值得留意:retrieve_schema用 ChromaDB 做 schema 的向量检索,检索不到就回落到配置里的全量 schema,保证流程不断;max_iterations=5限制住循环,防止模型自己跟自己较劲烧钱;最后还拿结果重跑一遍做校验,日志里记下不一致的情况。

    但它同时也把边界暴露得很清楚。这里的retrieve_schema检索的是表,不是指标。它能让模型更快找到airplanes表有哪几列,但没有任何机制告诉模型“什么样的用户算流失”。换句话说,上下文变窄了,语义还是空着的。检索对了表,不代表检索到了口径。

    这就是从 Text2SQL 到语义层 BI 的那条分界线。两者的输入都是自然语言,区别在于模型最终被允许动什么:是任意一张表,还是一组被定义过的指标和维度。

    七、市面上现在有几条路线

    语义层这个市场这两年突然挤满了人,路线其实差别很大:

    方案

    定义写在哪

    出口

    适合谁

    代价

    dbt MetricFlow

    dbt 项目里的 YAML,和模型代码放一起

    通过 dbt server / JDBC 供下游消费

    已经把转换放在 dbt 里的团队

    绑在 dbt 生态上,指标改动要走数据团队

    Cube

    JS / TS / YAML 定义,内置预聚合缓存

    SQL API、REST、GraphQL 三套

    要做嵌入式分析、要给 agent 供数

    自己运维一套服务

    AtScale

    虚拟化层,不搬数据

    XMLA / MDX,对旧 BI 工具伪装成多维库

    多套 BI 并存的大企业

    重,实施周期长,价格不便宜

    Snowflake Semantic Views

    建在 Snowflake 里的语义视图

    Cortex AI 直接消费

    数据本来就在 Snowflake

    逻辑绑在这朵云上

    Databricks UC Metric Views

    Unity Catalog 里,和治理、血缘放一起

    AI/BI、外部客户端通过 Delta Sharing

    湖仓路线,多格式数据

    依赖 Unity Catalog 体系

    SAP Datasphere

    从 S/4HANA 继承,不是手写

    Joule / 知识核心

    SAP 是主系统的企业

    只对 SAP 世界有效

    7.1 dbt:把指标当代码管

    MetricFlow 是 dbt 收购 Transform 之后整合进来的,思路很对工程团队的胃口。指标就是仓库里的一堆 YAML,和模型放一起,走同一个 Git 流程。

    # dbt MetricFlow 定义示例
    semantic_model:
      name: orders
      node_relation:
        relation_name: ref('fct_orders')
      entities:
        - name: order_id
          type: primary
      measures:
        - name: order_amount
          agg: SUM
    metrics:
      - name: total_revenue
        type: simple
        type_params:
          measure: order_amount

    好处不用多说:改指标要提 PR,要有人 review,有 CI 拦着,历史能回溯。坏处也在同一件事上,业务方想调个口径,得排进数据团队的迭代。这是所有代码化治理都要付的税。

    7.2 Snowflake 和 Databricks的两种性格

    Snowflake 的做法是把语义标注直接嵌进表结构旁边,让 Cortex 消费。用户体验最好——问一句就出结果,优化器、权限、缓存全是原生的。代价是逻辑定义跟这朵云计算绑在了一起,将来想换个引擎,得重新搬一遍。

    Databricks 反过来,把语义放进了 Unity Catalog,当成治理和血缘的一部分,底层是 Delta Lake 这种开放格式。好处是企业可以在外部客户端、多云笔记本之间共享同一套受治理的定义;代价是链路上多了几层,出问题要一层层排查。

    两家的差异说白了不是技术优劣,是「简单」和「开放」的取舍。

    7.3 那个不打算上牌桌的SAP

    整个行业都在推开放语义标准,SAP 一直很淡定。原因不复杂:它不需要在别人的数据上重建语义,因为它本身就是语义的产地。

    从 SAP 抽过数的人都知道那是什么体验。会计凭证行项目表叫BSEG,物料主数据叫MARA,几万个德语缩写,加上配置层、嵌套账本逻辑、严格的凭证流关系。把这些原始表原样抽到 Snowflake 或 BigQuery,技术上是成功的——数据落地了。但凭证分割规则、税码推导、跨币种换算、物料层级,全留在了 SAP 里面。

    于是外部团队开始干一件非常痛苦的事:在 YAML 里手工重写几百万行 ERP 业务规则。写得出来,但没人敢保证写对,每次 SAP 升级还要跟着改。

    Datasphere 的做法是把这条路反过来:语义不从外面逆向,而是从 S/4 HANA 直接继承下来。系统里有个叫知识核心的东西,把业务实体、关联、计算元素、权限这套东西原样暴露给 LLM。agent 问的时候不用猜「财务表和物料表怎么连」,平台本来就知道。

    这件事的启示跟技术选型无关:管理上下文最省事的办法,是一开始就别把它丢掉。

    八、真要落地,五条规则

    8.1 语义定义只能走代码评审

    不要让任何人在生产环境的界面上点着改指标。实体、join 拓扑、指标公式、维度属性,全部落在版本控制里,改动必须走 PR、过自动校验、有人签字。

    这条最难执行,因为业务方会嫌慢。但它是所有其他规矩的前提——定义一旦能被随手改,你后面所有的测试、审计、血缘都失去意义。

    8.2 定义必须在消费层的上游

    指标只在语义仓库里定义一次,Power BI、Excel、Text2SQL agent、下游运营系统都从这里取。如果某个分析师在单个仪表盘里做了一个指标覆盖,那不是灵活,那是治理失守的第一块砖。

    判断标准很土但很好用:改一个口径,需要动几个地方?答案必须是 1。

    8.3 指标要分层,别搞一刀切

    所有指标都走最严的流程,团队会被拖死;所有指标都放开,半年后你会有三百个互相冲突的活跃用户。分层是唯一可行的中间态:

    层级

    范围

    治理方式

    谁能改

    Tier 1 核心指标

    收入、ARR、毛利、人力成本

    集中治理,数据委员会审批

    数据团队 + 财务/业务负责人

    Tier 2 领域指标

    单次点击成本、归因窗口

    联邦治理,业务单元的分析工程师负责

    领域内数据工程

    Tier 3 实验指标

    临时探索用的一次性口径

    沙箱隔离,禁止 agent 自动调用

    分析师本人,过期自动清理

    关键在最后一条:Tier 3 必须挡在 agent 之外。人可以看着一个自己都知道不严谨的指标做探索,agent 不会。

    8.4、每次改定义都跑回归测试

    语义模型一改,PR 流水线就该拿一批标准问题去打沙箱环境,把结果和已知的历史基准对比。重点不是SQL 能不能跑通,是数有没有莫名变大。

    join 结构改一下导致扇出、过滤器少一层导致口径放宽,这两类问题在 code review 里看不出来,只有跑数能发现。测试用例不用多,二三十个核心指标各配两三个典型场景就够拦住大部分事故。

    8.5、给 agent 上预算和配额

    Agent 是迭代型的,一个计划问二十次很正常。如果每次都是全表扫描,账单会非常难看。

    在语义层这一层做三件事:单次查询的行数上限、单个用户/单个 agent 的查询预算、高频请求自动路由到预聚合表或缓存。这些都必须在语义层做,因为下游的 agent 你管不住。

    五个常见的错误如下:

    错误做法

    当时的想法

    后来的结果

    在 BI 工具里改指标

    「就这一次,先应付业务」

    半年后没人知道线上到底是哪个口径

    把 join 逻辑写进 prompt

    「多写几句提示词就行了」

    prompt 变成第二套语义层,还没人 review

    拿表注释当语义

    「注释写得详细点就够了」

    注释是描述,不是计算逻辑,模型照样不知道口径

    语义层只做文档不接执行

    「先梳理清楚,接不接以后再说」

    文档三个月就过期,没人再打开

    一次性建全公司的语义模型

    「要建就建完整」

    六个月没上线,业务方失去耐心,项目黄了

    最后一条尤其值得警惕。语义层是个持续演进的东西,不是一次性交付的工程。先把一个业务域的十个核心指标跑通、真正接到 agent 上,比画一张覆盖全公司的蓝图有用得多。

    九、还没解决的问题

    语义层不是银弹,它自己也有一堆没解决的事。

    歧义消不掉。自然语言本身不做承诺。「上个月」是自然月还是过去 30 天,「新客」是注册算还是首单算,这些在语义层里可以有明确答案,但用户脑子里想的可能是另一个。语义层能做的是把公司的标准答案固定下来,然后在用户问的时候把口径一起返回——而不是假装歧义不存在。

    schema 规模是硬约束。前面算过那笔账,2000 张表的 DDL 塞不进任何上下文窗口。语义层通过收窄接口缓解了这个问题,但「从几千个指标里挑对那三个」本身又变成了一个新的检索问题。

    成本。agent 的迭代特性决定了它的查询量是人的几十倍。预聚合、缓存、配额能压住大部分,但遇到真正需要全表扫描的探索型问题,账单还是会跳。

    标准还在路上。开放语义互换(OSI)这类倡议想做的是让语义模型跨平台通用——在开放仓库里写的定义,Snowflake 能直接解释,Cube 能对外暴露,外部 agent 能直接导航。方向是对的,但现在还没到能依赖的阶段。真要做选型,还是要按「这套定义将来能不能搬走」来评估。

    生成式语义听着很美。有些平台开始在做了:分析查询日志、血缘路径、甚至组织内的沟通记录,反推业务含义,自动生成语义定义、标记断掉的 join 路径、提出新指标配置供人审批。这件事如果能成,语义建设的人工成本会降一个数量级。但它同样需要一个能审的人,机器猜出来的口径,你敢直接让它上生产吗。

    小结

    SQL 只是一张语法正确的答卷,它不负责回答你们公司怎么定义这件事。这个定义过去藏在分析师的脑子里、藏在某个 Excel 的隐藏列里、藏在三年前一次会议的口头约定里。人还在的时候,这些藏起来的东西能靠追问捞出来;agent 来了,没人可问,它只能猜。

    所以语义层这件事,技术只占一半,另一半是把公司到底怎么算这笔账从人脑里搬到一个机器能读、能审、能版本化的地方。搬的过程很枯燥,要开会、要吵架、要让业务方签字,一点都不酷。

    但它是唯一能让 agent 的输出变得可信的办法。

    数据是燃料,语义是地图。没有地图,燃料只会让 AI 在企业这座迷宫里跑得更快,错得更远。而地图这个东西,谁画的,路就按谁的走法走。

    【关联阅读】

    跳转微信打开

    本体引导的知识提取

    2026年11月3日 20:26

    原创 半吊子全栈工匠 2026-11-03 20:26 北京

    本体引导的知识提取,从文档到上下文感知规则,让企业知识真正“可用”!

    【引】本体引导的知识提取,从文档到上下文感知规则,让企业知识真正“可用”。本文是对《本体驱动的AI大模型:方法与实践》一书的解读与补充。

    我们经常会遇到这样的问题:一份设备维护手册里写着“高温会导致部件老化”,但具体多高的温度算“高温”?这个结论适用于哪种型号的设备?在什么运行配置下才成立?缺少了这些关键信息,再精准的事实提取也无法为设备维护决策提供有效支持。这就是企业知识管理的痛点所在:我们不缺知识,缺的是将知识转化为受管控、可执行、可审计的决策逻辑的能力。

    本文将介绍一种以本体为核心的知识提取架构,它不再将本体仅仅作为提取知识的模板,而是让本体成为语义控制层,引导知识从零散事实向情境化、可测试的规则转化,真正实现企业知识的“可操作化”。这种架构适用于制造、金融、能源、医疗等多个行业,能够为风险评估、合规审查、设备维护、工作流自动化等场景提供有力支撑,且无论领域如何变化,核心架构都能保持稳定。

    一、从“描述性事实”到“条件性规则”

    我们先来看一下传统的知识提取流水线:

    文档→ 提取实体、关系和事实 → 构建知识图谱

    这套流水线的优势很明显,它能帮我们快速梳理出文档中包含的核心概念、概念的属性,以及概念之间的关联,还能追溯每个事实的来源,找出提及同一概念的所有文档。这些功能对于知识搜索、信息发现、检索增强生成和语义集成来说,已经足够实用。

    但如果我们的目标是支持业务决策,这套流水线就远远不够了。决策类系统需要的不是孤立的、描述性的事实,而是带有条件、约束和语境的结构化知识。它需要的是这样的逻辑:在语境Z下,当条件X和Y同时满足时,结合证据E,可以推导出结论R。

    我们通过两个例子来对比一下这两种知识表示方式的差异。第一种是传统提取得到的描述性事实:“高温与部件老化相关”。第二种是决策系统需要的条件性规则:“如果X类型的部件在Y配置下,运行温度超过批准的阈值,且持续时间超过允许时长,那么该部件的老化风险会显著升高”。

    对比之下不难发现,第二种表示方式包含了完整的操作结构:明确的主体、类型约束、可测量的条件、具体的阈值、持续时间、操作语境、结论,以及隐含的证据要求。这样的规则可以被评估、测试、审查,甚至直接转化为可执行的代码,真正为业务决策提供支撑。

    这也是知识提取的核心转变方向:从提取孤立的事实,转向提取和生成包含条件、约束、背景、观察、证据、结论、例外、建议行动等内容的结构化知识陈述。只有当提取的知识能够转化为情境化、受控且可测试的决策逻辑时,企业积累的海量文档资料,才能真正成为可操作的核心资产。

    二、本体引导的知识到规则模式

    要实现从事实到规则的转化,核心就是引入本体作为引导和控制的核心。本体引导的规则生成架构,并非一步到位生成可执行规则,而是通过多步转化,让知识逐步落地,其核心流程如下:

    非结构化/半结构化知识源 → 本体解释 → 生成一般知识规则 → 绑定特定上下文 → 生成决策/诊断规则草案 → 验证审查 → 转化为可执行逻辑

    这个过程的起点,是企业中各类非结构化或半结构化的知识源,比如我们前面提到的工程文件、法规政策、操作手册等。这些资料本身没有统一的结构,需要依靠本体来进行解释。本体通过定义领域内的核心概念、概念之间的关系、语义角色和约束条件,为零散的知识建立起统一的语义框架,让系统能够“读懂”文档中的知识。

    需要注意的是,从知识源中提取并生成的第一个成果,并非直接可用的生产规则,而是一般知识规则。这类规则描述的是条件和结果之间可重复使用的通用关系,不涉及具体的业务场景。随后,我们会将这些一般规则与具体的业务上下文绑定,比如特定的资产类型、产品配置、流程阶段、系统环境、组织政策等,再结合实际的观察、事件和测量数据,生成决策或诊断规则草案。

    这里有一个关键要点:生成的规则草案,并不一定是最终的决策结论。在实际业务场景中,企业知识往往具有条件性、不完整性或概率性,因此规则草案可能代表的是候选解释、高风险提示、影响因素、政策适用性评估、建议的行动,或者是需要补充额外证据、提交专家审阅的结论草案。一个可靠的知识系统,必须保留这些不确定性,而不是将每一个提取的关系都转化为绝对的确定性规则,这也是保证决策科学性的重要前提。

    三、知识规则的三个层次

    在本体引导的规则生成架构中,我们可以将规则分为三个层次,这三个层次由浅入深、由抽象到具体,逐步实现知识的可操作化。清晰区分这三个层次,能够帮助我们更好地管理知识、验证规则,避免将通用原则与具体场景混淆。

    3.1 Level 1:一般知识规则——领域通用的核心原则

    一般知识规则是领域内通用的、可重复使用的核心原则,它不指向特定的客户、产品、资产、组织或流程实例,是所有后续规则生成的基础。其基本形式为:

    条件A + 条件B + 启用约束C → 结果或风险R

    举几个实际场景中的例子:反复过载 + 冷却不足 → 设备故障风险升高;异常交易序列 + 控制权共享特征 → 欺诈风险升高;敏感操作 + 缺少审批流程 → 可能违反合规要求。这些规则适用于同一类场景,不针对具体的某一台设备、某一笔交易或某一次操作。

    一般知识规则的来源非常广泛,包括行业研究论文、行业标准、相关立法、企业内部政策、操作手册、专家经验、历史事件报告和调查结论等。这些规则表达的是在一类情况下可能成立的规律,但并没有明确该规则是否适用于某个具体场景,也没有明确具体的执行标准,因此还需要进一步的转化和落地。

    3.2 Level 2:情境化规则——绑定具体业务场景

    情境化规则的核心,是将一般知识规则与具体的操作环境、业务场景绑定,让通用原则落地到具体的业务中。比如,将“反复过载 + 冷却不足 → 设备故障风险升高”这个一般规则,绑定到工业压缩机的场景中,就变成了:工业压缩机在额定负载以上运行 + 冷却风扇容量低于要求标准 + 高负载运行反复出现 → 压缩机故障风险升高。

    这里的“上下文”涵盖的范围非常广,主要包括:资产或产品类型、组件结构、客户细分、地理位置、合同类型、系统配置、流程阶段、材料组合、设备型号、操作环境等。这些上下文信息,决定了规则的适用范围和具体执行标准。

    在这个过程中,本体发挥着关键的引导和验证作用。一方面,本体通过确定候选概念对特定语义角色是否有效,引导系统完成规则与上下文的绑定;另一方面,本体还能检测不兼容的绑定,避免出现逻辑错误。比如,要求“操作环境”作为上下文的规则,不能与被分类为“金融交易”的实体绑定;需要“可测量属性”的规则,不能与文档、组织等无法测量的实体绑定。因此,情境化不仅仅是简单的变量替换,更是对规则适用范围和有效性的精准界定。

    3.3 Level 3:决策或诊断规则——结合实际数据,支持业务决策

    第三个层次是决策或诊断规则,也是最贴近实际业务应用的规则,它在情境化规则的基础上,结合了实际的观察、事件、测量数据或状态变化,能够直接为业务决策提供参考。其基本形式为:情境化条件 + 观测状态 + 相关事件 + 可用证据 → 候选结论。

    例如,如果X类型的资产在Y配置下运行,且观测到异常的温度模式,同时冷却系统报告容量下降,那么冷却相关的老化问题,可能是导致当前异常状态的原因。这里的结论,并非绝对的判定,而是需要明确标注其知识置信度。

    结论的置信度类型主要包括确认的结论、候选原因、影响因素、相关性、高风险提示、未经证实的假设、证据不足的结果等。这样的设计,能够有效避免系统将简单的关联关系,错误地转化为确认的因果关系,保证决策的严谨性。比如,“事件A发生在结果B之前”,并不意味着“事件A导致了结果B”;“条件A经常与风险B同时出现”,也不代表“条件A一定会引发风险B”。明确标注置信度,是知识系统可信、可用的重要保障。

    四、本体作为语义控制层

    在整个架构中,本体的作用远不止于定义领域概念和关系,更重要的是,它在知识提取、情境化、规则生成和验证的全过程中,充当着语义控制层的角色,为知识的转化和落地提供统一的标准和约束,避免出现语义混乱、逻辑错误等问题。具体来说,本体的控制作用主要体现在四个方面。

    4.1 定义语义角色,让知识“各司其职”

    任何一条规则,都包含不同类型的参与者,比如目标、条件、处理过程、事件、观察、测量的特性、约束、证据、风险、原因、行动、结论等。本体通过明确定义这些语义角色,帮助系统在知识提取过程中,准确区分文档中出现的概念,以及这些概念在知识陈述中所承担的功能。

    比如,文档中提到“长时间暴露在水分中,会增加未受保护构件的腐蚀风险”,通过本体的引导,系统能够准确识别出:“湿度暴露”是条件,“暴露持续时间”是变量,“未受保护组件”是范围主体,“腐蚀风险”是结论。这样一来,零散的句子就被拆解为结构化的知识元素,为后续的规则生成奠定了基础。

    4.2 定义有效关系,规范知识“连接方式”

    本体的另一个重要作用,是限制哪些概念之间可以建立关联,明确概念之间的有效关系,为规则的解释提供统一的语义结构。比如,本体可以定义:资产参与流程、观察测量属性、事件发生在流程阶段内、政策适用于业务活动、证据支持结论、配置约束操作等。

    这些明确的关系定义,能够避免系统出现不合理的概念关联,保证知识的逻辑性和一致性。比如,系统不会错误地将“设备型号”与“审批流程”建立无关的关联,也不会将“温度测量”与“客户投诉”错误绑定,从而确保提取的知识和生成的规则符合业务逻辑。

    4.3 强制约束,验证知识“有效性”

    本体中定义的各类约束,是验证知识有效性、避免逻辑错误的关键。这些约束主要包括:领域和范围约束、所需关系约束、概念兼容性约束、单元兼容性约束、基数性约束、允许的分类约束、互斥状态约束、适用条件约束等。

    在实际操作中,我们可以借助相关技术工具来实现约束的验证:OWL推理可以支持逻辑一致性验证,确保规则的逻辑推导没有矛盾;SHACL可以验证知识图谱的结构、所需属性和数据质量条件,确保知识的完整性和准确性。通过这些约束验证,能够及时发现并纠正知识提取和规则生成过程中的错误,提升规则的可靠性。

    4.4 词汇对齐,解决知识“语言障碍”

    企业中的文档资料,往往来自不同的部门、不同的时期,使用的术语也存在很大差异:同一概念,可能会有缩略词、本地名称、遗留术语、产品特定标签、同义词等多种表达方式。这种术语的不统一,会导致知识提取出现偏差,无法实现知识的有效整合。

    本体通过提供规范性的概念和映射关系,将不同来源的术语,统一映射到企业的标准术语体系中,解决了术语不统一的问题。比如,“工业压缩机”“空压机”“压缩机组”等不同表述,通过本体的映射,都可以统一为“工业压缩设备”这个标准概念。这样一来,系统就能识别出不同文档中描述的是同一个核心概念,实现知识的有效整合和复用。

    可以说,本体就像一份“语义契约”,连接起了文档、知识图谱、企业数据、规则、智能体和运行时系统,让整个知识转化过程有统一的标准可依,确保知识在各个环节的流转中,不会出现语义偏差和逻辑混乱。

    五、端到端的AI原生生成流水线

    基于本体的语义控制作用,我们可以构建一套端到端的AI原生生成流水线,将知识从文档到可执行规则的转化过程,拆解为9个标准化阶段,每个阶段都有明确的目标和操作规范,确保知识转化的效率和质量。

    第1阶段:提取结构化知识陈述

    这一阶段的核心,是从非结构化文档中,提取出包含条件、结果、原因、效果、异常、阈值、变量、约束、建议、证据、适用性等内容的结构化知识陈述,而不仅仅是识别名词和关系。同时,对于每个提取的陈述,系统必须完整保留其溯源信息,包括来源文档、章节或页码、表格或图表、原始句子、提取方法、提取置信度等。溯源至关重要,因为后续生成的所有规则,都必须能够追溯到支持它的原始知识,这是规则可审计、可审查的基础。

    第2阶段:解读一般规则

    在这一阶段,系统会将提取的自然语言知识陈述,转化为结构化的规则骨架。比如,将“反复过载+冷却不足→设备故障风险升高”,转化为“输入:条件A(反复过载)、条件B(冷却不足);结论:结果R(设备故障风险升高)”的结构。此时,规则中的变量可能仍然是抽象的,这一阶段的核心目标,是明确知识的逻辑结构:需要哪些条件、需要测量哪些变量、哪些约束会影响结果、支持哪个结论、是否存在例外情况、这种关系是因果关系、相关关系还是建议关系。

    第3阶段:将变量绑定到本体概念

    这一阶段的核心,是将规则骨架中的抽象变量,映射到本体中定义的具体概念和属性。比如,将“条件A”映射到“设备运行状态”,将“条件B”映射到“冷却系统性能”,将“结果R”映射到“设备故障风险”。在这个过程中,本体将发挥验证作用,检查这些映射是否在语义上兼容。如果存在多个候选概念,系统不会默默做出选择,而是会保留所有替代方案,提交给人类专家进行确认,避免出现映射错误。

    第4阶段:将规则与企业背景联系起来

    完成变量与本体概念的绑定后,系统会将一般规则与企业的具体业务背景结合,解决规则的“落地”问题。这一过程可能涉及将抽象角色,与企业实际的资产、流程模型、产品、组织单位等关联起来。同一个一般规则,可能会根据不同的业务背景,生成多个情境化变体。比如,“反复过载导致设备故障风险升高”这个一般规则,在不同的资产设计、操作环境、控制配置、监管管辖权下,会有不同的具体执行标准,形成不同的情境化规则。

    第5阶段:将规则变量映射到数据

    规则要想真正可执行,就必须明确所需数据的来源。这一阶段,系统会确定规则中每个变量对应的数据源,比如:本体属性对应数据库中的某一列、本体概念对应API的响应结果、观察数据对应事件流、阈值对应批准的参数注册表、状态对应知识图谱中的断言等。同时,系统还会明确数据的类型、单位、更新频率、来源所有权、质量状态、可用性,以及必要的转换逻辑。需要特别注意的是,对于缺失的字段,系统必须明确报告,绝对不能因为规则需要,就随意创建运行时值,这是保证规则可靠性的关键。

    第6阶段:添加观察和证据

    情境化规则只有与实际的观测数据结合,才能真正具备可操作性。这一阶段,系统会将规则与实际的观测结果关联起来,这些观测结果包括:设备测量数据、状态转换记录、系统事件、业务交易、警告信息、检查结果、用户报告、外部信号等。系统会根据规则中描述的条件,对这些观测结果进行评估,同时明确区分证据与结论——测量数据可以支持某个假设,但不能直接证明假设成立,必须保留这种不确定性。

    第7阶段:生成监管规则草案

    这一阶段,系统会生成监管规则草案,而非直接生成可执行代码。规则草案需要包含完整的信息,具体包括:规则身份、规则类型、适用范围、本体绑定关系、所需输入、派生值、条件、结论、证据、缺失的输入、需要批准的阈值、置信度或状态、审查要求等。生成草案的目的,是为后续的验证和审查提供清晰的载体,确保规则的每一个细节都能被追溯、被审查。

    第8阶段:验证和审查

    在将规则部署到实际业务系统之前,必须进行多维度的验证和审查,这是保证规则可用性和可靠性的关键环节。验证主要包括:模式有效性验证(检查规则是否符合中间模式)、本体一致性验证(检查本体概念和关系的使用是否正确)、数据可用性验证(检查规则所需数据是否可获取)、单元兼容性验证(检查数据单位是否统一)、阈值审批验证(检查阈值是否经过批准)、证据充分性验证(检查支持结论的证据是否充足)、因果措辞验证(检查因果关系的表述是否严谨)、适用范围验证(检查规则的适用范围是否合理)、测试覆盖率验证(检查是否有足够的阳性、阴性测试用例)。

    在验证的基础上,人类专家还需要对规则进行最终审查,重点确认:规则是否有效、适用范围是否合适、阈值是否合理、因果关系的表述是否严谨、规则是否可能触发自动化操作、规则是否具备投入生产的条件等。尤其是在规则涉及安全、合规、财务结果或客户决策的场景中,人类专家的审查和批准,是必不可少的环节。

    第9阶段:编译批准规则

    经过验证和审查,获得批准的规则草案,会被编译为可执行的代码,具体的执行技术,会根据实际的业务场景选择,比如SPARQL查询语言、SHACL规则、SWRL规则、Cypher密码,或者企业自定义的规则语言。需要注意的是,规则的语义应保持独立于运行时语言,这样一来,即使更换了执行技术,规则的核心逻辑也不需要重新定义,提升了规则的复用性和可维护性。

    六、中间规则表示

    直接从文档生成可执行规则,是一种非常危险的做法。因为运行时语言(如Cypher、SPARQL等)的语法和逻辑,可能会模糊规则中需要优先审查的假设和前提,一旦出现错误,很难追溯和修改。因此,在规则生成过程中,引入中立的中间规则表示,是降低风险、提升规则可维护性的关键。

    中立的中间规则表示,核心是分离三个核心关注点:知识的含义、知识适用的语境、用于执行知识的技术。这样一来,规则的语义含义不会被执行技术的细节所掩盖,便于专家进行审查和修改,也便于后续将同一规则编译为不同的执行代码。

    我们来看一个简化的中间规则表示示例:

    rule_id: RULE-001(规则编号)

    rule_type: diagnostic(规则类型:诊断)

    status: draft(规则状态:草案)

    scope:(适用范围)

    subject_type: target_subject_type(主体类型)

    process_stage: target_process_stage(流程阶段)

    bindings:(本体绑定)

    role_a: ontology_concept_a(角色A对应本体概念A)

    role_b: ontology_concept_b(角色B对应本体概念B)

    inputs:(所需输入)

    - observed_value_a(观测值A)

    - observed_value_b(观测值B)

    - contextual_condition(语境条件)

    derived:(派生值)

    difference: abs(observed_value_a - observed_value_b)(派生值:观测值A与B的差值绝对值)

    conditions:(执行条件)

    - difference > ${approved_threshold}(差值超过批准阈值)

    - contextual_condition == true(语境条件满足)

    conclusion:(结论)

    candidate_outcome: target_risk(候选结果:目标风险)

    reasoning_status: candidate(推理状态:候选)

    evidence:(证据)

    - source_knowledge(来源知识)

    - source_data(来源数据)

    - supporting_observation(支持性观测)

    missing_inputs: [](缺失输入:无)

    review_required: true(需要审查:是)

    从这个示例中可以看到,中间规则表示清晰地展示了规则的核心逻辑、适用范围、本体绑定关系、所需数据、证据和状态,所有关键信息都一目了然,便于审查和修改。同一个中间规则定义,后续可以编译到不同的执行技术中,而无需重新定义其语义含义,大大提升了规则的复用性和可维护性。

    七、架构模式中的Agent能力

    本体引导的知识提取架构,并不依赖单一的智能体,而是可以通过多个智能体分工协作,或者构建具有专门功能的单个协调工作流来实现。这里的“智能体”,并非特指独立的自主应用,而是一种逻辑上的责任划分,每个智能体承担特定的任务,共同完成知识从文档到规则的转化过程。具体来说,我们可以设置以下7类智能体:

    1. 知识解释器:核心任务是将文档中的叙事性知识,转化为结构化的规则候选,完成知识的初步提取和结构化处理。

    2. 本体基础:负责将文档中的源术语,映射到本体中定义的标准概念,同时识别并报告模糊或不支持的映射,确保术语的统一和准确。

    3. 语境绑定器:将抽象的规则变量,与企业的具体业务语境绑定,解决规则的落地问题,生成情境化规则。

    4. 数据映射器:确定规则所需数据的来源,完成规则变量与数据源的映射,同时识别数据的类型、单位、质量等关键信息,报告缺失的数据。

    5. 规则生成器:基于前面的工作,生成中间规则、派生变量、所需阈值、证据引用以及测试用例,为后续的验证和审查提供基础。

    6. 规则验证器:负责对生成的规则进行多维度验证,包括模式一致性、本体兼容性、单元一致性、数据可用性、不受支持的阈值、缺失的证据和范围冲突等,及时发现并报告规则中的问题。

    7. 规则审查员:这里的审查员可以是人类专家,也可以是辅助审查的智能体,核心任务是确认规则的有效性、适用范围、阈值合理性、因果关系表述、自动化操作触发可能性,以及规则是否具备投入生产的条件,承担最终的审批责任。

    通过这些智能体的分工协作,知识转化的各个环节都有专门的角色负责,既提升了转化效率,又能有效避免错误,确保规则的质量。同时,这种分工模式也便于后续的维护和优化,当某个环节的需求发生变化时,只需调整对应的智能体即可,不会影响整个架构的运行。

    八、证据、溯源和认知状态

    一个可信的知识规则,绝不仅仅是简单的IF-THEN陈述,它必须能够回答一系列关键问题:使用了哪些本体概念?哪些数据字段实例化了规则中的变量?引入了哪些假设?哪些阈值是经过外部批准的?运行时有哪些证据可用?缺少了什么证据?结果是推测、相关还是确认?谁审核和批准了这条规则?

    这些信息,必须作为规则模型的一部分,与规则本身绑定,而不是存储在不相关的文档中。只有这样,规则才能实现可审计、可追溯,才能被业务人员信任和使用。同时,规则的结论本身,也需要明确传达主张的力度,不能模糊其置信度。

    在实际应用中,我们可以通过定义特定的关系,来明确结论的置信度,比如:候选原因、提示风险、支持假设、相关联、需要补充证据、确认原因等。需要特别注意的是,这些关系不能被等同对待,必须严格区分关联关系和因果关系、推测和确认。比如,“事件A发生在结果B之前”,不能自动等同于“事件A导致了结果B”;“条件A经常与风险B同时出现”,也不能证明“条件A一定会引发风险B”。

    明确表示规则的认知状态,能够让知识图谱准确区分不同类型的知识:断言、假设、建议、观察、相关性、候选原因、确认原因等。这对于企业的合规审查、风险管控、决策支持来说,至关重要——它能避免因错误解读知识而做出不合理的决策,同时也能为决策提供清晰的证据支持,满足审计要求。

    九、流水线阶段的一级公民

    在知识转化的整个流水线中,验证绝不是最后一个环节的技术检查,而是贯穿全过程的核心部分,是保证规则可靠性和可用性的关键。我们将验证分为四个层次,每个层次都有明确的目标和要求,共同构成了规则的质量保障体系。

    1. 结构验证:核心是检查生成的规则是否符合中间规则表示的模式,确保规则的结构完整、格式规范,没有语法错误,便于后续的审查、修改和编译。

    2. 语义验证:重点检查本体概念和关系的使用是否正确,规则的语义是否符合领域逻辑,是否存在语义偏差或概念混淆的问题,确保规则的逻辑一致性。

    3. 操作验证:主要确认规则是否可以实际评估和执行,检查规则所需的数据是否可获取、数据质量是否达标、数据单位是否统一,确保规则能够落地到实际业务场景中。

    4. 认知验证:核心是检查规则的结论是否夸大了现有证据,是否将关联关系错误地转化为因果关系,是否明确标注了结论的置信度,确保规则的结论严谨、可信。

    除此之外,每条生产规则在投入使用前,都必须经过充分的测试,至少包括:阳性测试(验证规则在符合条件时能否正确触发)、阴性测试(验证规则在不符合条件时能否正常不触发)、边界测试(验证规则在条件边界值时的表现)、缺失数据测试(验证规则在数据缺失时的处理能力)、超出范围测试(验证规则在超出适用范围时的表现)。

    通过这四个层次的验证和全面的测试,能够确保生成的规则不仅在技术上可执行,而且在语义和操作上都值得信赖,能够真正为企业的业务决策提供有效支持。

    十、从提取流水线到知识生命周期

    本体引导的知识提取,并非一次性的工作,而是一个持续迭代、不断优化的过程,它应该被视为企业更广泛的知识生命周期的一部分。完整的知识生命周期,包括以下10个环节:获取 → 提取 → 建模 → 情境化 → 生成规则 → 验证 → 批准 → 执行 → 观察结果 → 优化知识。

    知识的生命周期,始于知识的获取,我们从文档、专家、数据和操作系统中,收集各类领域知识;随后,通过本体对齐的概念和关系,对知识进行提取和建模;将提取的一般知识进行情境化处理,转化为规则草案;经过验证和批准后,将规则部署到决策系统、推理引擎、工作流或应用程序中执行;在规则执行的过程中,持续观察执行结果,并将结果反馈到知识体系中,对现有知识和规则进行优化。

    在这个生命周期中,企业需要能够随时提出并回答一系列问题,来监控和优化知识体系:哪些规则被触发了?哪些结论被接受了?哪些建议被拒绝了?哪些证据经常缺失?预期的结果是否发生了?是否存在假阳性情况?规则的适用范围是否需要调整?基础知识是否需要修改?

    这种反馈机制,让企业的规则库不再是静态的专家逻辑集合,而是成为一种受管控、可进化的知识产品。随着企业业务环境的变化、领域知识的更新、新证据的出现,规则库能够不断优化和完善,始终适应企业的业务需求。比如,新的法规出台后,相关的合规规则可以及时更新;产品配置调整后,对应的设备维护规则可以同步优化;新的事件报告出现后,能够补充和完善现有的风险规则。

    知识生命周期的重要性,还体现在企业环境和领域知识的动态变化上。在实际业务中,新的证据可能会挑战现有的规则,业务流程可能会被重新设计,产品配置可能会调整,法规可能会更新,阈值可能会失效。只有建立完整的知识生命周期,才能确保企业的知识和规则始终保持最新、最有效,为业务决策提供持续的支撑。

    小结

    本体引导的知识提取,代表了企业知识系统设计方式的一次重要转变——从构建可搜索的知识图谱,转向打造可操作的知识规则,核心目标是将企业中零散、非结构化的专业知识,转化为可以进行情境化、评估、管理和负责任使用的决策逻辑。这种架构模式,不仅适用于各类企业,还能跨行业复用,无论领域如何变化,核心的架构原则和流程都能保持稳定。

    支撑这种模式的核心架构原则,主要有8条,也是企业在落地过程中需要重点遵循的准则:

    1. 提取关系、条件和约束:知识提取不能局限于识别术语,更要捕捉条件、效果、例外、变量、约束、观察、证据、适用性等关键信息,构建结构化的知识陈述。

    2. 将一般知识与本地语境分离:可重用的领域通用原则,不应直接嵌入单个产品、流程或应用中,而应保持独立性,通过明确的约束与具体语境绑定,提升知识的复用性。

    3. 将本体视为一个控制平面:充分发挥本体在提取、术语对齐、语义角色识别、上下文绑定、数据映射、验证、解释等环节的控制作用,让知识转化有统一的标准可依。

    4. 在可执行代码之前生成中立规则:通过中间规则表示,分离知识的语义、语境和执行技术,保留规则的意义、来源、假设、范围、缺失信息和检查状态,降低规则风险。

    5. 永远不要发明缺失的阈值或输入:对于未知信息,明确表示为知识差距,识别缺失的字段、观察结果、阈值、证据和未解析的映射,不随意创建运行时值,保证知识的可靠性。

    6. 保留不确定性和因果强度:候选原因、相关性、建议等,都应明确标注其置信度,不将关联关系等同于因果关系,不将建议自动转化为强制性行动,确保结论的严谨性。

    7. 让起源成为规则的一部分:知识源、本体绑定、数据源和审批历史,应与规则绑定,贯穿规则的整个生命周期,确保规则可追溯、可审计。

    8. 让人类对激活负责:AI系统可以加速知识提取、解释、绑定、验证等过程,但授权专家必须对规则的操作使用负责,尤其是在规则影响安全、合规、财务结果或客户决策的场景中。

    我们可以将企业知识的成熟度,分为三个层次:第一层次是可搜索知识,能够实现事实的发现;第二层次是关联知识,能够在上下文中梳理和解释事实;第三层次是操作知识,能够用事实支持治理决策、规则和行动。本体引导的知识提取,正是帮助企业实现从第一层次、第二层次,向第三层次跨越的关键路径。

    对于企业而言,海量的文档资料不是负担,而是宝贵的知识资产。通过本体引导的知识提取架构,将这些资产转化为可操作的决策规则,不仅能够提升业务决策的科学性和效率,还能降低风险、保障合规,为企业的数字化转型提供坚实的知识支撑。未来,随着AI技术和本体技术的不断发展,这种架构模式将更加完善,成为企业知识管理的核心方式,让知识真正成为企业发展的核心竞争力。

    【关联阅读】

      跳转微信打开

      轻量级企业本体标准浅析

      2026年11月1日 20:26

      半吊子全栈工匠 2026-11-01 20:26 北京

      本体的回归,本质上不是知识表示这门学问翻红了,而是它的成本结构被改变了。LLM 把建模的前期投入打下来,ODPV 和 ODPG 这类标准又把“语义层该怎么建”从各家私有方案变成了可对齐的公共规范。Agent 则把“显式语义”从“最好有”变成了“必须有”......

      【引】模型会说话,但它没有一份稳定的世界模型。企业真正缺的,往往不是更强的模型,而是一层能说清“这里有哪些东西、它们怎么连、谁能对它们做什么”的语义底座。这两年,这层底座正在被标准化。本文是对《本体驱动的AI大模型:方法与实践》一书的解读与补充。

      “本体”回归不是怀旧,是多重信号叠加的结果。 Palantir 把 Ontology 放在 AIP 架构的心脏位置;Microsoft 在 Fabric IQ 里上线了 Ontology 预览;Yahoo 用带类型的图本体支撑它的 Seller Agent。与此同时,Open Data Products 阵营给出了 ODPV 和 ODPG 这一对标准,把“语义词汇表”和“图结构规范”拆成两个可以独立采纳的部分,这是本体第一次以“标准”的形态出现在企业数据架构里。

      本体和知识图谱不是一回事,这个区分决定架构成败。 本体定义一个领域的语言:有哪些概念、允许哪些关系。知识图谱用这套语言记录事实:哪个产品归谁管、哪个 API 暴露了哪份数据。ODPV 是字典,ODPG 是建筑蓝图,企业知识图谱是用你自己的资产盖起来的大厦。把三者混为一谈,是这类项目最常见的死因。

      Agent 把本体从“最好有”变成了“必须有”。 聊天机器人答错一句“这单大概是去年建的”,最多是个错误答案;Agent 调错一次 cancel_order() 或者 transfer_money(),是事故。显式语义、动作契约、治理闸门,是当前唯一讲得通的兜底方案。而 LLM 降低的恰恰是建本体的起草成本,进入成本变了,这门老学问才有了第二春。


      为什么“本体”这个词又回来了

      本体(Ontology)在 AI 和知识表示领域已经存在几十年,碰过知识图谱的人几乎都遇见过它。但它长期处在尴尬位置:理论漂亮,落地太贵,大多数企业宁可堆文档也不愿意养一个本体团队。

      最近一年,情况变了——

      Palantir 把 Ontology 描述成自家 AIP 架构的心脏,称它是企业决策的统一表示,把数据、逻辑、动作和安全整合在一起。它建模的是运营流程里的“名词”和“动词”,而且建模成人和 Agent 都能读懂的形式。

      Microsoft 在 Fabric IQ 里引入了 Ontology 条目(预览阶段),官方定义是“一套共享的、机器可理解的业务词汇表”,定位是跨团队、跨 Agent、跨工作流共享的业务模型,供 Fabric 里的 Agent 和实时智能组件消费。

      Google Cloud 在 2026 年 6 月的案例研究里,讲了 Yahoo 的 Seller Agent 怎么用知识图谱本体建模广告产品、库存、合同和治理控制,并且与 IAB AdCOM 这类行业标准做了对齐。Yahoo 还单独建了一套决策轨迹本体(decision-trace ontology),记录 Agent 的每次决策与结果,供审计回溯。

      Yahoo 这张本体图值得多看一眼。它把广告业务拆成几个子域:Demand(需求侧的 MediaBuy、Package)、Supply(供给侧的 AdProduct)、Pricing(Pricing Model、RateCard)、Targeting(人群、地域、品牌安全)、Measurement(曝光、转化)、Governance(政策与约束)。Package 这个中心节点把各方串起来:CONTAINS 广告产品、TARGETS 定向、HAS_PRICING_MODEL 定价模式、GOVERNED_BY 治理策略。整张图就是一个广告生意的运行模型,Agent 在上面找路径、做决策,每一步都有据可查。

      这些例子说明,本体正在被明确地放进企业 AI 和数据平台的内部。但要注意一个区分:这些平台说的 ontology,比经典 OWL 本体工程那个意思要宽,而且各自带着产品化的视角。 Palantir 的 Ontology 是横跨数据、逻辑、动作和安全的运营平台层;Fabric IQ 把本体呈现成受治理的业务模型和上下文层;Yahoo 是在具体 Agent 架构里用了带类型(typed)的图本体。

      而 Open Data Products 阵营走的是另一条路:不做一个产品,而是做标准。ODPV(Open Data Product Vocabulary)管含义,ODPG(Open Data Product Graph)管结构。

      讨论的前提是概念澄清,我们需要先把最容易被糊弄过去的概念区分讲清楚。


      一、本体、知识图谱与GraphRAG

      这三个词在聊天里经常互换着用,但它们解决的是三个不同的问题。

      本体定义的是一个领域的语言,在计算机科学里被定义为“对一个共享概念化的形式化、显式规范”。也就是,一套机器可解释的词汇表,包含概念、关系,还有一整套公理,规定这些概念该怎么被解释。它回答的是“什么是数据产品?”“‘支持’意味着什么?”“策略可以治理数据产品吗?”这类问题。W3C 在 2004 年把 OWL 发布为推荐标准,2009 年出了 OWL 2,OWL 系列至今仍是语义网技术栈里核心的本体语言。

      知识图谱记录的是实际的企业知识。 它不描述“数据产品”这个概念,而是表示 Customer360、Sales Analytics 这样的具体实例。它不定义抽象的“业务目标”,而是记录“降低客户流失率”这样的真实目标。关系在这里变成真实业务资产之间的显式连接。

      一个定义语义,一个表示现实。如果本体是一本字典来定义词语的含义和语法规则,那知识图谱就是一本用这些词语写出来的百科全书。可以有一本完美的字典,但没有百科全书,你仍然答不了“谁是谁的朋友”;反过来,百科全书如果每种语言各写一版,也可能没法被一致地理解。

      放到具体例子上,区分更直观:

      层次

      例子

      说明

      本体 / schema

      Customer → places → Order;Customer → locatedIn → Location

      抽象的类与关系,规定“可以有什么”

      知识图谱

      Florian → places → Order_91827;Florian → locatedIn → London

      具体的实例与连接,记录“实际有什么”

      GraphRAG 是第三样东西,经常被误当成“上了本体”。 它用 LLM 从文本里抽实体和关系建图,再用图来组织检索。它给了你一张图,但不保证这张图的语义稳定,下次抽取,同样的文档可能抽出不一样的实体。

      三者的分工如下表所示:

      概念

      一句话定义

      在系统里的位置

      本体(Ontology)

      共享概念化的形式化显式规范

      提供类、关系、公理,即“语义”

      知识图谱(KG)

      记录实体与关系的数据结构

      装实例,常以本体为 schema

      GraphRAG

      用图组织文本、支撑检索与摘要

      给 LLM 一张图,但不保证语义

      动作契约

      定义动作的前置条件、效果、权限、审计

      给 Agent 划边界


      二、ODPV来统一“说话的语言”

      企业里最常见的问题,不是没数据,是同一个词在各系统里含义不一样。“数据产品”在数据目录里是一种登记条目,在治理平台里是另一份文档里的概念,在组织架构表里又是一个团队名。人可以靠脑补把这些对上,AI 不行。

      ODPV(Open Data Product Vocabulary)干的就是把这个对齐工作标准化。它为 Open Data Products 生态系统提供一份共享的语义词汇表,标准化两类东西。

      第一类是核心概念,例如Data Product(数据产品)、Business Objective(业务目标)、Use Case(用例)、KPI(关键绩效指标)、API、Policy(策略)、Contract(合约)、Owner(所有者)、Stakeholder(利益相关者)、Risk(风险)。这十个词覆盖了数据生态里最基本的“名词”。

      第二类是关系语义,supports(支持)、contributesTo(贡献于)、governedBy(被……治理)、measuredBy(被……衡量)、ownedBy(被……拥有)、dependsOn(依赖于)。这些“动词”规定了概念之间允许什么样的连接。

      还有一个容易被忽略的设计点,ODPV 刻意采用了轻量级词汇表方案,没有引入带复杂推理需求的重型本体。 这是一个关键的架构决策,值得展开对比:

      维度

      传统重型本体(如 OWL)

      ODPV 轻量级词汇表

      上手门槛

      需要专业本体工程师

      开发者可以快速上手

      工具链

      需要专门的推理引擎

      现有工具可渐进式采纳

      建模周期

      漫长,一次到位

      按需扩展词汇表

      语义严格度

      高,支持公理推理

      够用即可,不追求全量形式化

      适合场景

      强推理、强合规的窄领域

      企业级数据生态的通用对齐

      这个取舍背后的判断是企业最不缺推理能力,而是一致性。先把“数据产品”这个词在所有系统里指同一个东西这件事做成,比建一套没人维护得起的公理体系有价值得多。


      三、ODPG是知识图谱的建筑蓝图

      如果 ODPV 定义含义,那 ODPG 定义结构。ODPG(Open Data Product Graph)规定了企业知识应该如何表示为图,它的标准化模型包含六个组成部分:

      1. 图元数据(Metadata)

        描述整个知识图谱的版本、创建时间、维护者等顶层信息,确保图本身可追溯、可治理。

      2. 节点(Nodes)

        图中的实体,每一个数据产品、业务目标、API、策略、所有者都是一个节点。节点有类型(由 ODPV 词汇表定义)和唯一标识。

      3. 关系(Relationships)

        节点之间的有向连接,带语义标签(如 supports、governedBy)。关系是知识图谱区别于普通文档库的核心——它让隐含的连接变为显式。

      4. 引用(References)

        指向外部系统的链接——一个数据产品节点可以引用代码仓库里的实现、数据目录里的注册条目、API 网关里的端点定义。引用让知识图谱成为连接现有企业资产的枢纽,而不是又一个信息孤岛。

      5. 属性(Properties)

        节点和关系的附加信息——数据产品的版本号、API 的调用频率、策略的生效日期。属性让图不仅可遍历,还可查询、可过滤。

      6. 验证规则(Validation)

        确保结构完整性——例如一个数据产品必须有至少一个所有者,一个业务目标必须至少被一个 KPI 衡量。验证规则让知识图谱保持质量,而非随时间腐化。

      这里有一个必须划清的界限:ODPG 本身不是一个知识图谱,它是用于构建知识图谱的规范。 ODPG 是建筑蓝图,它告诉你一栋知识图谱应该有哪些结构元素、如何连接、如何验证。但蓝图不是建筑。每个组织根据蓝图,用自己独特的业务资产(自己的数据产品、API、策略、所有者、合约、质量指标)实例化出属于自己的那张图。

      例如,ODPV 说“数据产品”这个词是什么意思、“支持”是什么意思;ODPG 说图里该有节点、边、属性和校验规则,节点怎么编号、关系怎么标注;而企业知识图谱里躺着的是“Customer360 由 Jane Smith 拥有、通过 Customer API 暴露、受 GDPR 策略治理、支持个性化推荐用例、被转化率 KPI 衡量”这些真东西。

      两者结合,在一套企业架构里的位置是这样的:

      ┌─────────────────────────────────────────────────────┐
      │  AI Agents                                          │
      │  在连接的知识上推理,自动化分析和决策支持                   │
      ├─────────────────────────────────────────────────────┤
      │  GraphRAG                                           │
      │  检索连接的知识,而非孤立文档                            │
      ├─────────────────────────────────────────────────────┤
      │  Enterprise Knowledge Graph                         │
      │  连接真实企业资产——数据产品、API、策略、所有者             │
      ├─────────────────────────────────────────────────────┤
      │  ODPG (Open Data Product Graph)                     │
      │  提供标准化的图结构模型                                 │
      ├─────────────────────────────────────────────────────┤
      │  ODPV (Open Data Product Vocabulary)                │
      │  建立语义一致性——共享的词汇表                            │
      └─────────────────────────────────────────────────────┘

      这是一个自底向上的分层架构:底层标准化含义和结构,中间层实例化为真实知识,上层消费知识进行推理。每一层都可以独立演进,但只有组合在一起,才构成所谓的“AI 就绪企业架构”。


      四、从“资产清单”到“连接的知识”

      ODPV 和 ODPG 服务的是一个更大的转型:让企业知识从“清单”变成“网络”。

      大多数组织在元数据目录、治理平台、API 网关、数据目录和文档仓库上投了很多钱,但这些资产是割裂的。业务目标存一个系统,数据产品存另一个,API 在别处,治理策略又是一个仓库,所有权信息躺在电子表格里。元数据目录能告诉你:你有 200 个数据产品、50 个 API、30 条治理策略。但它是一张张孤立的登记条目——有名字、有类型、有所有者、有更新时间,就是没有关系。

      考虑一个具体的业务问题:

      “哪些数据产品支持我们的欺诈检测?谁拥有它们?哪些 API 暴露了它们?适用哪些治理策略?成功如何衡量?”

      在目录模式下,回答这个问题要跑五个系统:数据目录找产品,治理平台找策略,API 网关找端点,组织架构图找所有者,BI 工具找 KPI,最后人工把结果拼起来。

      在企业知识图谱里,这些关系已经存在:

      业务目标 → 用例 → 数据产品 → API → 策略 → 所有者 → KPI

      与其从文档里推断关系,AI 直接遍历显式连接。查询时间从小时级降到秒级,答案的完整性有保障(不会遗漏某个系统里的信息),每条关系路径都是显式的、可审计的,新问题不需要重新集成,换一条遍历路径就行。

      不同的层级回答不同层次的问题。元数据目录回答“我们有什么”来盘点资产,知识图谱回答“一切是如何连接的”来揭示关系,AI Agent 最终问“我们接下来该做什么”。比如“鉴于策略 C 即将变更,哪些数据产品会受影响?需要通知哪些所有者?哪些业务目标存在风险?”第三层问题,只有在前两层的基础上才答得出来。


      五、检索的进化

      有了图,怎么喂给模型?这就要说到检索架构的代际变化。

      第一代企业 LLM 系统基本都长这样:文档 → 切块(chunking)→ 向量化(embedding)→ 向量库 → 检索增强生成。这套架构能跑,但它的内核只回答了一个问题:“哪些段落可能和这个问题相关?”

      用户提问 → 向量检索文档片段 → 拼接为上下文 → LLM 生成答案

      问题在于,检索到的是孤立的文档段落,模型必须自己推断它们之间的关系。文档 A 提到“欺诈检测数据产品”,文档 B 提到“数据产品 X 的所有者是张三”,模型需要自己推理出“张三拥有支持欺诈检测的数据产品 X”——而这个推理可能因为文档 B 没被检索到而失败。它没有显式地捕获企业对象的身份、关系、约束和生命周期规则。它能告诉你“合同里写了这条条款”,但答不了“这份合同的付款条款约束的是哪张发票、这张发票现在处于什么状态、能不能被修改”。

      GraphRAG 换了一种检索对象:

      用户提问 → 图遍历检索连接的实体和关系 → 结构化上下文 → LLM 生成答案

      GraphRAG 不检索孤立文档,而是检索连接的实体及其关系,语言模型收到的是结构化上下文。一个 AI 治理 Agent 需要理解的“哪些策略治理哪些数据产品、谁拥有这些产品、哪些合约适用”,知识图谱天然提供,不需要模型去猜。

      但是,GraphRAG 不等于本体。GraphRAG 给 LLM 一张“图”,本体给这张图稳定的“语义”。

      维度

      GraphRAG 给的

      本体给的

      结构

      实体与关系的网络

      类、关系、公理组成的 schema

      稳定性

      每次抽取可能不同

      定义稳定,可版本化

      可推理

      靠图遍历与摘要

      支持基于公理的推理

      治理

      弱

      强,约束与权限可挂上去

      适合

      探索性问答、全局摘要

      需要一致性和审计的业务流程

      以 Microsoft GraphRAG 的默认索引流程为例:它用 LLM 从文本里抽取实体和关系,构建一张图,用 Leiden 算法检测层级社区,再生成社区摘要。声明(claim)抽取是可选项,默认关闭。整个过程不要求事先定义一套严格的 OWL 本体——这意味着图结构是每次抽取临时产生的,语义没有版本化,也没有公理约束。

      学术界也在往这个方向走。EMNLP 2025 的 OG-RAG 把文档映射成“本体锚定的事实块”和超边(hyperedges),再用这个结构引导紧凑的上下文检索;ACL 2025 的 ORT 和后续的 OntGQA 用本体层面的类型图去引导知识图谱上的多跳问答。这些工作里的 ontology 主要指知识图谱的类型层或 schema 层,不一定是完整的 OWL 本体。

      三类做法放在一起看:

      做法

      核心动作

      显式语义在哪

      主要短板

      经典向量 RAG

      切块、嵌入、相似度检索

      没有,全隐含在向量里

      不懂对象身份与关系

      本体引导的检索(OG-RAG 等)

      把文档映射到本体锚定的事实块与超边

      在本体的类、关系、约束里

      依赖本体质量与覆盖度

      GraphRAG

      抽实体关系建图,社区检测生成摘要

      在图结构与社区报告里

      不保证语义稳定,无公理


      六、Agent成为本体真正的催化剂

      真正把本体推回台前的,其实是“写”:Agent 开始动手改数据了。

      三种形态放在一起看,差别一目了然:

      聊天机器人错一步的代价是一个错误答案:“这个订单大概是去年建的。”用户重问一次就完了。

      但 Agent 要是做错一步,这事的性质就完全变了。它需要的不再是“相关信息”,而是一整套运营语义:

      1. 存在哪些对象?

      2. 每个对象处于什么状态?

      3. 这些对象之间是什么关系?

      4. 允许执行哪些动作?

      5. 谁有权执行这些动作?

      6. 这些动作受什么约束?

      7. 动作执行之后会发生什么?

      这已经很接近一个经典的 AI 构想了:世界模型 + 动作模型。模型来自训练语料,而语料里对同一个词的用法本来就互相矛盾——A 公司的 Account 是客户账户,B 公司的是银行账户,模型混在一起,输出看起来通顺,语义上是错的,而且错得很自信。词义消歧、基数约束、依赖方向、状态可达性、权限边界,这些都不能靠模型的语感来回答,只能变成可以查询的事实。

      Palantir 的 Ontology 和 Agent 工作流契合得好,原因之一就在这里:它不只建模对象和链接,还把动作建模成一等的运营原语。配上本体绑定和范围化权限(scoped permissions),Agent 可以查询本体对象,并调用那些预先定义好的动作,对数据做受治理的变更。

      把这件事抽象成架构语言,就是从“开放式输出”到“受控操作”:

        开放式输出                          受控操作
        ────────────                       ──────────
        LLM ──► 文本 / 动作意图             LLM ──► 动作请求
                                                  │
                                          ┌───────▼────────┐
                                          │ 语义层:对象、状态、关系 │
                                          │ 治理层:权限、约束、审计 │
                                          └───────┬────────┘
                                                  │
                                           允许 → 执行并留痕
                                           拒绝 → 返回原因

      回到 ODPV/ODPG ,这就是 Agent 遍历知识图谱的完整闭环:Agent 理解用户意图(“哪些客户最可能响应夏季促销,同时符合 GDPR 合规?”)→ 在图上找入口实体 → 沿着关系边遍历(Goal → Customer → Data Product → Campaign → KPI → Policy)→ 综合多条路径的信息 → 生成答案或触发动作。语义模型(ODPV)保证每条边含义一致,图规范(ODPG)保证结构可校验,Agent 的每一步推理都落在显式的关系上,可解释、可审计。


      七、LLM 降成本,人守公理

      一个自然的问题是:道理都懂,但建本体太贵,企业养得起吗?

      这才是本轮本体复兴最实质的变化。过去建本体最大的问题很朴素:太贵。要一个本体工程师加一个领域专家,走完“识别概念 → 定义类 → 定层级 → 定关系 → 定约束 → 对齐 → 验证 → 维护”这一整条流水线,几乎全靠人力。领域专家懂业务但不懂 OWL 语法,工程师懂语法但不懂业务,两边来回翻译,沟通成本比技术成本还高。

      LLM 现在能接手其中相当一段:概念抽取、实体与关系抽取、schema 起草、初版 OWL 表示的生成。左半边是“LLM 降低起草负担”——从需求文档、能力问题(competency questions)、用户故事出发,模型产出候选概念、关系和 OWL 草稿;“LLM 单独不保证语义稳定”——Account 到底是银行账户还是客户账户?Customer 和 Account 是 1:N 还是 N:N?已取消的订单还能创建发货单吗?这些问题必须显式定义,不能靠猜。本体工程师的校验、对齐、精化不但不能省,反而是整个流程的质量闸门。

      研究进展也支持这个判断,但同样划出了边界。ESWC 2025 有一项研究提出了一个基准,包含 10 套本体、100 个能力问题、29 个用户故事。另一项针对三门课程本体的增量实验里,o1-preview 配合 Ontogenia 建模出的问题数量超过了新手学生的提交,但仍然产出了错误的公理和冗余元素,错误率和输出波动依然是真实存在的问题。还有研究在六个领域上测试了 DeepSeek 和 o1-preview 的自动领域本体生成,显示了一定的跨领域泛化。

      结论可以概括成一句话:能用,但还不能全信。 生成的初稿能省掉大量机械劳动,公理层面的正确性仍然需要人来把关。

      大量机械劳动,公理层面的正确性仍然需要人来把关。

              ┌──────────────────────┐
              │   LLM 加速起草        │
              │  概念抽取             │
              │  实体关系抽取          │
              │  schema 草案         │
              │  初版 OWL 生成        │
              └──────────┬───────────┘
                         │ 产出候选本体
                         ▼
              ┌──────────────────────┐
              │  人工校验 + 对齐       │  ← 关键:不能省
              └──────────┬───────────┘
                         │ 沉淀为正式本体
                         ▼
              ┌──────────────────────┐
              │  本体反哺系统          │
              │  有据可依的检索         │
              │  结果校验              │
              │  受治理的 Agent 动作   │
              └──────────────────────┘

      分环节看成本结构的变化:

      环节

      引入 LLM 前

      引入 LLM 后

      人的角色

      概念识别

      专家访谈、人工梳理

      LLM 从文档抽取候选

      判定哪些是核心概念

      类与层级

      手工画

      LLM 给草案

      修正错误层级

      关系与约束

      逐条写

      LLM 生成候选公理

      校验语义正确性

      OWL 表示

      本体工程师手写

      自动生成初版

      处理生成错误与冗余

      对齐与验证

      人工比对标准

      部分辅助

      仍是主要责任方

      维护

      长期人力投入

      增量更新可辅助

      版本与迁移决策

      过去本体价值高但建模太贵,难以规模化。现在 LLM 降低了初版起草的负担,产出的本体又能接进检索、校验和策略机制,给模型输出提供依据、给 Agent 动作设闸门。不是本体变了,是进入成本变了。


      八、什么时候上、怎么上

      落回工程,三张表,分别是判断、设计和避坑。

      先判断该不该上

      你的现状

      建议

      理由

      只做问答,输出给人看

      先不用

      向量 RAG 加人工复核够用

      Agent 会写数据、调外部接口

      该上

      动作需要边界和审计

      同一个词在不同部门含义不同

      该上

      需要共享词汇消除歧义

      有强合规、审计要求

      该上

      决策必须可追溯

      数据结构简单、字段稳定

      可缓

      直接写 schema 校验更省事

      领域本身还在剧烈变化

      先小

      本体维护成本会吞掉收益

      动作契约怎么写

      Agent 时代的本体,光有类和关系不够,关键是把“动作”也定义清楚。一份最小可用的动作契约大概长这样:

      action: cancel_order
      applies_to: Order
      preconditions:
        - Order.status in [created, confirmed]
        - Order.shipment is null
        - now < Order.cancellable_until
      effects:
        - Order.status = cancelled
        - emit event OrderCancelled
      permissions:
        allowed_roles: [customer_service, order_admin]
        require_approval_when:
          - Order.amount > 10000
      audit:
        record: [actor, timestamp, reason, before_state, after_state]

      这段东西的价值在于:它把模型从“决定做什么”里的一部分责任拿走了。 模型只需要提出意图,能不能做、做完什么样,由这层契约判定。这是让 Agent 可控的最直接办法,对应治理闸门。允许的执行并留痕,拒绝的返回原因,需要审批的转人工。

      常见的坑

      错误做法

      直接后果

      修正方向

      一次性建全量本体

      永远建不完,项目死在中途

      从 3 到 5 个核心场景切入

      让 LLM 直接产出终版 OWL

      错误公理与冗余元素混入

      LLM 出草案,人做公理校验

      本体与真实数据脱钩

      定义漂亮但查不到实例

      本体必须绑定实体解析(entity resolution)

      只做静态建模

      状态与现实不同步

      接入实时数据与事件流

      没有版本与迁移

      改一处,全线崩

      本体版本化,动作契约跟着版本走

      很多人把“用了图”当成“用了本体”。Neo4j 里存了一张属性图,不等于你有了一套受治理的语义层。判断标准很简单,换一个人来看图,或者换一个 Agent 来读图,对“这个节点是什么、这条边意味着什么”的理解是否唯一。唯一,才叫本体;不唯一,只是图。


      小结

      过去两年 AI 基础设施的演进,大致是一条线:提示词设计 → 检索接地 → 会用工具的 Agent → 更宽的上下文工程 → 重新关注结构化语义模型。每一步都在补上一步留下的缺口:Prompt 解决“听懂任务”但不知道企业事实;RAG 把文档喂进去但不懂对象关系;Agent 能动手了但动作没有边界;上下文工程管好了窗口但语义仍不稳定。于是球到了本体脚下。

      本体的回归,本质上不是知识表示这门学问翻红了,而是它的成本结构被改变了。LLM 把建模的前期投入打下来,ODPV 和 ODPG 这类标准又把“语义层该怎么建”从各家私有方案变成了可对齐的公共规范。Agent 则把“显式语义”从“最好有”变成了“必须有”。

      如果现在正在做企业 Agent,可以先问自己一个问题:当模型想要执行一个动作时,你的系统能不能在它动手之前,明确回答“这个对象现在能不能被这样改、谁有权改、改完会怎样”?

      能回答,说明你已经有一层本体了,不管你有没有管它叫本体。不能回答,那大概率也不是换个更强的模型能解决的。

      【关联阅读】

      跳转微信打开

      制造业 AI 落地回眸

      2026年10月27日 20:26

      原创 半吊子全栈工匠 2026-10-27 20:26 北京

      工厂里的 AI 不是"上一个模型",是"把每一台设备的每一秒,变成能被人和模型同时读懂的一行记录"。这件事很土,很慢,也没有发布会......

      【引】对于制造业的AI赋能而言,决定 AI 项目成败的,通常不是选了哪个模型,而是车间里那台 2012 年机床的时间戳跟 MES 对不对得上。本文是对《本体驱动的AI大模型:方法与实践》一书的案例扩展解读,也是一些制造业AI落地项目的一些实践笔记。

      在制造业的设计、生产、质量、供应链、售后和可持续这六个环节中,AI项目落地的真正前置条件只有一个:把设备数据做成"带上下文、能对齐时间"的资产。缺了这一步,任何场景换个厂区就会失效,而且失效得很安静——不是报错,是模型精度悄悄掉下去。

      最快见效的通常不是生成式 AI,而是三类"老机器学习":设备异常检测、视觉质检、能耗分析。它们指标清楚、数据现成、投入产出比能在一个季度内算出来。

      生成式 AI 目前在制造业最扎实的落点是排障和知识传承:把老师傅的经验变成带出处的回答,把小时级的排查压到分钟级。这条路对模型能力要求不高,但对数据质量要求极高。

      一、工业数据可能只有四个动词

      工业数据的处理拆成四个动词:摄取、存储、情境化、利用,这个拆法很工程化。

      环节

      要解决的问题

      工程上真正交付的东西

      摄取

      批量数据、流式数据、间歇性数据怎么统一进来

      一份点位清单,标明采样频率、协议、时区、谁负责

      存储

      源数据变化时,关系还能保持住

      原始层不动、加工层可重算的分层存储,而不是一个大表

      情境化

      筛选、过滤、插值、时间维度对齐

      数据字典:资产层级、工单号、班次、产品型号如何挂到每一行上

      利用

      让用数据的人拿到自己要的格式

      面向具体角色的数据产品,比如给工艺工程师的窗口视图

      这里最容易被跳过的是第三个。很多团队把"数据上云"当成目标,把 CSV 灌进对象存储就算完事,结果模型训练时才发现:这台机床的振动数据是毫秒级,那台的采集卡只给一秒一个点;这台用本地时间,那台用 UTC;换型时间只在班组长的纸质记录里。这些东西不补齐,后面所有分析都是沙上建塔。

      多数工厂是从单个场景切入的,比如选一个厂做预测性维护试点,验证成功后想推广到其他厂。但各厂的数据结构不同、标准不同,用的工具也不同,所以哪怕要解决的是完全一样的问题,第一个场景里有效的方案,到第二个场景就不见得有效。这不是技术问题,是资产建模没有统一。

      情境化听着抽象,落到代码上其实就是几十行。下面这段把一个产线三路数据对齐到同一张表上,注释里写了几个必须做判断的地方:

      import pandas as pd
      # 三路数据:设备秒级遥测、MES 工单事件、质量抽检结果
      telemetry = pd.read_parquet("plant-a/line-3/telemetry/")# ts, tag, value
      events    = pd.read_parquet("plant-a/line-3/mes/events/")# ts, wo_id, sku, state
      qc        = pd.read_parquet("plant-a/line-3/qc/")# ts, wo_id, defect_rate
      # 1) 统一时区,全部落到 UTC 秒。现场最常见的错误就是本地时间混 UTC
      for df in(telemetry, events, qc):
          df["ts"]= pd.to_datetime(df["ts"], utc=True).dt.floor("s")
      # 2) 以 1 秒网格重采样。前向填充只允许 3 秒,超过就置空
      #    原因:拿 10 分钟前的值填充,等于替设备编造了一段连续工况
      grid = pd.date_range(telemetry["ts"].min(), telemetry["ts"].max(), freq="1s")
      wide =(telemetry.pivot_table(index="ts", columns="tag", values="value")
      .reindex(grid).ffill(limit=3))
      # 3) 打上下文:资产层级 + 工单 + 班次,这才是"情境化"的实质
      wide = wide.reset_index().rename(columns={"index":"ts"})
      wide["asset"]="plant-a/line-3/filler-01"
      wide = pd.merge_asof(wide, events.sort_values("ts"), on="ts", direction="backward")
      wide["shift"]=(wide["ts"].dt.hour //8).map({0:"A",1:"B",2:"C"})
      # 4) 建模时分状态。开机、稳定运行、换型三种工况混在一起训练,模型必然学歪
      wide["run_state"]= wide["state"].fillna("unknown")

      这段代码没有任何高科技,但它决定了后面能不能做事。真正花时间的不是写代码,是搞清楚"filler-01 这个资产下面到底挂了几个传感器、它们的 tag 命名规则是什么、谁有权改"。

      给数据地基定验收门槛,比定技术栈有用得多:

      验收项

      及格线

      为什么

      时间对齐误差

      同一事件在三路数据里的时间差小于 1 秒

      超过 1 秒,故障前后的因果顺序就开始错乱

      资产覆盖率

      目标产线关键设备 100% 有点位清单

      缺一台设备,模型就会把它的停机算到别人头上

      历史回放能力

      任意 30 天窗口能重算出同样的结果

      不能回放就无法解释模型为什么报警

      缺失值策略

      每个点位标明"允许填充多久"

      无脑前向填充是精度虚高的主要来源

      口径一致性

      同一指标在两个厂的定义完全一致

      否则跨厂对比全是噪声

      二、设计端把试错成本从"开模具"降到"跑一次作业"

      工程设计是最早被云改变的一环,因为它天生就是计算密集的。例如,把仿真从本地工作站搬到云端 HPC,把设计协作从共享盘搬到云工作站,把 PLM 从机房搬到云上。

      场景

      做法

      公开案例数字

      衍生式设计

      工程师只定义约束,算法生成上千个候选结构

      某自行车零部件企业曲柄减重 20%、强度翻倍,骑手模拟从数小时降到几分钟

      大规模仿真

      云端弹性扩容,跑批量参数扫描

      某卫星推进企业模拟时间从 8 小时降到 1 小时

      芯片验证

      用变异感知方法替代暴力蒙特卡洛

      验证速度提升 1000 倍,迁到基于 ARM 架构的云服务器后成本降 24%

      PLM 上云

      15 个以上工程应用整合到一个闭环

      产品配置到交付 28 天降到 8 天,成本降 40%

      设计协同

      虚拟工作站串流,图纸不出云端

      某电动车企业设计速度提升 66%,整车 BOM 加载 22 分钟

      这些数字背后有一条共同逻辑:设计阶段的迭代成本,从"物理世界的一次试错"变成了"计算资源的一次调度"。以前改一版曲柄要开模、试制、上车测;现在先跑几百次拓扑优化,把明显不行的方案在仿真阶段就淘汰掉。

      但这里有个容易忽略的工程细节:收益不在"算得快",在"排队短"。本地 HPC 集群的利用率往往只有三四成,忙的时候排队三天,闲的时候机器空转。云端弹性解决的是排队问题,所以衡量这件事的指标应该是"仿真作业平均等待时间",而不是"单次仿真耗时"。前者从三天降到两小时,工程师的工作方式才会真的变——他敢一天试五个想法了。

      三、车间端最快见效的三条线

      生产现场的用例很多,但按"数据现成度"和"指标清晰度"排,只有三条线适合作为第一批。

      线

      典型数据源

      该盯的指标

      案例数字

      先决条件

      设备可用性

      振动、电流、温度、停机记录

      计划外停机小时数、MTBF、MTTR

      某医疗设备企业避免 500 小时以上计划外停机

      有至少半年的历史停机记录

      质量

      产线相机、抽检结果、工艺参数

      漏检率、误判率、一次合格率

      某药企用合成图像训练缺陷检测,误判率降 50% 以上

      缺陷样本能被标注,哪怕很少

      能耗

      电表、气表、水表、蒸汽流量

      单位产品能耗、WAGES 分项占比

      某饮料企业两个工艺系统年省 20% 能源、9% 用水

      计量点位细化到主要设备

      这是最容易被过度承诺的场景。某农业与能源企业原本跑的是冗长的定期维护流程,后来用振动监测和异常检测,比任何其他监控手段早若干小时发现了一台压缩机的问题,也提前发现了风扇可能失效的迹象。注意措辞——是"早若干小时",不是"提前三周"。

      真正的预测性维护需要带标签的故障历史:什么时候坏的、坏的是什么件、坏之前的工况是什么。多数工厂拿不出这个。拿不出就先做异常检测:用无监督方法学出"正常工况长什么样",偏离就报警,由人判断。这条路能拿到大部分收益,而且不需要标签。例如,某商用制冷企业用设备联网数据加预测模型,把维护需求预测准确率做到 80% 以上,从而减少了全球客户的制冷停机时间。80% 这个数字的意义不在精度本身,而在于它足以支撑排班——技术人员可以按预测结果提前安排路线,而不是等客户打电话。

      质检的模型结构早就成熟了,卡点一直在数据。某食品企业用边缘部署的视觉模型数产线上的产品数量,模型训练和重新部署的闭环建起来之后,收益才持续。某药企的做法更值得借鉴:真实缺陷样本太少,就用生成式方法合成图像来训练检测模型,最终各产品线误判率总体降低 50% 以上。

      合成数据解决的是长尾问题。一条产线一年可能只出几十个某种缺陷,但模型需要几百上千个样本才学得会。合成的时候要注意一点:合成样本的分布必须贴近真实相机、真实光照、真实工装,否则模型在产线上会"认得出假缺陷、认不出真缺陷"。

      能耗分析是投入最小、最容易说服管理层的一步。例如,用机器学习分析用电数据,发现有一台数控机床长期空转,仅这一项就把能耗降了 5%。这类"找闲置设备"的工作不需要复杂模型,需要的是分项计量。

      四、AI 真正开始干活的地方

      生成式 AI 的制造业场景分成三类:产品工程、生产、员工培训与生产力。这个分法可以用,但要加一列"成熟度",否则容易一起上、一起翻车。

      场景

      输入

      输出

      验收指标

      当前成熟度

      排障助手

      设备手册、历史工单、报警记录

      可能原因、检查步骤

      平均修复时间、上报率

      高,可规模化

      知识传承

      老师傅的维修记录、工艺参数调整日志

      带出处的问答、培训材料

      新员工独立上岗时间

      高,但依赖知识沉淀

      文档核对

      标签、图纸、BOM 文本

      差异清单

      漏检率、核对工时

      高,规则清晰

      设计生成

      约束条件、二维图、三维模型库

      候选三维结构

      概念阶段方案数量

      中,需人工筛选

      代码与报表

      业务数据、自然语言问题

      查询、图表、摘要

      报表交付时间

      中高,边界清楚

      直接控制设备

      实时时序

      控制指令

      不适用

      低,不建议现阶段做

      例如,某造纸企业给设备操作员配了生成式 AI 助手,用来提供故障排查指导、辅助熟悉复杂操作、定位问题根因。结果是检索故障排除指导的时间从数小时缩短到数分钟,向高级人员上报的次数明显减少。

      这个案例的价值在于它选了正确的任务:不是让模型控制设备,而是让模型帮人更快找到那一页手册。任务边界清楚,错了也不会出安全事故,但收益立刻可见。

      还有一个容易被低估的场景:某车企有二十多种车辆标签、涉及多语言、两千多个变体,人工核对极慢。用文档解析服务把标签文本抽出来跟系统数据比对,自动标出异常,接近零标签缺陷。这件事跟"大模型聪明不聪明"毫无关系,纯粹是把重复劳动交给机器。

      排障助手的技术形态基本都是检索增强生成。骨架不长,但有三个地方不能省:范围过滤、相关度阈值、出处引用。范围过滤防止把 A 型号的经验套到 B 型号上;阈值让系统在没把握时把人推给老师傅,而不是编一个像模像样的答案;引用让维修工能自己判断该不该信。少任何一个,这套东西在现场活不过两周。

      五、从设备到收入:联网产品的第二增长曲线

      设备联网之后,商业模型会变。原来是一次性卖硬件,卖完关系就淡了;现在可以卖可用性、卖耗材、卖预测性维护。几个不同行业的示例如下:

      案例

      做的事

      结果

      扫地机器人

      无服务器架构支撑 C 端应用与设备后端

      节假日流量激增 1900% 未出问题

      木屑颗粒烤架

      供应商平台下线,三个月完成迁移

      11.1 万台设备、70 万移动用户平移,18 个月设备量翻倍到 30 万台

      商用烤箱

      三款应用支持远程监控与程序下发

      服务层面客户要求满足率 95%

      商用制冷

      联网数据加预测模型排维护

      维护需求预测准确率 80% 以上

      冷链物流

      整合碎片化冷链数据,监控位置与温度

      减少食品变质,优化配送路线

      这些案例背后有个共同的坎,很少有人提前想到:设备身份管理。一台设备出厂、换固件、换通信模组、换 owner,它的身份记录必须能跟着变。等你有三十万台设备在线,再回头补这套东西,成本会高一个数量级。

      联网产品的价值不在"连上了",在"连上之后有人看数据并采取行动"。如果售后团队的组织方式还是"客户报修、我们上门",数据再多没用。

      六、可持续性的两本账

      可持续发展这件事容易写成口号,落到工程上是两本账:一本是工厂自己的能耗账(WAGES:水、空气、燃气、电力、蒸汽),一本是产品的碳足迹即从原料开采到最终销售的过程。

      层次

      具体动作

      案例数字

      工厂能耗

      分项计量加机器学习分析,找出低效设备

      某饮料企业两个工艺系统年省 20% 能源、9% 用水

      设备效率

      数字孪生模拟不同工况下的运行方式

      同上,用近实时资产监控优化生产流程

      泄漏与损耗

      数据湖加机器学习提升检测精度

      某水设备企业每天自动采集 5GB 以上数据,单客户五年预计省 800 万美元

      供应链碳

      统一平台汇集供应商数据,避免数据粉饰

      供应链占企业温室气体排放 90% 以上、运营成本 50%–70%

      产品碳足迹

      自动化精细排放跟踪

      需要物料清单、工艺路线、能源因子三者对齐

      有个判断标准很实用,这套碳数据能不能被审计。如果排放因子来自一张谁也说不清版本的 Excel,那优化就无从谈起,因为改一版工艺,账要重算一遍,永远算不完。先建"单一数据源 + 可追溯口径",再谈降碳。

      七、制造业AI落地的常见反模式

      起步四步法是对的:设定目标、确定具体场景、选模型、与专家携手。但它偏战略层,落到执行需要一张带交付物的时间表。

      然而,那些看似应该做却在落地困难的方式有哪些呢?这就是反模式。

      反模式

      直接后果

      更稳的做法

      先定模型,再找场景

      模型很强,但没有可验收的指标,项目无法结项

      先写清楚"哪条线、哪个指标、改善多少算成功"

      拿一个厂的试点直接复制

      数据结构、标准、工具都不同,复制即失效

      先统一资产模型与数据字典,再复制场景

      没有故障标签就承诺预测性维护

      模型学不到故障模式,最后退化成看门狗

      先做无监督异常检测加阈值告警,同时攒标签

      让大模型直接读秒级原始时序

      上下文烧光,幻觉严重,成本失控

      时序交给统计方法与专用模型,语言模型只处理文本与工单

      排障助手不给引用

      维修工试两次不信,然后弃用

      每条结论带工单号或手册页码,查不到就拒答

      碳数据靠人工汇总

      审计不过,改一版重算一遍

      建单一数据源,口径与因子版本化

      八、小结

      对于制造业的AI落地路径是先把数据变成资产,再让算法去用它。反过来做也能出成果,但成果会锁在第一个厂区里,出不来。

      如果只能记住一句话,那就是:工厂里的 AI 不是"上一个模型",是"把每一台设备的每一秒,变成能被人和模型同时读懂的一行记录"。这件事很土,很慢,也没有发布会。但它是唯一绕不过去的那一步。

      【关联阅读】


      跳转微信打开

      Agentic知识图谱浅析

      2026年10月25日 20:26

      原创 半吊子全栈工匠 2026-10-25 20:26 北京

      AI Agent不需要更长的提示词,它们需要结构化记忆、显式关系和能够真正使用的共享上下文。

      【引】AI Agent不需要更长的提示。它们需要结构化记忆、显式关系和能够真正使用的共享上下文。本文是对《本体驱动的AI大模型:方法与实践》一书的解读与补充。

      过去的很长一段时间,我们把AI Agent当作稍微聪明一点的聊天机器人。用户提问,模型回答,也许它调用一个工具、搜索文档、执行API请求,或从向量数据库检索几个文本块,然后返回响应。

      这对于建立在大型语言模型之上的第一代应用来说足够了。但当我们试图构建在真实公司中、跨真实流程、处理真实数据的Agent时,一个局限变得显而易见。

      一个AI Agent如果无法记忆、连接信息并基于关系推理,就无法真正有用。

      这或许就是Agentic 知识图谱(Agentic Knowledge Graphs)登场的地方。


      1. 什么是Agentic知识图谱?

      Agentic知识图谱是一种不仅用于存储信息,而且用于支持一个或多个AI Agent行为的知识图谱。传统知识图谱表示实体和关系。例如:

      • 一个产品

      • 一个客户

      • 一份文档

      • 一个支持工单

      • 一个供应商

      • 一个技术组件

      • 一项内部政策

      每个元素成为一个节点,每个连接成为一条关系。一个产品可以连接到供应商。一个工单可以连接到一个问题。一个问题可以连接到一个软件版本。一项政策可以连接到一个部门。

      到目前为止,这是传统知识图谱的世界。

      "Agentic"的部分出现在图不仅被用作数据结构,而是作为AI Agent的操作空间时。Agent可以使用图来:

      • 理解哪些信息相关

      • 回答前检索上下文

      • 存储新知识

      • 记住之前的交互

      • 验证概念之间的关系

      • 规划下一步

      • 与其他Agent协调

      换句话说,图成为了一种结构化记忆。它不再只是一个数据库,变成了Agent可以操作的世界地图。


      2.为什么本体/知识图谱重新重要了起来

      过去几年,企业AI应用的主导模式是RAG(检索增强生成),基本机制现在已为人熟知:

      公司文档、PDF、手册、网站、知识库、政策、工单、邮件、报告
          ↓
      切分为文本块
          ↓
      转化为嵌入向量
          ↓
      存入向量数据库
          ↓
      用户提问时 → 搜索语义最相似的文本块 → 传给语言模型

      这种方法使第一波企业AI成为可能:内部聊天机器人、文档助手、技术支持系统、语义搜索引擎以及知识库Copilot。

      但随着时间推移,一个问题变得清晰:语义相似不等于正确的上下文。

      两段文本可能听起来相似,但在业务领域毫不相关。或者最重要的信息可能在语言上与用户的问题完全不同——它可能通过一种关系连接。考虑一个简单例子。用户问:

      哪些组件可能导致产品X的故障?

      传统RAG系统可能检索提到"产品X"的文档。而基于知识图谱的系统可以做更多——它可以从产品X出发,探索其组件,移动到供应商,识别相似工单,比较之前的固件版本,连接客户评论,并检索相关技术文档。关键不在于找到相似文本,而在于遍历关系。这就是图变得至关重要的地方。


      3. 从RAG到GraphRAG

      GraphRAG是检索增强生成的演进。在传统RAG系统中,检索主要通过向量搜索进行。在GraphRAG系统中,向量搜索仍可作为入口点,但检索到的上下文会通过探索知识图谱来丰富:

      1. 用户提问

      2. 系统识别相关实体、概念或文档

      3. 将这些元素映射到知识图谱

      4. 通过显式关系遍历图

      5. 语言模型获得更丰富、更结构化、更可验证的上下文

      这个差异很重要。向量数据库擅长找到相似性,图擅长表示连接。当两者结合时,系统可以同时基于语义邻近和知识结构进行推理。

      GraphRAG之所以在企业AI中变得如此重要,不是因为它取代了传统RAG,而是因为它扩展了RAG。

      聊天机器人可以用上下文窗口生存。文档助手可以用RAG生存。但一个持续工作的AI Agent需要更多——它需要记忆、状态,需要知道之前发生了什么,需要将新信息与先前知识连接。

      Agent的记忆不能只是聊天消息的按时间排列列表。对话是线性的,但知识不是。知识由连接构成。

      用户今天可能谈论一个项目,明天谈论一个供应商,下周谈论一个技术问题,下个月谈论一个业务决策。这些元素可能全部相互连接,即使它们从未出现在同一次对话中。

      知识图谱允许这些连接被显式表示。Agent不仅存储"说了什么",还存储"事物如何连接"。这就是文本记忆和结构化语义记忆之间的区别。


      4. Agent记忆:超越聊天历史

      当人们谈论AI Agent的记忆时,通常想象非常简单的东西——用户说了名字,Agent记住它。这有用,但只是第一层。真正的Agent记忆应至少处理四种信息。

      1. 事实记忆

      对事实的记忆。例如:

      • 公司使用SAP

      • 项目叫Aurora

      • 客户属于零售行业

      • 产品X使用组件Y

      这些事实可以成为图中的节点和属性。

      2. 关系记忆

      对连接的记忆。例如:

      • 项目Aurora依赖数据团队

      • 组件Y由特定供应商提供

      • 零售客户报告了一个反复出现的问题

      • 一项内部政策仅适用于特定部门

      这是图比文本档案有用得多的地方。

      3. 过程记忆

      对事情如何完成的记忆。Agent可能学到某种请求需要它:

      检查数据源 → 验证政策 → 查询外部系统 → 生成摘要 → 请求用户确认

      这种知识可以表示为工作流、动作序列或操作图。

      4. 情景记忆

      对事件的记忆——发生了什么、何时发生、结果如何、做了什么决策、哪些信息被更正。在企业系统中,这种记忆可能是决定性的,因为它防止Agent每次从零开始。


      5.Agent知识图谱与多Agent编排

      最有趣的转变发生在不只有一个Agent,而是多个Agent协同工作时。

      • 一个Agent处理用户意图

      • 另一个分析结构化数据

      • 另一个从非结构化文本中提取实体

      • 另一个提出图模式

      • 另一个验证关系质量

      此时,问题不再只是回答一个问题,而是协调一个系统。

      知识图谱可以成为Agent之间的共享上下文。Agent不必来回传递大段文本,而是可以读取和更新一个共同结构。图成为共享工作空间:

      Agent A → 识别实体
      Agent B → 建议关系
      Agent C → 检查不一致性
      Agent D → 连接结构化和非结构化数据
      Agent E → 决定哪些信息已准备好用于检索

      这种架构更接近人类团队的运作方式——不是所有事都通过单一中央大脑,而是有角色、专业化、审查和共享记忆。


      6. 如何构建第一个Agentic知识图谱

      构建Agent图谱不意味着从大型基础设施项目开始。最常见的错误之一是假设你立刻需要Neo4j、向量数据库、复杂编排层、多个Agent和生产级GraphRAG流水线。实际上,第一步可以简单得多。

      从一个问题开始:

      Agent执行任务需要什么知识?

      不是"我们有什么数据",而是"Agent必须完成什么任务"。这改变了一切。有用的图不是公司数据库的优雅副本,而是做出更好决策所需信息的表示。

      第1步:定义Agent目标

      在提取节点和关系之前,定义用例。例如:

      • 复杂产品的技术支持

      • 合同分析

      • 企业文档搜索

      • 合规和政策协助

      • 供应商和组件监控

      • 个性化推荐

      • 客户支持知识库

      每个用例需要不同的图。技术支持Agent需要连接产品、组件、错误、工单、固件版本和解决方案。法律Agent需要连接条款、合同、法规、管辖区、风险和责任。HR Agent需要连接人员、角色、技能、流程、文档和请求。

      图从目标开始。

      第2步:识别主要实体

      目标明确后,识别核心实体。实体是图的节点。对于产品支持系统,可能包括:Product, Component, Supplier, Issue, Ticket, Review, Manual, FirmwareVersion, Resolution。

      你不需要在开始时建模所有东西。事实上你不应该。一个小而连贯的图比一个大而混乱的图有用得多。

      第3步:定义关系

      关系是最重要的部分。知识图谱的价值不在于节点数量,而在于连接质量。

      关系示例:

      Product  contains       ComponentComponent  supplied_by   SupplierTicket  reports          IssueReview  mentions         ProductIssue  resolved_by       ResolutionFirmwareVersion  affects ProductManual  documents        Component

      这些关系让Agent能够遍历领域。如果工单描述了一个错误,Agent可以移动到组件→从组件到供应商→从供应商发现其他受影响产品。这就是图将孤立信息转化为上下文的方式。

      第4步:连接结构化和非结构化数据

      大多数公司有两种知识。一边是结构化数据:CSV、数据库、CRM、ERP、产品表、供应商注册表。另一边是非结构化数据:PDF、评论、邮件、工单、手册、转录、报告。

      Agentic知识图谱在连接这两个世界时变得真正有用。一篇书面评论可能提到产品数据库中存在的产品。一个支持工单可能引用一个技术组件。一本手册可能描述适用于特定固件版本的流程。

      价值不仅在于从文本中提取信息,更在于将其链接到已知实体。

      第5步:使用专业化Agent

      这是Agent化部分变得实用的地方。不用一个模型做所有事,你可以创建专业化Agent:

      Agent 1 → 解读用户目标
      Agent 2 → 建议使用哪些文件
      Agent 3 → 分析结构化数据
      Agent 4 → 从文档中提取实体
      Agent 5 → 提出图模式
      Agent 6 → 验证关系
      Agent 7 → 构建或更新最终图

      这种方法更可控——每个Agent有明确职责,系统更容易调试,错误可以被隔离,需要时决策可由人工审查。


      7.实战案例:查找产品问题根因

      想象一家制造电子设备的公司。它有产品目录、组件清单、不同供应商、客户评论和支持工单。目标是构建一个AI Agent,帮助质量团队理解为什么某些产品收到负面报告。

      传统RAG系统可能搜索工单并检索与问题最相似的文档。Agentic知识图谱可以这样做:

      1. 识别提到的产品
      2. 检索连接的评论
      3. 提取反复出现的问题
      4. 将问题链接到产品组件
      5. 检查相同组件是否出现在其他产品中
      6. 验证这些组件是否来自同一供应商
      7. 生成假设:
         → 问题可能不是由最终产品本身引起的,
           而是由同一供应商提供的共享组件引起的

      这是简单语义搜索系统难以产生的推理。不是因为语言模型不够强大,而是因为没有显式关系,上下文仍然是碎片化的。


      8.JSON、图数据库还是完整GraphRAG?

      不是每个人都需要从企业级架构开始。在许多情况下,第一个知识图谱可以是简单的JSON结构。

      {
      "nodes":[
      {"id":"product-a","type":"Product","label":"Product A"},
      {"id":"battery-01","type":"Component","label":"Battery 01"},
      {"id":"issue-overheating","type":"Issue","label":"Overheating"}
      ],
      "edges":[
      {"source":"product-a","target":"battery-01","relation":"contains"},
      {"source":"product-a","target":"issue-overheating","relation":"reports"}
      ]
      }

      这种方法简单、便宜、快速,但随着图增长会受限。

      如果需要管理数百万节点、复杂查询、频繁更新和多用户 → 图数据库(如Neo4j)更合适

      如果目标是在大型文档集合上改进检索 → 可能需要混合架构:向量数据库 + 图数据库 + 实体提取流水线 + 验证Agent + LangGraph/ADK编排框架 + GraphRAG层

      规则很简单:不要选择最复杂的架构,选择与问题匹配的架构。


      9. Agentic知识图谱的应用

      相比仅基于提示、原始聊天记忆或经典RAG的系统,Agentic知识图谱提供多项优势:

      优势

      说明

      更优上下文质量

      模型不只收到相似文档,而是收到连接信息,在需要跨多源推理时显著提升答案质量

      更佳可解释性

      图可以被检查——查看使用了哪些节点、哪些关系导出了结论、连接是否正确。这对企业AI、合规、医疗、金融和受监管行业至关重要

      更稳健记忆

      图将事实、关系、事件和流程分离并连接,比纯文本存储更干净

      更好多Agent协调

      图成为共享状态,每个Agent读取所需并更新自己负责的部分,减少重复和不一致

      更强治理与审计

      图可追踪来源、关系、时间戳、作者、修订和置信度分数,使系统更容易治理

      Agentic知识图谱不是魔法,它们也带来真实挑战:

      • 提取质量:如果模型提取了错误实体或不准确关系,图会很快变得不可靠

      • 模式复杂性:太僵化的模式无法适应;太松散的模式变得混乱

      • 运营成本:构建、更新和验证图需要流水线、控制和维护

      • 过度工程:不是每个AI应用都需要GraphRAG。对于许多用例,设计良好的传统RAG系统更简单且足够好

      正确的问题不是"我们能不能用知识图谱?",而是"信息片段之间的关系对解决这个问题是否至关重要?"如果是,图可以带来真正改变。

      当以下至少一个条件为真时,Agentic知识图谱有意义:

      ✅ 数据来自多个不同来源

      ✅ 实体之间的关系很重要

      ✅ Agent必须随时间记住信息

      ✅ 需要可解释性和审计

      ✅ 多个Agent需要在共享上下文上协作

      ✅ 问题需要多跳推理

      ✅ 知识库随时间变化

      ✅ 仅靠文档不足以表示领域

      具体用例包括:高级技术支持助手、产品智能系统、供应链分析、合规和监管Agent、复杂企业文档的RAG系统、科研助手、内部知识管理、客户关怀自动化、业务流程多Agent系统。

      在这些场景中,图不是装饰层,它是系统的认知基础设施。

      现代Agentic知识图谱架构可分为多层:

      现代Agent不再像对语言模型的一次调用那样运作。它们通过循环运作:

      观察 → 检索信息 → 评估 → 更新上下文 → 重试 → 自我纠正 → 产出最终结果

      知识图谱使这些循环更强大。每次迭代后,Agent可以更新其对领域的理解:

      • 添加一个节点

      • 修正一个关系

      • 提高一个连接的置信度分数

      • 标记一个矛盾

      • 请求确认

      循环不再在虚空中运作,它在结构化记忆上运作。

      这是AI Agent演进中最重要的转变之一——不仅需要一个能推理的模型,还需要一个让推理能留下痕迹的环境。


      10.趋势还是自然演进?

      AI的每个新阶段都带来新术语——提示工程、RAG、Agentic AI、GraphRAG、多Agent系统。有时这些词感觉像炒作。但Agentic知识图谱背后有真实需求:

      • 语言模型很强大,但不天然拥有可靠的企业记忆

      • 向量数据库有用,但不表示显式关系

      • Agent工作流很有前景,但需要共享状态

      • 多Agent系统有趣,但没有共同记忆会变得混乱

      知识图谱恰好解决了这个问题——它提供结构、上下文、关系和Agent可以工作的基础层。

      这不像是一个转瞬即逝的趋势,更像是一次自然演进。

      如果这一方向持续,我们将看到一个越来越重要的专业角色的崛起:知识图谱/本体工程师。

      这个人将不仅是软件开发者、数据工程师或提示工程师。而是一个混合角色,结合:

      • 数据建模

      • 本体和分类法

      • 图数据库

      • RAG和GraphRAG

      • AI Agent

      • 多Agent编排

      • 检索评估

      • 知识治理

      • 对话式UX

      • 业务流程理解

      这份工作的核心是将分散的信息转化为可导航的知识,然后让AI Agent能够使用这些知识。这可能成为企业AI中最有价值的技能之一。


      小结

      Agentic知识图谱成为了生成式AI演进的重要一步。第一阶段由提示主导,第二阶段由RAG主导,第三阶段由Agent主导。现在我们正在进入一个Agent需要记忆、结构和协调的阶段。

      知识图谱恰好提供了这些。它们将文档、数据和对话转化为连接概念的网络。它们让Agent检索更好的上下文。它们让多Agent系统在共享记忆上协作。它们让公司构建更可解释、更可靠、更接近业务流程真实复杂性的AI应用。

      当然,它们并不总是必要的。对于许多用例,简单的RAG仍然是正确选择。但当信息片段之间的关系变得核心时,忽视图意味着让上下文的关键部分未被使用。

      AI Agent的未来可能不只由更大的模型定义,而是由记得更好的系统定义。而要记得更好,它们需要连接得更好。这就是Agentic知识图谱真正有趣的地方。

      【关联阅读】


      跳转微信打开

      微服务架构的复杂性思考:一份来自 1972 年的答案

      2026年10月22日 20:26

      原创 石涛声&曹洪伟 2026-10-22 20:26 北京

      我们用了二十多年年时间学会了怎么把系统拆小,却始终没学会该往哪里下刀。这篇文章想说明:刀口的位置,五十年前就有人写清楚了。

      【缘起】多年前,石头兄弟提出了一个问题“微服务的复杂性到底是什么”,我并没有答案,但答案允许迟到,但不会缺席。

      我们花了很长的时间学会了怎么把系统拆小,却始终没学会该往哪里下刀。这篇文章想说明:刀口的位置,五十年前就有人写清楚了。

      第一,复杂性不等于规模。一枚 5nm 芯片上有 153 亿个晶体管,人类可以设计、制造并控制它;一家公司的代码只有二十亿行,却会常年带着万分之二的崩溃率运转。差别不在数量级,而在部件之间有没有清晰的边界和有限的相互影响。

      第二,模块化之所以有效,不是工程习惯,而是可以被写成不等式的。把两个问题放在一起解决,其复杂度高于分别解决之和;由此推出工作量的不等式。但模块不能无限拆——集成成本随模块数量上升,总成本曲线是个 U 形,最优点在中间某处。

      第三,怎么找到那个"中间某处",帕纳斯在 1972 年给了准则。划分单位不是处理步骤,而是"困难的设计决策"和"容易变化的设计决策"。模块的职责是把这些决策藏起来。微服务把这条准则从函数级推到了进程级,收益和代价都被同比例放大了。


      引子:两个数字

      先看两组数字。

      2015 年,谷歌统计自家所有产品的代码,加起来约 20 亿行。2018 年,阿里巴巴的程序员一年写下 12 亿行代码。2020 年,华为的麒麟 9000 芯片,在 5nm 工艺上集成了 153 亿个晶体管。

      数量级是相近的,甚至芯片那边更多。

      但我们对这两样东西的掌控力,完全不在一个水平上。芯片从设计、流片到量产,有完整的验证链条,良品率是可以被预测和提升的;而一个日活千万级的 App,即便崩溃率已经做到业内优秀的万分之二,仍然会源源不断地冒出莫名其妙的 bug——无法复现,或者改完之后别处又坏了。

      同样是"亿"级的组成单元,为什么一个能被工程化地控制,另一个不能?

      这个问题指向软件工程里最实在的一处结构性差异,也是本文想讨论的全部内容:复杂性不是由部件的数量决定的,而是由部件之间的关联方式决定的。


      一、"复杂"这个词的三层含义

      1.1 词典给的三个条件

      讨论之前先澄清。牛津词典对 complex 的释义其实给了三个条件,缺一不可:

      • 由多个部分或事物组成;

      • 这些部分之间是有相互关联的;

      • 整体因此不便于理解。

      第一条讲数量,第二条讲关系,第三条讲认知后果。日常讨论里最常被忽略的是第二条——大家习惯用"东西多不多"来衡量复杂,而真正制造麻烦的是"事物之间连了多少条线"。

      1.2 庞杂与复杂,不是一回事

      有一本书叫《为什么需要生物学思维》,里面做了一个区分,值得借用:

      • 一堆东西放在那里,即使很多、很乱,那叫庞杂(complicated);

      • 一堆东西到了一定数量,彼此之间还互相影响、会发生级联效应,那才叫复杂(complex)。

      这个区分在工程上很好用。一个仓库里堆了三千个文件,很乱,但它是庞杂的——你可以一个一个看过去,顶多是花点时间。而一个只有三十个服务的系统,如果每个服务都能直接读写另外五个服务的数据库,它就是复杂的——你改一处,可能不知道哪里会有影响。

      维度

      庞杂

      复杂

      主要来源

      元素数量

      元素间的关联与反馈

      增长方式

      线性累加

      组合爆炸、级联放大

      可分解性

      可以逐项处理

      拆开后行为可能改变

      典型后果

      费时间

      无法归因、无法预测

      软件例子

      一个巨大的工具类文件

      三十个服务共享五张表

      一旦系统跨过庞杂到复杂的那条线,它就会变成一个既无法控制、也难以理解的东西。这个状态,可以叫"复杂性灾难"。

      1.3 级联:复杂性的放大器

      为什么关联比数量更致命?因为关联带来的是组合,不是加法。

      假设系统里有 n 个部件,两两之间可能发生影响,那么这个影响关系最多有 n(n-1)/2 条。n=10 时是 45 条,n=1000 时接近 50 万条。更要命的是,软件里的影响往往是分层的:函数调函数,模块调模块,服务调服务,每一层都有自己的级联。层与层叠加之后,可能出现的交互路径数量会迅速超出任何一个团队的理解能力。

      有一句话说得直白:几百上千万行代码,一旦发生互相之间的关联互动,而且是一层一层的不同级别的互动,"产生的情况有多少种呢?可能比整个宇宙的粒子数量还要多"。

      这不是夸张,是组合数学的常识。宇宙可观测部分的粒子数大约 10^80,而一个三十服务、每个服务暴露二十个接口的系统,其调用路径的组合数在考虑重试、超时、并发之后,轻易就能逼近甚至超过这个量级。

      所以真正的问题从来不是"我们的代码有多少行",而是"我们的代码之间有多少条没人知道的线"。

      二、复杂性灾难:当系统无法被归因

      2.1 三个案例

      要理解"复杂性灾难"到底是什么样子,看三个事故比看定义有效。

      1986 年 1 月 28 日,挑战者号航天飞机在升空 73 秒后解体。调查委员会在当年 6 月提交报告,原因指向固体助推器上的 O 形密封圈:低温发射时橡胶失去弹性,燃气泄漏烧穿了外贮箱。物理学家费曼做了一个后来被反复引用的演示——把一段 O 形圈丢进一杯冰水,再用 C 形夹压住,松手后它没有弹回来。结论明确,责任明确,甚至可以复现。

      1996 年 6 月 4 日,阿丽亚娜 5 号火箭首飞,升空约 37 秒后偏离航线,随即自毁解体。调查结论是:箭上惯导系统沿用了阿丽亚娜 4 号的软件,其中有一段把 64 位浮点数转换成 16 位有符号整数的代码。阿丽亚娜 5 的横向加速度比 4 号大得多,这个转换发生了溢出;溢出触发异常,异常导致主备两套惯导先后关机,火箭随即失控。这段代码在 4 号的多年服役中从未出过问题——它不是一个 bug,它是一个在新环境里失效的旧假设。这次失败损失了两颗卫星,代价约 3.7 亿美元。

      2009 年前后,丰田在美国因"意外加速"发起大规模召回。调查持续了数年,结论并不统一:2011 年 NASA 受委托完成的工程分析,未发现电子节气门系统存在可复现的软件缺陷;而 2013 年俄克拉荷马州一起案件的陪审团,认定车辆的电子控制系统存在缺陷。同一套系统,同一批事实,专业机构之间给出了不同的判断。

      2.2 归因失效才是灾难的本质

      把三个案例排在一起,会看到一个清晰的梯度:

      事故

      能否定位到单一部件

      能否复现

      责任能否归属

      挑战者号(1986)

      能,O 形密封圈

      能

      能

      阿丽亚娜 5 号(1996)

      部分能,一段复用代码

      能(仿真)

      难,无人被追责

      丰田意外加速(2009–)

      不能

      不能

      不能

      第一起是工程失败:系统足够复杂,但边界清楚,所以能被分解、被定位。第二起已经开始变质:出问题的不是某个零件,而是"旧代码在新参数下依然成立"这个假设,而假设散落在系统的语义里,没有物理位置。第三起则完全进入了复杂性灾难的范畴:问题存在于软件系统与外部机电系统的大规模交互之中,任何一个单点看上去都没错,整体却出了人命。

      这正是复杂性灾难的定义性特征:它不是"某个地方坏了",而是"没有任何一个地方单独坏掉"。

      有一句话被反复引用:雪崩时,没有一片雪花是无辜的。它的反面同样成立——雪崩时,因为没有一片雪花是无辜的,所以也没有一片雪花是需要负责的。这句话的工程含义非常冷酷:当系统复杂到无法归因,你也就失去了通过追责来改进系统的能力。

      2.3 为什么软件比硬件更容易掉进去

      物理设备之间的边界是清晰的。一根轴的公差是 0.01 毫米,一个接口的扭矩上限是清晰的,这些都是可以测量、可以验收、可以在图纸上标注的。而代码与代码之间的"边界",往往只存在于写它的人脑子里。

      更麻烦的是,软件没有物理约束来兜底。机械系统过载会变形、会发热、会断,物理定律替你做了限制;软件过载只是慢一点,然后在一个你没预料到的地方超时、重试、放大,最后把上下游打垮。物理世界用磨损提醒你系统在老去,软件则倾向于在崩溃之前一直"看起来正常"。

      所以,软件工程师和机械时代的工程师,处境其实很不一样。后者画蓝图、按图施工、精确控制,造出一个系统,他就是这个系统的神。前者一行行写下系统,却远远不是神——总有一些控制不住的东西,比如一辈子都要打交道的 bug。这不是工程师不够优秀,是这类系统的性质决定的。

      顺带说一句移动端。移动开发长期被认为"复杂度可控",原因是它建立在相当成熟的框架之上,大量工作是 UI 构建和与服务端的信息交换,业务相似度高、重复度高。但这不是逃过了复杂性,只是把复杂性爆炸的时间点推后了:随着业务量增长,偶发崩溃、不可复现的问题一样会出现。

      三、量级不等于复杂度

      回到引子里的对比。三个数字放在一起看很有意思:

      对象

      组成单元数量

      时间

      可控性

      谷歌全部产品代码

      约 20 亿行

      2015

      中,靠工程体系维持

      阿里巴巴年新增代码

      约 12 亿行

      2018

      中

      麒麟 9000 晶体管

      约 153 亿个

      2020

      高,可设计可验证

      波音 747 零件

      约 600 万个,275 公里管线

      —

      高,可靠性以百万架次计

      波音 747 有六百万个零件、两百七十五公里长的管线,世界上没有任何一个人能彻底搞清楚它的完整构造。按演讲中引用的统计口径,它的致命事故率约为每百万架次 1.6 起,安全性最高的机型可以做到 0.33 起——这个水平比绝大多数 App 的"事故率"要低得多。

      原因不在于飞机比软件简单,而在于大型物理系统具备四个可复制的特征:

      1. 精准完备的设计:图纸先于制造,改动要走变更流程;

      2. 清晰的模块边界:发动机、液压、航电,物理上就是分开的;

      3. 明确的、有限的相互关联:接口是标准件,连接是 enumerated 的;

      4. 可控的变更:改一个部件,需要重新验证的清单是已知的。

      软件很难做到第一条——需求在变,技术在变,很少有系统能在开工前把设计做完备。但后三条是可以努力靠近的,而且不需要等待任何新技术:清晰化模块边界,减少相互关联以降低级联效应,把变更关进笼子里。

      这才是本文真正的落点。下面的内容,基本都是这三句话的展开。

      四、模块化:一个可以写成公式的直觉

      4.1 两个不等式

      "分层和模块化是解决复杂问题的基本方案"——这句话大家都听过,但很少有人追问为什么。其实它可以被写得很朴素。

      设 c 表示问题的复杂度(包含问题现状及其可能的发展变化),w 表示解决它所需的工作量。那么:

      if c(k) > c(p) then w(k) > w(p)

      翻译成人话:复杂问题花的时间比简单问题多。这几乎不证自明。

      关键在第二步。当两个不同的问题被放在一起解决时,其复杂度通常高于分别解决之和:

      c(k + p) > c(k) + c(p)

      因为放在一起,就多出了"两者之间如何相互影响"这一层,而这一层本身是有成本的。代入第一个不等式,得到:

      if c(k + p) > c(k) + c(p) then w(k + p) > w(k) + w(p)

      两个问题合起来做,工作量大于分开做。这就是模块化的全部理由:它把一个大问题切成若干小问题,让工作量从"大于和"回到"接近和"。顺带还带来一个社会性收益——切开的块可以并行,多人协作因此成为可能。大规模软件之所以存在,前提就在这里。

      4.2 但模块不能无限拆

      既然拆分能降低成本,为什么不拆到最细?

      因为上面那个不等式只算了一侧。拆分本身有成本:模块越多,接口越多,集成就越贵。集成成本大致随模块数量超线性上升,而单个模块的开发成本随模块数量下降。两条曲线相加,总成本是一个 U 形曲线。

      模块数量

      单模块成本

      集成成本

      总成本

      很少

      高(问题未被分解)

      低

      高

      适中

      中

      中

      最低(最小成本区间)

      很多

      低

      高(接口爆炸)

      高

      日常开发中我们其实一直在描这条曲线:既不会把整个系统写成一个文件,也不会把一个函数拆成十个服务。所谓"架构能力",很大程度上就是对这条曲线最低点的判断力。

      那么问题来了:最低点在哪里?依据什么下刀?

      这就是 1972 年那篇论文要回答的事。


      五、1972 年:分解的准则

      5.1 一位容易被忽略的作者

      David Lorge Parnas,1941 年生,电气工程博士,是最早把传统工程原理系统性地引入软件设计的人之一。他是首届图灵奖得主 Alan Perlis 的博士生,也是"信息隐藏"(information hiding)这个概念真正的提出者。

      值得一提的是,我们今天熟悉的"高内聚、低耦合",帕纳斯本人几乎不用。他用的是另一个词:信息隐藏。这两个提法描述的是同一件事的不同侧面,但帕纳斯的版本更可操作——它告诉你该怎么下刀,而不只是告诉你刀口应该漂亮。

      他还是"星球大战"计划(SDI)的早期参与者,也是它最著名的公开批评者之一。1985 年,他发表文章论证:用于作战管理的软件不可能达到可以被信任去阻止核攻击的质量水平。这个判断的方法论基础,和他 1972 年那篇论文是同一套。

      5.2 那篇论文和它的问题

      1972 年 12 月,Parnas 在《Communications of the ACM》上发表《On the Criteria To Be Used in Decomposing Systems into Modules》。这篇论文讨论的问题极其具体:把系统拆成模块时,到底应该按什么标准拆?

      论文用了一个贯穿全文的例子:KWIC(Key Word In Context)索引系统。需求是这样的:

      系统接受若干行文本,每行由若干词组成,每个词由若干字符组成。每一行要做循环移位——反复把第一个词移到行末;然后把所有行、所有移位结果按字母顺序排列输出。

      举例来说,输入两行:

      Clouds are white 

      Ottawa is beautiful

      输出要长这样,每个关键词都被它所在的上下文包围:

      are white Clouds 

      beautiful Ottawa is 

      Clouds are white 

      is beautiful Ottawa 

      Ottawa is beautiful 

      white Clouds are

      这个问题简单,但包含了一个完整系统的所有要素:输入、数据结构、变换、排序、输出。用它来比较两种分解方式,非常干净。

      5.3 方案一:跟着流程图走

      第一种分解是最符合直觉的,也是几乎所有工程师默认会做的那一种:先画流程图,然后把每个处理步骤变成一个模块。

      于是得到五个模块:

      模块

      职责

      Input

      读入数据行,存进 core;存储格式为每机器字 4 个字符,并维护一个指向各行起始位置的指针数组

      Circular Shift

      在 Input 完成后调用;读行存储,生成一个"对"的数组(每个循环移位的首字符下标、原行号)

      Alphabetize

      在 Circular Shift 完成后调用;读上述两个数组,生成新的索引

      Output

      在排序完成后调用;读模块 1 和模块 3 产出的数组,漂亮地打印出来

      Master Control

      负责前四个模块的时序与错误处理

      这套设计能跑,功能正确。请注意:模块之间不是通过接口通信的,而是通过共享存储。Characters、Index、Alphabetised Index 三块数据结构是公共的,每个模块都直接读写它们。Output 模块的实现,必须知道 Index 里存的是"指向 Characters 的地址",也必须知道 Alphabetize 把结果按什么顺序摆好。

      在那个内存只有几 KB 的年代,这样的设计不仅是合理的,甚至是必要的——你必须精心设计字节排列和打包方式,才能把数据塞进去。这些关于存储格式的决策,本身就是设计的主体。

      5.4 方案二:跟着变化走

      第二种分解放弃了流程图。它给出的模块是这样的:

      模块

      职责

      Line Storage

      一组函数:CHAR(r,w,c) 返回第 r 行第 w 个词的第 c 个字符;SETCHAR 设置它;WORDS(r) 返回词数……

      Input

      从输入介质读原始行,调用 Line Storage 存起来

      Circular Shifter

      提供与模块 1 同构的一组函数:CSCHAR、CSWORDS、CSLINES、CSCHARS,外加上电时调用的 CSSETUP

      Alphabetizing

      ITH(i) 返回按字母序排第 i 位的循环移位下标;使用前必须先调 SORT()

      Output

      打印行或循环移位的集合

      表面上看,模块名字差不多,甚至数量都还是五个。但结构完全不同,关键差异只有一条:底层数据不再共享,所有访问都必须经过模块自己的接口。

      除了 Line Storage 自己,没有任何模块知道行是怎么存的、是不是每机器字打包四个字符、循环移位到底是真存了一份还是每次现算。Alphabetizing 甚至被设计成让调用方无法察觉排序究竟有没有真的做完——它可以在 SORT() 里全部算完,也可以在每次 ITH(i) 调用时临时算一点。

      这就是信息隐藏。模块不再是"一个处理步骤",而是"一组被藏起来的设计决策"。

      5.5 三把尺子

      两种方案都能正确实现功能,也都在一定程度上拆解了复杂性。论文用三把尺子来比较它们。

      第一把:可变性。论文列了五条在真实演进中很可能发生的变更:

      变更

      方案一的影响面

      方案二的影响面

      输入格式变更

      限于 Input 模块

      限于 Input 模块

      全部行常驻内存改为不常驻

      每个模块都要改

      限于 Line Storage

      字符打包方式变更

      所有模块都要改,因为都依赖 core 的存储格式

      只有 Line Storage 知道

      循环移位从"建索引"改为"实存"

      字母排序器和输出例程都要改

      限于 Circular Shifter

      排序时机从"预先全排"改为"按需计算"

      很麻烦,Output 假定索引已经就绪

      限于 Alphabetizing,外部无感

      除了第一条,其余四条在方案一里都会穿透到多个模块,在方案二里都被关在一个模块内。差异的来源很清楚:方案一把"存储格式怎么办、排序什么时候做"这些决策暴露在了接口上;方案二把它们藏在了接口后面。

      第二把:并行独立开发。方案一的模块接口是"复杂的格式和表组织结构",这些格式本身就是不能轻视的设计决策,必须由几个小组共同商定,而且要仔细设计——接口定不下来,谁也不能开工。方案二的接口更抽象,主要是函数名加上参数的数量和类型,都是相对简单的决策,独立的模块开发可以更早开始。

      第三把:可理解性。要理解方案一的 Output 模块,你必须先了解 Circular Shifter、Alphabetizer 和 Input 在做什么——只有在其他模块以特定方式工作的前提下,输出所用的表结构里某些字段才有意义。这个系统只能作为一个整体被理解。而在方案二里,Output 只需要调用一个简单接口。

      一句话总结:方案一是"按时间顺序切",方案二是"按知识的边界切"。

      5.6 Parnas的结论

      论文的结论说得很不客气:从流程图入手把系统分解为模块,几乎总是不妥的。

      正确的起手式不是画流程,而是先列出"一系列困难的设计决策,或者可能变化的设计决策",然后让每个模块去隐藏其中的一部分。模块的接口设计原则也随之确定:尽可能少地暴露内部工作原理。

      这里有一个常被忽略的判断:流程图对五千到一万条指令规模的系统是个有用的抽象,但超过这个量级,它就不够用了。这不是流程图本身的错,而是因为流程图表达的是"控制流",而大规模系统的麻烦几乎都长在"数据与知识的依赖"上。


      六、布鲁克斯的认错

      这套理论靠不靠谱?有一个旁证非常有说服力。《人月神话》的作者 Fred Brooks,在书里说过一句被引用得极多的话:给我看你的流程图而藏起你的数据表,我仍然会迷惑;给我看数据表,我通常就不需要流程图了,程序结构会变得很明显。

      这句话常被用来支持"数据结构优先",但它其实也埋下了对信息隐藏的怀疑:如果数据表才是理解系统的钥匙,那把数据藏起来,别人还怎么理解?所以在《人月神话》第一版里,Brooks 批评了信息隐藏,他推崇的是公开共享代码。

      二十年后的 1995 年,在 20 周年纪念版里,他专门用一小节更正了这个判断。原话是:

      Parnas was right, and I was wrong about information hiding. (…) I am now convinced that information hiding, today often embodied in object-oriented programming, is the only way of raising the level of software design.

      (……)[传统的]技术确保程序员可以通过知道另一边是什么,来知道他们所用接口的详细语义。隐藏这些语义会导致系统错误。另一方面,Parnas 的技术在变化面前是健壮的,在设计换变化的哲学中更合适。

      这段话值得逐句读。Brooks 承认的不是一个细节,而是一个方向:让接口的语义保持未知,短期看会增加误解,长期看是唯一能扛住变化的结构。

      顺带说,Parnas本人后来对这个问题的表述更硬。他不用"经验证明"这种说法,而是给出一个可以证明的命题:假设有两个模块 A 和 B;如果你可以只依据 B 的接口证明 A 是正确的;那么当你修改 B 而不改接口时,A 不需要任何改动。

      这个链条一旦成立,"信息隐藏"就不再是一种风格偏好,而是一个关于变更成本的定理。它也是后面所有关于"服务契约"的数学底子。


      七、微服务:把复杂性从空间上搬出去

      7.1 复杂性守恒

      Michael Feathers 有一句话,我认为是理解微服务最关键的一句:

      我坚信软件中存在一条复杂性守恒定律。当我们把大事分解成小块时,我们总是把复杂性推到它们的相互作用上。

      这句话解释了为什么微服务既让人兴奋又让人痛苦。

      单体架构里,复杂性集中在代码内部:一个类依赖三十个类,一次改动的爆炸半径无法预估。拆成微服务之后,单个服务内部的代码量确实显著下降,很多服务只有几千行——这正是"代码占用面积减少"的说法。但代价同步发生:代码里的函数调用,变成了服务间的网络调用。每个请求的状态必须从一个服务传到另一个服务,才能拼出响应。原来一个栈就能解决的事,现在需要序列化、传输、超时、重试、幂等、补偿。

      于是复杂性搬家了。从"代码内部"搬到了"交互之间",从"开发阶段"搬到了"运行阶段",从"程序员的可视范围"搬到了"运维和 SRE 的监控面板"。

      7.2 三种复杂性

      如果只记住一个区分,记住这个:把软件复杂性分成三层。

      类型

      含义

      微服务能否降低

      必备复杂性

      问题本身固有、无法消除的部分

      不能

      表面复杂性

      实现方式带来的额外纠缠,如杂乱的连线

      能,且这是主要收益

      设计复杂度

      设计不当、重复建设、为预研而引入的复杂性

      看治理水平,可能反增

      微服务做的事情,本质上是把"杂乱的连线"收成"一条总线":表面复杂性下降了,必备复杂性一点没变。那些以为上了微服务就能"消除"复杂性的项目,基本都在这条上栽了跟头。

      再往前一步,还有一层判断:系统的实际复杂性一定会超过它的必备复杂性,超出的部分就是设计复杂性。设计复杂性本身没有好坏——它可能来自设计不当,也可能来自有意的技术投入(比如做预研)。关键在于,这是一笔投入,你要问清楚它换回了什么。

      微服务就是一次复杂性投入。你多花了分布式事务、服务治理、链路追踪、灰度发布的成本,换回来的是独立部署、技术异构、故障隔离和团队自治。这笔账划不划算,取决于业务的变化速度——变化越快,买"独立演进"这个期权就越值。

      7.3 债还不掉,只能加速淘汰

      还有一个更根本的视角:软件的复杂性总是增加的。

      软件像熵,很难掌握,也无法直接测量,而且它遵守热力学第二定律。任何一个长期运行的系统,都会经历这样的过程:很多不同的人在上面工作,每个人都有自己的风格;功能不断被添加、修改、移除;系统还要和越来越多的外部系统集成,长出大量接口。结果是架构越来越不稳定,新功能上线越来越慢,创新被拖住。

      所以"微服务能消除技术债"这个说法要打个折。准确的说法是:债是还不掉的。你确定你重构代码、偿还债务的这份工作,本身没有在制造新的债务?存量即债,只要你开动代码生产机器,你就在高筑债台。

      微服务真正提供的,是一种加速淘汰的机制。服务粒度小、边界清楚、可以独立部署,意味着单个服务可以被更便宜地重写、替换、丢弃。从宠物变成牲畜,随时可以宰杀。降低单次淘汰的成本,比试图一次性还清债务,要现实得多。

      7.4 代价清单

      把微服务的收益与代价并列,会更容易做决策:

      维度

      单体

      微服务

      净效果

      单服务代码量

      大

      小

      改善

      改动爆炸半径

      大,靠编译期发现

      小,但错误后移到运行期

      双向

      调用成本

      函数调用,纳秒级

      网络调用,毫秒级

      恶化

      状态一致性

      本地事务

      分布式一致性

      显著恶化

      故障模式

      全挂或全活

      部分失败、级联失败

      恶化,需新能力

      独立部署

      不能

      能

      改善

      组织自治

      弱

      强

      改善

      可观测性要求

      低

      极高

      新增硬门槛

      注意最后一行,它不是一个"最好有"的加分项,而是前置条件。


      八、组织也是耦合

      技术之外还有一层常被低估的复杂性来源:组织本身。

      康威定律说,系统的结构会不可避免地复制组织的沟通结构。这条定律在微服务时代几乎是自我实现的:你按团队拆服务,服务边界就会长成组织边界的样子;反过来,如果你先画了一张理想的服务蓝图,却按另一套组织去落地,最终跑起来的架构会向组织妥协。

      邓巴数给了组织规模一个生物学的上限:人类能维持稳定社交关系的人数大约在 150 人。超过这个规模,靠"大家都认识"来协调就失效了,必须依赖流程和文档——而流程和文档正是复杂性的新来源。

      两个披萨的原则是这条规律在工程上的操作:如果两个披萨喂不饱一个团队,这个团队就太大了。人一多,会议效率下降,与会者倾向于附和而不是表达独立判断,扯皮和推诿随之出现。小团队更容易达成共识,也更容易让"服务边界"和"责任边界"重合。

      这三条放在一起,说明一件事:微服务不是纯粹的技术重构,它是组织重构的技术投影。只改代码不改组织,通常会得到"分布式的单体"——服务拆开了,发布还得一起发,数据库还共用一套。


      九、把准则落到服务边界上

      前面讲的都是判断依据,到底该怎么用呢?Parnas的准则要到服务级别,需要做一次翻译。

      9.1 划分前先问四个问题

      把"隐藏困难或易变的设计决策"翻译成服务设计语言,可以拆成四个可操作的问题:

      问题

      想验证什么

      不合格的信号

      这个边界两侧,变化的原因相同吗?

      是否按变化源切分

      改一个业务规则,要同时改三个服务

      这个服务对外暴露的,是契约还是实现?

      是否真的隐藏了决策

      上游要了解下游的表结构才能工作

      去掉这个服务,上游还能编译和测试吗?

      依赖是否收敛到接口

      上游必须起全套环境才能跑单测

      它挂了,会不会拖着别人一起挂?

      级联风险

      一个非核心服务超时,主链路雪崩

      第三问特别值得展开。方案一和方案二最本质的差别,其实就体现在"能不能只凭接口把上游测通"。如果一个服务的存在,使得上游必须启动它、连上它的数据库、造出符合它内部格式的数据才能测试,那么这个边界是假的——你只是把一张大表拆成了若干张互相认识的小表。

      9.2 接口只暴露契约

      Parnas方案二的接口长这样:CHAR(r,w,c)、WORDS(r)、ITH(i)、SORT()。它们有几个共同特征:

      • 参数是语义坐标(第几行、第几个词、第几个字符),不是内存地址或内部偏移;

      • 不暴露数据是"存着的"还是"算出来的";

      • 调用顺序的约束被显式声明(SORT() 必须先调),而实现自由度被保留。

      映射到 HTTP / RPC 上,就是几条很朴素的规矩:

      • 接口用业务语义命名而不是用表名;

      • 响应体不泄露内部主键与存储细节;

      • 对"何时可见""是否幂等""失败后能否重试"给出明确承诺;

      • 版本策略写在契约里而不是靠口头约定。

      反过来,下面这些做法都在把决策重新暴露出去:

      • 上游直接连下游的库;

      • 共享一张"公共表"当集成方式;

      • 接口返回原始 ORM 实体;

      • 用 status 字段的魔法值传递业务状态,而这些值的含义散落在三个仓库的注释里。

      9.3 把"互相影响"限流

      复杂性的放大器是级联。工程上对付级联的手段已经很成熟,但常常被当成"运维配置"而不是"架构约束":

      手段

      对应的问题

      注意事项

      超时

      无限等待导致的资源堆积

      超时必须小于上游的超时,逐层收敛

      重试 + 退避 + 抖动

      瞬时故障

      重试会放大流量,必须配合幂等

      熔断

      故障服务拖垮调用方

      半开策略要按业务调,不要抄默认值

      舱壁隔离

      单一依赖占满线程池

      按依赖分组,核心与非核心分开

      背压 / 限流

      上游过载传导

      限流点应靠近入口,且可观测

      降级

      非核心能力故障

      降级路径必须被真实演练过

      这里有一条容易忽视的原则:每一个跨服务调用,都必须有明确的失败语义。是快速失败、是降级返回、还是排队重试,这个决定必须在设计时做出,而不是等线上出事时由框架的默认值替你决定。默认值往往是最坏的那种:重试三次,每次超时三十秒。

      9.4 可观测性不是运维的事

      方案二之所以"可理解",是因为一个模块只需要知道它依赖的接口。微服务把这条链路打散了:一个请求穿过七个服务,任何一个人看到的都只是片段。

      于是"可理解性"这个准则在分布式系统里必须换一种实现方式——它从"读代码就能懂"变成了"看链路就能懂"。

      具体来说,需要三样东西同时成立:

      1. 统一的 trace id 贯穿全链路;

      2. 每个服务的关键决策点有结构化日志(不是 print("here"));

      3. 服务之间的依赖关系可以被自动发现并画出来,而不是靠一份三个月前更新的架构图。

      有一句话说得很好:如果没有实时地图显示微服务如何与数据库以及外部服务交互,那么 DevOps 就是盲目的。而盲目的运维,只能靠加人来弥补——这恰恰是《人件》批评过的那种做法。

      9.5 反模式清单

      反模式

      表面症状

      根源的问题

      分布式单体

      服务拆了,发布还得一起发

      边界按组织画,没按变化画

      共享数据库

      改表要开五个团队的会

      数据存储决策没有被隐藏

      贫血接口

      上游拿一堆字段自己拼业务逻辑

      业务决策暴露到了边界之外

      按技术分层拆服务

      Controller 服务、DAO 服务

      按处理步骤切,正是方案一

      按实体拆到最细

      一个表一个服务

      只算了拆分收益,没算集成成本

      无契约演进

      下游半夜被告知字段改了

      缺少显式的接口承诺

      全链路强一致

      一个下单要协调六个服务

      把本地事务的思维搬到分布式

      这些反模式的共同点,都能回到同一句话:它们把"变化的原因"和"部署的单位"搞混了。


      十、小结

      回到开头的问题:为什么芯片能被控制,软件不能?

      因为芯片的每一个部件之间的关系,在流片之前就被穷举过、验证过、写进了设计规则;而软件部件之间的关系,是在几百个人的日常改动中缓慢长出来的,没有人完整地看过那张图。芯片的复杂性是被设计出来的,软件的复杂性是被积累出来的。

      这决定了应对方式的不同。前者靠验证,后者只能靠结构。

      而结构这件事,1972 年那篇论文已经说得足够清楚了:不要从流程图开始,从"哪些决策是困难的、哪些决策是会变的"开始;让每个模块藏起一组决策;接口只承诺最少的东西。

      微服务没有发明新原理,它只是把这条原理的作用范围从函数扩大到了进程——收益被放大,代价也被同比例放大。所以它既不是银弹,也不是骗局,它是一次复杂性交易:用运行期的分布复杂性,换开发期的演进自由度。

      这笔交易划不划算,取决于你的业务变化有多快,也取决于你有没有能力把新增的那部分复杂性管住。管不住的时候,分布式系统不会退回单体,它只会变成一个更难归因的单体。

      最后留一个问题给自己:每次决定"这里拆一个服务"的时候,你藏起来的是哪一组决策?如果答不上来,那可能只是把一个函数搬到了另一台机器上。

      PS,在AI时代,架构的复杂性又是怎样的呢?

      【关联阅读】

      跳转微信打开

      本体方法实践:从 RDF 和 OWL 到 GraphRAG

      2026年10月20日 20:26

      原创 半吊子全栈工匠 2026-10-20 20:26 北京

      本体工程最实用的形态可能是什么?

      【引】"本体"(Ontology)这个词略显神秘。本质上,本体只是对一个领域的显式约定:哪些东西存在、它们之间可以有什么关系、这些关系应遵循什么规则、系统从已知事实能推断出什么。本文是对《本体驱动的AI大模型:方法与实践》一书的解读与补充。以一个实例逐层拆解 I命名空间、RDF、RDFS、OWL、SHACL 五大技术层,并展示本体如何让 GraphRAG 更可靠。

      Tom Gruber 将本体描述为"对概念化的显式规范"。用大白话说,它是一份机器可读的说明,描述我们如何决定理解世界的某个特定部分。

      例如,Vanguard S&P 500 ETF(VOO)是一个全球投资者熟悉的产品,追求跟踪 S&P 500 指数的投资表现。假设我们希望一个金融知识系统理解以下事实:

      • Vanguard S&P 500 ETF 是一只 ETF。

      • 它由Vanguard集团管理。

      • 它跟踪 S&P 500 指数。

      这三句话足以引入本体技术的每一个重要层次。

      一、本体和知识图谱不是一回事

      最简单的区分是本体定义世界的规则,知识图谱存储关于这个世界的事实。

      本体可能定义:

      • ETF和AssetManager作为实体类型
      • managedBy作为从 ETF 到资产管理者的关系
      • tracksIndex作为从 ETF 到市场指数的关系

      知识图谱则存储实际的实体和关系:

      • VOO 是一个 ETF

      • VOO managedBy Vanguard

      • VOO tracksIndex S&P500Index

      把本体想象成一款棋盘游戏的设计图——它定义棋子、合法走法和规则。知识图谱是桌上正在进行的这局棋。

      这就是为什么"本体是模式、知识图谱是数据"是一个有用的捷径,本体能表达比传统数据库schema丰富得多的逻辑。

      二、我们总需要本体吗?

      不需要。如果你的应用只存储几个字段并按精确键检索,关系表或 JSON 文档就够了。本体工作引入设计、治理、验证和维护成本。当一个或多个以下问题出现时,它才变得有价值:

      问题 1:不同系统用不同的词

      一个系统说"基金提供商",另一个说"资产管理公司",第三个说"管理公司"。本体可以定义首选概念并将替代标签映射到它。

      问题 2:用户提问需要关系

      考虑:

      哪些由先锋管理的 ETF 跟踪美国股票指数?

      回答这个问题需要跨越多种实体类型和关系的路径,而非简单的关键词匹配。

      问题 3:系统需要检测无效数据

      如果managedBy应指向一个组织,以下声明应被标记:

      VOO managedBy John Smith

      John Smith 可能是一位投资组合经理,但他不是负责该 ETF 的资产管理组织。金融机构、医疗提供商和其他受监管行业依赖可信的知识图谱——单个错误关系就可能破坏 AI 可靠性、合规性和决策。本体约束充当护栏,确保只有语义有效的知识进入系统。

      问题 4:系统应推导从未直接存储的事实

      如果每只 ETF 都是交易所交易产品,而 VOO 是一只 ETF,推理器可以推断:VOO 是一种交易所交易产品。

      问题 5:LLM 需要可靠的领域地图

      LLM 可能生成流畅文本,同时混淆基金、指数、发行人和投资组合经理。本体给系统明确的实体类型、路径和约束,可引导检索并检查生成的答案。

      实用规则很简单,从语义精度和关联推理创造足够价值以抵消维护成本的领域开始。

      三、一个例子,五个技术层

      语义 Web 技术栈常令人困惑,因为多个标准被一起讨论。每个标准回答不同的问题。让我们逐层构建示例。

      第 1 层:标识符与命名空间

      知识图谱需要为每个重要资源取一个无歧义的名字。"Vanguard"可读,但并非全局唯一——它可能指一个组织、一个产品系列或与金融无关的东西。IRI 给实体一个唯一标识符:

      https://example.org/finance/Vanguard

      到处输入完整标识符会很痛苦,所以我们定义命名空间前缀:

      @prefix fin: <https://example.org/finance/> .

      现在我们可以写:

      fin:Vanguard

      简写和完整 IRI 标识同一资源。前缀只是方便的缩写,不改变底层身份。

      为什么标识符看起来像网址?RDF 和 OWL 是为语义 Web 开发的,不同组织的数据需要无命名冲突地连接。Web 式 IRI 利用域名所有权创建全局唯一名称:company-a.com/ETF和company-b.com/ETF可以安全地指向不同概念。它可能打开文档页面,但不必如此——IRI 的首要工作是标识,不是导航。

      第 2 层:RDF 将事实表示为三元组

      RDF 将信息表示为"主语-谓语-宾语"三元组。

      主语

      谓语

      宾语

      VOO

      managedBy

      Vanguard

      VOO

      tracksIndex

      S&P 500 Index

      在 Turtle(一种紧凑的 RDF 序列化格式)中,同样的事实如下所示:

      @prefix fin: <https://example.org/finance/> .
      fin:VOO fin:managedBy fin:Vanguard ;
              fin:tracksIndex fin:SP500Index .

      分号表示下一条语句使用相同的主语fin:VOO。

      RDF 是数据模型,Turtle 是书写该模型的一种方式。关系类似表格和 CSV:一个是底层结构,另一个是表达它的文件格式。

      同一 RDF 图也可以序列化为 JSON-LD:

      {
      "@context":{
      "fin":"https://example.org/finance/",
      "managedBy":{
      "@id":"fin:managedBy",
      "@type":"@id"
      },
      "tracksIndex":{
      "@id":"fin:tracksIndex",
      "@type":"@id"
      }
      },
      "@id":"fin:VOO",
      "managedBy":"fin:Vanguard",
      "tracksIndex":"fin:SP500Index"
      }

      Turtle 和 JSON-LD 看起来不同,但可以描述同一个图。

      第 3 层:RDFS 引入基本模式

      RDF 能陈述事实,通过 RDF Schema,我们可以定义类、子类、属性、定义域和值域:

      @prefix fin:  <https://example.org/finance/> .
      @prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
      @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
      fin:FinancialProduct a rdfs:Class .
      fin:Fund             a rdfs:Class ;
                           rdfs:subClassOf fin:FinancialProduct .
      fin:ETF              a rdfs:Class ;
                           rdfs:subClassOf fin:Fund .
      fin:AssetManager     a rdfs:Class .
      fin:MarketIndex      a rdfs:Class .
      fin:managedBy a rdf:Property ;
          rdfs:domain fin:Fund ;
          rdfs:range fin:AssetManager .
      fin:tracksIndex a rdf:Property ;
          rdfs:domain fin:ETF ;
          rdfs:range fin:MarketIndex .

      现在图有了基本的概念结构:

      FinancialProduct
      └── Fund
          └── ETF

      有一个令许多初学者惊讶的关键细节:

      在 RDFS 中,定义域和值域主要支持推理,它们不是数据录入验证规则。

      如果图包含fin:VOO fin:managedBy fin:Vanguard,且managedBy的定义域是Fund,RDFS 推理器可能推断 VOO 是一个 Fund。它不一定会因为 VOO 缺少显式的 Fund 类型而拒绝该三元组。如果目标是拒绝或报告不符合规范的数据,那是 SHACL 等验证语言的工作。

      第 4 层:OWL 添加更丰富的语义

      OWL 2 是一种具有形式化定义含义的本体语言。它能表达类、属性、个体、等价性、不相交性、属性特征、基数约束等。例如:

      @prefix fin: <https://example.org/finance/> .
      @prefix owl: <http://www.w3.org/2002/07/owl#> .
      fin:managedBy a owl:ObjectProperty ;
          owl:inverseOf fin:manages .
      fin:ETF owl:disjointWith fin:AssetManager .

      逆属性公理意味着:

      如果 VOO 由 Vanguard 管理,那么 Vanguard 管理 VOO。

      我们只存储了一个方向:

      fin:VOO fin:managedBy fin:Vanguard .

      OWL 推理器可以推导另一个方向:

      fin:Vanguard fin:manages fin:VOO .

      不相交公理表示单一个体不能同时是 ETF 和资产管理公司。

      OWL 在目标是描述含义并支持逻辑推理时很有用。它不应被视为传统表单验证器。OWL 通常遵循开放世界假设:缺失的事实是"未知",而非自动为"假"。例如,如果某只 ETF 没有提供managedBy值,OWL 不一定得出该 ETF 没有管理者的结论,图可能只是不完整。

      第 5 层:SHACL 验证图数据

      SHACL 描述 RDF 数据应满足的条件,假设我们的应用要求:

      • 每只 ETF 必须有且仅有一个资产管理公司。

      • 每只 ETF 必须跟踪至少一个市场指数。

      我们可以写一个 SHACL 形状:

      @prefix fin: <https://example.org/finance/> .
      @prefix sh:  <http://www.w3.org/ns/shacl#> .
      fin:ETFShape
          a sh:NodeShape ;
          sh:targetClass fin:ETF ;
          sh:property [        
              sh:path fin:managedBy ;       
              sh:class fin:AssetManager ;        
              sh:minCount 1 ;        
              sh:maxCount 1    
          ] ;
          sh:property [        
              sh:path fin:tracksIndex ;        
              sh:class fin:MarketIndex ;        
              sh:minCount 1    
          ] .

      这组数据符合规范:

      fin:VOO a fin:ETF ;
          fin:managedBy fin:Vanguard ;
          fin:tracksIndex fin:SP500Index .
      fin:Vanguard a fin:AssetManager .
      fin:SP500Index a fin:MarketIndex .

      这组数据不符合:

      fin:BrokenFund a fin:ETF ;
          fin:managedBy fin:Alice .
      fin:Alice a fin:PortfolioManager .

      验证器可以报告至少两个问题:

      1. fin:Alice

        被归类为PortfolioManager而非AssetManager。

      2. fin:BrokenFund

        没有tracksIndex值。

      这个区别值得记住:OWL 描述语句的含义和可推断内容,SHACL 检查图是否符合操作要求,二者互补。

      四、推理如何创造新知识

      让我们组合几条公理:

      fin:ETF rdfs:subClassOf fin:Fund .
      fin:Fund rdfs:subClassOf fin:FinancialProduct .
      fin:managedBy rdfs:range fin:AssetManager .
      fin:managedBy owl:inverseOf fin:manages .

      现在只存储:

      fin:VOO a fin:ETF ;
          fin:managedBy fin:Vanguard .

      推理器可以推导出:

      fin:VOO a fin:Fund .
      fin:VOO a fin:FinancialProduct .
      fin:Vanguard a fin:AssetManager .
      fin:Vanguard fin:manages fin:VOO .

      两条显式三元组产生了四条额外语句。这是本体系统的核心吸引力:精心设计的语义让机器做出有用、可解释的推断,而非仅依赖文本相似度。

      然而,推断的事实仅与产生它们的公理一样可信。一条糟糕的领域规则可能在整个图中传播错误的分类。因此本体设计不仅是建模练习,更是知识治理。

      五、能力问题:从问题倒推设计

      一个常见错误是从"建模领域的一切已知内容"开始。这通常产生一个巨大的、价值不明的本体。更实用的方法从能力问题(Competency Questions)开始,即完成后的知识库必须能回答的问题。

      对于投资产品本体,它们可能包括:

      • 哪些 ETF 由给定的资产管理公司管理?

      • 某只 ETF 跟踪哪个市场指数?

      • 哪些 ETF 提供对给定公司的敞口?

      • 哪些基金使用相同的基准?

      • 谁管理一只基金,这个人受雇于哪个组织?

      这些问题揭示了我们真正需要的概念和关系:

      • 类:ETF,AssetManager,MarketIndex,Company,PortfolioManager
      • 关系:managedBy、tracksIndex、holdsSecurity、employs
      • 数据属性:ticker、legalName、identifier

      它们还暴露了语言的模糊。"管理者"一词可能指资产管理公司,也可能指个人投资组合经理。将它们建模为不同的类可以防止一种常见的范畴错误,过程是迭代的:

      1. 写下问题

      2. 识别所需的概念和路径

      3. 建模能回答它们的最小本体

      4. 用样本数据测试问题

      5. 仅在真实需求出现时扩展

      这种方法反映了一个重要设计原则:为预期用途做最小的本体承诺。

      六、实用的本体开发工作流

      已有多种成熟方法论,包括 TOVE、METHONTOLOGY、On-To-Knowledge、Ontology Development 101 等。它们在范围和严谨度上各有不同,但轻量级项目可以结合它们最实用的想法,形成约 9 个步骤的开发流程:从确定范围和目标出发,通过能力问题驱动概念提取,构建初始本体,再经过推理验证、迭代修订,最终发布和持续维护。

      LLM 可以加速本体工程,尤其在早期发现阶段。给定领域文档、数据库模式和样本用户查询,LLM 可以帮助:

      • 提出能力问题

      • 提取候选概念和关系

      • 规范化同义词

      • 起草类和属性定义

      • 建议逆关系

      • 生成初始 Turtle 和 SHACL

      • 识别缺失的标签和注释

      • 检测常见建模反模式

      一个有用的流水线:

      领域目标 + 用户问题 + 源数据
                    ↓
           能力问题生成
                    ↓
           概念和关系提取
                    ↓
            初始本体提案
                    ↓
        推理、SHACL 和查询评估
                    ↓
           人工审查和迭代修订

      人工审查步骤至关重要。LLM 可能生成语法正确但包含微妙业务错误的本体——例如把 S&P 500 指数当作可交易基金,一个负责任的系统因此应当是:

      • 有据可依(Grounded):只建模有权威来源或数据支持的概念
      • 可复用(Reusable):适当扩展已有词汇表
      • 可扩展(Extensible):允许新产品和关系而无需重写现有定义
      • 查询驱动(Query-driven):为真实能力问题优化模型
      • 可测试(Testable):自动评估推理、验证和查询结果
      • 受治理(Governed):重大语义规则需领域专家批准

      七、本体如何帮助 GraphRAG

      GraphRAG 将检索与图中的关系结合,本体可以让多个阶段更可靠。

      7.1. 查询分解

      考虑:"哪些由先锋管理的 ETF 跟踪 S&P 500 指数?"

      本体告诉系统这是一条有效路径:

      ETF ──managedBy──> AssetManager
      ETF ──tracksIndex──> MarketIndex

      问题可被翻译为结构化图查询:

      SELECT ?etf
      WHERE {
        ?etf a fin:ETF ;
             fin:managedBy fin:Vanguard ;
             fin:tracksIndex fin:SP500Index .
      }

      本体充当查询规划的导航地图。

      7.2. 实体消解

      同一组织可能出现为 "Vanguard"、"The Vanguard Group"、"Vanguard Group, Inc."。本体可以分开定义标签和强标识符——注册标识符或其他权威键可支持身份匹配,而skos:altLabel可为搜索保留别名。

      本体不会魔法般解决实体消解——它定义的是消解系统做决策时哪些证据有意义。

      7.3. 检索控制

      如果用户问 ETF 的基准,本体可以优先检索与tracksIndex关联的文档和图路径,而非检索每个包含该 ETF 名称的页面。

      7.4. 答案验证

      假设 LLM 说:"S&P 500 指数由先锋管理。"本体方法认为:

      • managedBy:期望 Fund 作为主语
      • S&P500Index :是 MarketIndex

      • MarketIndex 和 Fund 不相交

      系统可以检测到类型冲突,要求模型使用检索到的证据重新生成答案。本体给应用一种结构化方式,在某些类别的错误到达用户之前检测到它们。

      Tom Gruber 的经典本体设计原则在现代知识图谱项目中仍然有用:

      1. 清晰性(Clarity)——定义应有效传达含义
      2. 一致性(Coherence)——定义应逻辑自洽
      3. 可扩展性(Extendibility)——设计应支持共享词汇表上的特化
      4. 最小编码偏差(Minimal Encoding Bias)——概念化不应依赖于特定符号
      5. 最小本体承诺(Minimal Ontological Commitment)——只做推理需求所要求的假设

      最后一条尤为重要:一个能回答真实问题的更小本体,通常比整个金融宇宙的宏大模型更有价值。

      小结

      不需要记住整个语义 Web 技术栈,记住每层的职责即可:

      层

      职责

      IRI 和命名空间

      唯一命名事物

      RDF

      将事实表示为三元组

      RDFS

      定义基本词汇和层次

      OWL

      表达更丰富语义并启用逻辑推理

      SHACL

      根据操作要求验证数据

      Turtle / JSON-LD

      将图序列化为文件

      这就是本体工程最实用的形态:命名重要的事物、定义它们如何关联、让规则显式化、测试数据和答案是否尊重这些规则。

      对于知识图谱和 GraphRAG,但当语言模糊、关系重要、且需要可信推理时,它可以成为让整个系统保持一致的语义基石。

      【关联阅读】

      跳转微信打开

      Data Mesh 中的数据产品

      2026年10月18日 20:26

      原创 半吊子全栈工匠 2026-10-18 20:26 北京

      【引】Data Mesh 是否只是一种营销炒作呢?如果不是的话, 那么,Data Mesh 的基础是什么呢?

      【引】Data Mesh 是否只是一种营销炒作呢?如果不是的话, 那么,Data Mesh 的基础是什么呢?本文源自Eric Broda 一次分享的内容。

      数据产品作为企业数据网格的基石,扮演着至关重要的角色。那么,究竟什么是数据产品?它们是如何运作的?我们又该如何识别并快速构建这些关键组件呢?本文将深入探讨这些问题,揭示数据产品的核心概念、工作机制以及高效的构建方法,帮助企业更好地理解和利用数据产品,从而优化其数据管理和应用策略。

      1. 什么是数据产品

      数据产品及其构建的数据网格,极大地提升了数据的可访问性、可用性、共享性和管理效率。为了实现这一目标,从业者需要确保数据产品的构建、部署、安全性和管理过程简便高效。

      Data Mesh的提出者Zhamak Dehghani认为,数据产品是数据网格中的“架构量子”。它们是“可以独立部署和管理的最小架构单元”,具备“可发现性、可理解性、可信赖性、可寻址性、互操作性、可组合性、安全性、本地可访问性”,并且本身具有很高的价值。

      一个补充的定义是:数据产品是“数据领域”和“产品思维”的结合。这种结合使得数据产品不仅能够提供高质量的数据服务,还能够通过灵活的产品设计和开发流程,快速响应业务需求的变化。

      在实际应用中,数据产品通常以API的形式提供服务,这使得它们可以被轻松地集成到各种应用程序和服务中。同时,数据产品还提供了丰富的元数据和文档,帮助用户更好地理解和使用数据。此外,数据产品还支持多种数据格式和协议,以满足不同应用场景的需求。

      什么是“产品思维”?《哈佛商业评论》最近的一篇文章提供了一些有趣的见解。首先,一个产品统领了组织的生产能力,以实现“交付和获取价值”。其次,存在一个或多个“购买并使用该产品的终端客户”。最后,一个产品有一个所有者和团队,他们创建一个长期计划,以确保产品不断改进,使其更加成功,关注的是结果而不是产出。

      换句话说,产品思维意味着确保产品不仅满足特定的业务需求,还能提供实际的价值。这种思维方式强调长期规划和持续改进,以确保产品能够不断适应市场变化和客户需求。同时,产品思维还要求明确授权的所有者,他们不仅要代表企业的利益,还要关注客户的利益,确保产品能够在满足商业目标的同时,也能为客户带来真正的价值。

      定义“数据域”并非易事,尤其在大型企业中,这一术语往往模糊不清。对于首席数据官(CDO)和首席信息官(CIO)而言,治理、监管和隐私问题是导致数据领域划分粗粒度的核心因素。例如,当前的客户数据并不总是能代表所有客户,甚至可能只是一个特例。类似地,数据架构师可能会将客户视为某种参与方的子集,包括当前客户和潜在客户。而开发人员则可能将客户视为连接客户账户和交易的唯一标识符。

      这种多样性的定义反映了不同角色对数据的不同视角和需求。为了解决这一问题,企业需要采取一种更加统一和协调的方法来定义和管理数据域。这包括建立明确的数据治理框架,确保数据的质量和一致性,以及制定有效的数据隐私政策,保护客户的敏感信息。此外,企业还需要加强跨部门的沟通和协作,以确保所有相关方都能理解和遵守数据管理的最佳实践。通过这些措施,企业可以更好地利用数据资产,提高业务决策的效率和准确性。

      简单而言,我们可以将数据域定义为一组可识别的、真实的、相关的数据,这些数据被一致地管理,并且具有一定的质量和准确性度量。

      因此,一个实用的数据产品包括:

      • 清晰的边界,以建立一组可识别的相关数据

      • 一个被授权的所有者,提供组织资源和决策,需要使数据有价值和值得信赖,并提供产品演变的长期视图

      • 作为消费者和生产者生态系统的一部分,需要保证数据的互操作性、一致性和质量来为企业提供价值

      • 平台能力使数据可发现、可寻址、可访问和可互操作

      • 公开的元数据支持发现和自助服务,同时使数据易于理解

      • 联邦治理在企业策略和确保数据安全方面实现本地自治和全局管理的融合

      2. 数据产品的架构

      数据产品的架构特性包括可互操作性、有界性、自感知、可发现性、安全性、历史和时序以及可共享性。这些特性确保了数据产品能够解决数据访问和摄取需求,具有明确定义的边界和所有者,自动捕获更改和关于自身的信息,包含自己的“注册表”以发布元数据和政策,确保数据在构建期间和运行时的安全性,并使用不可变的日志来捕获和管理数据状态或异常的更改。此外,数据产品还允许其管理的数据被摄取或使用,支持准实时通信或在数据产品域内、数据产品之间进行传递。

      数据产品的架构具有如下的组件特性:

      • 可互操作: 可互操作的接口包括了查询以及 API、管道、文件和事件等,可用于解决数据访问和数据摄取的需求。其他接口(通常实现为 API)也可用于观察、运营、保护和管理数据产品。每个接口都有一个约定(例如,API 使用 OpenAPI 规范)来规范化交互。

      • 有界: 数据产品可以存储任何类型的数据,但这些数据具有明确定义的边界和所有者; 虽然分析数据是主要用例,但在数据产品中也可以对运营数据和行为数据进行管理。

      • 自感知: 自动捕获更改和关于自身的信息; 所有数据产品更改都可以被捕获并作为数据产品中的“事件”分发给其他数据产品或企业中的相关方。

      • 可发现性: 每个数据产品都包含自己的“注册表”,发布其数据产品元数据、所有权信息、政策和任何其他支持行为; 数据产品注册表是开发人员、数据科学家和数据分析人员“一站式”查找、使用、共享和治理由特定数据产品管理的数据。它也是特定于该数据产品行为的入口点,允许用户请求访问数据,或者“所有者”创建新的数据产品。

      • 安全性: 数据产品确保所有数据在构建期间和运行时都是安全的; 目标是确保所有数据产品在“零信任”容器/环境中运行。

      • 历史和时序: 使用数据产品对数据状态或异常的更改在一个不可变的日志中被捕获和管理,以支持联邦治理、安全问题的诊断,以及提供数据沿袭。

      • 可共享: 数据产品具有允许其管理的数据被摄取或使用。信息和事件(例如,数据更改或 API 调用)可以使用管道流水线实现准实时通信,或在数据产品域内、数据产品之间进行传递。

      3. 数据产品互操作接口

      在考虑互操作性的接口时,首先考虑的是两种接口: 将数据摄入到数据产品中的接口(流水线、 API 等) ,以及用于在数据产品中使用数据的查询。

      然而,在大型企业中,互操作型的接口有几个约束(在某些情况下是强制性的需求) :

      • 正规的约定: 每个数据摄取或数据消费的路径(如管道、查询、 API 或事件)都应该由正式的并已发布的契约定义。在某些情况下,契约将特定于所使用的工具 ,例如API 或事件分别可以是 OpenAPI 和 JSON Schema 等正式规范。

      • 正规的版本控制: 合同应该进行版本控制,从而允许向下兼容。在较小的环境中,只有很少的参与者共享数据,这可能并不重要。然而,在数据广泛共享的大型企业中,至关重要的是确保当上游系统改变数据格式时,下游系统不会挂掉。

      • 正规的安全规范: 每个工具可能提供不同的安全方法,更糟糕的是,有些工具可能没有健壮或完整的安全模型。尽管如此,这并不能否定保护生产者和消费者界面的必要性,相反,这只会让这一点变得更加困难。

      虽然生产者和使用者的接口很重要,但是我们不应该忽视那些服务发现、可观察性和可管理性接口的关键性。事实上,大多数这些接口都是作为 API 实现的,这意味着我们可以利用 OpenAPI 规范提供的功能。

      OpenAPI 和 AsyncAPI 规范提供了文档化良好、经过实战测试的规范,作为企业内部使用的正式同步/异步契约。OpenAPI 规范允许灵活的方法对 API 进行版本控制,以便随着时间的推移优雅地管理契约变更。OpenAPI 规范还提供了一个健壮的、易于理解的、文档化的方法来定义安全模式,这些安全模式定义为直接映射到角色的“范围”; 通过一些尽职调查,这些范围可以使用 OAUTH2(一种常见的安全方法)实现,并连接到企业的身份记录簿。

      4. 数据产品价值链

      数据产品的价值与其在企业中的使用成正比。在早期阶段,Data mesh 中的数据产品(是可发现的、可寻址的、可互操作的、自描述的、可信赖的和安全的。根据 Data Mesh 的创始人 Zamak Dehghani 的说法,这些是数据产品的基本特征,组成了数据产品提供持续价值的构件。

      有了这些基本属性,就可以开始在企业中使用数据产品了。如果设计良好,那么数据产品现在可以使数据易于查找、使用、共享和治理。由于数据更容易、更频繁地被使用和共享,因此产生了新的灵活性和速度。凭借这种灵活性和速度,能够实现以下商业价值:

      • 更快、更好的洞察力,是创造出色的客户体验或快速满足不断变化的市场需求的关键。

      • 改善上市时间,特别是对于严重依赖数据的最终消费产品。

      • 降低交付成本,因为速度和敏捷性缩短了交付时间。

      但是,如何才能快速、一致和安全地交付数据产品呢? 这就是“数据产品工厂”的用武之地。

      数据产品工厂可以通过建立可重复的步骤来制造数据产品:

      • 提供简化数据产品构建的模板; 这些模板生成具有内置可发现性(“/discover”端点)和可观察性(如“/observe”, “/usage”, “/logs”, 和 “/alerts”)的微服务API。

      • 通过提供上述模板的扩展,使每个 API/微服务都能够基于 OAUTH2的安全性,这些模板易于保护; 通过更多的尽职调查,这些模板还可以为我们的数据产品 API/微服务及其数据生成一个“零信任”的运行时环境。

      • 易于部署,通过提供对上述模板的扩展,将 API/微服务(如果需要,还有数据)生成到一个“容器”(例如 Docker)或 Kubernetes Pod,使得将 Data Products 部署到内部或云环境变得更加容易,并且相对容易地包含在 DevSecOps 管道中。

      • 通过将生成的 API/microservices (例如,“/log”和“/alert”端点)挂钩到企业管理和监控工具中,可以很容易地进行管理。

      5. 数据产品识别

      我们如何确认数据产品的身份呢?有很多方法可以帮助我们在企业中找到数据产品。

      康威定律在数据产品中的应用意味着所有权转移到与组织单位(如业务线)紧密结合的团队,这些团队对数据有深入的了解,并对数据交付结果负有直接责任。CDO 数据域和业务架构提供了识别数据产品候选者的“提示”,但可能需要细分为更细粒度的域以映射到数据产品。行业/商业模型基于数十年经验,识别特定行业中的核心实体,如金融服务领域的 BIAN 和 Teradata (FSLDM)。

      • 康威定律: 将康威定律应用于数据产品意味着所有权转移到与组织单位(业务线等)紧密结合的团队,这些团队对数据有深入的了解,并对数据交付结果负有直接责任,因此拥有数据的决策权和资金权。

      • CDO 数据域: 数据域映射(企业或组)标识对企业具有重要价值的业务实体。这些实体提供了可以识别数据产品候选者的“提示”。但是,请注意,在某些情况下,可能需要将企业域细分为更细粒度的域,以便映射到 Data Products。

      • 业务架构: 业务架构(企业或组)标识重要的业务功能。这些功能通常很容易转换为数据域,这些数据域与 CDO 域一样,提供“提示”,可以识别数据产品候选者。同样,企业域可能需要细分为更细粒度的域,以映射到数据产品。

      • 行业/商业模型: 基于数十年经验构建的商业模型,识别特定行业中的核心实体。在金融服务领域,有几种已建立的商业模型,包括 BIAN 和 Teradata (FSLDM,Financial Services Logical Data Model)。

      粒度很重要!所谓的企业数据域,例如: “企业客户端”,粒度过于粗糙,不适合数据产品,因此很难定义数据边界和所有者。更细粒度的数据边界更好地映射到“所有者”,从而映射到数据产品(“某银行的商业贷款客户”)。

      6. 数据网格: 一个数据产品的生态系统

      没有独立的数据产品,所有的数据产品都是生态系统的一部分,并在其中运行,这个生态系统为“Data mesh”。

      通过深入观察,我们能够将一些明确而具体的职责委托给企业的Data Mesh。Data Mesh首先是一个概念,它不仅是一个营销信息和执行命令,更是企业数据旅程中的一个关键划分。其主要目的是描述和传达如何将数据产品绑定到生态系统中的组织结构和逻辑架构抽象中。

      作为数据产品的可发现性代理,Data Mesh扮演着“企业数据产品注册中心”所有者的角色,这使得数据产品易于查找、使用、共享和治理。通过这种方式,Data Mesh确保了数据产品的可见性和可用性,从而促进了企业内部的数据流通和利用。

      此外,Data Mesh还是数据产品协议的管理者。它建立了一套协议,通过这些协议,数据可以在数据产品内部、数据产品之间以及与更广泛的组织之间进行共享。这种协议不仅规范了数据的交互方式,还提高了数据交换的效率和安全性。

      因此,Data Mesh成为了企业公共通信、流水线和/或事件流主干中的关键消费者和/或利益相关者。它通过提供统一的接口和标准,使得不同的数据源和应用能够顺畅地集成和交互。这种整合能力极大地提升了企业的数据处理能力和业务响应速度。

      总之,Data Mesh作为一种创新的数据管理架构,为企业提供了一种全新的视角来看待和管理其数据资产。它不仅简化了数据的发现和使用过程,还加强了数据的治理和安全性。随着越来越多的企业开始认识到Data Mesh的价值,这一架构有望在未来得到更广泛的应用和发展。

      7. 一句话小结

      数据产品是您的数据网格旅程的基础,本文浅析了数据产品如何使数据易于查找、使用、共享和治理,“数据产品工厂”使得数据产品易于构建、部署、安全和管理。

      【参考资料与关联阅读】

      跳转微信打开

      《数据即产品》译者序

      2026年10月13日 20:26

      原创 石涛声 2026-10-13 20:26 北京

      数据即产品,为什么?怎么做?能有营收?... ....

      亲爱的朋友们,

      我很荣幸向大家呈现《Managing Data as a Product》的中译本。

      在当今数据驱动的时代,数据管理的重要性已无需赘言。《Managing Data as a Product》为我们提供了一种全新的视角——将数据作为产品来管理。这种方法不仅能够帮助组织更高效地利用数据资产,还能有效应对传统数据平台在可扩展性、技术债务和维护成本方面的挑战。本书的中文译本旨在将这一前沿理念带给中国读者,为数据工程师、架构师、企业领导者以及所有致力于优化数据架构的专业人士提供宝贵的指导。

      传统的数据平台通常采用集中式、单体式架构,这种架构在面对现代数据需求的复杂性和规模时,往往显得力不从心。它们不仅在可扩展性上存在局限,还给数据团队带来了巨大的认知负担和技术债务。《Managing Data as a Product》提出了一种全新的解决方案——通过将数据视为产品,采用模块化和分布式的架构来管理数据。这种方法能够显著提升数据平台的灵活性和可持续性,帮助组织以增量、可衡量的方式实现数据价值。

      书中不仅探讨了数据产品化的理论基础,还提供了具体的实施策略。例如,它指导读者如何识别潜在的数据产品、如何设计和执行以数据产品为中心的战略,以及如何通过自助服务平台自动化数据产品生命周期管理。这些内容对于希望优化数据架构、降低维护成本的企业来说,具有重要的实践意义。

      中国作为全球数据量增长最快的国家之一,数据管理的效率和质量直接影响到企业的竞争力和国家的经济发展。根据国际数据公司(IDC)的报告,中国的年度数据量预计将从2022年的23.88ZB增长到2027年的76.6ZB,年复合增长率高达26.3%。与此同时,中国政府近年来将数据列为与土地、劳动、资本和技术并列的生产要素之一,并通过一系列政策推动数据的市场化配置。例如,2024年初发布的“数据要素X”三年行动计划,旨在通过提升数据质量、流通、分析和安全性,推动数据在经济中的高水平应用。在这一背景下,《Managing Data as a Product》所提出的数据产品化理念,与中国当前的数字化战略高度契合。例如,书中讨论的模块化和分布式数据平台架构,能够帮助中国企业应对数据规模快速增长带来的挑战。此外,书中关于数据建模和生成式AI应用的章节,与中国在人工智能领域的快速发展相呼应,为企业提供了如何利用数据支持AI创新的实用建议。

      翻译这本书对我而言是一个自然的选择,因为这本书与我的使命高度契合。作为GitData.AI的创始人和首席执行官,我致力于将软件工程的原则应用到数据中,提出数据应以与软件相同的严谨性和方法论进行管理。当数据被像软件一样管理时,数据自然成为一个产品。软件工程中的面向对象的特性,包括抽象、封装、模块化、继承和多态特性贯穿整个数据技术栈,使数据和数据工件的创建、读取、更新、删除操作遵循软件开发生命周期,包括审查周期、持续测试、质量保证、部署后监控和端到端可观察性。这种“数据即软件”的方法支持数据产品的可重用性和可扩展性,使数据天然具备产品的特性,能够即时提供服务,并提供对下游和上游影响的高度清晰度,同时允许灵活修改模块化组件。而这些正是《Managing Data as a Product》的核心主题。我相信,这本书将为中国的数据专业人士提供宝贵的见解,帮助他们更有效地管理数据资产并推动业务价值。

      本书的翻译源自几个不同有趣灵魂和人生轨迹的碰撞。首先感谢华章出版社和各位编辑老师的信任,把这样一个前沿技术领域的翻译工作交给了我们。感谢家人对我们支持,让我们把有限的时间更多地投入到译作中。特别感谢GitData.AI的联合创始人廖真益老师,在百忙之中审译了全书,提出了很多建设性的意见和建议。翻译是一项特殊的学习和创作过程,字里行间包含了译者的理解和选择。尽管小心谨慎如履薄冰,终因译者水平有限,本书翻译错漏之处在所难免,望诸位读者海涵并指正。

      我们希望通过这本中文译本,中国的数据工程师、架构师、企业领导者以及所有关注数据管理的专业人士,能够深入理解数据产品化的理念,并在实践中应用这些方法。无论是优化企业的数据架构、降低技术债务,还是推动生成式AI的应用,本书都提供了宝贵的指导。我们期待这本书能够为中国的数字化转型和数据经济发展贡献力量,帮助组织在快速变化的数字时代中保持竞争优势。

      最后,我还要向数据社区致敬,感谢他们对数据管理卓越的不懈追求。

      祝阅读愉快!

      石涛声
      GitData.AI 创始人兼首席执行官


      本书主要内容

      第1章“从数据副产品到数据产品”阐述了如何通过数据产品化实现数据架构模块化,从而解决阻碍其可持续发展的各种反复性问题。

      第2章“数据产品”界定了数据产品的定义,阐述了其关键特征,并详细解析了构成数据产品的核心要素,着重探讨了各个组成部分对其整体功能和价值的贡献。

      第3章“以数据产品为中心的架构”探讨了数据产品中心化架构的基本原则,分析了管理该架构所需的关键运营能力和组织能力。同时,我们将数据即产品范式与数据网格、数据织物等现代方法进行对比,以凸显它们之间的共同点和关键差异。

      第4章“识别数据产品并确定开发优先级”阐述了如何采用价值导向的方法来识别数据产品并确定其开发优先次序。本章首先通过领域驱动设计和事件风暴方法识别相关业务场景,继而详细说明如何定义支撑这些业务场景所需的数据产品。

      第5章“设计与实施数据产品”探讨了如何基于已识别的需求来设计数据产品,首先介绍了定义产品范围、接口和生态系统关系的相关技术。接着深入探讨了数据产品的核心组件、其开发流程以及如何通过机器可读文档进行描述。最后,对数据流进行了分析,重点阐述了负责数据获取、处理和服务的各个组件。

      第6章“在生产环境中运维数据产品”涵盖了数据产品从发布到退役的完整生命周期。本章介绍了CI/CD方法论,深入探讨了数据产品在生产环境中的管理,重点阐述了治理、可观察性和访问控制等方面,并探讨了在分布式环境中数据产品的演进和复用技术。

      第7章“自动化数据产品生命周期管理”阐述了如何通过构建自助服务平台来调动整个数据生态系统的力量,从而加速数据产品中心范式的落地。本章详细介绍了平台的核心功能特性,探讨了如何优化开发者、运营人员和用户的使用体验,并深入分析了在平台实施过程中选择自建、外购或混合方案的关键决策因素。

      第8章“数据产品化的实践历程”阐述了数据即产品范式的实施过程。本章概述了实施过程的关键阶段,深入探讨了每个阶段的具体目标、面临的挑战以及相关活动。最后,探讨了如何制定灵活的数据战略,使其能够随着各个阶段的推进而不断演进,并有效利用前期积累的经验教训。

      第9章“团队拓扑与规模化数据所有权”阐述了如何构建组织架构以实现数据即产品的管理模式。本章首先介绍了团队拓扑框架,详细探讨了团队类型与交互模式,并深入研究了如何组织团队以实现数据产品的高效交付。最后,重点探讨了这些团队如何融入组织架构,以及如何在集中式与分散式数据管理模型之间做出战略选择。

      第10章“分布式数据建模”探讨了在去中心化、以数据产品为核心的架构中的数据建模方法。本章首先界定了数据模型的概念并强调了建模的目的性,继而探究了适用于分布式环境的物理建模技术。最后,阐述了概念数据建模在指导数据产品设计与演进过程中的重要作用,以及如何在统一的生态系统中实现这一目标。

      第11章“构建面向AI的信息架构”探讨了如何构建信息架构以充分发挥数据产品的管理价值。本章阐述了信息架构的各个层面如何为数据赋予上下文含义,特别聚焦于知识层面,详细说明共享概念模型如何确保数据产品之间的语义互操作性。最后,本章探讨了联邦建模团队如何创建概念模型并将其与物理数据关联,从而构建企业知识图谱,这对于释放生成式AI的潜力具有关键作用。

      第12章"融会贯通"回顾了前几章的关键概念,并将其与启发本书写作的数据管理核心理念紧密联系。最后还提供了一些实用建议,帮助读者在数据管理实践中取得更大的成功。

      【关联阅读】

      《本体驱动的AI大模型》作者序

      《一书读懂物联网》作者序

      MCP的新特性——代码执行

      AI 会写 SQL 之后,为什么还要读《分布式数据库》?

      性能狂飙?关于《分布式系统性能优化:方法与实践》

      大模型应用的性能提升:语义缓存

      读《Agentic 多智能体架构模式》

      大模型的性能提升:KV-Cache

      《深入分布式缓存》的往事

      Token 工厂?财富新范式!

      拥抱“兼具并融”的未来——《AI领导力》译者序

      忆北邮同学生活及《超密集无线网络》译者序

      网络那些事儿!暨《深入剖析Wi-Fi7》译者序

      让算法真正产生价值?《算法工程珠玑》译者序

      了解大模型的背后,知其然进而所以然(《深度学习黑箱》译者序)

      质量属性?!《软件架构设计:实用方法及实践》译者序

      《实时分析实战》译者序

      《基础设施即代码(IaC)》译者序

      《精益DevOps》译者序

      《语音优先》智能语音技术驱动的交互界面设计与语音机器人设计(译者序)

      《 持续架构实践 》译者序

      《基于混合方法的自然语言处理》译者序

      计算机网络的元认知、实践与未来(《计算机网络问题与解决方案》的译者序)

      Web3.0,区块链后花园的姹紫嫣红(《区块链应用开发实战》译者序)

      架构设计过程中的10点体会

      来了!10个构建Agent的大模型应用框架

      大模型应用的10个架构挑战

      跳转微信打开

      ❌