Substitua o GitHub Copilot: Ollama + Continue.dev

laptop_mac macOS Sonoma Intermediate schedule 8 min read

by Alex Rivera • May 14, 2024

Step 1 O Custo do Autocomplete em Nuvem vs. IA Local

Cada tecla pressionada no VS Code com o GitHub Copilot ativo é transmitida para a infraestrutura OpenAI hospedada no Azure da Microsoft. Isso não é teoria conspiratória — é a arquitetura do produto documentada. Seus algoritmos proprietários, lógica de negócios interna, funcionalidades inéditas e decisões arquiteturais estão todas saindo da sua máquina. Para desenvolvedores individuais trabalhando em projetos pessoais, esse tradeoff é frequentemente aceitável. Para equipes construindo software comercialmente sensível, trata-se de um risco material de segurança e conformidade.

Depois há a dimensão financeira.

A Realidade dos Preços do GitHub Copilot

Para uma organização de engenharia de médio porte com 50 desenvolvedores no tier Business, você está olhando para $11.400 por ano — pagos indefinidamente, a um fornecedor externo, sem qualquer propriedade do modelo subjacente ou garantia de estabilidade de preços. A Microsoft já revisou os preços do Copilot para cima desde o lançamento, e não há nenhuma razão estrutural para esperar que essa tendência se reverta.

O Que "IA Local" Realmente Significa

Executar um modelo local via Ollama muda completamente a equação. O custo computacional é o seu hardware existente. O modelo de privacidade é absoluto — nenhum dado sai da sua máquina. A latência é frequentemente menor do que a do autocomplete baseado em nuvem, porque você elimina a sobrecarga de ida e volta pela rede até servidores de inferência remotos.

Cloud Copilot flow:
Keypress → VS Code → HTTPS → Azure OpenAI → Inference → Response → VS Code

Local Ollama flow:
Keypress → VS Code → localhost:11434 → Inference → Response → VS Code

O caminho de inferência via localhost remove toda uma categoria de modos de falha: interrupções de API, limitação de taxa, interferência de proxies corporativos e variação de latência geográfica. Desenvolvedores atrás de firewalls corporativos rígidos que anteriormente não conseguiam usar o Copilot podem agora executar um modelo de código totalmente capaz sem tocar no perímetro de rede.

Os Custos Ocultos da Dependência de Nuvem

Além das taxas de licenciamento, o autocomplete em nuvem introduz um acoplamento operacional que é fácil de subestimar:

• Aprisionamento do fornecedor: O fluxo de trabalho da sua equipe passa a depender de um serviço de terceiros com controle unilateral sobre preços, disponibilidade e termos de serviço.
• Sobrecarga de conformidade: Muitas indústrias regulamentadas (saúde, finanças, defesa) exigem acordos formais de processamento de dados e revisões de segurança para qualquer ferramenta que transmita código externamente. O processo de aprovação do Copilot nesses ambientes é não-trivial.
• Vazamento de janela de contexto: Os modelos em nuvem recebem não apenas seu arquivo atual, mas buffers de contexto adjacentes — arquivos vizinhos, abas abertas recentemente e metadados do repositório, dependendo da configuração.
• Lacunas na trilha de auditoria: Quando sugestões de código vêm de uma caixa-preta externa, atribuir a proveniência de propriedade intelectual torna-se complicado em litígios ou disputas de licenciamento.

Onde os Modelos Locais São Competitivos Hoje

Modelos quantizados modernos como Code Llama 13B e StarCoder2 7B rodando em hardware de consumo alcançam qualidade de autocomplete genuinamente competitiva com o Copilot para os cenários mais comuns: geração de boilerplate, completar assinaturas de funções, scaffolding de testes e implementações de algoritmos comuns. A diferença se estreita ainda mais quando o modelo opera sobre código em linguagens e padrões nos quais foi especificamente treinado.

O cálculo é direto: custo marginal zero, soberania completa sobre os dados e nenhuma dependência externa versus uma conta SaaS crescente e um acordo implícito de compartilhar sua base de código com um provedor de inferência em nuvem. Para equipes comprometidas com a propriedade de longo prazo do conjunto de ferramentas, a abordagem local-first não é um compromisso — é a escolha arquitetural mais defensável.

Step 2 Pré-requisitos: VS Code e Ollama

Antes de mergulhar na configuração, você precisa ter dois componentes fundamentais definidos e verificados. Pular a validação adequada dos pré-requisitos é a razão mais comum pela qual desenvolvedores desperdiçam horas depurando o que deveria ser uma configuração de IA local direta. Acerte esses, e tudo que vem depois se torna mecânico.

