Создание многоагентных систем с протоколом связи агентов (ACP)

По мере расширения мира искусственного интеллекта разработчики переходят от одного AI моделей в сложные многоагентные системы, в которых многочисленные специализированные агенты сотрудничают для решения проблем.

Протокол связи с агентами (ACP) предлагает решение, предоставляя единый язык для общения агентов, что делает системы более масштабируемыми, гибкими и простыми в управлении.

В этом руководстве подробно описан процесс создания масштабируемой многоагентной системы связи с использованием протокола связи агентов (Agent Communication Protocol).

Что такое протокол связи агента (ACP)?

Протокол связи с агентами (ACP) — это открытый протокол, разработанный для стандартизации способа AI агенты общаться друг с другом. Думайте об этом как об общем языке, как об английском или мандаринском, но для программных агентов.

Он предоставляет единый интерфейс, позволяющий агентам беспрепятственно взаимодействовать друг с другом независимо от языка программирования или используемой платформы. Это решает серьезную проблему при разработке многоагентных систем, где интеграция агентов часто требует написания пользовательского, ненадежного кода, который ломается при каждом обновлении агента.

Такая структура означает, что вы можете легко заменить агента на новую версию или на совершенно другой агент, созданный на другой платформе, без необходимости переписывать всю систему.

Основные принципы ACP

Чтобы внедрить ACP, вам нужно понять его основные строительные блоки. Протокол стандартизирует коммуникацию с помощью нескольких ключевых компонентов, которые гарантируют, что каждое сообщение структурировано, понятно и применимо на практике.

Сердцем протокола является ACPMessage класс данных. Это стандартизированный формат для всех сообщений, отправляемых между агентами. Он гарантирует, что каждый пакет связи содержит необходимую информацию для его правильного понимания и маршрутизации. Типичный ACPMessage включает в себя:

Перформатив — это глагол, который определяет цель сообщения. Он сообщает принимающему агенту, какое действие или ответ ожидается. Распространенные перформативы включают:

ACPAgent является базовым классом для любого агента, участвующего в системе. Он определяет агента's идентификация и ее основные возможности, такие как отправка и получение ACPMessages. Каждый агент имеет уникальное имя или идентификатор, который позволяет системе направлять ему сообщения.

В системе со множеством агентов вам понадобится центральное почтовое отделение для обработки всего трафика сообщений. ACPMessageBroker служит этой цели. Это's центральный компонент маршрутизации, который получает сообщения от агентов и обеспечивает их доставку правильному получателю. Эта архитектура брокера является ключом к тому, чтобы сделать систему масштабируемой и управляемой.

Руководство по кодированию вашей первой системы ACP

Шаг 1. Настройка среды

Для начала вам необходимо установить необходимую библиотеку Python для взаимодействия с Google.'s генеративный AI модели.

pip install google-generativeai

Вам также потребуется настроить свой API-ключ для аутентификации запросов.

Шаг 2: Определение основных компонентов ACP

Давайте переведём основные концепции ACP в код на Python . Начнём с определения структуры нашего сообщения.

# Define the ACP Message Structure using a dataclass
from dataclasses import dataclass, field
from typing import Any, Dict, Optional
import uuid

@dataclass
class ACPMessage:
    """A standard message format for Agent Communication Protocol."""
    sender: str
    receiver: str
    performative: str
    content: Any
    message_id: str = field(default_factory=lambda: str(uuid.uuid4()))
    conversation_id: Optional[str] = None
    metadata: Dict[str, Any] = field(default_factory=dict)

    def create_reply(self, sender: str, performative: str, content: Any) -> 'ACPMessage':
        """Helper to create a reply to this message."""
        return ACPMessage(
            sender=sender,
            receiver=self.sender,
            performative=performative,
            content=content,
            conversation_id=self.conversation_id or self.message_id
        )

Далее мы определяем ACPAgent класс. Каждый агент будет иметь имя и метод обработки входящих сообщений.

# Define the base class for an ACP Agent
class ACPAgent:
    """Base class for an agent in an ACP system."""
    def __init__(self, name, broker):
        self.name = name
        self.broker = broker
        self.broker.register_agent(self)

    def send_message(self, message: ACPMessage):
        """Sends a message through the broker."""
        print(f"[{self.name}] Sending message to {message.receiver}: {message.performative}")
        self.broker.route_message(message)

    def receive_message(self, message: ACPMessage):
        """Processes an incoming message."""
        print(f"[{self.name}] Received message from {message.sender}: {message.performative}")
        # Agent-specific logic goes here
        pass

Наконец, мы создаем ACPMessageBroker для управления коммуникацией.

