Claude Code com Ollama: Como Executar Revisão de Código Completamente Local (2026)

Por que executar Claude Code localmente?

O apelo é direto. Se você está revisando código proprietário, trabalhando sob restrições sensíveis à segurança ou simplesmente deseja evitar ferramentas dependentes de nuvem, executar a análise de código localmente oferece três vantagens concretas:

• Privacidade total. Seu código nunca deixa sua máquina. Sem transmissão, sem registro, sem acesso de terceiros.
• Sem assinaturas. Depois de configurar a infraestrutura, não há custos por solicitação ou taxas de API.
• Sem bloqueio. Você controla quais modelos executam onde e pode facilmente trocá-los ou personalizá-los.

A desvantagem também é direta: modelos de código aberto locais tendem a ser menos capazes do que Claude (a versão em nuvem). Eles são melhores em geração de código e explicação, menos precisos em raciocínio complexo em múltiplas etapas. Para muitas tarefas de revisão de código — detectar bugs óbvios, verificar estilo, identificar problemas de segurança — são mais do que adequados. Para análise arquitetônica nuançada, você ainda pode preferir raciocínio baseado em nuvem.

O que você precisa: ferramentas e hardware

Você precisará de três componentes: Ollama (o tempo de execução do modelo local), um LLM capaz de código e Claude Code (a estrutura de agente do Anthropic). Vamos primeiro examinar a linha de base de hardware, pois ela afeta a experiência.

Requisitos de hardware

Para revisão de código realmente utilizável — não demonstrações de brinquedo — você deve se esforçar para:

Um Mac Apple Silicon com 32 GB de memória unificada funciona muito bem. No lado do PC, um RTX 3090 ou RTX 4080 oferece espaço confortável para modelos maiores. Se você tiver apenas 8 GB VRAM, você ainda pode executar modelos menores de 7B, mas espere inferência mais lenta e possíveis desacelerações ao processar arquivos grandes.

Escolha do modelo

Nem todos os modelos abertos são igualmente úteis para trabalho com código. Dois se destacam no início de 2026:

• Qwen 2.5 Coder. Disponível em variantes de 7B e 32B. Excelente geração e análise de código. A versão 7B se encaixa confortavelmente em 8GB VRAM; a 32B precisa de 16-20GB. Inferência rápida, bom acompanhamento de instruções.
• GLM 4.7 Flash. Muito rápido, janela de contexto de 128K. Bom para revisar arquivos grandes de uma vez. Mais leve que Qwen em termos de memória, mas ligeiramente menos preciso em tarefas específicas de código.

Para a maioria dos desenvolvedores começando, Qwen 2.5 Coder (7B) é o melhor ponto de partida. É rápido o suficiente para feedback em tempo real, capaz o suficiente para análise significativa de código e se encaixa em hardware modesto.

Configurando: passo a passo

1. Instale o Ollama

Baixe o Ollama de ollama.com. Está disponível para macOS, Linux e Windows. A instalação é direta — basta executar o instalador e deixar completar.

Verifique a instalação abrindo um terminal e digitando:

ollama --version

Você deve ver um número de versão. Se você está no Linux, também verifique se sua GPU é detectada:

ollama list

2. Puxe um modelo

Puxe Qwen 2.5 Coder:

ollama pull qwen2.5-coder:7b

Isso baixa aproximadamente 5 GB de pesos de modelo quantizado. Em uma conexão de banda larga típica, espere 5-15 minutos. Ollama cuida de tudo — descompactação, conversão de formato, otimização.

Se você tiver 16GB VRAM, você pode tentar a versão 32B em vez disso:

ollama pull qwen2.5-coder:32b

3. Inicie o servidor Ollama

Ollama é executado como um serviço em segundo plano. Inicie-o com:

ollama serve

O servidor escuta em http://localhost:11434 por padrão. Deixe este terminal aberto ou configure o Ollama para iniciar automaticamente como um serviço do sistema (varia por SO).

4. Configure Claude Code

Claude Code lê três variáveis de ambiente para conectar à sua instância Ollama local. Defina-as antes de iniciar Claude Code:

export ANTHROPIC_AUTH_TOKEN="ollama"
export ANTHROPIC_API_KEY=""
export ANTHROPIC_BASE_URL="http://localhost:11434"

No Windows (PowerShell), use:

$env:ANTHROPIC_AUTH_TOKEN="ollama"
$env:ANTHROPIC_API_KEY=""
$env:ANTHROPIC_BASE_URL="http://localhost:11434"

Essas configurações dizem ao Claude Code para usar sua instância Ollama local em vez da API em nuvem do Anthropic.

5. Inicie Claude Code

Com essas variáveis de ambiente definidas, inicie Claude Code normalmente:

claude code

Claude Code agora roteirá solicitações para sua instância Ollama local. No primeiro uso, pode levar 10-30 segundos para carregar o modelo em VRAM. Solicitações subsequentes são mais rápidas.

Sua primeira revisão de código

Depois que tudo estiver executando, a revisão de código se sente natural. Aponte Claude Code para um diretório e peça para revisar um arquivo ou recurso específico:

• Revise esta função para problemas de segurança
• Verifique se este código segue nosso guia de estilo
• Qual é a complexidade temporal deste algoritmo?
• Refatore isto para legibilidade

