Correcteur de code SWE-agent

Déployez SWE-agent sur Clore.ai — automatisez la résolution d'incidents GitHub et les tâches d'ingénierie logicielle à l'aide d'agents IA avec sandbox Docker, prenant en charge Claude, GPT-4 et des LLM open source.

Aperçu

SWE-agent est un agent d'ingénierie logicielle propulsé par l'IA qui résout automatiquement des issues GitHub en laissant un modèle de langage interagir avec un dépôt de code via une interface terminal. Présenté à NeurIPS 2024 et avec plus de 15 000 étoiles GitHub, SWE-agent est devenu la solution open-source leader pour la correction automatique de bugs et la réparation de code.

Contrairement à la plupart des outils dans cette documentation, SWE-agent ne nécessite pas de GPU — il appelle des API LLM externes (Claude, GPT-4, Gemini, ou des modèles auto-hébergés) pour raisonner sur le code et générer des correctifs. Ce dont il a besoin, c'est d'un environnement Docker fiable pour exécuter du code de manière sûre et isolée. Les serveurs CPU de Clore.ai (ou toute instance louée avec Docker) conviennent parfaitement.

Fonctionnalités clés :

• 🐛 Résolution automatisée d'issues GitHub en une seule commande

• 🔒 Exécution sandboxée à l'intérieur de conteneurs Docker — sûr pour exécuter du code arbitraire

• 🤖 Prend en charge Claude, GPT-4, Gemini, les modèles compatibles OpenAI et les modèles locaux

• 🌐 Interface Web pour surveiller la progression de l'agent

• 🛡️ Mode cybersécurité pour les challenges CTF et les tests d'intrusion

• 📊 Compatible SWE-bench — testé sur plus de 300 issues GitHub réelles

• 🔧 Comportements de l'agent configurables via des fichiers YAML

---

Exigences

Exigences matérielles

SWE-agent n'a pas besoin de GPU — il utilise des LLM basés sur des API pour le raisonnement :

Niveau	CPU	RAM	Stockage	Prix Clore.ai
Minimum	4 cœurs	8 Go	30 Go SSD	~0,03 $/h
Recommandé	8 cœurs	16 Go	60 Go SSD	~0,06 $/h
Charges lourdes	16 cœurs	32 Go	100 Go SSD	~0,10 $/h
Avec LLM local	Serveur GPU	32 Go	100 Go SSD	~0,20 $/h

💡 Conseil sur les coûts : SWE-agent est étonnamment peu coûteux à exécuter sur Clore.ai puisque vous n'avez pas besoin de GPU. Le coût principal provient des appels API LLM (par exemple, Claude Sonnet coûte environ 0,003 $/1K tokens). Une correction d'issue typique coûte entre 0,50 $ et 2,00 $ en frais d'API.

Logiciels et exigences d'API

Exigence	Détails
Docker	Requis pour l'exécution sandboxée du code
Clé API LLM	Anthropic, OpenAI, Google, ou auto-hébergé
Token GitHub	Pour accéder aux dépôts privés et créer des PR
Python 3.11+	Pour pip install sweagent méthode

Référence de tarification des API LLM

Modèle	Entrée	Sortie	Coût typique d'exécution
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 (local)	Gratuit	Gratuit	Coût horaire Clore.ai seulement

---

Démarrage rapide

Étape 1 — Louer un serveur sur Clore.ai

1. Connectez-vous à clore.ai

2. Filtrer : Docker activé — le GPU est optionnel (un serveur CPU suffit)

3. Image recommandée : ubuntu:22.04 ou toute image avec Docker activé

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

5. 16 Go de RAM minimum recommandés pour exécuter Docker-in-Docker

Étape 2 — Se connecter via SSH

ssh -p <CLORE_SSH_PORT> root@<CLORE_SERVER_IP>

# Vérifier que Docker est disponible
docker --version
docker run --rm hello-world

Étape 3 — Pull de l'image Docker SWE-agent

# Récupérer l'image officielle SWE-agent (pré-construite, recommandée)
docker pull sweagent/swe-agent:latest

# Vérifier
docker images | grep sweagent

Alternativement, construire depuis la source pour la dernière version de développement :

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

Étape 4 — Configurer les clés API

# Créer un répertoire pour la configuration de SWE-agent
mkdir -p /workspace/sweagent && cd /workspace/sweagent

# Créer le fichier d'environnement avec vos clés API
cat > /workspace/sweagent/.env << 'EOF'
# Clés API LLM (ajoutez uniquement ce que vous possédez)
ANTHROPIC_API_KEY=sk-ant-...
OPENAI_API_KEY=sk-...
GOOGLE_API_KEY=...