Visual Studio Code

Você precisa do VS Code 1.80 ou superior. A extensão Continue.dev depende de APIs modernas do VS Code para completar texto inline no estilo ghost-text, e versões mais antigas falharão silenciosamente ou produzirão comportamento degradado.

Verifique sua versão pela linha de comando:

code --version

Saída esperada (a sua pode ser mais recente):

1.89.1
e170252f762678dec6ca2cc69aba1864a9a1f8ad
x64

Se você estiver usando um fork como VSCodium, o Continue.dev é totalmente compatível — apenas certifique-se de obter a extensão do Open VSX Registry em vez do Microsoft Marketplace, já que o VSCodium não inclui o host de extensões proprietário da Microsoft por padrão.

Ollama

O Ollama é o runtime de modelos local que gerencia downloads de modelos, gerenciamento de quantização e expõe uma API REST compatível com OpenAI em localhost:11434. Essa camada de compatibilidade é precisamente o motivo pelo qual o Continue.dev se integra a ele tão facilmente — nenhuma arquitetura de plugin personalizada é necessária.

Instalação por plataforma:

Após a instalação, inicie o daemon do Ollama:

ollama serve

No macOS, o Ollama roda automaticamente como um aplicativo da barra de menus após a instalação. No Linux, você pode querer configurá-lo como um serviço systemd:

sudo systemctl enable ollama
sudo systemctl start ollama

Verifique se a API está ativa:

curl http://localhost:11434/api/tags

Uma resposta bem-sucedida retorna um objeto JSON listando seus modelos instalados localmente. Uma lista vazia está correto neste estágio — os downloads dos modelos ocorrem em uma etapa posterior.

{
  "models": []
}

Considerações de Hardware

É aqui que a maioria dos tutoriais te deixa na mão. Seu hardware determina diretamente quais modelos são viáveis e em qual nível de quantização.

O Ollama automaticamente descarrega camadas para a sua GPU via Metal (Apple Silicon), CUDA (NVIDIA) ou ROCm (AMD). Nenhuma configuração manual é necessária — o Ollama detecta seu hardware e otimiza o descarregamento de camadas de forma transparente.

Nota crítica para usuários de Apple Silicon: A memória unificada é compartilhada entre CPU e GPU. Um MacBook Pro M3 com 16 GB pode executar um modelo 13B confortavelmente porque não há limite de VRAM discreta. Este é um dos argumentos mais sólidos para o Apple Silicon em fluxos de trabalho de IA local.

Confirmando Seu Ambiente

Execute esta verificação rápida de sanidade antes de prosseguir:

# Confirm VS Code version
code --version

# Confirm Ollama is running and responsive
curl -s http://localhost:11434/api/tags | python3 -m json.tool

# Confirm GPU acceleration (Ollama logs)
ollama run llama3.2:1b "say ok"

Observe a saída do terminal do Ollama durante a inferência do modelo. Você deve ver contagens de descarregamento de camadas referenciando sua GPU. Se tudo rodar na CPU, revise a instalação dos seus drivers antes de baixar modelos de código maiores.

Com ambos os pré-requisitos confirmados, você está pronto para instalar o Continue.dev e conectar tudo.

Step 3 Passo 1: Instalando a Extensão Continue.dev

O Continue.dev é a pedra angular de toda esta configuração — um assistente de código AI de código aberto que atua como um substituto direto para o GitHub Copilot, mas com uma diferença arquitetural crítica: ele roteia suas requisições para onde você determinar, incluindo uma instância do Ollama rodando localmente. Sem telemetria. Sem egresso para a nuvem. Sem assinatura.

Instalando pelo Marketplace do VS Code

O caminho de instalação mais simples passa pelo Marketplace de Extensões do VS Code, diretamente dentro do editor:

1. Abra o VS Code
2. Pressione Ctrl+Shift+X (Windows/Linux) ou Cmd+Shift+X (macOS) para abrir o painel de Extensões
3. Pesquise por "Continue"
4. Localize a extensão publicada por Continue (o ícone é um logotipo distinto com gradiente roxo)
5. Clique em Instalar

Alternativamente, instale pela linha de comando usando o VS Code CLI:

code --install-extension Continue.continue

Ou se você estiver usando o VS Codium (o fork sem telemetria), a extensão está disponível no Open VSX Registry:

codium --install-extension Continue.continue

Nota: O Continue.dev também suporta IDEs JetBrains (IntelliJ, PyCharm, GoLand, etc.) via um plugin separado, mas este guia foca exclusivamente na integração com VS Code.

