Kurs Python · Moduł 11: RAG i systemy wieloagentowe

CrewAI - Framework Multi-Agent

8 min czytania ·
W tej lekcji10

W poprzedniej lekcji sami napisaliśmy klasę agenta, orkiestratora i łańcuch wiadomości. Działało, ale każdą nową funkcję, taką jak narzędzia, pamięć czy delegowanie zadań, trzeba by dopisywać ręcznie. Gdy wyprawa rośnie, lepiej skorzystać z gotowego regulaminu obozu.

CrewAI to framework Pythona do tworzenia zespołów agentów AI, które współpracują przy rozwiązywaniu złożonych zadań. To jak montowanie załogi ekspedycji, gdzie każdy ma swoją rolę. Cały framework opiera się na trzech pojęciach: Agent (kto), Task (co) i Crew (jak razem).

Instalacja i podstawy

Instalujemy dwa pakiety i importujemy podstawowe klasy. Model językowy konfigurujemy klasą LLM z samego CrewAI:

# pip install crewai crewai-tools

from crewai import Agent, Task, Crew, Process, LLM

# Model LLM
llm = LLM(model="gpt-4o-mini", temperature=0.7)

Uwaga na zmianę w bibliotece: starsze przykłady w sieci używają tu ChatOpenAI z LangChain, ale aktualne wersje CrewAI nie zależą od LangChain i odrzucają taki obiekt przy walidacji agenta. LLM(model="gpt-4o-mini") korzysta pod spodem z klucza w zmiennej OPENAI_API_KEY.

Tworzenie agentów

Agent w CrewAI to trzy zdania o nim samym: rola (role), cel (goal) i historia (backstory). Model dostaje je jako opis postaci, w którą ma się wcielić. Oto badacz:

# Agent researcher
researcher = Agent(
    role="Senior Research Analyst",
    goal="Przeprowadzać dokładne badania i dostarczać wiarygodne informacje",
    backstory="""Jesteś doświadczonym analitykiem z 15-letnim doświadczeniem
    w badaniu trendów technologicznych. Specjalizujesz się w analizie AI i ML.
    Zawsze weryfikujesz fakty i szukasz wiarygodnych źródeł.""",
    verbose=True,
    allow_delegation=False,
    llm=llm
)

verbose=True wypisuje w konsoli rozumowanie agenta, a allow_delegation=False zabrania mu przekazywać pracy innym. W aktualnych wersjach False to i tak wartość domyślna.

Pisarz i redaktor wyglądają podobnie, zmienia się tylko opis postaci:

# Agent writer
writer = Agent(
    role="Content Writer",
    goal="Tworzyć angażujące i edukacyjne treści na temat technologii",
    backstory="""Jesteś utalentowanym pisarzem technicznym z pasją do
    tłumaczenia złożonych koncepcji na prosty język. Twoje artykuły
    są zawsze dobrze zorganizowane i przyjemne w czytaniu.""",
    verbose=True,
    allow_delegation=True,
    llm=llm
)

# Agent editor
editor = Agent(
    role="Senior Editor",
    goal="Zapewnić najwyższą jakość publikowanych treści",
    backstory="""Jesteś doświadczonym redaktorem z okiem do szczegółów.
    Dbasz o spójność stylu, poprawność faktyczną i klarowność przekazu.
    Nie boisz się proponować zmian, które poprawią tekst.""",
    verbose=True,
    allow_delegation=False,
    llm=llm
)

Pisarz ma allow_delegation=True, więc gdy czegoś nie wie, może zapytać kolegę z załogi. To jedyna różnica techniczna, reszta to charakter zapisany w backstory.

Definiowanie zadań

Task opisuje pracę do wykonania. Każde zadanie ma opis, oczekiwany wynik (expected_output) i przypisanego agenta:

# Zadanie badawcze
research_task = Task(
    description="""Przeprowadź dokładne badanie na temat: {topic}

    Twoje zadanie:
    1. Znajdź najnowsze informacje i trendy
    2. Zidentyfikuj kluczowych graczy i technologie
    3. Przeanalizuj potencjalne zastosowania
    4. Oceń przyszłe kierunki rozwoju

    Dostarcz szczegółowy raport z badań.""",
    expected_output="Szczegółowy raport badawczy z cytatami i źródłami",
    agent=researcher
)

Zapis {topic} w opisie to miejsce na zmienną. CrewAI podstawi tu wartość z parametru inputs przy uruchomieniu zespołu.

Zadanie pisarskie korzysta z wyniku badań. Służy do tego parametr context:

# Zadanie pisarskie
writing_task = Task(
    description="""Na podstawie raportu badawczego napisz artykuł blogowy.

    Wymagania:
    1. Wciągający wstęp
    2. Jasna struktura z nagłówkami
    3. Praktyczne przykłady
    4. Podsumowanie z kluczowymi wnioskami
    5. Długość: 1000-1500 słów

    Używaj przystępnego języka dla czytelników technicznych.""",
    expected_output="Kompletny artykuł blogowy gotowy do publikacji",
    agent=writer,
    context=[research_task]  # Używa wyniku poprzedniego zadania
)

