Execute o Gemma 4 gratuitamente no Claude Code usando Ollama

Execute o Gemma 4 gratuitamente no Claude Code usando Ollama

O momento em que parei de pagar por tokens de IA para programação foi numa tarde de terça-feira.

Eu estava consumindo créditos da API do Claude em um pipeline de automação de conteúdo — nada muito exótico, apenas um fluxo multiagente que raspava, resumia e reformatava dados de quatro sites diferentes. Aquele tipo de projeto em que você só percebe que fez 400 chamadas de API quando o painel de cobrança envia uma notificação educada avisando que você ultrapassou seu limite suave. De novo.

Já havia analisado todos os modelos Gemma 4 que o Google lançou em 2 de abril de 2026. Os benchmarks eram sólidos. O modelo 26B Mixture of Experts me impressionou pela relação entre velocidade e qualidade. Mas ainda não tinha integrado nenhum deles à minha ferramenta diária de fato — o Claude Code — como substituto completo da inferência em nuvem. Presumi que a diferença entre rodar um modelo open source localmente e usar os servidores da Anthropic tornaria a experiência frustrante.

Eu estava errado sobre isso. Espectacularmente errado.

Em menos de uma hora após configurar o Ollama para servir o modelo 26B do Gemma 4 através do endpoint compatível com Anthropic do Claude Code, eu já tinha o mesmo fluxo de edição de arquivos, chamadas de ferramentas, execução de bash e programação multi-etapas pelo qual vinha pagando — rodando inteiramente no meu próprio hardware. Sem chave de API. Sem painel de cobrança. Sem dados saindo da minha máquina. E rápido o suficiente para que eu parasse de conferir se as respostas estavam mais lentas do que a versão em nuvem, porque na maioria das vezes não havia diferença perceptível.

Isso não é uma configuração teórica. Estou rodando assim há mais de uma semana em projetos reais. Aqui está exatamente como montar o mesmo fluxo de trabalho, qual modelo Gemma 4 escolher para o seu hardware e onde a experiência realmente brilha — e onde ainda deixa a desejar.

Por que especificamente o Gemma 4 — e não outro modelo local

Testei muitos modelos locais no Claude Code. Qwen 3.5, Llama 4 Scout, variantes do DeepSeek, modelos Phi. Escrevi um guia completo sobre como rodar o Claude Code de graça com Ollama que cobre a abordagem geral. Então, por que o Gemma 4 merece um artigo de configuração próprio?

Três motivos, que se somam.

Eficiência de tokens muda a equação. Na minha análise prática do Gemma 4, medi que o modelo 26B usa cerca de 2,5 vezes menos tokens de saída do que o Qwen 3.5 para tarefas equivalentes. Quando você roda localmente, menos tokens significa geração mais rápida, menor pressão de memória e janelas de contexto mais curtas consumidas pelas próprias respostas do modelo. Em um loop de codificação agente, onde o Claude Code encadeia cinco ou seis chamadas de ferramentas por tarefa, essa diferença de eficiência representa a diferença entre um fluxo de trabalho que responde rápido e outro que parece que você está esperando o ônibus.

Chamada nativa de ferramentas funciona sem malabarismos. O Google treinou o uso de ferramentas diretamente no Gemma 4 — não foi apenas um fine-tuning em cima de um modelo base. O efeito prático: quando o Claude Code pede para o Gemma 4 ler um arquivo, editar uma função ou rodar um comando no shell, o modelo formata a chamada da ferramenta corretamente na primeira tentativa com muito mais frequência do que outros modelos de tamanho similar que testei. A integração do Ollama de abril de 2026 confirma que chamadas de ferramentas, leitura e edição de arquivos e execução de bash funcionam corretamente pela camada de compatibilidade da Anthropic Messages API.

A arquitetura Mixture of Experts o torna rápido em hardware modesto. O modelo 26B ativa aproximadamente 3,88 bilhões de parâmetros por inferência. O restante fica inativo. Isso significa que um modelo com 26 bilhões de parâmetros totais roda na velocidade que você esperaria de um modelo 4B — cerca de 300 tokens por segundo em um Mac Studio M2 Ultra, segundo benchmarks do Google. Meus próprios números ficaram abaixo desse valor de referência, mas ainda mais rápidos do que qualquer modelo de capacidade comparável que rodei localmente.

