Kurs Python · Moduł 11: RAG i systemy wieloagentowe

Multi-Agent Systems

8 min czytania ·
W tej lekcji6

Poproś jeden model, żeby zebrał informacje, przeanalizował je, napisał artykuł i jeszcze go skrytykował. Dostaniesz tekst, w którym wszystko jest trochę, a nic porządnie, bo jeden prompt ciągnie model w czterech kierunkach naraz. Na sawannie też nikt nie robi wszystkiego sam.

Systemy multi-agentowe to architektura, gdzie wiele wyspecjalizowanych agentów AI współpracuje przy rozwiązywaniu złożonych zadań. To jak stado zwierząt, gdzie każdy osobnik ma swoją rolę - łowcy, obserwatorzy, obrońcy. Każdy agent dostaje własny prompt systemowy i robi jedną rzecz dobrze.

Podstawy Multi-Agent

Najpierw ustalmy słownik. Role zapiszemy jako Enum, czyli zamknięty zbiór nazwanych stałych, a wiadomość między agentami jako @dataclass:

from dataclasses import dataclass
from enum import Enum
from abc import ABC, abstractmethod
from openai import OpenAI

class AgentRole(Enum):
    """Role agentów w systemie."""
    RESEARCHER = "researcher"      # Zbiera informacje
    ANALYZER = "analyzer"          # Analizuje dane
    WRITER = "writer"              # Pisze treści
    CRITIC = "critic"              # Recenzuje i poprawia
    COORDINATOR = "coordinator"    # Koordynuje pracę

@dataclass
class AgentMessage:
    """Wiadomość między agentami."""
    sender: str
    receiver: str
    content: str
    message_type: str = "task"

AgentMessage pamięta nadawcę, odbiorcę, treść i typ wiadomości. Domyślny typ to "task", więc przy zwykłym zleceniu nie trzeba go podawać.

Teraz bazowa klasa agenta. Dziedziczy po ABC, a właściwość system_prompt jest oznaczona @abstractmethod, więc każda klasa potomna musi ją zdefiniować:

class BaseAgent(ABC):
    """Bazowa klasa agenta."""

    def __init__(self, name: str, role: AgentRole, model: str = "gpt-4o-mini"):
        self.name = name
        self.role = role
        self.model = model
        self.client = OpenAI()
        self.memory: list[AgentMessage] = []

    @property
    @abstractmethod
    def system_prompt(self) -> str:
        """Prompt systemowy agenta."""
        pass

    def process(self, message: AgentMessage) -> str:
        """Przetwarza wiadomość i zwraca odpowiedź."""
        self.memory.append(message)

        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": self.system_prompt},
                {"role": "user", "content": message.content}
            ]
        )

        return response.choices[0].message.content

Metoda process zapisuje wiadomość w pamięci agenta i wysyła do modelu dwie wiadomości: prompt systemowy z rolą i treść zadania. Nie da się utworzyć obiektu samego BaseAgent, Python zgłosi TypeError, bo brakuje mu implementacji system_prompt.

Implementacja agentów specjalistycznych

Agenci specjaliści różnią się wyłącznie promptem. Pierwsza para to badacz i analityk:

class ResearcherAgent(BaseAgent):
    """Agent badawczy - zbiera informacje."""

    @property
    def system_prompt(self) -> str:
        return """Jesteś agentem badawczym. Twoja rola to:
1. Zbieranie informacji na zadany temat
2. Identyfikacja kluczowych faktów
3. Weryfikacja źródeł
4. Strukturyzowanie wiedzy

Zawsze podawaj źródła i dziel informacje na kategorie."""

class AnalyzerAgent(BaseAgent):
    """Agent analityczny - analizuje dane."""

    @property
    def system_prompt(self) -> str:
        return """Jesteś agentem analitycznym. Twoja rola to:
1. Analiza dostarczonych danych
2. Identyfikacja wzorców i trendów
3. Formułowanie wniosków
4. Ocena ryzyka i szans

Bądź precyzyjny i podawaj konkretne liczby."""

