> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/crewai.md).

# 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](https://github.com/crewAIInc/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](https://clore.ai/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](#gpu-acceleration))

***

## Schnellstart

### 1. Einen Clore.ai-Server mieten

Melde dich an bei [clore.ai](https://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

```bash
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)

```bash
# 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)

```bash
# 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

```bash
# 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

```yaml
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

```yaml
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

```python
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)

```yaml
# 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:
```

```bash
# 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)

```bash
# 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

```python
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](/guides/guides_v2-de/sprachmodelle/ollama.md) und [vLLM auf Clore.ai](/guides/guides_v2-de/sprachmodelle/vllm.md) für vollständige Anleitungen zur Inferenz-Einrichtung.

***

## Tipps & bewährte Methoden

### Kostenoptimierung

```bash
# 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

```bash
# 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

```python
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

```python
# 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

```bash
# 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

```bash
# 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)

```bash
# 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)

```bash
# 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

```bash
# 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

```bash
# 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](https://docs.crewai.com)
* [CrewAI GitHub-Repository](https://github.com/crewAIInc/crewAI)
* [CrewAI-Tools-Dokumentation](https://docs.crewai.com/concepts/tools)
* [CrewAI-Beispiel-Repository](https://github.com/crewAIInc/crewAI-examples)
* [Ollama auf Clore.ai ausführen](/guides/guides_v2-de/sprachmodelle/ollama.md)
* [vLLM auf Clore.ai ausführen](/guides/guides_v2-de/sprachmodelle/vllm.md)
* [Clore.ai GPU-Vergleich](/guides/guides_v2-de/erste-schritte/gpu-comparison.md)
* [CrewAI Community Discord](https://discord.com/invite/X4JWnZnxPb)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/crewai.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.