A combinação — chamadas de ferramentas rápidas, eficientes e confiáveis — faz do Gemma 4 o primeiro modelo local que realmente recomendo para uso diário no Claude Code, sem ressalvas do tipo “é bom só para tarefas simples”. Ele lida com trabalho de programação real.

Mas antes de instalar qualquer coisa, você precisa descobrir qual modelo se encaixa no seu hardware. Errar aqui pode custar horas.

Escolha o Modelo Gemma 4 Certo para Seu Hardware

A Google lançou quatro modelos, e escolher o tamanho errado é o erro mais comum que vejo as pessoas cometerem ao rodar IA localmente. Se for pequeno demais, você vai se frustrar com a qualidade das respostas. Se for grande demais, a inferência fica lenta ou o modelo nem chega a carregar.

Veja o lineup com requisitos de hardware realistas — não os números otimistas do marketing da Google, mas o que você realmente precisa para uma experiência utilizável no Claude Code:

Para o Claude Code especificamente, recomendo começar com o modelo 26B MoE. Eis o motivo: o Claude Code precisa de pelo menos 64K tokens de contexto para funcionar corretamente — os recursos agentivos dependem de manter conteúdos de arquivos, histórico de conversas e saídas de ferramentas na memória ao mesmo tempo. O modelo 26B atende a esse requisito de contexto e ainda mantém velocidade suficiente para programação interativa. O modelo E4B funciona, mas atinge um teto de qualidade em tarefas além de edições simples de arquivos e geração de código direta.

Como saber se seu hardware aguenta. Antes de baixar 18 GB de pesos do modelo e descobrir que sua máquina não roda, use um verificador de compatibilidade de hardware. Sites como WillItRunAI e CanIRun.ai permitem inserir o tipo de GPU, VRAM, RAM do sistema e núcleos da GPU para obter uma estimativa de compatibilidade. Selecione a variante Gemma 4 desejada, insira suas especificações e a ferramenta informa se a inferência será confortável, possível-mas-lenta ou inviável.

Alguns detalhes dos meus testes em diferentes hardwares:

• MacBook Pro M4 Pro (48 GB de memória unificada): O modelo 26B gera cerca de 51 tokens por segundo. Muito confortável para trabalho real de programação.
• M2 Pro (16 GB): O modelo 26B alcança 20-25 tokens por segundo. Usável, mas você vai notar pausas em saídas mais longas.
• RTX 4090 (24 GB VRAM): O modelo 31B denso roda a cerca de 41 tokens por segundo. O 26B MoE é significativamente mais rápido — bem acima de 60 tokens por segundo.
• RTX 3060 (12 GB VRAM): O modelo E4B roda suavemente. O modelo 26B carrega com quantização, mas você ficará limitado pela memória.

Se você tem um Mac com Apple Silicon e 16 GB ou mais de memória unificada, o modelo 26B com quantização Q4_K_M é o ideal. Se possui uma GPU NVIDIA dedicada com 24 GB de VRAM, pode rodar o modelo 31B denso e obter a máxima qualidade de saída.

Agora que você já sabe qual modelo baixar, vamos à configuração prática.

Passo 1: Instale o Ollama

O Ollama é o servidor local de modelos que viabiliza todo esse fluxo de trabalho. Pense nele como um Docker para modelos de linguagem — você faz o download das imagens dos modelos, o Ollama gerencia o runtime e seus aplicativos se comunicam com ele por meio de um endpoint de API local.

No macOS:

Baixe o instalador em ollama.com ou instale via Homebrew:

brew install ollama

No Linux:

curl -fsSL https://ollama.com/install.sh | sh

No Windows (via WSL):

Instale o WSL primeiro, se ainda não tiver, e depois siga as instruções para Linux dentro da sua distribuição WSL. Existe suporte nativo para Windows, mas o WSL oferece uma experiência mais consistente com o Claude Code.

Após a instalação, verifique se o Ollama está rodando:

ollama --version

Você deve ver a versão 0.6.x ou superior — versões anteriores não incluem a compatibilidade com a Anthropic Messages API, necessária para o Claude Code.

Inicie o servidor Ollama caso ele não esteja rodando automaticamente:

ollama serve

