AI Agent Protocol (MCP & A2A)

Core

AI Agent "đối thoại" với thế giới ngoài thế nào? Như Internet cần HTTP, AI Agent cần protocol chuẩn. Chương này giới thiệu 2 protocol mainstream: MCP + A2A, giải bài toán AI-tool và Agent-Agent communication.

0. Protocol là gì?

Protocol = bộ rule chuẩn cho các system/program "hiểu" + "communicate" nhau.

0.1 Sao cần protocol?

Tưởng gửi quà cho bạn cần điền địa chỉ. Nếu mỗi người viết format khác, shipper không giao được. Protocol = chuẩn "viết địa chỉ thế nào".

Computer cũng vậy. 2 program communicate phải agree:

Data format gì? (JSON? binary?)
Lập connection thế nào? (handshake)
Lỗi thì sao? (error handling)

0.2 Protocol thường gặp

Protocol	Use	Bạn dùng hàng ngày
HTTP	Web transfer	Browser mở web
HTTPS	HTTP encrypt	Banking, payment
TCP/IP	Internet base	Mọi network communication
DNS	Domain resolve	`google.com` → IP
SMTP	Send email	Gửi mail
WebSocket	Realtime 2-way	Chat, online game
SSH	Remote login secure	Connect server
FTP	File transfer	Upload/download

Đây là nền tảng Internet. Không có chúng = không xem web, không gửi mail.

0.3 Giá trị protocol

Core value: standardization + interoperability.

Standardization: cùng rule, giảm chi phí communicate
Interoperability: vendor/stack khác nhau seamless integrate

Vd HTTP: Chrome access Nginx server, Python crawler crawl Java website. Chrome + Nginx không cần "biết nhau", chỉ cần đều theo HTTP.

0.4 AI Agent cũng cần protocol

AI Agent muốn "làm việc" cần:

Gọi external tool (xem thời tiết, gửi mail, op DB)
Cộng tác Agent khác (chia việc, làm task phức tạp)

Cần protocol chuẩn cho "AI gọi tool", "Agent đối thoại". Đây là nguồn gốc MCP + A2A.

1. Layer của Agent protocol

Layer	Protocol	Vấn đề	Ẩn dụ
1	Function Call	AI gọi local function thế nào	Não phát lệnh
2	MCP	AI connect external tool/data	Cổng USB-C
3	A2A	Agent communicate Agent	Slack/Teams nội bộ

Đọc table

Layer 1 (Function Call): capability LLM cơ bản — output JSON trigger function. Là "nền protocol", nhưng giống capability hơn standard protocol.

Layer 2 (MCP): Model Context Protocol, Anthropic release 2024-11. Chuẩn hoá cách AI connect external tool + data, như USB-C thống nhất cổng sạc.

Layer 3 (A2A): Agent-to-Agent, Google release 2025-04. Cho các Agent discover-communicate-collaborate, như nội bộ enterprise.

2. MCP (Model Context Protocol)

2.1 Info

Item	Content
Full	Model Context Protocol
Initiator	Anthropic
Release	2024-11-25
Docs	modelcontextprotocol.io
License	MIT
GitHub	github.com/modelcontextprotocol

Sao gọi "Context Protocol"?

Context = key cho LLM hiểu task. Core idea MCP: AI dynamically lấy context cần, không phải nhét hết vào Prompt.

Vd AI cần đọc 1 file → không cần bạn copy-paste content, mà qua MCP access file system trực tiếp.

2.2 Background

2024, với Claude 3.5 Sonnet, Anthropic phát hiện vấn đề: mỗi tool phải tích hợp riêng.

Tưởng:

AI đọc GitHub repo → viết integration GitHub
AI query DB → viết integration DB
AI op file system → viết integration FS

Mỗi integration lặp code: auth, error, data transform...

Anthropic viết:

"Introducing MCP, an open protocol that standardizes how applications provide context to LLMs."

Mục tiêu: tool dev viết 1 lần, mọi AI app support MCP đều dùng được.

2.3 MCP là gì?

MCP 是什么？

MCP（Model Context Protocol）是 Anthropic 于 2024 年 11 月推出的AI 与外部工具连接的统一标准。它让 AI 应用可以调用外部工具、读取资源数据、使用预定义提示，就像给 AI 装上了"手"和"眼睛"。

