Key Takeaways
- O VS Code usa a extensão Continue.dev para se conectar a modelos locais (Ollama, LM Studio, vLLM).
- O Cursor é um fork do VS Code com suporte nativo a modelos locais. Você não precisa de nenhuma extensão.
- Melhores modelos locais para código: Qwen3-Coder 7B, Code Llama 13B ou Mistral Small.
- Espere uma latência de completamento de 2-5 segundos em GPUs de consumo com modelos 7B.
- Os completamentos de código locais são práticos hoje para uso pessoal, mas ainda não estão prontos para produção em equipes.
O VS Code (via extensão Continue.dev) e o Cursor podem usar LLMs locais como Qwen3-Coder 7B ou Code Llama 13B para completar código com privacidade, rodando inteiramente na sua própria GPU, sem chave de API nem conexão com a nuvem.
Em vez de enviar seu código para um serviço de IA na nuvem, você pode rodar o modelo de IA no seu próprio computador e conectá-lo ao seu editor de código. O VS Code precisa da extensão gratuita Continue.dev; o Cursor já oferece suporte nativo. Você recebe sugestões no estilo autocompletar sem que seu código saia da sua máquina, embora seja um pouco mais lento que ferramentas na nuvem como o GitHub Copilot.
Como configurar o Continue.dev no VS Code?
O Continue.dev é uma extensão do VS Code para completamentos de código locais e em nuvem.
# 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
Como usar modelos locais no Cursor?
O Cursor é um fork do VS Code otimizado para a programação assistida por IA. Ele tem suporte integrado a modelos locais via 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 completionsQuais modelos são os melhores para código?
⚠️ Regra de VRAM: Tenha sempre 2-3 GB de VRAM livre acima do que o modelo exige. Um modelo 7B em Q4 (4,7 GB) precisa de 8 GB de VRAM no total ao rodar no VS Code ou no Cursor.
Modelo | HumanEval | VRAM | Velocidade | Ideal para |
|---|---|---|---|---|
| Qwen3-Coder 7B | 72% | 4,7 GB | Rápido | Melhor equilíbrio, mais veloz |
| Code Llama 7B | 69% | 4,7 GB | Rápido | Programação geral |
| Mistral Small | 61% | 4,5 GB | Muito rápido | Leve, servidores UE |
| Code Llama 13B | 74% | 8,5 GB | Médio | Melhor qualidade em máquinas de 16 GB |
| DeepSeek-Coder 6.7B | 68% | 4 GB | Rápido | Alternativa leve |
Que latência e VRAM você deve esperar?
A latência de completamento (tempo até o primeiro token) é fundamental para a experiência no IDE. A partir de abril de 2026, estes são os valores típicos:
⚠️ Verificação de realidade da latência: Os completamentos locais são 2-10× mais lentos que os da nuvem. Use o local para trabalho privado; use a nuvem (Copilot, Claude) para programação em que o tempo importa.
💡 Otimização do desempenho: Reduza o `contextLength` de 2048 para 1024 tokens para reduzir a latência pela metade. O contraponto: menos linhas de código de contexto para as sugestões.
Hardware | Modelo | Latência | Vazão |
|---|---|---|---|
| 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 apenas | Qwen3-Coder 7B | 5-10 seg | 3 tokens/seg |
Nota sobre os dados de desempenho: Latência e vazão medidas com o formato Qwen3-Coder 7B Q4_K_M, batch size = 1, em um sistema sem carga (sem tarefas em segundo plano). Sua vazão real depende do sistema operacional, da disponibilidade de VRAM, do formato de quantização e da carga concorrente.
Como configurar os completamentos de código para o melhor desempenho?
Ajuste a experiência com estes parâmetros:
⚠️ Aviso: Em máquinas de 8 GB com modelos 13B, os completamentos podem levar 5-10 segundos, deixando o IDE pouco responsivo. Fique com os modelos 7B para um desempenho fluido.
💡 Dica profissional: Aumente o `debounceWaitMs` para 400-500 ms para reduzir o flicker e evitar mostrar sugestões 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)Quais são os erros comuns ao configurar completamentos de código locais?
- Não ajustar a latência de debounce: Se os completamentos parecerem "lentos", aumente o debounceWaitMs (por exemplo, para 400 ms) para evitar mostrar sugestões incompletas.
- Usar um modelo grande demais para a sua VRAM: Um modelo 13B mais o overhead do editor pode usar mais de 12 GB. Em máquinas de 8 GB, fique com modelos 7B.
- Esperar qualidade de código no nível da nuvem: O GPT-5.6 é significativamente melhor em código que qualquer modelo 7B. Os completamentos locais representam 70-80% da qualidade da nuvem.
- Rodar a inferência na CPU: Os completamentos na CPU são pouco práticos (latência de 5-10 segundos). A GPU é necessária para completamentos utilizáveis.
Perguntas frequentes: Completamentos de código locais
Qual modelo é melhor para completamentos de código com o Ollama?
O Qwen3-Coder 7B oferece o melhor equilíbrio entre velocidade e qualidade, com 72% no HumanEval e apenas 4,7 GB de VRAM. Com 16 GB de VRAM ou mais, o Code Llama 13B (74% no HumanEval, 8,5 GB de VRAM) melhora ainda mais a qualidade.
O Cursor suporta LLMs locais nativamente?
Sim. O Cursor suporta endpoints personalizados compatíveis com OpenAI. Defina a URL base como http://localhost:11434/v1 e insira qualquer chave de API (o Ollama não exige autenticação). Selecione seu modelo Ollama no menu suspenso de modelos e o Cursor encaminhará as solicitações para seu modelo local.
Qual é a VRAM mínima para completamentos de código locais utilizáveis?
8 GB de VRAM é o mínimo para completamentos utilizáveis com um modelo 7B em quantização Q4_K_M (~4,5 GB). Com apenas 8 GB, a margem é pequena. Recomenda-se 12 GB ou mais para uso confortável com Qwen3-Coder 7B ou Code Llama 7B.
Como configuro o Continue.dev no VS Code?
Instale a extensão Continue no VS Code Marketplace e configure-a para usar o Ollama: abra a barra lateral do Continue, clique no seletor de modelo, escolha "Ollama" como provedor, selecione seu modelo (por exemplo, qwen2.5-coder:7b) e salve. O Continue se conectará automaticamente ao Ollama em localhost:11434.
Posso usar LLMs locais para revisão de código e chat no VS Code?
Sim. O Continue.dev oferece tanto o completamento por tabulação quanto um modo de chat inline. Selecione código no seu editor, pressione Cmd/Ctrl+I e digite uma pergunta ou instrução. O modelo local responde dentro do contexto do editor. Isso funciona para revisão de código, sugestões de refatoração e pedidos de explicação.
O que acontece se o Ollama não estiver rodando ao abrir o VS Code?
O Continue.dev exibirá um erro de conexão e os completamentos não aparecerão. Inicie o Ollama com `ollama serve` em um terminal antes de abrir o VS Code. No macOS, você pode configurar o Ollama para iniciar automaticamente ao fazer login nas configurações da barra de menu do Ollama.
Os completamentos de código locais são mais rápidos que os da nuvem?
Não. Os completamentos na nuvem (GitHub Copilot) são mais rápidos graças a servidores otimizados. Os completamentos locais têm maior latência, mas têm custo zero e risco zero para a privacidade.
Posso usar completamentos locais com outros IDEs (PyCharm, Neovim)?
Sim, embora a configuração varie. O PyCharm tem um plugin para o Ollama. Para o Neovim, use o cmp-ollama (plugin de completamentos). Consulte sempre a comunidade do seu IDE para conhecer as integrações disponíveis.
Posso usar modelos em nuvem no Continue ou no Cursor?
Sim. Configure o Continue para usar OpenAI, Claude ou Gemini. Você também pode combiná-los (local para tarefas rápidas, nuvem para código complexo).
Os completamentos de código locais funcionam offline?
Sim. Se você baixou o modelo no Ollama, os completamentos funcionam totalmente offline.
Fontes
- Continue.dev Team. (2026). "Continue Documentation." docs.continue.dev/ -- Official setup guide, config.json reference, and local model integration instructions.
- Cursor. (2026). "Cursor Documentation." docs.cursor.com/ -- Local model configuration, Ollama integration, and inference setup guide.
- Alibaba Qwen Team. (2025). "Qwen3-Coder Technical Report." arXiv:2409.12186. arxiv.org/abs/2409.12186 -- HumanEval and code generation benchmarks for Qwen3-Coder variants.
- DeepSeek-AI. (2024). "DeepSeek-Coder Technical Paper." arXiv:2401.14196. arxiv.org/abs/2401.14196 -- Benchmark data and capability analysis for DeepSeek-Coder family.