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.

La función Protocolo de comunicación del agente (ACP) ofrece una solución que proporciona un lenguaje unificado para que los agentes se comuniquen, haciendo que los sistemas sean más escalables, flexibles y fáciles de administrar.

Esta guía proporciona un tutorial detallado para construir una plataforma escalable. sistema de comunicación multiagente que utiliza el Protocolo de Comunicación de Agentes. 

¿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 de la lenguaje de programación o el marco con el que se crearon. Esto soluciona un gran problema en el desarrollo de sistemas multiagente, donde la integración de agentes a menudo requiere 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:

La función 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 necesitarás configurar tu Clave API para autenticar sus solicitudes.

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

Deje que's traducir los conceptos básicos del ACP en Código de PythonComenzaremos definiendo la estructura de nuestro mensaje.

# 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 el marco establecido, podemos crear agentes especializados. Dejar's hacer un Agente investigador que pueda responder preguntas y una Agente gerente que lo consulta.

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

Cuando ejecutes este código, verás el agente gerente Envía una consulta, el intermediario la envía al investigador, este la procesa y envía una respuesta, y el intermediario envía la respuesta al administrador. Esta sencilla interacción demuestra un flujo de comunicación robusto y desacoplado.

ACP en el mundo real: el caso del SEO

Los principios del ACP no son solo teóricos; tienen aplicaciones directas en la automatización empresarial. Consideremos el campo de Buscar optimización del motor (SEO). Un moderno una estrategia de SEO Implica muchas partes móviles: análisis de palabras clave, creación de contenido, optimización en la página y seguimiento de vínculos de retroceso.

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 forma en que los agentes interactúan a través de un simple modelo cliente-servidor y una estructura de mensajes bien definida, ACP permite a los desarrolladores crear aplicaciones multiagente flexibles y potentes. Como se demuestra en nuestro... Guía de PythonImplementar un sistema ACP básico es sencillo. 

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