# Token GitHub pour accéder aux repos et créer des PR
GITHUB_TOKEN=ghp_...

# Optionnel : endpoint LLM auto-hébergé
# OPENAI_BASE_URL=http://votre-serveur-ollama:11434/v1
EOF

chmod 600 /workspace/sweagent/.env

Étape 5 — Corriger votre première issue GitHub

# Utilisation basique — corriger une issue GitHub avec 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

Étape 6 — Examiner la sortie

# SWE-agent écrit les résultats dans le répertoire de sortie
ls -la /workspace/sweagent/output/

# Voir le patch généré
cat /workspace/sweagent/output/*.patch

# Voir la trajectoire complète de l'agent (ce que l'agent a fait)
cat /workspace/sweagent/output/*.traj | python3 -m json.tool | less

---

Configuration

Fichier de configuration basique

Au lieu de longs flags en ligne de commande, utilisez un config YAML :

cat > /workspace/sweagent/config.yaml << 'EOF'
# Configuration de SWE-agent
agent :
  model :
    name: claude-sonnet-4-20250514
    per_instance_cost_limit: 2.00
    total_cost_limit: 10.00
    temperature: 0.0
  config :
    # Prompt système pour l'agent
    system_template: "default"
    # Nombre de tentatives en cas d'erreurs d'API
    retry_with_output_if_run_fails: true

env :
  repo :
    # Sera défini par exécution
    github_url: ""
  deployment :
    docker_args :
      - "--memory=4g"
      - "--cpus=2"

problem_statement :
  github_url: ""

actions :
  apply_patch_locally: true
  open_pr: false  # Mettre à true pour créer automatiquement une PR

output_dir: /output
EOF

# Exécuter avec le fichier de config
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

Mode UI Web

SWE-agent inclut une interface Web basée sur Gradio pour une utilisation interactive :

# Démarrer l'UI web
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

# Accéder à l'UI
echo "Ouvrir : http://<CLORE_SERVER_IP>:<MAPPED_PORT>"
docker logs -f sweagent-ui

Utiliser différents fournisseurs LLM

# 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 (option économique)
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

# Ollama local (associer avec le guide Ollama)
# Déployer d'abord Ollama sur un serveur GPU (voir ../language-models/ollama.md)
# Puis l'utiliser comme backend pour SWE-agent :
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

Traitement par lot de plusieurs issues

# Traiter plusieurs issues en utilisant le format SWE-bench
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

# Script d'exécution par lot
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 "Démarrage d'une exécution batch de SWE-agent..."
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 "=== Traitement : $REPO#$ISSUE_NUM avec $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 "ÉCHOUÉ : $REPO#$ISSUE_NUM"
done

echo "Batch terminé. Résultats dans $OUTPUT_DIR"
BASH

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

---

Configuration Docker-in-Docker

SWE-agent exécute le code dans des conteneurs Docker imbriqués pour la sécurité. Cela requiert l'accès au socket Docker :

# Vérifier que le socket Docker est accessible
ls -la /var/run/docker.sock

# Tester que Docker-in-Docker fonctionne
docker run --rm \
  -v /var/run/docker.sock:/var/run/docker.sock \
  docker:latest docker run --rm hello-world

# SWE-agent téléchargera automatiquement son image sandbox
# Sandbox par défaut : sweagent/swe-agent:latest (ou une image d'environnement spécialisée)

Considérations de sécurité

# Limites de ressources du sandbox SWE-agent (configurer dans votre YAML)
cat >> /workspace/sweagent/config.yaml << 'EOF'
env :
  deployment :
    docker_args :
      - "--memory=4g"          # Limiter la RAM du sandbox
      - "--cpus=2"             # Limiter le CPU du sandbox
      - "--network=bridge"     # Réseau isolé
      - "--read-only"          # Système de fichiers en lecture seule (avec exceptions)
      - "--tmpfs=/tmp:size=1g" # /tmp writable seulement
EOF

# Ne lancez jamais SWE-agent directement sur votre hôte — utilisez toujours Docker
# Le conteneur sandbox isole le code potentiellement dangereux

Utiliser une image d'environnement pré-construite

# SWE-agent prend en charge des images d'environnement personnalisées par dépôt
# Cela accélère les exécutions en pré-installant les dépendances
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

---

Conseils et bonnes pratiques

🎯 Rédiger des énoncés de problème efficaces

La qualité de la correction de SWE-agent dépend fortement de la description de l'issue :

# Méthode 1 : Utiliser une URL d'issue GitHub (recommandé)
--problem_statement.github_url=https://github.com/USER/REPO/issues/42

# Méthode 2 : Fournir un fichier texte avec une description détaillée
cat > /workspace/sweagent/issue.txt << 'EOF'
## Description du bug
La fonction `calculate_total()` dans `billing/calculator.py` renvoie 0 
lorsque la remise est exactement de 100 %. 

## Étapes pour reproduire
```python
total = calculate_total(price=100, discount=100)
assert total == 0  # Ceci échoue, retourne 100 à la place

Comportement attendu

Doit renvoyer 0 lorsque la remise est de 100 %.

Code pertinent

Voir billing/calculator.py lignes 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

### 💰 Contrôle des coûts

```bash
# Toujours définir des limites de coût par instance
--agent.model.per_instance_cost_limit=2.00  # Max 2 $ par issue

# Utiliser GPT-4o mini pour le tri initial, Claude pour les corrections complexes
# Stratégie budgétaire : ~0,10 $ pour scanner, ~1,50 $ pour corriger

# Surveiller les coûts en temps réel
docker logs -f sweagent-ui | grep -E "(cost|tokens|spent)"

# Définir un budget total pour toutes les exécutions
--agent.model.total_cost_limit=20.00  # Arrêter toutes les exécutions après 20 $

🔄 Création automatique de PR

# Créer automatiquement une pull request avec le correctif
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

📊 Évaluation SWE-bench

# Exécuter SWE-agent contre le benchmark officiel SWE-bench
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

🛡️ Mode cybersécurité

# SWE-agent prend en charge les challenges CTF et la cybersécurité
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="Trouvez le flag dans le service web en cours d'exécution à http://challenge.local:8080" \
    --output_dir=/output

---

Dépannage

Permission refusée sur le socket Docker

# Erreur : permission refusée lors de la tentative de connexion au daemon Docker
# Solution : vérifier que le socket Docker est monté correctement

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

# Si vous voyez des erreurs de permission, vérifiez les permissions du socket
ls -la /var/run/docker.sock
# Devrait être : srw-rw---- root docker

# Ajouter l'utilisateur courant au groupe docker (si pas root)
usermod -aG docker $USER
newgrp docker

Erreurs de clé API

# Vérifiez que votre clé API est définie correctement
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}')
"

# Tester la clé API Anthropic
curl https://api.anthropic.com/v1/models \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01"

L'agent est bloqué dans une boucle

# SWE-agent dispose d'une limite d'étapes intégrée (par défaut ~100 étapes)
# Augmenter ou diminuer via la config :

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

# Tuer une exécution bloquée
docker ps | grep sweagent
docker stop <container_id>

Manque de mémoire pendant l'exécution du code

# Augmenter la limite de mémoire du sandbox
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

# Pour de grands codebases, augmentez l'instance Clore.ai à 32 Go de RAM

Limitation de débit GitHub

# L'API GitHub a des limites de débit — utilisez un token d'accès personnel avec le scope repo
# Vérifiez votre statut de limite de débit actuel
curl -H "Authorization: token $GITHUB_TOKEN" \
  https://api.github.com/rate_limit | jq '.rate'

# Si vous êtes limité, attendez la réinitialisation ou utilisez un autre token
# La limite de débit se réinitialise chaque heure

---

Lectures complémentaires

• SWE-agent GitHub — Dépôt principal et docs

• Documentation SWE-agent — Documentation officielle

• Article SWE-agent (NeurIPS 2024) — Article de recherche

• Leaderboard SWE-bench — Voir comment différents modèles performent

• Clore.ai Démarrage — Bases de la plateforme

• Guide de comparaison GPU — Si vous avez besoin de GPU pour des LLM locaux

• Exécuter Ollama sur Clore.ai — Backend LLM local pour SWE-agent

• Exécuter vLLM sur Clore.ai — Serveur LLM local à haut débit

• Tarification API Anthropic — Coûts de l'API Claude

• Tarification API OpenAI — Coûts de l'API GPT-4

💡 Point fort Clore.ai + SWE-agent : Louez un serveur CPU-only (4 cœurs, 16 Go de RAM) à ~0,05 $/h, exécutez SWE-agent avec Claude Sonnet 4, et corrigez des issues GitHub pour environ 1–2 $ au total par issue (coûts API) plus quelques centimes de temps Clore.ai. Pour des équipes avec beaucoup d'issues, cela bat l'embauche d'un développeur pour des corrections routinières de plusieurs ordres de grandeur.