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.

Todos los ejemplos de servidores GPU usan servidores alquilados a través de Marketplace de CLORE.AI.

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.

Descripción general

Propiedad	Detalles
Proyecto	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	Varios modelos de 34B simultáneamente
Máximo	A100 80GB	80 GB	80 GB	200 GB	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.

# 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):

# 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

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).

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.

# 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 para ver todos los detalles de configuración.

# 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:

{
  "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:

{
  "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):

{
  "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:

# 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

# 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:

# 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:

# 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

# 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

# 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:

{
  "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:

# 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:

{
  "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

# 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

# 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 — documentación oficial para todas las integraciones de IDE y opciones de configuración

• GitHub de Continue.dev — código fuente, incidencias, compatibilidad de modelos

• Referencia de configuración de Continue.dev — completo config.json — esquema

• Ollama en Clore.ai — guía detallada de configuración de Ollama (backend recomendado)

• vLLM en Clore.ai — backend alternativo de alto rendimiento para equipos

• TabbyML — backend de autocompletado especializado con optimización FIM

• Guía de comparación de GPU — elige la GPU adecuada para tu carga de trabajo de programación

• Compatibilidad de modelos — qué modelos caben en qué tamaños de VRAM

• Qwen2.5-Coder — actualmente el mejor modelo abierto para programación

• DeepSeek-Coder-V2 — alternativa sólida con contexto largo

• Marketplace de CLORE.AI — alquila servidores GPU