---
url: /blog/acp-note/index.md
---
# ACP（Agent Communication Protocol）学习笔记

> **一句话定义**：ACP 是 AI 智能体之间通信的"HTTP"——一个让不同框架开发的 Agent 能够互相交流的开放协议。
>
> **重要提示**：ACP 已于 2025 年 8 月合并到 A2A 协议，由 Linux Foundation 统一管理。

***

## 一、背景：为什么需要 ACP？

### 1.1 AI Agent 的现状

2024-2025 年，AI Agent（智能体）爆发式增长：

* **框架百花齐放**：LangChain、CrewAI、BeeAI、AutoGen、Dify...
* **每个框架独立发展**：有自己的工具生态、通信方式、部署方案
* **Agent 之间无法对话**：用 LangChain 写的 Agent 和用 CrewAI 写的 Agent，互不相通

### 1.2 N × M 集成问题

假设有 **N 个 Agent 框架**，每个框架有 **M 个 Agent**，要让它们互相通信：

```
框架A的Agent ←→ 框架B的Agent  → 需要定制集成
框架A的Agent ←→ 框架C的Agent  → 又要定制集成
框架B的Agent ←→ 框架C的Agent  → 继续定制集成...
```

**结果**：集成成本 = N × M，呈指数级增长。

### 1.3 ACP 想要解决的问题

**核心问题**：如何让不同框架、不同团队、不同组织开发的 Agent 能够标准化地互相通信？

**ACP 的答案**：定义一个通用的"语言"（协议），只要 Agent 实现了这个协议，就能和任何其他实现了该协议的 Agent 通信。

```
                    ┌─────────────┐
                    │   ACP 协议   │
                    └──────┬──────┘
           ┌───────────────┼───────────────┐
           ▼               ▼               ▼
    ┌──────────┐    ┌──────────┐    ┌──────────┐
    │ LangChain│    │  CrewAI  │    │  BeeAI   │
    │  Agent   │    │  Agent   │    │  Agent   │
    └──────────┘    └──────────┘    └──────────┘
```

***

## 二、概述：ACP 是什么？

### 2.1 定义

**ACP (Agent Communication Protocol)** 是由 **IBM Research** 和 **BeeAI 团队**开发的开放协议，用于 AI 智能体之间的标准化通信。

**核心特点**：

| 特性           | 说明                                         |
| ------------ | ------------------------------------------ |
| **REST 原生**  | 基于 HTTP 的 RESTful API，可用 curl/Postman 直接调用 |
| **多模态消息**    | 支持文本、图像、JSON、代码等多种内容                       |
| **同步/异步/流式** | 三种通信模式都支持                                  |
| **有状态/无状态**  | Agent 可自主选择工作模式                            |
| **离线发现**     | Agent 可通过嵌入元数据被发现（即使未运行）                   |
| **无 SDK 要求** | 标准 HTTP 工具即可使用（也有 Python/TypeScript SDK）   |

### 2.2 协议生态：MCP / ACP / A2A / ANP

这四个协议解决的是**不同层面**的问题：

```
┌─────────────────────────────────────────────────────────────────┐
│                    AI Agent 协议生态系统                          │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   MCP (Anthropic)              A2A (Google)                     │
│   ↓ 垂直连接                   ↓ 水平连接                        │
│                                                                 │
│   ┌─────────┐                  ┌─────────┐                      │
│   │  Agent  │───── MCP ─────▶  │  Tools  │                      │
│   │         │                  │ DB/API  │                      │
│   └────┬────┘                  └─────────┘                      │
│        │                                                        │
│        └─────── A2A ─────────▶  ┌─────────┐                     │
│                                │ Agent B │                     │
│                                └─────────┘                     │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

MCP = Agent 访问工具/数据（Agent ↔ 工具）
A2A = Agent 之间的协作通信（Agent ↔ Agent）
ACP = 已合并到 A2A（REST 风格的 Agent 通信）
ANP = 去中心化的 Agent 网络（P2P）
```

**四协议对比**：

| 协议      | 创建者       | 用途            | 架构              | 类比                |
| ------- | --------- | ------------- | --------------- | ----------------- |
| **MCP** | Anthropic | LLM ↔ 工具/数据库  | Client-Server   | "USB-C for AI"    |
| **ACP** | IBM/BeeAI | Agent ↔ Agent | Brokered (REST) | "HTTP for Agents" |
| **A2A** | Google    | 企业级 Agent 协作  | Peer-to-Peer    | "Agent 互联网"       |
| **ANP** | 社区        | 去中心化 Agent 网络 | P2P             | "Agent 区块链"       |

