Agent Communication Protocol (ACP) — это открытый стандарт для взаимодействия между AI агентами, приложениями и людьми. Он решает одну из ключевых проблем современного ландшафта искусственного интеллекта: фрагментацию и отсутствие interoperability между агентами, разработанными в разных фреймворках, командах и инфраструктурах.
ACP предоставляет стандартизированный RESTful API, который позволяет агентам общаться и координировать свою работу независимо от используемых технологий. Это открывает путь к созданию сложных мультиагентных систем, где специализированные агенты могут эффективно взаимодействовать для решения комплексных задач.
Современные AI агенты часто создаются в изоляции:
Это приводит к следующим проблемам:
ACP решает эти проблемы, предоставляя универсальный стандарт для коммуникации.
Без стандартизированного протокола коммуникации:
Команда A (LangChain) → Кастомный адаптер → Команда B (CrewAI)
Команда A (LangChain) → Кастомный адаптер → Команда C (Smolagents)
Команда B (CrewAI) → Кастомный адаптер → Команда C (Smolagents)Каждая пара команд должна создавать свой собственный адаптер. С ростом числа команд количество необходимых адаптеров растет квадратично: O(n²).
С ACP все агенты используют один и тот же протокол:
Агент A (LangChain + ACP) ↔ ACP ↔ Агент B (CrewAI + ACP)
Агент A (LangChain + ACP) ↔ ACP ↔ Агент C (Smolagents + ACP)
Агент B (CrewAI + ACP) ↔ ACP ↔ Агент C (Smolagents + ACP)Количество необходимых адаптеров сокращается до O(n) — каждый агент просто обертывается ACP сервером.
| Подход | Интеграция | Масштабируемость | Стандартизация |
|---|---|---|---|
| Кастомные адаптеры | Сложная, требует знаний внутреннего API | Плохая | Нет |
| ACP | Простая, стандартный REST API | Отличная | Да (HTTP/JSON) |
| Native SDK | Зависит от фреймворка | Ограниченная | Частично |
ACP использует простые, хорошо определенные REST endpoints, которые соответствуют стандартным HTTP паттернам. В отличие от протоколов, требующих специализированных методов коммуникации (например, JSON-RPC), ACP использует знакомые HTTP конвенции, которые легко интегрируются в production среды.
ACP использует MimeTypes для идентификации содержимого, что делает его легко расширяемым для обработки любых форматов данных. Независимо от того, отправляете ли вы текст, изображения, аудио, видео или пользовательские бинарные форматы — любой mimetype работает "из коробки" без модификаций протокола.
Протокол достаточно прост для использования со стандартными HTTP инструментами, такими как curl, Postman или прямые запросы из браузера. Для команд, предпочитающих программную интеграцию, доступны официальные SDK для Python и TypeScript.
Агенты могут быть доступны для обнаружения даже в неактивном состоянии за счет встраивания метаданных непосредственно в пакеты их распространения. Это позволяет обнаруживать агенты в защищенных, изолированных или масштабируемых до нуля средах.
ACP изначально построен для асинхронной коммуникации, чтобы обрабатывать длительные задачи агентов, но полностью поддерживает и синхронную коммуникацию.
ACP построен на клиент-серверной архитектуре:
┌─────────────────┐
│ ACP Client │
│ (User/Agent) │
└────────┬────────┘
│ HTTP/REST
│
▼
┌─────────────────┐
│ ACP Server │
│ ┌───────────┐ │
│ │ Agent │ │
│ │ (Any FW) │ │
│ └───────────┘ │
└─────────────────┘Рис. 2. Архитектура ACP: клиент-серверная модель для коммуникации агентов.
ACP Server — это прокси-сервер, который оборачивает существующего агента и предоставляет его возможности через REST API. Он:
ACP Client — это библиотека или инструмент, который отправляет запросы к ACP серверу. Он:
Агент — это любая система, которая может принимать входные данные и выдавать выходные данные. Агент может быть:
Модель, описывающая возможности агента — его имя, описание и необязательные метаданные и статус — для обнаружения и композиции без раскрытия деталей реализации.
Структура Manifest:
{
"name": "string",
"description": "string",
"metadata": {
"version": "string",
"author": "string",
"tags": ["string"],
"capabilities": ["string"]
},
"status": "active" | "inactive" | "maintenance"
}Одиночное выполнение агента с конкретными входными данными. Поддерживает синхронную или потоковую передачу с промежуточными и финальными результатами.
Типы Run:
Основная структура для коммуникации, состоящая из последовательности упорядоченных компонентов, образующих полное, структурированное и мультимодальное обмен информацией.
Структура Message:
{
"role": "user" | "assistant" | "system" | "tool",
"parts": [MessagePart]
}Отдельные единицы содержимого внутри Message, которые могут включать типы такие как текст, изображение или JSON. Вместе они создают структурированное мультимодальное общение.
Структура MessagePart:
{
"content": "string",
"content_type": "string" // MIME type
}Позволяет агентам приостанавливаться для запроса информации от клиента и возобновлять выполнение, обеспечивая интерактивные обмены, когда агент может ждать внешнего ввода (данных, действий и т.д.) перед продолжением.
Позволяют агентам сохранять состояние и историю разговора между несколькими взаимодействиями с использованием идентификаторов сессий. SDK автоматически управляет состоянием сессии, позволяя агентам получать доступ к полной истории взаимодействий в рамках сессии.
curl -X GET http://localhost:8000/agents \
-H "Accept: application/json"{
"agents": [
{
"name": "echo",
"description": "Echoes everything",
"metadata": {
"version": "1.0.0",
"author": "John Doe",
"tags": ["utility", "testing"],
"capabilities": ["text-processing"]
},
"status": "active"
},
{
"name": "translator",
"description": "Translates text between languages",
"metadata": {
"version": "2.1.0",
"author": "Jane Smith",
"tags": ["translation", "nlp"],
"capabilities": ["multi-language", "text-generation"]
},
"status": "active"
},
{
"name": "calculator",
"description": "Performs mathematical calculations",
"metadata": {
"version": "1.5.0",
"author": "Dev Team",
"tags": ["math", "utility"],
"capabilities": ["calculation", "expression-evaluation"]
},
"status": "inactive"
}
]
}curl -X POST http://localhost:8000/runs \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
-d '{
"agent_name": "echo",
"input": [
{
"role": "user",
"parts": [
{
"content": "Howdy!",
"content_type": "text/plain"
}
]
}
],
"parameters": {
"temperature": 0.7,
"max_tokens": 100
}
}'{
"run_id": "run-abc123",
"agent_name": "echo",
"status": "completed",
"input": [
{
"role": "user",
"parts": [
{
"content": "Howdy!",
"content_type": "text/plain"
}
]
}
],
"output": [
{
"role": "assistant",
"parts": [
{
"content": "Howdy!",
"content_type": "text/plain"
}
]
}
],
"metadata": {
"created_at": "2026-03-31T10:30:00Z",
"completed_at": "2026-03-31T10:30:01Z",
"duration_ms": 1000,
"tokens_used": 12
}
}curl -X POST http://localhost:8000/runs \
-H "Content-Type: application/json" \
-H "Prefer: respond-async" \
-d '{
"agent_name": "translator",
"input": [
{
"role": "user",
"parts": [
{
"content": "Hello, how are you?",
"content_type": "text/plain"
}
]
}
],
"parameters": {
"source_language": "en",
"target_language": "es"
}
}'{
"run_id": "run-def456",
"agent_name": "translator",
"status": "in_progress",
"async_resource": "/runs/run-def456",
"metadata": {
"created_at": "2026-03-31T10:35:00Z"
}
}curl -X GET http://localhost:8000/runs/run-def456 \
-H "Accept: application/json"{
"run_id": "run-def456",
"agent_name": "translator",
"status": "in_progress",
"progress": {
"current": 50,
"total": 100,
"unit": "percent"
},
"metadata": {
"created_at": "2026-03-31T10:35:00Z",
"last_updated": "2026-03-31T10:35:02Z"
}
}{
"run_id": "run-def456",
"agent_name": "translator",
"status": "completed",
"input": [
{
"role": "user",
"parts": [
{
"content": "Hello, how are you?",
"content_type": "text/plain"
}
]
}
],
"output": [
{
"role": "assistant",
"parts": [
{
"content": "Hola, ¿cómo estás?",
"content_type": "text/plain"
}
]
}
],
"metadata": {
"created_at": "2026-03-31T10:35:00Z",
"completed_at": "2026-03-31T10:35:03Z",
"duration_ms": 3000,
"tokens_used": 25
}
}curl -X POST http://localhost:8000/runs/stream \
-H "Content-Type: application/json" \
-H "Accept: text/event-stream" \
-d '{
"agent_name": "writer",
"input": [
{
"role": "user",
"parts": [
{
"content": "Write a short poem about AI",
"content_type": "text/plain"
}
]
}
],
"parameters": {
"style": "cyberpunk"
}
}'event: thought
data: {"thought": "I need to write a poem about AI in cyberpunk style"}
event: thought
data: {"thought": "Starting with first line..."}
event: part
data: {"role": "assistant", "parts": [{"content": "In neon glow", "content_type": "text/plain"}]}
event: thought
data: {"thought": "Continuing with second line..."}
event: part
data: {"role": "assistant", "parts": [{"content": "Circuits ignite", "content_type": "text/plain"}]}
event: thought
data: {"thought": "Adding third line..."}
event: part
data: {"role": "assistant", "parts": [{"content": "Silicon dreams", "content_type": "text/plain"}]}
event: thought
data: {"thought": "Final line coming up..."}
event: part
data: {"role": "assistant", "parts": [{"content": "In endless night", "content_type": "text/plain"}]}
event: completed
data: {"status": "completed", "run_id": "run-stream789"}
event: done
data: {}curl -X POST http://localhost:8000/sessions \
-H "Content-Type: application/json" \
-d '{
"agent_name": "chatbot",
"session_metadata": {
"user_id": "user-123",
"context": "customer_support"
}
}'{
"session_id": "sess-xyz789",
"agent_name": "chatbot",
"created_at": "2026-03-31T11:00:00Z",
"expires_at": "2026-03-31T12:00:00Z",
"session_metadata": {
"user_id": "user-123",
"context": "customer_support"
}
}curl -X POST http://localhost:8000/sessions/sess-xyz789/runs \
-H "Content-Type: application/json" \
-d '{
"input": [
{
"role": "user",
"parts": [
{
"content": "I need help with my order",
"content_type": "text/plain"
}
]
}
]
}'{
"run_id": "run-sess123",
"session_id": "sess-xyz789",
"agent_name": "chatbot",
"status": "completed",
"input": [
{
"role": "user",
"parts": [
{
"content": "I need help with my order",
"content_type": "text/plain"
}
]
}
],
"output": [
{
"role": "assistant",
"parts": [
{
"content": "I can help you with your order. Could you please provide your order ID?",
"content_type": "text/plain"
}
]
}
],
"metadata": {
"created_at": "2026-03-31T11:05:00Z",
"completed_at": "2026-03-31T11:05:02Z",
"duration_ms": 2000,
"tokens_used": 45,
"session_context": {
"user_id": "user-123",
"conversation_history_length": 1
}
}
}curl -X POST http://localhost:8000/runs \
-H "Content-Type: application/json" \
-d '{
"agent_name": "interactive-bot",
"input": [
{
"role": "user",
"parts": [
{
"content": "Please help me configure my system",
"content_type": "text/plain"
}
]
}
]
}'{
"run_id": "run-await456",
"agent_name": "interactive-bot",
"status": "awaiting_input",
"await": {
"message": "I need to know your system type. Please choose: [1] Linux, [2] macOS, [3] Windows",
"expected_input": {
"type": "text/plain",
"options": ["1", "2", "3"]
}
},
"metadata": {
"created_at": "2026-03-31T11:10:00Z",
"await_started_at": "2026-03-31T11:10:01Z"
}
}curl -X POST http://localhost:8000/runs/run-await456/resume \
-H "Content-Type: application/json" \
-d '{
"input": [
{
"role": "user",
"parts": [
{
"content": "1",
"content_type": "text/plain"
}
]
}
]
}'{
"run_id": "run-await456",
"agent_name": "interactive-bot",
"status": "completed",
"input": [
{
"role": "user",
"parts": [
{
"content": "Please help me configure my system",
"content_type": "text/plain"
}
]
},
{
"role": "assistant",
"parts": [
{
"content": "I need to know your system type. Please choose: [1] Linux, [2] macOS, [3] Windows",
"content_type": "text/plain"
}
]
},
{
"role": "user",
"parts": [
{
"content": "1",
"content_type": "text/plain"
}
]
}
],
"output": [
{
"role": "assistant",
"parts": [
{
"content": "Great! You chose Linux. Here are the configuration steps for Linux...",
"content_type": "text/plain"
}
]
}
],
"metadata": {
"created_at": "2026-03-31T11:10:00Z",
"completed_at": "2026-03-31T11:10:05Z",
"duration_ms": 5000,
"tokens_used": 120,
"await_duration_ms": 3000
}
}curl -X POST http://localhost:8000/runs \
-H "Content-Type: application/json" \
-d '{
"agent_name": "image-analyzer",
"input": [
{
"role": "user",
"parts": [
{
"content": "What is in this image?",
"content_type": "text/plain"
},
{
"content": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
"content_type": "image/png"
}
]
}
]
}'{
"run_id": "run-multimod123",
"agent_name": "image-analyzer",
"status": "completed",
"input": [
{
"role": "user",
"parts": [
{
"content": "What is in this image?",
"content_type": "text/plain"
},
{
"content": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
"content_type": "image/png"
}
]
}
],
"output": [
{
"role": "assistant",
"parts": [
{
"content": "This image contains a red pixel on a white background. It appears to be a simple test image.",
"content_type": "text/plain"
}
]
}
],
"metadata": {
"created_at": "2026-03-31T11:15:00Z",
"completed_at": "2026-03-31T11:15:03Z",
"duration_ms": 3000,
"tokens_used": 85,
"image_dimensions": {
"width": 10,
"height": 10,
"format": "png"
}
}
}curl -X POST http://localhost:8000/runs \
-H "Content-Type: application/json" \
-d '{
"agent_name": "nonexistent-agent",
"input": [
{
"role": "user",
"parts": [
{
"content": "Test",
"content_type": "text/plain"
}
]
}
]
}'{
"error": {
"code": "AGENT_NOT_FOUND",
"message": "Agent 'nonexistent-agent' not found",
"details": {
"available_agents": ["echo", "translator", "calculator"],
"suggestions": ["Check agent name spelling", "Verify agent is active"]
}
}
}curl -X POST http://localhost:8000/runs \
-H "Content-Type: application/json" \
-d '{
"agent_name": "echo",
"input": "not-an-array"
}'{
"error": {
"code": "INVALID_REQUEST",
"message": "Invalid request format",
"details": {
"field": "input",
"expected_type": "array",
"received_type": "string",
"validation_errors": [
"input must be an array of Message objects"
]
}
}
}curl -X POST http://localhost:8000/runs \
-H "Content-Type: application/json" \
-H "Authorization: Bearer invalid-token" \
-d '{
"agent_name": "echo",
"input": [
{
"role": "user",
"parts": [
{
"content": "Test",
"content_type": "text/plain"
}
]
}
]
}'{
"error": {
"code": "UNAUTHORIZED",
"message": "Invalid or expired token",
"details": {
"authentication_method": "Bearer token",
"token_expiry": "2026-03-31T10:00:00Z"
}
}
}С ACP вы можете без труда заменять агентов в production системах, даже если они построены на разных фреймворках. Обновите агент для перевода с кастомной модели на последнюю LLM или замените инструмент генерации кода на специализированный coding assistant — всё без изменения точек интеграции.
Создавайте сложные системы, где специализированные агенты работают как координированные команды. В workflow создания контента может участвовать:
Каждый агент специализируется в своей области, но координируется через стандартизированные протоколы.
Подключайте агенты через ваш технологический стек — маркетинговую автоматизацию, аналитические платформы, инструменты разработки и системы коммуникации. Когда агент мониторинга обнаруживает проблему производительности, он может автоматически запустить агент реагирования на инциденты для создания тикетов, уведомления команд и координации с системами развертывания для отката изменений.
Обеспечьте безопасное сотрудничество агентов между организациями. Агент маршрутизации логистической компании может работать с агентом инвентаря поставщика для оптимизации графиков доставки, или агент маркетинговой кампании агентства может координироваться с агентом процесса утверждения клиента для потоковой передачи обзора контента через границы организаций.
ACP предоставляет универсальный стандарт для интеграции AI агентов с различными редакторами кода и IDE, превращая их в мощные интеллектуальные рабочие места. Благодаря стандартизированному REST API, разработчики могут подключать любые совместимые агенты без необходимости модификации самого редактора.
JetBrains IDEs поддерживают ACP через конфигурационный файл acp.json, который позволяет настраивать подключение к ACP серверам и управлять поведением агентов.
Примечание: Конфигурационный файл должен размещаться в ~/.jetbrains/acp.json для глобальной настройки. [^1]
{
"version": "1.0",
"agents": [
{
"name": "code-analyzer",
"url": "http://localhost:8000",
"enabled": true,
"auto_suggestions": true,
"context_window": 8192
},
{
"name": "documentation-generator",
"url": "https://acp.company.internal:8443",
"enabled": true,
"auto_suggestions": false,
"context_window": 4096
}
],
"settings": {
"default_agent": "code-analyzer",
"max_concurrent_requests": 3,
"request_timeout_ms": 30000,
"cache_ttl_seconds": 300,
"authentication": {
"type": "bearer",
"token_env_var": "ACP_AUTH_TOKEN"
}
}
}Alt+Enter (или Option+Enter на macOS)Конфигурационный файл acp.json можно разместить в:
.idea/acp.json — для конкретного проекта~/.jetbrains/acp.json — глобально для всех проектов (рекомендуемый путь)Zed — это высокопроизводительный редактор, построенный на Rust, который имеет нативную поддержку ACP через встроенный агентный интерфейс. [^2]
Cmd+Shift+P или Ctrl+Shift+P){
"agents": [
{
"name": "chat",
"url": "http://localhost:8000",
"default": true
},
{
"name": "code-completion",
"url": "http://localhost:8001",
"default": false
}
]
}Cmd+K или Ctrl+K) и выберите агентаCmd+. или Ctrl+. для вызова действий агентаNeovim поддерживает ACP через плагины Avante.nvim и CodeCompanion.nvim, которые предоставляют интеграцию с AI агентами прямо в вашем редакторе. [^3]
Avante.nvim — это мощный плагин для интеграции AI агентов в Neovim. [^4]
-- Используя packer.nvim
use({
"yetone/avante.nvim",
event = "VeryLazy",
lazy = false,
version = false,
build = "make",
requires = {
"nvim-lua/plenary.nvim",
"MunifTanjim/nui.nvim",
"nvim-tree/nvim-web-devicons"
}
})
-- Конфигурация
require("avante").setup({
provider = "openai",
endpoint = "http://localhost:8000",
model = "gpt-4",
key = os.getenv("OPENAI_API_KEY"),
mapping = {
-- Стандартные маппинги
["jump_to_question"] = { "n", "<C-j>" },
["submit_question"] = { "i", "<CR>" },
["toggle_visibility"] = { "n", "<leader>av" }
}
}):AvanteEdit:AvanteAction <action> для вызова действийCodeCompanion.nvim — еще один популярный плагин для интеграции AI агентов. [^5]
use({
"olimorris/codecompanion.nvim",
requires = {
"nvim-lua/plenary.nvim",
"nvim-treesitter/nvim-treesitter"
}
})
-- Конфигурация
require("codecompanion").setup({
adapter = require("codecompanion.adapters").new({
name = "openai",
config = {
model = "gpt-4",
endpoint = "http://localhost:8000",
headers = {
["Authorization"] = "Bearer " .. os.getenv("OPENAI_API_KEY")
}
}
}),
mappings = {
chat = "<leader>ac",
insert = "<leader>ai",
inline = "<leader>ao"
}
})Хотя VS Code не имеет нативной поддержки ACP, существует множество расширений, которые предоставляют интеграцию через ACP протокол:
Официальное расширение ACP Client от formulahendry предоставляет нативную интеграцию с ACP протоколом: [^6]
{
"acp.endpoint": "http://localhost:8000",
"acp.apiKey": "${env:ACP_API_KEY}",
"acp.defaultAgent": "code-analyzer"
}Cursor — это редактор на базе VS Code, который имеет встроенную поддержку ACP:
Cmd+, или Ctrl+,)ACP также поддерживается в других редакторах через community-плагины:
ACP как универсальный протокол позволяет интегрировать AI агентов в практически любую систему или платформу. Рассмотрим основные сферы применения.
ACP агенты могут автоматизировать и улучшать процессы непрерывной интеграции и доставки.
Примечание: Пример с acp-actions/review@v1 не подтвержден. Используйте общий curl-подход или создайте кастомный action. [^7]
name: AI Code Review
on: [pull_request]
jobs:
ai-review:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Run ACP Code Review
run: |
curl -X POST $ACP_ENDPOINT/runs \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $ACP_API_KEY" \
-d '{
"agent_name": "code-reviewer",
"input": [...]
}' | jq '.output'
env:
ACP_ENDPOINT: "http://acp-server.internal:8000"
ACP_API_KEY: ${{ secrets.ACP_API_KEY }}
- name: Process review results
run: echo "Review completed"Примечание: Пример адаптирован для общего curl-подхода. [^8]
ai_review:
stage: test
script:
- curl -X POST $ACP_ENDPOINT/runs \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $ACP_API_KEY" \
-d '{
"agent_name": "code-reviewer",
"input": [
{
"role": "user",
"parts": [
{
"content": "Review this merge request",
"content_type": "text/plain"
},
{
"content": "'$(cat git-diff-output.json)'",
"content_type": "application/json"
}
]
}
]
}'
rules:
- if: $CI_PIPELINE_SOURCE == "merge_request_event"Примечание: Пример адаптирован для общего curl-подхода. [^9]
pipeline {
agent any
environment {
ACP_ENDPOINT = 'http://acp-server.internal:8000'
ACP_API_KEY = credentials('ACP_API_KEY')
}
stages {
stage('AI Code Review') {
steps {
sh '''
curl -X POST $ACP_ENDPOINT/runs \\
-H "Content-Type: application/json" \\
-H "Authorization: Bearer $ACP_API_KEY" \\
-d '{
"agent_name": "code-reviewer",
"input": [...]
}' | jq '.output'
'''
}
}
}
}ACP агенты могут быть интегрированы в мессенджеры для автоматизации поддержки и взаимодействия.
Примечание: Пример демонстрирует общий паттерн интеграции с ACP. Используется библиотека python-telegram-bot. [^10]
import requests
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes
ACP_ENDPOINT = "http://localhost:8000"
ACP_API_KEY = "your-api-key"
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
response = requests.post(
f"{ACP_ENDPOINT}/runs",
headers={
"Content-Type": "application/json",
"Authorization": f"Bearer {ACP_API_KEY}"
},
json={
"agent_name": "telegram-bot",
"input": [{
"role": "user",
"parts": [{
"content": update.message.text,
"content_type": "text/plain"
}]
}]
}
)
result = response.json()
await update.message.reply_text(
result["output"][0]["parts"][0]["content"]
)
app = ApplicationBuilder().token("TELEGRAM_BOT_TOKEN").build()
app.add_handler(CommandHandler("start", start))
app.run_polling()Примечание: Пример демонстрирует общий паттерн интеграции с ACP. Используется библиотека discord.py. [^11]
import discord
import requests
client = discord.Client()
ACP_ENDPOINT = "http://localhost:8000"
ACP_API_KEY = "your-api-key"
@client.event
async def on_message(message):
if message.author.bot:
return
response = requests.post(
f"{ACP_ENDPOINT}/runs",
headers={
"Content-Type": "application/json",
"Authorization": f"Bearer {ACP_API_KEY}"
},
json={
"agent_name": "discord-bot",
"input": [{
"role": "user",
"parts": [{
"content": message.content,
"content_type": "text/plain"
}]
}]
}
)
result = response.json()
await message.channel.send(
result["output"][0]["parts"][0]["content"]
)
client.run("DISCORD_BOT_TOKEN")Примечание: Пример демонстрирует общий паттерн интеграции с ACP. Используется библиотека slack-sdk. [^12]
from slack_sdk import WebClient
from slack_sdk.errors import SlackApiError
import requests
slack_token = "xoxb-your-token"
client = WebClient(token=slack_token)
ACP_ENDPOINT = "http://localhost:8000"
ACP_API_KEY = "your-api-key"
def handle_slack_message(text, channel):
response = requests.post(
f"{ACP_ENDPOINT}/runs",
headers={
"Content-Type": "application/json",
"Authorization": f"Bearer {ACP_API_KEY}"
},
json={
"agent_name": "slack-bot",
"input": [{
"role": "user",
"parts": [{
"content": text,
"content_type": "text/plain"
}]
}]
}
)
result = response.json()
client.chat_postMessage(
channel=channel,
text=result["output"][0]["parts"][0]["content"]
)ACP агенты могут улучшать CRM и ERP системы, автоматизируя рутинные задачи и предоставляя интеллектуальные рекомендации.
Примечание: Пример демонстрирует общий паттерн интеграции с ACP через Apex HTTP Client. [^13]
public class ACPService {
public class RunRequest {
public String agent_name;
public List<Message> input;
public RunRequest(String agent, String text) {
agent_name = agent;
input = new List<Message>{
new Message('user', text)
};
}
}
public class Message {
public String role;
public List<MessagePart> parts;
public Message(String role, String text) {
this.role = role;
parts = new List<MessagePart>{
new MessagePart(text, 'text/plain')
};
}
}
public class MessagePart {
public String content;
public String content_type;
public MessagePart(String content, String type) {
this.content = content;
content_type = type;
}
}
@AuraEnabled
public static String runAgent(String agentName, String text) {
RunRequest req = new RunRequest(agentName, text);
String body = JSON.serialize(req);
Http http = new Http();
HttpRequest request = new HttpRequest();
request.setEndpoint('http://acp-server.internal:8000/runs');
request.setMethod('POST');
request.setHeader('Content-Type', 'application/json');
request.setHeader('Authorization', 'Bearer ' + System.Label.ACP_API_Key);
request.setBody(body);
HttpResponse response = http.send(request);
if (response.getStatusCode() == 200) {
Map<String, Object> result = (Map<String, Object>) JSON.deserializeUntyped(response.getBody());
List<Object> output = (List<Object>) result.get('output');
List<Object> parts = (List<Object>) output[0].get('parts');
return (String) parts[0].get('content');
}
return 'Error: ' + response.getBody();
}
}Примечание: Пример демонстрирует общий паттерн интеграции с ACP через ABAP HTTP Client. [^14]
DATA: lv_endpoint TYPE string VALUE 'http://acp-server.internal:8000/runs'.
DATA: lv_token TYPE string VALUE 'your-api-key'.
DATA: lv_payload TYPE string.
DATA: lv_response TYPE string.
lv_payload = `{ "agent_name": "sap-agent", "input": [ { "role": "user", "parts": [ { "content": "Analyze this transaction", "content_type": "text/plain" } ] } ] }`.
CALL METHOD cl_http_client=>create
EXPORTING
host = 'acp-server.internal'
service = '8000'
IMPORTING
client = DATA(http_client).
http_client->request->set_header_field( name = 'Content-Type' value = 'application/json' ).
http_client->request->set_header_field( name = 'Authorization' value = |Bearer {lv_token}| ).
http_client->request->set_content( lv_payload ).
http_client->send( ).
http_client->receive( ).
lv_response = http_client->response->get_content( ).ACP агенты могут автоматизировать маркетинговые задачи и создавать персонализированный контент.
Примечание: Пример демонстрирует общий паттерн интеграции с ACP для генерации email-контента. [^15]
import requests
import smtplib
from email.mime.text import MIMEText
def generate_email_content(topic, audience):
response = requests.post(
"http://localhost:8000/runs",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer your-api-key"
},
json={
"agent_name": "marketing-writer",
"input": [{
"role": "user",
"parts": [{
"content": f"Write a marketing email about {topic} for {audience}",
"content_type": "text/plain"
}]
}]
}
)
return response.json()["output"][0]["parts"][0]["content"]
def send_email(subject, content, to_email):
msg = MIMEText(content)
msg['Subject'] = subject
msg['From'] = 'marketing@company.com'
msg['To'] = to_email
with smtplib.SMTP('smtp.company.com', 587) as server:
server.starttls()
server.login("user", "password")
server.send_message(msg)
# Usage
email_content = generate_email_content("New AI Feature", "Enterprise Customers")
send_email("Introducing Our New AI Feature", email_content, "customer@example.com")Примечание: Пример демонстрирует общий паттерн интеграции с ACP для генерации постов в социальные сети. [^16]
import requests
import facebook
import twitter
def generate_social_post(topic, platform):
response = requests.post(
"http://localhost:8000/runs",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer your-api-key"
},
json={
"agent_name": "social-media-agent",
"input": [{
"role": "user",
"parts": [{
"content": f"Write a {platform} post about {topic}",
"content_type": "text/plain"
}]
}]
}
)
return response.json()["output"][0]["parts"][0]["content"]
def post_to_facebook(content):
graph = facebook.GraphAPI(access_token="your-token")
graph.put_object("me", "feed", message=content)
def post_to_twitter(content):
api = twitter.Api(consumer_key="...", consumer_secret="...", access_token_key="...", access_token_secret="...")
api.PostUpdate(content)
# Usage
post_content = generate_social_post("Product Launch", "LinkedIn")
post_to_facebook(post_content)
post_to_twitter(post_content)ACP агенты могут анализировать данные и генерировать инсайты.
Примечание: Пример демонстрирует общий паттерн интеграции с ACP для анализа данных с помощью pandas. [^17]
import requests
import pandas as pd
def analyze_data(df, question):
# Convert DataFrame to JSON
data_json = df.to_json(orient='records')
response = requests.post(
"http://localhost:8000/runs",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer your-api-key"
},
json={
"agent_name": "data-analyst",
"input": [{
"role": "user",
"parts": [
{
"content": question,
"content_type": "text/plain"
},
{
"content": data_json,
"content_type": "application/json"
}
]
}]
}
)
return response.json()["output"][0]["parts"][0]["content"]
# Usage
df = pd.read_csv("sales_data.csv")
insight = analyze_data(df, "What are the top 5 products by revenue?")
print(insight)Примечание: Пример демонстрирует общий паттерн интеграции с ACP для генерации инсайтов на основе данных. [^18]
import requests
import plotly.express as px
def generate_dashboard_insights(df, metrics):
response = requests.post(
"http://localhost:8000/runs",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer your-api-key"
},
json={
"agent_name": "dashboard-analyst",
"input": [{
"role": "user",
"parts": [
{
"content": f"Generate insights for these metrics: {metrics}",
"content_type": "text/plain"
},
{
"content": df.to_json(orient='records'),
"content_type": "application/json"
}
]
}]
}
)
return response.json()["output"][0]["parts"][0]["content"]ACP агенты могут автоматизировать задачи DevOps и управлять инфраструктурой.
Примечание: Пример демонстрирует общий паттерн интеграции с ACP для анализа инфраструктуры и оптимизации затрат AWS. [^19]
import requests
import boto3
def analyze_infrastructure_status():
response = requests.post(
"http://localhost:8000/runs",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer your-api-key"
},
json={
"agent_name": "infrastructure-analyst",
"input": [{
"role": "user",
"parts": [{
"content": "Analyze current infrastructure status and recommend optimizations",
"content_type": "text/plain"
}]
}]
}
)
return response.json()["output"][0]["parts"][0]["content"]
def optimize_aws_costs():
# Get cost data
ce = boto3.client('cost-explorer')
costs = ce.get_cost_and_usage(
TimePeriod={'Start': '2024-01-01', 'End': '2024-02-01'},
Granularity='DAILY',
Metrics=['UNBLENDED_COST']
)
# Send to ACP agent
response = requests.post(
"http://localhost:8000/runs",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer your-api-key"
},
json={
"agent_name": "cost-optimizer",
"input": [{
"role": "user",
"parts": [{
"content": f"Analyze AWS costs and recommend optimizations:\n{costs}",
"content_type": "text/plain"
}]
}]
}
)
return response.json()["output"][0]["parts"][0]["content"]Примечание: Пример демонстрирует общий паттерн интеграции с ACP для анализа логов CloudWatch. [^20]
import requests
import json
def analyze_logs(logs):
response = requests.post(
"http://localhost:8000/runs",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer your-api-key"
},
json={
"agent_name": "log-analyst",
"input": [{
"role": "user",
"parts": [{
"content": "Analyze these logs and identify issues",
"content_type": "text/plain"
}]
}]
}
)
return response.json()["output"][0]["parts"][0]["content"]
# Usage with CloudWatch logs
logs = get_cloudwatch_logs()
analysis = analyze_logs(logs)
print(analysis)27 августа 2025 года команда ACP объединилась с командой Google A2A (Agent-to-Agent) протокола для разработки единого стандарта коммуникации агентов. Теперь ACP развивается под эгидой Linux Foundation AI & Data program как часть более широкой инициативы A2A. [^21]
Это объединение означает, что будущее ACP — это единый, широкоподдерживаемый стандарт для взаимодействия AI агентов, который будет развиваться как открытый проект с сообществом разработчиков и индустриальным партнерством.
Примечание: Репозиторий i-am-bee/acp был официально архивирован 27 августа 2025 года после объединения с A2A. [^22]
Agent Communication Protocol (ACP) представляет собой важный шаг к созданию интероперабельной экосистемы AI агентов. Подобно тому, как HTTP и REST стандартизировали веб-коммуникацию, ACP стандартизирует взаимодействие между агентами, открывая путь к созданию сложных, координированных систем искусственного интеллекта.
С ACP разработчики могут:
Как и в случае с вебом, будущее AI агентов — за стандартами, которые делают интеграцию простой, надежной и доступной для всех.
[^1]: JetBrains IDEs ACP configuration file location ~/.jetbrains/acp.json подтверждено документацией JetBrains (2026-03-19).
[^2]: Zed Editor имеет нативную поддержку ACP (zed.dev/acp).
[^3]: Neovim поддерживает ACP через Avante.nvim и CodeCompanion.nvim (zed.dev/acp/editor/neovim).
[^4]: Avante.nvim — популярный плагин для Neovim с ACP интеграцией (github.com/yetone/avante.nvim).
[^5]: CodeCompanion.nvim — еще один популярный плагин для Neovim (github.com/olimorris/codecompanion.nvim).
[^6]: ACP Client от formulahendry — официальное расширение для VS Code (marketplace.visualstudio.com, 2026-02-08).
[^7]: acp-actions/review не найден в репозиториях GitHub. Рекомендуется использовать общий curl-подход.
[^8]: GitLab CI curl примеры подтверждены документацией GitLab и Stack Overflow.
[^9]: Jenkins curl примеры подтверждены общими практиками интеграции.
[^10]: python-telegram-bot — официальная библиотека для Telegram (github.com/python-telegram-bot/python-telegram-bot).
[^11]: discord.py — официальная библиотека для Discord (github.com/Rapptz/discord.py).
[^12]: slack-sdk — официальная библиотека для Slack (pypi.org/project/slack-sdk/).
[^13]: Apex HTTP Client поддерживает REST API вызовы (developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_integration_intro.htm).
[^14]: ABAP HTTP Client поддерживает REST API вызовы (community.sap.com, 2024-11-08).
[^15]: Python requests library для email интеграции — общепринятая практика.
[^16]: facebook и twitter Python библиотеки — общепринятые решения для социальных сетей.
[^17]: pandas-llm и LlamaIndex PandasQueryEngine — общепринятые решения для LLM интеграции с pandas.
[^18]: Plotly Dash и Optuna Dashboard — общепринятые решения для dashboard generation.
[^19]: boto3 с AWS Cost Explorer — официальный SDK для AWS (docs.aws.amazon.com).
[^20]: boto3 с CloudWatch Logs — официальный SDK для AWS (docs.aws.amazon.com).
[^21]: ACP и A2A объединены под Linux Foundation AI & Data program (подтверждено множеством источников).
[^22]: i-am-bee/acp архивирован 27 августа 2025 (github.com/i-am-bee/acp/releases).