MetaGPT Softwareunternehmen

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

Überblick

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.

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:

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

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:

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

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

# 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

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

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

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)

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

# 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

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

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

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

MetaGPT + vLLM (Hoher Durchsatz)

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

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

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

# 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

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

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

# 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

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

# 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

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

# 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

# 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

# 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 — Quellcode, Beispiele, Roadmap

• MetaGPT Dokumentation — Offizielle Docs, Konfigurationsreferenz, Tutorials

• MetaGPT Discord — Community-Support, Anwendungsfälle, Modelltipps

• Docker Hub: metagpt/metagpt — Verfügbare Image-Tags

• Ollama auf Clore.ai — Führen Sie lokale LLMs aus, um MetaGPT kostenlos zu betreiben

• vLLM auf Clore.ai — Hochdurchsatz-Lokales LLM für MetaGPT im großen Maßstab

• GPU-Vergleichsanleitung — 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 Programming for a Multi-Agent Collaborative Framework"