Verificando a Instalação

Uma vez instalado, você deve ver duas mudanças imediatas no seu ambiente VS Code:

Clique no ícone do Continue na Activity Bar para abrir o painel lateral. Na primeira inicialização, o Continue apresentará um fluxo de integração que solicita a conexão de um provedor. Você pode pular ou ignorar isso — vamos conectar o Ollama manualmente no próximo passo editando o config.json diretamente, o que nos dá muito mais controle do que o assistente gráfico.

Entendendo a Arquitetura da Extensão

Antes de avançar, vale a pena entender o que o Continue realmente instala e como ele se comunica:

VS Code Extension (Continue.dev)
        │
        ▼
  config.json  ──────────────────────────────────────────────────┐
        │                                                          │
        ▼                                                          ▼
  Chat Provider (LLM)                               Autocomplete Provider (LLM)
  e.g., Ollama → llama3                             e.g., Ollama → starcoder2
        │                                                          │
        └────────────────────────┬─────────────────────────────────┘
                                 │
                                 ▼
                    http://localhost:11434  (Ollama REST API)

O Continue separa chat e autocomplete em dois provedores configuráveis independentemente. Esta é uma distinção poderosa — você pode rodar um modelo grande com ajuste para instrução, como llama3 ou deepseek-coder, para consultas conversacionais, enquanto usa um modelo leve de fill-in-the-middle, como starcoder2:3b, para completar inline com baixa latência. Nenhuma outra alternativa mainstream ao Copilot expõe esse nível de granularidade de provedor.

Localizando o Arquivo config.json

Todo o comportamento do Continue é controlado por um único arquivo JSON. Saiba onde ele reside:

Você pode abri-lo diretamente de dentro do VS Code usando o ícone de engrenagem de configurações no painel do Continue, ou navegar até ele manualmente no seu terminal:

# macOS / Linux
cat ~/.continue/config.json

# Windows (PowerShell)
Get-Content "$env:USERPROFILE\.continue\config.json"

Com a extensão instalada e o arquivo de configuração localizado, você está pronto para apontar o Continue para sua instância local do Ollama.

Step 4 Passo 2: Configurando o config.json para o Ollama

Uma vez que o Continue.dev esteja instalado, todo o comportamento da extensão é governado por um único arquivo: config.json. É aqui que você conecta o Continue à sua instância local do Ollama, define quais modelos tratam de chat versus autocomplete e ajusta os parâmetros de desempenho. Acertar este arquivo é a diferença entre uma configuração lenta e não confiável e uma que rivaliza com o GitHub Copilot em responsividade.

Localizando o config.json

O Continue armazena sua configuração no seu diretório home:

Você também pode abri-lo diretamente do VS Code usando a barra lateral do Continue — clique no ícone de engrenagem na parte inferior do painel do Continue, e ele abrirá o config.json no editor.

A Configuração Mínima para o Ollama

Abaixo está um config.json de referência pronto para produção que conecta o Continue a uma instância do Ollama rodando localmente para chat e autocomplete por tab:

{
  "models": [
    {
      "title": "CodeLlama 13B (Chat)",
      "provider": "ollama",
      "model": "codellama:13b",
      "apiBase": "http://localhost:11434"
    }
  ],
  "tabAutocompleteModel": {
    "title": "StarCoder2 3B (Autocomplete)",
    "provider": "ollama",
    "model": "starcoder2:3b",
    "apiBase": "http://localhost:11434"
  },
  "tabAutocompleteOptions": {
    "useCopyBuffer": false,
    "maxPromptTokens": 1024,
    "prefixPercentage": 0.85
  },
  "allowAnonymousTelemetry": false
}

Por que dois modelos separados? Os modelos de chat são otimizados para seguir instruções e manter diálogos de múltiplos turnos. Os modelos de autocomplete — particularmente aqueles treinados com Fill-in-the-Middle (FIM) — são especificamente ajustados para prever código dado um contexto de prefixo e sufixo. Misturar os dois degrada ambas as experiências.

Detalhando Cada Campo

Array models — Define os modelos disponíveis no painel de chat do Continue. Você pode adicionar múltiplas entradas e alternar entre elas em tempo de execução. Cada objeto requer: - provider: definido como "ollama" para inferência local - model: a tag exata conforme aparece em ollama list - apiBase: o endpoint REST padrão do Ollama; só altere isso se você remapeou a porta