Każda klasa nadpisuje tylko system_prompt, a cała logika wywołania modelu pozostaje w BaseAgent. Tak wygląda dziedziczenie w praktyce: wspólny kod raz, różnice w podklasach.

Druga para to pisarz i krytyk:

class WriterAgent(BaseAgent):
    """Agent pisarski - tworzy treści."""

    @property
    def system_prompt(self) -> str:
        return """Jesteś agentem pisarskim. Twoja rola to:
1. Tworzenie angażujących treści
2. Dostosowanie stylu do odbiorcy
3. Strukturyzowanie tekstu
4. Dbanie o klarowność przekazu

Pisz zwięźle i na temat."""

class CriticAgent(BaseAgent):
    """Agent krytyczny - recenzuje i poprawia."""

    @property
    def system_prompt(self) -> str:
        return """Jesteś agentem krytycznym. Twoja rola to:
1. Ocena jakości treści
2. Identyfikacja błędów i niedociągnięć
3. Sugerowanie ulepszeń
4. Weryfikacja faktów

Bądź konstruktywny, ale szczery."""

Researcher zbiera informacje, Analyzer je analizuje, Writer tworzy treść, a Critic recenzuje i poprawia. To typowe role w systemie multi-agent. Zwróć uwagę, że rola "Destroyer, który usuwa pliki" nigdy tu nie występuje: agent ma pomagać, a nie niszczyć.

Orkiestracja agentów

Ktoś musi przekazywać wiadomości między członkami stada. Tę rolę pełni orkiestrator, który rejestruje agentów i pośredniczy w każdej rozmowie:

from typing import Optional

class AgentOrchestrator:
    """Koordynator pracy agentów."""

    def __init__(self):
        self.agents: dict[str, BaseAgent] = {}
        self.conversation_history: list[AgentMessage] = []

    def register_agent(self, agent: BaseAgent) -> None:
        """Rejestruje agenta w systemie."""
        self.agents[agent.name] = agent
        print(f"Zarejestrowano agenta: {agent.name} ({agent.role.value})")

    def send_message(
        self,
        sender: str,
        receiver: str,
        content: str
    ) -> str:
        """Wysyła wiadomość między agentami."""
        if receiver not in self.agents:
            raise ValueError(f"Agent {receiver} nie istnieje!")

        message = AgentMessage(
            sender=sender,
            receiver=receiver,
            content=content
        )

        self.conversation_history.append(message)

        response = self.agents[receiver].process(message)

        # Zapisz odpowiedź
        response_message = AgentMessage(
            sender=receiver,
            receiver=sender,
            content=response,
            message_type="response"
        )
        self.conversation_history.append(response_message)

        return response

send_message sprawdza, czy odbiorca istnieje, zapisuje wiadomość w historii, wywołuje process i zapisuje też odpowiedź. Dzięki temu cała rozmowa zostaje w jednym miejscu.

Metoda run_pipeline układa agentów w łańcuch, w którym wynik jednego staje się wejściem następnego:

    def run_pipeline(self, task: str) -> dict[str, str]:
        """Uruchamia pipeline przetwarzania."""
        results = {}

        # 1. Researcher zbiera informacje
        research = self.send_message("user", "researcher",
            f"Zbierz informacje na temat: {task}")
        results["research"] = research

        # 2. Analyzer analizuje
        analysis = self.send_message("researcher", "analyzer",
            f"Przeanalizuj te informacje:\n{research}")
        results["analysis"] = analysis

        # 3. Writer tworzy treść
        draft = self.send_message("analyzer", "writer",
            f"Na podstawie analizy napisz artykuł:\n{analysis}")
        results["draft"] = draft

        # 4. Critic recenzuje
        review = self.send_message("writer", "critic",
            f"Zrecenzuj ten artykuł:\n{draft}")
        results["review"] = review

        return results

