Tworzenie systemów wieloagentowych z protokołem komunikacji agentów (ACP)

W miarę rozwoju świata sztucznej inteligencji programiści przechodzą od pojedynczych AI modeli złożonych systemów wieloagentowych, w których liczni wyspecjalizowani agenci współpracują ze sobą w celu rozwiązania problemów.

Protokół komunikacji agentów (ACP) oferuje rozwiązanie w postaci ujednoliconego języka komunikacji agentów, dzięki czemu systemy stają się bardziej skalowalne, elastyczne i łatwiejsze w zarządzaniu.

W tym przewodniku znajdziesz szczegółowy opis procesu tworzenia skalowalnego systemu komunikacji wieloagentowej przy użyciu protokołu komunikacji agentów.

Czym jest protokół komunikacji agentów (ACP)?

Protokół komunikacji agentów (ACP) to otwarty protokół zaprojektowany w celu standaryzacji sposobu AI agentów komunikować się ze sobą. Pomyśl o tym jak o wspólnym języku, takim jak angielski lub mandaryński, ale dla agentów oprogramowania.

Zapewnia ujednolicony interfejs, który umożliwia agentom bezproblemową współpracę, niezależnie od języka programowania lub frameworka, w którym zostali stworzeni. Rozwiązuje to poważny problem związany z tworzeniem systemów wieloagentowych, gdzie integracja agentów często wymaga niestandardowego, niestabilnego kodu, który psuje się przy każdej aktualizacji agenta.

Taka struktura oznacza, że ​​można łatwo wymienić agenta na nową wersję lub zupełnie innego agenta zbudowanego na innym środowisku, bez konieczności przepisywania całego systemu.

Podstawowe zasady ACP

Aby wdrożyć ACP, musisz zrozumieć jego podstawowe elementy składowe. Protokół standaryzuje komunikację za pomocą kilku kluczowych komponentów, które zapewniają, że każda wiadomość jest ustrukturyzowana, jasna i możliwa do wykonania.

Sercem protokołu jest ACPMessage klasa danych. Jest to standardowy format wszystkich wiadomości wysyłanych między agentami. Zapewnia, że ​​każdy pakiet komunikacyjny zawiera niezbędne informacje, aby mógł zostać zrozumiany i prawidłowo przekierowany. Typowy ACPMessage obejmuje:

Performatyw to czasownik, który definiuje cel komunikatu. Informuje odbiorcę, jakiego rodzaju działania lub odpowiedzi się oczekuje. Typowe performatywy obejmują:

ACPAgent jest klasą bazową dla każdego agenta uczestniczącego w systemie. Definiuje agenta's tożsamość i jej podstawowe możliwości, takie jak wysyłanie i odbieranie ACPMessagesKażdy agent ma unikalną nazwę lub identyfikator, który umożliwia systemowi kierowanie do niego wiadomości.

W systemie z wieloma agentami potrzebny jest centralny urząd pocztowy do obsługi całego ruchu wiadomości. ACPMessageBroker służy temu celowi. To's centralny komponent routingu, który odbiera wiadomości od agentów i zapewnia ich dostarczenie do właściwego odbiorcy. Ta architektura brokera jest kluczowa dla skalowalności i zarządzania systemem.

Przewodnik po kodowaniu dla Twojego pierwszego systemu ACP

Krok 1: Konfigurowanie środowiska

Najpierw musisz zainstalować potrzebną bibliotekę Pythona do interakcji z Google's generatywny AI modele.

pip install google-generativeai

Będziesz musiał również skonfigurować klucz API , aby uwierzytelniać swoje żądania.

Krok 2: Definiowanie podstawowych komponentów ACP

Przetłumaczmy podstawowe koncepcje ACP na kod Pythona . Zacznijmy od zdefiniowania struktury wiadomości.

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

Następnie definiujemy ACPAgent Klasa. Każdy agent będzie miał nazwę i metodę obsługi wiadomości przychodzących.

# 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

Na koniec tworzymy plik ACPMessageBroker do zarządzania komunikacją.

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

Krok 3: Tworzenie i wdrażanie agentów

Mając już gotowe ramy, możemy tworzyć wyspecjalizowanych agentów. Stwórzmy agenta badawczego , który może odpowiadać na pytania, i agenta zarządzającego , który je zadaje.

importuj google.generativeai jak 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)

Krok 4: Uruchomienie systemu

Teraz pozwól's złóż to wszystko do kupy i zobacz w akcji.

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

Po uruchomieniu tego kodu zobaczysz, jak agent menedżera wysyła zapytanie, broker kieruje je do badacza, badacz przetwarza je i wysyła odpowiedź, a broker kieruje odpowiedź z powrotem do menedżera. Ta prosta interakcja demonstruje solidny, niezależny przepływ komunikacji.

ACP w realnym świecie: przypadek SEO

Zasady ACP nie są jedynie teoretyczne; mają bezpośrednie zastosowanie w automatyzacji biznesu. Rozważmy optymalizację pod kątem wyszukiwarek (SEO). Nowoczesna strategia SEO obejmuje wiele ruchomych elementów: analizę słów kluczowych, tworzenie treści, optymalizację na stronie i śledzenie linków zwrotnych.

System multi-agentowy zasilany przez ACP mógłby zautomatyzować cały ten proces. Wyobraź sobie system z:

1. An Agent strategii SEO który monitoruje trendy wyszukiwania i identyfikuje luki w treściach.
2. A Agent ds. badań słów kluczowych który znajduje wartościowe materiały podstawowe i Słowa kluczowe LSI.
3. A Agent ds. pisania treści który generuje artykuły na podstawie wytycznych stratega.
4. An Agent optymalizacji na stronie która sprawdza czytelność treści, gęstość słów kluczowych i trafność semantyczną.

Dzięki ACP agenci mogli komunikować się bezbłędnie. Agent strateg mógł wysłać REQUEST do agenta badawczego w celu uzyskania słów kluczowych, który następnie wysyła INFORM wiadomość ze swoimi ustaleniami do agenta piszącego. Ta modułowość sprawia, że ​​cały przepływ pracy SEO jest bardziej wydajny i skalowalny.

Wniosek

Budowanie współpracy AI systemy jest jedną z najbardziej ekscytujących granic w technologia. Jednak bez wspólnego standardu komunikacji systemy te ryzykują, że staną się splątanym bałaganem niestandardowych integracji. Protokół komunikacji agenta (ACP) zapewnia czyste, solidne i skalowalne rozwiązanie tego problemu.

Standaryzując interakcję agentów za pomocą prostego modelu klient-serwer i dobrze zdefiniowanej struktury komunikatów, ACP umożliwia programistom tworzenie elastycznych i wydajnych aplikacji wieloagentowych. Jak pokazano w naszym przewodniku po Pythonie , wdrożenie podstawowego systemu ACP jest proste.

Stamtąd możesz skalować, tworząc zaawansowane, hierarchiczne przepływy pracy, które poradzą sobie ze złożonymi zadaniami w różnych dziedzinach, od tworzenia oprogramowania po SEO. Wdrożenie protokołu takiego jak ACP to kluczowy krok w kierunku przyszłości, w której inteligentni agenci będą płynnie ze sobą współpracować, pomagając nam osiągać nasze cele.