SWE-agent Corrector de código

Despliega SWE-agent en Clore.ai: automatiza la resolución de issues de GitHub y tareas de ingeniería de software usando agentes de IA con sandboxing de Docker, compatible con Claude, GPT-4 y LLMs de código abierto.

Resumen

SWE-agent es un agente de ingeniería de software impulsado por IA que resuelve automáticamente problemas de GitHub permitiendo que un modelo de lenguaje interactúe con un repositorio de código a través de una interfaz de terminal. Presentado en NeurIPS 2024 y con más de 15,000 estrellas en GitHub, SWE-agent se ha convertido en la solución de código abierto líder para corrección automática de errores y reparación de código.

A diferencia de la mayoría de las herramientas en esta documentación, SWE-agent no requiere GPU — llama a APIs externas de LLM (Claude, GPT-4, Gemini o modelos autohospedados) para razonar sobre el código y generar correcciones. Lo que sí necesita es un entorno Docker fiable para la ejecución de código segura y en sandbox. Los servidores CPU de Clore.ai (o cualquier instancia alquilada con Docker) son una opción perfecta.

Características clave:

• 🐛 Resolución automatizada de issues de GitHub con un solo comando

• 🔒 Ejecución en sandbox dentro de contenedores Docker — seguro para ejecutar código arbitrario

• 🤖 Compatible con Claude, GPT-4, Gemini, OpenAI-compatible y modelos locales

• 🌐 Interfaz web para monitorizar el progreso del agente

• 🛡️ Modo de ciberseguridad para desafíos CTF y pruebas de penetración

• 📊 Compatible con SWE-bench — probado contra más de 300 issues reales de GitHub

• 🔧 Comportamientos del agente configurables mediante archivos YAML

---

Requisitos

Requisitos de hardware

SWE-agent no necesita GPU — utiliza LLMs basados en API para razonar:

Nivel	CPU	RAM	Almacenamiento	Precio de Clore.ai
Mínimo	4 núcleos	8 GB	30 GB SSD	~$0.03/h
Recomendado	8 núcleos	16 GB	60 GB SSD	~$0.06/h
Cargas de trabajo intensas	16 núcleos	32 GB	100 GB SSD	~$0.10/h
Con LLM local	Servidor con GPU	32 GB	100 GB SSD	~$0.20/h

💡 Consejo de coste: SWE-agent es inusualmente barato de ejecutar en Clore.ai ya que no necesitas GPU. El coste principal son las llamadas a la API del LLM (por ejemplo, Claude Sonnet cuesta ~ $0.003/1K tokens). Una corrección típica de un issue cuesta $0.50–$2.00 en tarifas de API.

Requisitos de software y API

Requisito	Detalles
Docker	Requerido para la ejecución de código en sandbox
Clave API de LLM	Anthropic, OpenAI, Google o autohospedado
Token de GitHub	Para acceder a repositorios privados y crear PRs
Python 3.11+	Para pip install sweagent método

Referencia de precios de API de LLM

Modelo	Entrada	Salida	Coste típico de ejecución
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)	Gratis	Gratis	Solo coste por hora de Clore.ai

---

Inicio rápido

Paso 1 — Alquila un servidor en Clore.ai

1. Inicia sesión en clore.ai

2. Filtrar: Docker habilitado — La GPU es opcional (un servidor CPU está bien)

3. Imagen recomendada: ubuntu:22.04 o cualquier imagen con Docker habilitado

4. Puertos abiertos: 22 (SSH), 7860 (Interfaz web de SWE-agent)

5. Se recomienda un mínimo de 16 GB de RAM para ejecutar Docker-in-Docker

Paso 2 — Conectar vía SSH

ssh -p <CLORE_SSH_PORT> root@<CLORE_SERVER_IP>

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

Paso 3 — Descargar la imagen Docker de SWE-agent

# Descargar la imagen oficial de SWE-agent (preconstruida, recomendada)
docker pull sweagent/swe-agent:latest

# Verificar
docker images | grep sweagent

Alternativamente, compilar desde la fuente para la versión de desarrollo más reciente:

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

Paso 4 — Configurar las claves API

# Crear un directorio para la configuración de SWE-agent
mkdir -p /workspace/sweagent && cd /workspace/sweagent