### 2.3 时间线

| 时间 | 事件 |
|------|------|
| 2024.11 | Anthropic 发布 **MCP** |
| 2025.03 | IBM 发布 **ACP**（BeeAI 平台） |
| 2025.04 | Google 发布 **A2A**（50+ 合作伙伴） |
| 2025.06 | A2A 捐赠给 Linux Foundation |
| **2025.08** | **ACP 合并到 A2A** |
| 2025.12 | 成立 Agentic AI Foundation (AAIF) |
| 2026.01 | A2A 发布 v1.0 |

***

## 三、核心概念

### 3.1 三个角色

ACP 定义了三个核心角色：

```
┌──────────────┐      ┌──────────────┐      ┌──────────────┐
│ Agent Client │ ◀──▶ │  ACP Server  │ ◀──▶ │  ACP Agent   │
│   (客户端)    │      │   (注册中心)  │      │   (智能体)    │
└──────────────┘      └──────────────┘      └──────────────┘
```

| 角色 | 职责 |
|------|------|
| **Agent Client** | 发起请求的应用（如 IDE、聊天界面） |
| **ACP Server** | 注册中心，管理 Agent 发现和路由 |
| **ACP Agent** | 实际执行任务的智能体 |

### 3.2 核心数据结构

#### Message（消息）

通信的基本单位，包含一个或多个 MessagePart：

```
Message
├── parts: MessagePart[]  ← 消息内容（可多个）
├── role: "user" | "agent"
└── metadata: {}          ← 可选元数据
```

#### MessagePart（消息部分）

单个内容单元，支持多模态：

```
MessagePart
├── content: string       ← 实际内容
├── type: "text" | "image" | "json" | ...
└── metadata: {}          ← 可选元数据（如引用、轨迹等）
```

#### Run（执行）

一次 Agent 执行的生命周期：

```
Run
├── run_id: string        ← 唯一标识
├── agent_name: string    ← 目标 Agent
├── status: "pending" | "running" | "completed" | "failed"
├── input: Message[]      ← 输入消息
├── output: Message[]     ← 输出消息
└── await_request: {}     ← 如果需要等待用户输入
```

### 3.3 通信流程

一个典型的 ACP 交互流程：

```
┌────────┐          ┌────────┐          ┌────────┐
│ Client │          │ Server │          │ Agent  │
└───┬────┘          └───┬────┘          └───┬────┘
    │                   │                   │
    │  1. 发现 Agent    │                   │
    │──────────────────▶│                   │
    │◀──────────────────│  返回 Agent 列表   │
    │                   │                   │
    │  2. 创建 Run      │                   │
    │──────────────────▶│                   │
    │                   │──────────────────▶│
    │                   │                   │ 执行任务
    │                   │◀──────────────────│
    │◀──────────────────│  返回 Run 结果     │
    │                   │                   │
    │  3. 获取输出      │                   │
    │──────────────────▶│                   │
    │◀──────────────────│  返回 Message     │
    │                   │                   │
```

### 3.4 三种通信模式

| 模式     | 适用场景        | 特点                        |
| ------ | ----------- | ------------------------- |
| **同步** | 快速任务，立即返回结果 | 请求-响应，简单直接                |
| **异步** | 长时间任务       | 返回 run\_id，后续轮询状态          |
| **流式** | 需要实时反馈      | SSE（Server-Sent Events）推送 |

***

## 四、快速理解：代码长什么样？

> 以下仅为概念展示，帮助你理解 ACP 的使用方式。

### 4.1 定义一个 Agent（Python）

```python
from acp_sdk.server import Server
from acp_sdk.models import Message

server = Server()

@server.agent()
async def echo(input: list[Message], context):
    """一个简单的回声 Agent"""
    for message in input:
        yield f"你说的是: {message.parts[0].content}"

# 启动 Agent
server.run()
```

### 4.2 调用 Agent（HTTP）

```bash
# 创建一个 Run
curl -X POST http://localhost:8000/runs \
  -H "Content-Type: application/json" \
  -d '{
    "agent_name": "echo",
    "input": [{
      "parts": [{"content": "你好", "type": "text"}]
    }]
  }'

# 响应
{
  "run_id": "44e480d6-9a3e-4e35-8a03-faa759e19588",
  "status": "completed",
  "output": [{
    "parts": [{"content": "你说的是: 你好"}]
  }]
}
```

