CrewAI Beispiele: Agenten-Teams erstellen und koordinieren

CrewAI ist ein Python-Framework für die Erstellung von KI-Agenten-Teams, das ein rollenbasiertes Modell verwendet. Anstatt komplexe Graphen zu definieren (wie bei LangGraph), beschreibst Du einfach, wer in Deinem Team ist, was jeder macht und wie sie zusammenarbeiten. Das ist intuitiver — Du denkst in Rollen und Aufgaben, nicht in Nodes und Edges.

CrewAI wurde 2024 von João Moura entwickelt und hat sich schnell als das einsteigerfreundlichste Multi-Agent-Framework etabliert. Es baut auf LangChain auf, abstrahiert aber die Komplexität weg. Wenn Du schnell ein funktionierendes Agenten-Team bauen willst, ohne Graph-Theorie zu lernen, ist CrewAI die beste Wahl.

In diesem Tutorial zeige ich Dir drei vollständige, praxisnahe Beispiele: eine Content-Creation-Crew, eine Code-Review-Crew und eine Customer-Support-Crew. Alle Beispiele sind lauffähig und können direkt als Vorlage für Deine eigenen Projekte verwendet werden.

TL;DR — CrewAI in 90 Sekunden

Die CrewAI-Architektur — Wie es funktioniert

Das Rollenmodell

CrewAI basiert auf einer einfachen aber mächtigen Idee: Du modellierst ein Agenten-Team wie ein echtes Team. Jedes Teammitglied hat:

• Rolle (Role): Wer ist der Agent? “Senior Data Analyst”, “Tech Writer”, “Security Expert”
• Ziel (Goal): Was will der Agent erreichen? “Finde alle Sicherheitslücken im Code”
• Backstory: Welche Erfahrung und Persönlichkeit hat der Agent? “Du bist ein Security-Experte mit 15 Jahren Erfahrung in Penetration Testing”
• Tools: Welche Werkzeuge stehen dem Agenten zur Verfügung? Web-Suche, Code-Ausführung, Datei-Zugriff

Die Backstory ist wichtig — sie beeinflusst, wie das LLM “denkt” und antwortet. Ein Agent mit der Backstory “Du bist ein strenger Reviewer, der keine Kompromisse macht” wird anders antworten als einer mit “Du bist ein hilfsbereiter Mentor, der Entwickler unterstützt”.

Der Task-Lebenszyklus

Wenn Du crew.kickoff() aufrufst, passiert folgendes:

1. Task-Reihenfolge wird bestimmt: Bei Process.sequential werden Tasks in der Reihenfolge ausgeführt, in der sie definiert wurden. Bei Process.hierarchical entscheidet ein Manager-Agent.
2. Agent-Auswahl: Jeder Task hat einen agent-Parameter. Der entsprechende Agent wird aktiviert.
3. LLM-Aufruf: Der Agent bekommt seine Rolle, sein Ziel, seine Backstory, den Task und die Ergebnisse vorheriger Tasks als Kontext.
4. Tool-Nutzung: Wenn der Agent Tools hat, kann er diese aufrufen (Web-Suche, Datei-Lesen, etc.).
5. Ergebnis: Die Ausgabe des Agents wird an den nächsten Task weitergegeben.
6. Delegation: Wenn allow_delegation=True, kann ein Agent Tasks an andere Agenten delegieren.

Sequentiell vs. Hierarchisch

Sequentiell (Standard): Tasks werden nacheinander ausgeführt. Die Ausgabe von Task 1 ist automatisch im Kontext von Task 2. Einfach, vorhersehbar, gut für lineare Workflows.

Hierarchisch: Ein Manager-Agent bekommt alle Tasks und entscheidet, welcher Agent was macht und in welcher Reihenfolge. Der Manager kann Tasks umverteilen, neu anordnen und Ergebnisse bewerten. Gut für komplexe Workflows, aber teurer (zusätzlicher LLM-Aufruf für den Manager).

Installation und Setup

pip install crewai crewai-tools

API-Keys:

export OPENAI_API_KEY="sk-..."
# Für Web-Suche mit SerperDev:
export SERPER_API_KEY="..."

Lokale Modelle (kostenlos für Entwicklung):

# Ollama installieren und Modell laden
ollama pull llama3.1:8b

# In CrewAI verwenden:
from langchain_community.llms import Ollama
llm = Ollama(model="llama3.1:8b")

Die 3 Kernkomponenten — Im Detail

1. Agent — Das Teammitglied

from crewai import Agent

researcher = Agent(
    role="Senior Research Analyst",
    goal="Finde umfassende, aktuelle und präzise Informationen zum gegebenen Thema",
    backstory="""Du bist ein erfahrener Research Analyst mit 10 Jahren Erfahrung.
    Du hast Zugang zu wissenschaftlichen Datenbanken und weißt, wie man 
    verlässliche von unzuverlässigen Quellen unterscheidet.
    Du strukturierst Deine Recherche immer klar und gibst Quellen an.""",
    verbose=True,           # Detaillierte Logs
    allow_delegation=False,  # Dieser Agent delegiert nicht
    tools=[search_tool],    # Tools, die dieser Agent nutzen kann
    llm=llm                  # Optional: eigenes LLM für diesen Agent
)

Wichtige Parameter:

• verbose=True: Zeigt detaillierte Logs, was der Agent denkt und tut. Unverzichtbar für Debugging.
• allow_delegation: Wenn True, kann der Agent Aufgaben an andere Agenten delegieren. Nützlich für Manager oder Reviewer, gefährlich bei zu vielen Delegationen (Kosten!).
• tools: Liste von LangChain-Tools. Ohne Tools ist der Agent nur ein Chatbot.
• llm: Pro Agent ein anderes LLM möglich. z.B. GPT-4o für komplexe Tasks, GPT-4o-mini für einfache.
• max_iter: Maximale Anzahl von Iterationen (Standard: 25). Schützt vor Endlosschleifen.
• memory: Wenn True, behält der Agent ein Gedächtnis über mehrere Tasks hinweg.

2. Task — Die Aufgabe

from crewai import Task

research_task = Task(
    description="""Recherchiere die neuesten Entwicklungen in der 
    KI-Programmierung 2026. Berücksichtige neue Tools, Best Practices 
    und Praxisbeispiele. Der Bericht soll mindestens 5 Hauptpunkte umfassen.""",
    
    expected_output="""Ein detaillierter Bericht mit 5 Hauptpunkten (je 2-3 Sätze),
    Quellenangaben und einer Zusammenfassung am Ende.""",
    
    agent=researcher,
    output_file="output/research_report.md"  # Optional: Output als Datei
)

Wichtige Parameter:

• description: Sei spezifisch — vage Tasks führen zu vagen Ergebnissen.
• expected_output: Beschreibe genau, wie die Ausgabe aussehen soll. Das ist der wichtigste Parameter. Statt “schreibe einen Artikel” → “schreibe einen 800-Wörter-Artikel in Markdown mit Einleitung, 3 Zwischenüberschriften und Fazit”.
• agent: Welcher Agent soll diesen Task erledigen?
• context: Liste von anderen Tasks, deren Ergebnisse als Kontext dienen sollen.
• output_file: Speichert die Ausgabe in einer Datei. Praktisch für Debugging.

3. Crew — Das Team

from crewai import Crew, Process

crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, write_task, edit_task],
    process=Process.sequential,  # oder Process.hierarchical
    verbose=True,
    memory=True,       # Memory über mehrere Ausführungen
    cache=True,        # Cache für Tool-Ergebnisse
    max_rpm=10         # Rate-Limiting: Requests pro Minute
)

result = crew.kickoff()

Was kickoff() macht: Validiert Agenten-Tasks, bestimmt die Ausführungsreihenfolge, führt jeden Task aus (Agent bekommt Kontext + Task → LLM-Aufruf → Ergebnis), und gibt das Endergebnis zurück.

Beispiel 1: Content-Creation-Crew (Vollständig)