三大核心能力

能力

英文

作用

示例

工具

Tools

AI 可以调用的功能

查询天气、发送邮件、调用 API

资源

Resources

AI 可以读取的数据

文件内容、数据库记录、配置信息

提示

Prompts

预定义的提示模板

代码审查模板、写作模板

什么时候用 MCP？

当 AI 需要执行实际操作时

AI 不仅要回答问题，还要真正做事：发送邮件、操作文件、调用第三方 API

当 AI 需要访问私有数据时

读取本地文件、查询数据库、访问企业内部系统

当需要标准化工具接入时

一次开发，多个 AI 应用可用（Claude、Cursor、Windsurf 等）

如何使用 MCP？

开发 MCP Server

按 MCP 规范实现 Server，提供 tools/resources/prompts

配置 AI 应用连接

在 AI 应用中添加 MCP Server 配置（本地或远程）

AI 自动调用

AI 根据任务需求，自动发现并调用合适的工具或读取资源

3 capability core:

Capability	EN	Use	Vd
Tools	—	Function AI gọi	Query weather, send mail
Resources	—	Data AI đọc	File content, DB record
Prompts	—	Template prompt	Code review, writing template

2.4 MCP internal

MCP 内部实现客户端-服务器架构的通信细节

为什么 MCP 这么火？

MCP 之前，AI 只能"看"和"说"，有了 MCP，AI 终于可以"动手"了。它让 AI 可以操纵各种程序，真正帮你干活。

Cursor / Claude 等 AI 编辑器

直接读写文件、执行代码、操作 Git

浏览器自动化

AI 自动打开网页、点击按钮、填表单

数据库查询

直接查询/写入数据库，无需手动导出

AI 操作电脑

Windows-MCP 让 AI 直接操控鼠标键盘

自动化部署

Vercel-MCP 一键部署网站到线上

设计稿转代码

Figma-MCP 读取设计稿自动生成网页

如何使用 MCP？

使用 MCP 非常简单，只需要配置一个 mcp.json 文件，就可以在你的 IDE 里使用各种 MCP 工具。

找到 MCP Server

从 MCP 资源站或 GitHub 找到你需要的 MCP Server

官方 Server 列表github.com/modelcontextprotocol/servers

MCP.so（中文）mcp.so

Pulse MCP（英文）pulsemcp.com

Smithery（英文）smithery.ai

配置 mcp.json

在你的 AI 编辑器（Cursor / Claude Desktop 等）中找到 MCP 配置文件位置，添加 Server 配置

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/home/user/projects"
      ]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "your-token-here"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://user:pass@localhost/db"
      }
    }
  }
}

重启 IDE 即可使用

重启后，AI 会自动发现并加载 MCP 工具，你就可以直接让 AI 使用这些工具了

Skills 正在替代 MCP？

随着 Skills 的普及，越来越多的场景开始使用 Skills 替代 MCP 协议。Skills 更轻量、更易编写，适合大多数常见任务。MCP 更适合需要复杂工具集成、多客户端复用的场景。如果你只是想让 AI 做一些简单操作，建议优先考虑 Skills。

常见 IDE 的 mcp.json 位置

Cursor~/.cursor/mcp.json

Claude Desktop~/Library/Application Support/Claude/claude_desktop_config.json (macOS)

Windsurf~/.windsurf/mcp.json

如何实现一个 MCP Server？

假设你有一个天气 API，想把它封装成 MCP Server 让 AI 可以调用。下面以 Node.js 为例演示：

weather-mcp-server.js

import { Server } from '@modelcontextprotocol/sdk/server/index.js'
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'

// 1. 创建 MCP Server
const server = new Server({
  name: 'weather-server',
  version: '1.0.0'
}, {
  capabilities: { tools: {} }
})

// 2. 定义工具列表
server.setRequestHandler('tools/list', async () => ({
  tools: [{
    name: 'get_weather',
    description: '获取指定城市的天气信息',
    inputSchema: {
      type: 'object',
      properties: {
        city: { type: 'string', description: '城市名称' }
      },
      required: ['city']
    }
  }]
}))