### 4.3 调用 Agent（Python SDK）

```python
from acp_sdk.client import Client

async with Client(base_url="http://localhost:8000") as client:
    run = await client.run(
        agent_name="echo",
        input=[Message(parts=[{"content": "你好", "type": "text"}])]
    )
    print(run.output[0].parts[0].content)
    # 输出: 你说的是: 你好
```

***

## 五、运用场景

### 5.1 IDE 集成（已落地）

**是的，IDE 集成是 ACP 的重要应用场景之一。**

JetBrains（IntelliJ IDEA、PyCharm 等）的 AI Assistant 已经支持 ACP：

```
┌─────────────────────────────────────────────────────────┐
│                    JetBrains IDE                         │
├─────────────────────────────────────────────────────────┤
│  ┌─────────────┐                                        │
│  │  AI Chat    │  ←── 用户在这里和 Agent 对话           │
│  └──────┬──────┘                                        │
│         │                                               │
│         │ ACP 协议                                      │
│         ▼                                               │
│  ┌─────────────┐     ┌─────────────┐                   │
│  │ OpenCode    │     │   Goose     │   ← 第三方 Agent  │
│  │   Agent     │     │   Agent     │     (可扩展)       │
│  └─────────────┘     └─────────────┘                   │
└─────────────────────────────────────────────────────────┘
```

**具体能力**：

* 从 **ACP Registry** 安装社区维护的 Agent
* 添加**自定义 Agent**（通过 `acp.json` 配置）
* Agent 可以访问 IDE 的 MCP 服务器（代码上下文、文件操作）

**配置示例**：

```json
// ~/.jetbrains/acp.json
{
  "default_mcp_settings": {
    "use_idea_mcp": true,      // 传递 IDE 内置的 MCP 服务器
    "use_custom_mcp": true     // 传递用户配置的 MCP 服务器
  },
  "agent_servers": {
    "opencode": {
      "command": "/path/to/opencode",
      "args": ["acp"]
    }
  }
}
```

### 5.2 多 Agent 协作

让不同专长的 Agent 协作完成复杂任务：

```
┌──────────────────────────────────────────────────────────┐
│                     工作流编排                            │
├──────────────────────────────────────────────────────────┤
│                                                          │
│   用户: "帮我写一篇技术博客"                              │
│                                                          │
│   ┌─────────────┐      ┌─────────────┐                  │
│   │ 选题 Agent  │ ───▶ │ 写作 Agent  │                  │
│   │ (生成选题)  │ ACP  │ (撰写内容)  │                  │
│   └─────────────┘      └──────┬──────┘                  │
│                               │                         │
│                               │ ACP                     │
│                               ▼                         │
│                        ┌─────────────┐                  │
│                        │ 审校 Agent  │                  │
│                        │ (润色纠错)  │                  │
│                        └─────────────┘                  │
│                                                          │
└──────────────────────────────────────────────────────────┘
```

**关键点**：

* 每个 Agent 可以用**不同框架**开发（LangChain、CrewAI、自定义）
* 通过 ACP 标准接口通信，无需了解彼此内部实现
* Agent 可以独立部署、独立扩展

### 5.3 本地/边缘部署

ACP 的 REST 设计使其适合**低延迟、离线环境**：

| 场景 | 说明 |
|------|------|
| **本地开发** | Agent 运行在本地，无需云端 |
| **边缘计算** | 工控机、IoT 设备上的 Agent 协作 |
| **内网环境** | 企业内网，数据不出网 |
| **离线场景** | 无网络环境下的 Agent 通信 |

### 5.4 跨框架互操作

解决"框架孤岛"问题：

```
之前：LangChain Agent ⟷ CrewAI Agent  → 需要定制开发

之后：
┌────────────────┐                  ┌────────────────┐
│ LangChain      │                  │ CrewAI         │
│   Agent        │ ───── ACP ─────▶ │   Agent        │
│                │                  │                │
└────────────────┘                  └────────────────┘
        ↓                                   ↓
   实现 ACP 接口                       实现 ACP 接口
```

**价值**：

* 复用不同框架的优势（LangChain 的生态、CrewAI 的角色扮演）
* 渐进式迁移（不必一次性重写所有 Agent）
* 技术选型自由（团队可以用擅长的框架）

### 5.5 场景选择指南

