> 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

## Überblick

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

Im Gegensatz zu einem einzelnen Programmieragenten spiegelt MetaGPT reale Team-Workflows wider. Wenn Sie ihm eine Aufgabe wie „Erstelle ein Snake-Spiel in Python“ geben, dann:

1. **Product Manager** — Schreibt 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 den tatsächlich funktionierenden 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.

**Wesentliche Funktionen:**

* **Voller Software-Lifecycle** — Von Anforderungen bis zu funktionierendem Code mit einem Befehl
* **Rollenbasierte Agenten** — Spezialisierte Agenten mit klaren Verantwortlichkeiten
* **Dokumentengenerierung** — Produziert automatisch PRDs, Systementwürfe, API-Spezifikationen
* **Mehrsprachige Unterstützung** — Python, Node.js, Go und mehr
* **Dateninterpreter** — Autonomer Agent für Datenanalyse und Visualisierung
* **Inkrementelle Entwicklung** — Fügt bestehenden Projekten Funktionen hinzu
* **Modus für menschliche Interaktion** — Pausiert für menschliche Überprüfung in wichtigen Phasen

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

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

* **Lang laufende Aufgaben** — MetaGPT-Generierung kann 10–60 Minuten dauern; dedizierte Server bewältigen dies ohne Timeouts
* **Lokaler LLM-Backend** — Verwenden Sie Ollama oder vLLM, um Token-basierte API-Kosten bei großen Projekten zu eliminieren
* **Kostenkontrolle** — Bei $0,20–0,35/Stunde laufen umfangreiche MetaGPT-Sitzungen günstiger als GPT-4o-API-Aufrufe
* **Isolierte Umgebung** — Generierter Code läuft in einer kontrollierten Serverumgebung
* **Teamzusammenarbeit** — Teilen Sie einen MetaGPT-Serverendpunkt im Entwicklungsteam

***

## Anforderungen

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

| Konfiguration                      | GPU       | VRAM  | RAM   | Speicher | Geschätzter Preis   |
| ---------------------------------- | --------- | ----- | ----- | -------- | ------------------- |
| **MetaGPT + OpenAI/Anthropic API** | Keine     | —     | 4 GB  | 20 GB    | \~$0.03–0.08/Stunde |
| **+ Ollama (Qwen2.5-Coder 7B)**    | RTX 3090  | 24 GB | 16 GB | 40 GB    | \~$0.20/Stunde      |
| **+ Ollama (DeepSeek Coder 33B)**  | RTX 4090  | 24 GB | 32 GB | 60 GB    | \~$0.35/Stunde      |
| **+ vLLM (Qwen2.5-Coder 32B)**     | RTX 4090  | 24 GB | 32 GB | 80 GB    | \~$0.35/Stunde      |
| **+ vLLM (Llama 3.1 70B)**         | A100 80GB | 80 GB | 64 GB | 100 GB   | \~$1.10/Stunde      |

