AI エージェントプロトコル（MCP & A2A）

核心的課題

AI エージェントはどのようにして外部世界と「対話」するのか？ インターネットに HTTP プロトコルが必要であるように、AI エージェントにも標準化された通信プロトコルが必要です。本章では、最も主流な 2 つのエージェントプロトコルである MCP と A2A を紹介します。これらはそれぞれ、AI とツール間の通信、エージェント間の通信という問題を解決します。

0. プロトコルとは？

コンピュータ分野において、プロトコル（Protocol） とは、異なるシステムやプログラムが相互に「理解」し「通信」できるようにするための、標準化されたルールと取り決めのセットです。

0.1 なぜプロトコルが必要か？

あるシナリオを想像してみてください：友人に荷物を送る際、住所を記入する必要があります。もし全員が異なる形式で住所を書いたら、配達員は配送できません。プロトコルは「住所の書き方」の標準を定めるものです——都道府県、市区町村、番地という形式に従えば、誰でも理解できます。

コンピュータも同様です。2 つのプログラムが通信するには、以下を取り決める必要があります：

データ形式は何か？（JSON？バイナリ？）
どのように接続を確立するか？（ハンドシェイクの流れ）
エラーが発生した場合はどうするか？（エラーハンドリング）

0.2 コンピュータにおける一般的なプロトコル

プロトコル	役割	日常的な使用例
HTTP	Web ページ転送プロトコル	ブラウザで Web ページを開く
HTTPS	暗号化された HTTP	ネットバンキング、決済ページ
TCP/IP	インターネットの基盤プロトコル	すべてのネットワーク通信
DNS	ドメイン名解決プロトコル	`google.com` を IP アドレスに変換
SMTP	メール送信プロトコル	メールの送信
WebSocket	双方向リアルタイム通信	チャットアプリ、オンラインゲーム
SSH	セキュアなリモートログイン	サーバーへの接続
FTP	ファイル転送プロトコル	ファイルのアップロード/ダウンロード

これらのプロトコルがインターネットの基盤を構成しています。これらがなければ、Web ページの閲覧、メールの送信、動画の視聴はできません。

0.3 プロトコルの価値

プロトコルの核心的価値は標準化と相互運用性です：

標準化：全員が同じルールに従うことで、コミュニケーションコストを削減
相互運用性：異なるベンダー、異なる技術スタックのシステムがシームレスに連携可能

例えば HTTP プロトコルは、Chrome ブラウザが Nginx サーバーにアクセスすることを可能にし、Python クローラが Java ウェブサイトのデータを取得することを可能にします。Chrome と Nginx が互いを「認識」する必要はなく、両方が HTTP プロトコルに準拠していればよいのです。

0.4 AI エージェントにもプロトコルが必要

AI エージェントが実際に「作業」するには、以下が必要です：

外部ツールの呼び出し（天気の確認、メール送信、データベース操作）
他のエージェントとの協調（複雑なタスクの分業と協力）

そのためには、「AI がどのようにツールを呼び出すか」「エージェント間でどのように対話するか」を規定する標準化されたプロトコルが必要です。これが MCP と A2A の由来です。

1. エージェントプロトコルの階層

具体的なプロトコルを深く理解する前に、まずエージェントエコシステムにおける通信の階層を見てみましょう：

階層	プロトコル	解決する問題	例え
1	Function Call	AI がローカル関数を呼び出す方法	脳が指令を出す
2	MCP	AI が外部ツールやデータソースに接続する方法	USB-C インターフェース
3	A2A	エージェント間の協調通信方法	Slack

この表の行ごとの解説

第1層（Function Call）：これは大規模モデルの最も基本的な能力です——構造化データ（JSON）を出力して関数の実行をトリガーします。これは「プロトコル」の基礎ですが、それ自体は標準プロトコルというよりは一つの能力です。

第2層（MCP）：Model Context Protocol、2024 年 11 月に Anthropic が発表しました。AI と外部ツール・データソース間の接続方法を標準化し、USB-C があらゆるデバイスの充電インターフェースを統一したのと同様の役割を果たします。

第3層（A2A）：Agent-to-Agent Protocol、2025 年 4 月に Google が発表しました。異なるエージェントが相互に発見、通信、協調できるようにし、Slack が同僚間でタスクを送ったりチャットしたりできるようにするのと似ています。

本章では、第 2、3 層の 2 つの正式なプロトコルである MCP と A2A に焦点を当てます。

