第28天：Skills vs MCP vs SubAgent

学习目标

理解Skills、MCP、SubAgent的定义和核心概念
掌握三者的核心区别
掌握三者的应用场景
学会协同使用三者
能够为不同场景选择合适的技术

核心内容

Skills、MCP、SubAgent的定义

Skills（技能）

Skills是Anthropic推出的文档驱动的AI能力标准，通过skill.md文件定义AI能力，实现能力的自动发现和加载。

核心特点：

文档驱动：通过Markdown文档定义能力
自动发现：解析skill.md文件，自动发现能力
可组合：支持能力的组合和复用
跨平台：不依赖特定平台或框架

适用场景：

定义独立的AI能力
需要文档驱动开发
能力需要复用和组合
跨平台部署

MCP（Model Context Protocol）

MCP是Anthropic推出的标准化协议，用于AI模型与外部工具、资源之间的通信。

核心特点：

标准化协议：定义统一的通信协议
Server-Client架构：采用Server-Client架构
工具和资源：支持工具调用和资源访问
安全机制：内置权限和安全控制

适用场景：

AI与外部系统通信
需要标准化通信协议
需要权限和安全控制
集成到Claude Desktop

SubAgent（子智能体）

SubAgent是AI Agent架构中的子智能体，用于拆解复杂任务，实现任务的分工协作。

核心特点：

任务拆解：将复杂任务拆解为子任务
专业化：每个SubAgent专注于特定领域
协作：多个SubAgent协同工作
层次化：支持多层次的Agent架构

适用场景：

复杂任务处理
需要专业分工
多Agent协作
层次化任务处理

三者的核心区别

1. 设计理念

技术	设计理念	核心价值
Skills	文档驱动	可读性、可维护性
MCP	标准化通信	互操作性、安全性
SubAgent	任务拆解	专业化、协作性

2. 架构层次

┌─────────────────────────────────────┐
│         Application Layer          │  应用层
├─────────────────────────────────────┤
│         Agent Layer              │  Agent层
│         (SubAgent)               │
├─────────────────────────────────────┤
│         Skills Runtime            │  Skills层
├─────────────────────────────────────┤
│         MCP Protocol              │  MCP层
├─────────────────────────────────────┤
│         External Systems          │  外部系统
└─────────────────────────────────────┘

3. 技术维度

维度	Skills	MCP	SubAgent
抽象层次	能力定义	通信协议	任务架构
实现方式	Markdown文档	Server-Client	Agent框架
核心功能	能力发现	工具调用	任务拆解
通信方式	无	JSON-RPC	消息传递
安全机制	无	权限控制	依赖框架
适用范围	单一能力	系统集成	复杂任务

三者的应用场景对比

场景1：文件操作

使用Skills：

定义文件读取、写入、解析等能力
通过skill.md文档描述能力
适合独立的能力定义

使用MCP：

实现文件操作Server
通过MCP协议提供文件操作服务
适合与Claude Desktop集成

使用SubAgent：

创建文件操作SubAgent
专注于文件操作任务
适合作为复杂任务的一部分

推荐方案：Skills + MCP

使用Skills定义文件操作能力
使用MCP提供服务

场景2：数据处理

使用Skills：

定义数据清洗、转换、分析等能力
通过文档描述数据处理流程
适合独立的数据处理能力

使用MCP：

实现数据处理Server
提供数据处理工具
适合远程数据处理服务

使用SubAgent：

创建数据处理SubAgent
专注于数据处理任务
适合作为数据分析流程的一部分

推荐方案：Skills + SubAgent

使用Skills定义数据处理能力
使用SubAgent实现数据处理流程

场景3：网络请求

使用Skills：

定义HTTP请求、API调用等能力
通过文档描述API接口
适合API能力定义

使用MCP：

实现网络请求Server
提供网络请求工具
适合与外部API集成

使用SubAgent：

创建网络请求SubAgent
专注于网络请求任务
适合作为复杂任务的一部分

推荐方案：MCP

使用MCP提供网络请求服务
适合与Claude Desktop集成

场景4：复杂任务处理

使用Skills：

定义各个子任务的能力
通过文档描述任务流程
适合能力定义和复用

使用MCP：

实现各个子任务的Server
通过MCP协议提供服务
适合系统集成

使用SubAgent：

创建多个SubAgent
每个SubAgent负责子任务
通过协作完成复杂任务