| 你的需求              | 推荐方案                   |
| ----------------- | ---------------------- |
| IDE 里用 AI 助手      | ACP/A2A（JetBrains 已支持） |
| 多个 Agent 协作完成复杂任务 | A2A（企业级）/ ACP（轻量级）     |
| Agent 访问工具/数据库    | MCP                    |
| 去中心化 Agent 网络     | ANP                    |
| 本地/边缘部署           | ACP（REST 简单）           |

***

## 六、与 MCP 的配合

ACP 和 MCP 是**互补关系**，不是竞争关系：

```
┌─────────────────────────────────────────────────────────┐
│                      完整的 Agent 系统                    │
├─────────────────────────────────────────────────────────┤
│                                                         │
│   ┌─────────┐                    ┌─────────┐            │
│   │ Agent A │────── A2A ───────▶ │ Agent B │            │
│   └────┬────┘                    └────┬────┘            │
│        │                              │                 │
│        │ MCP                          │ MCP             │
│        ▼                              ▼                 │
│   ┌─────────┐                    ┌─────────┐            │
│   │ 数据库  │                    │ API服务 │            │
│   └─────────┘                    └─────────┘            │
│                                                         │
│   MCP 提供"手"（工具访问能力）                           │
│   A2A 提供"嘴"（Agent 间通信能力）                       │
└─────────────────────────────────────────────────────────┘
```

**简单记忆**：

* **MCP** = Agent 访问外部资源（工具、数据库、API）
* **A2A/ACP** = Agent 之间互相通信

***

## 七、常见问题

### Q1: ACP 和 A2A 选哪个？

**结论**：新项目直接用 **A2A**。

* ACP 已于 2025 年 8 月合并到 A2A
* A2A 是当前行业标准，有更多生态支持
* ACP 的设计理念（RESTful、简单易用）已融入 A2A

### Q2: 我该学哪个协议？

**建议学习顺序**：

1. **MCP**（必学）—— 工具集成是基础
2. **A2A**（必学）—— Agent 协作是趋势
3. **ACP**（了解）—— 理解 REST 风格的设计思想

### Q3: ACP 还值得学吗？

**值得了解，但不必深入**：

* ✅ 了解概念和设计思想
* ✅ 理解 RESTful Agent 通信的优点
* ❌ 不必投入大量时间学习实现细节
* ❌ 新项目不要用 ACP，直接用 A2A

***

## 八、学习资源

### 官方文档

| 资源 | 链接 |
|------|------|
| ACP 官方文档（已归档） | https://agentcommunicationprotocol.dev |
| A2A 官方文档（推荐） | https://a2a-protocol.org |
| Linux Foundation AAIF | https://www.linuxfoundation.org/press/linux-foundation-launches-the-agent2agent-protocol-project |

### GitHub 仓库

| 仓库                                                  | 说明            |
| --------------------------------------------------- | ------------- |
| [i-am-bee/acp](https://github.com/i-am-bee/acp)     | ACP 原始仓库（已归档） |
| [a2aproject/A2A](https://github.com/a2aproject/A2A) | A2A 主仓库（当前活跃） |

### 视频课程

| 课程 | 链接 |
|------|------|
| DeepLearning.AI - A2A 课程 | https://goo.gle/dlai-a2a |

### 深度阅读

| 文章 | 链接 |
|------|------|
| 协议对比分析 | https://zylos.ai/research/2026-02-15-agent-to-agent-communication-protocols |
| MCP vs A2A vs ACP 完整指南 | https://www.jitendrazaa.com/blog/ai/mcp-vs-a2a-vs-acp-vs-anp-complete-ai-agent-protocol-guide/ |

***

## 总结

```
┌─────────────────────────────────────────────────────────┐
│                    ACP 核心要点                          │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  1. 定义：AI Agent 之间通信的开放协议（"HTTP for Agents"）│
│                                                         │
│  2. 创建者：IBM Research / BeeAI                        │
│                                                         │
│  3. 特点：REST 原生、多模态、同步/异步/流式              │
│                                                         │
│  4. 现状：已合并到 A2A（2025.08）                       │
│                                                         │
│  5. 与 MCP 关系：互补（MCP=工具，A2A=通信）             │
│                                                         │
│  6. 建议：新项目用 A2A，ACP 了解概念即可                │
│                                                         │
└─────────────────────────────────────────────────────────┘
```

***

> 📝 **笔记状态**：初稿完成，基于 2026 年 3 月的资料整理。
>
> 💡 **下一步**：学习 MCP → 学习 A2A → 实践多 Agent 协作