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 agenta (ACP) oferuje rozwiązanie, zapewniając ujednolicony język komunikacji agentów, dzięki czemu systemy stają się bardziej skalowalne, elastyczne i łatwiejsze w zarządzaniu.

W tym przewodniku znajdziesz szczegółowy opis tworzenia skalowalnego rozwiązania wieloagentowy system komunikacji wykorzystujący protokół 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ęzyk programowania lub framework, w którym zostały zbudowane. Rozwiązuje to główny problem w rozwijaniu systemów wieloagentowych, gdzie integrowanie agentów często wymaga niestandardowego, kruchego kodu, który psuje się za każdym razem, gdy agent jest aktualizowany.

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ć swoje Klucz API aby uwierzytelnić Twoje żądania.

Krok 2: Definiowanie podstawowych komponentów ACP

Niech's przetłumaczyć podstawowe koncepcje ACP na Kod PythonaZaczniemy od zdefiniowania struktury naszej 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ż ramy, możemy tworzyć wyspecjalizowanych agentów. Niech's zrobić Agent badawczy który może odpowiedzieć na pytania i Menedżer Agent który to podważa.

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 agent menedżer wyślij 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 pokazuje solidny, odseparowany przepływ komunikacji.

ACP w realnym świecie: przypadek SEO

Zasady ACP nie są tylko teoretyczne; mają bezpośrednie zastosowanie w automatyzacji biznesu. Rozważmy dziedzinę Optymalizacja wyszukiwarki internetowej (SEO). Nowoczesny Strategia SEO obejmuje wiele ruchomych części: analizę słów kluczowych, tworzenie treści, optymalizację na stronie i śledzenie linków przychodzących.

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 sposób interakcji agentów za pomocą prostego model klient-serwer i dobrze zdefiniowaną strukturę wiadomości, ACP umożliwia deweloperom tworzenie elastycznych i wydajnych aplikacji wieloagentowych. Jak wykazano w naszym Przewodnik po Pythoniewdrożenie podstawowego systemu ACP jest proste. 

Stamtąd możesz skalować, aby tworzyć wyrafinowane, hierarchiczne przepływy pracy, które mogą zająć się złożonymi zadaniami w dziedzinach od rozwoju oprogramowania po SEO. Przyjęcie protokołu takiego jak ACP jest kluczowym krokiem w kierunku przyszłości, w której inteligentni agenci współpracują ze sobą bezproblemowo, aby pomóc nam osiągnąć nasze cele.