推荐方案：Skills + MCP + SubAgent

使用Skills定义能力
使用MCP提供服务
使用SubAgent协调任务

三者的协同使用

协同架构

┌─────────────────────────────────────┐
│         Main Agent               │  主Agent
├─────────────────────────────────────┤
│         SubAgent 1              │  SubAgent 1
│    ┌─────────────────────────┐   │
│    │  Skills Runtime        │   │
│    │  - Skill A            │   │
│    │  - Skill B            │   │
│    └─────────────────────────┘   │
│         MCP Client             │
├─────────────────────────────────────┤
│         SubAgent 2              │  SubAgent 2
│    ┌─────────────────────────┐   │
│    │  Skills Runtime        │   │
│    │  - Skill C            │   │
│    │  - Skill D            │   │
│    └─────────────────────────┘   │
│         MCP Client             │
├─────────────────────────────────────┤
│         MCP Server               │  MCP Server
│    ┌─────────────────────────┐   │
│    │  Tool A               │   │
│    │  Tool B               │   │
│    │  Resource A           │   │
│    └─────────────────────────┘   │
└─────────────────────────────────────┘

协同流程

Main Agent接收任务
Main Agent将任务拆解为子任务
SubAgent 1处理子任务1
- 使用Skills定义的能力
- 通过MCP调用外部服务
SubAgent 2处理子任务2
- 使用Skills定义的能力
- 通过MCP调用外部服务
Main Agent整合结果
返回最终结果

协同示例

场景：数据分析任务

python

from agent import MainAgent, SubAgent
from skills import DataProcessingSkill, VisualizationSkill
from mcp import MCPClient

# 创建主Agent
main_agent = MainAgent()

# 创建SubAgent 1：数据处理
data_processing_agent = SubAgent(
    name="data_processing",
    skills=[
        DataProcessingSkill(),
        VisualizationSkill()
    ],
    mcp_client=MCPClient()
)

# 创建SubAgent 2：报告生成
report_agent = SubAgent(
    name="report_generation",
    skills=[
        ReportGenerationSkill()
    ],
    mcp_client=MCPClient()
)

# 注册SubAgent
main_agent.register_subagent(data_processing_agent)
main_agent.register_subagent(report_agent)

# 执行任务
task = "分析销售数据并生成报告"
result = main_agent.execute(task)

技术选型指南

选型决策树

开始
  │
  ├─ 需要定义AI能力？
  │   ├─ 是 → 使用Skills
  │   └─ 否 → 继续
  │
  ├─ 需要与外部系统通信？
  │   ├─ 是 → 使用MCP
  │   └─ 否 → 继续
  │
  ├─ 需要处理复杂任务？
  │   ├─ 是 → 使用SubAgent
  │   └─ 否 → 继续
  │
  └─ 需要组合多种技术？
      └─ 是 → Skills + MCP + SubAgent

选型建议

单一能力定义：

使用Skills
文档驱动，易于维护

系统集成：

使用MCP
标准化通信，安全可靠

复杂任务处理：

使用SubAgent
任务拆解，专业分工

综合应用：

Skills + MCP + SubAgent
各司其职，协同工作

最佳实践案例

案例1：智能客服系统

架构：

Skills：定义问答、知识检索、情感分析等能力
MCP：提供知识库、CRM系统集成
SubAgent：协调问答、知识检索、情感分析

实现：

python

# 定义Skills
class QASkill:
    def answer(self, question):
        pass

class KnowledgeRetrievalSkill:
    def retrieve(self, query):
        pass

class SentimentAnalysisSkill:
    def analyze(self, text):
        pass

# 创建SubAgent
qa_agent = SubAgent(
    skills=[QASkill(), KnowledgeRetrievalSkill()]
)

sentiment_agent = SubAgent(
    skills=[SentimentAnalysisSkill()]
)

# 创建主Agent
main_agent = MainAgent()
main_agent.register_subagent(qa_agent)
main_agent.register_subagent(sentiment_agent)

# MCP集成
mcp_client = MCPClient()
mcp_client.connect("knowledge-base-server")
mcp_client.connect("crm-server")

案例2：个人助理Agent

架构：

Skills：定义日程管理、邮件处理、信息查询等能力
MCP：提供日历、邮件、天气等服务
SubAgent：协调日程、邮件、信息查询

实现：

python

# 定义Skills
class ScheduleManagementSkill:
    def add_event(self, event):
        pass

