Key Takeaways
- VS Code usa la extensión Continue.dev para conectarse a modelos locales (Ollama, LM Studio, vLLM).
- Cursor es un fork de VS Code con soporte nativo para modelos locales. No necesitas ninguna extensión.
- Mejores modelos locales para código: Qwen3-Coder 7B, Code Llama 13B o Mistral Small.
- Espera una latencia de completación de 2-5 segundos en GPUs de consumo con modelos 7B.
- Las completaciones de código locales son prácticas hoy para uso personal, pero aún no están listas para producción en equipos.
VS Code (mediante la extensión Continue.dev) y Cursor pueden usar LLM locales como Qwen3-Coder 7B o Code Llama 13B para completaciones de código privadas, ejecutándose por completo en tu propia GPU sin clave de API ni conexión a la nube.
En lugar de enviar tu código a un servicio de IA en la nube, puedes ejecutar el modelo de IA en tu propio ordenador y conectarlo a tu editor de código. VS Code necesita la extensión gratuita Continue.dev; Cursor lo admite de forma nativa. Obtienes sugerencias de tipo autocompletado sin que tu código salga de tu máquina, aunque es algo más lento que herramientas en la nube como GitHub Copilot.
¿Cómo configurar Continue.dev en VS Code?
Continue.dev es una extensión de VS Code para completaciones de código locales y en la nube.
# 1. Install Continue from VS Code marketplace
# Search "Continue" and click Install
# 2. Make sure Ollama is running
ollama serve
# 3. Open Continue settings (Ctrl+Shift+P → Continue: Open Settings)
# config.json opens
# 4. Configure for your local model:
# Replace the default settings with:
{
"models": [{
"title": "Ollama",
"provider": "ollama",
"model": "qwen2.5-coder:7b",
"apiBase": "http://localhost:11434"
}],
"tabAutocompleteModel": {
"title": "Ollama",
"provider": "ollama",
"model": "qwen2.5-coder:7b"
}
}
# 5. Start typing code and press Tab for completions
# Or Ctrl+Shift+\ to manually trigger completions
¿Cómo usar modelos locales en Cursor?
Cursor es un fork de VS Code optimizado para la programación asistida por IA. Tiene soporte integrado para modelos locales mediante Ollama.
# 1. Download Cursor from cursor.sh
# 2. Make sure Ollama is running
ollama serve
# 3. Open Cursor Settings (Cmd/Ctrl + ,)
# 4. Search "Model" and set:
# - Model Provider: "Ollama"
# - Model: "qwen2.5-coder:7b" (or your choice)
# - API Base: "http://localhost:11434"
# 5. Type code and press Tab for inline completions
# 6. Ctrl+K for multi-line completions¿Qué modelos son los mejores para código?
⚠️ Regla de VRAM: Ten siempre 2-3 GB de VRAM libre por encima de lo que requiere el modelo. Un modelo 7B en Q4 (4,7 GB) necesita 8 GB de VRAM en total al ejecutarse en VS Code o Cursor.
| Modelo | HumanEval | VRAM | Velocidad | Ideal para |
|---|---|---|---|---|
| Qwen3-Coder 7B | 72% | 4,7 GB | Rápido | Mejor equilibrio, más veloz |
| Code Llama 7B | 69% | 4,7 GB | Rápido | Programación general |
| Mistral Small | 61% | 4,5 GB | Muy rápido | Ligero, servidores UE |
| Code Llama 13B | 74% | 8,5 GB | Medio | Mejor calidad en máquinas de 16 GB |
| DeepSeek-Coder 6.7B | 68% | 4 GB | Rápido | Alternativa ligera |
¿Qué latencia y VRAM debes esperar?
La latencia de completación (tiempo hasta el primer token) es fundamental para la experiencia en el IDE. A partir de abril de 2026, estos son los valores típicos:
⚠️ Verificación de realidad de la latencia: Las completaciones locales son 2-10× más lentas que las de la nube. Usa lo local para trabajo privado; usa la nube (Copilot, Claude) para programación donde el tiempo importa.
💡 Optimización del rendimiento: Reduce `contextLength` de 2048 a 1024 tokens para reducir la latencia a la mitad. La contrapartida: menos líneas de código de contexto para las sugerencias.
| Hardware | Modelo | Latencia | Rendimiento |
|---|---|---|---|
| RTX 4090 GPU | Qwen3-Coder 7B | 0,3-0,5 seg | 150 tokens/seg |
| RTX 4070 GPU | Qwen3-Coder 7B | 0,8-1,5 seg | 80 tokens/seg |
| M3 MacBook Pro | Qwen3-Coder 7B | 2-3 seg | 20 tokens/seg |
| CPU de 8 núcleos solo | Qwen3-Coder 7B | 5-10 seg | 3 tokens/seg |
Nota sobre los datos de rendimiento: Latencia y rendimiento medidos con el formato Qwen3-Coder 7B Q4_K_M, tamaño de lote = 1, en un sistema sin carga (sin tareas en segundo plano). Tu rendimiento real depende del sistema operativo, la disponibilidad de VRAM, el formato de cuantización y la carga concurrente.
¿Cómo configurar las completaciones de código para obtener el mejor rendimiento?
Ajusta la experiencia con estos parámetros:
⚠️ Advertencia: En máquinas de 8 GB con modelos 13B, las completaciones pueden tardar 5-10 segundos, haciendo que el IDE se sienta poco responsivo. Quédate con los modelos 7B para un rendimiento fluido.
💡 Consejo profesional: Aumenta `debounceWaitMs` a 400-500 ms para reducir el parpadeo y evitar mostrar sugerencias incompletas.
# config.json advanced settings
{
"tabAutocompleteModel": {
"contextLength": 2048, # How much code context to send
"maxTokens": 50 # Max tokens per completion
},
"completionOptions": {
"maxContextTokens": 1024,
"maxSuggestionsCount": 5,
"debounceWaitMs": 200 # Wait before showing completions (ms)
},
# For faster inference, use smaller context:
"models": [{
"contextLength": 1024 # Smaller context = faster
}]
}
# For best speed on 8GB machines:
# - Use 7B model (not 13B)
# - Set maxTokens to 30
# - Set debounceWaitMs to 500 (less flickering)¿Cuáles son los errores comunes al configurar completaciones de código locales?
- No ajustar la latencia de debounce: Si las completaciones se sienten "lentas", aumenta debounceWaitMs (por ejemplo, a 400 ms) para evitar mostrar sugerencias incompletas.
- Usar un modelo demasiado grande para tu VRAM: Un modelo 13B más la sobrecarga del editor puede usar más de 12 GB. En máquinas de 8 GB, quédate con modelos 7B.
- Esperar calidad de código al nivel de la nube: GPT-5.6 es significativamente mejor en código que cualquier modelo 7B. Las completaciones locales representan el 70-80% de la calidad de la nube.
- Ejecutar la inferencia en CPU: Las completaciones en CPU son poco prácticas (latencia de 5-10 segundos). La GPU es necesaria para obtener completaciones utilizables.
Preguntas frecuentes: Completaciones de código locales
¿Qué modelo es mejor para completaciones de código con Ollama?
Qwen3-Coder 7B ofrece el mejor equilibrio entre velocidad y calidad, con un 72% en HumanEval y solo 4,7 GB de VRAM. Con 16 GB de VRAM o más, Code Llama 13B (74% en HumanEval, 8,5 GB de VRAM) mejora aún más la calidad.
¿Cursor soporta LLMs locales de forma nativa?
Sí. Cursor admite endpoints personalizados compatibles con OpenAI. Configura la URL base como http://localhost:11434/v1 e introduce cualquier clave de API (Ollama no requiere autenticación). Selecciona tu modelo de Ollama en el desplegable de modelos y Cursor enviará las solicitudes a tu modelo local.
¿Cuál es la VRAM mínima para completaciones de código locales utilizables?
8 GB de VRAM es el mínimo para completaciones utilizables con un modelo 7B en cuantización Q4_K_M (~4,5 GB). Con solo 8 GB tienes poco margen. Se recomiendan 12 GB o más para un uso cómodo con Qwen3-Coder 7B o Code Llama 7B.
¿Cómo configuro Continue.dev en VS Code?
Instala la extensión Continue desde el VS Code Marketplace y configúrala para usar Ollama: abre la barra lateral de Continue, haz clic en el selector de modelo, elige "Ollama" como proveedor, selecciona tu modelo (por ejemplo, qwen2.5-coder:7b) y guarda. Continue se conectará automáticamente a Ollama en localhost:11434.
¿Puedo usar LLMs locales para revisión de código y chat en VS Code?
Sí. Continue.dev ofrece tanto completado por tabulación como un modo de chat en línea. Selecciona código en tu editor, pulsa Cmd/Ctrl+I, y escribe una pregunta o instrucción. El modelo local responde dentro del contexto del editor. Funciona para revisión de código, sugerencias de refactorización y solicitudes de explicación.
¿Qué ocurre si Ollama no está en ejecución al abrir VS Code?
Continue.dev mostrará un error de conexión y no aparecerán completaciones. Inicia Ollama con `ollama serve` en una terminal antes de abrir VS Code. En macOS, puedes configurar Ollama para que se inicie automáticamente al iniciar sesión desde los ajustes de la barra de menú de Ollama.
¿Las completaciones de código locales son más rápidas que las de la nube?
No. Las completaciones en la nube (GitHub Copilot) son más rápidas gracias a servidores optimizados. Las completaciones locales tienen mayor latencia, pero tienen coste cero y cero riesgo para la privacidad.
¿Puedo usar completaciones locales con otros IDEs (PyCharm, Neovim)?
Sí, aunque la configuración varía. PyCharm tiene un plugin para Ollama. Para Neovim, usa cmp-ollama (plugin de completaciones). Consulta siempre la comunidad de tu IDE para conocer las integraciones disponibles.
¿Puedo usar modelos en la nube en Continue o Cursor?
Sí. Configura Continue para usar OpenAI, Claude o Gemini. También puedes combinarlos (local para tareas rápidas, nube para código complejo).
¿Las completaciones de código locales funcionan sin conexión?
Sí. Si has descargado el modelo en Ollama, las completaciones funcionan completamente sin conexión.
Fuentes
- Continue.dev Team. (2026). "Continue Documentation." https://docs.continue.dev/ -- Official setup guide, config.json reference, and local model integration instructions.
- Cursor. (2026). "Cursor Documentation." https://docs.cursor.com/ -- Local model configuration, Ollama integration, and inference setup guide.
- Alibaba Qwen Team. (2025). "Qwen3-Coder Technical Report." arXiv:2409.12186. https://arxiv.org/abs/2409.12186 -- HumanEval and code generation benchmarks for Qwen3-Coder variants.
- DeepSeek-AI. (2024). "DeepSeek-Coder Technical Paper." arXiv:2401.14196. https://arxiv.org/abs/2401.14196 -- Benchmark data and capability analysis for DeepSeek-Coder family.