# Codificación con IA de Continue.dev

Continue.dev es un asistente de codificación con IA de código abierto para VS Code y JetBrains con más de 25K estrellas en GitHub. El **complemento se ejecuta en tu máquina local** (o en tu IDE), pero se conecta a un servidor de modelos en backend para inferencia. Al apuntar Continue.dev a una GPU potente alquilada en Clore.ai, obtienes:

* **Modelos de codificación de primer nivel** (34B+ parámetros) que no cabrán en tu portátil
* **Privacidad total** — el código permanece en la infraestructura que controlas
* **Costos flexibles** — paga solo mientras codificas (\~$0.20–0.50/h vs. $19/mes por Copilot)
* **API compatible con OpenAI** — Continue.dev se conecta a Ollama, vLLM o TabbyML sin problemas

Esta guía se centra en configurar el **backend GPU de Clore.ai** (Ollama o vLLM) al que se conecta tu extensión Continue.dev local.

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

{% hint style="info" %}
**Arquitectura**: Tu IDE (con la extensión Continue.dev) → Internet → servidor GPU de Clore.ai (ejecutando Ollama / vLLM / TabbyML) → inferencia del modelo local. Ningún código toca jamás una API de terceros.
{% endhint %}

## Resumen

| Propiedad                    | Detalles                                                                                     |
| ---------------------------- | -------------------------------------------------------------------------------------------- |
| **Proyecto**                 | [continuedev/continue](https://github.com/continuedev/continue)                              |
| **Licencia**                 | Apache 2.0                                                                                   |
| **Estrellas en GitHub**      | 25K+                                                                                         |
| **Soporte de IDE**           | VS Code, JetBrains (IntelliJ, PyCharm, WebStorm, GoLand, etc.)                               |
| **Archivo de configuración** | `~/.continue/config.json`                                                                    |
| **Opciones de backend**      | Ollama, vLLM, TabbyML, LM Studio, llama.cpp, APIs compatibles con OpenAI                     |
| **Dificultad**               | Fácil (instalar extensión) / Media (backend autoalojado)                                     |
| **¿Se requiere GPU?**        | En el servidor Clore.ai (sí); en tu portátil (no)                                            |
| **Características clave**    | Autocompletado, chat, modo edición, contexto del código (RAG), comandos slash personalizados |

### Modelos recomendados para codificación

| Modelo                | VRAM    | Fortaleza                            | Notas                                       |
| --------------------- | ------- | ------------------------------------ | ------------------------------------------- |
| `codellama:7b`        | \~6 GB  | Autocompletado rápido                | Buen punto de partida                       |
| `codellama:13b`       | \~10 GB | Equilibrado                          | Mejor calidad/velocidad para autocompletado |
| `codellama:34b`       | \~22 GB | Mejor calidad de CodeLlama           | Requiere RTX 3090 / A100                    |
| `deepseek-coder:6.7b` | \~5 GB  | Especialista en Python/JS            | Excelente para desarrollo web               |
| `deepseek-coder:33b`  | \~22 GB | Código abierto de primer nivel       | Rivaliza con GPT-4 en código                |
| `qwen2.5-coder:7b`    | \~6 GB  | Código multilingüe                   | Fuerte en 40+ lenguajes                     |
| `qwen2.5-coder:32b`   | \~22 GB | Estado del arte                      | Mejor modelo abierto para codificación 2024 |
| `starcoder2:15b`      | \~12 GB | Especialista en completado de código | Soporte FIM (fill-in-the-middle)            |

## Requisitos

### Requisitos del servidor Clore.ai

| Nivel           | GPU       | VRAM  | RAM   | Disco  | Precio    | Modelos                                          |
| --------------- | --------- | ----- | ----- | ------ | --------- | ------------------------------------------------ |
| **Económico**   | RTX 3060  | 12 GB | 16 GB | 40 GB  | \~$0.10/h | CodeLlama 7B, DeepSeek 6.7B, Qwen2.5-Coder 7B    |
| **Recomendado** | RTX 3090  | 24 GB | 32 GB | 80 GB  | \~$0.20/h | CodeLlama 34B, DeepSeek 33B, Qwen2.5-Coder 32B   |
| **Rendimiento** | RTX 4090  | 24 GB | 32 GB | 80 GB  | \~$0.35/h | Mismos modelos que arriba, inferencia más rápida |
| **Potencia**    | A100 40GB | 40 GB | 64 GB | 120 GB | \~$0.60/h | Varios modelos 34B concurrentemente              |
| **Máximo**      | A100 80GB | 80 GB | 80 GB | 200 GB | \~$1.10/h | Modelos de 70B (CodeLlama 70B)                   |

### Requisitos locales (tu máquina)

* VS Code o cualquier IDE de JetBrains
* Extensión Continue.dev instalada
* Conexión a internet estable con tu servidor Clore.ai
* **No se necesita GPU local** — toda la inferencia ocurre en Clore.ai

## Inicio rápido

### Parte 1: Configurar el backend de Clore.ai

#### Opción A — Backend Ollama (recomendado para la mayoría de usuarios)

Ollama es el backend más sencillo para Continue.dev — configuración simple, excelente gestión de modelos, API compatible con OpenAI.

```bash
# 1. Conéctate por SSH a tu servidor Clore.ai
ssh root@<clore-server-ip> -p <port>

# 2. Inicia Ollama con soporte GPU
docker run -d \
  --name ollama \
  --gpus all \
  -p 11434:11434 \
  -v /workspace/ollama:/root/.ollama \
  --restart unless-stopped \
  ollama/ollama

# 3. Verifica que Ollama esté en ejecución
curl http://localhost:11434/

# 4. Descarga tu modelo de codificación (elige según tu VRAM)
# Para 12GB VRAM (RTX 3060):
docker exec ollama ollama pull codellama:13b

# Para 24GB VRAM (RTX 3090 / RTX 4090):
docker exec ollama ollama pull qwen2.5-coder:32b
# o:
docker exec ollama ollama pull deepseek-coder:33b

# 5. Descarga un modelo de autocompletado rápido (separado del modelo de chat)
docker exec ollama ollama pull starcoder2:3b   # Muy rápido, excelente para autocompletado FIM

# 6. Verifica que los modelos estén disponibles
docker exec ollama ollama list

# 7. Prueba la inferencia
docker exec ollama ollama run qwen2.5-coder:32b "Write a Python function to binary search a sorted list"
```

Para exponer Ollama externamente (para que tu IDE local pueda conectarse):

```bash
# Reinicia Ollama con acceso externo habilitado
docker stop ollama && docker rm ollama

docker run -d \
  --name ollama \
  --gpus all \
  -p 11434:11434 \
  -v /workspace/ollama:/root/.ollama \
  -e OLLAMA_HOST=0.0.0.0 \
  --restart unless-stopped \
  ollama/ollama

# Prueba desde tu máquina LOCAL:
curl http://<clore-server-ip>:11434/api/tags
```

{% hint style="warning" %}
Exponer el puerto 11434 públicamente no tiene autenticación por defecto. Para uso en producción, configura un túnel SSH en su lugar (ver [Consejos y mejores prácticas](#tips--best-practices)).
{% endhint %}

#### Opción B — Backend vLLM (alto rendimiento / compatible con OpenAI)

vLLM ofrece inferencia más rápida y soporte multiusuario. Ideal si varios desarrolladores comparten un servidor Clore.ai.

```bash
# Inicia vLLM con API compatible con OpenAI
docker run -d \
  --name vllm \
  --gpus all \
  -p 8000:8000 \
  -v /workspace/hf-models:/root/.cache/huggingface \
  -e HF_TOKEN="tu-token-huggingface" \
  --restart unless-stopped \
  vllm/vllm-openai:latest \
  --model Qwen/Qwen2.5-Coder-32B-Instruct \
  --dtype auto \
  --max-model-len 32768 \
  --tensor-parallel-size 1 \
  --gpu-memory-utilization 0.90 \
  --served-model-name qwen2.5-coder-32b

# Para multi-GPU (por ejemplo, dos RTX 3090):
docker run -d \
  --name vllm \
  --gpus all \
  -p 8000:8000 \
  -v /workspace/hf-models:/root/.cache/huggingface \
  -e HF_TOKEN="tu-token-huggingface" \
  vllm/vllm-openai:latest \
  --model deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct \
  --tensor-parallel-size 2 \
  --dtype auto \
  --max-model-len 65536 \
  --served-model-name deepseek-coder-v2

# Prueba la API
curl http://localhost:8000/v1/models
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen2.5-coder-32b",
    "messages": [{"role": "user", "content": "Write a hello world in Rust"}],
    "max_tokens": 200
  }'
```

#### Opción C — Backend TabbyML (especialista en autocompletado FIM)

TabbyML ofrece un mejor autocompletado fill-in-the-middle (FIM): las sugerencias en texto fantasma en línea. Consulta la [documentación de TabbyML](https://tabby.tabbyml.com/) para los detalles completos de configuración.

```bash
# Configuración rápida de TabbyML para autocompletado de Continue.dev
docker run -d \
  --name tabby \
  --gpus all \
  -p 8080:8080 \
  -v /workspace/tabby-data:/data \
  --restart unless-stopped \
  tabbyml/tabby serve \
  --model StarCoder2-7B \
  --chat-model Mistral-7B \
  --device cuda

# Verificar
curl http://localhost:8080/v1/health
```

### Parte 2: Instalar la extensión Continue.dev

**VS Code:**

1. Abre el panel de Extensiones (`Ctrl+Shift+X` / `Cmd+Shift+X`)
2. Buscar **"Continue"** — instala la extensión oficial de Continue (continuedev)
3. Haz clic en el icono de Continue en la barra lateral (o `Ctrl+Shift+I`)

**JetBrains (IntelliJ, PyCharm, WebStorm, GoLand):**

1. `Archivo → Settings → Plugins → Marketplace`
2. Buscar **"Continue"** e instala
3. Reinicia el IDE; el panel de Continue aparece en la barra lateral derecha

### Parte 3: Configurar Continue.dev para usar Clore.ai

Edita `~/.continue/config.json` en tu **máquina local**:

```json
{
  "models": [
    {
      "title": "Clore.ai — Qwen2.5-Coder 32B",
      "provider": "ollama",
      "model": "qwen2.5-coder:32b",
      "apiBase": "http://<clore-server-ip>:11434",
      "contextLength": 32768,
      "completionOptions": {
        "temperature": 0.1,
        "topP": 0.95,
        "maxTokens": 4096
      }
    },
    {
      "title": "Clore.ai — CodeLlama 13B (rápido)",
      "provider": "ollama",
      "model": "codellama:13b",
      "apiBase": "http://<clore-server-ip>:11434",
      "contextLength": 16384
    }
  ],
  "tabAutocompleteModel": {
    "title": "StarCoder2 3B (autocompletado)",
    "provider": "ollama",
    "model": "starcoder2:3b",
    "apiBase": "http://<clore-server-ip>:11434"
  },
  "embeddingsProvider": {
    "provider": "ollama",
    "model": "nomic-embed-text",
    "apiBase": "http://<clore-server-ip>:11434"
  },
  "contextProviders": [
    { "name": "code" },
    { "name": "docs" },
    { "name": "diff" },
    { "name": "terminal" },
    { "name": "problems" },
    { "name": "folder" },
    { "name": "codebase" }
  ],
  "slashCommands": [
    { "name": "edit", "description": "Editar el código seleccionado" },
    { "name": "comment", "description": "Agregar comentarios al código" },
    { "name": "share", "description": "Exportar conversación como markdown" },
    { "name": "cmd", "description": "Generar comando de terminal" },
    { "name": "commit", "description": "Generar mensaje de commit de git" }
  ]
}
```

Para **backend vLLM** en lugar de Ollama:

```json
{
  "models": [
    {
      "title": "Clore.ai — DeepSeek Coder 33B (vLLM)",
      "provider": "openai",
      "model": "deepseek-coder-v2",
      "apiBase": "http://<clore-server-ip>:8000/v1",
      "apiKey": "not-required",
      "contextLength": 65536,
      "completionOptions": {
        "temperature": 0.0,
        "maxTokens": 8192
      }
    }
  ]
}
```

Para **Backend TabbyML** (solo autocompletado):

```json
{
  "tabAutocompleteModel": {
    "title": "Clore.ai — TabbyML StarCoder2",
    "provider": "openai",
    "model": "StarCoder2-7B",
    "apiBase": "http://<clore-server-ip>:8080/v1",
    "apiKey": "auth-token-if-set"
  }
}
```

## Configuración

### Configuración de túnel SSH (acceso remoto seguro)

En lugar de exponer puertos públicamente, usa un túnel SSH desde tu máquina local:

```bash
# Abrir túnel SSH: puerto local 11434 → puerto 11434 del servidor Clore.ai
ssh -N -L 11434:localhost:11434 root@<clore-server-ip> -p <clore-ssh-port>

# Mantén el túnel activo (agrega a ~/.ssh/config):
Host clore-coding
  HostName <clore-server-ip>
  Port <clore-ssh-port>
  User root
  LocalForward 11434 localhost:11434
  LocalForward 8000 localhost:8000
  ServerAliveInterval 60
  ServerAliveCountMax 3

# Conectar con:
ssh -N clore-coding

# Entonces en config.json usa localhost:
# "apiBase": "http://localhost:11434"
```

### Túnel persistente con autossh

```bash
# Instala autossh en tu máquina local (Linux/macOS)
sudo apt install autossh   # Ubuntu/Debian
brew install autossh       # macOS

# Ejecuta túnel persistente que se reconecta automáticamente
autossh -M 0 -N \
  -o "ServerAliveInterval 30" \
  -o "ServerAliveCountMax 3" \
  -L 11434:localhost:11434 \
  root@<clore-server-ip> -p <clore-ssh-port>

# Agregar a systemd para inicio automático en el arranque (Linux)
cat > ~/.config/systemd/user/clore-tunnel.service << 'EOF'
[Unit]
Description=SSH tunnel to Clore.ai coding server
After=network.target

[Service]
ExecStart=autossh -M 0 -N \
  -o StrictHostKeyChecking=accept-new \
  -o ServerAliveInterval=30 \
  -o ServerAliveCountMax=3 \
  -L 11434:localhost:11434 \
  root@CLORE_IP -p CLORE_PORT
Restart=always
RestartSec=10

[Install]
WantedBy=default.target
EOF

systemctl --user enable clore-tunnel
systemctl --user start clore-tunnel
```

### Cargar múltiples modelos para diferentes tareas

Para una RTX 3090 (24 GB), puedes ejecutar un gran modelo de chat y un modelo pequeño de autocompletado simultáneamente:

```bash
# En el servidor Clore.ai:

# Descarga los modelos
docker exec ollama ollama pull qwen2.5-coder:32b      # Chat (22 GB)
docker exec ollama ollama pull starcoder2:3b           # Autocompletado (2 GB)
docker exec ollama ollama pull nomic-embed-text        # Embeddings (0.5 GB)

# Ollama gestiona el intercambio de modelos automáticamente
# Los tres entran dentro de 24 GB de VRAM con caché inteligente

# Monitorea el uso de VRAM
nvidia-smi --query-gpu=memory.used,memory.free --format=csv -l 5
```

### Indexado de la base de código (RAG para tu repositorio)

Continue.dev puede indexar tu base de código para sugerencias con conciencia del contexto. Descarga un modelo de embeddings:

```bash
# En el servidor Clore.ai — agrega el modelo de embeddings a Ollama
docker exec ollama ollama pull nomic-embed-text

# En config.json (local), los embeddings ya están configurados arriba.
# Continue.dev indexará tu espacio de trabajo abierto automáticamente.
# Forzar reindexado manual: Ctrl+Shift+P → "Continue: Index Codebase"
```

## Aceleración por GPU

### Monitorea el rendimiento de la inferencia

```bash
# En tu servidor Clore.ai — observa la GPU durante las sesiones de codificación
watch -n 1 nvidia-smi

# Verifica tokens por segundo (logs de Ollama)
docker logs ollama --tail 20 -f

# Estadísticas detalladas de GPU
nvidia-smi dmon -s u -d 2

# Desglose de memoria
nvidia-smi --query-gpu=name,memory.used,memory.free,utilization.gpu \
  --format=csv,noheader -l 5
```

### Rendimiento esperado por GPU

| GPU           | Modelo                   | Contexto | Tokens/seg (aprox.) |
| ------------- | ------------------------ | -------- | ------------------- |
| RTX 3060 12GB | CodeLlama 7B             | 8K       | \~40–60 t/s         |
| RTX 3060 12GB | DeepSeek-Coder 6.7B      | 8K       | \~45–65 t/s         |
| RTX 3090 24GB | Qwen2.5-Coder 32B (Q4)   | 16K      | \~15–25 t/s         |
| RTX 3090 24GB | DeepSeek-Coder 33B (Q4)  | 16K      | \~15–22 t/s         |
| RTX 4090 24GB | Qwen2.5-Coder 32B (Q4)   | 16K      | \~25–40 t/s         |
| A100 40GB     | Qwen2.5-Coder 32B (FP16) | 32K      | \~35–50 t/s         |
| A100 80GB     | CodeLlama 70B (Q4)       | 32K      | \~20–30 t/s         |

Para autocompletado (fill-in-the-middle), **starcoder2:3b** o **codellama:7b** lograr 50–100 t/s — lo suficientemente rápido como para sentirse instantáneo en el IDE.

### Optimiza Ollama para mejor rendimiento

```bash
# En el servidor Clore.ai — optimiza los ajustes de Ollama
docker stop ollama && docker rm ollama

docker run -d \
  --name ollama \
  --gpus all \
  -p 11434:11434 \
  -v /workspace/ollama:/root/.ollama \
  -e OLLAMA_HOST=0.0.0.0 \
  -e OLLAMA_NUM_PARALLEL=2 \
  -e OLLAMA_MAX_LOADED_MODELS=2 \
  -e OLLAMA_FLASH_ATTENTION=1 \
  --restart unless-stopped \
  ollama/ollama

# OLLAMA_NUM_PARALLEL=2: servir 2 solicitudes simultáneamente
# OLLAMA_MAX_LOADED_MODELS=2: mantener 2 modelos en memoria GPU
# OLLAMA_FLASH_ATTENTION=1: habilitar flash attention (más rápido, menos memoria)
```

## Consejos y mejores prácticas

### Usa diferentes modelos para tareas distintas

Configura Continue.dev con modelos especializados por tipo de tarea — la UI te permite cambiar modelos a mitad de la conversación:

```json
{
  "models": [
    {
      "title": "Chat — Qwen2.5-Coder 32B",
      "provider": "ollama",
      "model": "qwen2.5-coder:32b",
      "apiBase": "http://localhost:11434",
      "contextLength": 32768,
      "description": "Mejor para preguntas complejas, revisión de código, decisiones de arquitectura"
    },
    {
      "title": "Rápido — CodeLlama 7B",
      "provider": "ollama",
      "model": "codellama:7b",
      "apiBase": "http://localhost:11434",
      "contextLength": 8192,
      "description": "Respuestas rápidas, completados simples, baja latencia"
    },
    {
      "title": "Autocompletado — StarCoder2 3B",
      "provider": "ollama",
      "model": "starcoder2:3b",
      "apiBase": "http://localhost:11434",
      "contextLength": 4096,
      "description": "Sugerencias en texto fantasma en línea"
    }
  ]
}
```

### Comparación de costos

| Solución              | Costo mensual (uso 8h/día) | Privacidad          | Calidad del modelo   |
| --------------------- | -------------------------- | ------------------- | -------------------- |
| GitHub Copilot        | $19/usuario/mes            | ❌ Nube de Microsoft | GPT-4o (cerrado)     |
| Cursor Pro            | $20/usuario/mes            | ❌ Nube de Cursor    | Claude 3.5 (cerrado) |
| RTX 3060 en Clore.ai  | \~$24/mes                  | ✅ Tu servidor       | CodeLlama 13B        |
| RTX 3090 en Clore.ai  | \~$48/mes                  | ✅ Tu servidor       | Qwen2.5-Coder 32B    |
| RTX 4090 en Clore.ai  | \~$84/mes                  | ✅ Tu servidor       | Qwen2.5-Coder 32B    |
| A100 80GB en Clore.ai | \~$264/mes                 | ✅ Tu servidor       | CodeLlama 70B        |

Para un equipo de 3+ desarrolladores que comparten una RTX 3090 de Clore.ai (\~$48/mes en total), el costo por usuario supera a Copilot mientras proporciona un modelo más grande y privado.

### Apagar cuando no se esté programando

Clore.ai cobra por hora. Usa un script sencillo para arrancar/detener el servidor:

```bash
# Guarda estos como scripts locales

# start-coding-server.sh
#!/bin/bash
echo "Abriendo túnel SSH a Clore.ai..."
ssh -N -f -L 11434:localhost:11434 clore-coding
echo "Túnel abierto. Continue.dev está listo."

# stop-coding-server.sh
#!/bin/bash
echo "Cerrando túnel SSH..."
pkill -f "ssh.*clore-coding"
echo "Túnel cerrado. ¡Recuerda detener tu pedido en Clore.ai para dejar de facturar!"
```

### Usar comandos personalizados de Continue.dev

Añade comandos personalizados con barra a `config.json` para flujos de trabajo comunes de codificación:

```json
{
  "customCommands": [
    {
      "name": "review",
      "prompt": "Revisa este código en busca de errores, problemas de seguridad y problemas de rendimiento. Sé específico y proporciona acciones concretas.",
      "description": "Revisión de código"
    },
    {
      "name": "test",
      "prompt": "Escribe pruebas unitarias exhaustivas para este código. Incluye casos límite. Usa el mismo lenguaje/marco que el código.",
      "description": "Generar pruebas"
    },
    {
      "name": "docstring",
      "prompt": "Añade docstrings/comentarios claros y completos a este código siguiendo las mejores prácticas del lenguaje.",
      "description": "Añadir documentación"
    },
    {
      "name": "optimize",
      "prompt": "Optimiza este código para el rendimiento. Explica qué cambiaste y por qué.",
      "description": "Optimizar código"
    }
  ]
}
```

## Solución de problemas

| Problema                                  | Causa probable                                 | Solución                                                                                                            |
| ----------------------------------------- | ---------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
| Continue.dev muestra "Conexión denegada"  | Ollama no accesible                            | Verifica que el túnel SSH esté activo; comprueba `curl http://localhost:11434/` funciona                            |
| Autocompletar no se activa                | Modelo de autocompletar con Tab no configurado | Añade `tabAutocompleteModel` a config.json; habilítalo en la configuración de Continue                              |
| Respuestas muy lentas (>30s primer token) | Modelo cargándose desde disco                  | La primera solicitud carga el modelo en VRAM — las solicitudes posteriores son rápidas                              |
| Error "Modelo no encontrado"              | Modelo no descargado                           | Ejecuta `docker exec ollama ollama pull <model-name>` en el servidor de Clore.ai                                    |
| Alta latencia entre tokens                | Retardo de red o modelo demasiado grande       | Usa túnel SSH; cambia a un modelo más pequeño; verifica la utilización de la GPU del servidor                       |
| El contexto del código no funciona        | Falta el modelo de embeddings                  | Descarga `nomic-embed-text` vía Ollama; comprueba `embeddingsProvider` en config.json                               |
| El túnel SSH se cae con frecuencia        | Conexión inestable                             | Usa `autossh` para reconexión persistente; añade `ServerAliveInterval 30`                                           |
| Ventana de contexto excedida              | Archivos/conversaciones largas                 | Reduce `contextLength` en config.json; usa un modelo con contexto más largo                                         |
| Plugin de JetBrains no carga              | Incompatibilidad de versión del IDE            | Actualiza el IDE de JetBrains a la última versión; comprueba la matriz de compatibilidad del plugin de Continue.dev |
| vLLM OOM durante la carga                 | No hay suficiente VRAM                         | Añade `--gpu-memory-utilization 0.85`; usa un modelo más pequeño o una versión cuantizada                           |

### Comandos de depuración

```bash
# En tu máquina LOCAL — prueba la conectividad
curl http://localhost:11434/api/tags          # si usas túnel SSH
curl http://<clore-ip>:11434/api/tags        # si el puerto está abierto directamente

# En el servidor CLORE.AI — revisa Ollama
docker logs ollama --tail 30 -f
docker exec ollama ollama list
docker exec ollama ollama ps                  # muestra los modelos cargados actualmente

# Probar tiempo de respuesta del modelo
time curl http://localhost:11434/api/generate \
  -d '{"model": "codellama:7b", "prompt": "def hello():", "stream": false}'

# Comprobar memoria GPU
nvidia-smi --query-gpu=memory.used,memory.free --format=csv

# Revisar logs de vLLM
docker logs vllm --tail 50 -f

# Reiniciar Ollama sin perder modelos
docker restart ollama
```

### Validación de la configuración de Continue.dev

```bash
# Valida la sintaxis de config.json en tu máquina local
python3 -c "
import json, sys
try:
    config = json.load(open(sys.argv[1]))
    print('✅ La configuración es JSON válido')
    print(f'Modelos: {[m[\"title\"] for m in config.get(\"models\", [])]}')
except Exception as e:
    print(f'❌ Error: {e}')
" ~/.continue/config.json
```

## Lecturas adicionales

* [Documentación de Continue.dev](https://docs.continue.dev/) — documentación oficial para todas las integraciones de IDE y opciones de configuración
* [Continue.dev en GitHub](https://github.com/continuedev/continue) — código fuente, issues, compatibilidad de modelos
* [Referencia de configuración de Continue.dev](https://docs.continue.dev/reference) — completa `config.json` esquema
* [Ollama en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — guía detallada de configuración de Ollama (backend recomendado)
* [vLLM en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) — backend alternativo de alto rendimiento para equipos
* [TabbyML](https://tabby.tabbyml.com/) — backend especializado de autocompletado con optimización FIM
* [Guía de comparación de GPU](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md) — elige la GPU adecuada para tu carga de trabajo de codificación
* [Compatibilidad de modelos](/guides/guides_v2-es/primeros-pasos/model-compatibility.md) — qué modelos caben en qué tamaños de VRAM
* [Qwen2.5-Coder](https://huggingface.co/Qwen/Qwen2.5-Coder-32B-Instruct) — actualmente el mejor modelo abierto para codificación
* [DeepSeek-Coder-V2](https://huggingface.co/deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct) — alternativa sólida con contexto largo
* [Mercado CLORE.AI](https://clore.ai/marketplace) — alquilar servidores GPU


---

# Agent Instructions: 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-es/plataformas-y-agentes-de-ia/continue-dev.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.