2. MCP (Model Context Protocol)

2.1 プロトコル基本情報

項目	内容
正式名称	Model Context Protocol
発起元	Anthropic
公開日	2024 年 11 月 25 日
公式ドキュメント	modelcontextprotocol.io
オープンソースライセンス	MIT License
GitHub	github.com/modelcontextprotocol

なぜ「Context Protocol」と呼ばれるのか？

Context（コンテキスト） は、大規模モデルがタスクを理解するための鍵です。MCP の核心的な考え方は：AI が必要なコンテキスト情報を動的に取得できるようにすることであり、すべての情報をプロンプトに詰め込むことではありません。

例えば、AI がファイルを読む必要がある場合、ファイルの内容をコピー＆ペーストする必要はなく、MCP を通じて直接ファイルシステムにアクセスします。

2.2 公開の背景

2024 年、Claude 3.5 Sonnet のリリースに伴い、Anthropic はある問題を発見しました：各ツールを個別に統合しなければならないことです。

想像してみてください：

AI に GitHub リポジトリを読ませたい → GitHub 統合コードを書く必要がある
AI にデータベースをクエリさせたい → データベース統合コードを書く必要がある
AI にファイルシステムを操作させたい → ファイルシステム統合コードを書く必要がある

各統合で、認証、エラーハンドリング、データ変換といった類似のコードを繰り返し書く必要がありました……

Anthropic は公式ブログで次のように述べています：

"We're introducing the Model Context Protocol (MCP), an open protocol that standardizes how applications provide context to LLMs."

核心的目標：ツール開発者が一度コードを書けば、MCP をサポートするすべての AI アプリケーションがそれを使用できるようにすること。

2.3 MCP とは？

What is MCP?

MCP (Model Context Protocol) is a unified standard introduced by Anthropic in November 2024 for connecting AI with external tools. It lets AI applications call tools, read resources, and use predefined prompts, giving AI practical "hands" and "eyes".

Three Core Capabilities

Capability

English

Role

Example

Tools

Tools

Functions AI can call

Check weather, send email, call APIs

Resources

Resources

Data AI can read

File content, database records, configuration

Prompts

Prompts

Predefined prompt templates

Code review templates, writing templates

When should you use MCP?

When AI needs to perform real actions

AI should not only answer questions, but also send emails, operate files, and call third-party APIs.

When AI needs access to private data

Read local files, query databases, or access internal business systems.

When tool integration should be standardized

Build once and reuse across AI applications such as Claude, Cursor, and Windsurf.

How do you use MCP?

Develop an MCP Server

Implement a server that provides tools, resources, and prompts according to the MCP spec.

Configure the AI app connection

Add the MCP Server configuration to your AI app, either local or remote.

Let AI call it automatically

AI discovers and calls suitable tools or reads resources based on the task.

3 つの核心的能力：

能力	英語	役割	例
ツール	Tools	AI が呼び出せる機能	天気の確認、メール送信
リソース	Resources	AI が読み取れるデータ	ファイル内容、データベースレコード
プロンプト	Prompts	事前定義されたプロンプトテンプレート	コードレビューテンプレート、執筆テンプレート

2.4 MCP の内部実装

MCP InternalsCommunication details of the client-server architecture

Why is MCP so popular?

Before MCP, AI could only read and respond. With MCP, AI can finally take action by operating programs and helping with real work.

AI editors such as Cursor and Claude

Read and write files, execute code, and operate Git directly.

Browser automation

AI opens pages, clicks buttons, and fills forms automatically.

Database queries

Query and write databases directly without manual exports.

Computer control by AI

Windows-MCP lets AI control the mouse and keyboard directly.

Automated deployment

Vercel-MCP deploys websites online in one flow.

Design to code

Figma-MCP reads designs and generates web pages automatically.

How do you use MCP?

Using MCP is simple: configure an mcp.json file, then your IDE can use MCP tools.

Find an MCP Server

Find the MCP Server you need from an MCP directory or GitHub.

Official server listgithub.com/modelcontextprotocol/servers

MCP.somcp.so

Pulse MCPpulsemcp.com

Smitherysmithery.ai

Configure mcp.json

Find the MCP config location in your AI editor, such as Cursor or Claude Desktop, and add the server configuration.

{
  "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"
      }
    }
  }
}

Restart the IDE

After restart, AI discovers and loads MCP tools automatically, so you can ask it to use them.

Are Skills replacing MCP?

