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: Qwen2.5-Coder 7B, Llama Code 13B o Mistral 7B.
- Espera una latencia de completación de 2-5 segundos en GPUs de consumo con modelos 7B.
- A partir de abril de 2026, las completaciones de código locales son prácticas para uso personal, pero aún no están listas para producción en equipos.
¿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 |
|---|---|---|---|---|
| Qwen2.5-Coder 7B | 72% | 4,7 GB | Rápido | Mejor equilibrio, más veloz |
| Llama Code 7B | 69% | 4,7 GB | Rápido | Programación general |
| Mistral 7B | 61% | 4,5 GB | Muy rápido | Ligero, servidores UE |
| Llama Code 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 | Qwen2.5-Coder 7B | 0,3-0,5 seg | 150 tokens/seg |
| RTX 4070 GPU | Qwen2.5-Coder 7B | 0,8-1,5 seg | 80 tokens/seg |
| M3 MacBook Pro | Qwen2.5-Coder 7B | 2-3 seg | 20 tokens/seg |
| CPU de 8 núcleos solo | Qwen2.5-Coder 7B | 5-10 seg | 3 tokens/seg |
Nota sobre los datos de rendimiento: Latencia y rendimiento medidos con el formato Qwen2.5-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-4o 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
¿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.
Lecturas relacionadas
- Mejor asistente de código IA para LLM local -- Comparativa completa de Cursor, Continue.dev, Cody, Tabnine y Windsurf con soporte para LLM local.
- Stack de desarrollador con LLM local -- El stack completo que incluye configuración del servidor API y monitoreo en producción más allá de la integración con el IDE.
- Cómo instalar Ollama -- Configura Ollama para completaciones de código.
- Mejores LLMs locales para programación -- Benchmark detallado de modelos de código.
- How to Install LM Studio -- Qué herramienta usar.
- API compatible con OpenAI para LLM local -- APIs para completaciones de código.
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). "Qwen2.5-Coder Technical Report." arXiv:2409.12186. https://arxiv.org/abs/2409.12186 -- HumanEval and code generation benchmarks for Qwen2.5-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.