# Define the Message Broker for routing messages
class ACPMessageBroker:
    """A central broker to route messages between agents."""
    def __init__(self):
        self.agents: Dict[str, ACPAgent] = {}

    def register_agent(self, agent: ACPAgent):
        """Adds a new agent to the network."""
        print(f"[Broker] Registering agent: {agent.name}")
        self.agents[agent.name] = agent

    def route_message(self, message: ACPMessage):
        """Routes a message to the intended recipient."""
        recipient_agent = self.agents.get(message.receiver)
        if recipient_agent:
            recipient_agent.receive_message(message)
        else:
            print(f"[Broker] Error: Agent '{message.receiver}' not found.")

Шаг 3: Создание и внедрение агентов

Имея такую ​​структуру, мы можем создавать специализированных агентов. Давайте создадим агента-исследователя , который сможет отвечать на вопросы, и агента-менеджера , который будет задавать ему вопросы.

импорт google.generativeai как генай

# Configure your Gemini API key
# genai.configure(api_key="YOUR_API_KEY")

class ResearcherAgent(ACPAgent):
    """An agent that uses a generative model to answer queries."""
    def __init__(self, name, broker):
        super().__init__(name, broker)
        # self.model = genai.GenerativeModel('gemini-pro')

    def receive_message(self, message: ACPMessage):
        super().receive_message(message)
        if message.performative == "QUERY":
            question = message.content
            # For demonstration, we'll use a canned response.
            # In a real scenario, you would call the model:
            # response_text = self.model.generate_content(question).text
            response_text = f"My analysis on '{question}' indicates a positive outlook."

            reply = message.create_reply(
                sender=self.name,
                performative="INFORM",
                content=response_text
            )
            self.send_message(reply)

class ManagerAgent(ACPAgent):
    """An agent that delegates tasks and queries other agents."""
    def receive_message(self, message: ACPMessage):
        super().receive_message(message)
        if message.performative == "INFORM":
            print(f"[{self.name}] Got a response: {message.content}")

    def start_task(self, topic: str):
        """Starts a new task by querying the researcher."""
        print(f"[{self.name}] Initiating research on: {topic}")
        query_message = ACPMessage(
            sender=self.name,
            receiver="Researcher_1",
            performative="QUERY",
            content=f"What is the market trend for {topic}?",
            conversation_id=str(uuid.uuid4())
        )
        self.send_message(query_message)

Шаг 4: Запуск системы

Теперь позвольте's соберите все это вместе и посмотрите в действии.

# Main execution block
if __name__ == "__main__":
    # 1. Initialise the broker
    message_broker = ACPMessageBroker()

    # 2. Create and register agents
    manager = ManagerAgent("Manager_Alpha", message_broker)
    researcher = ResearcherAgent("Researcher_1", message_broker)

    # 3. Kick off a task
    manager.start_task("AI-powered SEO tools")

При запуске этого кода вы увидите, как агент-менеджер отправляет запрос, брокер перенаправляет его исследователю, исследователь обрабатывает его и отправляет ответ, а брокер перенаправляет ответ обратно менеджеру. Это простое взаимодействие демонстрирует надежный, независимый поток коммуникации.

ACP в реальном мире: аргументы в пользу SEO

Принципы ACP не ограничиваются теорией; они имеют прямое применение в автоматизации бизнес-процессов. Рассмотрим область поисковой оптимизации (SEO). Современная SEO-стратегия включает в себя множество составляющих: анализ ключевых слов, создание контента, оптимизация страниц и отслеживание обратных ссылок.

Многоагентная система на базе ACP могла бы автоматизировать весь этот процесс. Представьте себе систему с:

1. An Агент SEO-стратега который отслеживает тенденции поиска и выявляет пробелы в контенте.
2. A Агент по исследованию ключевых слов который находит высокоценные первичные и Ключевые слова LSI.
3. A Агент по написанию контента который генерирует статьи на основе сводок от стратега.
4. An Агент оптимизации на странице который проверяет контент на читабельность, плотность ключевых слов и семантическую релевантность.

С ACP эти агенты могли общаться безупречно. Агент-стратег мог отправить REQUEST исследовательскому агенту по ключевым словам, который затем отправляет INFORM сообщение с его выводами для агента-писателя. Эта модульность делает весь рабочий процесс SEO более эффективным и масштабируемым.

Заключение

Построение совместной работы AI системы является одним из самых захватывающих рубежей в Технология. Однако без общего стандарта связи эти системы рискуют превратиться в запутанную мешанину пользовательских интеграций. Протокол связи агентов (ACP) обеспечивает чистое, надежное и масштабируемое решение этой проблемы.

Стандартизация взаимодействия агентов с помощью простой клиент-серверной модели и четко определенной структуры сообщений позволяет ACP разработчику создавать гибкие и мощные многоагентные приложения. Как показано в нашем руководстве по Python , реализация базовой системы ACP довольно проста.

Отсюда можно масштабировать систему для создания сложных иерархических рабочих процессов, способных решать комплексные задачи в самых разных областях, от разработки программного обеспечения до SEO. Внедрение протокола, подобного ACP, — важный шаг на пути к будущему, где интеллектуальные агенты будут беспрепятственно сотрудничать, помогая нам достигать наших целей.