Ein Team aus Researcher, Writer und Editor für Blogartikel — mit echten Tools, detaillierten Prompts und Output-Dateien.

import os
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool, ScrapeWebsiteTool

# Tools initialisieren
search_tool = SerperDevTool()
web_scraper = ScrapeWebsiteTool()

# --- AGENTS ---

researcher = Agent(
    role="Senior Content Researcher",
    goal="Sammle fundierte, aktuelle und präzise Informationen zum Thema",
    backstory="""Du bist ein Recherche-Experte mit Zugang zu wissenschaftlichen 
    Quellen und Tech-Blogs. Du weißt, wie man verlässliche von unzuverlässigen 
    Quellen unterscheidet. Du strukturierst Deine Recherche immer klar und 
    gibst alle Quellen mit URL an.""",
    tools=[search_tool, web_scraper],
    verbose=True,
    allow_delegation=False
)

writer = Agent(
    role="Tech Journalist",
    goal="Schreibe einen engagierenden, informativen und gut strukturierten Artikel",
    backstory="""Du bist ein preisgekrönter Tech-Journalist, der komplexe Themen 
    verständlich erklärt. Du schreibst für ein technisches Publikum, das 
    Praxisbezug sucht. Du verwendest aktive Sprache, kurze Sätze und 
    konkrete Beispiele.""",
    verbose=True,
    allow_delegation=False
)

editor = Agent(
    role="Senior Editor",
    goal="Stelle Qualität, Korrektheit, Lesbarkeit und SEO-Optimierung sicher",
    backstory="""Du bist ein strenger Editor mit 20 Jahren Erfahrung. Du prüfst 
    auf Grammatik, Stil, faktische Korrektheit und SEO-Keywords. Du gibst 
    konkretes Feedback und verbesserst den Artikel direkt. Du akzeptierst 
    keine unpräzisen Aussagen oder fehlenden Quellen.""",
    verbose=True,
    allow_delegation=True  # Editor kann an Researcher oder Writer delegieren
)

# --- TASKS ---

research_task = Task(
    description="""Recherchiere das Thema 'Python Frameworks 2026'.
    Finde die Top 5 Python-Frameworks für Web-Entwicklung 2026 mit
    Vor- und Nachteilen, Praxisbeispielen und Performance-Vergleichen.
    Nutze die Web-Suche für aktuelle Informationen.""",
    expected_output="""Strukturierte Recherche mit Top 5 Frameworks,
    Vor-/Nachteilen pro Framework, mindestens 3 Quellen pro Framework,
    und Empfehlung für 3 Use Cases (Startup, Enterprise, Prototyp).""",
    agent=researcher,
    output_file="output/research.md"
)

write_task = Task(
    description="""Schreibe einen Blogartikel (800-1200 Wörter) basierend 
    auf der Recherche. Struktur: Einleitung, Hauptteil mit 
    Zwischenüberschriften, Vergleichstabelle, Praxisbeispiele, Fazit.
    Schreibe auf Deutsch, duze den Leser, verwende aktive Sprache.""",
    expected_output="""Vollständiger Blogartikel in Markdown: 800-1200 Wörter,
    H1/H2-Struktur, Vergleichstabelle, Code-Beispiele, klare Empfehlung.""",
    agent=writer,
    output_file="output/article_draft.md"
)

edit_task = Task(
    description="""Prüfe und verbessere den Artikel: Grammatik, Stil,
    faktische Korrektheit, SEO (Meta-Description, Keywords, Headings),
    und Praxisbezug. Verbessere unpräzise Aussagen.""",
    expected_output="""Finaler korrigierter Artikel in Markdown mit
    SEO-Meta-Description, verbesserte Lesbarkeit, überprüfte Quellen.""",
    agent=editor,
    output_file="output/article_final.md"
)

# --- CREW ---

content_crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, write_task, edit_task],
    process=Process.sequential,
    verbose=True,
    memory=True
)

result = content_crew.kickoff()
print(result)

