SWE-agent Code-Fixer

Deploye SWE-agent auf Clore.ai — automatisiere die Lösung von GitHub-Issues und Software-Engineering-Aufgaben mit KI-Agenten und Docker-Sandboxing, mit Unterstützung für Claude, GPT-4 und Open-Source-LLMs.

Überblick

SWE-agent ist ein KI-gestützter Software-Engineering-Agent, der GitHub-Issues automatisch löst indem er ein Sprachmodell über eine Terminal-Schnittstelle mit einem Code-Repository interagieren lässt. Vorgestellt auf NeurIPS 2024 und mit über 15.000 GitHub-Sternen, ist SWE-agent zur führenden Open-Source-Lösung für automatisierte Fehlerbehebung und Code-Reparatur geworden.

Im Gegensatz zu den meisten Tools in dieser Dokumentation benötigt SWE-agent keine GPU — es ruft externe LLM-APIs (Claude, GPT-4, Gemini oder selbst gehostete Modelle) auf, um über Code nachzudenken und Fixes zu generieren. Was es braucht ist eine zuverlässige Docker-Umgebung für sichere, sandboxed Code-Ausführung. Clore.ai's CPU-Server (oder jede gemietete Instanz mit Docker) passen perfekt.

Hauptfunktionen:

• 🐛 Automatisches Lösen von GitHub-Issues mit einem einzigen Befehl

• 🔒 Sandbox-Ausführung in Docker-Containern — sicher zum Ausführen beliebigen Codes

• 🤖 Unterstützt Claude, GPT-4, Gemini, OpenAI-kompatible und lokale Modelle

• 🌐 Web-UI zur Überwachung des Agentenfortschritts

• 🛡️ Cybersecurity-Modus für CTF-Herausforderungen und Penetrationstests

• 📊 SWE-bench-kompatibel — getestet an über 300 echten GitHub-Issues

• 🔧 Konfigurierbare Agentenverhalten über YAML-Konfigurationsdateien

---

Anforderungen

Hardware-Anforderungen

SWE-agent braucht keine GPU — es nutzt API-basierte LLMs zum Gründen:

Tier	CPU	RAM	Speicher	Clore.ai-Preis
Minimum	4 Kerne	8 GB	30 GB SSD	~0,03 $/Std.
Empfohlen	8 Kerne	16 GB	60 GB SSD	~0,06 $/Std.
Hohe Arbeitslasten	16 Kerne	32 GB	100 GB SSD	~0,10 $/Std.
Mit lokalem LLM	GPU-Server	32 GB	100 GB SSD	~$0.20/Stunde

💡 Kosten-Tipp: SWE-agent ist ungewöhnlich günstig auf Clore.ai zu betreiben, da keine GPU benötigt wird. Die Hauptkosten sind die LLM-API-Aufrufe (z. B. kostet Claude Sonnet ~0,003 $/1K Tokens). Ein typischer Issue-Fix kostet 0,50–2,00 $ an API-Gebühren.

Software- & API-Anforderungen

Anforderung	Details
Docker	Erforderlich für sandboxed Code-Ausführung
LLM-API-Schlüssel	Anthropic, OpenAI, Google oder selbst gehostet
GitHub-Token	Zum Zugriff auf private Repos und zum Erstellen von PRs
Python 3.11+	Für pip install sweagent Methode

LLM-API-Preisreferenz

Modell	Eingabe	Ausgabe	Typische Laufkosten
Claude Sonnet 4	3 $/M Tokens	15 $/M Tokens	~1,00–2,00 $
GPT-4o	5 $/M Tokens	15 $/M Tokens	~1,00–3,00 $
GPT-4o mini	0,15 $/M Tokens	0,60 $/M Tokens	~0,05–0,20 $
Ollama (lokal)	Kostenlos	Kostenlos	Nur Clore.ai-Stundenpreis

---

Schnellstart

Schritt 1 — Server auf Clore.ai mieten

1. Melde dich an bei clore.ai

2. Filtern: Docker aktiviert — GPU ist optional (CPU-Server ist ausreichend)

3. Empfohlenes Image: ubuntu:22.04 oder jedes Docker-fähige Image

4. Offene Ports: 22 (SSH), 7860 (SWE-agent Web-UI)

5. Mindestens 16 GB RAM empfohlen für das Ausführen von Docker-in-Docker