Kolejność jest stała: Researcher zbiera informacje, Analyzer analizuje dane, Writer tworzy treść, Critic recenzuje. Słownik results zachowuje wynik każdego etapu, a nie tylko ostatni.

Pozostało zarejestrować czterech agentów i uruchomić pipeline:

# Użycie
orchestrator = AgentOrchestrator()
orchestrator.register_agent(ResearcherAgent("researcher", AgentRole.RESEARCHER))
orchestrator.register_agent(AnalyzerAgent("analyzer", AgentRole.ANALYZER))
orchestrator.register_agent(WriterAgent("writer", AgentRole.WRITER))
orchestrator.register_agent(CriticAgent("critic", AgentRole.CRITIC))

results = orchestrator.run_pipeline("Przyszłość sztucznej inteligencji w 2025")

Każdy agent jest zapisany pod swoją nazwą, więc send_message("user", "researcher", ...) trafia dokładnie tam, gdzie trzeba.

Komunikacja asynchroniczna

Agenci nie muszą rozmawiać wyłącznie po kolei. Można im zostawiać wiadomości w kolejce asyncio.Queue, jak notatki przy wodopoju:

import asyncio
from typing import Callable

class AsyncAgentSystem:
    """Asynchroniczny system agentów."""

    def __init__(self):
        self.agents: dict[str, BaseAgent] = {}
        self.message_queue: asyncio.Queue = asyncio.Queue()
        self.results: dict[str, str] = {}

    async def process_messages(self) -> None:
        """Przetwarza wiadomości z kolejki."""
        while True:
            message = await self.message_queue.get()

            if message.content == "STOP":
                break

            agent = self.agents.get(message.receiver)
            if agent:
                response = agent.process(message)
                self.results[message.receiver] = response

            self.message_queue.task_done()

Pętla process_messages czeka na wiadomość słowem await, obsługuje ją i kończy pracę, gdy dostanie sygnał "STOP".

Metoda run_parallel_tasks wkłada zadania do kolejki i uruchamia przetwarzanie:

    async def run_parallel_tasks(self, tasks: list[tuple[str, str]]) -> dict:
        """Uruchamia zadania równolegle."""
        # Dodaj zadania do kolejki
        for agent_name, task in tasks:
            await self.message_queue.put(
                AgentMessage("system", agent_name, task)
            )

        # Dodaj sygnał końca
        await self.message_queue.put(
            AgentMessage("system", "STOP", "STOP")
        )

        # Uruchom przetwarzanie
        await self.process_messages()

        return self.results

# Przykład równoległego przetwarzania
async def main():
    system = AsyncAgentSystem()
    # ... rejestracja agentów ...

    tasks = [
        ("researcher", "Zbadaj temat X"),
        ("analyzer", "Przeanalizuj dane Y"),
    ]

    results = await system.run_parallel_tasks(tasks)
    print(results)

asyncio.run(main())

Uczciwie: mimo nazwy te zadania nie wykonują się równolegle. Jest jeden konsument kolejki, a agent.process to zwykłe, blokujące wywołanie. Prawdziwą równoległość dałby asynchroniczny klient AsyncOpenAI i asyncio.gather albo asyncio.to_thread. Kolejka przydaje się jednak do rozdzielenia nadawców od odbiorców.

Narzędzia agenta

Agent, który tylko pisze, jest jak tropiciel bez lornetki. Narzędzia pozwalają mu działać: przeszukać bazę, pobrać pogodę, policzyć koszt. W LangChain funkcję zamienia się w narzędzie dekoratorem @tool:

from langchain_core.tools import tool

@tool
def search_db(query: str) -> list:
    """Przeszukuje bazę obserwacji zwierząt."""
    return [f"Obserwacja pasująca do: {query}"]

print(search_db.name)           # search_db
print(search_db.invoke("lwy"))  # ['Obserwacja pasująca do: lwy']