context=[research_task] przekazuje pisarzowi raport badacza, więc nie musimy ręcznie kleić tekstów, jak robił to nasz orkiestrator.

Redaktor dostaje w kontekście artykuł pisarza:

# Zadanie redakcyjne
editing_task = Task(
    description="""Zrecenzuj i popraw artykuł.

    Sprawdź:
    1. Poprawność gramatyczną i stylistyczną
    2. Spójność argumentacji
    3. Klarowność przekazu
    4. Angażujący ton

    Wprowadź niezbędne poprawki.""",
    expected_output="Zredagowany, finalny artykuł",
    agent=editor,
    context=[writing_task]
)

Opis, oczekiwany wynik, agent i kontekst to cztery elementy, z których składasz każde zadanie.

Tworzenie i uruchamianie Crew

Crew łączy agentów i zadania. Parametr process decyduje, jak załoga pracuje:

# Tworzenie zespołu
content_crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.sequential,  # lub Process.hierarchical
    verbose=True
)

# Uruchomienie z inputami
result = content_crew.kickoff(inputs={"topic": "RAG w enterprise AI"})
print(result)

Process.sequential wykonuje zadania po kolei, w kolejności z listy. CrewAI wspiera dwa typy procesów: sequential i hierarchical. kickoff zwraca obiekt CrewOutput, którego tekst znajdziesz w polu raw, a print wypisze go od razu.

Narzędzia dla agentów

Agent bez narzędzi zna tylko to, czego nauczył się model. Pakiet crewai-tools daje gotowe narzędzia do wyszukiwarki, stron i plików:

from crewai_tools import (
    SerperDevTool,      # Wyszukiwanie Google
    WebsiteSearchTool,  # Przeszukiwanie stron
    FileReadTool,       # Czytanie plików
    PDFSearchTool,      # Przeszukiwanie PDF
)

# Konfiguracja narzędzi
search_tool = SerperDevTool()
web_tool = WebsiteSearchTool()
file_tool = FileReadTool()

# Agent z narzędziami
researcher_with_tools = Agent(
    role="Research Analyst",
    goal="Zbierać i analizować informacje z różnych źródeł",
    backstory="Ekspert w wyszukiwaniu informacji...",
    tools=[search_tool, web_tool, file_tool],
    verbose=True,
    llm=llm
)

SerperDevTool wymaga klucza w zmiennej SERPER_API_KEY. Agent sam decyduje, kiedy sięgnąć po które narzędzie, na podstawie ich opisów.

Własne narzędzie to klasa dziedzicząca po BaseTool. Obecnie importujemy ją z crewai.tools, a nie z crewai_tools, jak w starszych przykładach:

# Własne narzędzie
from crewai.tools import BaseTool
from pydantic import BaseModel, Field

class DatabaseQueryInput(BaseModel):
    query: str = Field(description="SQL query to execute")

class DatabaseQueryTool(BaseTool):
    name: str = "Database Query"
    description: str = "Wykonuje zapytania SQL na bazie danych"
    args_schema: type[BaseModel] = DatabaseQueryInput

    def _run(self, query: str) -> str:
        # Implementacja zapytania
        return f"Wynik zapytania: {query}"

args_schema to model Pydantic opisujący argumenty, a metoda _run zawiera właściwą logikę. name i description czyta model językowy, więc pisz je jasno.

Hierarchiczny proces

W procesie hierarchicznym zadania rozdziela menedżer. Tworzymy go jak zwykłego agenta:

# Manager koordynujący
manager = Agent(
    role="Project Manager",
    goal="Koordynować pracę zespołu i zapewnić terminową realizację",
    backstory="Doświadczony PM z umiejętnością zarządzania zespołami AI",
    verbose=True,
    llm=llm
)

# Crew z hierarchią
hierarchical_crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.hierarchical,
    manager_agent=manager,  # lub manager_llm=llm
    verbose=True
)

Menedżer nie trafia na listę agents, tylko do manager_agent. Zamiast własnego menedżera możesz podać manager_llm, a CrewAI stworzy go sam. Jedno z dwóch jest wymagane w procesie hierarchicznym.

Pamięć i kontekst

Załoga może pamiętać wcześniejsze ustalenia. Pamięć włączamy flagą memory=True, a embedder wskazuje model embeddingów, którym CrewAI zapisuje wspomnienia:

# Crew z pamięcią
crew_with_memory = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
    memory=True,  # Włącza pamięć
    embedder={
        "provider": "openai",
        "config": {"model": "text-embedding-3-small"}
    },
    verbose=True
)