Schritt 2 — Verbindung per SSH herstellen

ssh -p <CLORE_SSH_PORT> root@<CLORE_SERVER_IP>

# Überprüfen, ob Docker verfügbar ist
docker --version
docker run --rm hello-world

Schritt 3 — Das SWE-agent Docker-Image ziehen

# Ziehe das offizielle SWE-agent Image (vorgebaut, empfohlen)
docker pull sweagent/swe-agent:latest

# Verifizieren
docker images | grep sweagent

Alternativ aus dem Quellcode bauen für die neueste Entwicklungsvariante:

git clone https://github.com/SWE-agent/SWE-agent.git
cd SWE-agent
docker build -t sweagent/swe-agent:local .

Schritt 4 — API-Schlüssel einrichten

# Erstelle ein Verzeichnis für SWE-agent-Konfiguration
mkdir -p /workspace/sweagent && cd /workspace/sweagent

# Erstelle Umgebungsdatei mit deinen API-Schlüsseln
cat > /workspace/sweagent/.env << 'EOF'
# LLM-API-Schlüssel (füge nur hinzu, was du hast)
ANTHROPIC_API_KEY=sk-ant-...
OPENAI_API_KEY=sk-...
GOOGLE_API_KEY=...

# GitHub-Token zum Zugriff auf Repos und zum Erstellen von PRs
GITHUB_TOKEN=ghp_...

# Optional: selbst gehosteter LLM-Endpunkt
# OPENAI_BASE_URL=http://your-ollama-server:11434/v1
EOF

chmod 600 /workspace/sweagent/.env

Schritt 5 — Dein erstes GitHub-Issue beheben

# Basisverwendung — behebe ein GitHub-Issue mit Claude Sonnet
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /workspace/sweagent/output:/output \
  -v /var/run/docker.sock:/var/run/docker.sock \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=claude-sonnet-4-20250514 \
    --agent.model.per_instance_cost_limit=2.00 \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/1 \
    --actions.apply_patch_locally=true \
    --output_dir=/output

Schritt 6 — Die Ausgabe prüfen

# SWE-agent schreibt Ergebnisse in das Ausgabe-Verzeichnis
ls -la /workspace/sweagent/output/

