Quanta RAM eu preciso para executar o Gemma 4 localmente?

O Gemma 4 E2B e o E4B rodam com apenas 5GB de RAM com quantization de 4-bit — qualquer laptop moderno é qualificado. O modelo 26B MoE precisa de aproximadamente 18GB de RAM (cabe nos 24GB de VRAM de uma RTX 4090). O modelo 31B Dense precisa de aproximadamente 20GB de RAM. Para execução apenas em CPU, adicione 20-30% a mais de RAM do que o tamanho do peso do modelo.

Qual modelo Gemma 4 devo escolher para uso local?

Para laptops sem uma GPU dedicada: E2B (mais rápido, mais leve). Para laptops com uma GPU ou desktops: E4B (melhor qualidade, ainda leve). Para desktops com uma RTX 4090 ou equivalente: 26B MoE (melhor relação qualidade/computação). Para workstations com 24GB+ de VRAM: 31B Dense (maior qualidade). O 26B MoE é o equilíbrio ideal para a maioria dos desenvolvedores.

O Gemma 4 é gratuito para usar localmente?

Sim. O Gemma 4 é lançado sob a licença Apache 2.0, que permite o uso irrestrito, incluindo aplicações comerciais. O Ollama também é gratuito e de código aberto. O único custo é o seu hardware. Não há taxas de API, nem limites de uso, nem restrições de licença.

Quão rápido é o Gemma 4 localmente em comparação com as APIs de nuvem?

Em uma RTX 4090, o Gemma 4 E4B gera 80-120 tokens por segundo. O 26B MoE gera 30-50 tokens/seg. O 31B Dense gera 20-35 tokens/seg. APIs de nuvem como o Google AI Studio podem ser mais rápidas para os modelos maiores, mas adicionam latência de rede de 100-500ms por solicitação. Para uso interativo, a inferência local nos modelos menores parece instantânea.

Posso usar o Gemma 4 localmente como uma API para minhas aplicações?

Sim. O Ollama expõe uma REST API local na porta 11434 que é compatível com o formato da OpenAI API. Qualquer aplicação, framework ou ferramenta que suporte a OpenAI API pode se conectar ao Gemma 4 local, apontando a URL base para http://localhost:11434/v1. Isso inclui Python, Node.js e a maioria dos frameworks de AI.

O Gemma 4 suporta aceleração por GPU com o Ollama?

Sim. O Ollama detecta e usa automaticamente GPUs NVIDIA (CUDA), Apple Silicon (Metal) e GPUs AMD (ROCm). Nenhuma configuração adicional é necessária — se sua GPU tiver VRAM suficiente para conter o modelo, o Ollama o usará automaticamente. A NVIDIA também lançou versões de Gemma 4 otimizadas para RTX para ganhos adicionais de desempenho.

Principal Conclusão

Executar o Gemma 4 localmente leva menos de 5 minutos com o Ollama: instale o Ollama, execute um comando e você terá um modelo de AI totalmente capaz rodando em seu próprio hardware com zero custos de API, zero dados saindo de sua máquina e zero restrições de uso sob a licença Apache 2.0. O modelo E2B roda em qualquer laptop. O modelo 26B MoE cabe em uma única RTX 4090 e entrega uma qualidade que rivaliza com modelos com 10x o seu número de parâmetros ativos.

Executar Gemma 4 Localmente: O Guia Completo

Por que executar o Gemma 4 localmente?

Antes de mergulhar na configuração, veja por que a inferência local é importante em 2026:

Privacidade — Seus dados nunca saem da sua máquina. Nenhum prompt é enviado para servidores externos. Crucial para código proprietário, documentos jurídicos, dados médicos ou qualquer informação sensível.
Custo — Zero custo por tokens após o investimento único em hardware. Usuários pesados economizam centenas de dólares por mês em comparação aos preços de API.
Latência — Sem viagens de ida e volta pela rede. Os modelos E2B e E4B respondem em milissegundos em hardware moderno.
Confiabilidade — Sem limites de taxa de API, sem interrupções, sem mudanças nas políticas do provedor. Seu modelo está sempre disponível.
Customização — Faça fine-tune, quantize e modifique o modelo livremente sob a Apache 2.0.
Acesso offline — Funciona sem uma conexão com a internet uma vez que o modelo foi baixado.

O Gemma 4 é particularmente adequado para implantação local porque o Google projetou os modelos menores especificamente para uso em edge e dispositivos. Os modelos E2B e E4B não são pensados como secundários — são modelos de primeira classe otimizados para as restrições do hardware local.

Pré-requisitos

