# Aider AI Coding

Aider es un asistente de codificación con IA basado en terminal con más de 39K estrellas en GitHub. Edita archivos directamente en tu repositorio, crea commits de Git automáticamente y admite tanto APIs en la nube (OpenAI, Anthropic) como modelos totalmente locales a través de Ollama. En una GPU de Clore.ai, puedes ejecutar modelos grandes de codificación como DeepSeek-R1 32B o Qwen2.5-Coder-32B por completo en tu propio hardware: privado, rápido y rentable.

{% hint style="success" %}
Todos los ejemplos se ejecutan en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Características clave

* **Nativo de terminal** — funciona vía SSH, perfecto para servidores Clore.ai sin interfaz gráfica
* **Con conciencia de Git** — auto-commits de cada cambio con mensajes descriptivos, fácil de revisar y revertir
* **Edición de múltiples archivos** — agrega múltiples archivos al contexto y edítalos simultáneamente
* **Soporte de modelos locales** — conéctate a Ollama para codificación totalmente privada y sin coste de API
* **Modo arquitecto** — usa un modelo de razonamiento potente para planificar y luego un modelo rápido para implementar
* **Mapa del repositorio** — indexa automáticamente tu base de código para ediciones con conocimiento del contexto
* **Linting y pruebas** — ejecuta linters/tests después de cada edición, corrige automáticamente las fallas
* **Entrada de voz** — dicta instrucciones de codificación mediante micrófono

## Requisitos

| Componente | Mínimo         | Recomendado    |
| ---------- | -------------- | -------------- |
| GPU        | RTX 3060 12 GB | RTX 4090 24 GB |
| VRAM       | 12 GB          | 24 GB          |
| RAM        | 16 GB          | 32 GB          |
| Disco      | 30 GB          | 60 GB          |
| Python     | 3.9            | 3.11           |

**Precios de Clore.ai:** RTX 4090 ≈ $0.5–2/día · RTX 3090 ≈ $0.3–1/día · RTX 3060 ≈ $0.15–0.3/día

Para modelos solo en la nube (sin inferencia local), no se requiere GPU, pero las GPUs de Clore.ai te permiten ejecutar modelos Ollama localmente para total privacidad.

## Inicio rápido

### 1. Instala Aider

```bash
pip install aider-chat
```

### 2. Configura Ollama para modelos locales

```bash
# Instalar Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Descarga un modelo de codificación
ollama pull deepseek-r1:32b

# O un modelo más pequeño para menor VRAM
ollama pull qwen2.5-coder:7b
```

### 3. Inicia Aider con un modelo local

```bash
cd /workspace/tu-proyecto

# Usa DeepSeek-R1 32B vía Ollama (necesita ~20 GB de VRAM)
aider --model ollama/deepseek-r1:32b

# O usa un modelo más pequeño en RTX 3060
aider --model ollama/qwen2.5-coder:7b
```

### 4. Comienza a codificar

Dentro del REPL de Aider:

```
> /add src/main.py src/utils.py
> Añade manejo de errores a la función parse_config y escribe pruebas unitarias para ella
```

Aider hará:

1. Leer los archivos y comprender la base de código
2. Proponer cambios como un diff
3. Aplicar los cambios en el disco
4. Crear un commit de Git con un mensaje descriptivo

## Ejemplos de uso

### Modo Arquitecto (Configuración de dos modelos)

Usa un modelo potente para el razonamiento y un modelo rápido para la generación de código:

```bash
# Arquitecto en la nube + editor local
aider --architect --model ollama/deepseek-r1:32b --editor-model ollama/qwen2.5-coder:7b
```

El modelo arquitecto planifica los cambios y el modelo editor escribe el código real: combinando razonamiento de alta calidad con implementación rápida.

### Agregar archivos y editar

```bash
# Agrega archivos específicos al contexto del chat
> /add src/api/routes.py src/models/user.py

# Pide cambios
> Refactoriza el endpoint de registro de usuario para usar async/await y añade validación de entradas con Pydantic

# Agrega todo un directorio
> /add src/tests/

# Ejecuta pruebas después de la edición
> /test pytest src/tests/ -v
```