# Den generierten Patch anzeigen
cat /workspace/sweagent/output/*.patch

# Die vollständige Agenten-Trajektorie anzeigen (was der Agent getan hat)
cat /workspace/sweagent/output/*.traj | python3 -m json.tool | less

---

Konfiguration

Basis-Konfigurationsdatei

Anstelle langer Kommandozeilen-Flags nutze eine YAML-Konfig:

cat > /workspace/sweagent/config.yaml << 'EOF'
# SWE-agent Konfiguration
agent:
  model:
    name: claude-sonnet-4-20250514
    per_instance_cost_limit: 2.00
    total_cost_limit: 10.00
    temperature: 0.0
  config:
    # System-Prompt für den Agenten
    system_template: "default"
    # Wie viele Wiederholungen bei API-Fehlern
    retry_with_output_if_run_fails: true

env:
  repo:
    # Wird pro Lauf gesetzt
    github_url: ""
  deployment:
    docker_args:
      - "--memory=4g"
      - "--cpus=2"

problem_statement:
  github_url: ""

actions:
  apply_patch_locally: true
  open_pr: false  # Auf true setzen, um automatisch einen PR zu erstellen

output_dir: /output
EOF

# Mit Konfigurationsdatei ausführen
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /workspace/sweagent/output:/output \
  -v /workspace/sweagent/config.yaml:/config.yaml \
  -v /var/run/docker.sock:/var/run/docker.sock \
  sweagent/swe-agent:latest \
  python run.py \
    --config /config.yaml \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/42

Web-UI-Modus

SWE-agent enthält eine Gradio-basierte Web-Oberfläche für interaktive Nutzung:

# Starte die Web-UI
docker run -d \
  --name sweagent-ui \
  --env-file /workspace/sweagent/.env \
  -p 7860:7860 \
  -v /workspace/sweagent/output:/output \
  -v /var/run/docker.sock:/var/run/docker.sock \
  sweagent/swe-agent:latest \
  python app.py --port 7860 --host 0.0.0.0

# Auf die UI zugreifen
echo "Öffnen: http://<CLORE_SERVER_IP>:<MAPPED_PORT>"
docker logs -f sweagent-ui

Verwendung verschiedener LLM-Anbieter

# GPT-4o (OpenAI)
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /workspace/sweagent/output:/output \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=gpt-4o-2024-11-20 \
    --agent.model.per_instance_cost_limit=3.00 \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/1

# GPT-4o Mini (Budget-Option)
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /workspace/sweagent/output:/output \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=gpt-4o-mini-2024-07-18 \
    --agent.model.per_instance_cost_limit=0.50 \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/1

# Lokales Ollama (in Verbindung mit Ollama-Anleitung)
# Zuerst Ollama auf einem GPU-Server bereitstellen (siehe ../language-models/ollama.md)
# Dann als Backend für SWE-agent verwenden:
docker run --rm \
  -e OPENAI_API_KEY=dummy \
  -e OPENAI_BASE_URL=http://<OLLAMA_HOST>:11434/v1 \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /workspace/sweagent/output:/output \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=qwen2.5-coder:32b \
    --agent.model.per_instance_cost_limit=0.00 \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/1

Stapelverarbeitung mehrerer Issues

# Verarbeite mehrere Issues im SWE-bench-Format
cat > /workspace/sweagent/batch_issues.json << 'EOF'
[
  {
    "repo": "USER/REPO",
    "issue_number": 1,
    "model": "claude-sonnet-4-20250514"
  },
  {
    "repo": "USER/REPO",
    "issue_number": 2,
    "model": "claude-sonnet-4-20250514"
  }
]
EOF

# Batch-Run-Skript
cat > /workspace/sweagent/run_batch.sh << 'BASH'
#!/bin/bash
set -e

ISSUES_FILE="${1:-/workspace/sweagent/batch_issues.json}"
OUTPUT_DIR="/workspace/sweagent/output"
ENV_FILE="/workspace/sweagent/.env"

echo "Starte batch SWE-agent Lauf..."
python3 -c "
import json
issues = json.load(open('$ISSUES_FILE'))
for i, issue in enumerate(issues):
    print(f'Issue {i+1}/{len(issues)}: {issue[\"repo\"]}#{issue[\"issue_number\"]}')
" 

jq -c '.[]' "$ISSUES_FILE" | while read issue; do
    REPO=$(echo "$issue" | jq -r '.repo')
    ISSUE_NUM=$(echo "$issue" | jq -r '.issue_number')
    MODEL=$(echo "$issue" | jq -r '.model')

    echo "=== Verarbeite: $REPO#$ISSUE_NUM mit $MODEL ==="
    
    docker run --rm \
      --env-file "$ENV_FILE" \
      -v "$OUTPUT_DIR:/output" \
      -v /var/run/docker.sock:/var/run/docker.sock \
      sweagent/swe-agent:latest \
      python run.py \
        --agent.model.name="$MODEL" \
        --agent.model.per_instance_cost_limit=2.00 \
        --env.repo.github_url="https://github.com/$REPO" \
        --problem_statement.github_url="https://github.com/$REPO/issues/$ISSUE_NUM" \
        --output_dir=/output || echo "FEHLGESCHLAGEN: $REPO#$ISSUE_NUM"
done

echo "Batch abgeschlossen. Ergebnisse in $OUTPUT_DIR"
BASH

chmod +x /workspace/sweagent/run_batch.sh
/workspace/sweagent/run_batch.sh

---

Docker-in-Docker Einrichtung

SWE-agent führt Code in verschachtelten Docker-Containern aus für Sicherheit. Dies erfordert Zugriff auf den Docker-Socket:

# Verifiziere, dass der Docker-Socket zugänglich ist
ls -la /var/run/docker.sock

# Teste, dass Docker-in-Docker funktioniert
docker run --rm \
  -v /var/run/docker.sock:/var/run/docker.sock \
  docker:latest docker run --rm hello-world

# SWE-agent wird automatisch sein Sandbox-Image ziehen
# Standard-Sandbox: sweagent/swe-agent:latest (oder ein spezialisiertes Env-Image)

Sicherheitsüberlegungen

# SWE-agent Sandbox-Ressourcenlimits (in deiner YAML konfigurieren)
cat >> /workspace/sweagent/config.yaml << 'EOF'
env:
  deployment:
    docker_args:
      - "--memory=4g"          # Sandbox-RAM begrenzen
      - "--cpus=2"             # Sandbox-CPU begrenzen
      - "--network=bridge"     # Isoliertes Netzwerk
      - "--read-only"          # Nur-Lese-Dateisystem (mit Ausnahmen)
      - "--tmpfs=/tmp:size=1g" # Schreibbares /tmp nur
EOF

# Führe SWE-agent niemals direkt auf dem Host aus — immer Docker verwenden
# Der Sandbox-Container isoliert potenziell schädlichen Code

Verwendung eines vorgefertigten Environment-Images

# SWE-agent unterstützt benutzerdefinierte Environment-Images pro Repository
# Das beschleunigt Läufe durch vorinstallierte Abhängigkeiten
cat > /workspace/sweagent/env-config.yaml << 'EOF'
env:
  deployment:
    image: sweagent/swe-agent:latest
    pre_install:
      - "pip install -e ."
      - "pip install pytest"
    post_clone:
      - "git config --global user.email '[e-mail]'"
      - "git config --global user.name 'SWE-agent'"
EOF

---

Tipps & bewährte Methoden

🎯 Effektive Problemstellungen schreiben

Die Qualität der Fixes von SWE-agent hängt stark von der Issue-Beschreibung ab:

# Methode 1: Verwende eine GitHub-Issue-URL (empfohlen)
--problem_statement.github_url=https://github.com/USER/REPO/issues/42

# Methode 2: Stelle eine Textdatei mit detaillierter Beschreibung bereit
cat > /workspace/sweagent/issue.txt << 'EOF'
## Fehlerbeschreibung
Die Funktion `calculate_total()` in `billing/calculator.py` gibt 0 zurück 
wenn der Rabatt genau 100% beträgt. 

## Schritte zum Reproduzieren
```python
total = calculate_total(price=100, discount=100)
assert total == 0  # Das schlägt fehl, gibt stattdessen 100 zurück

Erwartetes Verhalten

Sollte 0 zurückgeben, wenn der Rabatt 100% beträgt.

Relevanter Code

Siehe billing/calculator.py Zeilen 45-67. EOF

docker run --rm --env-file /workspace/sweagent/.env -v /workspace/sweagent/output:/output -v /workspace/sweagent/issue.txt:/issue.txt -v /var/run/docker.sock:/var/run/docker.sock sweagent/swe-agent:latest python run.py --agent.model.name=claude-sonnet-4-20250514 --env.repo.github_url=https://github.com/USER/REPO --problem_statement.text_file=/issue.txt

### 💰 Kostenkontrolle

```bash
# Setze stets Per-Instance-Kostenlimits
--agent.model.per_instance_cost_limit=2.00  # Max. 2 $ pro Issue

# Verwende GPT-4o mini für erste Triage, Claude für komplexe Fixes
# Budgetstrategie: ~0,10 $ zum Scannen, ~1,50 $ zum Beheben

# Überwache Kosten in Echtzeit
docker logs -f sweagent-ui | grep -E "(cost|tokens|spent)"

# Setze ein Gesamtbudget für alle Läufe
--agent.model.total_cost_limit=20.00  # Stoppt alle Läufe nach 20 $

🔄 Auto-PR Erstellung

# Automatisch einen Pull Request mit dem Fix erstellen
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /workspace/sweagent/output:/output \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=claude-sonnet-4-20250514 \
    --agent.model.per_instance_cost_limit=2.00 \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/42 \
    --actions.open_pr=true \
    --actions.push_gh_repo_url=https://github.com/USER/REPO

📊 SWE-bench Bewertung

# Führe SWE-agent gegen das offizielle SWE-bench-Benchmark aus
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /workspace/sweagent/output:/output \
  sweagent/swe-agent:latest \
  python run_batch.py \
    --agent.model.name=claude-sonnet-4-20250514 \
    --env.repo.github_url=https://github.com/USER/REPO \
    --instances.type=swe_bench \
    --instances.subset=lite \
    --instances.split=test \
    --output_dir=/output \
    --num_workers=4

🛡️ Cybersecurity-Modus

# SWE-agent unterstützt CTF- und Cybersecurity-Herausforderungen
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /workspace/sweagent/output:/output \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=claude-sonnet-4-20250514 \
    --agent.config=config/default_from_url_ctf.yaml \
    --env.deployment.image=sweagent/ctf-env:latest \
    --problem_statement.text="Finde die Flagge im laufenden Webdienst unter http://challenge.local:8080" \
    --output_dir=/output

---

Fehlerbehebung

Docker-Socket: Zugriff verweigert

# Fehler: Zugriff verweigert beim Verbinden mit dem Docker-Daemon
# Lösung: Stelle sicher, dass der Docker-Socket korrekt gemountet ist

docker run --rm \
  -v /var/run/docker.sock:/var/run/docker.sock \
  sweagent/swe-agent:latest \
  docker ps

# Wenn du Berechtigungsfehler siehst, überprüfe die Socket-Berechtigungen
ls -la /var/run/docker.sock
# Sollte sein: srw-rw---- root docker

# Füge den aktuellen Benutzer zur docker-Gruppe hinzu (falls nicht root)
usermod -aG docker $USER
newgrp docker

API-Schlüssel-Fehler

# Überprüfe, ob dein API-Schlüssel korrekt gesetzt ist
docker run --rm \
  --env-file /workspace/sweagent/.env \
  sweagent/swe-agent:latest \
  python -c "
import os
keys = ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'GITHUB_TOKEN']
for k in keys:
    val = os.environ.get(k, 'NOT SET')
    masked = val[:8] + '...' if len(val) > 8 else val
    print(f'{k}: {masked}')
"

# Anthropic-API-Schlüssel testen
curl https://api.anthropic.com/v1/models \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01"

Agent steckt in einer Schleife fest

# SWE-agent hat ein eingebautes Schritt-Limit (Standard ~100 Schritte)
# Erhöhe oder verringere es über die Konfiguration:

docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /var/run/docker.sock:/var/run/docker.sock \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=claude-sonnet-4-20250514 \
    --agent.model.per_instance_cost_limit=2.00 \
    --agent.max_requeries=5 \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/1

# Einen feststeckenden Lauf beenden
docker ps | grep sweagent
docker stop <container_id>

Speicher-Fehler während der Code-Ausführung

# Erhöhe das Sandbox-Speicherlimit
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /workspace/sweagent/output:/output \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=claude-sonnet-4-20250514 \
    --env.deployment.docker_args='["--memory=8g", "--cpus=4"]' \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/1

# Für große Codebasen die Clore.ai-Instanz auf 32 GB RAM erhöhen

GitHub-Ratenbegrenzung

# Die GitHub-API hat Ratenbegrenzungen — verwende ein Personal Access Token mit repo-Berechtigungen
# Überprüfe deinen aktuellen Ratenlimit-Status
curl -H "Authorization: token $GITHUB_TOKEN" \
  https://api.github.com/rate_limit | jq '.rate'

# Wenn du ratenbegrenzt bist, warte auf das Reset oder verwende ein anderes Token
# Das Ratenlimit setzt sich stündlich zurück

---

Weiterführende Lektüre

• SWE-agent GitHub — Haupt-Repository und Docs

• SWE-agent Dokumentation — Offizielle Dokumentation

• SWE-agent Paper (NeurIPS 2024) — Forschungspapier

• SWE-bench Bestenliste — Sieh, wie verschiedene Modelle abschneiden

• Clore.ai Erste Schritte — Plattform-Grundlagen

• GPU-Vergleichsanleitung — Falls du eine GPU für lokale LLMs benötigst

• Ollama auf Clore.ai ausführen — Lokales LLM-Backend für SWE-agent

• vLLM auf Clore.ai ausführen — Hochdurchsatz lokaler LLM-Server

• Anthropic API Preise — Claude API-Kosten

• OpenAI API Preise — GPT-4 API-Kosten

💡 Clore.ai + SWE-agent Sweet Spot: Miete einen CPU-only Server (4 Kerne, 16 GB RAM) für ~0,05 $/Std., betreibe SWE-agent mit Claude Sonnet 4 und behebe GitHub-Issues für ungefähr 1–2 $ insgesamt pro Issue (API-Kosten) plus ein paar Cent Clore.ai-Zeit. Für Teams mit vielen Issues ist das gegenüber der Einstellung eines Entwicklers für routinemäßige Fehlerbehebungen um Größenordnungen günstiger.