AI Agent 协议全景：MCP vs A2A vs ACP vs ANP 选型实战指南

// MCP Server 端：定义一个天气查询工具
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({
  name: "weather-server",
  version: "1.0.0",
});

// 注册工具：声明名称、描述、输入 Schema
server.tool(
  "get_weather",
  "获取指定城市的当前天气信息，包括温度、湿度、风速",
  {
    city: z.string().describe("城市名称，如 '北京' 或 'Shanghai'"),
    unit: z.enum(["celsius", "fahrenheit"]).default("celsius"),
  },
  async ({ city, unit }) => {
    // 实际实现：调用天气 API
    const weather = await fetchWeatherData(city);
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify({
            city,
            temperature: weather.temp,
            humidity: weather.humidity,
            wind: weather.windSpeed,
            unit,
          }),
        },
      ],
    };
  }
);

// 启动 Server（stdio 传输模式）
const transport = new StdioServerTransport();
await server.connect(transport);

// A2A Agent Card 定义（发布在 /.well-known/agent.json）
import { AgentCard, AgentSkill } from "@a2a-protocol/core";

const agentCard: AgentCard = {
  name: "数据分析 Agent",
  description: "专业的数据分析 Agent，擅长 CSV/Excel 数据处理、统计分析和可视化",
  url: "https://data-agent.example.com/a2a",
  version: "1.0.0",
  capabilities: {
    streaming: true,        // 支持 SSE 流式响应
    pushNotifications: true, // 支持异步回调
    stateTransitionHistory: true,
  },
  skills: [
    {
      id: "csv-analysis",
      name: "CSV 数据分析",
      description: "分析 CSV 文件，输出统计摘要和可视化图表",
      tags: ["data", "csv", "analytics"],
      examples: [
        "分析这份销售数据的月度趋势",
        "对比 Q1 和 Q2 的转化率差异",
      ],
    },
    {
      id: "excel-report",
      name: "Excel 报表生成",
      description: "从原始数据生成格式化的 Excel 报表",
      tags: ["data", "excel", "report"],
      examples: [],
    },
  ],
  // 认证要求
  authentication: {
    schemes: ["bearer"],
    credentials: "https://auth.example.com/.well-known/jwks.json",
  },
};

// Express 路由：暴露 Agent Card
app.get("/.well-known/agent.json", (req, res) => {
  res.json(agentCard);
});

# ACP 流程定义（BPMN 子集）
# 文件: expense-approval-process.yaml
apiVersion: acp/v1
kind: ProcessDefinition
metadata:
  name: "费用审批流程"
  description: "员工提交费用报销 → AI 审核 → 经理审批 → 财务打款"
spec:
  participants:
    - id: "employee-agent"
      type: "agent"
      capabilities: ["form-filling", "receipt-ocr"]
    - id: "audit-agent"
      type: "agent"
      capabilities: ["compliance-check", "fraud-detection"]
    - id: "manager-agent"
      type: "agent"
      capabilities: ["approval", "risk-assessment"]
    - id: "finance-agent"
      type: "agent"
      capabilities: ["payment", "accounting"]
  
  steps:
    - id: "submit"
      agent: "employee-agent"
      action: "submit_expense"
      output: "expense_report"
    
    - id: "audit"
      agent: "audit-agent"
      action: "compliance_review"
      input: "$steps.submit.output"
      transitions:
        - condition: "risk_score < 0.3"
          next: "approve"
        - condition: "risk_score >= 0.3"
          next: "manual_review"
    
    - id: "approve"
      agent: "manager-agent"
      action: "auto_approve"
      sla: { timeoutSeconds: 30 }
    
    - id: "manual_review"
      agent: "manager-agent"
      action: "manual_review"
      sla: { timeoutSeconds: 86400 }  # 24h
    
    - id: "payment"
      agent: "finance-agent"
      action: "process_payment"
      input: "$steps.approve.output || $steps.manual_review.output"

// ACP Client：启动流程实例并跟踪状态
import { ACPClient, ProcessInstance } from "@ibm/acp-client";

const acp = new ACPClient({
  baseUrl: "https://acp-gateway.example.com",
  auth: {
    type: "oidc",
    clientId: process.env.ACP_CLIENT_ID!,
    clientSecret: process.env.ACP_CLIENT_SECRET!,
    tokenEndpoint: "https://sso.example.com/oauth/token",
  },
});

