Vytvářejte multiagentní systémy s protokolem ACP (Agent Communication Protocol)

S rozšiřováním světa umělé inteligence se vývojáři přesouvají od jednoho AI modelů až po komplexní multiagentní systémy, kde na řešení problémů spolupracuje řada specializovaných agentů.

Protokol Agent Communication Protocol (ACP) nabízí řešení, které poskytuje jednotný jazyk pro komunikaci agentů, čímž se systémy stávají škálovatelnějšími, flexibilnějšími a snadněji spravovatelnými.

Tato příručka poskytuje podrobný návod pro vytvoření škálovatelného multiagentního komunikačního systému s využitím Agent Communication Protocol.

Co je protokol pro komunikaci agentů (ACP)?

Protokol pro komunikaci agentů (ACP) je otevřený protokol určený ke standardizaci způsobu, jakým AI agentů komunikovat mezi sebou. Představte si to jako společný jazyk, jako je angličtina nebo mandarínština, ale pro softwarové agenty.

Poskytuje jednotné rozhraní, které umožňuje agentům bezproblémovou spolupráci bez ohledu na programovací jazyk nebo framework, ve kterém byli vytvořeni. To řeší velký problém při vývoji multiagentních systémů, kde integrace agentů často vyžaduje vlastní a křehký kód, který se při každé aktualizaci agenta pokazí.

Vyvinuto společností IBM Research a nyní je součástí Linux Foundation. VčelaAI projekt, ACP je postaven na jednoduché, ale výkonné architektuře klient-server. Umožňuje bezproblémovou interakci mezi AI Klienti a cloudové nástroje, které umožňují modulární provádění úloh v reálném čase. Funguje to takto:

Tato struktura znamená, že můžete snadno vyměnit agenta za novou verzi nebo za zcela jiného agenta postaveného na jiném frameworku, aniž byste museli přepisovat celý systém.

Základní principy ACP

Pro implementaci ACP je nutné porozumět jeho základním stavebním kamenům. Protokol standardizuje komunikaci prostřednictvím několika klíčových komponent, které zajišťují, že každá zpráva je strukturovaná, jasná a proveditelná.

Srdcem protokolu je ACPMessage datová třída. Jedná se o standardizovaný formát pro všechny zprávy odesílané mezi agenty. Zajišťuje, aby každý komunikační paket obsahoval potřebné informace k jeho pochopení a správnému směrování. Typický ACPMessage zahrnuje:

Performativ je sloveso, které definuje účel sdělení. Říká přijímajícímu agentovi, jaký druh akce nebo reakce se očekává. Mezi běžné performativy patří:

Jedno ACPAgent je základní třída pro jakéhokoli agenta zapojeného do systému. Definuje agenta's identita a její základní funkce, jako je odesílání a přijímání ACPMessagesKaždý agent má jedinečné jméno nebo ID, které systému umožňuje směrovat k němu zprávy.

V systému s mnoha agenty potřebujete centrální poštu, která bude zpracovávat veškerý provoz zpráv. ACPMessageBroker Slouží tomuto účelu.'s centrální směrovací komponenta, která přijímá zprávy od agentů a zajišťuje jejich doručení správnému příjemci. Tato architektura brokera je klíčem k škálovatelnosti a spravovatelnosti systému.

Průvodce kódováním vašeho prvního systému ACP

A teď se pustíme do tvorby jednoduchého systému pro zasílání zpráv v Pythonu , který bude kompatibilní s ACP . V tomto tutoriálu se pro zpracování přirozeného jazyka použije rozhraní Gemini API od Googlu , jak je demonstrováno v původní implementaci.

Krok 1: Nastavení prostředí

Nejprve je potřeba nainstalovat potřebnou knihovnu Pythonu pro interakci s Googlem's generativní AI modely.

pip install google-generativeai

Budete také muset nakonfigurovat klíč API pro ověřování vašich požadavků.

Krok 2: Definování základních komponent ACP

Převeďme si základní koncepty ACP do kódu Pythonu . Začneme definováním struktury naší zprávy.

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

Dále definujeme ACPAgent třída. Každý agent bude mít jméno a metodu pro zpracování příchozích zpráv.

# 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

Nakonec vytvoříme ACPMessageBroker řídit komunikaci.

# 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: Vytvoření a implementace agentů

S tímto frameworkem můžeme vytvořit specializované agenty. Vytvořme agenta-výzkumníka , který bude odpovídat na otázky, a agenta-manažera , který bude odesílat dotazy.

importovat google.generativeai jako 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: Spuštění systému

Teď, nech's dejte to všechno dohromady a uvidíte to v akci.

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

Když spustíte tento kód, uvidíte, jak agent manažera odešle dotaz, broker jej směruje k výzkumníkovi, výzkumník jej zpracuje a odešle odpověď a broker směruje odpověď zpět manažerovi. Tato jednoduchá interakce demonstruje robustní, oddělený komunikační tok.

ACP v reálném světě: Argumenty pro SEO

Principy ACP nejsou jen teoretické; mají přímé uplatnění v automatizaci podnikání. Vezměme si například oblast optimalizace pro vyhledávače (SEO). Moderní SEO strategie zahrnuje mnoho pohyblivých částí: analýzu klíčových slov, tvorbu obsahu, optimalizaci na stránce a sledování zpětných odkazů.

Multiagentní systém s technologií ACP by mohl celý tento proces automatizovat. Představte si systém s:

1. An Agent SEO stratéga který sleduje trendy vyhledávání a identifikuje mezery v obsahu.
2. A Agent pro výzkum klíčových slov který nachází vysoce hodnotné primární a LSI klíčová slova.
3. A Agent pro psaní obsahu který generuje články na základě zadání od stratéga.
4. An Agent pro optimalizaci na stránce který kontroluje čitelnost obsahu, hustotu klíčových slov a sémantickou relevanci.

S ACP mohli tito agenti bezchybně komunikovat. Agent-stratég mohl odeslat REQUEST výzkumnému agentovi pro klíčová slova, který poté odešle INFORM zprávu s jejími zjištěními autorovi. Tato modularita zefektivňuje a škáluje celý pracovní postup SEO.

Závěr

Budování spolupráce AI systémy je jednou z nejzajímavějších hranic v technikaBez společného komunikačního standardu však tyto systémy riskují, že se stanou spletitým komplexem vlastních integrací. Protokol Agent Communication Protocol (ACP) poskytuje čisté, robustní a škálovatelné řešení tohoto problému.

Standardizací způsobu interakce agentů prostřednictvím jednoduchého modelu klient-server a dobře definované struktury zpráv umožňuje ACP vývojářům vytvářet flexibilní a výkonné multiagentové aplikace. Jak je ukázáno v našem průvodci Pythonem , implementace základního systému ACP je jednoduchá.

Odtud můžete škálovat a vytvářet sofistikované, hierarchické pracovní postupy, které dokáží zvládat složité úkoly v oblastech od vývoje softwaru až po SEO. Přijetí protokolu, jako je ACP, je zásadním krokem k budoucnosti, kde inteligentní agenti bezproblémově spolupracují a pomáhají nám dosahovat našich cílů.