Mantenha esse comando rodando em uma aba do terminal ou configure como um serviço em segundo plano. Todos os próximos passos dependem do Ollama estar ativo e ouvindo em localhost:11434.

Passo 2: Baixe Seu Modelo Gemma 4

É aqui que a decisão de hardware da seção anterior faz diferença. Execute o comando correspondente ao modelo escolhido:

# Para a maioria dos usuários — equilíbrio ideal entre velocidade e qualidade
ollama pull gemma4:26b

# Para hardware de ponta — máxima qualidade
ollama pull gemma4:31b

# Para setups mais leves — ainda capaz para programação básica
ollama pull gemma4:e4b

O modelo 26B tem aproximadamente 18 GB. Em uma conexão de internet razoável, espere de 5 a 15 minutos para o download. O Ollama cuida automaticamente de toda a quantização e otimização — você não precisa configurar arquivos GGUF ou scripts de conversão manualmente.

Após concluir o download, verifique se o modelo foi carregado corretamente:

ollama run gemma4:26b "Write a Python function that reverses a linked list"

Você deve receber uma resposta de código coerente em poucos segundos. Se o modelo demorar mais de 30 segundos para responder, seu hardware pode estar sobrecarregado — considere utilizar a variante E4B.

Configuração crítica: defina a janela de contexto. O Claude Code exige pelo menos 64K tokens de contexto para funcionar corretamente. O Ollama utiliza por padrão uma janela bem menor. Crie um Modelfile para sobrescrever esse valor:

# Crie um Modelfile personalizado
cat <<EOF > Modelfile
FROM gemma4:26b
PARAMETER num_ctx 65536
EOF

# Crie o modelo customizado
ollama create gemma4-claude -f Modelfile

Isso cria uma nova variante de modelo chamada gemma4-claude com uma janela de contexto de 65.536 tokens. Use essa variante para todo o trabalho com Claude Code. Sem esse passo, o Claude Code perde o acompanhamento do conteúdo dos arquivos durante a edição, esquece instruções anteriores e gera alterações fragmentadas. Aprendi isso da maneira difícil quando meu agente tentou refatorar uma classe de serviço com 200 linhas e simplesmente esqueceu que a segunda metade existia.

Etapa 3: Instale o Claude Code

Se você ainda não tem o Claude Code instalado, a configuração é simples em todas as plataformas.

Pré-requisitos: O Node.js 18+ deve estar instalado no seu sistema.

npm install -g @anthropic-ai/claude-code

Isso instala o CLI do Claude Code globalmente. Funciona no macOS, Linux, Windows e WSL.

Verifique a instalação:

claude --version

Se você já utiliza o Claude Code com uma chave de API da Anthropic, não tem problema — vamos redirecioná-lo para sua instância local do Ollama.

Etapa 4: Conecte o Claude Code ao Ollama

É aqui que a mágica acontece. Você está instruindo o Claude Code a enviar suas requisições de API para o seu servidor Ollama local em vez da nuvem da Anthropic.

Defina as variáveis de ambiente. O método exato depende do seu sistema operacional e shell.

Para macOS/Linux (zsh ou bash):

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

Adicione estas linhas ao seu ~/.zshrc ou ~/.bashrc para torná-las permanentes:

echo 'export ANTHROPIC_BASE_URL="http://localhost:11434"' >> ~/.zshrc
echo 'export ANTHROPIC_AUTH_TOKEN="ollama"' >> ~/.zshrc
echo 'export ANTHROPIC_API_KEY="sk-placeholder"' >> ~/.zshrc
source ~/.zshrc

Para Windows (PowerShell):

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

Para tornar as variáveis permanentes no Windows, adicione-as em Propriedades do Sistema > Variáveis de Ambiente ou no seu perfil do PowerShell.

O que está acontecendo aqui: O Ollama expõe um endpoint de API que imita a Messages API da Anthropic. O Claude Code não percebe a diferença. Ele envia requisições para o que acredita ser o servidor da Anthropic, o Ollama as intercepta, direciona para o seu modelo Gemma 4 local e retorna as respostas exatamente no formato que o Claude Code espera. O valor de ANTHROPIC_API_KEY não importa — ele só precisa estar preenchido para que o Claude Code não reclame da ausência de uma chave.

Passo 5: Inicie e Verifique

Agora, inicie o Claude Code com o seu modelo Gemma 4 local:

