Construya sistemas multiagente con el Protocolo de comunicación de agentes (ACP)

A medida que el mundo de la inteligencia artificial se expande, los desarrolladores están pasando de un solo... AI modelos a sistemas complejos de múltiples agentes donde numerosos agentes especializados colaboran para resolver problemas.

El Protocolo de Comunicación de Agentes (ACP) ofrece una solución, proporcionando un lenguaje unificado para que los agentes se comuniquen, lo que hace que los sistemas sean más escalables, flexibles y fáciles de administrar.

Esta guía proporciona un tutorial detallado para construir un sistema de comunicación multiagente escalable utilizando el Protocolo de Comunicación de Agentes (ACP).

¿Qué es el Protocolo de Comunicación del Agente (ACP)?

El Protocolo de Comunicación del Agente (ACP) es un protocolo abierto diseñado para estandarizar la forma AI agentes Comunicarse entre sí. Piénselo como un idioma común, como el inglés o el mandarín, pero para agentes de software.

Proporciona una interfaz unificada que permite a los agentes trabajar juntos sin problemas, independientemente del lenguaje de programación o el marco de trabajo con el que se hayan creado. Esto resuelve un gran problema en el desarrollo de sistemas multiagente, donde la integración de agentes suele requerir código personalizado y frágil que falla cada vez que se actualiza un agente.

Esta estructura significa que puedes cambiar fácilmente un agente por una nueva versión o un agente completamente diferente creado en otro marco sin tener que reescribir todo el sistema.

Los principios básicos del ACP

Para implementar el ACP, es necesario comprender sus componentes fundamentales. El protocolo estandariza la comunicación mediante unos pocos componentes clave que garantizan que cada mensaje sea estructurado, claro y práctico.

El corazón del protocolo es el ACPMessage Clase de datos. Este es un formato estandarizado para todos los mensajes enviados entre agentes. Garantiza que cada paquete de comunicación contenga la información necesaria para su correcta comprensión y enrutamiento. Un ejemplo típico... ACPMessage incluye:

Un performativo es un verbo que define el propósito del mensaje. Indica al receptor qué tipo de acción o respuesta se espera. Algunos performativos comunes son:

El ACPAgent Es la clase base para cualquier agente que participe en el sistema. Define al agente.'s identidad y sus capacidades básicas, como enviar y recibir ACPMessagesCada agente tiene un nombre o ID único que permite que el sistema le envíe mensajes.

En un sistema con muchos agentes, se necesita una oficina postal central para gestionar todo el tráfico de mensajes. ACPMessageBroker sirve para este propósito.'s Un componente de enrutamiento central que recibe mensajes de los agentes y garantiza su entrega al destinatario correcto. Esta arquitectura de intermediario es clave para que el sistema sea escalable y manejable.

Una guía de codificación para su primer sistema ACP

Paso 1: configurar su entorno

Primero, debes instalar la biblioteca de Python necesaria para interactuar con Google's generativo AI .

pip install google-generativeai

También deberá configurar su clave API para autenticar sus solicitudes.

Paso 2: Definición de los componentes principales del ACP

Vamos a traducir los conceptos básicos de ACP a código Python . Empezaremos definiendo la estructura de nuestros mensajes.

# 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
        )

A continuación, definimos el ACPAgent clase. Cada agente tendrá un nombre y un método para manejar los mensajes entrantes.

# 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

Finalmente, creamos el ACPMessageBroker Para gestionar la comunicación.

# 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.")

Paso 3: Creación e implementación de agentes

Con la estructura establecida, podemos crear agentes especializados. Creemos un Agente Investigador que pueda responder preguntas y un Agente Gestor que las consulte.

importar google.generativeai como genai

# 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)

Paso 4: Ejecución del sistema

Ahora deja's Júntalo todo y míralo en acción.

# 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")

Al ejecutar este código, verá que el agente gestor envía una consulta, el intermediario la reenvía al investigador, este la procesa y envía una respuesta, y el intermediario reenvía la respuesta al gestor. Esta sencilla interacción demuestra un flujo de comunicación robusto y desacoplado.

ACP en el mundo real: el caso del SEO

Los principios de ACP no son meramente teóricos; tienen aplicaciones directas en la automatización empresarial. Consideremos el campo de la optimización para motores de búsqueda (SEO). Una estrategia SEO moderna implica muchos elementos: análisis de palabras clave, creación de contenido, optimización en la página y seguimiento de enlaces entrantes.

Un sistema multiagente basado en ACP podría automatizar todo este proceso. Imagine un sistema con:

1. An Agente estratega de SEO que monitorea las tendencias de búsqueda e identifica brechas de contenido.
2. A Agente de investigación de palabras clave que encuentra valores primarios de alto valor y Palabras clave de LSI.
3. A Agente de redacción de contenidos que genera artículos basados ​​en los informes del estratega.
4. An Agente de optimización en la página que verifica el contenido en cuanto a legibilidad, densidad de palabras clave y relevancia semántica.

Con ACP, estos agentes podían comunicarse sin problemas. El agente estratega podía enviar un REQUEST al agente de investigación de palabras clave, que luego envía un INFORM Mensaje con sus hallazgos al agente redactor. Esta modularidad hace que todo el flujo de trabajo de SEO sea más eficiente y escalable.

Conclusión

Construyendo colaboración AI sistemas es una de las fronteras más apasionantes de la tecnologíaSin embargo, sin un estándar de comunicación común, estos sistemas corren el riesgo de convertirse en un enredo de integraciones personalizadas. El Protocolo de Comunicación de Agentes (ACP) ofrece una solución clara, robusta y escalable a este problema.

Al estandarizar la interacción entre agentes mediante un modelo cliente-servidor sencillo y una estructura de mensajes bien definida, ACP permite a los desarrolladores crear aplicaciones multiagente flexibles y potentes. Como se muestra en nuestra guía de Python , implementar un sistema ACP básico es muy sencillo.

A partir de ahí, se puede escalar para crear flujos de trabajo jerárquicos y sofisticados que aborden tareas complejas en ámbitos que van desde el desarrollo de software hasta el SEO. Adoptar un protocolo como ACP es un paso fundamental hacia un futuro donde los agentes inteligentes colaboren sin problemas para ayudarnos a alcanzar nuestros objetivos.