Requisitos de Hardware por Modelo

Modelo	RAM Mínima	VRAM Recomendada	Viável apenas com CPU?	Espaço em Disco
E2B (4-bit)	5 GB	4 GB	Sim	~1.5 GB
E4B (4-bit)	5 GB	4 GB	Sim	~2.8 GB
E4B (FP16)	9 GB	9 GB	Lento	~9 GB
26B MoE (4-bit)	18 GB	16 GB	Muito lento	~15 GB
26B MoE (FP16)	52 GB	48 GB	Não	~52 GB
31B Dense (4-bit)	20 GB	18 GB	Muito lento	~18 GB
31B Dense (FP16)	62 GB	48 GB+	Não	~62 GB

Principal conclusão: Se você tem um laptop fabricado após 2022, você pode rodar o E2B ou E4B. Se você tem uma RTX 4090 (24GB VRAM) ou um Mac da linha Apple M-series com 32GB+ de RAM, você pode rodar o 26B MoE ou o 31B Dense com quantização 4-bit.

Requisitos de Software

Sistema operacional: macOS, Linux, ou Windows
Ollama: Versão 0.6+ (baixe em ollama.com)
Drivers de GPU (opcional): NVIDIA CUDA 12+ para GPUs NVIDIA, nenhum driver extra necessário para Apple Silicon

Passo 1: Instalar o Ollama

macOS

Baixe de ollama.com/download ou use o Homebrew:

brew install ollama

Linux

Script de instalação de uma linha:

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

Windows

Baixe o instalador de ollama.com/download e execute-o. O Ollama roda como um serviço de segundo plano no Windows.

Verificar Instalação

ollama --version

Você deve ver ollama version 0.6.x ou superior. Se você ver um número de versão, o Ollama está instalado corretamente.

Fonte: Guia de instalação do Ollama

Passo 2: Baixar um Modelo Gemma 4

Escolha o modelo que corresponde ao seu hardware:

Para Laptops e Cargas de Trabalho Leves

# Menor modelo — roda em qualquer laptop moderno (5GB RAM)
ollama pull gemma4:e2b

# Modelo pequeno com capacidade mais ampla (5-9GB RAM)
ollama pull gemma4:e4b

Para Desktops com uma GPU Dedicada

# Melhor eficiência — qualidade de flagship com 3.8B de parâmetros ativos (18GB RAM)
ollama pull gemma4:26b-moe

# Qualidade máxima — 31B de parâmetros completos (20GB RAM)
ollama pull gemma4:31b

Especificando a Quantização

Por padrão, o Ollama baixa a quantização recomendada para cada modelo (geralmente Q4_K_M para um bom equilíbrio entre qualidade e tamanho). Você pode especificar diferentes quantizações:

# Maior qualidade, maior tamanho
ollama pull gemma4:31b-q5_K_M

# Menor tamanho, qualidade ligeiramente inferior
ollama pull gemma4:31b-q3_K_M

# Precisão total (requer muito mais RAM)
ollama pull gemma4:31b-fp16

O download levará alguns minutos dependendo da sua conexão com a internet. Os tamanhos dos modelos variam de ~1.5GB (E2B 4-bit) a ~62GB (31B FP16).

Passo 3: Executar o Gemma 4

Chat Interativo

ollama run gemma4:e4b

Isso abre uma sessão de chat interativa. Digite seu prompt e pressione Enter:

>>> What are the key differences between REST and GraphQL APIs?

O modelo responderá diretamente no seu terminal. Digite /bye para sair.

Prompt Único (Não Interativo)

echo "Explain the Builder design pattern in Python with an example" | ollama run gemma4:26b-moe

Com Modo de Pensamento

O Gemma 4 suporta o modo de pensamento configurável para tarefas complexas. Ative-o adicionando um prompt de sistema:

ollama run gemma4:31b --system "Think step by step before answering. Show your reasoning process."

Para tarefas de matemática, lógica e análise complexa, o modo de pensamento melhora significativamente a qualidade da resposta. O modelo gerará mais de 4.000 tokens de raciocínio interno antes de produzir sua resposta final.

Passo 4: Usar a API Local

O Ollama expõe uma API REST em localhost:11434 que é compatível com o formato da API da OpenAI. Isso significa que qualquer ferramenta ou biblioteca que suporte a API da OpenAI pode se conectar ao seu Gemma 4 local com uma simples mudança de URL.

Testar a API com curl

curl http://localhost:11434/api/generate -d '{
  "model": "gemma4:26b-moe",
  "prompt": "Write a Python function to parse CSV files with error handling",
  "stream": false
}'