Was hier passiert: Researcher nutzt Web-Suche → Writer bekommt Recherche als Kontext und schreibt Artikel → Editor prüft und verbessert, kann bei Unklarheiten delegieren. Jeder Schritt speichert Output-Dateien für Debugging. Kosten mit GPT-4o: ca. 0.50-2.00$ pro Durchlauf.

Beispiel 2: Code-Review-Crew (Vollständig)

Ein Team für automatisierte Code-Reviews mit Security-Fokus.

from crewai import Agent, Task, Crew, Process
from crewai_tools import DirectoryReadTool, FileReadTool

file_reader = FileReadTool()
dir_reader = DirectoryReadTool(directory="src/")

# --- AGENTS ---

code_reviewer = Agent(
    role="Senior Security Code Reviewer",
    goal="Identifiziere Bugs, Security-Issues, Performance-Probleme und Best-Practice-Verletzungen",
    backstory="""Du bist ein Security-Experte mit 15 Jahren Erfahrung. Du kennst 
    OWASP Top 10, CWE-Top-25 und gängige Security-Patterns. Du reviewst Code 
    systematisch: erst Security, dann Bugs, dann Style. Du gibst jedem Issue 
    einen Schweregrad (Critical/High/Medium/Low).""",
    tools=[file_reader, dir_reader],
    verbose=True
)

refactorer = Agent(
    role="Refactoring Specialist",
    goal="Verbessere Code-Qualität ohne Funktionalität zu ändern",
    backstory="""Du bist spezialisiert auf Clean Code, SOLID-Prinzipien und 
    Design Patterns. Du refactorest konservativ: kleine, sichere Änderungen. 
    Du brichst niemals bestehende Funktionalität. Du erklärst jede Änderung.""",
    tools=[file_reader],
    verbose=True
)

doc_writer = Agent(
    role="Technical Writer",
    goal="Erstelle klare, verständliche Dokumentation für den verbesserten Code",
    backstory="""Du schreibst verständliche technische Dokumentation für 
    Entwickler. Du verwendest Code-Beispiele, Diagramme und Tabellen. 
    Du dokumentierst nicht nur WAS, sondern auch WARUM.""",
    verbose=True
)

# --- TASKS ---

review_task = Task(
    description="""Review den gesamten Code im Verzeichnis src/.
    Prüfe: OWASP Top 10, Auth Issues, Hardcoded Secrets, Error Handling,
    Performance (N+1 Queries), Code Smells. Nutze DirectoryReadTool und
    FileReadTool um alle Dateien zu lesen.""",
    expected_output="""Code-Review-Report mit Tabelle aller Issues
    (Datei, Zeile, Schweregrad, Beschreibung), gruppiert nach Schweregrad,
    mit konkreter Empfehlung pro Issue.""",
    agent=code_reviewer,
    output_file="output/code_review.md"
)

refactor_task = Task(
    description="""Refactore den Code basierend auf dem Review.
    Priorität: 1. Critical/High Issues beheben, 2. Security-Lücken schließen,
    3. Code-Smells reduzieren. WICHTIG: Keine Funktionalität ändern!""",
    expected_output="""Refactorter Code mit allen Änderungen aufgelistet
    (Datei, was geändert, warum), Vorher/Nachher-Vergleich für kritische
    Änderungen, Begründung pro Refactoring.""",
    agent=refactorer,
    output_file="output/refactored_code.md"
)

doc_task = Task(
    description="""Dokumentiere die Änderungen und den neuen Code.
    Erstelle CHANGELOG.md, Funktionsdokumentation und Security-Checklist.""",
    expected_output="""Vollständige Dokumentation: CHANGELOG.md,
    Modul-Dokumentation mit Funktionsbeschreibungen, Code-Beispiele,
    Security-Checklist für zukünftige Entwicklungen.""",
    agent=doc_writer,
    output_file="output/documentation.md"
)

# --- CREW ---

code_crew = Crew(
    agents=[code_reviewer, refactorer, doc_writer],
    tasks=[review_task, refactor_task, doc_task],
    process=Process.sequential,
    verbose=True
)