claude --model gemma4-claude

Se você criou o Modelfile personalizado com a janela de contexto de 65K, use gemma4-claude. Se pulou essa etapa (não pule), use gemma4:26b diretamente.

Você deve ver a interface do Claude Code carregando. Tente um comando simples para verificar se tudo está conectado:

> Leia o diretório atual e liste todos os arquivos

O Claude Code deve usar sua ferramenta de leitura de arquivos, chamar o modelo Gemma 4 local via Ollama e retornar uma listagem formatada do diretório. Se isso funcionar, toda a sua stack está ativa — o toolkit completo do Claude Code rodando sobre um modelo gratuito, privado e local.

Solução de problemas comuns:

• Erro "Connection refused": O servidor Ollama não está em execução. Abra um terminal separado e execute ollama serve.
• Respostas extremamente lentas: Seu modelo é grande demais para o seu hardware. Use uma variante menor ou aumente o offload para GPU com OLLAMA_NUM_GPU=99.
• Claude Code trava em arquivos longos: A janela de contexto é pequena demais. Certifique-se de ter criado o Modelfile personalizado com num_ctx 65536.
• Falha nas chamadas de ferramentas: Confirme se você está rodando o Ollama 0.6.x ou superior. Versões anteriores não suportam totalmente o formato de chamadas de ferramentas exigido pelo Claude Code.

Se preferir que alguém monte essa configuração do zero — ajustada para o seu hardware específico, otimizada para o seu fluxo de trabalho — eu faço exatamente esse tipo de serviço. Você pode ver o que já realizei em fiverr.com/s/EgxYmWD.

O que Realmente Funciona — Tarefas de Programação Reais que Executei

Guias de configuração são inúteis sem relatos honestos de desempenho. Estou rodando este stack Gemma 4 + Ollama + Claude Code há mais de uma semana em projetos reais. Veja o que ele faz bem e onde apresenta limitações.

Geração de UI frontend — forte. Pedi ao modelo 26B, via Claude Code, para estruturar um dashboard React com sidebar, tabela de dados, componente de gráfico e alternância para modo escuro. O resultado foi limpo. Separação adequada de componentes. Classes Tailwind bem combinadas. Gerenciamento de estado com hooks do React, sem complicar demais. Para prototipagem e ferramentas internas, isso elimina totalmente minha necessidade de acessar a API.

Edição de arquivos múltiplos — confiável. O fluxo de trabalho de edição multi-arquivo do Claude Code — ler um arquivo, propor mudanças, aplicá-las, rodar testes — funciona corretamente via ponte do Ollama. O modelo Gemma 4 26B formata as chamadas de ferramenta de forma adequada, lida com caminhos de arquivos sem confusão e faz edições cirúrgicas, sem reescrever arquivos inteiros. Testei em um projeto Laravel com mais de 40 arquivos e ele navegou pelo código sem perder contexto.

Refatoração de código — bom, com limites. Pedi para refatorar um controller de 300 linhas em classes de serviço com injeção de dependência. O modelo 26B dividiu a lógica em três serviços, com interfaces corretas e injeção via construtor. As convenções de nomenclatura estavam razoáveis. Onde tropeçou: o arquivo de teste gerado para um dos serviços tinha um pequeno erro de namespace. Corrigi em dois segundos, mas vale mencionar — o Claude Opus hospedado na nuvem teria acertado isso.

Geração e execução de comandos Bash — excelente. Um dos recursos mais úteis do Claude Code é gerar e executar comandos de shell. O Gemma 4 faz isso com confiança via Ollama. Operações Git, comandos npm, gerenciamento Docker, manipulação de sistema de arquivos — o modelo entende fluxos de trabalho no terminal e gera comandos corretos para o sistema operacional em que está rodando.

Workflows complexos de múltiplas etapas — aqui está o limite. Configurei um pipeline de cinco etapas — raspar uma página web, extrair dados estruturados, transformá-los, gravar no banco de dados e gerar um relatório-resumo. O modelo 26B executou as quatro primeiras etapas sem problemas, mas se confundiu na etapa de resumo, produzindo um relatório que referenciava dados da etapa dois em vez da quatro. Rodando o mesmo pipeline no modelo denso 31B, o problema foi resolvido. Isso confirma o que observei na minha análise completa do Gemma 4 — o modelo 26B é excepcional para tarefas com três ou quatro etapas de raciocínio, mas começa a perder precisão em cadeias mais longas.