As Skills become more common, many scenarios are starting to use Skills instead of the MCP protocol. Skills are lighter and easier to write for common tasks. MCP remains better for complex tool integrations and reuse across multiple clients. For simple operations, consider Skills first.

Common mcp.json locations

Cursor~/.cursor/mcp.json

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

Windsurf~/.windsurf/mcp.json

How do you implement an MCP Server?

Suppose you have a weather API and want to wrap it as an MCP Server that AI can call. This Node.js example shows the shape:

weather-mcp-server.js

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

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

// 2. Define tool list
server.setRequestHandler('tools/list', async () => ({
  tools: [{
    name: 'get_weather',
    description: 'Get weather for a city',
    inputSchema: {
      type: 'object',
      properties: {
        city: { type: 'string', description: 'City name' }
      },
      required: ['city']
    }
  }]
}))

// 3. Implement tool call logic
server.setRequestHandler('tools/call', async (request) => {
  const { name, arguments: args } = request.params

  if (name === 'get_weather') {
    // Call your 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. Start service through stdio
const transport = new StdioServerTransport()
await server.connect(transport)

stdio vs HTTP+SSE transport

stdio (local process)

The MCP Server runs as a child process and communicates through standard input and output.

Pros: simple, secure, and suitable for local tools.

Cons: local only; no remote access.

HTTP + SSE (remote service)

The MCP Server runs as an HTTP service and supports SSE pushes.

Pros: remote access and sharing across multiple clients.

Cons: requires server deployment and authentication.

Communication Flow (4 Steps)

1Handshake (initialize)▼

When the MCP Server starts, it sends an initialize request to the client and declares protocol version and capabilities.

Server → Client

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

2List tools (tools/list)▶

3Call tool (tools/call)▶

4Return result▶

Deep Dive: JSON-RPC 2.0 Message Format

Request Message Structure

{
  "jsonrpc": "2.0",           // protocol version
  "id": 1,                     // request ID used to match response
  "method": "tools/call",      // method name
  "params": { ... }            // parameter object
}

Response Message Structure

// Successful response
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": { ... }
}

// Error response
{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32600,
    "message": "Invalid Request"
  }
}

JSON-RPC 2.0 is stateless. Every request includes an id so the client can match the response.

Deep Dive: Two Transport Modes

stdio (local process)

Used for local tools through standard input and output.

// Start MCP Server as a child process
npx @modelcontextprotocol/server-filesystem ./project

// Communicate through stdio
// stdin: receive requests
// stdout: send responses

HTTP + SSE (remote)

Used for remote services with long-lived push connections.

// HTTP transport with Server-Sent Events
POST /mcp HTTP/1.1
Content-Type: application/json

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

// SSE long connection for push updates
GET /mcp/sse HTTP/1.1
// Continuously receive server updates

Deep Dive: MCP Core APIs

initializeInitialize

Server declares protocol version and capabilities to the client.

tools/listTool list

Get all available tools provided by the server.

tools/callCall tool

Call a specific tool and receive the result.

resources/listResource list

Get accessible resources such as files and databases.

resources/readRead resource

Read content from a specific resource.

prompts/listPrompt templates

Get predefined prompt templates.

2.5 例えで理解する：USB-C インターフェース

MCP は USB-C インターフェース のようなものです：

以前：各デバイスに独自の充電ポート（丸型、平型、マグネット式……）
現在：USB-C がすべてのデバイスの充電とデータ転送を統一
MCP：AI とすべてのツール間の接続方法を統一

ツール開発者は MCP Server を一度実装するだけで、MCP をサポートするすべての AI アプリケーション（Claude、Cursor、Windsurf など）が直接使用できます。

2.6 MCP の典型的なユースケース

シナリオ	説明	例
ローカルファイル操作	AI にローカルファイルの読み取り/変更を許可	コードベースの読み取り、ログファイルの分析
データベースクエリ	AI にデータベースの直接クエリを許可	SQL クエリ、データ分析
API 呼び出し	AI にサードパーティサービスの呼び出しを許可	GitHub API、Slack、メール
開発ツール統合	AI に開発ツールの使用を許可	Git 操作、ターミナルコマンド

実際の事例：

Cursor/Windsurf：MCP を通じてファイルシステム、Git、ターミナルに接続
Claude Desktop：MCP を通じてノートアプリ、メールクライアントに接続
自動化スクリプト：AI に自動化タスク（バックアップ、デプロイ、データ同期）を実行させる

3. A2A (Agent-to-Agent Protocol)

3.1 プロトコル基本情報

項目	内容
正式名称	Agent-to-Agent Protocol
発起元	Google
公開日	2025 年 4 月 9 日
公式ドキュメント	google.github.io/A2A
オープンソースライセンス	Apache 2.0
GitHub	github.com/google/A2A

なぜ Google が発起したのか？

Google は Cloud Next 2025 カンファレンスで A2A を発表し、そのエンタープライズ AI 戦略と密接に関連しています。

Google は次のように考えています：未来のエンタープライズ AI は単一のスーパーエージェントではなく、複数の専門エージェントの協調です——あるエージェントはデータ分析を担当し、別のエージェントはコード生成を担当し、また別のエージェントはドキュメント処理を担当します。

これらのエージェントには標準化された通信手段が必要であり、そこで A2A が生まれました。

3.2 公開の背景

MCP は「AI がツールにどう接続するか」という問題を解決しましたが、もう一つの問題が残っています：複数のエージェントがどのように協調するか？

あるシナリオを想像してください：

エージェント A は「要件分析の専門家」
エージェント B は「コード生成の専門家」
エージェント C は「テストの専門家」

ユーザーが「ログイン機能を開発してほしい」と言います。

エージェント A が要件を分析した後、タスクをエージェント B に割り当てる必要があります。エージェント B がコードを書いた後、エージェント C にテストを依頼する必要があります。これらはどのように通信するのでしょうか？

Google は公式ブログで次のように述べています：

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

核心的目標：異なるベンダー、異なるフレームワークで開発されたエージェントがシームレスに協調できるようにすること。

3.3 A2A とは？

What is A2A?

A2A (Agent-to-Agent Protocol) is a communication standard introduced by Google in April 2025 for collaboration between agents. It lets agents from different vendors and frameworks discover each other, assign tasks, and exchange information, like an intercom for the AI world.

Core Concepts

Agent Card

Public metadata for each agent, including capability descriptions, version, and endpoint.

Task

A work unit passed between agents. It can include multi-turn dialogue and file attachments.

Message

Communication content between agents, supporting text, files, audio, and other modalities.

SSE (Server-Sent Events)

A server push mechanism used for real-time task progress updates.

When should you use A2A?

When multiple agents need to complete a complex task

One agent analyzes requirements, another writes code, and another tests the result.

When integrating agents from different vendors

Agents from Google, Anthropic, OpenAI, and others need to collaborate.

When task delegation and progress tracking are needed

A main agent assigns work to expert agents and receives live progress updates.

How do you use A2A?

Publish an Agent Card

Expose the agent capability description at /.well-known/agent.json.

Discover agents

Use the agents/get API to fetch another agent card and inspect capabilities.

Send a task

Use the tasks/send API to send work, optionally receiving progress through SSE.

Fetch the result

After completion, use the tasks/get API to retrieve the final result.

3 つの核心的概念：

概念	英語	役割	例え
Agent Card	エージェント名刺	エージェントの能力を記述	社員証
Task	タスク	実行する作業単位	作業チケット
Message	メッセージ	エージェント間の通信内容	チャット履歴

3.4 A2A の内部実装

A2A InternalsCommunication details of the peer-to-peer architecture

What can A2A do?

A2A lets multiple AI agents collaborate instead of working alone. A complex task can be assigned to specialized agents, each doing what it is best at.

Software development pipeline

Requirements agent → code agent → test agent → deployment agent

Multi-vendor agent integration

Agents from Google, Anthropic, and OpenAI can call each other.

Enterprise workflows

HR, finance, and approval agents coordinate business processes.

Customer support escalation

Reception agent → business agent → human agent handoff

Research collaboration

Literature agent → experiment agent → analysis agent → report agent

Automated operations

Monitoring agent → diagnosis agent → repair agent → notification agent

How do you use A2A?

A2A is still early and mainly driven by Google. To try it, you need to develop an agent service that supports the A2A protocol.

Implement the Agent Card endpoint

Expose /.well-known/agent.json in your agent service and declare capabilities and version.

Implement A2A APIs

Implement core APIs such as agents/get, tasks/send, and tasks/get.

Deploy and register the agent

Deploy the agent to a server and register it so other agents can discover it.

Current Status

A2A was released in April 2025 and is still evolving quickly. Google provides reference implementations, while the ecosystem is still being built. Follow the official docs for current progress.

Communication Flow (5 Steps)

1Discovery (agents/get)▼

Agents fetch each other Agent Cards over HTTP to understand capabilities and versions.

HTTP request

// Agent A fetches Agent B's Agent Card
GET /.well-known/agent.json HTTP/1.1
Host: agent-b.company.com

// Response
{
  "name": "Code Agent",
  "description": "Professional code generation agent",
  "url": "https://agent-b.company.com",
  "version": "1.0.0",
  "capabilities": {
    "streaming": true,
    "pushNotifications": true
  },
  "skills": [
    {"id": "code-gen", "name": "Code generation"},
    {"id": "code-review", "name": "Code review"}
  ]
}

2Send task (tasks/send)▶

3Process task▶

4Push updates (SSE)▶

5Return result (tasks/get)▶

Deep Dive: Agent Card Format

An Agent Card is a JSON file, usually hosted at /.well-known/agent.json.

Agent Card Example

{
  "name": "Code Generation Agent",
  "description": "Professional frontend and backend code generation agent",
  "url": "https://code-agent.company.com",
  "version": "1.0.0",
  "capabilities": {
    "streaming": true,
    "pushNotifications": true
  },
  "skills": [
    {
      "id": "frontend",
      "name": "Frontend development",
      "description": "React/Vue/Angular"
    },
    {
      "id": "backend",
      "name": "Backend development",
      "description": "Node/Python/Go"
    }
  ],
  "authentication": {
    "schemes": ["Bearer", "OAuth2"]
  }
}

With Agent Cards, agents can discover each other, understand capabilities and versions, and interoperate.

Deep Dive: HTTP + SSE Communication

Task Send (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": "Write a login endpoint" }]
  }
}