Endpoint Compatível com OpenAI

curl http://localhost:11434/v1/chat/completions -d '{
  "model": "gemma4:26b-moe",
  "messages": [
    {"role": "user", "content": "Explain async/await in JavaScript"}
  ]
}'

Fonte: Documentação da API do Ollama

Passo 5: Integrar com Sua Aplicação

Python

import requests

def ask_gemma(prompt, model="gemma4:26b-moe"):
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False
        }
    )
    return response.json()["response"]

# Usage
answer = ask_gemma("What is the time complexity of merge sort?")
print(answer)

Python com SDK da OpenAI

from openai import OpenAI

# Point to local Ollama instead of OpenAI
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Ollama doesn't require a real API key
)

response = client.chat.completions.create(
    model="gemma4:26b-moe",
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a React hook for debounced search"}
    ]
)
print(response.choices[0].message.content)

Node.js / TypeScript

const response = await fetch("http://localhost:11434/v1/chat/completions", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "gemma4:26b-moe",
    messages: [
      { role: "user", content: "Explain the Observer pattern with a TypeScript example" }
    ]
  })
});

const data = await response.json();
console.log(data.choices[0].message.content);

Usando com LangChain

from langchain_community.llms import Ollama

llm = Ollama(model="gemma4:26b-moe")
response = llm.invoke("Summarize the key principles of clean architecture")
print(response)

Usando com LlamaIndex

from llama_index.llms.ollama import Ollama

llm = Ollama(model="gemma4:26b-moe", request_timeout=120.0)
response = llm.complete("What are the SOLID principles in software engineering?")
print(response)

Opções de Quantização Explicadas

A quantização reduz o tamanho do modelo e o uso de memória usando números de menor precisão para representar os pesos do modelo. A troca é entre qualidade e uso de recursos:

Quantização	Bits por Peso	Impacto na Qualidade	Economia de Memória	Melhor Para
FP16	16 bits	Nenhum (qualidade total)	Base	Servidores com VRAM ampla
Q8_0	8 bits	Negligível	~50%	Inferência local de alta qualidade
Q6_K	6 bits	Muito pequeno	~62%	Uso local focado em qualidade
Q5_K_M	5 bits	Pequeno	~69%	Bom equilíbrio
Q4_K_M	4 bits	Reduzido	~75%	Padrão recomendado
Q3_K_M	3 bits	Moderado	~81%	Hardware limitado
Q2_K	2 bits	Significativo	~87%	Limitações extremas

Q4_K_M é o ponto ideal para a maioria dos usuários. A diferença de qualidade para o FP16 é pequena o suficiente para que a maioria das tarefas produza resultados indistinguíveis, enquanto a economia de memória de 75% faz a diferença entre "precisa de um servidor" e "roda no meu laptop".

Escolhendo a Quantização Correta

Para Gemma 4 E2B/E4B: Use o padrão (Q4_K_M). Estes modelos já são pequenos o suficiente para que uma quantização maior não mude significativamente a experiência do usuário.

Para Gemma 4 26B MoE: Q4_K_M cabe em 18GB de RAM, o que está dentro da VRAM de 24GB de uma RTX 4090 com espaço para o cache KV. Se você tiver 48GB+ de VRAM (A6000, dual GPUs), considere Q8_0 para uma qualidade marginalmente melhor.

Para Gemma 4 31B Dense: Q4_K_M com 20GB cabe em uma RTX 4090 com margens apertadas. Q5_K_M produz resultados ligeiramente melhores, mas requer ~24GB, consumindo toda a VRAM disponível. Se você tiver 32GB+ de VRAM (RTX 5090, A6000), o Q6_K ou Q8_0 valem o upgrade.

Ajuste de Performance

Descarregamento para GPU (GPU Offloading)

O Ollama descarrega automaticamente as camadas do modelo para a GPU quando a VRAM está disponível. Se apenas parte do modelo couber na VRAM, o Ollama divide entre GPU e CPU. Você pode controlar isso:

# Forçar todas as camadas para a GPU (falha se a VRAM for insuficiente)
OLLAMA_NUM_GPU=999 ollama run gemma4:26b-moe

# Forçar apenas CPU (útil para testes)
OLLAMA_NUM_GPU=0 ollama run gemma4:e4b

Configuração da Janela de Contexto

Por padrão, o Ollama usa uma janela de contexto de 2048 tokens por eficiência. Para utilizar as capacidades totais de contexto do Gemma 4:

# Definir janela de contexto para 32K tokens
ollama run gemma4:26b-moe --num-ctx 32768

