> 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/metagpt.md).

# MetaGPT-Softwareunternehmen

Deploye MetaGPT auf Clore.ai — betreibe ein vollständig autonomes Multi-Agenten-KI-Softwareunternehmen auf günstigen GPU-Cloud-Servern, um vollständige Codebasen, PRDs, Architekturentwürfe und QA-Tests aus einem ein

## Überblick

[MetaGPT](https://github.com/geekan/MetaGPT) ist ein Multi-Agenten-KI-Framework, das eine **Softwarefirma** — komplett mit Agenten für Produktmanager, Architekt, Ingenieur und QA-Ingenieur — die alle zusammenarbeiten, um aus einer Idee in einem Satz ein voll funktionsfähiges Softwareprojekt zu machen. Mit über 45.000 GitHub-Stars ist MetaGPT einer der innovativsten Ansätze für KI-gestützte Softwareentwicklung.

Im Gegensatz zu einem einzelnen Coding-Agenten bildet MetaGPT echte Team-Workflows ab. Wenn du ihm eine Aufgabe wie „Baue ein Snake-Spiel in Python“ gibst, dann:

1. **Produktmanager** — Erstellt ein Product Requirements Document (PRD)
2. **Architekt** — Entwirft die Systemarchitektur und den Tech-Stack
3. **Projektmanager** — Zerlegt Aufgaben und weist sie zu
4. **Ingenieure** — Schreiben tatsächlich lauffähigen Code für jede Komponente
5. **QA-Ingenieur** — Schreibt Unit-Tests und validiert die Implementierung

Das Ergebnis ist ein vollständiges Projektverzeichnis mit Code, Dokumentation und Tests — autonom generiert.

**Wichtige Funktionen:**

* **Vollständiger Software-Lebenszyklus** — Von den Anforderungen bis zum lauffähigen Code mit nur einem Befehl
* **Rollenbasierte Agenten** — Spezialisierte Agenten mit klaren Verantwortlichkeiten
* **Dokumentengenerierung** — Erstellt automatisch PRDs, Systementwürfe und API-Spezifikationen
* **Unterstützung für mehrere Sprachen** — Python, Node.js, Go und mehr
* **Dateninterpretierer** — Autonomer Agent für Datenanalyse und Visualisierung
* **Inkrementelle Entwicklung** — Funktionen zu bestehenden Projekten hinzufügen
* **Modus für menschliche Interaktion** — An wichtigen Stellen für menschliche Prüfung anhalten

**Warum Clore.ai für MetaGPT?**

MetaGPT selbst ist CPU-basiert, aber Clore.ai bietet entscheidende Vorteile:

* **Lang laufende Aufgaben** — Die Generierung mit MetaGPT kann 10–60 Minuten dauern; dedizierte Server bewältigen das ohne Timeouts
* **Lokales LLM-Backend** — Nutze Ollama oder vLLM, um API-Kosten pro Token für große Projekte zu vermeiden
* **Kostenkontrolle** — Für 0,20–0,35 $/h kannst du umfangreiche MetaGPT-Sitzungen günstiger ausführen als GPT-4o-API-Aufrufe
* **Isolierte Umgebung** — Generierter Code läuft in einer kontrollierten Serverumgebung
* **Teamzusammenarbeit** — Teile einen MetaGPT-Server-Endpunkt mit einem Entwicklungsteam

***

## Anforderungen

MetaGPT orchestriert LLM-API-Aufrufe — die GPU wird nur benötigt, wenn du ein lokales LLM-Backend verwendest.

| Konfiguration                      | GPU       | VRAM  | RAM   | Speicher | Geschätzter Preis                         |
| ---------------------------------- | --------- | ----- | ----- | -------- | ----------------------------------------- |
| **MetaGPT + OpenAI/Anthropic-API** | Keine     | —     | 4 GB  | 20 GB    | \~0,03–0,08 $/Std.                        |
| **+ Ollama (Qwen2.5-Coder 7B)**    | RTX 3090  | 24 GB | 16 GB | 40 GB    | ca. 0,07–0,21 $/h                         |
| **+ Ollama (DeepSeek Coder 33B)**  | RTX 4090  | 24 GB | 32 GB | 60 GB    | ca. 0,14–0,42 $/h                         |
| **+ vLLM (Qwen2.5-Coder 32B)**     | RTX 4090  | 24 GB | 32 GB | 80 GB    | ca. 0,14–0,42 $/h                         |
| **+ vLLM (Llama 3.1 70B)**         | A100 80GB | 80 GB | 64 GB | 100 GB   | [Bare Metal](https://clore.ai/bare-metal) |

> **Empfehlung:** MetaGPT ist stark auf die Modellqualität für schlüssiges mehrstufiges Denken angewiesen. Für komplexe Projekte nutze die APIs von GPT-4o oder Claude Sonnet 3.5 oder lokal Qwen2.5-Coder-32B / DeepSeek-Coder-V2. Siehe die [GPU-Vergleichsleitfaden](/guides/guides_v2-de/erste-schritte/gpu-comparison.md).

**Softwareanforderungen auf dem Clore.ai-Server:**

* Docker Engine (auf allen Clore.ai-Images vorinstalliert)
* NVIDIA Container Toolkit (nur für die lokale LLM-Option)
* 20+ GB freier Speicherplatz (MetaGPT-Image + generierte Projektdateien)
* Ausgehender Internetzugang (zum Abrufen von Docker-Images und zum Erreichen von LLM-APIs)

***

## Schnellstart

### Schritt 1: Verbinde dich mit deinem Clore.ai-Server

Buche einen Server auf [Clore.ai-Marktplatz](https://clore.ai):

* Für API-only: Jeder Server mit ≥4 GB RAM
* Für lokales LLM: GPU mit ≥24 GB VRAM

```bash
ssh root@<server-ip> -p <ssh-port>
```

### Schritt 2: Ziehe das MetaGPT-Docker-Image

```bash
docker pull metagpt/metagpt:latest
```

> Das MetaGPT-Image ist \~3 GB groß. Der erste Download kann 2–5 Minuten dauern.

### Schritt 3: Konfiguration einrichten

MetaGPT benötigt eine YAML-Konfigurationsdatei mit deinen LLM-API-Zugangsdaten:

```bash
# Verzeichnisse erstellen
mkdir -p /opt/metagpt/{config,workspace}

# Extrahiere die Standard-Konfigurationsvorlage aus dem Image
docker run --rm metagpt/metagpt:latest \\
  cat /app/metagpt/config/config2.yaml \\
  > /opt/metagpt/config/config2.yaml

# Die Konfiguration anzeigen
cat /opt/metagpt/config/config2.yaml
```

### Schritt 4: Deinen LLM-Anbieter konfigurieren

Bearbeite die Konfigurationsdatei:

```bash
nano /opt/metagpt/config/config2.yaml
```

**Für OpenAI (GPT-4o):**

```yaml
llm:
  api_type: "openai"
  model: "gpt-4o"
  base_url: "https://api.openai.com/v1"
  api_key: "sk-your-openai-key-here"

repair_llm_output: true
max_auto_summarize_code: 1
```

**Für Anthropic (Claude):**

```yaml
llm:
  api_type: "anthropic"
  model: "claude-3-5-sonnet-20241022"
  api_key: "sk-ant-your-key-here"

repair_llm_output: true
```

**Für lokales Ollama (siehe GPU-Abschnitt):**

```yaml
llm:
  api_type: "ollama"
  model: "ollama/qwen2.5-coder:32b"
  base_url: "http://host.docker.internal:11434"
  api_key: "ollama"

repair_llm_output: true
```

### Schritt 5: Starte dein erstes MetaGPT-Projekt

```bash
# Generiere ein Snake-Spiel (klassische Demo)
docker run --rm --privileged \\
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  -v /opt/metagpt/workspace:/app/metagpt/workspace \\
  metagpt/metagpt:latest \\
  metagpt "Erstelle ein Snake-Spiel mit Python"
```

Beobachte, wie die Agenten arbeiten: Du wirst nacheinander die PRD-Generierung, den Systementwurf, das Schreiben des Codes und das Testen sehen. Rechne je nach deinem LLM mit 5–15 Minuten.

### Schritt 6: Ausgabe anzeigen

```bash
ls -la /opt/metagpt/workspace/
# Du wirst ein Verzeichnis sehen, das nach deinem Projekt benannt ist

find /opt/metagpt/workspace -type f | head -30
# Listet alle generierten Dateien auf: .py, .md, requirements.txt, tests/
```

***

## Konfiguration

### Vollständige Konfigurationsreferenz

```yaml
# /opt/metagpt/config/config2.yaml

# Primäre LLM-Konfiguration
llm:
  api_type: "openai"          # openai | anthropic | ollama | azure | gemini
  model: "gpt-4o"
  base_url: "https://api.openai.com/v1"
  api_key: "your-api-key"
  temperature: 0.0            # Niedriger = deterministischere Code-Generierung
  max_token: 4096

# MetaGPT-Verhaltenseinstellungen
repair_llm_output: true       # Fehlerhafte LLM-Antworten automatisch korrigieren
max_auto_summarize_code: 1    # Iterationen der Code-Zusammenfassung (0 = deaktiviert)
max_project_auto_run: 5       # Maximale Anzahl automatischer Ausführungszyklen

# Projekteinstellungen
project_name: ""              # Optional: generierten Projektnamen überschreiben
inc: false                    # Inkrementeller Modus (zu bestehendem Projekt hinzufügen)
reqa_file: ""                 # QA für eine bestimmte Datei ausführen

# Kostenverfolgung
max_budget: 10.0              # Maximal auszugebender Betrag in $ (nur API-Aufrufe)
```

### Laufen im interaktiven Modus

Für mehr Kontrolle starte MetaGPT mit Prüfstationen für menschliche Freigabe:

```bash
docker run --rm -it --privileged \\
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  -v /opt/metagpt/workspace:/app/metagpt/workspace \\
  metagpt/metagpt:latest \\
  metagpt "Erstelle eine REST-API für eine Todo-Listen-App mit FastAPI" \\
  --human-review
```

Mit `--human-review`pausiert MetaGPT nach der PRD- und Systementwurfsphase, sodass du vor Beginn der Implementierung Feedback geben kannst.

### Inkrementelle Entwicklung (zu bestehendem Projekt hinzufügen)

```bash
# An der Entwicklung eines bestehenden Projekts fortfahren
docker run --rm -it --privileged \\
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  -v /opt/metagpt/workspace:/app/metagpt/workspace \\
  -v /opt/metagpt/workspace/my-project:/app/metagpt/workspace/my-project \\
  metagpt/metagpt:latest \\
  metagpt "Füge der bestehenden Todo-API Benutzer-Authentifizierung hinzu" \\
  --project-path /app/metagpt/workspace/my-project \\
  --inc
```

### Den Data Interpreter ausführen

MetaGPT enthält einen spezialisierten Data-Interpreter-Agenten für die Datenanalyse:

```bash
# Interaktive Python-Datenanalyse
docker run --rm -it --privileged \\
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  -v /opt/metagpt/workspace:/app/metagpt/workspace \\
  -v /path/to/your/data:/data:ro \\
  metagpt/metagpt:latest \\
  python -m metagpt.roles.di.data_interpreter \\
    "Analysiere /data/sales.csv und finde die Produkte mit der besten Leistung, erstelle eine Visualisierung"
```

### Docker Compose für persistentes Setup

```yaml
# /opt/metagpt/docker-compose.yml
version: "3.9"

services:
  metagpt:
    image: metagpt/metagpt:latest
    privileged: true
    volumes:
      - /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml:ro
      - /opt/metagpt/workspace:/app/metagpt/workspace
      - /opt/metagpt/logs:/app/metagpt/logs
    environment:
      - PYTHONUNBUFFERED=1
    stdin_open: true
    tty: true
    # Hinweis: MetaGPT ist aufgabenbasiert, kein persistenter Dienst.
    # Verwende 'docker compose run metagpt metagpt "deine aufgabe"', um auszuführen
    entrypoint: ["bash"]
```

```bash
# Eine Aufgabe via docker-compose ausführen
docker compose -f /opt/metagpt/docker-compose.yml \\
  run --rm metagpt \\
  metagpt "Erstelle eine Flask-Web-App mit Benutzerregistrierung"
```

***

## GPU-Beschleunigung (lokale LLM-Integration)

### MetaGPT + Ollama

Führe MetaGPT komplett kostenlos aus (keine API-Kosten) mithilfe eines lokalen Coding-Modells:

```bash
# Schritt 1: Ollama mit GPU starten
docker run -d \
  --name ollama \\
  --gpus all \
  --restart unless-stopped \\
  -p 11434:11434 \
  -v ollama-models:/root/.ollama \\
  ollama/ollama:latest

# Schritt 2: Ein hochwertiges Coding-Modell herunterladen
# Für RTX 3090/4090 (24 GB VRAM):
docker exec ollama ollama pull qwen2.5-coder:32b      # Am besten für Code
docker exec ollama ollama pull deepseek-coder-v2:16b  # Alternative
# Für kleinere GPUs (8–16 GB VRAM):
docker exec ollama ollama pull qwen2.5-coder:7b
docker exec ollama ollama pull codellama:13b

# Schritt 3: MetaGPT für Ollama konfigurieren
cat > /opt/metagpt/config/config2.yaml << 'EOF'
llm:
  api_type: "ollama"
  model: "ollama/qwen2.5-coder:32b"
  base_url: "http://host.docker.internal:11434"
  api_key: "ollama"
  temperature: 0.0
  max_token: 4096

repair_llm_output: true
max_auto_summarize_code: 0
EOF

# Schritt 4: MetaGPT mit Host-Netzwerk für den Ollama-Zugriff ausführen
docker run --rm --privileged \\
  --add-host host.docker.internal:host-gateway \\
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  -v /opt/metagpt/workspace:/app/metagpt/workspace \\
  metagpt/metagpt:latest \\
  metagpt "Erstelle ein Python-CLI-Tool zur Dateiorganisation"
```

> Siehe den vollständigen [Ollama-Leitfaden](/guides/guides_v2-de/sprachmodelle/ollama.md) für die Modellkonfiguration und GPU-Optimierung.

### MetaGPT + vLLM (Hoher Durchsatz)

Für maximalen Token-Durchsatz bei großen, komplexen Projekten:

```bash
# Schritt 1: vLLM mit einem Coding-Modell starten
docker run -d \
  --name vllm \\
  --gpus all \
  --restart unless-stopped \\
  -p 8000:8000 \
  --ipc=host \\
  vllm/vllm-openai:latest \
  --model Qwen/Qwen2.5-Coder-32B-Instruct \
  --max-model-len 32768 \
  --gpu-memory-utilization 0.90

# Auf das Laden des Modells warten
until curl -s http://localhost:8000/health | grep -q ok; do
  echo "Warte auf vLLM..."; sleep 10
done

# Schritt 2: MetaGPT für vLLM konfigurieren
cat > /opt/metagpt/config/config2.yaml << 'EOF'
llm:
  api_type: "openai"
  model: "Qwen/Qwen2.5-Coder-32B-Instruct"
  base_url: "http://host.docker.internal:8000/v1"
  api_key: "none"
  temperature: 0.0
  max_token: 8192

repair_llm_output: true
EOF

# Schritt 3: MetaGPT ausführen
docker run --rm --privileged \\
  --add-host host.docker.internal:host-gateway \\
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  -v /opt/metagpt/workspace:/app/metagpt/workspace \\
  metagpt/metagpt:latest \\
  metagpt "Erstelle ein vollständiges E-Commerce-Backend mit FastAPI und PostgreSQL"
```

> Siehe die [vLLM-Leitfaden](/guides/guides_v2-de/sprachmodelle/vllm.md) für Quantisierungsoptionen und Multi-GPU-Setups.

### Empfohlene Modelle nach Aufgabe

| Aufgabentyp       | Modell                         | Min. VRAM | Hinweise                             |
| ----------------- | ------------------------------ | --------- | ------------------------------------ |
| Einfache Skripte  | `qwen2.5-coder:7b`             | 8 GB      | Schnell, gut für CLI-Tools           |
| Mittlere Projekte | `qwen2.5-coder:14b`            | 12 GB     | Gute Balance                         |
| Komplexe Systeme  | `qwen2.5-coder:32b`            | 24 GB     | Beste lokale Option                  |
| Große Codebasen   | `gpt-4o` / `claude-3-5-sonnet` | API       | Am zuverlässigsten für komplexe PRDs |

> **Tipp:** Lokale Modelle eignen sich gut für die Codegenerierung, haben aber manchmal Schwierigkeiten mit komplexem architektonischem Denken. Für PRDs und Systementwürfe in Produktionsqualität solltest du für die Planungsphase GPT-4o oder Claude verwenden und für die Codegenerierung ein lokales Modell.

***

## Tipps & bewährte Praktiken

### 1. Wirksame Aufgaben-Prompts schreiben

Die Leistung von MetaGPT hängt stark von der Qualität deines ursprünglichen Prompts ab:

```
✅ Gute Prompts:
„Erstelle eine Python-REST-API mit FastAPI, die einen Bibliothekskatalog verwaltet.
Funktionen: Bücher hinzufügen/suchen/löschen, Benutzerauthentifizierung mit JWT, 
SQLite-Datenbank, OpenAPI-Dokumentation. Ziel: produktionsreif mit Tests.“

„Erstelle ein CLI-Datenpipeline-Tool in Python, das CSV-Dateien einliest,
statistische Analysen durchführt und Diagramme mit matplotlib ausgibt.“

❌ Vage Prompts:
„Mach eine Web-App“
„Bau etwas mit Python“
```

### 2. API-Kosten vor dem Ausführen schätzen

```bash
# MetaGPT verarbeitet pro Projekt viele Tokens:
# - Einfaches Skript: ~50K Tokens (~0,25 $ mit GPT-4o)
# - Mittlere Web-App: ~200K Tokens (~1,00 $ mit GPT-4o)
# - Komplexes System: ~500K+ Tokens (~2,50 $+ mit GPT-4o)

# Budgetgrenze in der Konfiguration festlegen:
# max_budget: 2.0  # Nach 2 $ Ausgaben stoppen
```

### 3. Zuerst das generierte PRD prüfen

Verwende `--human-review` für wichtige Projekte. In der PRD-Phase werden die Anforderungen festgelegt — Probleme hier zu erkennen spart erheblich Token-Kosten im Vergleich zu Änderungen nach der Codegenerierung.

### 4. Generierten Code testen

MetaGPT generiert Unit-Tests, aber überprüfe immer:

```bash
# Zum generierten Projekt wechseln
cd /opt/metagpt/workspace/<dein-projekt>

# Abhängigkeiten installieren
pip install -r requirements.txt

# Die generierten Tests ausführen
pytest tests/ -v

# Versuche, die Hauptanwendung auszuführen
python main.py
```

### 5. Versionsverwaltung verwenden

```bash
# Git im Workspace initialisieren
cd /opt/metagpt/workspace
git init
git add .
git commit -m "Erste MetaGPT-Generierung"

# Nach jeder Iteration
git add .
git commit -m "MetaGPT: Authentifizierungsfunktion hinzugefügt"
```

### 6. Mehrere Projekte stapelweise ausführen

Führe über Nacht mehrere Projekte auf Clore.ai aus, um maximalen Nutzen zu erzielen:

```bash
#!/bin/bash
# /opt/metagpt/batch-run.sh
PROJECTS=(
  "Erstelle einen URL-Shortener-Dienst mit Python und Redis"
  "Erstelle ein CLI-Tool zum Konvertieren von Markdown nach PDF"
  "Erstelle eine REST-API für einen Blog mit Kommentaren und Tags"
)

for project in "${PROJECTS[@]}"; do
  echo "Starte: $project"
  docker run --rm --privileged \\
    -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
    -v /opt/metagpt/workspace:/app/metagpt/workspace \\
    metagpt/metagpt:latest \\
    metagpt "$project"
  echo "Abgeschlossen: $project"
done
```

***

## Fehlerbehebung

### Image-Pull schlägt fehl

```bash
# Wenn das Docker-Hub-Rate-Limit erreicht wurde
docker login  # Mit deinem Docker-Hub-Konto anmelden
docker pull metagpt/metagpt:latest

# Verfügbaren Speicherplatz prüfen
df -h
# Das MetaGPT-Image ist ~3 GB groß; der Workspace kann auf mehrere GB anwachsen
```

### Konfigurationsdatei nicht gefunden

```bash
# Überprüfe, ob die Pfadzuordnung korrekt ist
docker run --rm \\
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  metagpt/metagpt:latest \\
  ls -la /app/metagpt/config/

# Überprüfe außerdem, ob dein YAML gültig ist
python3 -c "import yaml; yaml.safe_load(open('/opt/metagpt/config/config2.yaml'))"
```

### LLM-API-Authentifizierungsfehler

```bash
# Teste deinen API-Schlüssel unabhängig
curl https://api.openai.com/v1/models \\
  -H "Authorization: Bearer sk-your-key"

# Für Anthropic:
curl https://api.anthropic.com/v1/models \\
  -H "x-api-key: sk-ant-your-key" \\
  -H "anthropic-version: 2023-06-01"

# Häufige Probleme:
# - Schlüssel mit zusätzlichem Leerraum eingefügt
# - Schlüssel abgelaufen oder Kontingent überschritten
# - Falscher api_type in der Konfiguration (z. B. "openai" statt "anthropic")
```

### Ollama-Verbindung vom Container abgelehnt

```bash
# Überprüfe, ob Ollama läuft
docker ps | grep ollama
curl http://localhost:11434/api/tags

# Aus Sicht des MetaGPT-Containers testen
docker run --rm \\
  --add-host host.docker.internal:host-gateway \\
  metagpt/metagpt:latest \\
  curl http://host.docker.internal:11434/api/tags

# Wenn es immer noch fehlschlägt, prüfe die Ollama-Logs
docker logs ollama --tail 20
```

### Generierung hängt oder läuft in einen Timeout

```bash
# Prüfe, ob das LLM tatsächlich antwortet
# Debug-Logging hinzufügen, um zu sehen, welcher Agent festhängt
docker run --rm --privileged \\
  -e PYTHONUNBUFFERED=1 \\
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  -v /opt/metagpt/workspace:/app/metagpt/workspace \\
  metagpt/metagpt:latest \\
  metagpt "Einfache Aufgabe" 2>&1 | tee /opt/metagpt/logs/debug.log

# Häufige Ursachen:
# - Lokales Modell zu langsam (probier ein kleineres quantisiertes Modell)
# - API-Rate-Limitierung (Verzögerungen hinzufügen oder Tarif wechseln)
# - Modell-Kontextfenster überschritten (max_auto_summarize_code reduzieren)
```

### Kein Speicherplatz mehr auf dem Laufwerk

```bash
# Generierte Projekte können groß sein; alte aufräumen
du -sh /opt/metagpt/workspace/*
rm -rf /opt/metagpt/workspace/old-project/

# Auch den Docker-Build-Cache bereinigen
docker system prune -f

# Gesamtnutzung prüfen
df -h /opt/metagpt/
```

### Schleifen bei „LLM-Ausgabe reparieren“

```bash
# Wenn MetaGPT wegen fehlerhafter LLM-Ausgabe ständig erneut versucht:
# 1. Ein leistungsfähigeres Modell ausprobieren (GPT-4o, Claude Sonnet)
# 2. Temperatur reduzieren (für Determinismus auf 0.0 setzen)
# 3. Reparatur deaktivieren (wenn ein leistungsfähiges Modell verwendet wird):
#    repair_llm_output: false
```

***

## Weiterführende Lektüre

* [MetaGPT GitHub-Repository](https://github.com/geekan/MetaGPT) — Quellcode, Beispiele, Roadmap
* [MetaGPT-Dokumentation](https://docs.deepwisdom.ai/main/en/) — Offizielle Dokumentation, Konfigurationsreferenz, Tutorials
* [MetaGPT Discord](https://discord.gg/DYn29wFk9z) — Community-Support, Anwendungsfälle, Modelltipps
* [Docker Hub: metagpt/metagpt](https://hub.docker.com/r/metagpt/metagpt) — Verfügbare Image-Tags
* [Ollama auf Clore.ai](/guides/guides_v2-de/sprachmodelle/ollama.md) — Lokale LLMs ausführen, um MetaGPT kostenlos zu betreiben
* [vLLM auf Clore.ai](/guides/guides_v2-de/sprachmodelle/vllm.md) — Lokales LLM mit hohem Durchsatz für MetaGPT im großen Maßstab
* [GPU-Vergleichsleitfaden](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) — Wählen Sie die richtige Clore.ai-GPU für Ihre Arbeitslast
* [SWE-bench-Bestenliste](https://www.swebench.com) — Benchmark für Multi-Agenten-Coding-Frameworks
* [MetaGPT-Paper](https://arxiv.org/abs/2308.00352) — Originalforschung: „MetaGPT: Meta-Programmierung für ein kollaboratives Multi-Agenten-Framework“


---

# 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/metagpt.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.