Real-time Push (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) lets the server push messages, which works well for long-running task status updates.

Deep Dive: A2A Core APIs

GETagents/get

Fetch the target agent Agent Card and inspect capabilities.

POSTtasks/send

Send a task to the target agent and wait synchronously for the result.

POSTtasks/sendSubscribe

Send a task and subscribe to SSE progress updates.

GETtasks/get

Fetch task status and result by task ID.

GETtasks/cancel

Cancel a running task.

Deep Dive: Authentication

API Key

Simple authentication for internal agent communication.

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

OAuth 2.0

Enterprise authentication with token refresh and permission control.

Authorization: Bearer {access_token}
# refresh token supported
POST /oauth/token
{
  "grant_type": "refresh_token",
  "refresh_token": "xxx"
}

3.5 例えで理解する：Slack

A2A は Slack のようなものです：

Agent Card：各人のプロフィール、氏名、部門、役職を表示
タスク送信：@メンションで誰かにタスクを割り当て
チャットコミュニケーション：タスク実行中にいつでもコミュニケーション可能
タスク追跡：タスクの進捗と状態を確認可能

異なるエージェントは異なる同僚のようなもので、A2A によって複雑なプロジェクトを協力して完了できます。

3.6 A2A の典型的なユースケース

シナリオ	説明	例
ソフトウェア開発	複数エージェントによる開発タスクの協調実行	要件分析→コード→テスト→デプロイ
エンタープライズワークフロー	異なる部門のエージェントによる業務処理の協調	人事エージェント + 経理エージェント + 法務エージェント
インテリジェントカスタマーサポート	複数の専門エージェントによる分業対応	受付→回答→転送→記録
データ分析	複数エージェントによるデータ分析の協調	収集→クレンジング→分析→可視化→レポート

