Construir sistemes multiagent amb el protocol de comunicació d'agents (ACP)

A mesura que el món de la intel·ligència artificial s'expandeix, els desenvolupadors passen d'un sol AI models fins a sistemes complexos amb múltiples agents on nombrosos agents especialitzats col·laboren per resoldre problemes.

L' Protocol de comunicació d'agents (ACP) ofereix una solució, proporcionant un llenguatge unificat perquè els agents es comuniquin, fent que els sistemes siguin més escalables, flexibles i fàcils de gestionar.

Aquesta guia ofereix una guia detallada per construir un sistema escalable sistema de comunicació multiagent que utilitza el protocol de comunicació d'agents. 

Què és el protocol de comunicació d'agents (ACP)?

El Protocol de Comunicació d'Agents (ACP) és un protocol obert dissenyat per estandarditzar la manera com AI agents comunicar-se entre ells. Penseu-hi com una llengua comuna, com l'anglès o el mandarí, però per a agents de programari.

Proporciona una interfície unificada que permet als agents treballar junts sense problemes, independentment de llenguatge de programació o el marc de treball amb què es van construir. Això resol un gran maldecap en el desenvolupament de sistemes multiagent, on la integració d'agents sovint requereix un codi personalitzat i fràgil que es trenca cada vegada que s'actualitza un agent.

Aquesta estructura significa que podeu canviar fàcilment un agent per una nova versió o un agent completament diferent creat sobre un altre marc de treball sense haver de reescriure tot el sistema.

Els principis bàsics de l'ACP

Per implementar l'ACP, cal entendre els seus components fonamentals. El protocol estandarditza la comunicació a través d'uns quants components clau que garanteixen que cada missatge sigui estructurat, clar i pràctic.

El cor del protocol és el ACPMessage classe de dades. Aquest és un format estandarditzat per a tots els missatges enviats entre agents. Assegura que cada paquet de comunicació contingui la informació necessària perquè sigui entès i encaminat correctament. Un format típic ACPMessage inclou:

Un performatiu és un verb que defineix el propòsit del missatge. Indica a l'agent receptor quin tipus d'acció o resposta s'espera. Els performatius comuns inclouen:

L' ACPAgent és la classe base per a qualsevol agent que participi en el sistema. Defineix l'agent's la identitat i les seves capacitats bàsiques, com ara enviar i rebre ACPMessagesCada agent té un nom o identificador únic que permet al sistema encaminar-hi missatges.

En un sistema amb molts agents, necessiteu una oficina de correus central per gestionar tot el trànsit de missatges. El ACPMessageBroker serveix per a aquest propòsit. Això's un component d'encaminament central que rep els missatges dels agents i garanteix que es lliurin al destinatari correcte. Aquesta arquitectura de broker és clau per fer que el sistema sigui escalable i gestionable.

Una guia de codificació per al vostre primer sistema ACP

Pas 1: Configura el teu entorn

Primer, cal instal·lar la biblioteca de Python necessària per interactuar amb Google.'s generatiu AI models.

pip install google-generativeai

També hauràs de configurar el teu Clau de l'API per autenticar les vostres sol·licituds.

Pas 2: Definició dels components bàsics de l'ACP

Deixar's traduir els conceptes bàsics de l'ACP a Codi PythonComençarem definint l'estructura del nostre missatge.

# 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ó, definim el ACPAgent classe. Cada agent tindrà un nom i un mètode per gestionar els missatges entrants.

# 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

Finalment, creem el ACPMessageBroker per gestionar la comunicació.

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

Pas 3: Creació i implementació d'agents

Amb el marc de treball establert, podem crear agents especialitzats. Sigui's fer una Agent Investigador que pot respondre preguntes i una Agent gerent que ho consulta.

importa google.generativeai com a 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)

Pas 4: Execució del sistema

Ara, deixem's ajunta-ho tot i veu-ho en acció.

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

Quan executeu aquest codi, veureu el agent gerent envien una consulta, el broker la redirigeix ​​a l'investigador, l'investigador la processa i envia una resposta, i el broker redirigeix ​​la resposta de tornada al gestor. Aquesta simple interacció demostra un flux de comunicació robust i desacoblat.

ACP al món real: el cas del SEO

Els principis de l'ACP no són només teòrics; tenen aplicacions directes en l'automatització empresarial. Considereu el camp de Optimització de motors de cerca (SEO). Un modern Estratègia de SEO Implica moltes parts mòbils: anàlisi de paraules clau, creació de contingut, optimització a la pàgina i seguiment d'enllaços entrants.

Un sistema multiagent impulsat per ACP podria automatitzar tot aquest procés. Imagineu-vos un sistema amb:

1. An Agent estrateg SEO que supervisa les tendències de cerca i identifica les llacunes de contingut.
2. A Agent de recerca de paraules clau que troba primàries d'alt valor i Paraules clau LSI.
3. A Agent de redacció de continguts que genera articles basats en informes de l'estrateg.
4. An Agent d'optimització a la pàgina que comprova la llegibilitat del contingut, la densitat de paraules clau i la rellevància semàntica.

Amb l'ACP, aquests agents es podien comunicar perfectament. L'agent estrateg podia enviar un REQUEST a l'agent de recerca de paraules clau, que després envia un INFORM missatge amb les seves conclusions a l'agent de redacció. Aquesta modularitat fa que tot el flux de treball de SEO sigui més eficient i escalable.

Conclusió

Construint col·laboració AI sistemes és una de les fronteres més emocionants de Nova Tecnologia LEDTanmateix, sense un estàndard de comunicació comú, aquests sistemes corren el risc de convertir-se en un embolic d'integracions personalitzades. El protocol de comunicació d'agents (ACP) proporciona una solució neta, robusta i escalable a aquest problema.

Estandarditzant com interactuen els agents mitjançant un sistema senzill model client-servidor i una estructura de missatges ben definida, ACP permet als desenvolupadors crear aplicacions multiagent flexibles i potents. Com es demostra a la nostra Guia de Python, implementar un sistema ACP bàsic és senzill. 

A partir d'aquí, podeu escalar per crear fluxos de treball jeràrquics i sofisticats que puguin abordar tasques complexes en camps que van des del desenvolupament de programari fins al SEO. L'adopció d'un protocol com l'ACP és un pas vital cap a un futur on agents intel·ligents col·laboren sense problemes per ajudar-nos a assolir els nostres objectius.