### Usar con APIs en la nube

```bash
# OpenAI
export OPENAI_API_KEY=sk-...
aider --model gpt-4o

# Anthropic
export ANTHROPIC_API_KEY=sk-ant-...
aider --model claude-sonnet-4-20250514
```

### Integración con Git

```bash
# Cada cambio crea un commit automáticamente
git log --oneline -5
# a1b2c3d aider: Añadir manejo de errores a parse_config
# d4e5f6g aider: Escribir pruebas unitarias para parse_config
# h7i8j9k aider: Refactorizar el endpoint de registro de usuario

# Deshacer el último cambio de aider
aider --undo
```

### Lint y autoarreglo

```bash
# Configura un linter
aider --lint-cmd "ruff check --fix" --auto-lint

# Aider ejecuta el linter después de cada edición y corrige automáticamente los problemas
```

### Modo no interactivo (scripted)

```bash
# Ejecuta una sola instrucción y sale
aider --model ollama/deepseek-r1:32b \
  --message "Añadir anotaciones de tipo a todas las funciones en src/utils.py" \
  --yes  # aceptar cambios automáticamente
```

## Recomendaciones de modelos

| Modelo                | VRAM    | Velocidad | Calidad | Mejor para                  |
| --------------------- | ------- | --------- | ------- | --------------------------- |
| deepseek-r1:32b       | \~20 GB | Medio     | Alto    | Refactorización compleja    |
| qwen2.5-coder:32b     | \~20 GB | Medio     | Alto    | Generación de código        |
| qwen2.5-coder:7b      | \~5 GB  | Rápido    | Bueno   | Ediciones rápidas, RTX 3060 |
| codellama:34b         | \~20 GB | Medio     | Bueno   | Código legado, C/C++        |
| deepseek-coder-v2:16b | \~10 GB | Rápido    | Bueno   | Rendimiento equilibrado     |

## Consejos

* **Usa `/add` selectivamente** — solo añade los archivos que Aider necesita ver. Demasiados archivos desperdician tokens del contexto
* **Modo arquitecto** es poderoso para cambios complejos — el modelo de razonamiento detecta casos límite que el modelo editor podría pasar por alto
* **`/undo`** revierte el último cambio limpiamente vía Git — experimenta con libertad
* **`/diff`** muestra los cambios propuestos antes de aplicarlos — úsalo para revisar
* **Establecer `--auto-commits`** (por defecto) para un historial completo de Git de cada cambio de la IA
* **Usa `.aiderignore`** para excluir archivos del mapa del repositorio (node\_modules, .venv, etc.)
* **Para repositorios grandes**, el mapa del repositorio de Aider ayuda al modelo a entender la estructura del código — déjalo ejecutarse en la primera carga
* **Ejecuta pruebas después de las ediciones** — `/test pytest` detecta regresiones de inmediato

## Solución de problemas

| Problema                           | Solución                                                                             |
| ---------------------------------- | ------------------------------------------------------------------------------------ |
| Modelo Ollama demasiado lento      | Usa una cuantización más pequeña (q4\_0) o un modelo más pequeño                     |
| `CUDA fuera de memoria` con Ollama | Descarga una variante de modelo más pequeña o usa `OLLAMA_NUM_GPU=0` para CPU        |
| Errores de commit de Git           | Asegúrate de `git config user.email` y `user.name` están configurados                |
| Aider ignora mis archivos          | Usa `/add filename.py` explícitamente — Aider solo edita los archivos añadidos       |
| El modelo produce ediciones pobres | Prueba un modelo más potente o usa el modo arquitecto                                |
| Conexión rechazada (Ollama)        | Asegúrate de que Ollama está en ejecución: `ollama serve` o `systemctl start ollama` |
| Ventana de contexto excedida       | Elimina archivos con `/drop`, conserva solo los relevantes                           |

## Recursos

* [Aider en GitHub](https://github.com/Aider-AI/aider)
* [Documentación de Aider](https://aider.chat)
* [Biblioteca de modelos de Ollama](https://ollama.com/library)
* [CLORE.AI Marketplace](https://clore.ai/marketplace)
