Kurs Python · Moduł 11: RAG i systemy wieloagentowe
Multi-Agent Systems
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.contentMetoda 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 responsesend_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 resultsKolejność 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_outputTo 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 conversationKaż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. Co to jest system multi-agentowy?
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: