Codificación AI Continue.dev

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 codificación con IA.

Continue.dev es un asistente de programació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 la inferencia. Apuntando Continue.dev a una GPU potente alquilada en Clore.ai, obtienes:

• Modelos de codificación de primera categoría (34B+ parámetros) que no caben en tu portátil

• Privacidad total — el código permanece en la infraestructura que controlas

• Costos flexibles — paga solo mientras programas (~$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 local de Continue.dev.

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

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

Resumen

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 (instalar extensión) / Medio (backend autohospedado)
¿Se requiere GPU?	En el servidor Clore.ai (sí); en tu portátil (no)
Características clave	Autocompletar, chat, modo edición, contexto del código (RAG), comandos slash personalizados

Modelos recomendados para programación

Modelo	VRAM	Fortaleza	Notas
codellama:7b	~6 GB	Autocompletar rápido	Buen punto de partida
codellama:13b	~10 GB	Equilibrado	Mejor calidad/velocidad para autocompletar
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	Gama alta de código abierto	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	Última generación	Mejor modelo abierto para código 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	Múltiples modelos 34B concurrentes
Máximo	A100 80GB	80 GB	80 GB	200 GB	~$1.10/h	Modelos 70B (CodeLlama 70B)

Requisitos locales (tu máquina)

• VS Code o cualquier IDE 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.

# 1. Haz 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 de VRAM (RTX 3060):
docker exec ollama ollama pull codellama:13b

# Para 24GB 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 rápido de autocompletar (separado del modelo de chat)
docker exec ollama ollama pull starcoder2:3b   # Muy rápido, ideal para autocompletar 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):

# 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 un túnel SSH en su lugar (ver Consejos y mejores prácticas).

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.

# 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 autocompletar FIM)

TabbyML ofrece un autocompletar fill-in-the-middle (FIM) superior — las sugerencias de texto fantasmal en línea. Consulta la guía de TabbyML para los detalles completos de la configuración.

# Configuración rápida de TabbyML para autocompletar en 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. File → 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

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 (autocompletar)",
    "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 la 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:

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

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

# Abre 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 vivo (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

# Conéctate 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 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 inicio automático al arrancar (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 modelo de chat grande y un modelo pequeño de autocompletar simultáneamente:

# 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           # Autocompletar (2 GB)
docker exec ollama ollama pull nomic-embed-text        # Embeddings (0.5 GB)

# Ollama gestiona el intercambio de modelos automáticamente
# Los tres caben 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 repo)

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

# En el servidor 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á tu espacio de trabajo abierto automáticamente.
# Forzar reindexado manual: Ctrl+Shift+P → "Continue: Index Codebase"

Aceleración por GPU

Monitorear el rendimiento de inferencia

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

# Comprueba 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 autocompletar (fill-in-the-middle), starcoder2:3b o codellama:7b logra 50–100 t/s — lo bastante rápido como para sentirse instantáneo en el IDE.

Ajusta Ollama para mejor rendimiento

# En el servidor Clore.ai — optimiza las configuraciones 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 modelos diferentes 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:

{
  "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": "Autocompletar — StarCoder2 3B",
      "provider": "ollama",
      "model": "starcoder2:3b",
      "apiBase": "http://localhost:11434",
      "contextLength": 4096,
      "description": "Sugerencias de texto fantasmal 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 RTX 3090 en Clore.ai (~$48/mes en total), el costo por usuario supera a Copilot mientras proporciona un modelo más grande y privado.

Apaga cuando no estés programando

Clore.ai cobra por hora. Usa un script simple para iniciar/detener el servidor:

# Guarda estos como scripts locales

# start-coding-server.sh
#!/bin/bash
echo "Abriendo túnel SSH hacia 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!"

Usa comandos personalizados de Continue.dev

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

{
  "customCommands": [
    {
      "name": "review",
      "prompt": "Revisa este código en busca de bugs, problemas de seguridad y problemas de rendimiento. Sé específico y accionable.",
      "description": "Revisión de código"
    },
    {
      "name": "test",
      "prompt": "Escribe tests unitarios comprensivos para este código. Incluye casos límite. Usa el mismo lenguaje/marco que el código.",
      "description": "Generar tests"
    },
    {
      "name": "docstring",
      "prompt": "Añade docstrings/comentarios claros y comprensivos 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 "Connection refused"	Ollama no accesible	Comprueba que el túnel SSH esté activo; verifica curl http://localhost:11434/ funciona
Autocompletar no se activa	Modelo de autocompletar de pestaña no configurado	Agregar tabAutocompleteModel en config.json; habilita en la configuración de Continue
Respuestas muy lentas (>30s primer token)	Carga del modelo desde disco	La primera solicitud carga el modelo en VRAM — las solicitudes posteriores son rápidas
Error "Model not found"	Modelo no descargado	Ejecuta docker exec ollama ollama pull <model-name> en el servidor Clore.ai
Latencia alta entre tokens	Lag de red o modelo demasiado grande	Usa túnel SSH; cambia a un modelo más pequeño; comprueba la utilización de la GPU del servidor
Contexto de la base de código no funciona	Falta el modelo de embeddings	Descarga nomic-embed-text vía Ollama; verifica 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	Reducir contextLength en config.json; usa un modelo con contexto más largo
El plugin de JetBrains no carga	Incompatibilidad con la versión del IDE	Actualiza el IDE JetBrains a la última versión; comprueba la matriz de compatibilidad del plugin Continue.dev
vLLM OOM durante la carga	No hay suficiente VRAM	Agregar --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 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 actualmente cargados

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

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

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

# Reinicia Ollama sin perder 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('✅ Config 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 — documentación oficial para todas las integraciones de IDE y opciones de configuración

• GitHub de Continue.dev — código fuente, problemas, 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 en Clore.ai — backend especializado en autocompletar con optimización FIM

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

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

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

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

• CLORE.AI Marketplace — alquila servidores GPU