result = code_crew.kickoff()
print(result)

Warum dieses Setup funktioniert: Der Reviewer liest Code und findet Probleme mit File-Tools → der Refactorer bekommt die Issue-Liste und verbessert den Code → der Doc Writer dokumentiert alles. Sequentieller Prozess: Jeder Schritt baut auf dem vorherigen auf.

Beispiel 3: Customer-Support-Crew (Hierarchisch)

Ein Team für automatisierten Customer-Support mit Manager-Koordination.

from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool, FileReadTool

search_tool = SerperDevTool()
kb_reader = FileReadTool()

# --- AGENTS ---

triage_agent = Agent(
    role="Support Triage Specialist",
    goal="Kategorisiere und priorisiere eingehende Support-Tickets korrekt",
    backstory="""Du analysierst Support-Anfragen in Sekunden. Du erkennst 
    Schweregrad, Kategorie (Technical, Billing, Feature Request) und 
    Dringlichkeit. Du leitest jedes Ticket an den richtigen Agenten weiter.""",
    verbose=True
)

solver_agent = Agent(
    role="Technical Support Engineer",
    goal="Löse technische Probleme der Kunden schnell und korrekt",
    backstory="""Du bist ein Allrounder in der technischen Problemlösung. 
    Du kennst die Knowledge-Base auswendig und kannst in der Dokumentation 
    suchen. Wenn Du eine Lösung nicht kennst, sagst Du es ehrlich und 
    schlägst Workarounds vor.""",
    tools=[search_tool, kb_reader],
    verbose=True
)

escalation_agent = Agent(
    role="Escalation Manager",
    goal="Eskaliere ungelöste Probleme an das richtige Team mit vollem Kontext",
    backstory="""Du entscheidest, wann ein Problem an Spezialisten weitergeleitet 
    wird. Du stellst sicher, dass alle Informationen weitergegeben werden, 
    damit der Spezialist nicht bei null anfangen muss. Du priorisierst 
    Eskalationen nach Business-Impact.""",
    verbose=True
)

# --- TASKS ---

triage_task = Task(
    description="""Analysiere das Support-Ticket: 'Kunde kann sich nicht 
    einloggen. Fehlermeldung: Invalid token. Chrome auf Windows 11.'
    Bestimme Kategorie, Schweregrad, Dringlichkeit und empfohlenen Agent.""",
    expected_output="""Triage-Report mit Kategorie, Schweregrad + Begründung,
    Dringlichkeit, empfohlenem Agent, und Ersteinschätzung (2-3 Sätze).""",
    agent=triage_agent
)

solve_task = Task(
    description="""Versuche das Problem zu lösen. Suche in der Knowledge-Base
    nach 'Invalid token' und 'Login problems'. Suche im Web nach Lösungen.
    Wenn lösbar: Schritt-für-Schritt-Anleitung. Wenn nicht: Eskalation vorbereiten.""",
    expected_output="""Entweder Lösungsvorschlag mit Schritt-für-Schritt-Anleitung
    und Verweis auf KB-Artikel, oder Eskalations-Report mit allen Informationen
    und Empfehlung für Empfänger-Team.""",
    agent=solver_agent
)

escalation_task = Task(
    description="""Wenn das Problem nicht gelöst werden konnte, bereite 
    eine professionelle Eskalation vor mit Problembeschreibung, bisherigen 
    Lösungsversuchen, Kundensystem, Business-Impact und Empfehlung.""",
    expected_output="""Eskalations-Ticket mit Zusammenfassung, allen bisherigen 
    Schritten, bewertetem Business-Impact und Prioritätsempfehlung.""",
    agent=escalation_agent
)

# --- CREW (HIERARCHISCH) ---

support_crew = Crew(
    agents=[triage_agent, solver_agent, escalation_agent],
    tasks=[triage_task, solve_task, escalation_task],
    process=Process.hierarchical,  # Manager entscheidet Reihenfolge!
    verbose=True
)