Tarefas multimodais — uma surpresa genuína. O Gemma 4 tem suporte nativo a visão, e isso funciona via ponte Ollama + Claude Code. Enviei uma captura de tela de um design Figma e pedi para gerar o HTML/CSS correspondente. Ele identificou a estrutura do layout, paleta de cores e escolhas tipográficas com precisão razoável. Não ficou pixel-perfect — mas suficientemente próximo para que o resultado fosse um ponto de partida útil, não uma tela em branco.

O padrão que adotei: uso o Gemma 4 local para 80% das minhas tarefas de programação — edição de arquivos, scaffolding, refatoração, geração de comandos, protótipos rápidos. Troco para o Claude Opus na nuvem nos 20% restantes, quando preciso de raciocínio profundo em múltiplas etapas, decisões arquiteturais complexas ou lidar com bases de código com interdependências intricadas.

Os Compromissos Honestos — O Que Você Perde ao Rodar Localmente

Eu estaria te enganando se dissesse que isso é um substituto direto para o serviço em nuvem da Anthropic. Não é. Veja o que você abre mão.

O cache de prompts não funciona. O cache de prompts da Anthropic — que acelera dramaticamente conversas repetidas ao armazenar o prompt do sistema e o contexto inicial — não está disponível na camada de compatibilidade do Ollama até abril de 2026. Cada requisição processa todo o contexto do zero. Para interações curtas, isso não faz diferença. Em sessões longas de programação, onde você constrói sobre 30+ interações, você vai perceber a latência aumentando conforme o contexto cresce.

tool_choice não é suportado. O Claude Code às vezes usa tool_choice para forçar a chamada de uma ferramenta específica — como exigir que o modelo leia um arquivo antes de editá-lo. Esse parâmetro não é suportado no modo de compatibilidade da API Anthropic do Ollama. Na prática, o Gemma 4 ainda aciona as ferramentas certas voluntariamente na maioria das vezes, mas ocasionalmente o modelo tenta responder de memória quando deveria ler o arquivo. É um incômodo menor, não um impeditivo.

O teto de raciocínio é real. O modelo de 26B do Gemma 4 marca 31 no índice de inteligência que acompanho entre modelos. O Qwen 3.5 marca 42. O Claude Opus pontua significativamente mais alto. Em tarefas que exigem verdadeira originalidade — como desenhar um algoritmo para um problema único, identificar erros lógicos sutis em lógica de negócios complexa, tomar decisões arquiteturais considerando oito restrições diferentes — você vai sentir a diferença. O modelo entrega um primeiro rascunho forte. Levar esse rascunho à produção às vezes exige refinamento humano que modelos em nuvem já fazem automaticamente.

Sem streaming em algumas plataformas. Dependendo da sua versão do Ollama e do sistema operacional, respostas em streaming podem não funcionar perfeitamente. Você pode ver a resposta inteira aparecer de uma vez, em vez de token por token. O resultado funcional é idêntico — mas a experiência parece menos interativa.

Você é responsável pelas atualizações. Quando a Anthropic atualiza o Claude, você recebe as melhorias automaticamente. Com um modelo local, é preciso baixar manualmente novas versões do Gemma 4 conforme o Google lança melhorias de quantização, correções de bugs e variantes ajustadas. A comunidade é ativa, mas ainda é um processo manual.

Nada disso inviabilizou o fluxo de trabalho para mim. A privacidade, velocidade e custo zero superam as limitações para a maioria das tarefas de programação do meu dia a dia. Mas entre sabendo exatamente o que esperar.

Além da Programação — O Que Mais Esse Stack Oferece

Depois de colocar o Gemma 4 rodando dentro do Claude Code via Ollama, você não fica restrito à escrita de código. O framework agente suporta qualquer fluxo de trabalho que possa ser expresso como uma sequência de chamadas de ferramentas.

Redação automatizada de e-mails. Conecte o Claude Code ao seu sistema de arquivos local onde ficam os modelos de e-mail, descreva os e-mails que precisa e o agente gera rascunhos personalizados. Tudo local. Nenhum conteúdo de e-mail trafega por servidores externos.

