Какие протоколы меж-агентской коммуникации существуют (A2A, MCP, OpenAI swarm)?

Краткий тезис

Протоколы меж-агентской коммуникации — это стандарты и фреймворки, позволяющие автономным AI-агентам обмениваться запросами, инструментами и контекстом. Основные существующие протоколы: A2A (Agent2Agent) от Google (открытый протокол для discovery и async-сообщений), MCP (Model Context Protocol) от Anthropic (стандартизация доступа к инструментам), OpenAI Swarm (экспериментальный фреймворк для роя агентов с handoff) и ACME (формат сообщений на JSON-LD для семантической совместимости). Выбор протокола зависит от сценария: от вертикального вызова инструментов до горизонтального взаимодействия независимых агентов.

1. Зачем нужны протоколы меж-агентской коммуникации

В Agentic RAG и мульти-агентных системах несколько агентов (специализированных LLM, обёрнутых инструментами) должны координировать свои действия. Без общего протокола каждый агент реализует собственную RPC-схему, что ведёт к хрупкости, дублированию и невозможности масштабирования. Протоколы решают проблемы:

• Discovery — как агент находит другого агента с нужными навыками.
• Capability negotiation — согласование того, какие запросы, форматы и инструменты поддерживаются.
• Async messaging — обмен сообщениями с возможностью отложенного ответа.
• Handoff — передача управления от одного агента другому.
• Semantic interoperability — единый формат данных (например, JSON-LD).

2. A2A (Agent2Agent) от Google

A2A — открытый протокол, предложенный Google, для взаимодействия независимых агентов, работающих на разных платформах.

Ключевые возможности:

• Agent Card — JSON-документ, описывающий возможности агента (название, поддерживаемые задачи, входные/выходные схемы, стоимость, контакты).
• Discovery — агенты публикуют Agent Card в реестре (например, DNS-запись или web-эндпоинт). Другие агенты запрашивают карту и выбирают подходящего.
• Async messaging — агенты общаются через брокер сообщений (например, NATS, RabbitMQ). Сообщения содержат task_id, статус, payload и метаданные.
• Task-oriented communication — каждое взаимодействие — задача (task), которая может быть выполнена синхронно или асинхронно.

Структура сообщения A2A (упрощённо):

{
  "protocol": "agent2agent/1.0",
  "task_id": "abc123",
  "sender": {"agent_id": "assistant-1", "card_url": "https://.../card.json"},
  "target": {"agent_id": "retriever-2", "card_url": "https://.../card.json"},
  "action": "execute",
  "payload": {
    "input": {"query": "какая погода в Москве?"},
    "tools": ["weather_api"]
  },
  "metadata": {"timeout": "30s"}
}

Применение:

• Горизонтальное взаимодействие: ассистент запрашивает данные у специализированного агента-ретривера.
• Поддержка long-lived задач (например, мониторинг).

3. MCP (Model Context Protocol) от Anthropic

MCP — протокол, разработанный Anthropic для стандартизации доступа LLM к инструментам (tools). Это не протокол «агент-агент», а протокол «хост-инструмент» (или «агент-инструмент»). Однако в мульти-агентной архитектуре MCP может использоваться каждым агентом для вызова внешних функций.

Ключевые элементы:

• MCP Server — процесс, предоставляющий инструменты (например, поиск в БД, вызов API). Он публикует описание инструментов (название, параметры, возвращаемый тип) в JSON-схеме.
• MCP Client — компонент (агент), который подключается к серверу, получает список инструментов и вызывает их.
• Transport — по умолчанию через stdin/stdout или WebSocket.
• Context — сессия, в рамках которой передаётся история взаимодействий, чтобы сервер мог быть stateful.

Пример вызова инструмента через MCP (псевдокод):

# MCP Client (внутри агента)
from mcp.client import MCPClient

client = MCPClient.connect("weather-mcp")
tools = client.list_tools()  # [{"name": "get_weather", "parameters": {"city": "string"}}]
result = client.call_tool("get_weather", {"city": "Москва"})
# Вернёт JSON с погодой

Применение:

• Универсальный интерфейс между LLM и любыми инструментами (API, базы данных, файловая система).
• Позволяет легко заменять backend инструментов без изменения логики агента.

4. OpenAI Swarm

OpenAI Swarm — экспериментальный фреймворк (не протокол, а библиотека) для создания роя агентов с handoff (передачей управления). Основан на идее функциональных вызовов (function calling) и передачи реплик (turn taking).

Ключевые особенности:

• Агенты — это объекты с инструкцией (system prompt), набором инструментов и параметрами (температура, модель, etc.).
• Handoff — агент может решить, что текущий запрос лучше обработает другой агент, и передать управление. Это делается через специальную функцию transfer_to_<агент>.
• Рой — группа агентов, которые могут передавать запросы друг другу, образуя граф.
• Отсутствие центрального оркестратора — каждый агент решает, кому передать управление.

Пример (концептуальный):

from swarm import Swarm, Agent

client = Swarm()

billing_agent = Agent(
    name="Billing Agent",
    instructions="You handle billing questions.",
    functions=[transfer_to_support]  # может передать в support
)