class EmailProcessingSkill:
    def send_email(self, email):
        pass

class InformationQuerySkill:
    def query_weather(self, location):
        pass

# 创建SubAgent
schedule_agent = SubAgent(
    skills=[ScheduleManagementSkill()],
    mcp_client=MCPClient()
)

email_agent = SubAgent(
    skills=[EmailProcessingSkill()],
    mcp_client=MCPClient()
)

info_agent = SubAgent(
    skills=[InformationQuerySkill()],
    mcp_client=MCPClient()
)

# 创建主Agent
main_agent = MainAgent()
main_agent.register_subagent(schedule_agent)
main_agent.register_subagent(email_agent)
main_agent.register_subagent(info_agent)

实践任务

任务1：对比分析三者应用场景

分析Skills、MCP、SubAgent在不同场景下的适用性。

步骤：

列出常见的AI应用场景
分析每个场景的特点
评估Skills、MCP、SubAgent的适用性
给出推荐方案

输出：

场景对比分析表
推荐方案说明
选型建议

任务2：设计协同使用方案

设计一个Skills+MCP+SubAgent协同使用的方案。

步骤：

选择一个复杂应用场景
设计系统架构
定义Skills
设计MCP服务
设计SubAgent架构

输出：

系统架构图
Skills定义
MCP服务设计
SubAgent架构

任务3：实现简单的Skills+MCP集成

实现一个简单的Skills+MCP集成示例。

步骤：

定义一个Skill
实现一个MCP Server
实现MCP Client
集成Skill和MCP

输出：

Skill实现代码
MCP Server实现代码
MCP Client实现代码
集成示例代码

代码示例

示例1：Skills定义

yaml

---
name: "data-processor"
version: "1.0.0"
author: "Your Name"
description: "Data processing capabilities"
tags: ["data", "processing"]
license: "MIT"
---

# Data Processor Skill

## Description

The data-processor skill provides data cleaning, transformation, and analysis capabilities.

## Parameters

| Parameter | Type | Required | Description | Default |
|-----------|------|----------|-------------|---------|
| data | any | Yes | Input data | - |
| operation | string | Yes | Operation type (clean, transform, analyze) | - |
| options | object | No | Operation options | {} |

## Returns

Returns processed data or analysis results.

## Examples

### Example 1: Clean data

```python
from skills import DataProcessorSkill

skill = DataProcessorSkill()
result = skill.clean(data)

Example 2: Transform data

python

from skills import DataProcessorSkill

skill = DataProcessorSkill()
result = skill.transform(data, operation="normalize")


### 示例2：MCP Server实现

```python
from mcp import MCPServer, Tool, Resource
import json

class DataProcessingServer(MCPServer):
    def __init__(self):
        super().__init__("data-processing-server")
        self.register_tools()
        self.register_resources()
    
    def register_tools(self):
        self.add_tool(Tool(
            name="clean_data",
            description="Clean and preprocess data",
            parameters={
                "type": "object",
                "properties": {
                    "data": {"type": "any"},
                    "options": {"type": "object"}
                },
                "required": ["data"]
            },
            handler=self.clean_data
        ))
        
        self.add_tool(Tool(
            name="transform_data",
            description="Transform data",
            parameters={
                "type": "object",
                "properties": {
                    "data": {"type": "any"},
                    "operation": {"type": "string"},
                    "options": {"type": "object"}
                },
                "required": ["data", "operation"]
            },
            handler=self.transform_data
        ))
    
    def register_resources(self):
        self.add_resource(Resource(
            name="data_schema",
            description="Data schema definition",
            uri="data://schema",
            handler=self.get_schema
        ))
    
    def clean_data(self, params):
        data = params["data"]
        options = params.get("options", {})
        
        # Data cleaning logic
        cleaned_data = self._clean(data, options)
        
        return {
            "success": True,
            "data": cleaned_data
        }
    
    def transform_data(self, params):
        data = params["data"]
        operation = params["operation"]
        options = params.get("options", {})
        
        # Data transformation logic
        if operation == "normalize":
            transformed_data = self._normalize(data, options)
        elif operation == "aggregate":
            transformed_data = self._aggregate(data, options)
        else:
            raise ValueError(f"Unknown operation: {operation}")
        
        return {
            "success": True,
            "data": transformed_data
        }
    
    def get_schema(self):
        return {
            "type": "object",
            "properties": {
                "id": {"type": "string"},
                "name": {"type": "string"},
                "value": {"type": "number"}
            }
        }
    
    def _clean(self, data, options):
        # Implement data cleaning
        return data
    
    def _normalize(self, data, options):
        # Implement data normalization
        return data
    
    def _aggregate(self, data, options):
        # Implement data aggregation
        return data