result = support_crew.kickoff()
print(result)

Warum hierarchisch? Bei Support-Tickets ist nicht immer klar, welche Reihenfolge sinnvoll ist. Manchmal kann der Solver das Problem direkt lösen. Manchmal muss sofort eskaliert werden. Der Manager-Agent entscheidet dynamisch. Nachteil: Der Manager macht einen zusätzlichen LLM-Aufruf pro Entscheidung — das kostet mehr, aber die Flexibilität ist es wert.

Custom Tools für CrewAI

Du kannst eigene Tools erstellen, wenn die Built-in-Tools nicht ausreichen:

from crewai_tools import BaseTool

class DatabaseQueryTool(BaseTool):
    name: str = "Database Query Tool"
    description: str = "Führt SQL-Queries aus und gibt Ergebnisse zurück."
    
    def _run(self, query: str) -> str:
        import sqlite3
        conn = sqlite3.connect("database.db")
        cursor = conn.cursor()
        try:
            cursor.execute(query)
            results = cursor.fetchall()
            return str(results)
        except Exception as e:
            return f"Query failed: {str(e)}"
        finally:
            conn.close()

class APIRequestTool(BaseTool):
    name: str = "API Request Tool"
    description: str = "Macht HTTP-Requests an eine API."
    
    def _run(self, url: str, method: str = "GET") -> str:
        import requests
        response = requests.request(method, url)
        return response.text

# Verwenden:
db_tool = DatabaseQueryTool()
api_tool = APIRequestTool()

analyst = Agent(
    role="Data Analyst",
    goal="Analysiere Daten aus der Datenbank",
    backstory="Du bist ein SQL-Experte.",
    tools=[db_tool, api_tool]
)

Wichtig bei Custom Tools:

• Die description ist kritisch — das LLM entscheidet anhand der Beschreibung, ob es das Tool nutzt
• Die _run-Methode muss einen String zurückgeben (das ist, was das LLM sieht)
• Error-Handling im Tool: Gib immer einen nützlichen String zurück, keine Exception
• Sicherheit: Sanitize Inputs! Das LLM könnte beliebige SQL-Queries generieren

Best Practices aus der Praxis

1. Backstory ist wichtiger als Du denkst

Die Backstory bestimmt den “Charakter” des Agents und beeinflusst die Qualität massiv. “Du bist ein strenger Reviewer, der jede Behauptung mit Quellen belegt” produziert dramatisch andere Ergebnisse als “Du bist ein Reviewer”.

2. Expected Output muss präzise sein

“Schreibe einen Artikel” → vage Ausgabe. “Schreibe einen 800-Wörter-Artikel in Markdown mit H1/H2-Struktur, 3 Code-Beispielen und einer Vergleichstabelle” → präzise Ausgabe.

3. Tools machen den Unterschied

Ein Agent ohne Tools ist nur ein Chatbot. Mit Web-Suche, Datei-Zugriff oder API-Anbindung wird er erst nützlich.

4. Kosten kontrollieren

Jeder Agent macht mindestens 1 LLM-Call. Bei 3 Agenten + Delegation + Manager sind das schnell 10+ Calls. Nutze GPT-4o-mini für einfache Tasks und GPT-4o nur für komplexe.

5. Output-Files nutzen

output_file pro Task speichert Zwischenergebnisse. Gold wert für Debugging — Du siehst genau, was jeder Agent produziert hat.

CrewAI vs. LangGraph — Welches für welchen Fall?

Aspekt	CrewAI	LangGraph
Ansatz	Rollenbasiert (Team-Metapher)	Graph-basiert (Graph-Theorie)
Setup-Zeit	10 Min für 3 Agenten	30-60 Min für denselben Workflow
Kontrolle	Weniger feingranular	Sehr feingranular (Conditional Edges)
Lernkurve	Flach — intuitiv	Steil — Graph-Konzepte nötig
Cycles/Schleifen	Eingeschränkt (max_iter)	Nativ (Conditional Edges)
Human-in-the-Loop	Manuell	Nativ (interrupt)
Delegation	Nativ (allow_delegation)	Manuell implementiert
Manager-Agent	Nativ (Process.hierarchical)	Manuell als Node
Eignung	Standard-Workflows, Prototypen	Komplexe, bedingte Workflows, Produktion

