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 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:

Produktmanager — Erstellt ein Product Requirements Document (PRD)
Architekt — Entwirft die Systemarchitektur und den Tech-Stack
Projektmanager — Zerlegt Aufgaben und weist sie zu
Ingenieure — Schreiben tatsächlich lauffähigen Code für jede Komponente
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

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.

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:

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

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

Schritt 2: Ziehe das MetaGPT-Docker-Image

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:

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

nano /opt/metagpt/config/config2.yaml

Für OpenAI (GPT-4o):

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):

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):

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

# 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

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

# /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:

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-reviewpausiert MetaGPT nach der PRD- und Systementwurfsphase, sodass du vor Beginn der Implementierung Feedback geben kannst.

Inkrementelle Entwicklung (zu bestehendem Projekt hinzufügen)

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

# 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

# /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"]

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

# 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 für die Modellkonfiguration und GPU-Optimierung.

MetaGPT + vLLM (Hoher Durchsatz)

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

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

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

# 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

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

#!/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

# 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

# Ü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

# 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

# Ü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

# 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

# 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“

# 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 — Quellcode, Beispiele, Roadmap
MetaGPT-Dokumentation — Offizielle Dokumentation, Konfigurationsreferenz, Tutorials
MetaGPT Discord — Community-Support, Anwendungsfälle, Modelltipps
Docker Hub: metagpt/metagpt — Verfügbare Image-Tags
Ollama auf Clore.ai — Lokale LLMs ausführen, um MetaGPT kostenlos zu betreiben
vLLM auf Clore.ai — Lokales LLM mit hohem Durchsatz für MetaGPT im großen Maßstab
GPU-Vergleichsleitfaden — Wählen Sie die richtige Clore.ai-GPU für Ihre Arbeitslast
SWE-bench-Bestenliste — Benchmark für Multi-Agenten-Coding-Frameworks
MetaGPT-Paper — Originalforschung: „MetaGPT: Meta-Programmierung für ein kollaboratives Multi-Agenten-Framework“

VorherigeFlowise KI-Agenten-Builder

NächsteSuperAGI-Agenten-Framework

Zuletzt aktualisiert vor 1 Monat

War das hilfreich?