აგენტის კომუნიკაციის პროტოკოლის (ACP) გამოყენებით მრავალაგენტიანი სისტემების შექმნა

ხელოვნური ინტელექტის სამყაროს გაფართოებასთან ერთად, დეველოპერები ერთიანობიდან გადადიან AI მოდელები რთული, მრავალაგენტიანი სისტემებისთვის, სადაც მრავალი სპეციალიზებული აგენტი თანამშრომლობს პრობლემების გადასაჭრელად.

აგენტის კომუნიკაციის პროტოკოლი (ACP) გვთავაზობს გადაწყვეტას, რომელიც აგენტებს კომუნიკაციისთვის ერთიან ენას სთავაზობს, რაც სისტემებს უფრო მასშტაბირებადს, მოქნილს და მართვადს ხდის.

ეს სახელმძღვანელო გთავაზობთ დეტალურ ინსტრუქციას, თუ როგორ უნდა ავაშენოთ მასშტაბირებადი მრავალაგენტიანი საკომუნიკაციო სისტემა აგენტის საკომუნიკაციო პროტოკოლის გამოყენებით.

რა არის აგენტის კომუნიკაციის პროტოკოლი (ACP)?

აგენტის კომუნიკაციის პროტოკოლი (ACP) არის ღია პროტოკოლი, რომელიც შექმნილია სტანდარტიზაციისთვის. AI აგენტები ერთმანეთთან კომუნიკაცია. წარმოიდგინეთ ეს, როგორც საერთო ენა, როგორიცაა ინგლისური ან მანდარინი, მაგრამ პროგრამული უზრუნველყოფის აგენტებისთვის.

ის უზრუნველყოფს ერთიან ინტერფეისს, რომელიც საშუალებას აძლევს აგენტებს შეუფერხებლად იმუშაონ ერთად, მიუხედავად იმ პროგრამირების ენისა თუ ჩარჩოსი, რომლითაც ისინი შეიქმნა. ეს წყვეტს მრავალაგენტიანი სისტემების შემუშავების მთავარ პრობლემას, სადაც აგენტების ინტეგრირება ხშირად მოითხოვს მორგებულ, მყიფე კოდს, რომელიც აგენტის ყოველ განახლებაზე იშლება.

ეს სტრუქტურა ნიშნავს, რომ თქვენ შეგიძლიათ მარტივად შეცვალოთ აგენტი ახალი ვერსიით ან სრულიად განსხვავებული აგენტით, რომელიც აგებულია სხვა ჩარჩოზე, მთელი სისტემის გადაწერის გარეშე.

ACP-ის ძირითადი პრინციპები

ACP-ის განსახორციელებლად, თქვენ უნდა გესმოდეთ მისი ფუნდამენტური საფუძვლები. პროტოკოლი სტანდარტიზაციას უკეთებს კომუნიკაციას რამდენიმე ძირითადი კომპონენტის მეშვეობით, რაც უზრუნველყოფს, რომ თითოეული შეტყობინება იყოს სტრუქტურირებული, ნათელი და ქმედითი.

პროტოკოლის არსი არის ACPMessage მონაცემთა კლასი. ეს არის სტანდარტიზებული ფორმატი აგენტებს შორის გაგზავნილი ყველა შეტყობინებისთვის. ის უზრუნველყოფს, რომ ყველა საკომუნიკაციო პაკეტი შეიცავდეს საჭირო ინფორმაციას მისი გაგებისა და სწორად გადასაცემად. ტიპიური ACPMessage მოიცავს:

პერფორმატივი არის ზმნა, რომელიც განსაზღვრავს შეტყობინების მიზანს. ის მიმღებ აგენტს ეუბნება, თუ რა სახის მოქმედება ან რეაქციაა მოსალოდნელი. გავრცელებული პერფორმატივებია:

ის ACPAgent არის სისტემაში მონაწილე ნებისმიერი აგენტის საბაზო კლასი. ის განსაზღვრავს აგენტს's იდენტობა და მისი ძირითადი შესაძლებლობები, როგორიცაა გაგზავნა და მიღება ACPMessagesთითოეულ აგენტს აქვს უნიკალური სახელი ან ID, რომელიც სისტემას საშუალებას აძლევს, შეტყობინებები მასზე გადაამისამართოს.

სისტემაში, სადაც ბევრი აგენტია, საჭიროა ცენტრალური ფოსტა, რომელიც ყველა შეტყობინების ტრაფიკს დაამუშავებს. ACPMessageBroker ამ მიზანს ემსახურება.'s ცენტრალური მარშრუტიზაციის კომპონენტი, რომელიც იღებს შეტყობინებებს აგენტებისგან და უზრუნველყოფს მათ სწორ მიმღებამდე მიწოდებას. ბროკერის ეს არქიტექტურა სისტემის მასშტაბირებადობისა და მართვადობის გასაღებია.

კოდირების სახელმძღვანელო თქვენი პირველი ACP სისტემისთვის

ნაბიჯი 1: თქვენი გარემოს დაყენება

პირველ რიგში, Google-თან ურთიერთქმედებისთვის საჭიროა Python-ის საჭირო ბიბლიოთეკის ინსტალაცია.'s გენერაციული AI მოდელები.

pip install google-generativeai

ასევე დაგჭირდებათ თქვენი API გასაღების კონფიგურაცია თქვენი მოთხოვნების ავტორიზაციისთვის.

ნაბიჯი 2: ACP-ის ძირითადი კომპონენტების განსაზღვრა