# Definir janela de contexto para 128K tokens (requer mais RAM)
ollama run gemma4:26b-moe --num-ctx 131072

Importante: Janelas de contexto maiores consomem mais RAM para o cache KV. Uma janela de contexto de 128K no modelo 31B pode exigir de 8-16GB de RAM adicionais além dos pesos do modelo. Comece com 32K e aumente apenas se o seu caso de uso exigir.

Requisições Simultâneas

O Ollama suporta o atendimento de múltiplas requisições simultaneamente:

# Permitir até 4 requisições simultâneas
OLLAMA_NUM_PARALLEL=4 ollama serve

Cada requisição simultânea adiciona sobrecarga de memória para o seu cache KV. Em uma GPU de 24GB rodando o 26B MoE em Q4_K_M (~18GB), você tem cerca de 6GB de folga — o suficiente para 2-3 requisições simultâneas com contextos curtos.

Configurações de Keep-Alive

Por padrão, o Ollama mantém os modelos carregados na memória por 5 minutos após a última requisição. Ajuste isso para o seu caso de uso:

# Manter modelo carregado por 1 hora
OLLAMA_KEEP_ALIVE=3600 ollama serve

# Manter modelo carregado indefinidamente
OLLAMA_KEEP_ALIVE=-1 ollama serve

# Descarregar imediatamente após cada requisição (economiza memória)
OLLAMA_KEEP_ALIVE=0 ollama serve

Otimização NVIDIA RTX

A NVIDIA lançou builds otimizados do Gemma 4 para GPUs RTX. Essas otimizações incluem:

Kernels CUDA customizados para o mecanismo de atenção do Gemma 4
Integração TensorRT-LLM para inferência mais rápida
Suporte Flash Attention para redução do uso de memória durante inferência de contexto longo
Gerenciamento de cache KV otimizado para melhor rendimento (throughput)

Instalando o Gemma 4 otimizado para NVIDIA

Se você possui uma GPU das séries RTX 4000 ou 5000:

# Verifique sua GPU
nvidia-smi

# Baixe a versão otimizada pela NVIDIA (se disponível no Ollama)
ollama pull gemma4:31b-nvidia

Alternativamente, use o NVIDIA AI Workbench ou TensorRT-LLM diretamente para desempenho máximo. As versões otimizadas pela NVIDIA podem fornecer inferência 30-50% mais rápida em GPUs RTX em comparação com os builds padrão do Ollama.

Benchmarks de Desempenho em Mundo Real

Medido em configurações de hardware comuns:

Tokens por Segundo (Velocidade de Geração)

Modelo	RTX 4090 (24GB)	RTX 3090 (24GB)	M3 Max (36GB)	Apenas CPU (32GB)
E2B (Q4)	~150 tok/s	~120 tok/s	~100 tok/s	~30 tok/s
E4B (Q4)	~100 tok/s	~80 tok/s	~70 tok/s	~15 tok/s
26B MoE (Q4)	~40 tok/s	~30 tok/s	~25 tok/s	~3 tok/s
31B Dense (Q4)	~30 tok/s	~20 tok/s	~20 tok/s	~2 tok/s

Contexto: A velocidade de leitura humana é de aproximadamente 4-5 tokens por segundo. Qualquer modelo que gere acima de 10 tok/s parece "instantâneo" para uso interativo. Os modelos E2B e E4B são rápidos o suficiente para streaming em tempo real em quase qualquer hardware.

Tempo para o Primeiro Token (Latência)

Modelo	RTX 4090	M3 Max	Apenas CPU
E2B	<100ms	<200ms	<500ms
E4B	<200ms	<300ms	~1s
26B MoE	~500ms	~1s	~5s
31B Dense	~800ms	~1.5s	~8s

Para aplicações interativas, o tempo para o primeiro token importa mais do que a velocidade de geração. Os modelos E2B e E4B começam a gerar quase instantaneamente mesmo em CPU, tornando-os ideais para interfaces de chat em tempo real.

Casos de Uso Comuns

Assistente de Programação Local

Use o Gemma 4 como um assistente de programação privado que nunca envia seu código para servidores externos:

ollama run gemma4:26b-moe --system "You are an expert software engineer. When given code, analyze it for bugs, suggest improvements, and explain your reasoning. Be concise and practical."

Combine isso com extensões do VS Code como Continue ou Twinny que suportam o Ollama como backend.

Análise de Documentos

Processe documentos sensíveis localmente:

echo "Analyze this contract clause and identify potential risks: [paste clause]" | ollama run gemma4:31b

