Bygg fleragentsystemer med agentkommunikasjonsprotokoll (ACP)

Etter hvert som verdenen av kunstig intelligens utvides, beveger utviklere seg fra enkeltstående AI modeller til komplekse systemer med flere agenter der en rekke spesialiserte agenter samarbeider for å løse problemer.

Agent Communication Protocol (ACP) tilbyr en løsning som gir et enhetlig språk for agenter å kommunisere med, noe som gjør systemene mer skalerbare, fleksible og enklere å administrere.

Denne veiledningen gir en detaljert gjennomgang av hvordan du bygger et skalerbart kommunikasjonssystem med flere agenter ved hjelp av Agent Communication Protocol.

Hva er agentkommunikasjonsprotokollen (ACP)?

Agent Communication Protocol (ACP) er en åpen protokoll som er utformet for å standardisere måten AI agenter kommunisere med hverandre. Tenk på det som et felles språk, som engelsk eller mandarin, men for programvareagenter.

Det gir et enhetlig grensesnitt som lar agenter samarbeide sømløst, uavhengig av hvilket programmeringsspråk eller rammeverk de ble bygget med. Dette løser en stor hodepine i utviklingen av systemer med flere agenter, der integrering av agenter ofte krever tilpasset, skjør kode som går i stykker hver gang en agent oppdateres.

Denne strukturen betyr at du enkelt kan bytte ut en agent med en ny versjon eller en helt annen agent bygget på et annet rammeverk uten å måtte skrive om hele systemet.

Kjerneprinsippene i ACP

For å implementere ACP må du forstå de grunnleggende byggesteinene. Protokollen standardiserer kommunikasjon gjennom noen få nøkkelkomponenter som sikrer at hver melding er strukturert, tydelig og handlingsrettet.

Kjernen i protokollen er ACPMessage dataklasse. Dette er et standardisert format for alle meldinger som sendes mellom agenter. Det sikrer at hver kommunikasjonspakke inneholder den nødvendige informasjonen for at den skal forstås og rutes riktig. En typisk ACPMessage inkluderer:

Et performativ er et verb som definerer formålet med meldingen. Det forteller mottakeren hva slags handling eller respons som forventes. Vanlige performativer inkluderer:

Ocuco ACPAgent er basisklassen for enhver agent som deltar i systemet. Den definerer agenten's identitet og dens kjernefunksjoner, som å sende og motta ACPMessagesHver agent har et unikt navn eller en unik ID som lar systemet rute meldinger til den.

I et system med mange agenter trenger du et sentralt postkontor for å håndtere all meldingstrafikken. ACPMessageBroker tjener dette formålet. Det's en sentral rutingskomponent som mottar meldinger fra agenter og sørger for at de leveres til riktig mottaker. Denne meglerarkitekturen er nøkkelen til å gjøre systemet skalerbart og håndterbart.

En kodeguide til ditt første ACP-system

Trinn 1: Sett opp miljøet ditt

Først må du installere det nødvendige Python-biblioteket for å samhandle med Google.'s generative AI modeller.

pip install google-generativeai

Du må også konfigurere API-nøkkelen din for å autentisere forespørslene dine.

Trinn 2: Definere kjernekomponentene i ACP

La oss oversette de viktigste ACP-konseptene til Python-kode . Vi begynner med å definere meldingsstrukturen vår.

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

Deretter definerer vi ACPAgent klasse. Hver agent vil ha et navn og en metode for å håndtere innkommende meldinger.

# 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

Til slutt lager vi ACPMessageBroker å håndtere kommunikasjonen.

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

Trinn 3: Opprette og implementere agenter

Med rammeverket på plass kan vi opprette spesialiserte agenter. La oss lage en forskeragent som kan svare på spørsmål og en lederagent som stiller spørsmål til den.

importer google.generativeai som 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)

Trinn 4: Kjøre systemet

Nå, la's sett alt sammen og se det i aksjon.

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

Når du kjører denne koden, vil du se at administratoragenten sender en forespørsel, megleren ruter den til forskeren, forskeren behandler den og sender et svar, og megleren ruter svaret tilbake til administratoren. Denne enkle interaksjonen demonstrerer en robust, frakoblet kommunikasjonsflyt.

ACP i den virkelige verden: Argumentet for SEO

Prinsippene bak ACP er ikke bare teoretiske; de ​​har direkte anvendelser innen forretningsautomatisering. Tenk på feltet søkemotoroptimalisering (SEO). En moderne SEO-strategi involverer mange bevegelige deler: søkeordanalyse, innholdsproduksjon, optimalisering på siden og sporing av tilbakekoblinger.

Et system med flere agenter drevet av ACP kan automatisere hele denne prosessen. Tenk deg et system med:

1. An SEO-strategagent som overvåker søketrender og identifiserer innholdshull.
2. A Agent for søkeordanalyse som finner primær- og LSI søkeord.
3. A Innholdsskrivingsagent som genererer artikler basert på briefinger fra strategen.
4. An Agent for optimalisering på siden som sjekker innholdet for lesbarhet, søkeordtetthet og semantisk relevans.

Med ACP kunne disse agentene kommunisere feilfritt. Strategagenten kunne sende en REQUEST til forskningsagenten for nøkkelord, som deretter sender en INFORM melding med funnene til skriveagenten. Denne modulariteten gjør hele SEO-arbeidsflyten mer effektiv og skalerbar.

Konklusjon

Bygge samarbeid AI systemer er en av de mest spennende grenseområdene i teknologiUten en felles kommunikasjonsstandard risikerer imidlertid disse systemene å bli et virvar av tilpassede integrasjoner. Agent Communication Protocol (ACP) gir en ren, robust og skalerbar løsning på dette problemet.

Ved å standardisere hvordan agenter samhandler gjennom en enkel klient-server-modell og en veldefinert meldingsstruktur, lar ACP utviklere bygge fleksible og kraftige applikasjoner med flere agenter. Som vist i Python-guiden vår , er det enkelt å implementere et grunnleggende ACP-system.

Derfra kan du skalere for å lage sofistikerte, hierarkiske arbeidsflyter som kan håndtere komplekse oppgaver innen felt som spenner fra programvareutvikling til SEO. Å ta i bruk en protokoll som ACP er et viktig skritt mot en fremtid der intelligente agenter samarbeider sømløst for å hjelpe oss med å nå målene våre.