Kurs Python · Moduł 11: RAG i systemy wieloagentowe
Subagents i Hierarchie Agentów
W tej lekcji8
Wyprawa rośnie: ktoś bada trasę, ktoś liczy zapasy, ktoś sprawdza pozwolenia, ktoś pilnuje jakości. Gdy każdy z nich rozmawia z każdym, po tygodniu nikt nie wie, kto co ustalił. Potrzebujesz kierownika wyprawy, który rozdziela zadania i zbiera raporty.
Subagenty to wzorzec architektoniczny, gdzie główny agent (orchestrator) deleguje zadania do wyspecjalizowanych podagentów. To jak struktura organizacyjna firmy - CEO deleguje zadania do managerów, którzy delegują dalej.
Architektura Subagentów
Schemat pokazuje trzy piętra hierarchii, od kierownika po narzędzia:
┌─────────────────────────────────────────────────────────────┐
│ Agent Hierarchy │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌───────────────┐ │
│ │ Orchestrator │ │
│ │ (Main AI) │ │
│ └───────┬───────┘ │
│ │ │
│ ┌────────────────┼────────────────┐ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌────────────┐ ┌────────────┐ ┌────────────┐ │
│ │ Research │ │ Analysis │ │ Execution │ │
│ │ Subagent │ │ Subagent │ │ Subagent │ │
│ └─────┬──────┘ └─────┬──────┘ └─────┬──────┘ │
│ │ │ │ │
│ ┌─────┴─────┐ ┌─────┴─────┐ ┌─────┴─────┐ │
│ │ Tools │ │ Tools │ │ Tools │ │
│ └───────────┘ └───────────┘ └───────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘Na górze orchestrator, który koordynuje pracę i deleguje zadania. Niżej subagenci specjaliści, a na dole narzędzia, których używają. Orchestrator nigdy nie sięga po narzędzia bezpośrednio.
Podstawowa implementacja Subagentów
Najpierw typy danych: role jako Enum oraz zadanie i wynik jako @dataclass:
from openai import OpenAI
from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Optional
from enum import Enum
client = OpenAI()
class SubagentRole(Enum):
RESEARCHER = "researcher"
ANALYST = "analyst"
EXECUTOR = "executor"
VALIDATOR = "validator"
@dataclass
class SubagentTask:
"""Zadanie dla subagenta."""
description: str
context: str
expected_output: str
priority: int = 1
@dataclass
class SubagentResult:
"""Wynik pracy subagenta."""
success: bool
output: str
metadata: dictSubagentTask niesie opis, kontekst i oczekiwany wynik, czyli wszystko, czego specjalista potrzebuje, żeby nie pytać kierownika o szczegóły.
Bazowa klasa Subagent dziedziczy po ABC i wymusza system_prompt przez @abstractmethod, tak jak BaseAgent z lekcji o systemach multi-agentowych:
class Subagent(ABC):
"""Bazowa klasa subagenta."""
def __init__(self, name: str, role: SubagentRole, model: str = "gpt-4o-mini"):
self.name = name
self.role = role
self.model = model
self.tools: list[dict] = []
self.memory: list[str] = []
@property
@abstractmethod
def system_prompt(self) -> str:
"""Prompt systemowy subagenta."""
pass
def add_tool(self, tool: dict) -> None:
"""Dodaje narzędzie do subagenta."""
self.tools.append(tool)Każdy subagent ma własną listę narzędzi i pamięć. add_tool dopisuje definicję narzędzia w formacie OpenAI, a memory zbiera skróty wykonanych zadań.
Metoda execute składa prompt z trzech pól zadania i woła model:
async def execute(self, task: SubagentTask) -> SubagentResult:
"""Wykonuje zadanie."""
messages = [
{"role": "system", "content": self.system_prompt},
{"role": "user", "content": f"""
Zadanie: {task.description}
Kontekst: {task.context}
Oczekiwany output: {task.expected_output}
"""}
]
response = client.chat.completions.create(
model=self.model,
messages=messages,
tools=self.tools if self.tools else None
)
output = response.choices[0].message.content
self.memory.append(f"Task: {task.description} -> Result: {output[:100]}...")
return SubagentResult(
success=True,
output=output,
metadata={"model": self.model, "role": self.role.value}
)Metoda jest async, ale używa synchronicznego klienta, więc blokuje pętlę zdarzeń. W produkcji użyj AsyncOpenAI i await. Uwaga też na narzędzia: gdy model zamiast tekstu wywoła narzędzie, content będzie None i output[:100] zgłosi błąd.
Wyspecjalizowane Subagenty
Specjaliści, podobnie jak wcześniej, różnią się tylko promptem. Badacz i analityk:
class ResearchSubagent(Subagent):
"""Subagent badawczy - zbiera informacje."""
@property
def system_prompt(self) -> str:
return """Jesteś wyspecjalizowanym agentem badawczym.
Twoje zadania:
1. Zbieranie informacji z dostępnych źródeł
2. Weryfikacja faktów
3. Strukturyzowanie wiedzy
4. Identyfikacja luk informacyjnych
Zawsze:
- Podawaj źródła informacji
- Zaznaczaj niepewności
- Proponuj dalsze kierunki badań"""
class AnalysisSubagent(Subagent):
"""Subagent analityczny - analizuje dane."""
@property
def system_prompt(self) -> str:
return """Jesteś wyspecjalizowanym agentem analitycznym.
Twoje zadania:
1. Analiza dostarczonych danych
2. Identyfikacja wzorców i trendów
3. Formułowanie wniosków
4. Ocena ryzyka i szans
Zawsze:
- Używaj danych liczbowych
- Przedstawiaj alternatywne interpretacje
- Podkreślaj kluczowe odkrycia"""Każdy prompt mówi, co subagent robi i czego ma zawsze pilnować. Sekcja "Zawsze" działa jak regulamin obozu dla danego specjalisty.
Wykonawca i walidator domykają zespół:
class ExecutorSubagent(Subagent):
"""Subagent wykonawczy - realizuje zadania."""
@property
def system_prompt(self) -> str:
return """Jesteś wyspecjalizowanym agentem wykonawczym.
Twoje zadania:
1. Realizacja zaplanowanych działań
2. Używanie narzędzi do wykonania zadań
3. Raportowanie postępów
4. Obsługa błędów
Zawsze:
- Wykonuj zadania krok po kroku
- Weryfikuj wyniki każdej akcji
- Raportuj problemy natychmiast"""
class ValidatorSubagent(Subagent):
"""Subagent walidujący - sprawdza jakość."""
@property
def system_prompt(self) -> str:
return """Jesteś wyspecjalizowanym agentem walidacyjnym.
Twoje zadania:
1. Weryfikacja poprawności wyników
2. Sprawdzanie zgodności z wymaganiami
3. Identyfikacja błędów i niedociągnięć
4. Sugerowanie poprawek
Zawsze:
- Bądź krytyczny ale konstruktywny
- Używaj konkretnych kryteriów
- Proponuj rozwiązania problemów"""Walidator to recenzent wyników pozostałych, dzięki czemu błąd jednego specjalisty ma szansę zostać wyłapany.
Orchestrator - Zarządzanie Subagentami
Orchestrator trzyma rejestr subagentów i historię zadań:
from typing import Dict, List
import asyncio
class AgentOrchestrator:
"""Główny orchestrator zarządzający subagentami."""
def __init__(self, model: str = "gpt-4o-mini"):
self.model = model
self.subagents: Dict[str, Subagent] = {}
self.task_history: List[dict] = []
def register_subagent(self, subagent: Subagent) -> None:
"""Rejestruje subagenta."""
self.subagents[subagent.name] = subagent
print(f"Zarejestrowano subagenta: {subagent.name} ({subagent.role.value})")
def get_available_subagents(self) -> str:
"""Zwraca opis dostępnych subagentów."""
return "\n".join([
f"- {name}: {agent.role.value}"
for name, agent in self.subagents.items()
])get_available_subagents tworzy tekstową listę specjalistów, którą za chwilę pokażemy modelowi.
Kroki orchestratora idą zawsze w tej kolejności: plan_execution, wybór subagenta, subagent.execute i synthesize_results. Planowanie prosi model o plan w JSON:
async def plan_execution(self, task: str) -> List[SubagentTask]:
"""Planuje wykonanie zadania przez odpowiednich subagentów."""
planning_prompt = f"""Masz do wykonania zadanie: {task}
Dostępni subagenci:
{self.get_available_subagents()}
Zaplanuj wykonanie zadania. Dla każdego kroku określ:
1. Który subagent powinien wykonać krok
2. Opis zadania dla subagenta
3. Oczekiwany output
4. Priorytet (1-5)
Odpowiedz w formacie JSON:
{{"steps": [{{"subagent": "nazwa", "task": "opis", "expected_output": "...", "priority": 1}}, ...]}}"""
response = client.chat.completions.create(
model=self.model,
messages=[
{"role": "system", "content": "Jesteś planistą zadań. Odpowiadaj tylko w JSON."},
{"role": "user", "content": planning_prompt}
],
response_format={"type": "json_object"}
)
import json
plan = json.loads(response.choices[0].message.content)
tasks = []
for step in plan.get("steps", plan):
tasks.append(SubagentTask(
description=step["task"],
context=task,
expected_output=step["expected_output"],
priority=step.get("priority", 1)
))
return tasksTryb response_format={"type": "json_object"} gwarantuje poprawny obiekt JSON, ale nie tablicę. Dlatego prompt prosi o obiekt z kluczem steps, a kod czyta plan.get("steps", plan).
execute_task spina planowanie, wykonanie i syntezę:
async def execute_task(self, task: str) -> str:
"""Wykonuje zadanie używając subagentów."""
# 1. Planowanie
planned_tasks = await self.plan_execution(task)
print(f"Zaplanowano {len(planned_tasks)} kroków")
# 2. Wykonanie
results = []
for i, subtask in enumerate(planned_tasks):
# Znajdź odpowiedniego subagenta
subagent = self._select_subagent(subtask)
if subagent:
print(f"Krok {i+1}: {subagent.name} wykonuje: {subtask.description[:50]}...")
result = await subagent.execute(subtask)
results.append({
"step": i + 1,
"subagent": subagent.name,
"task": subtask.description,
"result": result.output
})
# 3. Synteza
final_result = await self._synthesize_results(task, results)
return final_resultWyniki trafiają do listy słowników, więc synteza wie, który subagent co zrobił.
Wybór subagenta to prosta heurystyka słów kluczowych:
def _select_subagent(self, task: SubagentTask) -> Optional[Subagent]:
"""Wybiera najlepszego subagenta dla zadania."""
# Prosta heurystyka - można rozbudować o ML
keywords = {
"researcher": ["zbadaj", "znajdź", "wyszukaj", "informacje"],
"analyst": ["analizuj", "oceń", "porównaj", "wnioski"],
"executor": ["wykonaj", "zrób", "stwórz", "zaimplementuj"],
"validator": ["sprawdź", "zweryfikuj", "waliduj", "przetestuj"]
}
task_lower = task.description.lower()
for subagent_type, kws in keywords.items():
if any(kw in task_lower for kw in kws):
for agent in self.subagents.values():
if agent.role.value == subagent_type:
return agent
# Domyślnie pierwszy dostępny
return list(self.subagents.values())[0] if self.subagents else NoneKlucze słownika muszą równać się wartościom ról, dlatego pierwszy klucz to "researcher", a nie "research", bo inaczej badacz nigdy by nie został wybrany. Pole subagent z planu jest tu pomijane, co warto poprawić.
Na końcu synteza łączy wyniki w jedną odpowiedź:
async def _synthesize_results(self, original_task: str, results: List[dict]) -> str:
"""Syntezuje wyniki ze wszystkich subagentów."""
results_summary = "\n\n".join([
f"Krok {r['step']} ({r['subagent']}): {r['result']}"
for r in results
])
synthesis_prompt = f"""Oryginalne zadanie: {original_task}
Wyniki subagentów:
{results_summary}
Stwórz spójną, końcową odpowiedź na podstawie wyników wszystkich subagentów."""
response = client.chat.completions.create(
model=self.model,
messages=[
{"role": "system", "content": "Jesteś syntetykiem. Łączysz wyniki w spójną całość."},
{"role": "user", "content": synthesis_prompt}
]
)
return response.choices[0].message.contentTo trzecie wywołanie modelu w jednym zadaniu, obok planowania i pracy subagentów.
Użycie Orchestratora
Rejestrujemy czterech specjalistów i zlecamy planowanie Safari:
import asyncio
async def main():
# Tworzenie orchestratora
orchestrator = AgentOrchestrator()
# Rejestracja subagentów
orchestrator.register_subagent(
ResearchSubagent("safari_researcher", SubagentRole.RESEARCHER)
)
orchestrator.register_subagent(
AnalysisSubagent("data_analyst", SubagentRole.ANALYST)
)
orchestrator.register_subagent(
ExecutorSubagent("task_executor", SubagentRole.EXECUTOR)
)
orchestrator.register_subagent(
ValidatorSubagent("quality_checker", SubagentRole.VALIDATOR)
)
# Wykonanie złożonego zadania
result = await orchestrator.execute_task(
"Przygotuj kompletny plan Safari w Serengeti na 7 dni dla 4 osób"
)
print("\n" + "="*50)
print("WYNIK KOŃCOWY:")
print("="*50)
print(result)
asyncio.run(main())asyncio.run uruchamia główną korutynę, a orchestrator sam planuje, deleguje i składa wynik. O tym, który specjalista dostanie krok, decydują słowa w opisach wygenerowanych przez planistę, a nie w samym zadaniu.
Hierarchia Wielopoziomowa
Duża wyprawa ma kierowników zespołów. Orchestrator może mieć pod sobą innych orchestratorów:
class HierarchicalOrchestrator:
"""Orchestrator z wielopoziomową hierarchią."""
def __init__(self, name: str, level: int = 0):
self.name = name
self.level = level
self.subagents: Dict[str, Subagent] = {}
self.sub_orchestrators: Dict[str, "HierarchicalOrchestrator"] = {}
def add_sub_orchestrator(self, orchestrator: "HierarchicalOrchestrator") -> None:
"""Dodaje pod-orchestratora (dla głębszej hierarchii)."""
orchestrator.level = self.level + 1
self.sub_orchestrators[orchestrator.name] = orchestrator
async def delegate_task(self, task: str) -> str:
"""Deleguje zadanie do odpowiedniego poziomu hierarchii."""
# Sprawdź czy zadanie wymaga pod-orchestratora
complexity = self._assess_complexity(task)
if complexity > 3 and self.sub_orchestrators:
# Deleguj do pod-orchestratora
sub_orch = self._select_sub_orchestrator(task)
return await sub_orch.delegate_task(task)
else:
# Wykonaj przez własnych subagentów
return await self._execute_locally(task)delegate_task przekazuje zadanie niżej, gdy ocena złożoności przekracza 3.
Metody pomocnicze oceniają złożoność i wykonują zadanie lokalnie:
def _assess_complexity(self, task: str) -> int:
"""Ocenia złożoność zadania (1-5)."""
# Prosta heurystyka
complexity_indicators = [
"kompletny", "szczegółowy", "wieloetapowy",
"kompleksowy", "rozbudowany"
]
return sum(1 for ind in complexity_indicators if ind in task.lower()) + 1
def _select_sub_orchestrator(self, task: str) -> "HierarchicalOrchestrator":
"""Wybiera pod-orchestratora dla zadania."""
# Można rozbudować o inteligentny wybór
return list(self.sub_orchestrators.values())[0]
async def _execute_locally(self, task: str) -> str:
"""Wykonuje zadanie lokalnie."""
# Użyj własnych subagentów
results = []
for subagent in self.subagents.values():
subtask = SubagentTask(
description=task,
context=f"Level {self.level}",
expected_output="Rezultat zadania"
)
result = await subagent.execute(subtask)
results.append(result.output)
return "\n".join(results)Złożoność to liczba słów-wskaźników plus jeden, a _select_sub_orchestrator na razie zawsze bierze pierwszy zespół.
Przykład buduje dwa zespoły pod głównym orchestratorem:
# Przykład użycia hierarchii
async def hierarchical_example():
# Główny orchestrator
main_orchestrator = HierarchicalOrchestrator("Main Orchestrator")
# Pod-orchestrator dla badań
research_orchestrator = HierarchicalOrchestrator("Research Team")
research_orchestrator.subagents["researcher"] = ResearchSubagent(
"researcher", SubagentRole.RESEARCHER
)
# Pod-orchestrator dla analizy
analysis_orchestrator = HierarchicalOrchestrator("Analysis Team")
analysis_orchestrator.subagents["analyst"] = AnalysisSubagent(
"analyst", SubagentRole.ANALYST
)
# Dodaj do hierarchii
main_orchestrator.add_sub_orchestrator(research_orchestrator)
main_orchestrator.add_sub_orchestrator(analysis_orchestrator)
# Wykonaj złożone zadanie
result = await main_orchestrator.delegate_task(
"Przeprowadź kompletne badanie rynku Safari w Afryce Wschodniej"
)
print(result)Znajdź pułapkę: zadanie zawiera za mało słów-wskaźników, więc zostaje u głównego orchestratora, który nie ma własnych subagentów i zwraca pusty tekst. Obniż próg albo daj mu subagenta.
Komunikacja między Subagentami
Czasem specjalista musi dopytać kolegę. Najpierw typy wiadomości:
from dataclasses import dataclass, field
from typing import Optional, List
from datetime import datetime
from enum import Enum
class MessageType(Enum):
TASK = "task"
RESULT = "result"
QUERY = "query"
RESPONSE = "response"
ERROR = "error"
@dataclass
class AgentMessage:
"""Wiadomość między agentami."""
sender: str
receiver: str
content: str
message_type: MessageType
timestamp: datetime = field(default_factory=datetime.now)
correlation_id: Optional[str] = None
metadata: dict = field(default_factory=dict)correlation_id łączy pytanie z odpowiedzią, a field(default_factory=...) daje każdej wiadomości własny znacznik czasu.
Message Bus to szyna, przez którą agenci rozmawiają bez bezpośrednich zależności:
class MessageBus:
"""Szyna komunikacyjna dla agentów."""
def __init__(self):
self.messages: List[AgentMessage] = []
self.subscribers: Dict[str, List[callable]] = {}
def publish(self, message: AgentMessage) -> None:
"""Publikuje wiadomość."""
self.messages.append(message)
# Powiadom subskrybentów
if message.receiver in self.subscribers:
for callback in self.subscribers[message.receiver]:
callback(message)
def subscribe(self, agent_name: str, callback: callable) -> None:
"""Subskrybuje agenta do wiadomości."""
if agent_name not in self.subscribers:
self.subscribers[agent_name] = []
self.subscribers[agent_name].append(callback)
def get_messages_for(self, agent_name: str) -> List[AgentMessage]:
"""Pobiera wiadomości dla agenta."""
return [m for m in self.messages if m.receiver == agent_name]Agent subskrybuje swoje imię, a publish wywołuje callbacki odbiorcy. Nadawca nie musi znać obiektu odbiorcy, wystarczy mu nazwa, i to właśnie oznacza luźne powiązanie.
Subagent z komunikacją odpowiada na zapytania i wysyła wiadomości:
class CommunicatingSubagent(Subagent):
"""Subagent z możliwością komunikacji."""
def __init__(self, name: str, role: SubagentRole, message_bus: MessageBus):
super().__init__(name, role)
self.message_bus = message_bus
self.message_bus.subscribe(name, self._handle_message)
self.pending_responses: Dict[str, str] = {}
def _handle_message(self, message: AgentMessage) -> None:
"""Obsługuje przychodzące wiadomości."""
if message.message_type == MessageType.QUERY:
# Odpowiedz na zapytanie
response = self._process_query(message.content)
self.send_message(
message.sender,
response,
MessageType.RESPONSE,
correlation_id=message.correlation_id
)
elif message.message_type == MessageType.RESPONSE:
# Zapisz odpowiedź
if message.correlation_id:
self.pending_responses[message.correlation_id] = message.content
def send_message(
self,
receiver: str,
content: str,
message_type: MessageType,
correlation_id: Optional[str] = None
) -> None:
"""Wysyła wiadomość do innego agenta."""
import uuid
message = AgentMessage(
sender=self.name,
receiver=receiver,
content=content,
message_type=message_type,
correlation_id=correlation_id or str(uuid.uuid4())
)
self.message_bus.publish(message)
def _process_query(self, query: str) -> str:
"""Przetwarza zapytanie od innego agenta."""
# Implementacja zależna od roli
return f"Odpowiedź na: {query}"Odpowiedź wraca z tym samym correlation_id, więc pytający wie, na co to odpowiedź.
Pytanie z oczekiwaniem na odpowiedź:
async def ask_other_agent(self, agent_name: str, question: str) -> str:
"""Pyta innego agenta i czeka na odpowiedź."""
import uuid
correlation_id = str(uuid.uuid4())
self.send_message(
agent_name,
question,
MessageType.QUERY,
correlation_id
)
# Czekaj na odpowiedź (z timeout)
import asyncio
for _ in range(10):
if correlation_id in self.pending_responses:
return self.pending_responses.pop(correlation_id)
await asyncio.sleep(0.1)
return "Timeout - brak odpowiedzi"Szyna wywołuje callbacki synchronicznie, więc odpowiedź zwykle czeka już przy pierwszym sprawdzeniu, a limit to sekunda.
Best Practices dla Subagentów
Zasady architektury subagentów zebrane w jednym miejscu:
"""
Best Practices dla architektury subagentów:
1. SEPARATION OF CONCERNS
- Każdy subagent ma jedną, jasno określoną odpowiedzialność
- Unikaj "god agents" robiących wszystko
2. LOOSE COUPLING
- Subagenci komunikują się przez message bus
- Nie ma bezpośrednich zależności między subagentami
3. SINGLE SOURCE OF TRUTH
- Orchestrator jest jedynym źródłem prawdy o stanie zadania
- Subagenci raportują wyniki do orchestratora
4. GRACEFUL DEGRADATION
- System działa nawet gdy jeden subagent zawiedzie
- Implementuj fallback strategies
5. OBSERVABILITY
- Loguj wszystkie interakcje między agentami
- Implementuj metryki i monitoring
6. SCALABILITY
- Subagenci powinni być bezstanowi (stateless)
- Łatwo dodać więcej instancji tego samego typu
7. TESTING
- Testuj subagentów w izolacji
- Testuj integrację orchestratora z subagentami
"""Zwróć uwagę na punkt o bezstanowości: nasze subagenty mają memory, więc przy skalowaniu przenieś ją do zewnętrznego magazynu.
Ostatni element to orchestrator odporny na błędy:
class RobustOrchestrator(AgentOrchestrator):
"""Orchestrator z obsługą błędów i fallback."""
async def execute_with_fallback(self, task: str) -> str:
"""Wykonuje zadanie z obsługą błędów."""
try:
return await self.execute_task(task)
except Exception as e:
print(f"Błąd głównego wykonania: {e}")
# Fallback - prostsze podejście
return await self._simple_execution(task)
async def _simple_execution(self, task: str) -> str:
"""Proste wykonanie jako fallback."""
response = client.chat.completions.create(
model=self.model,
messages=[
{"role": "system", "content": "Jesteś pomocnym asystentem."},
{"role": "user", "content": task}
]
)
return response.choices[0].message.contentGdy pełny pipeline zawiedzie, fallback pyta model bezpośrednio. Polecam od początku projektować hierarchię płasko, a kolejne piętra dodawać dopiero przy prawdziwej potrzebie.
Subagenty i hierarchie agentów to potężne wzorce architektoniczne, które pozwalają budować złożone, skalowalne systemy AI. Gratulacje - poznałeś zaawansowane techniki AI! W ostatnim module stworzysz kompleksowy projekt łączący wszystkie zdobyte umiejętności!
Zapamiętaj: dobry orchestrator to kierownik wyprawy, który rozdziela zadania, zbiera raporty i sam nie niesie wszystkich plecaków.
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. Czym są subagenty w architekturze AI?
2. Jaka jest rola orchestratora w systemie subagentów?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w pionie
Ułóż typową hierarchię agentów od góry do dołu:
- Edytor kodu
Zaimplementuj klasę Subagent z ABC i @abstractmethod.
- Układanie w pionie
Ułóż kroki wykonania zadania przez orchestratora:
- Edytor kodu
Zaimplementuj AgentOrchestrator z metodami register_subagent i execute_task.
- Edytor kodu
Zbuduj graf Safari AI z węzłami agent, tool i approval.
- Edytor kodu
Stwórz HierarchicalOrchestrator z sub_orchestrators i subagents.
Zadania po tej lekcji
- PytanieSubagents
- PytanieOrchestrator
- Ułóż w kolejnościHierarchia agentów
- Zadanie z kodemSubagent Class
- PytanieMessage Bus
- Ułóż w kolejnościOrchestrator Execute
- Zadanie z kodemAgentOrchestrator
- Zadanie z kodemProjekt: LangGraph Workflow
- Zadanie z kodemProjekt: Hierarchiczny System Agentów
- WideoRAG i Multi-Agent - podsumowanie teorii
- Projekt do wysłaniaWyślij projekt do mentora
- WideoPodsumowanie modułu