# Agent z pamięcią
agent_with_memory = Agent(
    role="Assistant",
    goal="Pomagać użytkownikowi",
    backstory="...",
    memory=True,
    llm=llm
)

To te same embeddingi, które poznaliśmy dwie lekcje temu, tylko używane do przechowywania wspomnień załogi zamiast dokumentów.

Callbacks i monitorowanie

Przy dłuższych zadaniach chcesz wiedzieć, co się dzieje. Crew przyjmuje dwie funkcje zwrotne: task_callback po każdym zadaniu i step_callback po każdym kroku agenta:

from crewai.tasks.task_output import TaskOutput

def on_task_end(output: TaskOutput) -> None:
    """Wywoływana po zakończeniu każdego zadania."""
    print(f"Zakończono: {output.description[:50]}")
    print(f"   Output: {output.raw[:100]}...")

def on_step(step) -> None:
    """Wywoływana po każdym kroku agenta."""
    print(f"Krok agenta: {str(step)[:100]}")

# Użycie
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    task_callback=on_task_end,
    step_callback=on_step,
    verbose=True
)

TaskOutput niesie opis zadania i surowy wynik w polu raw. Nie szukaj klasy CrewCallback ani modułu crewai.callbacks: w CrewAI ich nie ma, funkcje zwrotne przekazujesz właśnie przez te dwa parametry.

Asynchroniczne wykonanie

Kilka niezależnych załóg możesz uruchomić jednocześnie. Służy do tego kickoff_async:

import asyncio

async def run_crew_async(topic: str) -> str:
    """Asynchroniczne uruchomienie crew."""
    crew = Crew(
        agents=[researcher, writer],
        tasks=[research_task, writing_task],
        process=Process.sequential
    )

    result = await crew.kickoff_async(inputs={"topic": topic})
    return result

# Równoległe uruchomienie wielu crew
async def run_multiple_crews():
    topics = ["AI w medycynie", "AI w finansach", "AI w edukacji"]

    tasks = [run_crew_async(topic) for topic in topics]
    results = await asyncio.gather(*tasks)

    return dict(zip(topics, results))

results = asyncio.run(run_multiple_crews())

asyncio.gather czeka na wszystkie trzy załogi naraz, a dict(zip(...)) paruje tematy z wynikami. W produkcji twórz osobne obiekty agentów i zadań dla każdej załogi, bo tu wszystkie współdzielą te same research_task i writing_task.

Przykład: Content Pipeline

Na koniec składamy wszystko w jeden pipeline z dodatkowym specjalistą SEO:

def create_content_pipeline(topic: str) -> str:
    """Kompletny pipeline tworzenia treści."""

    # Agenci
    seo_analyst = Agent(
        role="SEO Specialist",
        goal="Optymalizować treści pod kątem wyszukiwarek",
        backstory="Ekspert SEO z doświadczeniem w content marketingu",
        tools=[SerperDevTool()],
        llm=llm
    )

    # Zadania
    seo_task = Task(
        description=f"Przeanalizuj słowa kluczowe dla tematu: {topic}",
        expected_output="Lista 10 słów kluczowych z ich potencjałem",
        agent=seo_analyst
    )

    # Crew
    pipeline = Crew(
        agents=[seo_analyst, researcher, writer, editor],
        tasks=[seo_task, research_task, writing_task, editing_task],
        process=Process.sequential,
        verbose=True
    )

    return pipeline.kickoff(inputs={"topic": topic})

# Uruchomienie
article = create_content_pipeline("Machine Learning w 2025")

Opis seo_task używa f-stringa, ale zadania badacza i pisarza wciąż mają {topic}, dlatego kickoff dostaje inputs. Bez tego agenci zobaczyliby dosłowny tekst "{topic}". Polecam zaczynać od procesu sequential, a hierarchię włączać dopiero przy większej załodze, bo menedżer to dodatkowe wywołania modelu.

CrewAI to potężny framework do budowania zespołów AI. W następnej lekcji poznasz produkcyjne systemy RAG - jak wdrażać te technologie w enterprise!

Zapamiętaj: w CrewAI agent to członek załogi, zadanie to jego przydział, a crew to cała ekspedycja.

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 CrewAI?

  2. 2. Jakie typy procesów wspiera CrewAI?

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż elementy:

  • Edytor kodu

    Zdefiniuj agenta researcher w CrewAI

  • Układanie w poziomie

    Ułóż tworzenie Crew w CrewAI:

  • Klikanie w kolejności

    Ułóż elementy definicji Task w CrewAI:

  1. PytanieCrewAI
  2. Ułóż w kolejnościImport CrewAI
  3. PytanieProcess w CrewAI
  4. Zadanie z kodemCrewAI Agent
  5. Ułóż w kolejnościCrewAI Crew
  6. Kliknij w kolejnościCrewAI Task

Przydatne artykuły