Spring AI Alibaba 1.x 系列【30】Nacos Skill Registry 的底层设计与实现

云烟成雨TD2026-04-23 13:00

文章目录

  • [1 概述](#1 概述)
  • [2 模块架构](#2 模块架构)
    • [2.1 概览](#2.1 概览)
    • [2.2 模块依赖关系详解](#2.2 模块依赖关系详解)
      • [2.2.1 模块依赖层次图](#2.2.1 模块依赖层次图)
    • [2.3 各子模块详细说明](#2.3 各子模块详细说明)
      • [2.3.1 核心模块](#2.3.1 核心模块)
      • [2.3.2 SPI 插件模块](#2.3.2 SPI 插件模块)
      • [2.3.3 SPI 默认实现模块](#2.3.3 SPI 默认实现模块)
      • [2.3.4 客户端模块](#2.3.4 客户端模块)
      • [2.3.5 服务端模块](#2.3.5 服务端模块)
    • [2.4 模块依赖传递链](#2.4 模块依赖传递链)
    • [2.5 ai 模块内部包结构](#2.5 ai 模块内部包结构)
    • [2.6 api 模块 Skill 相关结构](#2.6 api 模块 Skill 相关结构)
    • [2.7 console 模块 Skill 相关结构](#2.7 console 模块 Skill 相关结构)
    • [2.8 maintainer-client 模块 Skill 相关结构](#2.8 maintainer-client 模块 Skill 相关结构)
  • [3 核心源码分析](#3 核心源码分析)
    • [3.1 数据模型](#3.1 数据模型)
      • [3.1.1 数据库表结构](#3.1.1 数据库表结构)
      • [3.1.2 version_info JSON 结构](#3.1.2 version_info JSON 结构)
      • [3.1.3 storage JSON 结构](#3.1.3 storage JSON 结构)
      • [3.1.4 Skill 索引清单 (SkillIndexManifest)](#3.1.4 Skill 索引清单 (SkillIndexManifest))
    • [3.2 存储层架构](#3.2 存储层架构)
      • [3.2.1 存储抽象设计](#3.2.1 存储抽象设计)
      • [3.2.2 StorageKey 解析逻辑](#3.2.2 StorageKey 解析逻辑)
    • [3.3 版本治理机制](#3.3 版本治理机制)
      • [3.3.1 版本状态流转](#3.3.1 版本状态流转)
      • [3.3.2 版本状态常量](#3.3.2 版本状态常量)
      • [3.3.3 CAS 更新机制](#3.3.3 CAS 更新机制)
    • [3.4 发布审核 Pipeline](#3.4 发布审核 Pipeline)
      • [3.4.1 Pipeline 架构](#3.4.1 Pipeline 架构)
      • [3.4.2 Pipeline 执行流程](#3.4.2 Pipeline 执行流程)
      • [3.4.3 Pipeline 回调处理](#3.4.3 Pipeline 回调处理)
    • [3.5 索引清单服务](#3.5 索引清单服务)
      • [3.5.1 SkillIndexManifestService](#3.5.1 SkillIndexManifestService)
      • [3.5.2 索引清单更新时机](#3.5.2 索引清单更新时机)
    • [3.6 可见性控制](#3.6 可见性控制)
      • [3.6.1 VisibilityHelper](#3.6.1 VisibilityHelper)
      • [3.6.2 可见性规则](#3.6.2 可见性规则)
  • [4 核心执行流程](#4 核心执行流程)
    • [4.1 Skill 上传流程 (uploadSkillFromZip)](#4.1 Skill 上传流程 (uploadSkillFromZip))
    • [4.2 Skill 发布流程 (submit → publish)](#4.2 Skill 发布流程 (submit → publish))
    • [4.3 Skill 查询流程 (querySkill - 客户端)](#4.3 Skill 查询流程 (querySkill - 客户端))
  • [5 API 接口清单](#5 API 接口清单)
    • [5.1 Admin API (`/v3/admin/ai/skills`)](#5.1 Admin API (/v3/admin/ai/skills))
    • [5.2 Client API (`/v3/client/ai/skills`)](#5.2 Client API (/v3/client/ai/skills))
  • [6 SPI 扩展点](#6 SPI 扩展点)
    • [6.1 存储扩展 (AiResourceStorage)](#6.1 存储扩展 (AiResourceStorage))
    • [6.2 发布审核扩展 (PublishPipelineService)](#6.2 发布审核扩展 (PublishPipelineService))
    • [6.3 可见性扩展 (VisibilityService)](#6.3 可见性扩展 (VisibilityService))
  • [7 配置项](#7 配置项)
  • [8 设计亮点](#8 设计亮点)
    • [8.1 双层存储架构](#8.1 双层存储架构)
    • [8.2 CAS 乐观锁](#8.2 CAS 乐观锁)
    • [8.3 Pipeline 发布审核](#8.3 Pipeline 发布审核)
    • [8.4 索引清单分离](#8.4 索引清单分离)
  • [9 总结](#9 总结)

1 概述

Nacos Skill Registry是Nacos 3.2.0版本引入的AI Agent注册中心核心组件，用于管理和分发Claude Code Skills（AI技能包）。它提供了完整的Skill生命周期管理能力，包括上传、版本治理、发布审核、上线/下线、可见性控制等功能。

Nacos Skill Registry 作为企业级智能体技能管理方案，安全可控、与微服务生态融合度高是其核心优势。但是它和 Nacos 是深度绑定关系。在实际企业级智能体管理平台开发中，推荐参考借鉴，设计开发一套属于企业自己的智能体技能管理平台。接下来，分析下其底层设计与实现。

核心能力：

能力 说明
Skill 存储 支持Skill ZIP包上传，包含SKILL.md和资源文件
版本治理 完整的版本生命周期：Draft → Reviewing → Online/Offline
发布审核 可配置的Pipeline发布审核流程，支持SPI扩展
索引发现 基于Nacos Config的索引清单机制，支持客户端快速发现
可见性控制 PUBLIC/PRIVATE可见范围，支持权限控制
统计追踪 下载次数统计、操作审计日志

2 模块架构

2.1 概览

Nacos Skill Registry作为AI Agent注册中心的核心功能，涉及Nacos项目中的15+个子模块，按功能层次可分为六大类：

复制代码 
┌─────────────────────────────────────────────────────────────────────────────┐
│                        Skill Registry 模块全景图                              │
├─────────────────────────────────────────────────────────────────────────────┤
│  第一层：API 定义层                                                           │
│  ┌─────────────────────────────────────────────────────────────────────────┐ │
│  │  `api`                 - Skill 模型定义、proto、公共接口                   │ │
│  └─────────────────────────────────────────────────────────────────────────┘ │
│                              ↓                                               │
│  第二层：SPI 插件接口层                                                       │
│  ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌────────────┐              │ │
│  │`plugin/ai`│ │`plugin/`│ │`plugin/`│ │`plugin/`│              │ │
│  │            │ │`visibility`│ │`auth`│ │`datasource`│              │ │
│  │ 存储/审核   │ │ 可见性SPI  │ │ 权限SPI    │ │ 数据源SPI  │              │ │
│  └────────────┘ └────────────┘ └────────────┘ └────────────┘              │ │
│                              ↓                                               │
│  第三层：核心业务层                                                           │
│  ┌─────────────────────────────────────────────────────────────────────────┐ │
│  │  `ai`                  - Skill Registry 核心实现                           │ │
│  │  `config`              - Nacos Config 服务（文件存储后端）                  │ │
│  │  `auth`                - 权限验证                                           │ │
│  └─────────────────────────────────────────────────────────────────────────┘ │
│                              ↓                                               │
│  第四层：SPI 默认实现层                                                       │
│  ┌────────────┐ ┌────────────────────────┐ ┌────────────────┐            │ │
│  │`plugin-`│ │`nacos-default-`│ │`nacos-default-`│            │ │
│  │`default-impl`│ │`ai-pipeline-plugin`│ │`datasource-`│            │ │
│  │            │ │ SkillScanner审核       │ │`plugin`│            │ │
│  │ 默认实现包  │ │                        │ │ MySQL/Derby等  │            │ │
│  └────────────┘ └────────────────────────┘ └────────────────┘            │ │
│                              ↓                                               │
│  第五层：基础设施层                                                           │
│  ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌────────────┐              │ │
│  │`common`│ │`core`│ │`persistence`│ │`sys`│              │ │
│  │ 通用工具    │ │ 核心框架    │ │ 数据持久化  │ │ 系统配置    │              │ │
│  └────────────┘ └────────────┘ └────────────┘ └────────────┘              │ │
│                              ↓                                               │
│  第六层：客户端与控制台层                                                     │
│  ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌────────────┐              │ │
│  │`client`│ │`client-basic`│ │`maintainer`│ │`console`│              │ │
│  │ SDK接口    │ │ SDK基础实现 │ │`-client`│ │ 控制台API  │              │ │
│  └────────────┘ └────────────┘ └────────────┘ └────────────┘              │ │
│                              ↓                                               │
│  第七层：服务器组装层                                                         │
│  ┌─────────────────────────────────────────────────────────────────────────┐ │
│  │  `server`              - Nacos Server 聚合启动                             │ │
│  │  `distribution`        - 发布打包                                          │ │
│  └─────────────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────────────┘

2.2 模块依赖关系详解

2.2.1 模块依赖层次图

复制代码 
┌─────────────────────────────────────────────────────────────────────┐
│                         `api` (接口层)                                  │
│  [Maven: `nacos-api`]                                                  │
│  - `Skill/SkillBase/SkillSummary/SkillMeta/SkillResource` 模型定义     │
│  - `SkillUtils` 工具类                                                 │
│  - `proto` 定义                                                        │
│  - `Java 8` 兼容                                                       │
└─────────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────────┐
│                     `plugin/ai` (SPI 插件层)                           │
│  [Maven: `nacos-ai-plugin`]                                            │
│  依赖: `api`, `common`                                                   │
│  - `AiResourceStorage` (存储 SPI)                                      │
│  - `PublishPipelineService` (发布审核 SPI)                             │
│  - `StorageKey` 存储键模型                                              │
│  - `PublishPipelineContext` 上下文模型                                  │
└─────────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────────┐
│                   `plugin/visibility` (可见性 SPI)                      │
│  [Maven: `nacos-visibility-plugin`]                                    │
│  依赖: `common`                                                        │
│  - `VisibilityService` 可见性服务接口                                   │
│  - `VisibilityResource` 资源模型                                       │
│  - `QueryAdvisor` 查询顾问模型                                         │
└─────────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────────┐
│                          `ai` (核心模块)                                │
│  [Maven: `nacos-ai`]                                                   │
│  依赖: `common`, `naming`, `config`, `ai-plugin`, `visibility-plugin`         │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐   │
│  │`controller`│ │`service`│ │`storage`│ │`pipeline`│   │
│  │ Admin API   │ │ 业务逻辑     │ │ 存储实现     │ │ 发布审核     │   │
│  │ Client API  │ │ 版本治理     │ │`NacosConfig`│ │ 执行引擎     │   │
│  └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘   │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐   │
│  │`model`│ │`repository`│ │`config`│ │`visibility`│   │
│  │ 数据实体     │ │ 持久化服务   │ │ 初始化配置   │ │ 可见性控制   │   │
│  └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘   │
└─────────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────────┐
│                 `plugin-default-impl` (默认实现)                        │
│  ┌────────────────────────────────────────────────────────────┐     │
│  │`nacos-default-ai-pipeline-plugin`│     │
│  │ 依赖: `ai-plugin`, `common`                                     │     │
│  │ - `SkillScannerPipelineService`: Skill 内容扫描审核           │     │
│  │ - `SkillScannerMarkdownFindingParser`: `Markdown` 解析         │     │
│  └────────────────────────────────────────────────────────────┘     │
│  ┌────────────────────────────────────────────────────────────┐     │
│  │`nacos-default-datasource-plugin`│     │
│  │ - `MySQL/Derby/PostgreSQL/Oracle` 数据库 `Schema`              │     │
│  │ - `ai_resource / ai_resource_version` 表定义                  │     │
│  └────────────────────────────────────────────────────────────┘     │
└─────────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────────┐
│                      `config / persistence`                            │
│  [Maven: `nacos-config`] / [Maven: `nacos-persistence`]                 │
│  - `ConfigOperationService`: 配置发布服务                              │
│  - `ConfigQueryChainService`: 配置查询链                               │
│  - `AiResourceMapper`: 数据库操作                                      │
│  - 数据库`Schema`定义                                                │
└─────────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────────┐
│                      `common / core / sys`                              │
│  [Maven: `nacos-common`] / [Maven: `nacos-core`] / [Maven: `nacos-sys`]   │
│  - `JacksonUtils`: `JSON` 工具                                          │
│  - `NotifyCenter`: 事件通知中心                                        │
│  - `ExecutorUtils`: 线程池                                             │
│  - `VersionUtils`: 版本号解析                                          │
│  - `EnvUtil`: 环境配置                                                 │
└─────────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────────┐
│                    `console / maintainer-client`                        │
│  [Maven: `nacos-console`] / [Maven: `nacos-maintainer-client`]          │
│  依赖: `ai`                                                           │
│  - `ConsoleSkillController`: 控制台 Skill API                          │
│  - `SkillHandler / SkillProxy`: `Handler-Proxy` 模式                    │
│  - `SkillMaintainerService`: 维护客户端 SDK                            │
│  - `SkillMaintainerServiceImpl`: `HTTP/gRPC` 实现                        │
└─────────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────────┐
│                    `client / client-basic`                              │
│  [Maven: `nacos-client`] / [Maven: `nacos-client-basic`]                │
│  - `Java 8` 兼容                                                       │
│  - 客户端 SDK 基础设施                                               │
│  - `HTTP/gRPC` 客户端                                                  │
└─────────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────────┐
│                      `server / distribution`                            │
│  [Maven: `nacos-server`] / [Maven: `nacos-distribution`]                │
│  - `Spring Boot` 聚合启动                                              │
│  - 打包发布                                                          │
└─────────────────────────────────────────────────────────────────────┘

2.3 各子模块详细说明

2.3.1 核心模块

模块 Maven Artifact 依赖 Skill Registry 作用
api nacos-api 无 Skill模型定义（Skill, SkillBase, SkillSummary, SkillMeta, SkillResource, SkillUtils）
ai nacos-ai common, config, naming, ai-plugin, visibility-plugin Skill Registry核心实现 ，包含controller/service/storage/pipeline/model/repository
config nacos-config common, persistence Nacos Config服务，作为Skill文件存储后端
persistence nacos-persistence common 数据持久化基础设施，数据库Mapper
common nacos-common 无 JacksonUtils、NotifyCenter、StringUtils等通用工具
core nacos-core common RequestContextHolder、参数校验、线程池
sys nacos-sys common EnvUtil环境配置读取

2.3.2 SPI 插件模块

模块 Maven Artifact 依赖 Skill Registry 作用
plugin/ai nacos-ai-plugin api, common AiResourceStorage存储SPI、PublishPipelineService审核SPI、StorageKey模型
plugin/visibility nacos-visibility-plugin common VisibilityService可见性SPI、VisibilityResource模型、QueryAdvisor
plugin/auth nacos-auth-plugin common, api 权限验证SPI（@Secured注解支持）
plugin/datasource nacos-datasource-plugin common 数据源SPI

2.3.3 SPI 默认实现模块

模块 Maven Artifact 依赖 Skill Registry 作用
nacos-default-ai-pipeline-plugin 子模块 ai-plugin, common SkillScannerPipelineService: Skill内容扫描审核默认实现
nacos-default-datasource-plugin 父模块 datasource-plugin MySQL/Derby/PostgreSQL/Oracle数据库实现，包含ai_resource表Schema
nacos-default-auth-plugin 子模块 auth-plugin 默认权限验证实现

2.3.4 客户端模块

模块 Maven Artifact 依赖 Skill Registry 作用
client nacos-client client-basic 客户端SDK公共接口
client-basic nacos-client-basic api, common Java 8兼容的SDK基础实现（HTTP/gRPC）
maintainer-client nacos-maintainer-client common, client-basic SkillMaintainerService维护客户端SDK
console nacos-console ai, config, naming, core, maintainer-client ConsoleSkillController控制台API、SkillHandler/SkillProxy

2.3.5 服务端模块

模块 Maven Artifact 依赖 Skill Registry 作用
server nacos-server 所有核心模块 Spring Boot聚合启动，Skill Registry服务入口
distribution nacos-distribution server 打包发布，生成nacos-server-*.zip
bootstrap nacos-bootstrap common 启动引导

2.4 模块依赖传递链

复制代码 
Skill 客户端调用链:
`client` → `client-basic` → `api` → (Skill 模型)

Skill 服务端调用链:
`server` → `console` → `ai` → `config` → `persistence` → `common`
                  ↓
                `plugin/ai` → `plugin-default-impl/nacos-default-ai-pipeline-plugin`
                  ↓
                `plugin/visibility` → (可见性验证)

Skill 维护客户端调用链:
`maintainer-client` → `client-basic` → `api` → (Skill 模型)
                 → `common` → (`HTTP/gRPC` 客户端)

2.5 ai 模块内部包结构

包路径 核心文件 作用
controller SkillAdminController, SkillClientController REST API入口
service/skills SkillOperationServiceImpl, SkillIndexManifestService Skill业务逻辑
service/repository AiResourcePersistService, AiResourceVersionPersistService 数据持久化
service/resource AiResourceManager 通用资源管理器（Skill/AgentSpec共享）
service VisibilityHelper 可见性权限控制
storage NacosConfigAiResourceStorage 基于Nacos Config的文件存储
pipeline PublishPipelineExecutor, PublishPipelineManager 发布审核流程执行
pipeline/repository PipelineExecutionRepository Pipeline执行记录存储
model AiResource, AiResourceVersion 数据库实体
model/skills SkillIndexManifest Skill索引清单模型
config AiResourceStorageInitializer, SkillDataBootstrapInitializer, PipelineConfiguration Spring配置
form/skills SkillForm, SkillListForm, SkillDraftCreateForm API表单
param SkillHttpParamExtractor HTTP参数提取
event SkillDownloadEvent 下载事件
utils SkillZipParser, SkillRequestUtil, ExecutorUtils 工具类

2.6 api 模块 Skill 相关结构

包路径 核心文件 作用
api/ai/model/skills Skill, SkillBase, SkillSummary, SkillMeta, SkillResource, SkillBasicInfo, SkillUtils Skill模型定义
api/ai/model/agentspecs AgentSpec, AgentSpecUtils AgentSpec模型（类似Skill）
api/ai/model/prompt Prompt, PromptUtils Prompt模型（类似Skill）
api/model/v2 Result, ErrorCode API响应包装
api/model Page, NacosForm 分页、表单模型

2.7 console 模块 Skill 相关结构

包路径 核心文件 作用
controller/v3/ai ConsoleSkillController 控制台Skill API
handler/ai SkillHandler Handler接口
handler/impl/inner/ai SkillInnerHandler 内部模式实现
handler/impl/remote/ai SkillRemoteHandler 远程模式实现
handler/impl/noop/ai SkillNoopHandler 空实现
proxy/ai SkillProxy Handler代理

2.8 maintainer-client 模块 Skill 相关结构

包路径 核心文件 作用
ai SkillMaintainerService, SkillMaintainerServiceImpl Skill维护客户端SDK
ai AiMaintainerService, NacosAiMaintainerServiceImpl AI模块统一维护接口

3 核心源码分析

3.1 数据模型

3.1.1 数据库表结构

ai_resource表（元数据表）:

sql 复制代码 
CREATE TABLE `ai_resource` (
    `id` bigint(20) NOT NULL AUTO_INCREMENT,
    `gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
    `gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
    `name` varchar(256) NOT NULL COMMENT '资源名称',
    `type` varchar(32) NOT NULL COMMENT '资源类型(skill/agentspec)',
    `c_desc` varchar(2048) DEFAULT NULL COMMENT '描述',
    `status` varchar(32) DEFAULT NULL COMMENT 'enable/disable',
    `namespace_id` varchar(128) NOT NULL DEFAULT '',
    `biz_tags` varchar(1024) DEFAULT NULL COMMENT '业务标签JSON',
    `ext` longtext DEFAULT NULL COMMENT '扩展信息',
    `c_from` varchar(256) NOT NULL DEFAULT 'local' COMMENT '来源标识',
    `version_info` longtext DEFAULT NULL COMMENT '版本信息JSON',
    `meta_version` bigint(20) NOT NULL DEFAULT 1 COMMENT '乐观锁版本',
    `scope` varchar(16) NOT NULL DEFAULT 'PRIVATE' COMMENT 'PUBLIC/PRIVATE',
    `owner` varchar(128) NOT NULL DEFAULT '' COMMENT '创建者',
    `download_count` bigint(20) NOT NULL DEFAULT 0 COMMENT '下载次数',
    PRIMARY KEY (`id`),
    UNIQUE KEY `uk_ai_resource_ns_name_type` (`namespace_id`,`name`,`type`,`c_from`)
);

ai_resource_version表（版本表）:

sql 复制代码 
CREATE TABLE `ai_resource_version` (
    `id` bigint(20) NOT NULL AUTO_INCREMENT,
    `gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
    `gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
    `type` varchar(32) NOT NULL COMMENT '资源类型',
    `author` varchar(128) DEFAULT NULL COMMENT '作者',
    `name` varchar(256) NOT NULL COMMENT '资源名称',
    `c_desc` varchar(2048) DEFAULT NULL COMMENT '版本描述',
    `status` varchar(32) NOT NULL COMMENT 'draft/reviewing/online/offline',
    `version` varchar(64) NOT NULL COMMENT '版本号',
    `namespace_id` varchar(128) NOT NULL DEFAULT '',
    `storage` longtext DEFAULT NULL COMMENT '存储信息JSON',
    `publish_pipeline_info` longtext DEFAULT NULL COMMENT 'Pipeline审核信息',
    `download_count` bigint(20) NOT NULL DEFAULT 0,
    PRIMARY KEY (`id`),
    UNIQUE KEY `uk_ai_resource_ver_ns_name_type_ver` (`namespace_id`,`name`,`type`,`version`)
);

3.1.2 version_info JSON 结构

存储在ai_resource.version_info字段中：

json 复制代码 
{
    "labels": {
        "latest": "v3",
        "stable": "v2"
    },
    "editingVersion": "v4",
    "reviewingVersion": null,
    "onlineCnt": 2
}
字段 说明
labels 版本标签映射，用于路由（如latest、stable）
editingVersion 当前正在编辑的草稿版本
reviewingVersion 当前处于审核流程的版本
onlineCnt 已上线版本数量

3.1.3 storage JSON 结构

存储在ai_resource_version.storage字段中：

json 复制代码 
{
    "provider": "nacos_config",
    "scope": "namespaceId:skillName:version",
    "files": ["SKILL.md", "script/run.sh", "template/result.json"]
}
字段 说明
provider 存储提供者标识（如nacos_config、oss）
scope 存储范围标识
files 该版本包含的所有文件列表

3.1.4 Skill 索引清单 (SkillIndexManifest)

存储在Nacos Config：group=skill_{name}, dataId=skill_index.json

json 复制代码 
{
    "labels": {
        "latest": "v3",
        "stable": "v2"
    },
    "versions": {
        "v1": ["SKILL.md"],
        "v2": ["SKILL.md", "script/run.sh"],
        "v3": ["SKILL.md", "script/run.sh", "template/result.json"]
    }
}

作用 : 作为客户端Skill发现的唯一数据源，轻量级索引用于快速定位版本和文件。

3.2 存储层架构

3.2.1 存储抽象设计

复制代码 
┌─────────────────────────────────────────────────────────────────┐
│                      `AiResourceStorageRouter`                     │
│  (全局路由器/门面，单例模式)                                        │
│  - `route(StorageKey)` → `AiResourceStorage`                        │
│  - `join(AiResourceStorage)` 注册存储实现                          │
│  - `ConcurrentHashMap` 缓存所有存储实现                            │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│                   `StorageKey` (统一存储键)                         │
│  {`provider`: "nacos_config",                                     │
│   `key`: "namespaceId:resourceType:name:version:filePath"}        │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│              `NacosConfigAiResourceStorage` (默认实现)              │
│  基于`Nacos Config`的文件存储                                     │
│  - `save()`: 写入文件内容到`Nacos Config`                           │
│  - `get()`: 读取文件内容                                           │
│  - `delete()`: 删除配置项                                          │
│                                                                  │
│  Key 解析规则:                                                    │
│  - 5-part: `namespaceId:type:name:version:filePath`               │
│  → `group = {prefix}{name}__{version}`                            │
│  → `dataId = filePath`                                            │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│                     `Nacos Config Server`                          │
│  配置存储引擎，支持`MySQL/Derby/PostgreSQL`后端                   │
└─────────────────────────────────────────────────────────────────┘

3.2.2 StorageKey 解析逻辑

源码位置 : NacosConfigAiResourceStorage.java:255-301

java 复制代码 
// 5-part typed format: `namespaceId:resourceType:name:version:filePath`
String[] parts = storageKey.getKey().split(":", 5);
String namespaceId = parts[0];
String resourceType = parts[1];  // `skill`, `agentspec`, `prompt`
String name = parts[2];
String version = parts[3];
String filePath = parts[4];

// 根据`resourceType`确定group前缀
String group;
if (RESOURCE_TYPE_SKILL.equals(resourceType)) {
    group = SkillUtils.buildSkillVersionGroup(name, version);  // `skill__{name}__{version}`
} else if (RESOURCE_TYPE_AGENTSPEC.equals(resourceType)) {
    group = AgentSpecUtils.buildAgentSpecVersionGroup(name, version);
}
// 最终存储: `group` + `dataId(filePath)` + `namespaceId`

3.3 版本治理机制

3.3.1 版本状态流转

复制代码 
                         ┌────────────────┐
                         │   `DRAFT`        │ ← 创建草稿
                         │  (草稿状态)     │
                         └────────────────┘
                                │ `submit()`
                                ↓
                         ┌────────────────┐
                         │  `REVIEWING`     │ ← 提交审核
                         │  (审核中)       │
                         └────────────────┘
                    ┌──────────┴──────────┐
                    │                     │
            `Pipeline`│                     │`forcePublish`
            `APPROVED`│                     │(管理员强制发布)
                    ↓                     ↓
              ┌────────────────┐   ┌────────────────┐
              │    `ONLINE`      │   │    `ONLINE`      │
              │   (已上线)      │   │   (已上线)      │
              └────────────────┘   └────────────────┘
                    │ `offline()`         │
                    ↓                   │
              ┌────────────────┐       │
              │   `OFFLINE`      │ ←─────┘
              │   (已下线)      │
              └────────────────┘

3.3.2 版本状态常量

源码位置 : AiResourceConstants.java

java 复制代码 
// 元数据状态
public static final String META_STATUS_ENABLE = "enable";     // `Skill`全局启用
public static final String META_STATUS_DISABLE = "disable";   // `Skill`全局禁用

// 版本状态
public static final String VERSION_STATUS_DRAFT = "draft";      // 草稿
public static final String VERSION_STATUS_REVIEWING = "reviewing"; // 审核中
public static final String VERSION_STATUS_ONLINE = "online";    // 已上线
public static final String VERSION_STATUS_OFFLINE = "offline";  // 已下线

// 其他常量
public static final int MAX_WORKING_VERSION_RETRY = 3;  // `CAS`更新最大重试次数
public static final String LABEL_LATEST = "latest";      // 最新版本标签

3.3.3 CAS 更新机制

源码位置 : AiResourceManager.java:117-132

java 复制代码 
CasResult doCasLoop(String namespaceId, String name, String type, long initialExpected,
        AiResource newValue, BiConsumer<AiResource, AiResource> onConflictRefresh) {
    long expected = initialExpected;
    for (int i = 0; i < AiResourceConstants.MAX_WORKING_VERSION_RETRY; i++) {
        // 使用`meta_version`作为乐观锁
        if (aiResourcePersistService.updateMetaCas(namespaceId, name, type, expected, newValue)) {
            return CasResult.SUCCESS;
        }
        // `CAS`失败，重新加载最新数据
        AiResource latest = aiResourcePersistService.find(namespaceId, name, type);
        expected = latest.getMetaVersion();
        // 回调刷新非目标字段
        onConflictRefresh.accept(newValue, latest);
    }
    return CasResult.MAX_RETRIES;
}

设计要点:

  • 使用meta_version字段作为乐观锁
  • 最大重试3次
  • 冲突时保留用户修改的目标字段，刷新其他字段
  • 适用于高并发场景下的versionInfo、bizTags、status等字段更新

3.4 发布审核 Pipeline

3.4.1 Pipeline 架构

复制代码 
┌─────────────────────────────────────────────────────────────────┐
│                    `PublishPipelineExecutor`                       │
│  (核心执行引擎)                                                   │
│  - 异步串行执行`Pipeline`节点                                     │
│  - 持久化执行状态                                                 │
│  - 回调通知完成状态                                               │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│                    `PublishPipelineManager`                        │
│  (`Pipeline`服务管理)                                              │
│  - `SPI`加载`PublishPipelineService`实现                          │
│  - 按`pipelineId`缓存                                            │
│  - 按`preferOrder`排序执行节点                                   │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│                 `PipelineConfigProvider`                           │
│  (配置提供者)                                                     │
│  - `FilePipelineConfigProvider`: 从文件加载配置                    │
│  - 控制`Pipeline`是否启用、节点列表                               │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│                 `PublishPipelineService` (SPI)                     │
│  (审核节点服务)                                                   │
│  - `SkillScannerPipelineService`: Skill 内容扫描审核               │
│  - 自定义`SPI`扩展                                                │
└─────────────────────────────────────────────────────────────────┘

3.4.2 Pipeline 执行流程

源码位置 : PublishPipelineExecutor.java:97-209

java 复制代码 
public String execute(PublishPipelineContext context, PipelineCallback callback, String executionId) {
    // Step 1: 检查配置是否启用
    PipelineConfig config = configProvider.getConfig();
    if (!config.isEnabled()) {
        return null;  // `Pipeline`未启用，直接发布
    }
    
    // Step 2: 获取匹配的`Pipeline`服务节点
    List<PublishPipelineService> services = pipelineManager.getPipelineServices(
            context.getResourceType(), config.getNodes());
    if (services.isEmpty()) {
        return null;  // 无匹配节点，直接发布
    }
    
    // Step 3: 创建执行记录
    PipelineExecution execution = new PipelineExecution();
    execution.setExecutionId(executionId);
    execution.setStatus(PipelineExecutionStatus.IN_PROGRESS);
    executionRepository.save(execution);
    
    // Step 4: 异步执行节点串行审核
    asyncExecutor.submit(() -> {
        boolean allPassed = true;
        for (PublishPipelineService service : services) {
            PipelineNodeResult nodeResult = service.execute(context);
            execution.getPipeline().add(nodeResult);
            executionRepository.update(execution);
            if (!nodeResult.isPassed()) {
                allPassed = false;
                break;  // 失败则终止后续节点
            }
        }
        
        // Step 5: 设置最终状态并回调
        execution.setStatus(allPassed ? APPROVED : REJECTED);
        executionRepository.update(execution);
        callback.onComplete(result);
    });
    
    return executionId;
}

3.4.3 Pipeline 回调处理

源码位置 : AiResourceManager.java:997-1033

java 复制代码 
public void onPipelineComplete(String namespaceId, String name, String type, String version,
        PipelineExecutionResult result) {
    // 更新版本`Pipeline`信息
    PublishPipelineInfo info = new PublishPipelineInfo();
    info.setExecutionId(result.getExecutionId());
    info.setStatus(result.getStatus());
    info.setPipeline(result.getPipeline());
    aiResourceVersionPersistService.updatePublishPipelineInfo(...);
    
    if (result.getStatus() != APPROVED) {
        // 审核拒绝：回滚到`Draft`状态
        aiResourceVersionPersistService.updateStatus(..., VERSION_STATUS_DRAFT);
        // 更新meta: `reviewingVersion` → `editingVersion`
        ResourceVersionInfo vInfo = requireVersionInfo(meta);
        vInfo.setReviewingVersion(null);
        vInfo.setEditingVersion(version);
        updateVersionInfoCas(...);
    } else {
        // 审核通过：等待管理员手动`publish`
        // 版本状态保持`reviewing`，由`publish()`接口上线
    }
}

3.5 索引清单服务

3.5.1 SkillIndexManifestService

源码位置 : SkillIndexManifestService.java

java 复制代码 
@Service
public class SkillIndexManifestService {
    
    // 存储: `group=skill_{skillName}`, `dataId=skill_index.json`
    private static final String INDEX_DATA_ID = SkillUtils.SKILL_INDEX_DATA_ID;
    
    // 查询清单
    public SkillIndexManifest query(String namespaceId, String skillName) {
        ConfigQueryChainRequest request = ConfigQueryChainRequest.build(
                INDEX_DATA_ID, SkillUtils.buildSkillGroup(skillName), namespaceId);
        ConfigQueryChainResponse response = configQueryChainService.handle(request);
        return JacksonUtils.toObj(response.getContent(), SkillIndexManifest.class);
    }
    
    // 写入清单（创建或更新）
    public void write(String namespaceId, String skillName, SkillIndexManifest manifest) {
        ConfigForm form = new ConfigForm();
        form.setDataId(INDEX_DATA_ID);
        form.setGroup(SkillUtils.buildSkillGroup(skillName));
        form.setContent(JacksonUtils.toJson(manifest));
        configOperationService.publishConfig(form, requestInfo, null);
    }
    
    // 删除清单（Skill下线或删除时）
    public void delete(String namespaceId, String skillName) {
        configOperationService.deleteConfig(INDEX_DATA_ID,
                SkillUtils.buildSkillGroup(skillName), namespaceId, ...);
    }
    
    // 版本解析: explicit version > label lookup > latest label
    public static String resolveVersion(SkillIndexManifest manifest, String version, String label) {
        if (StringUtils.isNotBlank(version)) {
            return manifest.getVersions().containsKey(version) ? version : null;
        }
        String labelKey = StringUtils.isNotBlank(label) ? label : LABEL_LATEST;
        return manifest.getLabels().get(labelKey);
    }
}

3.5.2 索引清单更新时机

操作 索引清单行为
publish() 添加版本到versions映射，更新latest标签
offline(version) 从versions映射移除该版本
online(skill scope) 重建索引清单（从所有online版本）
offline(skill scope) 删除索引清单
deleteSkill() 删除索引清单
updateLabels() 同步labels到索引清单

3.6 可见性控制

3.6.1 VisibilityHelper

源码位置 : VisibilityHelper.java

java 复制代码 
public class VisibilityHelper {
    
    // 解析当前用户身份
    public static String resolveCurrentIdentity() {
        IdentityContext identity = RequestContextHolder.getContext()
                .getAuthContext().getIdentityContext();
        return identity.getParameter(Constants.Identity.IDENTITY_ID).toString();
    }
    
    // 检查读权限
    public static boolean canReadResource(VisibilityResource resource) {
        VisibilityService service = findVisibilityService();
        ValidationResult result = service.validateVisibility(
                resolveCurrentIdentity(), ACTION_READ, resolveCurrentApiType(), resource);
        return result.isAllowed();
    }
    
    // 检查写权限（无权限抛403）
    public static void checkWritableResource(AiResource resource) throws NacosException {
        VisibilityService service = findVisibilityService();
        ValidationResult result = service.validateVisibility(
                resolveCurrentIdentity(), ACTION_WRITE, resolveCurrentApiType(), resource);
        if (!result.isAllowed()) {
            throw new NacosApiException(NO_RIGHT, ACCESS_DENIED, "No permission...");
        }
    }
    
    // 解析创建时的默认可见范围
    public static String resolveDefaultScopeForCreate(String resourceType) {
        return findVisibilityService()
                .map(s -> s.resolveDefaultScopeForCreate(identity, apiType, resourceType))
                .orElse(SCOPE_PRIVATE);  // 默认`PRIVATE`
    }
}

3.6.2 可见性规则

scope 读权限 写权限
PUBLIC 所有用户可读 仅创建者和显式授权用户
PRIVATE 仅创建者和显式授权用户 仅创建者和显式授权用户

4 核心执行流程

4.1 Skill 上传流程 (uploadSkillFromZip)

源码位置 : SkillOperationServiceImpl.java:158-195

复制代码 
┌─────────────────────────────────────────────────────────────────┐
│ Step 1: 解析`ZIP`包                                              │
│  - `SkillZipParser.parseSkillFromZip(zipBytes, namespaceId)`      │
│  - 提取`SKILL.md`和所有资源文件                                   │
│  - 验证`Skill name`不为空                                        │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│ Step 2: 解析版本号                                               │
│  - 优先级: `SKILL.md YAML front-matter` → `meta.json` → "0.0.1"     │
│  - `resolveUploadVersion(skillMd, zipBytes)`                      │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│ Step 3: 检查现有元数据                                           │
│  - `resourceManager.findMeta(namespaceId, name, type)`            │
│  - 若`overwrite=false`: 检查是否有working version               │
│  - 若`overwrite=true`: 覆盖现有草稿或创建新版本                   │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│ Step 4: 解决版本冲突                                             │
│  - 若版本已存在: bump patch version (`maxSemver + 1`)             │
│  - `VersionUtils.nextSemverPatch(maxSemver)`                      │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│ Step 5: 创建草稿                                                 │
│  - `createDraftWithSkill()`: 写入存储 + 插入版本行 + 更新元数据     │
│  - 写入`SKILL.md`和资源文件到`Nacos Config`                       │
│  - 插入version row (`status=draft`)                              │
│  - 更新meta.`editingVersion`指针                                 │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│ Step 6: 记录审计日志                                             │
│  - `AiResourceTraceService.logSuccess(OP_UPLOAD, ...)`            │
└─────────────────────────────────────────────────────────────────┘

4.2 Skill 发布流程 (submit → publish)

复制代码 
┌─────────────────────────────────────────────────────────────────┐
│                       `submit()` 提交审核                          │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│ Step 1: 验证元数据和权限                                          │
│  - `requireMeta()` + `checkWritableResource()`                      │
│  - `resolveSubmitTarget()`: 确定target version                   │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│ Step 2: 状态转换: `draft` → `reviewing`                             │
│  - `moveToReviewing()`: 更新version.`status`                       │
│  - 更新meta: `editingVersion` → null, `reviewingVersion` → target │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│ Step 3: 检查`Pipeline`可用性                                     │
│  - `isPipelineAvailable(resourceType)`                            │
│  - 若不可用: 直接`publish()`                                      │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│ Step 4: 执行`Pipeline`                                            │
│  - `runPipelineExecution()`: 异步执行审核节点                      │
│  - 写入`publish_pipeline_info` (`IN_PROGRESS`)                     │
│  - 回调: `onPipelineComplete()`                                   │
└─────────────────────────────────────────────────────────────────┘
                               ↓
                    ┌─────────┴─────────┐
                    │                   │
            `APPROVED`│                   │`REJECTED`
                    ↓                   ↓
        ┌───────────────────┐   ┌───────────────────┐
        │ 等待`publish()`    │   │ 回滚到`draft`      │
        │ 手动发布          │   │ `editingVersion`    │
        └───────────────────┘   └───────────────────┘
                    ↓
┌─────────────────────────────────────────────────────────────────┐
│                       `publish()` 发布上线                         │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│ Step 1: 验证审核结果                                              │
│  - 检查`Pipeline execution`状态是否`APPROVED`                    │
│  - 版本状态必须为`reviewing`                                      │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│ Step 2: 更新版本状态                                              │
│  - version.`status` → `online`                                      │
│  - meta.`reviewingVersion` → null                                 │
│  - meta.`onlineCnt`++                                             │
│  - meta.`labels["latest"]` = version                              │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│ Step 3: 更新索引清单                                              │
│  - `manifestService.loadForUpdate()`                              │
│  - manifest.`versions[version]` = fileList                         │
│  - manifest.`labels["latest"]` = version                          │
│  - `manifestService.write()`                                      │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│ Step 4: 记录审计日志                                              │
│  - `AiResourceTraceService.logSuccess(OP_PUBLISH, ...)`           │
└─────────────────────────────────────────────────────────────────┘

4.3 Skill 查询流程 (querySkill - 客户端)

源码位置 : SkillOperationServiceImpl.java:947-981

复制代码 
┌─────────────────────────────────────────────────────────────────┐
│ 输入: `namespaceId`, `name`, `version(可选)`, `label(可选)`              │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│ Step 1: 验证元数据和读权限                                        │
│  - `findMeta()` + `ensureReadableOrNotFound()`                      │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│ Step 2: 加载索引清单                                              │
│  - `manifestService.query()`                                      │
│  - 若清单不存在或为空 → `NOT_FOUND`                                │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│ Step 3: 解析目标版本                                              │
│  - `resolveVersion(manifest, version, label)`                     │
│  - 优先级: explicit version > label lookup > "latest" label     │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│ Step 4: 从清单获取文件列表                                        │
│  - files = manifest.`versions[resolvedVersion]`                   │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│ Step 5: 从存储加载文件内容                                        │
│  - `loadSkillFromFiles()`: 遍历files                             │
│  - `storageRouter.route(StorageKey).get()`                        │
│  - `SKILL.md` → skillMd, 其他 → resource map                      │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│ Step 6: 发布下载事件                                              │
│  - `NotifyCenter.publishEvent(SkillDownloadEvent)`                │
│  - 用于下载次数统计                                               │
└─────────────────────────────────────────────────────────────────┘
                               ↓
┌─────────────────────────────────────────────────────────────────┐
│ 返回: `Skill` (`namespaceId`, `name`, `description`, `skillMd`, `resource`) │
└─────────────────────────────────────────────────────────────────┘

5 API 接口清单

5.1 Admin API (/v3/admin/ai/skills)

接口 方法 功能
/list GET 分页查询Skill列表
/ GET 获取Skill详情（包含所有版本）
/version GET 获取指定版本详情
/version/download GET 下载指定版本ZIP
/upload POST 上传Skill ZIP包
/ DELETE 删除Skill
/draft POST 创建草稿版本
/draft PUT 更新草稿内容
/draft DELETE 删除草稿
/submit POST 提交审核
/publish POST 发布上线
/force-publish POST 强制发布（管理员）
/online POST 上线（版本级或Skill级）
/offline POST 下线
/labels PUT 更新版本标签
/biz-tags PUT 更新业务标签
/scope PUT 更新可见范围

5.2 Client API (/v3/client/ai/skills)

接口 方法 功能
/search GET 搜索Skill（仅返回基本信息）
/query GET 查询Skill内容（用于Agent加载）

6 SPI 扩展点

6.1 存储扩展 (AiResourceStorage)

接口位置 : plugin/ai/src/main/java/com/alibaba/nacos/plugin/ai/storage/spi/AiResourceStorage.java

java 复制代码 
public interface AiResourceStorage {
    String type();  // 存储提供者标识
    void save(StorageKey key, byte[] content) throws NacosException;
    byte[] get(StorageKey key) throws NacosException;
    void delete(StorageKey key) throws NacosException;
}

扩展方式:

  1. 实现AiResourceStorage接口
  2. 创建AiResourceStorageBuilder SPI实现
  3. 在META-INF/services/注册

6.2 发布审核扩展 (PublishPipelineService)

接口位置 : plugin/ai/src/main/java/com/alibaba/nacos/plugin/ai/pipeline/spi/PublishPipelineService.java

java 复制代码 
public interface PublishPipelineService {
    String pipelineId();  // 节点标识
    int preferOrder();    // 执行顺序
    PublishPipelineResourceType resourceType();  // 适用资源类型
    PublishPipelineResult execute(PublishPipelineContext context);  // 执行审核
}

默认实现 : SkillScannerPipelineService（Skill内容扫描审核）

6.3 可见性扩展 (VisibilityService)

接口位置 : plugin/visibility/src/main/java/com/alibaba/nacos/plugin/visibility/spi/VisibilityService.java

java 复制代码 
public interface VisibilityService {
    ValidationResult validateVisibility(String identity, String action, String apiType, VisibilityResource resource);
    QueryAdvisor adviseQuery(String identity, String action, String apiType, VisibilityQueryContext context);
    String resolveDefaultScopeForCreate(String identity, String apiType, String resourceType);
}

7 配置项

配置项 默认值 说明
nacos.ai.skill.storage.provider nacos_config Skill存储提供者
nacos.ai.agentspec.storage.provider nacos_config AgentSpec存储提供者
nacos.plugin.visibility.type nacos 可见性插件类型

8 设计亮点

8.1 双层存储架构

  • 元数据层 : 关系型数据库存储Skill元信息和版本索引
  • 内容层 : Nacos Config存储文件内容，支持多存储提供者扩展

优势:

  • 元数据查询高效（SQL索引）
  • 内容存储灵活（可扩展OSS等）
  • 索引清单轻量（客户端快速发现）

8.2 CAS 乐观锁

  • 使用meta_version字段实现高并发场景下的安全更新
  • 自动重试机制（最多3次）
  • 冲突时智能合并用户修改

8.3 Pipeline 发布审核

  • SPI扩展机制，支持自定义审核节点
  • 异步串行执行，避免阻塞主流程
  • 审核拒绝自动回滚

8.4 索引清单分离

  • 索引清单独立存储，客户端无需遍历数据库
  • 支持版本标签路由（latest、stable）
  • 上线/下线操作实时更新索引

9 总结

Nacos Skill Registry是一个完整的AI Skill注册中心实现，核心特点：

  1. 完整生命周期 : Draft → Reviewing → Online/Offline
  2. 版本治理 : 标签路由、多版本管理、CAS安全更新
  3. 发布审核 : Pipeline SPI扩展、异步执行、自动回滚
  4. 存储灵活 : Nacos Config默认实现、SPI扩展支持
  5. 可见性控制 : PUBLIC/PRIVATE、权限验证
  6. 客户端友好: 轻量级索引清单、快速发现和加载

该架构设计为Nacos的AI Agent注册中心提供了坚实的基础，同时支持Skill、AgentSpec、Prompt等多种AI资源类型的统一管理。

相关推荐
Zzj_tju2 小时前
大语言模型部署实战：从 Ollama、vLLM 到 SGLang，本地服务到底怎么搭？
人工智能·语言模型·自然语言处理·vllm
不会学习的小白O^O2 小时前
使用可识别的CNN进行茶花检测和拔出点识别
人工智能
北辰屿风2 小时前
宝塔部署tomcat项目，nginx负载均衡代理访问报错404问题
java·tomcat
CS创新实验室2 小时前
AI推理进化史：从GPT到推理模型，AI的“思考能力”如何突破？
人工智能·gpt
威迪斯特2 小时前
项目解决方案：食堂反浪费AI智能监督系统项目解决方案
人工智能·实时视频分析·算法分析·边缘分析·ai识别盒子·餐盘浪费检测·智能食堂
AI服务老曹2 小时前
深度解析：基于异构计算的 AI 视频管理平台架构实践
人工智能·架构·音视频
谷哥的小弟2 小时前
大模型核心基础知识(02)—大模型的主要特征与能力边界
人工智能·深度学习·机器学习·大模型·智能体
鱼鳞_2 小时前
Java学习笔记_Day37（网络编程）
java·网络·笔记·学习
热门推荐
012026年4月技术前沿：AI大模型爆发、智能体革命与量子安全新纪元02GitHub 镜像站点032026年4月AI大事件深度解读：大模型竞争进入“深水区“04近期有什么ai的新消息，新动态？ 2026.4月052026 年 AI 编程助手全面对比评测：Cursor vs Copilot vs Claude Code vs GitHub Copilot Free06AI Weekly | 2026年4月第二周 · GitHub热门项目与AI发展趋势深度解析07CC-Switch & Claude 基于 Linux 服务器安装使用指南08从限购到畅通：GLM-5.1 Coding Plan接入攻略09Claude Code Windows 兼容性问题：指定版本 2.1.112 可解决10UBUNTU Claude Code 报错 claude native binary not installed