Kurs Python · Moduł 11: RAG i systemy wieloagentowe

Subagents i Hierarchie Agentów

13 min czytania ·
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: dict

SubagentTask 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 tasks

Tryb 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_result

Wyniki 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 None

Klucze 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.content

To 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.content

Gdy 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. 1. Czym są subagenty w architekturze AI?

  2. 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.

  1. PytanieSubagents
  2. PytanieOrchestrator
  3. Ułóż w kolejnościHierarchia agentów
  4. Zadanie z kodemSubagent Class
  5. PytanieMessage Bus
  6. Ułóż w kolejnościOrchestrator Execute
  7. Zadanie z kodemAgentOrchestrator
  8. Zadanie z kodemProjekt: LangGraph Workflow
  9. Zadanie z kodemProjekt: Hierarchiczny System Agentów
  10. WideoRAG i Multi-Agent - podsumowanie teorii
  11. Projekt do wysłaniaWyślij projekt do mentora
  12. WideoPodsumowanie modułu

Przydatne artykuły