tabAutocompleteModel — Uma entrada dedicada para autocomplete inline. Este modelo é acionado a cada pausa no ritmo de digitação, portanto quanto menor e mais rápido, melhor aqui. Um modelo de 3B–7B parâmetros com suporte a FIM é o ponto ideal.

tabAutocompleteOptions — Controle refinado sobre o motor de autocomplete:

allowAnonymousTelemetry — Defina isso como false. Você está rodando IA local especificamente para manter seu código fora de servidores de terceiros; não há razão para enviar telemetria para o pipeline de análise do Continue.

Verificando a Conexão

Após salvar o config.json, confirme que o Ollama é acessível pelo Continue abrindo a Paleta de Comandos do VS Code (Cmd+Shift+P / Ctrl+Shift+P) e executando:

Continue: Open Debug Panel

Você deve ver um indicador de status verde e um ping bem-sucedido ao modelo. Se encontrar um erro de connection refused, verifique se o Ollama está rodando com:

ollama serve
# or check its status
curl http://localhost:11434/api/tags

Uma resposta JSON válida listando seus modelos baixados confirma que a API está ativa e o Continue pode prosseguir para servir completions.

Step 5 Passo 3: Baixando Code Llama ou StarCoder2

Com o Continue.dev instalado e seu config.json configurado, a próxima decisão crítica é qual modelo você realmente baixa para sua máquina. Para completar código local e chat, dois modelos dominam a conversa: Code Llama (Meta) e StarCoder2 (BigCode/Hugging Face). Ambos rodam excelentemente através do Ollama, mas têm pontos fortes significativamente diferentes. Vamos analisá-los e depois percorrer os comandos exatos de download.

Comparação de Modelos em Resumo

Recomendação: Se você tiver 8 GB de VRAM ou RAM disponíveis, comece com codellama:7b-code para uma experiência equilibrada. Se você está focado puramente na qualidade do autocomplete inline e suporte multilinguagem, o starcoder2:7b frequentemente supera em benchmarks de fill-in-the-middle (FIM).

Baixando o Code Llama via Ollama

O Ollama torna o gerenciamento de modelos trivialmente simples. Abra seu terminal e execute:

# Lightweight 7B instruct variant — best starting point
ollama pull codellama:7b-instruct

# 7B code-specialized variant — better raw completion, less chat
ollama pull codellama:7b-code

# If you have the hardware headroom (13B is noticeably sharper)
ollama pull codellama:13b-instruct

A variante instruct entende instruções em linguagem natural e é ideal para o painel de chat dentro do Continue.dev. A variante code é simplificada e ajustada puramente para tarefas de completion — pense nela como a variante "motor de autocomplete".

Após o download, verifique se o modelo está disponível:

ollama list

Você deve ver uma saída semelhante a:

NAME                    ID              SIZE    MODIFIED
codellama:7b-instruct   8fdf8f752f6e    3.8 GB  2 minutes ago

Baixando o StarCoder2 via Ollama

O StarCoder2 foi construído especificamente para tarefas de fill-in-the-middle (FIM) — exatamente o que o autocomplete de IDE utiliza. Ele foi treinado em mais de 600 linguagens de programação do dataset The Stack v2, tornando-o excepcionalmente abrangente.

# 3B — runs on nearly any modern machine, including CPU-only
ollama pull starcoder2:3b

# 7B — sweet spot for quality vs. resource usage
ollama pull starcoder2:7b

# 15B — requires ~10+ GB VRAM, but delivers near-Copilot quality
ollama pull starcoder2:15b

Teste o modelo imediatamente no seu terminal para confirmar que está respondendo corretamente:

ollama run starcoder2:7b "Write a Python function to flatten a nested list."

Se você obtiver uma saída coerente e sintaticamente correta, seu modelo está pronto para ser consumido pelo Continue.dev.

Uma Nota sobre Restrições de Hardware

Não se deixe intimidar pelas contagens de parâmetros maiores. Modelos quantizados (que o Ollama baixa por padrão — tipicamente quantização Q4_K_M) são dramaticamente menores do que seus tamanhos teóricos. Um modelo de 7B em quantização Q4 roda confortavelmente em:

• Macs com Apple Silicon (M1/M2/M3) com 16 GB de memória unificada — aceleração GPU quase nativa via Metal
• GPUs NVIDIA com 6–8 GB de VRAM (RTX 3060, 4060, etc.)
• Máquinas apenas com CPU com 16+ GB de RAM — mais lento, mas totalmente funcional para chat; a latência do autocomplete será perceptível

Se você estiver limitado à CPU, prefira fortemente o starcoder2:3b ou codellama:7b-code — seu menor consumo de memória se traduz diretamente em geração de tokens mais rápida e uma experiência de autocomplete mais responsiva.

