第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：

使用Skills包括定义文件读取、写入、解析等能力、通过skill.md文档描述能力、适合独立的能力定义等方面。

使用MCP：

使用MCP包括实现文件操作Server、通过MCP协议提供文件操作服务、适合与Claude Desktop集成等方面。

使用SubAgent：

使用SubAgent包括创建文件操作SubAgent、专注于文件操作任务、适合作为复杂任务的一部分等方面。

推荐方案：Skills + MCP

推荐方案包括使用Skills定义文件操作能力、使用MCP提供服务等方面。

场景2：数据处理

使用Skills：

使用Skills包括定义数据清洗、转换、分析等能力、通过文档描述数据处理流程、适合独立的数据处理能力等方面。

使用MCP：

使用MCP包括实现数据处理Server、提供数据处理工具、适合远程数据处理服务等方面。

使用SubAgent：

使用SubAgent包括创建数据处理SubAgent、专注于数据处理任务、适合作为数据分析流程的一部分等方面。

推荐方案：Skills + SubAgent

推荐方案包括使用Skills定义数据处理能力、使用SubAgent实现数据处理流程等方面。

场景3：网络请求

使用Skills：

使用Skills包括定义HTTP请求、API调用等能力、通过文档描述API接口、适合API能力定义等方面。

使用MCP：

使用MCP包括实现网络请求Server、提供网络请求工具、适合与外部API集成等方面。

使用SubAgent：

使用SubAgent包括创建网络请求SubAgent、专注于网络请求任务、适合作为复杂任务的一部分等方面。

推荐方案：MCP

推荐方案包括使用MCP提供网络请求服务、适合与Claude Desktop集成等方面。

场景4：复杂任务处理

使用Skills：

使用Skills包括定义各个子任务的能力、通过文档描述任务流程、适合能力定义和复用等方面。

使用MCP：

使用MCP包括实现各个子任务的Server、通过MCP协议提供服务、适合系统集成等方面。

使用SubAgent：

使用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：个人助理系统

架构：

架构包括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的实际开发方法。

参考资源

参考资源包括Anthropic Skills Documentation（https://docs.anthropic.com/）、MCP Protocol Specification（https://modelcontextprotocol.io/）、Multi-Agent Systems（https://arxiv.org/abs/2005.14165）等。

第28天：Skills vs MCP vs SubAgent ​

学习目标 ​

核心内容 ​

Skills、MCP、SubAgent的定义 ​

Skills（技能） ​

MCP（Model Context Protocol） ​

SubAgent（子智能体） ​

三者的核心区别 ​

1. 设计理念 ​

2. 架构层次 ​

3. 技术维度 ​

三者的应用场景对比 ​

场景1：文件操作 ​

场景2：数据处理 ​

场景3：网络请求 ​

场景4：复杂任务处理 ​

三者的协同使用 ​

协同架构 ​

协同流程 ​

协同示例 ​

技术选型指南 ​

选型决策树 ​

选型建议 ​

最佳实践案例 ​

案例1：智能客服系统 ​

案例2：个人助理系统 ​

实践任务 ​

任务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：个人助理系统

实践任务

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

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

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

代码示例

示例1：Skills定义

Example 2: Transform data

示例3：SubAgent实现

总结

参考资源