実際の事例：

Google Agent Space：社内の複数エージェントがドキュメント、メール、スケジュールを協調処理
ソフトウェア開発チーム：要件エージェント → コードエージェント → テストエージェント → デプロイエージェント
インテリジェントカスタマーサポートシステム：受付エージェント → 専門回答エージェント → 有人転送エージェント

4. MCP vs A2A：比較と関係

4.1 核心的な違い

次元	MCP	A2A
発起元	Anthropic (2024.11)	Google (2025.04)
位置付け	AI とツールの接続	エージェント間の協調
通信範囲	Client-Server	Peer-to-Peer
データ形式	JSON-RPC 2.0	HTTP + JSON
例え	USB-C インターフェース	Slack

4.2 両者の関係

MCP と A2A は競合関係ではなく、補完関係です：

MCP vs A2APositioning differences between two major AI Agent protocols

Imagine a large shopping mall: MCP is like a unified outlet standard, so every tool can plug in; A2A is like an internal intercom system, so different agents can coordinate with each other.

MCPTool connection

Model Context Protocol

A protocol that connects AI applications with external tools and data sources, so tool builders can write once and support many AI apps.

InitiatorAnthropic

Released2024.11

ArchitectureClient-Server

Data formatJSON-RPC 2.0

AnalogyUSB-C: one interface for many devices