Claude Code pode ler arquivos, executar comandos e iterar sobre sugestões. Para revisão de código especificamente, o comando /loop é útil para tarefas em lote — executar uma revisão em vários arquivos, verificar PRs ou automatizar análise repetitiva.

Local vs nuvem: as compensações reais

Executar localmente nem sempre é melhor. É diferente, com vantagens genuínas e limitações reais.

Vitórias locais

• Privacidade completa: seu código fica na sua máquina.
• Sem latência de rede para arquivos pequenos.
• Funciona offline.
• Sem faturamento por solicitação.

Vitórias em nuvem

• Significativamente melhor raciocínio para problemas complexos.
• Mais rápido para arquivos muito grandes (servidores em nuvem têm mais recursos).
• Atualizações automáticas; sem gerenciamento manual de modelo.
• Melhor manipulação de casos extremos e padrões de código inusitados.

O argumento de privacidade merece atenção específica. Quando você envia código para um serviço em nuvem, duas coisas acontecem: sua solicitação é transmitida pela rede e o provedor pode registrá-la (para depuração, prevenção de abuso ou melhoria de modelo). Mesmo se uma empresa afirmar não reter dados, os padrões que seu código representa são aprendidos pelo modelo durante o treinamento — exclusão dos arquivos originais não apaga esse aprendizado. Para código proprietário, segredos comerciais ou dados regulados, a execução local genuinamente elimina essa categoria de risco.

Dicas práticas e armadilhas comuns

A quantização afeta a qualidade

Ollama puxa modelos quantizados por padrão. Um modelo 7B com quantização Q4_K_M usa aproximadamente 4-5 GB VRAM; o mesmo modelo com precisão completa de 16 bits precisa de 14 GB. Você perde alguma precisão de raciocínio, mas geralmente não o suficiente para importar para revisão de código. Se a qualidade se degradar, experimente variantes de precisão mais alta (procure por tags :q6 ou :q8).

O carregamento do modelo leva tempo

Primeira inferência após uma reinicialização pode pausar por 10-30 segundos enquanto o modelo é carregado em VRAM. Isso é normal. Solicitações subsequentes usam o modelo em cache e são muito mais rápidas. Se você revisar código com frequência, mantenha Ollama executando em segundo plano.

As janelas de contexto importam

Qwen 2.5 Coder tem uma janela de contexto 32K; GLM 4.7 Flash tem 128K. Para arquivos grandes ou revisões de muitos arquivos, uma janela de contexto maior ajuda o modelo a "ver" mais código de uma vez. Se você estiver revisando bases de código enormes, considere a variante Qwen 32B ou GLM.

Configurações de temperatura

Para revisão de código, temperatura mais baixa (mais determinística) é geralmente melhor do que temperatura alta. Claude Code padroniza para valores razoáveis, mas se as respostas parecerem muito criativas ou instáveis, verifique sua configuração local.

Perguntas frequentes

Posso usar Claude Code com Ollama sem a API do Anthropic?

Sim. Esse é o ponto inteiro desta configuração. Ollama implementa o formato da API do Anthropic, então Claude Code o trata como um substituto instantâneo. Nenhuma conta Anthropic ou chave de API necessária.

E se minha GPU for muito pequena para Qwen 7B?

Recue para modelos menores como Mistral 7B ou Orca Mini (3B). Eles são menos capazes, mas ainda úteis para revisão básica de código. Alternativamente, execute em modo somente CPU (muito mais lento) ou use descarregamento de camada se seu driver GPU o suportar.

Posso alternar modelos dinamicamente?

Sim. Se você tiver vários modelos puxados, você pode especificar qual Ollama usa via variáveis de ambiente ou flags CLI. Veja a documentação do Ollama para a sintaxe exata. Na prática, a maioria dos desenvolvedores fica com um bom modelo para evitar sobrecarga de alternância de contexto.

A revisão de código local é segura contra extração de código?

Mais seguro que nuvem, sim. Um LLM local não pode exfiltrar seu código pela rede. Mas como todos os modelos de ML, ele aprende padrões do que vê. Um atacante com acesso à sua máquina pode extrair pesos ou examinar os estados ocultos do modelo para inferir estrutura de código. Para código verdadeiramente sensível (chaves criptográficas, algoritmos de segurança), a revisão deve ainda ser manual ou usar ambientes isolados por hardware.

E sobre executar Ollama em uma máquina separada?

Você pode. Ollama suporta conexões de rede. Configure ANTHROPIC_BASE_URL para apontar para IP:porta de uma máquina remota. Isso é útil se você deseja um servidor GPU robusto e máquinas cliente mais leves. A latência de rede aumenta, porém.

Para onde ir a partir daqui

Depois que você se sente confortável com configuração básica, considere:

• Configurar Ollama como um serviço do sistema para que inicie automaticamente.
• Experimentar vários modelos e comparar sua qualidade de revisão de código.
• Criar prompts personalizados ou modelos de revisão para o guia de estilo da sua equipe.
• Executar Ollama em um servidor GPU compartilhado se você trabalhar com outros desenvolvedores.

A cadeia de ferramentas de revisão de código local agora é prática para trabalho de desenvolvimento sério. Ela não substitui a revisão humana, mas é uma primeira passagem capaz, e está totalmente sob seu controle.