> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/plateformes-et-agents-ia/swe-agent.md).

# Correcteur de code SWE-agent

## Aperçu

[SWE-agent](https://github.com/SWE-agent/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](https://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

```bash
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

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

```bash
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

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

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

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

```bash
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
```

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

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

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

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

```bash
# 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é

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

```bash
# 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 'agent@sweagent.ai'"
      - "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 :

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

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

```bash
# 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é

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

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

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

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

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

```bash
# 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](https://github.com/SWE-agent/SWE-agent) — Dépôt principal et docs
* [Documentation SWE-agent](https://swe-agent.com/docs/) — Documentation officielle
* [Article SWE-agent (NeurIPS 2024)](https://arxiv.org/abs/2405.15793) — Article de recherche
* [Leaderboard SWE-bench](https://www.swebench.com/) — Voir comment différents modèles performent
* [Clore.ai Démarrage](/guides/guides_v2-fr/prise-en-main/getting-started.md) — Bases de la plateforme
* [Guide de comparaison GPU](/guides/guides_v2-fr/prise-en-main/gpu-comparison.md) — Si vous avez besoin de GPU pour des LLM locaux
* [Exécuter Ollama sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/ollama.md) — Backend LLM local pour SWE-agent
* [Exécuter vLLM sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/vllm.md) — Serveur LLM local à haut débit
* [Tarification API Anthropic](https://www.anthropic.com/pricing) — Coûts de l'API Claude
* [Tarification API OpenAI](https://openai.com/api/pricing/) — 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.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/plateformes-et-agents-ia/swe-agent.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.