// 3. 实现工具调用逻辑
server.setRequestHandler('tools/call', async (request) => {
  const { name, arguments: args } = request.params
  
  if (name === 'get_weather') {
    // 调用你的天气 API
    const response = await fetch(
      `https://api.weather.com/v1/current?city=${args.city}`
    )
    const data = await response.json()
    
    return {
      content: [{
        type: 'text',
        text: JSON.stringify(data)
      }]
    }
  }
})

// 4. 启动服务（stdio 方式）
const transport = new StdioServerTransport()
await server.connect(transport)

stdio vs HTTP+SSE 传输方式

stdio（本地进程）

MCP Server 作为子进程运行，通过标准输入输出通信

优点：简单、安全、适合本地工具

缺点：只能本地使用，不支持远程

HTTP + SSE（远程服务）

MCP Server 作为 HTTP 服务运行，支持 SSE 推送

优点：支持远程访问、多客户端共享

缺点：需要部署服务器、配置认证

通信流程（4 步）

1握手（initialize）▼

MCP Server 启动时向 Client 发送握手请求，声明自己的协议版本和能力

Server → Client

// Server 发送 initialize 请求
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "initialize",
  "params": {
    "protocolVersion": "2024-11-05",
    "capabilities": {
      "tools": {},
      "resources": {},
      "prompts": {}
    },
    "serverInfo": {
      "name": "filesystem",
      "version": "1.0.0"
    }
  }
}

2列工具（tools/list）▶

3调工具（tools/call）▶

4返回结果▶

技术深究：JSON-RPC 2.0 消息格式

请求消息结构

{
  "jsonrpc": "2.0",           // 协议版本
  "id": 1,                     // 请求 ID，用于匹配响应
  "method": "tools/call",      // 方法名
  "params": { ... }            // 参数对象
}

响应消息结构

// 成功响应
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": { ... }
}

// 错误响应
{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32600,
    "message": "Invalid Request"
  }
}

JSON-RPC 2.0 是无状态协议，每个请求都需要包含 id 用于匹配响应

技术深究：两种传输方式

stdio（本地进程）

适用于本地工具，通过标准输入输出通信

// 启动 MCP Server 作为子进程
npx @modelcontextprotocol/server-filesystem ./project

// 通过 stdio 通信
// stdin: 接收请求
// stdout: 发送响应

HTTP + SSE（远程）

适用于远程服务，支持长连接推送

// HTTP 传输（Server-Sent Events）
POST /mcp HTTP/1.1
Content-Type: application/json

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": { ... }
}

// SSE 长连接用于推送
GET /mcp/sse HTTP/1.1
// 持续接收服务器推送的更新

技术深究：MCP 核心 API

initialize初始化

Server 向 Client 声明协议版本和能力

tools/list工具列表

获取 Server 提供所有可用工具

tools/call调用工具

实际调用某个工具并获取结果

resources/list资源列表

获取可访问的资源（如文件、数据库）

resources/read读取资源

读取某个资源的内容

prompts/list提示模板

获取预定义的提示模板

2.5 Ẩn dụ: USB-C

MCP như USB-C:

Trước: mỗi device 1 cổng (tròn, dẹt, magnetic...)
Giờ: USB-C thống nhất sạc + transfer
MCP: thống nhất cách AI connect mọi tool

Tool dev implement 1 lần MCP Server, mọi AI app support MCP (Claude, Cursor, Windsurf) đều dùng.

2.6 MCP scenario

Scenario	Note	Vd
Local file	AI đọc/sửa local file	Đọc codebase, phân tích log
DB query	AI query DB trực tiếp	SQL, data analysis
API call	AI gọi 3rd party	GitHub API, Slack, mail
Dev tool	AI dùng dev tool	Git, terminal

Case thực:

Cursor/Windsurf: MCP connect FS, Git, terminal
Claude Desktop: MCP connect note app, mail
Auto script: AI execute auto task (backup, deploy, sync)

3. A2A (Agent-to-Agent Protocol)

3.1 Info

Item	Content
Full	Agent-to-Agent Protocol
Initiator	Google
Release	2025-04-09
Docs	google.github.io/A2A
License	Apache 2.0
GitHub	github.com/google/A2A

Sao Google?

Google release A2A tại Cloud Next 2025, liên quan enterprise AI strategy.

