CrewAI Multi-Agenten-Framework

Deploye CrewAI auf Clore.ai — orchestriere Teams rollenspielender autonomer KI-Agenten für komplexe mehrstufige Aufgaben mit jedem LLM-Anbieter.

Überblick

CrewAI ist ein hochmodernes Framework zur Orchestrierung rollenspielender autonomer KI-Agenten, mit über 44.000 GitHub-Sternen. Anders als Einzel-Agenten-Systeme ermöglicht CrewAI die Definition spezialisierter Agenten (Researcher, Writer, Coder, Analyst...) die als „Crew“ zusammenarbeiten, um komplexe Aufgaben zu erledigen — jeder Agent mit eigener Rolle, eigenem Ziel, eigener Hintergrundgeschichte und eigenem Werkzeugkasten.

Auf Clore.ai, kann CrewAI in einer Docker-Umgebung bereits ab $0,05–0,20/Std.. Während CrewAI selbst CPU-gebunden ist (es orchestriert API-Aufrufe), erhältst du durch die Kombination mit einem lokalen Ollama- oder vLLM-Server auf demselben GPU-Knoten ein vollständig privates, offline-fähiges Multi-Agenten-System.

Wichtige Funktionen:

• 👥 Multi-Agenten-Crews — definiere Agenten-Personas mit Rollen, Zielen und Hintergrundgeschichten

• 🎯 Aufgabenverteilung — der Manager-Agent weist Aufgaben automatisch dem richtigen Spezialisten zu

• 🛠️ Tool-Ökosystem — Websuche, Datei-I/O, Codeausführung, Datenbankzugriff, benutzerdefinierte Tools

• 🔁 Sequenziell & Parallel — Aufgaben in Reihenfolge ausführen oder unabhängige Aufgaben gleichzeitig laufen lassen

• 🧠 Agentenspeicher — kurzzeitige, langfristige, Entitäts- und kontextuelle Speichertypen

• 🔌 LLM-agnostisch — funktioniert mit OpenAI, Anthropic, Google, Ollama, Groq, Azure und mehr

• 📊 CrewAI Studio — visuelle Oberfläche zum Erstellen von Crews ohne Code (Enterprise)

• 🚀 Pipelines — mehrere Crews für komplexe mehrstufige Workflows verketten

---

Anforderungen

CrewAI ist eine Python-Bibliothek. Sie läuft auf der CPU und benötigt nur eine Systemumgebung mit Python 3.10+ oder Docker. Eine GPU ist optional, ermöglicht aber leistungsstarke lokale Modellinferenz.

Konfiguration	GPU	VRAM	System-RAM	Festplatte	Clore.ai-Preis
Minimal (Cloud-APIs)	Keins / CPU	—	2 GB	10 GB	~$0,03/Std. (CPU)
Standard	Keins / CPU	—	4 GB	20 GB	~$0,05/Std.
+ Lokales LLM (klein)	RTX 3080	10 GB	8 GB	40 GB	$0,05–0,19/Std.
+ Lokales LLM (groß)	RTX 3090 / 4090	24 GB	16 GB	60 GB	ca. 0,07–0,21 $/h
+ Hochwertiges lokales LLM	A100 40 GB	40 GB	32 GB	100 GB	Bare Metal

API-Schlüssel

CrewAI funktioniert mit den meisten großen LLM-Anbietern. Du benötigst mindestens einen:

• OpenAI — GPT-4o (beste Schlussfolgerung für komplexe Aufgaben)

• Anthropic — Claude 3.5 Sonnet (hervorragend für textlastige Crews)

• Groq — Kostenloses Kontingent, schnelle Inferenz (Llama 3 70B)

• Ollama — Vollständig lokal, kein API-Schlüssel erforderlich (siehe GPU-Beschleunigung)

---

Schnellstart

1. Einen Clore.ai-Server mieten

Melde dich an bei clore.ai:

• Nur CPU wenn Cloud-LLM-APIs verwendet werden

• RTX 3090/4090 für lokale Ollama-Inferenz

• SSH-Zugriff aktiviert