# Crear archivo de entorno con tus claves API
cat > /workspace/sweagent/.env << 'EOF'
# Claves API de LLM (añade solo las que tengas)
ANTHROPIC_API_KEY=sk-ant-...
OPENAI_API_KEY=sk-...
GOOGLE_API_KEY=...

# Token de GitHub para acceder a repos y crear PRs
GITHUB_TOKEN=ghp_...

# Opcional: endpoint de LLM autohospedado
# OPENAI_BASE_URL=http://your-ollama-server:11434/v1
EOF

chmod 600 /workspace/sweagent/.env

Paso 5 — Arregla tu primer issue de GitHub

# Uso básico — arregla un issue de GitHub con 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

Paso 6 — Revisar la salida

# SWE-agent escribe los resultados en el directorio de salida
ls -la /workspace/sweagent/output/

# Ver el parche generado
cat /workspace/sweagent/output/*.patch

# Ver la trayectoria completa del agente (lo que hizo el agente)
cat /workspace/sweagent/output/*.traj | python3 -m json.tool | less

---

Configuración

Archivo de configuración básico

En lugar de largas banderas de línea de comandos, usa un archivo YAML:

cat > /workspace/sweagent/config.yaml << 'EOF'
# Configuración 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:
    # Plantilla de sistema para el agente
    system_template: "default"
    # Cuántos reintentos ante errores de API
    retry_with_output_if_run_fails: true

env:
  repo:
    # Se establecerá por ejecución
    github_url: ""
  deployment:
    docker_args:
      - "--memory=4g"
      - "--cpus=2"

problem_statement:
  github_url: ""

actions:
  apply_patch_locally: true
  open_pr: false  # Ponlo en true para crear un PR automáticamente

output_dir: /output
EOF

# Ejecutar con archivo de configuración
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

Modo interfaz web

SWE-agent incluye una interfaz web basada en Gradio para uso interactivo:

# Iniciar la interfaz 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

# Acceder a la interfaz
echo "Abrir: http://<CLORE_SERVER_IP>:<MAPPED_PORT>"
docker logs -f sweagent-ui

Usando diferentes proveedores de 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 (opción económica)
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 (combinar con la guía de Ollama)
# Primero despliega Ollama en un servidor con GPU (ver ../language-models/ollama.md)
# Luego úsalo como backend para 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

Procesamiento por lotes de múltiples issues

# Procesar múltiples issues usando el formato 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 de ejecución por lotes
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 "Iniciando ejecución por lotes 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 "=== Procesando: $REPO#$ISSUE_NUM con $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 "FALLADO: $REPO#$ISSUE_NUM"
done

echo "Lote completo. Resultados en $OUTPUT_DIR"
BASH

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

---

Configuración Docker-in-Docker

SWE-agent ejecuta código en contenedores Docker anidados por seguridad. Esto requiere acceso al socket de Docker:

# Verificar que el socket de Docker sea accesible
ls -la /var/run/docker.sock

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

# SWE-agent descargará automáticamente su imagen de sandbox
# Sandbox por defecto: sweagent/swe-agent:latest (o una imagen de entorno especializada)

Consideraciones de seguridad

# Límites de recursos del sandbox de SWE-agent (configura en tu YAML)
cat >> /workspace/sweagent/config.yaml << 'EOF'
env:
  deployment:
    docker_args:
      - "--memory=4g"          # Limitar RAM del sandbox
      - "--cpus=2"             # Limitar CPU del sandbox
      - "--network=bridge"     # Red aislada
      - "--read-only"          # Sistema de archivos en solo lectura (con excepciones)
      - "--tmpfs=/tmp:size=1g" # /tmp solo escribible
EOF

# Nunca ejecutes SWE-agent directamente en tu host — siempre usa Docker
# El contenedor sandbox aísla código potencialmente dañino

Uso de una imagen de entorno preconstruida

# SWE-agent admite imágenes de entorno personalizadas por repositorio
# Esto acelera las ejecuciones al preinstalar dependencias
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

---

Consejos y mejores prácticas

🎯 Redacción efectiva de declaraciones de problema

La calidad de la reparación de SWE-agent depende en gran medida de la descripción del issue:

# Método 1: Usa una URL de issue de GitHub (recomendado)
--problem_statement.github_url=https://github.com/USER/REPO/issues/42

# Método 2: Proporciona un archivo de texto con una descripción detallada
cat > /workspace/sweagent/issue.txt << 'EOF'
## Descripción del bug
La función `calculate_total()` en `billing/calculator.py` devuelve 0 
cuando el descuento es exactamente 100%. 

## Pasos para reproducir
```python
total = calculate_total(price=100, discount=100)
assert total == 0  # Esto falla, devuelve 100 en su lugar

Comportamiento esperado

Debería devolver 0 cuando el descuento es 100%.

Código relevante

Ver billing/calculator.py líneas 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

### 💰 Control de costes

```bash
# Siempre establece límites de coste por instancia
--agent.model.per_instance_cost_limit=2.00  # Máx $2 por issue

# Usa GPT-4o mini para la triaje inicial, Claude para correcciones complejas
# Estrategia de presupuesto: ~ $0.10 para escanear, ~ $1.50 para arreglar

# Monitoriza los costes en tiempo real
docker logs -f sweagent-ui | grep -E "(cost|tokens|spent)"

# Establece un presupuesto total para todas las ejecuciones
--agent.model.total_cost_limit=20.00  # Detener todas las ejecuciones después de $20

🔄 Creación automática de PRs

# Crear automáticamente un pull request con la corrección
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

📊 Evaluación SWE-bench

# Ejecuta SWE-agent contra el benchmark oficial 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

🛡️ Modo de ciberseguridad

# SWE-agent soporta desafíos CTF y de ciberseguridad
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="Encuentra la flag en el servicio web en ejecución en http://challenge.local:8080" \
    --output_dir=/output

---

Solución de problemas

Permiso denegado para el socket de Docker

# Error: permiso denegado al intentar conectar con el daemon de Docker
# Solución: asegura que el socket de Docker esté montado correctamente

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

# Si ves errores de permisos, revisa los permisos del socket
ls -la /var/run/docker.sock
# Debería ser: srw-rw---- root docker

# Añade el usuario actual al grupo docker (si no eres root)
usermod -aG docker $USER
newgrp docker

Errores de claves API

# Verifica que tu clave API esté configurada correctamente
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}')
"

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

El agente se queda atascado en un bucle

# SWE-agent tiene un límite de pasos incorporado (por defecto ~100 pasos)
# Aumenta o disminuye vía configuración:

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

# Matar una ejecución atascada
docker ps | grep sweagent
docker stop <container_id>

Agotamiento de memoria durante la ejecución de código

# Aumenta el límite de memoria del 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

# Para bases de código grandes, aumenta la instancia de Clore.ai a 32GB de RAM

Limitación de tasa de GitHub

# La API de GitHub tiene límites de tasa — usa un token de acceso personal con ámbito repo
# Comprueba el estado actual de tu límite de tasa
curl -H "Authorization: token $GITHUB_TOKEN" \
  https://api.github.com/rate_limit | jq '.rate'

# Si estás limitado por la tasa, espera al reinicio o usa otro token
# El límite de tasa se reinicia cada hora

---

Lecturas adicionales

• SWE-agent en GitHub — Repositorio principal y documentación

• Documentación de SWE-agent — Documentación oficial

• Artículo de SWE-agent (NeurIPS 2024) — Artículo de investigación

• Leaderboard de SWE-bench — Mira cómo rinden diferentes modelos

• Empezando con Clore.ai — Conceptos básicos de la plataforma

• Guía de comparación de GPU — Si necesitas GPU para LLMs locales

• Ejecutando Ollama en Clore.ai — Backend de LLM local para SWE-agent

• Ejecutando vLLM en Clore.ai — Servidor local de LLM de alto rendimiento

• Precios de la API de Anthropic — Costes de la API Claude

• Precios de la API de OpenAI — Costes de la API GPT-4

💡 Punto óptimo Clore.ai + SWE-agent: Alquila un servidor solo CPU (4 núcleos, 16GB RAM) por ~ $0.05/h, ejecuta SWE-agent con Claude Sonnet 4 y arregla issues de GitHub por aproximadamente $1–2 en total por issue (costes de API) más unos pocos centavos de tiempo en Clore.ai. Para equipos con muchos issues, esto supera con creces contratar a un desarrollador para correcciones rutinarias de bugs.