async function submitExpense(employeeId: string, receipts: File[]) {
  // 1. 启动流程实例
  const instance: ProcessInstance = await acp.processes.start(
    "expense-approval",
    {
      initiator: employeeId,
      context: {
        receipts: receipts.map((f) => ({
          name: f.name,
          url: await uploadToStorage(f),
        })),
        currency: "CNY",
        totalAmount: await calculateTotal(receipts),
      },
    }
  );

  console.log(`流程已启动: ${instance.id}`);
  console.log(`当前步骤: ${instance.currentStep.id}`);
  // 输出: 当前步骤: submit

  // 2. 监听流程事件（审计日志）
  acp.instances.onEvent(instance.id, (event) => {
    console.log(`[${event.timestamp}] ${event.step}: ${event.status}`);
    // [2026-06-16T10:00:00Z] submit: completed
    // [2026-06-16T10:00:05Z] audit: completed (risk_score: 0.12)
    // [2026-06-16T10:00:06Z] approve: completed (auto-approved)
    // [2026-06-16T10:00:10Z] payment: completed (tx_id: PAY-20260616-001)
  });

  // 3. 等待流程完成
  const result = await acp.instances.waitForCompletion(instance.id, {
    timeoutMs: 3600_000, // 1 小时超时
  });

  return result;
}

{
  "@context": "https://anp.example.org/v0.3",
  "id": "did:agent:finance-expert-001",
  "type": ["Agent", "FinanceExpert"],
  "name": "金融分析专家 Agent",
  "description": "专注于金融市场分析、风险评估和投资组合优化",
  "endpoint": "https://finance-agent.example.com/anp",
  "capabilities": [
    {
      "id": "market-analysis",
      "name": "市场行情分析",
      "inputSchema": { "type": "object", "properties": { "symbol": { "type": "string" } } },
      "outputSchema": { "type": "object", "properties": { "trend": { "type": "string" }, "confidence": { "type": "number" } } }
    },
    {
      "id": "risk-assessment",
      "name": "风险评估",
      "inputSchema": { "type": "object", "properties": { "portfolio": { "type": "array" } } },
      "outputSchema": { "type": "object", "properties": { "riskLevel": { "type": "string" }, "score": { "type": "number" } } }
    }
  ],
  "trustScore": {
    "value": 0.92,
    "basedOn": 1847,
    "lastUpdated": "2026-06-15T00:00:00Z"
  },
  "authentication": {
    "type": "did-auth",
    "publicKey": "did:key:z6MkhaXgBZDvotDkL5257faiztiScC2xtKgj"
  }
}

// 协调 Agent：使用 A2A 协议编排多 Agent 协作
import { A2AClient, AgentCard, Task, Message, Part } from "@a2a-protocol/core";
import { McpClient } from "@modelcontextprotocol/sdk/client/index.js";

class CoordinatorAgent {
  private dataAnalystClient: A2AClient;
  private writerClient: A2AClient;
  private mcpClient: McpClient;

  constructor() {
    // 初始化 A2A Clients（连接其他 Agent）
    this.dataAnalystClient = new A2AClient(
      await this.discoverAgent("https://data-analyst.example.com")
    );
    this.writerClient = new A2AClient(
      await this.discoverAgent("https://writer.example.com")
    );
    // 初始化 MCP Client（连接自己的工具）
    this.mcpClient = new McpClient();
    await this.mcpClient.connect("mcp-calendar-server");
  }

  private async discoverAgent(url: string): Promise<AgentCard> {
    const resp = await fetch(`${url}/.well-known/agent.json`);
    return resp.json();
  }

  async generateReport(userRequest: string): Promise<string> {
    // Step 1: 委托数据分析 Agent
    const analysisTask = await this.dataAnalystClient.sendTask({
      messages: [
        new Message({
          role: "coordinator",
          parts: [
            new Part({ type: "text", text: `分析以下主题的市场数据: ${userRequest}` }),
            new Part({ type: "text", text: "要求: 包含市场规模、增长率、主要玩家、融资事件" }),
          ],
        }),
      ],
      capabilities: { streaming: true },
    });

    // 等待分析完成
    const analysisResult = await this.dataAnalystClient.waitForCompletion(
      analysisTask.id,
      { timeoutMs: 300_000 }
    );

    // Step 2: 提取分析数据
    const analysisData = analysisResult.artifacts
      .filter((a) => a.type === "data")
      .map((a) => a.content)
      .join("\n");

    // Step 3: 委托写作 Agent
    const writingTask = await this.writerClient.sendTask({
      messages: [
        new Message({
          role: "coordinator",
          parts: [
            new Part({ type: "text", text: `基于以下数据撰写研究报告:\n\n${analysisData}` }),
            new Part({ type: "text", text: "报告格式: 摘要 + 市场分析 + 趋势预测 + 投资建议，5000字" }),
          ],
        }),
      ],
    });

    const writingResult = await this.writerClient.waitForCompletion(
      writingTask.id,
      { timeoutMs: 600_000 }
    );

    // Step 4: 返回最终报告
    return writingResult.artifacts[0].content;
  }
}