Google nghĩ: tương lai enterprise AI không phải 1 super-Agent, mà nhiều specialized Agent collaborate — có cái data analysis, có cái code gen, có cái doc process.

Cần standard communicate.

3.2 Background

MCP giải "AI connect tool", còn: multi-Agent cộng tác thế nào?

Vd:

Agent A: requirements analyst
Agent B: code gen
Agent C: test

User: "Build login function"

A phân tích req → assign B; B viết code → cho C test. Communicate thế nào?

Google:

"A2A is an open protocol that enables AI agents to communicate with each other, facilitating collaboration across different frameworks and vendors."

Mục tiêu: Agent khác vendor/framework seamless collaborate.

3.3 A2A là gì?

A2A 是什么？

A2A（Agent-to-Agent Protocol）是 Google 于 2025 年 4 月推出的Agent 之间相互协作的通信标准。它让不同厂商、不同框架的 Agent 能够相互发现、分配任务、交换信息，就像给 AI 世界装上了"对讲机"。

核心概念

Agent Card（Agent 名片）

每个 Agent 公开的元数据，包括能力描述、版本号、端点地址等，相当于人的"名片"

Task（任务）

Agent 之间传递的工作单元，可以包含多轮对话、文件附件等

Message（消息）

Agent 之间的通信内容，支持文本、文件、语音等多模态

SSE（Server-Sent Events）

服务器推送技术，用于实时任务进度更新

什么时候用 A2A？

当需要多个 Agent 协作完成复杂任务时

一个 Agent 负责需求分析，一个负责写代码，一个负责测试，各自发挥专长

当需要集成不同厂商的 Agent 时

Google 的 Agent、Anthropic 的 Agent、OpenAI 的 Agent 需要相互协作

当需要任务委托和进度追踪时

主 Agent 分配任务给专家 Agent，并实时接收进度更新

如何使用 A2A？

发布 Agent Card

在 /.well-known/agent.json 路径暴露 Agent 的能力描述

发现 Agent

通过 agents/get API 获取其他 Agent 的名片，了解其能力

发送任务

通过 tasks/send API 发送任务，支持 SSE 接收进度更新

获取结果

任务完成后，通过 tasks/get API 获取最终结果

3 core concept:

Concept	EN	Use	Ẩn dụ
Agent Card	—	Mô tả capability	Thẻ nhân viên
Task	—	Đơn vị công việc	Ticket
Message	—	Nội dung communicate	Chat log

3.4 A2A internal

A2A 内部实现对等网络架构的通信细节

A2A 可以做什么？

A2A 让多个 AI Agent 可以相互协作，不再是单打独斗。一个复杂任务可以分配给多个专业 Agent，每个 Agent 做自己擅长的事。

软件开发流水线

需求分析 Agent → 代码 Agent → 测试 Agent → 部署 Agent

多厂商 Agent 集成

Google、Anthropic、OpenAI 的 Agent 可以相互调用

企业工作流

HR Agent、财务 Agent、审批 Agent 协同处理业务流程

智能客服升级

接待 Agent → 业务 Agent → 人工 Agent 逐级转接

科研协作

文献 Agent → 实验 Agent → 分析 Agent → 报告 Agent

自动化运维

监控 Agent → 诊断 Agent → 修复 Agent → 通知 Agent

如何使用 A2A？

A2A 目前还在早期阶段，主要由 Google 推动。如果你想尝试 A2A，需要开发支持 A2A 协议的 Agent 服务。

实现 Agent Card 端点

在你的 Agent 服务中暴露 /.well-known/agent.json，声明 Agent 的能力和版本

实现 A2A API

实现 agents/get、tasks/send、tasks/get 等核心 API

部署并注册 Agent

将 Agent 部署到服务器，并在 Agent 注册表中登记，让其他 Agent 可以发现它

当前状态

A2A 协议于 2025 年 4 月发布，目前还在快速发展中。Google 提供了参考实现，但生态还在建设中。建议关注官方文档获取最新进展。

通信流程（5 步）

1发现（agents/get）▼

Agent 之间通过 HTTP 请求获取对方的 Agent Card，了解对方的能力和版本

HTTP 请求

// Agent A 获取 Agent B 的 Agent Card
GET /.well-known/agent.json HTTP/1.1
Host: agent-b.company.com