Com 256K de contexto, o modelo 31B pode processar documentos de até ~750 páginas — o suficiente para a maioria dos contratos, artigos de pesquisa e documentação técnica.

RAG Local (Geração Aumentada por Recuperação)

Combine o Gemma 4 com um banco de dados vetorial local para um sistema RAG totalmente privado:

from langchain_community.llms import Ollama
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.vectorstores import Chroma

# Use Gemma 4 for both embeddings and generation
embeddings = OllamaEmbeddings(model="gemma4:e4b")
llm = Ollama(model="gemma4:26b-moe")

# Create vector store from your documents
vectorstore = Chroma.from_documents(documents, embeddings)

# Query with RAG
retriever = vectorstore.as_retriever()
docs = retriever.get_relevant_documents("What is our refund policy?")
context = "\n".join([doc.page_content for doc in docs])
response = llm.invoke(f"Based on this context:\n{context}\n\nAnswer: What is our refund policy?")

Construindo Recursos de AI em Aplicações

Para desenvolvedores construindo aplicações com capacidades de AI, executar o Gemma 4 localmente via API do Ollama é o caminho mais rápido para um protótipo funcional. A API compatível com OpenAI significa que você pode começar com o Gemma 4 local para desenvolvimento e mudar para APIs de nuvem para produção sem alterar o código da aplicação.

Plataformas como ZBuild podem lidar com a infraestrutura da aplicação — frontend, backend, autenticação, banco de dados — enquanto você foca na camada de integração de AI. Aponte o endpoint de AI da sua aplicação para localhost:11434 durante o desenvolvimento e troque para um endpoint de nuvem quando estiver pronto para escalar.

Solução de Problemas

Erros de "Out of memory"

Se você ver erros de memória:

Tente uma quantização menor: ollama pull gemma4:31b-q3_K_M
Reduza a janela de contexto: --num-ctx 4096
Feche outras aplicações intensivas em GPU
Mude para um modelo menor: o 26B MoE entrega qualidade próxima ao 31B com menor custo de memória

Velocidade de Geração Lenta

Se a geração estiver mais lenta do que o esperado:

Verifique a utilização da GPU: nvidia-smi (deve mostrar alto uso da GPU)
Certifique-se de que o modelo cabe inteiramente na VRAM — o descarregamento parcial para a CPU é dramaticamente mais lento
Reduza --num-ctx para liberar VRAM para computação
Verifique se outros processos estão usando a GPU

Modelo não encontrado

Se ollama run gemma4:26b-moe falhar:

# List available models
ollama list

# Search for Gemma 4 models
ollama search gemma4

# Pull the specific model
ollama pull gemma4:26b-moe

Conexão com a API Recusada

Se as aplicações não conseguirem se conectar ao localhost:11434:

# Check if Ollama is running
ollama list

# Start the Ollama server manually
ollama serve

# Check the port
curl http://localhost:11434/api/tags

Árvore de Decisão para Seleção de Modelo

Use isto para escolher rapidamente o modelo certo:

Você tem uma GPU dedicada com 16GB+ de VRAM?

Sim → Você quer qualidade máxima ou eficiência máxima?
- Qualidade máxima → gemma4:31b (Q4_K_M, precisa de 20GB)
- Eficiência máxima → gemma4:26b-moe (Q4_K_M, precisa de 18GB)
Não → Você tem 8GB+ de RAM?
- Sim → gemma4:e4b (Q4_K_M, melhor qualidade)
- Não → gemma4:e2b (Q4_K_M, roda com 5GB)

Para a maioria dos desenvolvedores com um desktop moderno ou PC gamer: Comece com gemma4:26b-moe. Ele oferece a melhor relação qualidade-recurso em toda a família Gemma 4.

O que você pode construir

Com o Gemma 4 rodando localmente, você tem um backend de AI de custo zero para:

Aplicações de chat com privacidade total de conversação
Ferramentas de análise de código que funcionam em bases de código proprietárias
Pipelines de processamento de documentos para dados sensíveis
Assistentes de AI locais que funcionam offline
Protótipos de recursos de AI antes de se comprometer com custos de API em nuvem
Modelos com fine-tune para tarefas específicas de domínio (a Apache 2.0 permite isso livremente)

A licença Apache 2.0 significa que tudo o que você constrói é seu — sem restrições de uso, sem compartilhamento de receita, sem necessidade de aprovação. Execute-o localmente, implante-o em seus servidores, incorpore-o em seus produtos. É assim que uma AI verdadeiramente aberta se parece.

Execute o Gemma 4 Localmente em 5 Minutos: Guia Completo de Configuração do Ollama (2026)