if __name__ == "__main__":
    server = DataProcessingServer()
    server.run(host="localhost", port=8000)

示例3：SubAgent实现

python

from agent import SubAgent, MainAgent
from skills import DataProcessingSkill, VisualizationSkill
from mcp import MCPClient

class DataProcessingAgent(SubAgent):
    def __init__(self):
        super().__init__(
            name="data_processing",
            skills=[
                DataProcessingSkill(),
                VisualizationSkill()
            ],
            mcp_client=MCPClient()
        )
    
    def process_task(self, task):
        if task.type == "clean":
            return self.skills[0].clean(task.data)
        elif task.type == "transform":
            return self.skills[0].transform(task.data, task.operation)
        elif task.type == "visualize":
            return self.skills[1].visualize(task.data)
        else:
            raise ValueError(f"Unknown task type: {task.type}")

class MainAgentWithSubAgents(MainAgent):
    def __init__(self):
        super().__init__()
        self.register_subagent(DataProcessingAgent())
    
    def execute(self, task):
        if task.complex:
            subtasks = self.decompose(task)
            results = []
            for subtask in subtasks:
                result = self.delegate(subtask)
                results.append(result)
            return self.aggregate(results)
        else:
            return self.delegate(task)

# 使用示例
main_agent = MainAgentWithSubAgents()
result = main_agent.execute({
    "type": "data_analysis",
    "data": {...},
    "complex": True
})

总结

Skills、MCP、SubAgent是AI开发中的三个重要技术，各有其特点和适用场景：

Skills：文档驱动的AI能力标准，适合定义独立能力
MCP：标准化通信协议，适合系统集成
SubAgent：任务拆解和协作，适合复杂任务处理

三者可以协同使用，构建更强大的AI系统。在实际应用中，需要根据具体场景选择合适的技术，或者组合使用多种技术。

本节我们学习了：

Skills、MCP、SubAgent的定义和核心概念
三者的核心区别
三者的应用场景对比
三者的协同使用方法
技术选型指南

下一步，我们将学习Skills开发基础，掌握Skills的实际开发方法。

第28天：Skills vs MCP vs SubAgent ​

学习目标 ​

核心内容 ​

Skills、MCP、SubAgent的定义 ​

Skills（技能） ​

MCP（Model Context Protocol） ​

SubAgent（子智能体） ​

三者的核心区别 ​

1. 设计理念 ​

2. 架构层次 ​

3. 技术维度 ​

三者的应用场景对比 ​

场景1：文件操作 ​

场景2：数据处理 ​

场景3：网络请求 ​

场景4：复杂任务处理 ​

三者的协同使用 ​

协同架构 ​

协同流程 ​

协同示例 ​

技术选型指南 ​

选型决策树 ​

选型建议 ​

最佳实践案例 ​

案例1：智能客服系统 ​

案例2：个人助理Agent ​

实践任务 ​

任务1：对比分析三者应用场景 ​

任务2：设计协同使用方案 ​

任务3：实现简单的Skills+MCP集成 ​

代码示例 ​

示例1：Skills定义 ​

Example 2: Transform data ​

示例3：SubAgent实现 ​

总结 ​

参考资源 ​

第28天：Skills vs MCP vs SubAgent

学习目标

核心内容

Skills、MCP、SubAgent的定义

Skills（技能）

MCP（Model Context Protocol）

SubAgent（子智能体）

三者的核心区别

1. 设计理念

2. 架构层次

3. 技术维度

三者的应用场景对比

场景1：文件操作

场景2：数据处理

场景3：网络请求

场景4：复杂任务处理

三者的协同使用

协同架构

协同流程

协同示例

技术选型指南

选型决策树

选型建议

最佳实践案例

案例1：智能客服系统

案例2：个人助理Agent

实践任务

任务1：对比分析三者应用场景

任务2：设计协同使用方案

任务3：实现简单的Skills+MCP集成

代码示例

示例1：Skills定义

Example 2: Transform data

示例3：SubAgent实现

总结

参考资源