მოდით, ACP-ის ძირითადი კონცეფციები Python-ის კოდში გადავთარგმნოთ . დავიწყოთ ჩვენი შეტყობინების სტრუქტურის განსაზღვრით.

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

შემდეგი, ჩვენ განვსაზღვრავთ ACPAgent კლასი. თითოეულ აგენტს ექნება სახელი და მეთოდი შემომავალი შეტყობინებების დასამუშავებლად.

# 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

საბოლოოდ, ჩვენ ვქმნით ACPMessageBroker კომუნიკაციის სამართავად.

# 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: აგენტების შექმნა და დანერგვა

ჩარჩოს შექმნით, ჩვენ შეგვიძლია შევქმნათ სპეციალიზებული აგენტები. მოდით შევქმნათ მკვლევარი აგენტი , რომელსაც შეუძლია კითხვებზე პასუხის გაცემა და მენეჯერი აგენტი , რომელიც კითხვებს სვამს.

google.generative-ის იმპორტიai როგორც გენაი

# 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: სისტემის გაშვება

ახლა, მოდით's შეაერთეთ ყველაფერი და ნახეთ მოქმედებაში.

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

ამ კოდის გაშვებისას, თქვენ დაინახავთ, რომ მენეჯერი აგენტი აგზავნის მოთხოვნას, ბროკერი მას მკვლევართან გადამისამართებს, მკვლევარი ამუშავებს მას და პასუხს უგზავნის, ხოლო ბროკერი პასუხს მენეჯერთან უკან გადამისამართებს. ეს მარტივი ურთიერთქმედება აჩვენებს მყარ, განცალკევებულ კომუნიკაციის ნაკადს.

ACP რეალურ სამყაროში: SEO-ს სასარგებლოდ არსებული არგუმენტები

ACP-ის პრინციპები მხოლოდ თეორიული არ არის; მათ პირდაპირი გამოყენება აქვთ ბიზნესის ავტომატიზაციაში. განვიხილოთ საძიებო სისტემის ოპტიმიზაციის (SEO) სფერო . თანამედროვე SEO სტრატეგია მოიცავს მრავალ მოძრავ ნაწილს: საკვანძო სიტყვების ანალიზს, კონტენტის შექმნას, გვერდის ოპტიმიზაციას და უკუკავშირის თვალყურის დევნებას.

ACP-ზე მომუშავე მრავალაგენტიან სისტემას შეუძლია მთელი ამ პროცესის ავტომატიზაცია. წარმოიდგინეთ სისტემა, რომელსაც აქვს:

1. An SEO სტრატეგი აგენტი რომელიც აკონტროლებს ძიების ტენდენციებს და ადგენს კონტენტის ხარვეზებს.
2. A საკვანძო სიტყვების კვლევის აგენტი რომელიც პოულობს მაღალი ღირებულების პირველად და LSI საკვანძო სიტყვები.
3. A კონტენტის წერის აგენტი რომელიც სტრატეგის მოკლე მოხსენებებზე დაყრდნობით სტატიებს ქმნის.
4. An გვერდის ოპტიმიზაციის აგენტი რომელიც ამოწმებს კონტენტის წაკითხვადობას, საკვანძო სიტყვების სიმკვრივეს და სემანტიკურ შესაბამისობას.

ACP-ის საშუალებით ამ აგენტებს შეეძლოთ უნაკლოდ კომუნიკაცია. სტრატეგ აგენტს შეეძლო გაეგზავნა REQUEST საკვანძო სიტყვების ძიების აგენტს, რომელიც შემდეგ აგზავნის INFORM მისი დასკვნებით შეტყობინებას წერის აგენტს უგზავნის. ეს მოდულარობა მთელ SEO სამუშაო პროცესს უფრო ეფექტურს და მასშტაბირებადს ხდის.

დასკვნა

თანამშრომლობის დამყარება AI სისტემები ერთ-ერთი ყველაზე საინტერესო საზღვარია ტექნოლოგიათუმცა, საერთო საკომუნიკაციო სტანდარტის გარეშე, ეს სისტემები რისკის ქვეშ არიან, რომ მორგებული ინტეგრაციების ჩახლართულ არეულობებად იქცნენ. აგენტის საკომუნიკაციო პროტოკოლი (ACP) ამ პრობლემის სუფთა, საიმედო და მასშტაბირებად გადაწყვეტას უზრუნველყოფს.

აგენტების ურთიერთქმედების სტანდარტიზაციით მარტივი კლიენტ-სერვერის მოდელისა და კარგად განსაზღვრული შეტყობინების სტრუქტურის მეშვეობით, ACP საშუალებას აძლევს დეველოპერებს შექმნან მოქნილი და ძლიერი მრავალაგენტიანი აპლიკაციები. როგორც ჩვენს Python სახელმძღვანელოშია ნაჩვენები , ACP-ის საბაზისო სისტემის დანერგვა მარტივია.

იქიდან შეგიძლიათ მასშტაბირება მოახდინოთ დახვეწილი, იერარქიული სამუშაო პროცესების შესაქმნელად, რომლებსაც შეუძლიათ რთული ამოცანების გადაჭრა სხვადასხვა სფეროებში, პროგრამული უზრუნველყოფის შემუშავებიდან დაწყებული SEO-თი დამთავრებული. ACP-ის მსგავსი პროტოკოლის დანერგვა სასიცოცხლოდ მნიშვნელოვანი ნაბიჯია მომავლისკენ, სადაც ინტელექტუალური აგენტები შეუფერხებლად ითანამშრომლებენ ჩვენი მიზნების მისაღწევად.