A2AAgent collaboration

Agent-to-Agent Protocol

A communication protocol that lets agents from different vendors and frameworks collaborate smoothly.

InitiatorGoogle

Released2025.04

ArchitecturePeer-to-Peer

Data formatHTTP + JSON

AnalogyWork chat: coworkers can assign tasks and talk

Core idea:MCP and A2A are complementary, not competing. MCP answers "how can AI access external capabilities"; A2A answers "how can multiple AI agents collaborate".

4.3 どのように選択するか？

シナリオ	選択
AI にローカル関数やツールを呼び出させる	Function Call
サードパーティツール（データベース、API、ファイルシステム）を使用する	MCP
マルチエージェント協調システムを構築する	A2A
ツール統合とマルチエージェント協調の両方が必要	MCP + A2A

5. プロトコルの将来動向

5.1 エコシステムの発展

MCP エコシステム（2025 年初頭現在）：

公式提供の Server：ファイルシステム、SQLite、Git、PostgreSQL など
コミュニティ貢献の Server：Slack、Notion、Figma、Stripe など
MCP 対応アプリケーション：Claude Desktop、Cursor、Windsurf、Zed など

A2A エコシステム（公開直後）：

Google 自社のエージェント製品がいち早く対応
オープンソースコミュニティが各言語の SDK を開発中
エンタープライズアプリケーションは検討段階

5.2 標準化のプロセス

現在、エージェントプロトコルはまだ「戦国時代」にあります：

MCP と A2A が最も主流な 2 つ
ANP、AGP などの他の新興プロトコルも存在
将来的には融合または統一される可能性がある

インターネットの発展に例えると：

初期：さまざまな LAN プロトコルが併存
後期：TCP/IP が標準に
現在：エージェントプロトコルも統一に向かう可能性がある

6. まとめ

核心ポイント

プロトコル	一言で言うと	公開日	発起元	適用シーン
MCP	AI がツールに接続する「USB-C」	2024.11	Anthropic	ツール統合、データソース接続
A2A	エージェント協調の「Slack」	2025.04	Google	マルチエージェント協調、タスク委任

重要な洞察：

MCP は「AI がどのように外部能力を取得するか」の問題を解決
A2A は「複数の AI がどのように協調するか」の問題を解決
両者は補完関係にあり、将来的には融合して使用される可能性がある
プロトコルの選択は具体的なシナリオに基づくべきであり、銀の弾丸は存在しない

参考資料

MCP 公式ドキュメント: modelcontextprotocol.io
MCP GitHub: github.com/modelcontextprotocol
Anthropic 公開ブログ: "Introducing the Model Context Protocol" (2024-11-25)
A2A 公式ドキュメント: google.github.io/A2A
A2A GitHub: github.com/google/A2A
Google Cloud Blog: "Announcing the Agent-to-Agent Protocol" (2025-04-09)

AI エージェントプロトコル（MCP & A2A） ​

0. プロトコルとは？ ​

0.1 なぜプロトコルが必要か？ ​

0.2 コンピュータにおける一般的なプロトコル ​

0.3 プロトコルの価値 ​

0.4 AI エージェントにもプロトコルが必要 ​

1. エージェントプロトコルの階層 ​

2. MCP (Model Context Protocol) ​

2.1 プロトコル基本情報 ​

2.2 公開の背景 ​

2.3 MCP とは？ ​

2.4 MCP の内部実装 ​

2.5 例えで理解する：USB-C インターフェース ​

2.6 MCP の典型的なユースケース ​

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

3.1 プロトコル基本情報 ​

3.2 公開の背景 ​

3.3 A2A とは？ ​

3.4 A2A の内部実装 ​

3.5 例えで理解する：Slack ​

3.6 A2A の典型的なユースケース ​

4. MCP vs A2A：比較と関係 ​

4.1 核心的な違い ​

4.2 両者の関係 ​

4.3 どのように選択するか？ ​

5. プロトコルの将来動向 ​

5.1 エコシステムの発展 ​

5.2 標準化のプロセス ​

6. まとめ ​

参考資料 ​