Uma vez que seu modelo escolhido seja baixado e verificado, o Continue.dev o descobrirá automaticamente através do endpoint da API do Ollama (http://localhost:11434) configurado no Passo 2 — nenhuma vinculação adicional é necessária.

Step 6 Melhores Práticas para Autocomplete Local e Chat

Colocar o stack em funcionamento é apenas metade da batalha. Extrair produtividade máxima de uma configuração de IA local requer escolhas deliberadas de configuração, hábitos disciplinados de prompt e uma compreensão clara de onde os modelos locais se destacam versus onde vão te frustrar.

Estratégia de Seleção de Modelos

Nem todos os modelos são criados iguais, e a ferramenta certa depende da tarefa em mãos. Execute modelos separados para autocomplete e chat em vez de forçar um único modelo a fazer os dois.

O insight-chave: autocomplete é sensível à latência, chat é sensível à qualidade. Um modelo de 3B respondendo em 150ms parece mágico para completions. Esse mesmo modelo dando uma resposta superficial a uma questão arquitetural complexa parece quebrado.

Ajustando o Comportamento do Autocomplete no config.json

As configurações padrão de autocomplete no Continue.dev são conservadoras. Ajuste-as para uma experiência melhor:

{
  "tabAutocompleteModel": {
    "title": "StarCoder2 3B",
    "provider": "ollama",
    "model": "starcoder2:3b",
    "apiBase": "http://localhost:11434"
  },
  "tabAutocompleteOptions": {
    "useCopyBuffer": false,
    "maxPromptTokens": 1024,
    "prefixPercentage": 0.85,
    "multilineCompletions": "always",
    "debounceDelay": 300
  }
}

Principais opções explicadas:

• debounceDelay: 300 — Aguarda 300ms após sua última tecla pressionada antes de disparar uma requisição de completion. Valores menores parecem mais responsivos, mas sobrecarregam sua GPU. Encontre seu limiar.
• prefixPercentage: 0.85 — Aloca 85% da janela de contexto para o código antes do cursor. Isso é ideal pois o modelo precisa do máximo de contexto de prefixo para produzir completions relevantes.
• multilineCompletions: "always" — Força o modelo a tentar completar blocos inteiros, não apenas linhas únicas. Essencial para geração de boilerplate.
• maxPromptTokens: 1024 — Mantém as requisições enxutas. Valores maiores melhoram a qualidade marginalmente, mas aumentam a latência significativamente em hardware de consumo.

Gerenciamento de Contexto para Chat

A interface de chat é onde a maioria dos desenvolvedores subutiliza o Continue.dev. Use os provedores de contexto integrados de forma agressiva:

• @file — Referencia um arquivo específico diretamente no seu prompt
• @codebase — Dispara uma busca por embeddings em todo o seu repositório (requer configuração de um modelo de embeddings)
• @terminal — Cola a saída mais recente do seu terminal no contexto
• @problems — Injeta o conteúdo do painel de Problemas do VS Code, perfeito para depurar erros de compilador

Exemplo de fluxo de trabalho para depuração:

@problems @file src/auth/middleware.ts

The JWT validation is throwing a 401 on every request even with a valid token.
Walk me through what could cause this and show me the fix.

Este único prompt fornece ao modelo a mensagem de erro, o arquivo-fonte relevante e uma declaração clara do problema — melhorando drasticamente a qualidade da saída.

Dicas de Otimização de Hardware

Usuários de GPU (NVIDIA/AMD): Certifique-se de que o Ollama está realmente usando sua GPU e não retrocedendo para a CPU:

# Verify GPU utilization while a model is loaded
ollama ps

# Check VRAM usage
nvidia-smi  # NVIDIA
rocm-smi    # AMD

Se ollama ps mostrar 100% CPU, você provavelmente tem um problema de estouro de VRAM. Reduza para uma quantização menor:

# Pull a smaller quantized variant
ollama pull codellama:13b-code-q4_K_M

Usuários apenas com CPU: Mantenha os modelos de autocomplete em 3B parâmetros ou abaixo. Use quantização q4_0 para o menor consumo de memória e defina numThreads no ambiente do Ollama para corresponder à contagem de núcleos físicos (não os por hyperthreading):

```bash OLLAMA_NUM_PARALLEL=1 OLLAMA_MAX

Continue Reading

Performance

Mistral 7B vs Llama 3 on Apple Silicon

Tools

Best GUI clients for Local LLMs

Advanced

Quantization 101: Speed up your Inference