support_agent = Agent(
    name="Support Agent",
    instructions="You handle support tickets.",
    functions=[transfer_to_billing]
)

response = client.run(
    agent=billing_agent,
    messages=[{"role": "user", "content": "I need a refund."}]
)
# Если billing_agent решит, что это не его зона, он вызовет transfer_to_support

Применение:

• Прототипирование мульти-агентных систем с простым handoff.
• Подходит для кастомер-сервиса, где запросы направляются в разные отделы.
• Не предназначен для production (экспериментальный).

5. ACME (Agent Communication Message Encoding)

ACME — формат сообщений на базе JSON-LD (JSON для Linked Data), обеспечивающий семантическую совместимость между агентами. Не является протоколом в полном смысле (не определяет transport/flow), но задаёт структуру контента.

Особенности:

• JSON-LD — добавляет контекст (@context), который связывает поля с онтологиями (например, schema.org).
• Позволяет разным агентам понимать одинаковые концепты (например, "weather:Temperature" везде означает температуру).
• Используется в академических проектах и стандарте FIPA (Foundation for Intelligent Physical Agents).

Пример сообщения ACME:

{
  "@context": "https://w3id.org/acme/context.json",
  "@type": "QueryMessage",
  "sender": "agent:retriever-1",
  "receiver": "agent:weather-2",
  "query": {
    "@type": "WeatherQuery",
    "city": "Москва",
    "units": "celsius"
  }
}

Применение:

• Обеспечение интероперабельности в гетерогенных системах.
• Полезна, когда агенты создаются разными командами/компаниями.

6. Сравнительная таблица протоколов

7. Пример сценария с комбинацией протоколов

Представим систему автоматического подбора подарков. Есть агенты:

• Orchestrator Agent (использует A2A для координации)
• Retriever Agent (использует MCP для вызова векторной БД)
• Creative Agent (генерирует описание, использует MCP для DALL-E API)
• Billing Agent (использует OpenAI Swarm handoff для передачи сложных запросов)

Как это работает

1. Пользователь: "Найди подарок для мамы под 2000 рублей."
2. Orchestrator получает запрос и отправляет задачу Retriever через A2A (async-сообщение с task_id).
3. Retriever через MCP вызывает векторную БД с встроенным инструментом поиска. Результат (список идей) возвращается Orchestrator.
4. Orchestrator выбирает лучший вариант и через A2A вызывает Creative Agent, который через MCP получает изображение от DALL-E.
5. Если возникает вопрос по оплате, Creative Agent передаёт управление Billing Agent через handoff (OpenAI Swarm).

Таким образом, протоколы не исключают друг друга, а решают разные уровни: A2A — меж-агентная координация, MCP — доступ к инструментам, Swarm — handoff, ACME — семантика.

8. Практические соображения при выборе протокола

• Зрелость и поддержка: A2A всё ещё разрабатывается (2025), MCP уже интегрирован в Claude Desktop, Swarm experimental, ACME академический.
• Требования к масштабу: Для сети из многих независимых агентов (SaaS) — A2A. Для одного агента с набором инструментов — MCP. Для быстрого прототипа ручного handoff — Swarm.
• Совместимость: MCP хорошо работает с любыми LLM, поддерживающими function calling. A2A требует брокера сообщений. Swarm завязан на OpenAI API.
• Безопасность: A2A и MCP не имеют встроенной аутентификации (нужно добавлять OAuth/JWT). Swarm работает внутри одного процесса — безопаснее.
• Производительность: MCP через WebSocket имеет низкую задержку. A2A с брокером добавляет накладные расходы, но лучше для long-lived задач.

9. Пет-проект для закрепления

Задача

Реализовать двух агентов (SearchAgent и SummarizerAgent), которые общаются через MCP и A2A. SearchAgent использует MCP для поиска в локальной БД, SummarizerAgent получает результаты через A2A и генерирует краткое изложение.

Инструменты

• Python 3.11+
• mcp библиотека (или собственная реализация)
• aiohttp для A2A-заглушки
• Simple vector store (FAISS + sentence-transformers)
• Ollama или OpenAI API для SummarizerAgent

Шаги

1. Создать MCP-сервер, который предоставляет инструмент search_documents(query: str) -> list[dict].
2. Реализовать SearchAgent как MCP-клиента, вызывающего этот инструмент.
3. Создать A2A-заглушку: SearchAgent публикует Agent Card (JSON) на локальном HTTP-endpoint. SummarizerAgent запрашивает карту и отправляет task с результатами поиска.
4. SummarizerAgent обрабатывает полученные документы и возвращает summary.

Ожидаемый результат

• Модульная система, в которой можно заменить SearchAgent на другой без изменения SummarizerAgent.
• Запуск end-to-end команды: python main.py "Как работает RAG?" — вывод краткого summary на основе найденных документов.

10. Связь с другими вопросами

11. Навигация

• Предыдущий: 809
• Следующий: 811
• Индекс: 00. Индекс разборов

Навигация

• Предыдущий: 809
• Следующий: 811
• Индекс: 00. Индекс разборов