> 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/plataformas-y-agentes-de-ia/continue-dev.md).

# Continue.dev Programación con IA

Potencia Continue.dev con GPUs de Clore.ai: ejecuta CodeLlama 34B, DeepSeek Coder y Qwen2.5-Coder localmente en alquileres de GPU baratos para asistencia privada de programación con IA.

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

* **Modelos de codificación de primer nivel** (más de 34 mil millones de parámetros) que no caben en tu portátil
* **Privacidad total** — el código permanece en una infraestructura que controlas
* **Costes flexibles** — paga solo mientras estás programando (\~$0.20–0.50/h frente a $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 de GPU de Clore.ai** (Ollama o vLLM) al que se conecta tu extensión local de Continue.dev.

{% hint style="success" %}
Todos los ejemplos de servidores GPU usan servidores alquilados a través de [Marketplace de 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 de modelo local. Ningún código toca nunca una API de terceros.
{% endhint %}

## Descripción general

| Propiedad                    | Detalles                                                                                                  |
| ---------------------------- | --------------------------------------------------------------------------------------------------------- |
| **Proyecto**                 | [continuedev/continue](https://github.com/continuedev/continue)                                           |
| **Licencia**                 | Apache 2.0                                                                                                |
| **Estrellas en GitHub**      | 25K+                                                                                                      |
| **Compatibilidad con 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 (instalación de la extensión) / Media (backend autohospedado)                                       |
| **¿Se requiere GPU?**        | En el servidor de Clore.ai (sí); en tu portátil (no)                                                      |
| **Características clave**    | Autocompletado, chat, modo de edición, contexto de la base de código (RAG), comandos personalizados con / |

### Modelos recomendados para programar

| Modelo                | VRAM    | Fortaleza                              | Notas                                          |
| --------------------- | ------- | -------------------------------------- | ---------------------------------------------- |
| `codellama:7b`        | \~6 GB  | Autocompletado rápido                  | Buen punto de partida                          |
| `codellama:13b`       | \~10 GB | Equilibrado                            | La mejor calidad/velocidad para autocompletado |
| `codellama:34b`       | \~22 GB | La mejor calidad de CodeLlama          | Necesita 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                     | Muy sólido en más de 40 idiomas                |
| `qwen2.5-coder:32b`   | \~22 GB | De última generación                   | Mejor modelo abierto de codificación 2024      |
| `starcoder2:15b`      | \~12 GB | Especialista en finalización de código | Compatibilidad con FIM (fill-in-the-middle)    |

## Requisitos

### Requisitos del servidor de Clore.ai

| Nivel           | GPU       | VRAM  | RAM   | Disco  | Precio                                    | Modelos                                              |
| --------------- | --------- | ----- | ----- | ------ | ----------------------------------------- | ---------------------------------------------------- |
| **Económico**   | RTX 3060  | 12 GB | 16 GB | 40 GB  | $0.03–0.07/h                              | CodeLlama 7B, DeepSeek 6.7B, Qwen2.5-Coder 7B        |
| **Recomendado** | RTX 3090  | 24 GB | 32 GB | 80 GB  | $0.07–0.21/h                              | CodeLlama 34B, DeepSeek 33B, Qwen2.5-Coder 32B       |
| **Rendimiento** | RTX 4090  | 24 GB | 32 GB | 80 GB  | $0.14–0.42/h                              | Los mismos modelos que arriba, inferencia más rápida |
| **Potencia**    | A100 40GB | 40 GB | 64 GB | 120 GB | [bare metal](https://clore.ai/bare-metal) | Varios modelos de 34B simultáneamente                |
| **Máximo**      | A100 80GB | 80 GB | 80 GB | 200 GB | [bare metal](https://clore.ai/bare-metal) | 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 a tu servidor de Clore.ai
* **No se necesita GPU local** — toda la inferencia ocurre en Clore.ai

## Inicio rápido

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

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

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

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

# 2. Inicia Ollama con soporte de 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é funcionando
curl http://localhost:11434/

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

# Para 24 GB de 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 "Escribe una función en Python para realizar búsqueda binaria en una lista ordenada"
```

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 en su lugar un túnel SSH (ver [Consejos y mejores prácticas](#tips--best-practices)).
{% endhint %}

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

vLLM ofrece una inferencia más rápida y soporte multiusuario. Ideal si varios desarrolladores comparten un servidor de 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-de-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-de-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

# Probar 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": "Escribe un hola mundo en Rust"}],
    "max_tokens": 200
  }'
```

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

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

```bash
# Configuración rápida de TabbyML para el 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: Instala la extensión Continue.dev

**VS Code:**

1. Abre el panel de extensiones (`Ctrl+Shift+X` / `Cmd+Shift+X`)
2. Busca **"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 → Configuración → Plugins → Marketplace`
2. Busca **"Continue"** e instala
3. Reinicia el IDE; el panel de Continue aparece en la barra lateral derecha

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

Editar `~/.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": "Añadir comentarios al código" },
    { "name": "share", "description": "Exportar la conversación como markdown" },
    { "name": "cmd", "description": "Generar comando de terminal" },
    { "name": "commit", "description": "Generar mensaje de commit de git" }
  ]
}
```

Para **el 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": "no-requerida",
      "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": "token-de-autenticación-si-está-configurado"
  }
}
```

## Configuración

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

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

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

# Mantén el túnel activo (añádelo 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

# Luego 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 un 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>

# Añadir a systemd para el inicio automático al arrancar (Linux)
cat > ~/.config/systemd/user/clore-tunnel.service << 'EOF'
[Unit]
Descripción=Túnel SSH al servidor de codificación de Clore.ai
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
```

### Carga varios modelos para distintas tareas

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

```bash
# En el servidor de 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 automáticamente el intercambio de modelos
# Los tres caben dentro de 24 GB de VRAM con almacenamiento en caché inteligente

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

### Indexación de la base de código (RAG para tu repo)

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

```bash
# En el servidor de Clore.ai — añade 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á automáticamente tu espacio de trabajo abierto.
# Activar reindexación manual: Ctrl+Shift+P → "Continue: Index Codebase"
```

## Aceleración GPU

### Supervisar el rendimiento de la inferencia

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

# Comprueba los tokens por segundo (registros de Ollama)
docker logs ollama --tail 20 -f

# Estadísticas detalladas de la 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** puede alcanzar 50–100 t/s — lo bastante rápido como para sentirse instantáneo en el IDE.

### Ajusta Ollama para mejor rendimiento

```bash
# En el servidor de Clore.ai — optimiza la configuración 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: atiende 2 solicitudes simultáneamente
# OLLAMA_MAX_LOADED_MODELS=2: mantiene 2 modelos en memoria GPU
# OLLAMA_FLASH_ATTENTION=1: habilita flash attention (más rápido, menos memoria)
```

## Consejos y mejores prácticas

### Usa distintos modelos para distintas tareas

Configura Continue.dev con modelos especializados por tipo de tarea — la interfaz te permite cambiar de modelo a mitad de 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, completaciones simples, baja latencia"
    },
    {
      "title": "Autocompletado — StarCoder2 3B",
      "provider": "ollama",
      "model": "starcoder2:3b",
      "apiBase": "http://localhost:11434",
      "contextLength": 4096,
      "description": "Sugerencias de texto fantasma en línea"
    }
  ]
}
```

### Comparación de costos

| Solución              | Costo mensual (uso 8 h/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 compartiendo una sola RTX 3090 de Clore.ai (\~$48/mes en total), el coste por usuario supera al de Copilot mientras ofrece un modelo más grande y privado.

### Apaga cuando no estés programando

Clore.ai cobra por hora. Usa un script sencillo para iniciar/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 orden de Clore.ai para dejar de facturar!"
```

### Usa comandos personalizados de Continue.dev

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

```json
{
  "customCommands": [
    {
      "name": "review",
      "prompt": "Revisa este código en busca de errores, problemas de seguridad y rendimiento. Sé específico y accionable.",
      "description": "Revisión de código"
    },
    {
      "name": "test",
      "prompt": "Escribe pruebas unitarias completas para este código. Incluye casos límite. Usa el mismo lenguaje/framework 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 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 rechazada"     | Ollama no es accesible                                   | Comprueba que el túnel SSH esté activo; verifica `curl http://localhost:11434/` funciona                            |
| El autocompletado no se activa                | No se ha configurado el modelo de autocompletado con Tab | Añade `tabAutocompleteModel` en config.json; actívalo en la configuración de Continue                               |
| Respuestas muy lentas (>30 s el primer token) | Carga del modelo desde disco                             | La primera solicitud carga el modelo en la VRAM — las solicitudes posteriores son rápidas                           |
| Error de "Modelo no encontrado"               | El modelo no se ha descargado                            | Ejecuta `docker exec ollama ollama pull <model-name>` en el servidor de Clore.ai                                    |
| Alta latencia entre tokens                    | Retraso de red o modelo demasiado grande                 | Usa el túnel SSH; cambia a un modelo más pequeño; comprueba el uso de la GPU del servidor                           |
| El contexto de la base de código no funciona  | Falta el modelo de embeddings                            | Descárgalo `nomic-embed-text` a través de 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`                                           |
| Se superó la ventana de contexto              | Archivos/conversaciones largas                           | Reduce `contextLength` en config.json; usa un modelo con un contexto más largo                                      |
| El plugin de JetBrains no se 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 |
| OOM de vLLM 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 un túnel SSH
curl http://<clore-ip>:11434/api/tags        # si el puerto está abierto directamente

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

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

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

# Comprueba los registros de vLLM
docker logs vllm --tail 50 -f

# Reinicia Ollama sin perder los modelos
docker restart ollama
```

### Validación de 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álida')
    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
* [GitHub de Continue.dev](https://github.com/continuedev/continue) — código fuente, incidencias, compatibilidad de modelos
* [Referencia de configuración de Continue.dev](https://docs.continue.dev/reference) — completo `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 de autocompletado especializado 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 programació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 programación
* [DeepSeek-Coder-V2](https://huggingface.co/deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct) — alternativa sólida con contexto largo
* [Marketplace de CLORE.AI](https://clore.ai/marketplace) — alquila servidores GPU


---

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