// 响应
{
  "name": "Code Agent",
  "description": "专业代码生成 Agent",
  "url": "https://agent-b.company.com",
  "version": "1.0.0",
  "capabilities": {
    "streaming": true,
    "pushNotifications": true
  },
  "skills": [
    {"id": "code-gen", "name": "代码生成"},
    {"id": "code-review", "name": "代码审查"}
  ]
}

2发任务（tasks/send）▶

3执行（Task Processing）▶

4推送（SSE）▶

5返回结果（tasks/get）▶

技术深究：Agent Card 名片格式

Agent Card 是一个 JSON 文件，通常放在 /.well-known/agent.json 路径

Agent Card 示例

{
  "name": "代码生成 Agent",
  "description": "专业的前后端代码生成 Agent",
  "url": "https://code-agent.company.com",
  "version": "1.0.0",
  "capabilities": {
    "streaming": true,
    "pushNotifications": true
  },
  "skills": [
    {
      "id": "frontend",
      "name": "前端开发",
      "description": "React/Vue/Angular"
    },
    {
      "id": "backend", 
      "name": "后端开发",
      "description": "Node/Python/Go"
    }
  ],
  "authentication": {
    "schemes": ["Bearer", "OAuth2"]
  }
}

通过 Agent Card，Agent 之间可以相互发现，了解对方的能力和版本，实现互操作

技术深究：HTTP + SSE 通信

任务发送（HTTP POST）

POST /tasks/send HTTP/1.1
Host: agent-b.company.com
Content-Type: application/json
Authorization: Bearer {token}

{
  "id": "task-001",
  "message": {
    "role": "user",
    "parts": [{ "type": "text", "text": "写一个登录接口" }]
  }
}

实时推送（SSE）

GET /tasks/task-001/sse HTTP/1.1
Authorization: Bearer {token}

event: progress
data: {"status": "processing", "progress": 50}

event: completed  
data: {"status": "completed", "result": {...}}

SSE（Server-Sent Events）允许服务器主动推送消息，适合长时任务的状态更新

技术深究：A2A 核心 API

GETagents/get

获取指定 Agent 的 Agent Card，了解其能力

POSTtasks/send

发送任务给目标 Agent，同步等待结果

POSTtasks/sendSubscribe

发送任务并订阅 SSE 推送，实时获取进度

GETtasks/get

根据任务 ID 获取任务状态和结果

GETtasks/cancel

取消正在执行的任务

技术深究：认证机制

API Key

简单的认证方式，适合内部 Agent 通信

Authorization: Bearer sk-xxxxx
# 或
Authorization: ApiKey sk-xxxxx

OAuth 2.0

企业级认证，支持令牌刷新和权限控制

Authorization: Bearer {access_token}
# 支持刷新令牌
POST /oauth/token
{
  "grant_type": "refresh_token",
  "refresh_token": "xxx"
}

3.5 Ẩn dụ: Slack/Teams nội bộ

A2A như Slack nội bộ:

Agent Card: thẻ mỗi người, name + dept + role
Send task: @ai đó, assign task
Chat: trong task có thể chat
Task tracking: thấy progress + status

Agent khác = đồng nghiệp khác, A2A cho collaborate project phức tạp.

3.6 A2A scenario

Scenario	Note	Vd
Software dev	Multi-Agent dev	Req → code → test → deploy
Enterprise workflow	Dept khác Agent collaborate	HR + Finance + Legal Agent
Smart CS	Specialized Agent chia việc	Greet → answer → escalate → record
Data analysis	Multi-Agent	Collect → clean → analyze → visualize → report

Case:

Google Agent Space: multi-Agent xử doc, mail, calendar
Dev team: Req → Code → Test → Deploy Agent
CS system: Greet → Specialist → Human escalate Agent

4. MCP vs A2A

4.1 Khác biệt

Dim	MCP	A2A
Initiator	Anthropic (2024.11)	Google (2025.04)
Position	AI ↔ Tool	Agent ↔ Agent
Scope	Client-Server	Peer-to-Peer
Format	JSON-RPC 2.0	HTTP + JSON
Ẩn dụ	USB-C	Slack

4.2 Quan hệ

MCP + A2A không phải cạnh tranh, mà bổ sung:

MCP vs A2AAI Agent 两大协议的定位差异