> **Empfehlung:** MetaGPT ist stark auf Modellqualität angewiesen, um kohärentes mehrstufiges Denken zu ermöglichen. Für komplexe Projekte verwenden Sie GPT-4o- oder Claude Sonnet 3.5-APIs oder lokal Qwen2.5-Coder-32B / DeepSeek-Coder-V2. Siehe das [GPU-Vergleichsanleitung](/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 Festplattenspeicher (MetaGPT-Image + generierte Projektdateien)
* Ausgehender Internetzugang (zum Herunterladen von Docker-Images und für den Zugriff auf LLM-APIs)

***

## Schnellstart

### Schritt 1: Verbindung zu Ihrem Clore.ai-Server herstellen

Buchen Sie 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: Ziehen Sie das MetaGPT-Docker-Image

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

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

### Schritt 3: Konfiguration einrichten

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

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

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

# Ansicht der Konfiguration
cat /opt/metagpt/config/config2.yaml
```

### Schritt 4: Konfigurieren Sie Ihren LLM-Anbieter

Bearbeiten Sie 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: Starten Sie Ihr erstes MetaGPT-Projekt

```bash
# Generieren Sie 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 "Create a snake game with Python"
```

Beobachten Sie die Arbeit der Agenten: Sie sehen PRD-Erstellung, Systementwurf, Codeerstellung und Tests in Folge. Rechnen Sie mit 5–15 Minuten, abhängig von Ihrem LLM.

### Schritt 6: Ansicht der Ausgabe

```bash
ls -la /opt/metagpt/workspace/
# Sie sehen ein Verzeichnis mit dem Namen Ihres Projekts

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 Codeerzeugung
  max_token: 4096

# MetaGPT-Verhaltens-Einstellungen
repair_llm_output: true       # Automatisches Beheben fehlerhafter LLM-Antworten
max_auto_summarize_code: 1    # Code-Zusammenfassungsiterationen (0 = deaktiviert)
max_project_auto_run: 5       # Maximale automatische Ausführungszyklen

# Projekteinstellungen
project_name: ""              # Optional: überschreibt den generierten Projektnamen
inc: false                    # Inkrementeller Modus (zum Hinzufügen zu einem bestehenden Projekt)
reqa_file: ""                 # Führe QA für eine bestimmte Datei aus

# Kostenverfolgung
max_budget: 10.0              # Max. $ zum Ausgeben (nur API-Aufrufe)
```

### Ausführung im interaktiven Modus

Für mehr Kontrolle führen Sie MetaGPT mit menschlichen Review-Checkpoints aus:

```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 "Build a REST API for a todo list app with FastAPI" \
  --human-review
```

Mit `--human-review`, pausiert MetaGPT nach den Phasen PRD und Systementwurf, sodass Sie Feedback geben können, bevor die Entwicklung beginnt.

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

```bash
# Fortsetzen der Entwicklung an einem bestehenden Projekt
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 "Add user authentication to the existing todo API" \
  --project-path /app/metagpt/workspace/my-project \
  --inc
```

### Ausführen des Dateninterpreters

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 \
    "Analyze /data/sales.csv and find top-performing products, create visualization"
```

### Docker Compose für persistente Einrichtung

```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.
    # Verwenden Sie 'docker compose run metagpt metagpt "your task"' zur Ausführung
    entrypoint: ["bash"]
```

```bash
# Führen Sie eine Aufgabe über docker-compose aus
docker compose -f /opt/metagpt/docker-compose.yml \
  run --rm metagpt \
  metagpt "Create a Flask web app with user registration"
```

***

## GPU-Beschleunigung (Integration lokaler LLMs)

### MetaGPT + Ollama

Führen Sie MetaGPT vollständig kostenlos (ohne API-Kosten) mit einem lokalen Codierungsmodell aus:

```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: Laden Sie ein hochwertiges Codierungsmodell
# 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: Konfigurieren Sie MetaGPT für Ollama
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: Führen Sie MetaGPT mit Host-Netzwerk für Ollama-Zugriff aus
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 "Create a Python CLI tool for file organization"
```

> Sehen Sie das vollständige [Ollama-Anleitung](/guides/guides_v2-de/sprachmodelle/ollama.md) für Modellsetup und GPU-Optimierung.

### MetaGPT + vLLM (Hoher Durchsatz)

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

```bash
# Schritt 1: Starten Sie vLLM mit einem Codierungsmodell
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

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

# Schritt 2: Konfigurieren Sie MetaGPT für vLLM
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: Führen Sie MetaGPT aus
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 "Build a complete e-commerce backend with FastAPI and PostgreSQL"
```

> Siehe die [vLLM-Anleitung](/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     | Gutes Gleichgewicht                  |
| 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 zur Codegenerierung, haben jedoch manchmal Schwierigkeiten bei komplexer architektonischer Begründung. Für produktionsreife PRDs und Systementwürfe sollten Sie in der Planungsphase GPT-4o oder Claude verwenden und ein lokales Modell für die Codegenerierung einsetzen.

***

## Tipps & bewährte Methoden

### 1. Schreiben Sie effektive Aufgaben-Prompts

Die Leistung von MetaGPT hängt stark von der Qualität Ihres initialen Prompts ab:

```
✅ Gute Prompts:
"Create a Python REST API using FastAPI that manages a library catalog.
Features: add/search/delete books, user authentication with JWT, 
SQLite database, OpenAPI docs. Target: production-ready with tests."

"Build a CLI data pipeline tool in Python that reads CSV files,
performs statistical analysis, and outputs charts using matplotlib."

❌ Vage Prompts:
"Make a web app"
"Build something with Python"
```

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

```bash
# MetaGPT verarbeitet viele Tokens pro Projekt:
# - Einfaches Skript: ~50K Tokens (~$0.25 mit GPT-4o)
# - Mittlere Webapp: ~200K Tokens (~$1.00 mit GPT-4o)
# - Komplexes System: ~500K+ Tokens (~$2.50+ mit GPT-4o)

# Setzen Sie ein Budget-Limit in der Konfiguration:
# max_budget: 2.0  # Stoppen nach $2 Ausgaben
```

### 3. Überprüfen Sie zuerst das generierte PRD

Verwenden Sie `--human-review` bei wichtigen Projekten. Die PRD-Phase ist der Punkt, an dem Anforderungen festgelegt werden — das Auffinden von Problemen hier spart signifikante Token-Kosten im Vergleich zu Überarbeitungen nach der Codegenerierung.

### 4. Testen Sie den generierten Code

MetaGPT generiert Unit-Tests, aber überprüfen Sie immer:

```bash
# Wechseln Sie in das generierte Projektverzeichnis
cd /opt/metagpt/workspace/<your-project>

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

# Führen Sie die generierten Tests aus
pytest tests/ -v

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

### 5. Verwenden Sie Versionskontrolle

```bash
# Initialisieren Sie git im Workspace
cd /opt/metagpt/workspace
git init
git add .
git commit -m "Initial MetaGPT generation"

# Nach jeder Iteration
git add .
git commit -m "MetaGPT: Added authentication feature"
```

### 6. Batchen Sie mehrere Projekte

Führen Sie mehrere Projekte über Nacht auf Clore.ai für maximalen Nutzen aus:

```bash
#!/bin/bash
# /opt/metagpt/batch-run.sh
PROJECTS=(
  "Create a URL shortener service with Python and Redis"
  "Build a Markdown to PDF converter CLI tool"
  "Create a REST API for a blog with comments and tags"
)

for project in "${PROJECTS[@]}"; do
  echo "Starting: $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 "Completed: $project"
done
```

***

## Fehlerbehebung

### Image-Pull schlägt fehl

```bash
# Wenn das Docker-Hub-Rate-Limit erreicht ist
docker login  # Melden Sie sich mit Ihrem Docker-Hub-Konto an
docker pull metagpt/metagpt:latest

# Überprüfen Sie den verfügbaren Festplattenspeicher
df -h
# Das MetaGPT-Image ist ~3 GB; der Workspace kann auf mehrere GB anwachsen
```

### Konfigurationsdatei nicht gefunden

```bash
# Überprüfen Sie, ob das Pfad-Mapping 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üfen Sie außerdem, ob Ihr YAML gültig ist
python3 -c "import yaml; yaml.safe_load(open('/opt/metagpt/config/config2.yaml'))"
```

### LLM-API-Authentifizierungsfehler

```bash
# Testen Sie Ihren 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 Leerzeichen kopiert
# - Schlüssel abgelaufen oder Kontingent überschritten
# - Falscher api_type in der Konfiguration (z. B. "openai" vs "anthropic")
```

### Ollama-Verbindung vom Container abgelehnt

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

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

# Wenn es weiterhin fehlschlägt, prüfen Sie die Ollama-Logs
docker logs ollama --tail 20
```

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

```bash
# Prüfen Sie, ob das LLM tatsächlich antwortet
# Fügen Sie Debug-Logging hinzu, 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 "Simple task" 2>&1 | tee /opt/metagpt/logs/debug.log

# Häufige Ursachen:
# - Lokales Modell zu langsam (versuchen Sie ein kleineres quantisiertes Modell)
# - API-Rate-Limiting (Fügen Sie Verzögerungen hinzu oder wechseln Sie das Tier)
# - Modell-Kontextfenster überschritten (reduzieren Sie max_auto_summarize_code)
```

### Festplattenspeicher erschöpft

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

# Bereinigen Sie auch den Docker-Build-Cache
docker system prune -f

# Überprüfen Sie die Gesamtbelegung
df -h /opt/metagpt/
```

### "Repair LLM Output"-Schleifen

```bash
# Wenn MetaGPT wegen fehlerhafter LLM-Ausgaben ständig neu versucht:
# 1. Versuchen Sie ein leistungsfähigeres Modell (GPT-4o, Claude Sonnet)
# 2. Reduzieren Sie die Temperatur (auf 0.0 für Determinismus setzen)
# 3. Deaktivieren Sie Repair (wenn Sie ein leistungsfähiges Modell nutzen):
#    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 Docs, 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) — Führen Sie lokale LLMs aus, um MetaGPT kostenlos zu betreiben
* [vLLM auf Clore.ai](/guides/guides_v2-de/sprachmodelle/vllm.md) — Hochdurchsatz-Lokales LLM für MetaGPT im großen Maßstab
* [GPU-Vergleichsanleitung](/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 Programming for a Multi-Agent Collaborative 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:

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

The question should be specific, self-contained, and written in natural language.
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.