Pesquisa de leads e scraping. A execução bash do Claude Code combinada com o raciocínio do Gemma 4 permite criar pipelines simples de scraping. Extraia dados de fontes públicas, estruture as informações e formate para seu CRM. Configurei prompts agendados do Ollama dentro do Claude Code que executam esse tipo de tarefa em horários definidos — coleta de dados automatizada sem dependência da nuvem.

Análise e sumarização de documentos. Envie PDFs, arquivos markdown ou documentação de código pelo pipeline e obtenha resumos estruturados. A capacidade multimodal permite até processar capturas de tela e diagramas.

Integrações com Slack e ambientes de trabalho. Por meio de servidores MCP (Model Context Protocol) e do ecossistema de ferramentas do Claude Code, você pode conectar seu agente Gemma 4 local ao Slack, Google Workspace e outras ferramentas de produtividade. O modelo cuida do raciocínio; as conexões de ferramentas executam as ações. Tudo roda na sua máquina.

O ponto em comum: qualquer fluxo de trabalho onde a privacidade dos dados é fundamental, onde você quer custo marginal zero por consulta ou precisa rodar centenas de requisições automatizadas sem se preocupar com limites de uso. É aqui que modelos locais não apenas igualam os serviços em nuvem — eles superam.

O Que Eu Faria Diferente ao Configurar Isso Pela Segunda Vez

Após uma semana de uso diário, algumas otimizações que teriam me poupado tempo já no primeiro dia.

Defina OLLAMA_NUM_GPU=99 desde o início. Isso instrui o Ollama a descarregar o máximo possível de camadas do modelo na GPU. Passei dois dias me perguntando por que meu modelo 26B estava mais lento do que o esperado antes de descobrir que o Ollama estava rodando metade das camadas na CPU por padrão. Uma variável de ambiente resolveu:

export OLLAMA_NUM_GPU=99

Crie o Modelfile com contexto de 65K antes da sua primeira sessão no Claude Code. Comecei com a janela de contexto padrão do Ollama — 8K ou 16K, dependendo do modelo — e não conseguia entender por que o Claude Code continuava perdendo o rastreamento dos arquivos. O mínimo de 65K não é opcional. É um requisito para que os recursos agentivos do Claude Code funcionem corretamente.

Mantenha um fallback em nuvem configurado. Não excluí minha chave de API da Anthropic — criei um alias simples no shell que alterna entre os modos local e em nuvem:

alias claude-local='ANTHROPIC_BASE_URL=http://localhost:11434 ANTHROPIC_AUTH_TOKEN=ollama claude --model gemma4-claude'
alias claude-cloud='ANTHROPIC_BASE_URL=https://api.anthropic.com claude'

Quando o modelo local trava em uma tarefa complexa, alterno para o modo em nuvem em dois segundos. O melhor dos dois mundos.

Monitore sua VRAM. Se você está em uma máquina compartilhada ou rodando outros aplicativos pesados de GPU junto com o Ollama, a disputa por VRAM vai degradar o desempenho silenciosamente. No macOS, o Monitor de Atividade mostra o uso de memória unificada. No Linux com NVIDIA, execute nvidia-smi para verificar a alocação de memória da GPU. Se seu modelo estiver competindo por VRAM com um navegador rodando vídeo acelerado por GPU, você vai se perguntar por que a inferência ficou três vezes mais lenta de repente.

O Panorama Maior — Por Que Isso Importa Além das Chamadas de API Gratuitas

Economizar dinheiro com tokens de IA é o benefício mais óbvio. Mas, após uma semana usando esse fluxo de trabalho, o que realmente me chama atenção não é o custo.

É o controle.

Cada linha de código que gero através desse stack permanece na minha máquina. Cada projeto que analiso, cada arquivo que leio, cada comando que executo — nada disso passa por um servidor externo. Para trabalhos de clientes com NDAs, para bases de código proprietárias, para qualquer coisa envolvendo dados sensíveis, isso não é apenas uma comodidade. É um requisito de conformidade resolvido por arquitetura, não por acordos legais.

A velocidade foi o segundo ponto que me surpreendeu. Sem latência de rede — sem ida e volta até um datacenter, sem fila atrás das requisições de outros usuários — os tempos de resposta dependem totalmente do meu hardware. Durante horários de pico, quando APIs em nuvem ficam lentas, minha configuração local mantém a mesma velocidade. Às 2h da manhã, quando estou no fluxo de programação e disparando prompts, não há limite de taxa me segurando.