想象你在一个大型商场：MCP 就像商场的"统一插座标准"，让各种电器（工具）都能插上使用；A2A 就像商场的"内部对讲系统"，让不同店铺（Agent）之间可以协作。

MCP工具连接

Model Context Protocol

AI 与外部工具、数据源的连接协议，让工具开发者写一次代码，所有 AI 应用都能用

发起方Anthropic

发布时间2024.11

架构Client-Server

数据格式JSON-RPC 2.0

类比USB-C 接口 —— 统一各种设备的充电方式

A2AAgent协作

Agent-to-Agent Protocol

Agent 之间的通信协议，让不同厂商、不同框架的 Agent 能够无缝协作

发起方Google

发布时间2025.04

架构Peer-to-Peer

数据格式HTTP + JSON

类比企业微信 —— 让同事之间可以发任务、聊天

核心思想：MCP 和 A2A 不是竞争关系，而是互补关系。MCP 解决"AI 如何获取外部能力"，A2A 解决"多个 AI 如何协作"。

4.3 Chọn?

Scenario	Chọn
AI gọi local function/tool	Function Call
Dùng 3rd party tool (DB, API, FS)	MCP
Build multi-Agent collaborative system	A2A
Cần cả tool integration + multi-Agent	MCP + A2A

5. Tương lai

5.1 Ecosystem

MCP (đến 2026):

Official Server: FS, SQLite, Git, PostgreSQL
Community: Slack, Notion, Figma, Stripe
App support: Claude Desktop, Cursor, Windsurf, Zed, Cline

A2A (mới ra):

Google Agent products đầu tiên support
Open source SDK đang phát triển
Enterprise đang khám phá

5.2 Standardization

Hiện Agent protocol đang "thời chiến quốc":

MCP + A2A mainstream
Còn ANP, AGP và mới khác
Tương lai có thể merge/unify

Như Internet:

Sớm: nhiều LAN protocol
Sau: TCP/IP standard
Giờ: Agent protocol có thể đi tới unify

6. Tóm tắt

Key

Protocol	1 câu	Release	Initiator	Use
MCP	"USB-C" cho AI ↔ Tool	2024.11	Anthropic	Tool integration
A2A	"Slack" cho Agent collaboration	2025.04	Google	Multi-Agent

Insight:

MCP giải "AI lấy external capability"
A2A giải "Multi-AI collaborate"
Bổ sung, tương lai có thể merge
Chọn theo scenario, không có silver bullet

2026 cho VN dev

MCP tăng tốc dữ dội: 500+ MCP server công khai trên GitHub
Claude Code + MCP: pipeline AI dev hiện đại
A2A vẫn nascent: chưa nhiều case thực, theo dõi Google
Cursor + MCP: setup MCP server cho project = boost productivity
Bài tập: viết 1 MCP server đơn giản đọc Notion DB

Tài liệu

MCP: modelcontextprotocol.io
MCP GitHub: github.com/modelcontextprotocol
Anthropic blog: "Introducing MCP" (2024-11-25)
A2A: google.github.io/A2A
A2A GitHub: github.com/google/A2A
Google Cloud blog: "Announcing A2A" (2025-04-09)

AI Agent Protocol (MCP & A2A) ​

0. Protocol là gì? ​

0.1 Sao cần protocol? ​

0.2 Protocol thường gặp ​

0.3 Giá trị protocol ​

0.4 AI Agent cũng cần protocol ​

1. Layer của Agent protocol ​

2. MCP (Model Context Protocol) ​

2.1 Info ​

2.2 Background ​

2.3 MCP là gì? ​

2.4 MCP internal ​

2.5 Ẩn dụ: USB-C ​

2.6 MCP scenario ​

3. A2A (Agent-to-Agent Protocol) ​

3.1 Info ​

3.2 Background ​

3.3 A2A là gì? ​

3.4 A2A internal ​

3.5 Ẩn dụ: Slack/Teams nội bộ ​

3.6 A2A scenario ​

4. MCP vs A2A ​

4.1 Khác biệt ​

4.2 Quan hệ ​

4.3 Chọn? ​

5. Tương lai ​

5.1 Ecosystem ​

5.2 Standardization ​

6. Tóm tắt ​

Tài liệu ​