Meine Empfehlung:

• CrewAI für: Content-Erstellung, Code-Review, Customer-Support, einfache 2-5 Agenten-Teams
• LangGraph für: Komplexe Produktions-Workflows mit Schleifen, Bedingungen, Human-in-the-Loop
• Beide können coexistieren — CrewAI für schnelle Prototypen, LangGraph für die Produktionsversion

Häufige Probleme und Lösungen

Problem: Agent halluziniert Quellen

Lösung: Gib dem Agent Web-Suche-Tool und schreibe in die Task-Description: “Alle Behauptungen müssen mit Quellen belegt werden.”

Problem: Agent delegiert zu viel

Lösung: Setze allow_delegation=False für Agenten, die selbstständig arbeiten sollen. Nur Manager und Reviewer sollten delegieren dürfen.

Problem: Crew dauert zu lange

Lösung: Reduziere max_iter, nutze schnellere Modelle (GPT-4o-mini), reduziere Anzahl Agenten, deaktiviere memory.

Problem: Ergebnisse sind oberflächlich

Lösung: Verfeinere expected_output mit konkreten Anforderungen (Länge, Struktur, Format).

Prüfungsrelevante Punkte

• CrewAI: Rollenbasiertes Multi-Agent-Framework, baut auf LangChain auf
• 3 Kernkomponenten: Agent (Rolle, Ziel, Backstory, Tools), Task (Beschreibung, expected_output, Agent), Crew (Agenten + Tasks + Prozess)
• Prozess-Typen: Sequential (lineare Reihenfolge) vs. Hierarchical (Manager-Agent koordiniert)
• Delegation: allow_delegation=True erlaubt Agenten, Tasks an andere weiterzugeben
• Tools: Built-in (SerperDev, ScrapeWebsite, FileRead, DirectoryRead) und Custom Tools (BaseTool)
• Memory: memory=True für kontextübergreifendes Gedächtnis
• Output-Files: output_file pro Task für Debugging und Zwischenergebnisse
• Kosten: Pro Agent mind. 1 LLM-Call; Manager und Delegation kosten extra
• Vergleich: CrewAI (schnell, intuitiv, eingeschränkte Kontrolle) vs. LangGraph (komplex, feingranular, Produktionsreif)

FAQ

Kann CrewAI mit lokalen Modellen arbeiten? Ja, über Ollama-Integration: from langchain_community.llms import Ollama; llm = Ollama(model="llama3.1:8b"). Du kannst llm pro Agent setzen oder global in der Crew. Lokale Modelle sind gut für Entwicklung, aber Cloud-Modelle liefern meist bessere Ergebnisse.

Wie viele Agenten sollte eine Crew haben? 3-5 Agenten sind typisch und gut koordinierbar. Mehr als 8 werden schwer zu managen — die Agenten delegieren zu viel und die Kosten explodieren. Für komplexe Anforderungen besser in mehrere kleine Crews aufteilen.

Können Agenten miteinander kommunizieren? Ja, mit allow_delegation=True können Agenten Tasks an andere delegieren. Bei Process.hierarchical kann der Manager-Agent alle Agenten koordinieren und Tasks umverteilen.

Wie debugge ich eine Crew? Drei Tools: 1) verbose=True für detaillierte Logs. 2) output_file pro Task für Zwischenergebnisse. 3) LangSmith-Tracing (Umgebungsvariablen: LANGCHAIN_TRACING_V2=true).

Was kostet ein CrewAI-Durchlauf? Mit GPT-4o und 3 Agenten: ca. 0.50-2.00$ pro Durchlauf. Mit GPT-4o-mini: ca. 0.05-0.20$. Mit lokalen Modellen (Ollama): 0$ aber langsamer und geringere Qualität.

Empfohlene Literatur