Többügynökös rendszerek létrehozása az Agent Communication Protocol (ACP) segítségével

Ahogy a mesterséges intelligencia világa bővül, a fejlesztők az egyszeri… AI modellektől a komplex, többágenses rendszerekig, ahol számos specializált ágens működik együtt a problémák megoldása érdekében.

Az Ügynöki kommunikációs protokoll Az (ACP) megoldást kínál, egységes nyelvet biztosítva az ügynökök kommunikációjához, így a rendszerek skálázhatóbbak, rugalmasabbak és könnyebben kezelhetők.

Ez az útmutató részletes útmutatót nyújt egy skálázható többügynökös kommunikációs rendszer az Agent Communication Protocol használatával. 

Mi az Agent Communication Protocol (ACP)?

Az Agent Communication Protocol (ACP) egy nyílt protokoll, amelyet a ... szabványosítására terveztek. AI szerek kommunikáljanak egymással. Gondolj rá úgy, mint egy közös nyelvre, mint az angolra vagy a mandarinra, de szoftverügynökök számára.

Egységes felületet biztosít, amely lehetővé teszi az ügynökök számára, hogy zökkenőmentesen együttműködjenek, függetlenül attól, hogy programozási nyelv vagy a keretrendszer, amellyel készültek. Ez megold egy komoly fejfájást a többágenses rendszerek fejlesztése során, ahol az ágensek integrálása gyakran egyedi, törékeny kódot igényel, amely minden alkalommal megszakad, amikor egy ágens frissül.

Ez a struktúra azt jelenti, hogy könnyen lecserélhetsz egy ügynököt egy új verzióra vagy egy teljesen más, egy másik keretrendszerre épülő ügynökre anélkül, hogy a teljes rendszert újra kellene írnod.

Az ACP alapelvei

Az ACP megvalósításához meg kell érteni az alapvető építőelemeit. A protokoll néhány kulcsfontosságú összetevőn keresztül szabványosítja a kommunikációt, amelyek biztosítják, hogy minden üzenet strukturált, világos és cselekvésre ösztönző legyen.

A protokoll lényege a ACPMessage adatosztály. Ez egy szabványosított formátum az ügynökök között küldött összes üzenethez. Biztosítja, hogy minden kommunikációs csomag tartalmazza a szükséges információkat a megértéshez és a helyes útvonaltervezéshez. Egy tipikus ACPMessage tartalmazza:

A performatívusz egy ige, amely meghatározza az üzenet célját. Megmondja a címzettnek, hogy milyen cselekvést vagy választ vár. A gyakori performatívuszok közé tartoznak:

Az ACPAgent a rendszerben részt vevő bármely ágens alaposztálya. Ez definiálja az ágenst's identitás és annak alapvető képességei, például küldés és fogadás ACPMessagesMinden ügynöknek egyedi neve vagy azonosítója van, amely lehetővé teszi a rendszer számára, hogy üzeneteket irányítson hozzá.

Egy sok ügynökkel rendelkező rendszerben szükség van egy központi postára, amely az összes üzenetforgalmat kezeli. ACPMessageBroker Ezt a célt szolgálja.'s egy központi útválasztó komponens, amely fogadja az ügynököktől érkező üzeneteket, és biztosítja, hogy azok a megfelelő címzetthez jussanak. Ez a brókerarchitektúra kulcsfontosságú a rendszer skálázhatóvá és kezelhetővé tételéhez.

Kódolási útmutató az első ACP rendszeredhez

1. lépés: A környezet beállítása

Először telepítenie kell a szükséges Python könyvtárat a Google-lel való interakcióhoz.'s nemző AI modellek.

pip install google-generativeai

Azt is konfigurálnia kell a API kulcsot a kéréseid hitelesítéséhez.

2. lépés: Az ACP alapvető összetevőinek meghatározása

Legyen's lefordítani az ACP alapvető koncepcióit Python kódKezdjük az üzenetstruktúránk meghatározásával.

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

Ezután definiáljuk a ACPAgent osztály. Minden ügynöknek lesz egy neve és egy metódusa a bejövő üzenetek kezelésére.

# 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

Végül létrehozzuk a ACPMessageBroker a kommunikáció kezelésére.

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

3. lépés: Ügynökök létrehozása és megvalósítása

A keretrendszerrel specializált ágenseket hozhatunk létre. Legyen's csinálj egy Kutató ügynök amely kérdésekre tud válaszolni, és Menedzser Ügynök ami megkérdőjelezi azt.

import google.generativeai mint 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)

4. lépés: A rendszer futtatása

Most pedig hagyd's Tedd össze az egészet, és nézd meg működés közben.

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

Amikor lefuttatod ezt a kódot, látni fogod, hogy ügynökmenedzser Elküld egy lekérdezést, a bróker továbbítja azt a kutatónak, a kutató feldolgozza azt és választ küld, a bróker pedig visszairányítja a választ a vezetőnek. Ez az egyszerű interakció egy robusztus, leválasztott kommunikációs folyamatot demonstrál.

ACP a való világban: Érvek a SEO mellett

Az ACP alapelvei nem csupán elméletiek; közvetlen alkalmazási lehetőségekkel rendelkeznek az üzleti automatizálásban. Vegyük figyelembe a következő területet: Keresőoptimalizálás (SEO). Egy modern SEO stratégia sok mozgó részt foglal magában: kulcsszóelemzést, tartalomkészítést, oldalon belüli optimalizálást és backlinkkövetést.

Egy ACP által működtetett többügynökös rendszer automatizálhatná ezt a teljes folyamatot. Képzeljen el egy olyan rendszert, amelyben:

1. An SEO stratégiai ügynök amely figyeli a keresési trendeket és azonosítja a tartalmi hiányosságokat.
2. A Kulcsszókutató ügynök amely nagy értékű elsődleges és LSI kulcsszavak.
3. A Tartalomíró ügynök amely a stratéga megbízásai alapján cikkeket generál.
4. An Oldalon belüli optimalizáló ügynök amely ellenőrzi a tartalom olvashatóságát, kulcsszó-sűrűségét és szemantikai relevanciáját.

Az ACP segítségével ezek az ügynökök hibátlanul tudtak kommunikálni. A stratéga ügynöke küldhetett egy REQUEST a kulcsszavak keresésével foglalkozó ügynökségnek, amely ezután egy INFORM üzenetet küldjön a megállapításaival az író ügynöknek. Ez a modularitás hatékonyabbá és skálázhatóbbá teszi a teljes SEO munkafolyamatot.

Összegzés

Együttműködés építése AI rendszerek az egyik legizgalmasabb határvidék technológiaKözös kommunikációs szabvány nélkül azonban ezek a rendszerek az egyedi integrációk kusza káoszává válhatnak. Az Agent Communication Protocol (ACP) tiszta, robusztus és skálázható megoldást kínál erre a problémára.

Azzal, hogy szabványosítjuk az ügynökök interakcióját egy egyszerű kliens-szerver modell és egy jól definiált üzenetstruktúrával az ACP lehetővé teszi a fejlesztők számára, hogy rugalmas és hatékony többügynökös alkalmazásokat hozzanak létre. Amint azt a mi Python útmutatóegy alapvető ACP rendszer megvalósítása egyszerű. 

Innen kiindulva skálázható, kifinomult, hierarchikus munkafolyamatok hozhatók létre, amelyek képesek komplex feladatok elvégzésére a szoftverfejlesztéstől a SEO-ig terjedő területeken. Az ACP-hez hasonló protokoll bevezetése létfontosságú lépés egy olyan jövő felé, ahol intelligens ügynökök zökkenőmentesen együttműködnek céljaink elérésében.