# 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](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/gpu-comparison).

**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](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama) 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](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm) 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](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama) — Führen Sie lokale LLMs aus, um MetaGPT kostenlos zu betreiben
* [vLLM auf Clore.ai](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm) — Hochdurchsatz-Lokales LLM für MetaGPT im großen Maßstab
* [GPU-Vergleichsanleitung](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/gpu-comparison) — 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"