> 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-es/herramientas-de-codificacion-con-ia/aider.md).

# Codificación con IA Aider

Codificación con IA basada en terminal con Aider en Clore.ai: consciente de Git, multiarchivo, modelos locales vía Ollama

Aider es un asistente de codificación con IA basado en terminal y con más de 39 mil estrellas en GitHub. Edita archivos directamente en tu repositorio, crea commits de Git automáticamente y es compatible tanto con APIs en la nube (OpenAI, Anthropic) como con modelos totalmente locales mediante Ollama. En una GPU de Clore.ai, puedes ejecutar modelos grandes de programación como DeepSeek-R1 32B o Qwen2.5-Coder-32B completamente 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 [Marketplace de CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Características clave

* **Nativo del terminal** — funciona sobre SSH, perfecto para servidores Clore.ai sin interfaz gráfica
* **Compatible con Git** — hace commits automáticos de cada cambio con mensajes descriptivos, fácil de revisar y revertir
* **Edición de varios archivos** — añade varios archivos al contexto y edítalos simultáneamente
* **Compatibilidad con modelos locales** — conéctate a Ollama para una programación totalmente privada y sin coste de API
* **Modo arquitecto** — usa un modelo de razonamiento potente para planificar, luego un modelo rápido para implementar
* **Mapa del repositorio** — indexa automáticamente tu base de código para realizar ediciones con conocimiento del contexto
* **Análisis estático y pruebas** — ejecuta linters/pruebas después de cada edición, corrige automáticamente los fallos
* **Entrada de voz** — dicta instrucciones de programación mediante el 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.14–0.42/h · RTX 3090 ≈ $0.07–0.21/h · RTX 3060 ≈ $0.03–0.07/h

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

## 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 programación
ollama pull deepseek-r1:32b

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

### 3. Inicia Aider con un modelo local

```bash
cd /workspace/your-project

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

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

### 4. Empieza a programar

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á lo siguiente:

1. Leer los archivos y entender la base de código
2. Proponer cambios como un diff
3. Aplicar los cambios en 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.

### Añadir archivos y editar

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

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

# Añade un directorio completo
> /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ñade manejo de errores a parse_config
# d4e5f6g aider: Escribe pruebas unitarias para parse_config
# h7i8j9k aider: Refactoriza el endpoint de registro de usuarios

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

### Análisis estático y corrección automática

```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 (por script)

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

## Recomendaciones de modelos

| Modelo                | VRAM    | Velocidad | Calidad | Ideal 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 heredado, 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 de 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 limpiamente el último cambio mediante Git — experimenta libremente
* **`/diff`** muestra los cambios propuestos antes de aplicarlos — úsalo para revisar
* **Establece `--auto-commits`** (predeterminado) para tener el historial completo de Git de cada cambio de 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 — deja que se ejecute en la primera carga
* **Ejecuta pruebas después de las ediciones** — `/test pytest` detecta regresiones al instante

## Solución de problemas

| Problema                                | Solución                                                                             |
| --------------------------------------- | ------------------------------------------------------------------------------------ |
| El modelo de Ollama es demasiado lento  | Usa una cuantización más pequeña (q4\_0) o un modelo más pequeño                     |
| `CUDA sin memoria` con Ollama           | Descarga una variante más pequeña del modelo o usa `OLLAMA_NUM_GPU=0` para CPU       |
| Errores en commits 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 deficientes | Prueba con 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` |
| Se superó la ventana de contexto        | 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)
* [Marketplace de CLORE.AI](https://clore.ai/marketplace)


---

# 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/herramientas-de-codificacion-con-ia/aider.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.