E a matemática da escalabilidade se inverte. Com APIs em nuvem, mais uso significa mais custo. Com inferência local, o custo é fixo — você já possui o hardware. Seja fazendo 10 ou 10.000 consultas, sua conta de energia mal muda. Para fluxos de trabalho agentivos que encadeiam dezenas de chamadas de ferramentas por tarefa, isso viabiliza arquiteturas que seriam absurdamente caras com cobrança em nuvem.

O Google lançar o Gemma 4 sob a licença Apache 2.0 — a licença open-source mais permissiva disponível — remove a última barreira legal. Sem limites de usuários ativos mensais como na licença Llama da Meta. Sem políticas de uso aceitável sendo aplicadas. Liberdade comercial total. Você pode construir produtos com isso, entregá-los a clientes e não deve taxa de licença ou relatório de uso a ninguém.

O futuro do desenvolvimento assistido por IA não é escolher entre nuvem e local. É rodar ambos — direcionando tarefas simples para sua instância local do Gemma 4, buscando velocidade e privacidade, e escalando para Claude Opus ou GPT quando precisar de capacidades de ponta. Essa configuração é esse futuro híbrido, disponível hoje, funcionando agora.

Um comando para baixar o modelo. Três variáveis de ambiente para conectar. Vinte minutos entre ler esta frase e rodar um agente de IA gratuito no seu próprio hardware.

A única pergunta que resta é: o que você vai construir com isso?

Perguntas Frequentes

O Gemma 4 funciona com todos os recursos do Claude Code via Ollama?

Leitura e edição de arquivos, execução de bash e chamada de ferramentas funcionam corretamente desde abril de 2026. Cache de prompts e tool_choice (seleção forçada de ferramenta) não são suportados pela camada de compatibilidade do Ollama. Para a comparação completa de capacidades, consulte a seção de tradeoffs acima.

Qual modelo Gemma 4 é o melhor para o Claude Code?

O modelo 26B MoE oferece o melhor equilíbrio entre velocidade e qualidade para a maioria dos hardwares. Ele ativa apenas 3,88 bilhões de parâmetros por chamada de inferência, entregando uma qualidade de saída próxima à variante densa de 31B. Você precisa de no mínimo 16 GB de RAM e deve configurar uma janela de contexto de 65K tokens.

Quão rápido é o Gemma 4 rodando localmente em comparação com o Claude na nuvem?

Em um MacBook Pro M4 Pro com 48 GB de memória, o modelo 26B gera cerca de 51 tokens por segundo. Uma RTX 4090 leva o modelo 31B a cerca de 41 tokens por segundo. O Claude na nuvem costuma ser mais rápido em throughput bruto, mas a inferência local elimina a latência de rede — o tempo de resposta do primeiro token geralmente é comparável.

Posso rodar o Gemma 4 em um MacBook Air ou notebook de entrada?

O modelo E4B (4 bilhões de parâmetros) roda em máquinas com 8 GB de RAM e lida com tarefas básicas de programação. Para fluxos de trabalho sérios com Claude Code, o ideal é o modelo 26B com no mínimo 16 GB. O modelo E2B roda praticamente em qualquer máquina, mas é limitado demais para programação agentica significativa.

Essa configuração é realmente gratuita, sem custos ocultos?

O Gemma 4 possui licença Apache 2.0 — gratuito para qualquer uso, inclusive comercial. O Ollama é open source. O Claude Code CLI é gratuito para instalar. O único custo é o seu hardware e eletricidade. Sem chaves de API, sem assinaturas, sem rastreamento de uso, sem dados saindo da sua máquina.

Vamos Trabalhar Juntos

Quer construir sistemas de IA, automatizar fluxos de trabalho ou escalar sua infraestrutura tecnológica? Eu posso ajudar.

• Fiverr (projetos personalizados & integrações): fiverr.com/s/EgxYmWD
• Portfólio: mejba.me
• Ramlit Limited (soluções corporativas): ramlit.com
• ColorPark (design & branding): colorpark.io
• xCyberSecurity (serviços de segurança): xcybersecurity.io