• Keine besonderen Portanforderungen für die CLI-Nutzung (Ports nur für Web-UIs freigeben)

2. Verbinden und vorbereiten

ssh root@<clore-server-ip> -p <ssh-port>

# System aktualisieren
apt-get update && apt-get upgrade -y

# Python 3.11 installieren (falls nicht vorhanden)
apt-get install -y python3.11 python3.11-venv python3-pip
python3 --version   # Sollte 3.10+ sein

# Docker prüfen
docker --version

3. Option A — Direktes pip-Install (am schnellsten)

# Eine virtuelle Umgebung erstellen
python3 -m venv crewai-env
source crewai-env/bin/activate

# CrewAI mit allen Tools installieren
pip install crewai crewai-tools

# Installation überprüfen
python -c "import crewai; print(crewai.__version__)"
crewai --version

4. Option B — Docker-Container (empfohlen für Reproduzierbarkeit)

# Projektverzeichnis erstellen
mkdir my-crew && cd my-crew

# Dockerfile schreiben
cat > Dockerfile << 'EOF'
FROM python:3.11-slim

# Systemabhängigkeiten installieren
RUN apt-get update && apt-get install -y \
    curl \
    git \
    && rm -rf /var/lib/apt/lists/*

# Arbeitsverzeichnis festlegen
WORKDIR /app

# CrewAI und gängige Tools installieren
RUN pip install --no-cache-dir \
    crewai \
    crewai-tools \
    langchain-openai \
    langchain-anthropic \
    python-dotenv

# Anwendungscode kopieren
COPY . .

# Standardbefehl
CMD ["python", "main.py"]
EOF

# Das Image bauen
docker build -t my-crewai-app .

5. Erstelle deine erste Crew

# Ein neues CrewAI-Projekt über die CLI initialisieren
source crewai-env/bin/activate
crewai create crew my-research-crew
cd my-research-crew

# API-Schlüssel konfigurieren
cat > .env << 'EOF'
OPENAI_API_KEY=sk-...
# Oder für Anthropic:
# ANTHROPIC_API_KEY=sk-ant-...
# Oder für Ollama (kein Schlüssel nötig):
# OPENAI_API_BASE=http://localhost:11434/v1
# OPENAI_API_KEY=ollama
EOF

# Projektabhängigkeiten installieren
crewai install

# Die Crew ausführen
crewai run

---

Konfiguration

Projektstruktur (von crewai create)

my-research-crew/
├── .env                    # API-Schlüssel und Einstellungen
├── pyproject.toml          # Abhängigkeiten
├── src/
│   └── my_research_crew/
│       ├── config/
│       │   ├── agents.yaml   # Agentendefinitionen
│       │   └── tasks.yaml    # Aufgabendefinitionen
│       ├── tools/
│       │   └── custom_tool.py  # Deine benutzerdefinierten Tools
│       ├── crew.py           # Crew-Zusammenstellung
│       └── main.py           # Einstiegspunkt

agents.yaml — Definiere deine Agenten

researcher:
  role: >
    Senior Research-Analyst
  goal: >
    Erkunde bahnbrechende Entwicklungen in {topic} und fasse umsetzbare Erkenntnisse zusammen
  backstory: >
    Du bist ein erfahrener Forscher mit Talent dafür, Informationen aus
    vielfältigen Quellen zu finden und miteinander zu verknüpfen. Du hast ein scharfes Auge für Glaubwürdigkeit und Relevanz.
  tools:
    - SerperDevTool
    - ScrapeWebsiteTool
  llm: gpt-4o                # Kann pro Agent festgelegt werden
  verbose: true
  max_iter: 15               # Maximale Schlussfolgerungsiterationen
  memory: true               # Agentenspeicher aktivieren

writer:
  role: >
    Experte für technische Texte
  goal: >
    Wandle komplexe Recherche in klare, überzeugende und präzise Inhalte um
  backstory: >
    Du formulierst Erklärungen, die komplexe Themen zugänglich machen, ohne an Tiefe zu verlieren.
    Du zitierst Quellen und strukturierst Inhalte für maximale Lesbarkeit.
  llm: claude-3-5-sonnet-20241022
  verbose: true

tasks.yaml — Definiere Aufgaben

research_task:
  description: >
    Recherchiere die neuesten Entwicklungen zu {topic} aus den letzten 6 Monaten.
    Identifiziere wichtige Trends, Durchbrüche und Implikationen.
    Sammle mindestens 10 glaubwürdige Quellen.
  expected_output: >
    Ein detaillierter Recherchebericht mit nach Themen gegliederten Ergebnissen,
    einschließlich Quell-URLs und Veröffentlichungsdaten.
  agent: researcher

writing_task:
  description: >
    Schreibe anhand des Rechercheberichts einen umfassenden Blogbeitrag über {topic}.
    Zielumfang: 1500–2000 Wörter. Enthält einen Titel, eine Einleitung, Hauptabschnitte,
    und ein Fazit mit Ausblick auf die Zukunft.
  expected_output: >
    Ein veröffentlichungsreifer Blogbeitrag im Markdown-Format.
  agent: writer
  context:
    - research_task    # Die Schreibaufgabe erhält die Ausgabe des Forschers
  output_file: output/blog_post.md

crew.py — Stelle die Crew zusammen

from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task
from crewai_tools import SerperDevTool, ScrapeWebsiteTool

@CrewBase
class MyResearchCrew():
    """Crew für Recherche und Schreiben"""
    agents_config = 'config/agents.yaml'
    tasks_config = 'config/tasks.yaml'

    @agent
    def researcher(self) -> Agent:
        return Agent(
            config=self.agents_config['researcher'],
            tools=[SerperDevTool(), ScrapeWebsiteTool()],
            verbose=True
        )

    @agent
    def writer(self) -> Agent:
        return Agent(
            config=self.agents_config['writer'],
            verbose=True
        )

    @task
    def research_task(self) -> Task:
        return Task(config=self.tasks_config['research_task'])

    @task
    def writing_task(self) -> Task:
        return Task(
            config=self.tasks_config['writing_task'],
            output_file='output/blog_post.md'
        )

    @crew
    def crew(self) -> Crew:
        return Crew(
            agents=self.agents,
            tasks=self.tasks,
            process=Process.sequential,  # oder Process.hierarchical
            verbose=True,
            memory=True,
            max_rpm=10   # Rate-Limit für API-Aufrufe
        )

Ausführung mit Docker Compose (mit Ollama)

# docker-compose.yml
version: "3.8"

services:
  crewai:
    build: .
    volumes:
      - ./src:/app/src
      - ./output:/app/output
    environment:
      - OPENAI_API_BASE=http://ollama:11434/v1
      - OPENAI_API_KEY=ollama
      - OPENAI_MODEL_NAME=llama3.1:70b
      - SERPER_API_KEY=${SERPER_API_KEY}
    depends_on:
      - ollama

  ollama:
    image: ollama/ollama:latest
    volumes:
      - ollama_data:/root/.ollama
    ports:
      - "11434:11434"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

volumes:
  ollama_data:

# Stack starten
docker compose up -d ollama

# Dein Modell ziehen
docker compose exec ollama ollama pull llama3.1:70b

# Deine Crew ausführen
docker compose run --rm crewai python src/my_research_crew/main.py

---

GPU-Beschleunigung

CrewAI selbst nutzt die GPU nicht — aber das aufgerufene LLM schon. Starte Ollama oder vLLM auf demselben Clore-Server für GPU-beschleunigte lokale Inferenz.

Ollama-Einrichtung (empfohlen der Einfachheit halber)

# Ollama auf dem Host installieren
curl -fsSL https://ollama.com/install.sh | sh

# GPU-Erkennung prüfen
nvidia-smi
ollama run llama3:8b "Test"   # Sollte die GPU verwenden

# Modelle für unterschiedliche Agentenanforderungen ziehen
ollama pull llama3.1:8b          # Schnelles, leichtgewichtiges Schlussfolgern
ollama pull llama3.1:70b         # Komplexes Schlussfolgern (benötigt A100+)
ollama pull codestral:latest     # Speziell für Code-Agenten
ollama pull nomic-embed-text     # Für Speicher-/RAG-Embeddings

# CrewAI für die Verwendung von Ollama konfigurieren
export OPENAI_API_BASE=http://localhost:11434/v1
export OPENAI_API_KEY=ollama
export OPENAI_MODEL_NAME=llama3.1:8b

CrewAI-LLM pro Agent konfigurieren

from crewai import Agent, LLM

# Ollama für einen bestimmten Agenten verwenden
local_llm = LLM(
    model="ollama/llama3.1:8b",
    base_url="http://localhost:11434"
)

# Für einen anderen Agenten die Cloud-API verwenden (z. B. für komplexes Schlussfolgern)
cloud_llm = LLM(
    model="gpt-4o",
    api_key="sk-..."
)

researcher = Agent(
    role="Researcher",
    goal="Informationen finden",
    backstory="Erfahrener Forscher",
    llm=local_llm    # Nutzt die lokale GPU
)

strategist = Agent(
    role="Strategist",
    goal="Maßnahmen planen",
    backstory="Strategischer Denker",
    llm=cloud_llm    # Nutzt die Cloud-API
)

Modellempfehlungen für Agentenaufgaben

Aufgabentyp	Empfohlenes Modell	VRAM	Hinweise
Recherche + Websuche	Llama 3.1 70B	40 GB	Bestes lokales Schlussfolgern
Code-Generierung	Codestral 22B	13 GB	Auf Code spezialisiert
Schreiben	Llama 3.1 8B	6 GB	Schnell, gute Qualität
Komplexe Orchestrierung	GPT-4o (API)	—	Insgesamt am besten
Embeddings/Speicher	nomic-embed-text	< 1 GB	Für Speicher erforderlich

Siehe Ollama auf Clore.ai und vLLM auf Clore.ai für vollständige Anleitungen zur Inferenz-Einrichtung.

---

Tipps & bewährte Methoden

Kostenoptimierung

# Verfolge die LLM-API-Kosten mit CrewAIs integriertem Nutzungs-Tracking
# Zu deiner Crew hinzufügen:
result = crew.kickoff(inputs={"topic": "AI agents"})
print(f"Verwendete Tokens insgesamt: {result.token_usage}")

# Für einfache Aufgaben günstigere Modelle verwenden, Premium-Modelle für komplexe
# Llama 3.1 8B auf Ollama = $0 API-Kosten
# GPT-4o = ca. $0.005/1K Eingabetokens

# Setze max_iter, um außer Kontrolle geratene Agenten zu verhindern
Agent(max_iter=10, max_execution_time=120)  # 2-Minuten-Timeout

# LLM-Antworten während der Entwicklung cachen
os.environ["CREWAI_DISABLE_CACHE"] = "false"

Crews als dauerhaften Dienst ausführen

# Crews über einen FastAPI-Endpunkt bereitstellen
pip install fastapi uvicorn

cat > server.py << 'EOF'
from fastapi import FastAPI, BackgroundTasks
from my_research_crew.crew import MyResearchCrew
import asyncio

app = FastAPI()
results = {}

@app.post("/run/{topic}")
async def run_crew(topic: str, background_tasks: BackgroundTasks):
    job_id = f"job-{topic}-{len(results)}"
    background_tasks.add_task(execute_crew, job_id, topic)
    return {"job_id": job_id, "status": "started"}

async def execute_crew(job_id: str, topic: str):
    crew = MyResearchCrew().crew()
    result = crew.kickoff(inputs={"topic": topic})
    results[job_id] = str(result)

@app.get("/result/{job_id}")
async def get_result(job_id: str):
    return {"result": results.get(job_id, "pending")}

EOF

# Server starten
uvicorn server:app --host 0.0.0.0 --port 8080 &

# Einen Crew-Durchlauf auslösen
curl -X POST http://<clore-ip>:8080/run/quantum-computing

Nützliche integrierte CrewAI-Tools

from crewai_tools import (
    SerperDevTool,        # Google-Suche über die Serper-API
    ScrapeWebsiteTool,    # Web-Scraping
    FileReadTool,         # Lokale Dateien lesen
    FileWriterTool,       # Dateien schreiben
    DirectoryReadTool,    # Verzeichnisinhalte auflisten
    CodeInterpreterTool,  # Python-Code ausführen
    GithubSearchTool,     # GitHub-Repos durchsuchen
    YoutubeVideoSearchTool, # YouTube durchsuchen
    PGSearchTool,         # PostgreSQL abfragen
)

Human-in-the-Loop implementieren

# An einer bestimmten Aufgabe menschliche Eingaben anfordern
task = Task(
    description="Recherchiere {topic}",
    expected_output="Recherchebericht",
    agent=researcher,
    human_input=True    # Pausiert und fordert den Nutzer zu Feedback auf
)

---

Fehlerbehebung

"openai.AuthenticationError" sogar mit gültigem Schlüssel

# Prüfen, ob dein API-Schlüssel geladen ist
python3 -c "import os; from dotenv import load_dotenv; load_dotenv(); print(os.getenv('OPENAI_API_KEY')[:10])"

# Wenn Ollama verwendet wird, sicherstellen, dass diese gesetzt sind:
export OPENAI_API_BASE=http://localhost:11434/v1
export OPENAI_API_KEY=ollama
export OPENAI_MODEL_NAME=llama3.1:8b

# Prüfen, ob Ollama erreichbar ist
curl http://localhost:11434/v1/models

Agent steckt in einer Denk-Schleife fest

# Eine feste Grenze für Iterationen setzen
Agent(
    max_iter=10,            # Maximale Denkschritte
    max_execution_time=300  # Harte Zeitüberschreitung von 5 Minuten
)

# Verbose aktivieren, um zu sehen, wo er in der Schleife hängt
Agent(verbose=True)

# Prüfen, ob das Modell Tool-Calling unterstützt
# Einige kleinere Modelle tun das nicht; verwende llama3.1 oder mistral-nemo

CrewAI-Tools schlagen fehl (SerperDevTool 403)

# SerperDevTool benötigt einen kostenlosen API-Schlüssel von serper.dev
export SERPER_API_KEY=dein-serper-schlüssel

# Alternative: DuckDuckGo verwenden (kein API-Schlüssel erforderlich)
from langchain_community.tools import DuckDuckGoSearchRun
from crewai import tool

@tool("DuckDuckGo Search")
def ddg_search(query: str) -> str:
    """Das Web mit DuckDuckGo durchsuchen."""
    return DuckDuckGoSearchRun().run(query)

Speicherfehler (ChromaDB / Embeddings)

# CrewAI-Speicher verwendet ChromaDB für die Vektorspeicherung
# Wenn es fehlschlägt, Speicherplatz und Berechtigungen prüfen
df -h
ls -la ~/.local/share/crewai/

# Beschädigten Speicher löschen
rm -rf ~/.local/share/crewai/

# Oder den Speicher deaktivieren, wenn er nicht benötigt wird
Crew(memory=False)

# Wenn Ollama-Embeddings verwendet werden, sicherstellen, dass das Modell heruntergeladen wurde
docker exec ollama ollama pull nomic-embed-text

Docker-Build schlägt bei ARM/x86-Mismatch fehl

# Clore.ai-Server sind x86_64; Plattform explizit angeben:
docker build --platform linux/amd64 -t my-crewai-app .

# Oder in docker-compose.yml:
services:
  crewai:
    platform: linux/amd64
    build: .

Rate Limiting durch LLM-APIs

# Anfragen pro Minute reduzieren
Crew(max_rpm=5)   # 5 Anfragen pro Minute

# Wiederholungslogik in der LLM-Konfiguration hinzufügen
LLM(
    model="gpt-4o",
    max_retries=3,
    timeout=60
)

---

Weiterführende Lektüre

• Offizielle CrewAI-Dokumentation

• CrewAI GitHub-Repository

• CrewAI-Tools-Dokumentation

• CrewAI-Beispiel-Repository

• Ollama auf Clore.ai ausführen

• vLLM auf Clore.ai ausführen

• Clore.ai GPU-Vergleich

• CrewAI Community Discord