Docstring nie jest tu ozdobą: model czyta go jako opis narzędzia, a bez niego dekorator zgłosi błąd. Typy parametrów mówią modelowi, jakie argumenty podać. Agent z narzędziami pracuje w pętli: planuje działanie, wykonuje akcję, obserwuje wynik i robi refleksję, czy poprawić kurs.

Wzorce współpracy agentów

Na koniec trzy klasyczne wzorce. Chain to łańcuch, w którym każdy agent przekazuje wynik kolejnemu:

class CollaborationPatterns:
    """Wzorce współpracy agentów."""

    @staticmethod
    def chain(agents: list[BaseAgent], initial_input: str) -> str:
        """Chain - każdy agent przekazuje output kolejnemu."""
        current_output = initial_input

        for agent in agents:
            message = AgentMessage("system", agent.name, current_output)
            current_output = agent.process(message)

        return current_output

To uogólnienie naszego run_pipeline: lista agentów może mieć dowolną długość.

Debate to dyskusja dwóch agentów przez kilka rund:

    @staticmethod
    def debate(agent1: BaseAgent, agent2: BaseAgent, topic: str, rounds: int = 3) -> list[str]:
        """Debate - agenci dyskutują na temat."""
        conversation = []

        current = f"Dyskusja na temat: {topic}. Przedstaw swoje stanowisko."

        for i in range(rounds):
            # Agent 1
            response1 = agent1.process(
                AgentMessage(agent2.name, agent1.name, current)
            )
            conversation.append(f"{agent1.name}: {response1}")

            # Agent 2 odpowiada
            response2 = agent2.process(
                AgentMessage(agent1.name, agent2.name, response1)
            )
            conversation.append(f"{agent2.name}: {response2}")
            current = response2

        return conversation

Każda odpowiedź jednego agenta staje się wejściem drugiego, a lista conversation zapisuje całą wymianę zdań.

Consensus zbiera opinie wszystkich i prosi jednego agenta o syntezę:

    @staticmethod
    def consensus(agents: list[BaseAgent], question: str) -> str:
        """Consensus - agenci dochodzą do wspólnego wniosku."""
        opinions = []

        # Zbierz opinie
        for agent in agents:
            opinion = agent.process(
                AgentMessage("system", agent.name, question)
            )
            opinions.append(f"{agent.name}: {opinion}")

        # Synteza (użyj jednego z agentów)
        synthesis_prompt = f"""Pytanie: {question}

Opinie agentów:
{chr(10).join(opinions)}

Sformułuj wspólny konsensus na podstawie tych opinii."""

        return agents[0].process(
            AgentMessage("system", agents[0].name, synthesis_prompt)
        )

chr(10) to znak nowej linii, użyty zamiast "\n" wewnątrz f-stringa. Polecam zaczynać od prostego łańcucha, a debatę i konsensus dokładać dopiero tam, gdzie jedna perspektywa naprawdę nie wystarcza, bo każda runda to kolejne płatne wywołania modelu.

Systemy multi-agentowe otwierają drzwi do złożonych aplikacji AI. W następnej lekcji poznasz CrewAI - framework do tworzenia zespołów agentów, który daje te wzorce w gotowej postaci!

Zapamiętaj: dobry system agentów działa jak stado, w którym każdy zna swoją rolę, a przewodnik pilnuje kierunku.

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Co to jest system multi-agentowy?

  2. 2. Która rola agenta NIE jest typowa w systemie multi-agent?

Zadania praktyczne w grze

  • Edytor kodu

    Zaimplementuj AgentOrchestrator

  • Układanie w pionie

    Uporządkuj kroki:

  • Klikanie w kolejności

    Ułóż definicję narzędzia agenta:

  • Układanie w pionie

    Ułóż typowy workflow przetwarzania w systemie multi-agent:

  1. PytanieMulti-Agent
  2. PytanieRole agentów
  3. Zadanie z kodemAgent Orchestrator
  4. Ułóż w kolejnościCykl życia agenta
  5. Kliknij w kolejnościAgent Tool Definition
  6. Ułóż w kolejnościWorkflow agentów

Przydatne artykuły