使用代理通信协议（ACP）构建多代理系统

随着人工智能世界的不断扩展，开发人员正在从单一 AI 模型是复杂的多智能体系统，其中众多专门的智能体协作来解决问题。

代理通信协议(ACP) 提供了一种解决方案，为代理之间的通信提供了一种统一的语言，使系统更具可扩展性、灵活性和易管理性。

本指南详细介绍了如何使用代理通信协议构建可扩展的多代理通信系统。

什么是代理通信协议 (ACP)？

代理通信协议 (ACP) 是一种开放协议，旨在标准化 AI 中介代理 相互沟通。可以将其视为一种通用语言，就像英语或普通话一样，但适用于软件代理。

它提供了一个统一的接口，使各个智能体能够无缝协作，而无需考虑它们使用何种编程语言或框架构建。这解决了开发多智能体系统的一个主要难题：集成智能体通常需要编写自定义的、脆弱的代码，每次智能体更新时都会出现问题。

这种结构意味着您可以轻松地将代理换成新版本或基于另一个框架构建的完全不同的代理，而无需重写整个系统。

ACP 的核心原则

要实施 ACP，您需要了解其基本构建模块。该协议通过几个关键组件实现通信标准化，确保每条消息都结构化、清晰且可操作。

该协议的核心是 ACPMessage 数据类。这是代理之间发送的所有消息的标准化格式。它确保每个通信数据包都包含必要的信息，以便被正确理解和路由。典型的 ACPMessage 包括：

施事句是一个动词，它定义了信息的目的。它告诉接收者期望什么样的动作或响应。常见的施事句包括：

此 ACPAgent 是系统中所有代理的基类。它定义了代理's 身份及其核心功能，例如发送和接收 ACPMessages. 每个代理都有一个唯一的名称或 ID，以便系统将消息路由给它。

在具有多个代理的系统中，需要一个中央邮局来处理所有消息流量。 ACPMessageBroker 就是为了达到这个目的。's 一个中央路由组件，用于接收来自代理的消息并确保其传递到正确的收件人。这种代理架构是实现系统可扩展性和可管理性的关键。

您的第一个 ACP 系统的编码指南

第 1 步：设置您的环境

首先，你需要安装与 Google 交互所需的 Python 库'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 这样的协议是迈向未来智能代理无缝协作、帮助我们实现目标的关键一步。