Sunday, 22 November 2026 | Updating Daily AI insight, written for builders

Ollama Gemma 4: Modelos Gemma atuais e como executá-los

Atualizado · Originalmente publicado
  • Gemma 4 está disponível e na Ollama biblioteca como gemma4. O Google o lançou em 31 de março de 2026 em tamanhos E2B, E4B, 26B A4B e 31B, e adicionou o modelo Unified 12B em 3 de junho de 2026.
  • Executar ollama run gemma4 para o modelo E4B padrão, ou escolha um tamanho: gemma4:e2b, gemma4:12b, gemma4:26b ou gemma4:31b.
  • Os downloads de 4 bits (q4_K_M) têm 4,6 GB (E2B), 6,6 GB (E4B), 8,0 GB (12B), 18 GB (26B) e 20 GB (31B). O contexto é de 128K tokens em E2B e E4B e 256K nos tamanhos maiores.
  • Gemma 4 é lançado sob Apache 2.0. Gemma 3 e Gemma 2, ainda no Ollama, usam os Termos de Uso do Gemma do Google.
  • Os números de velocidade nesta página são marcados como tetos de largura de banda de memória, não medições; as velocidades reais são mais baixas.

O Gemma 4 está disponível no Ollama?

Sim. Gemma 4 está na biblioteca do Ollama como gemma4, em cinco tamanhos: E2B, E4B, 12B, 26B (um modelo mistura-de-especialistas com aproximadamente 3,8B parâmetros ativos) e 31B. Instale ou atualize o Ollama, então execute ollama run gemma4 para o modelo E4B padrão, ou adicione uma tag de tamanho como gemma4:12b. Cada tag aceita texto e imagens, e os tamanhos maiores leem até 256K tokens de contexto.

Tamanhos do Gemma 4 no Ollama

Contagens de parâmetros e janelas de contexto abaixo vêm do cartão de modelo Gemma 4 do Google. Os tamanhos de download são os builds q4_K_M listados na página de tags do Ollama.

Modelo Parâmetros Contexto Comando Ollama Download de 4 bits (q4_K_M)
Gemma 4 E2B 2,3B efetivos (5,1B com embeddings) 128K ollama run gemma4:e2b 4,6 GB
Gemma 4 E4B (padrão) 4,5B efetivos (8B com embeddings) 128K ollama run gemma4 6,6 GB
Gemma 4 12B Unified 11,95B 256K ollama run gemma4:12b 8,0 GB
Gemma 4 26B A4B (MoE) 25,2B total, 3,8B ativos 256K ollama run gemma4:26b 18 GB
Gemma 4 31B (denso) 30,7B 256K ollama run gemma4:31b 20 GB

O «E» em E2B e E4B significa parâmetros efetivos: o Google diz que os modelos pequenos usam Per-Layer Embeddings para maximizar a eficiência de parâmetros em dispositivos, e seu cartão lista 5,1B e 8B parâmetros depois que esses embeddings são contados, por isso os arquivos são maiores do que a contagem efetiva sugere. O «A» em 26B A4B significa parâmetros ativos. O cartão de modelo do Google diz que «é executado quase tão rápido quanto um modelo de parâmetro 4B», enquanto ainda precisa da memória de um modelo com aproximadamente 25B parâmetros.

As tags simples como gemma4:31b mostram um intervalo de tamanho na página do Ollama, porque mais de um build está por trás delas. Se você quer um arquivo previsível, nomeie o build: gemma4:31b-it-q4_K_M (20 GB), gemma4:31b-it-qat (19 GB), gemma4:31b-it-q8_0 (34 GB) ou gemma4:31b-it-bf16 (63 GB). O mesmo padrão funciona para os outros tamanhos. O Ollama também lista tags de nuvem, gemma4:cloud e gemma4:31b-cloud, que são executadas nos servidores do Ollama em vez de sua GPU; nosso Explicador Ollama Cloud cobre como elas funcionam.

Como executar Gemma 4 com Ollama

Se você ainda não tem Ollama, siga o Guia de instalação do Ollama. Se você já o tem e o pull falha, atualize o Ollama primeiro, já que novas famílias de modelos costumam precisar de um lançamento recente. Depois, em macOS, Linux ou Windows:

# Tamanho padrão (E4B)
ollama run gemma4

# Escolher um tamanho
ollama run gemma4:e2b
ollama run gemma4:12b
ollama run gemma4:26b
ollama run gemma4:31b

# Baixar sem iniciar um chat
ollama pull gemma4:12b

Modo de raciocínio

Todos os tamanhos do Gemma 4 conseguem raciocinar antes de responder. O modelo card do Google diz que o pensamento é ativado colocando o <|think|> token no início do prompt do sistema, e desativado removendo-o. A API do Ollama também tem um raciocinar parâmetro: true solicita pensamento, false solicita nenhuma saída de pensamento se o modelo permitir, e deixá-lo não definido usa o padrão do modelo.

Usando Gemma 4 a partir de código

Ollama oferece uma API local em http://localhost:11434:

curl http://localhost:11434/api/generate -d '{
  "model": "gemma4",
  "prompt": "Explain quantum entanglement in simple terms.",
  "stream": false
}'

Também oferece um endpoint compatível com OpenAI, portanto o código cliente OpenAI existente funciona alterando a URL base. O cliente precisa de um valor de chave de API, mas o Ollama ignora:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1/",
    api_key="ollama",  # required but ignored
)

response = client.chat.completions.create(
    model="gemma4:12b",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(response.choices[0].message.content)

Quanta memória cada tamanho precisa?

O tamanho do download é o piso: os pesos precisam caber na memória da GPU (ou memória unificada Apple) para velocidade total. A janela de contexto precisa de memória além disso, e cresce com o comprimento do contexto que você permite. A documentação do Ollama diz que escolhe um contexto padrão a partir da VRAM detectada: 4K tokens abaixo de 24 GiB, 32K de 24 a 48 GiB, e 256K em 48 GiB ou mais. Você pode substituir com OLLAMA_CONTEXT_LENGTH ao iniciar o servidor, e ollama ps mostra em sua coluna PROCESSOR se parte do modelo foi derramada para a CPU.

Tamanho Pesos de 4 bits Nossa regra de ouro para um ajuste completo da GPU
E2B 4,6 GB GPUs de 8 GB e a maioria dos laptops recentes
E4B 6,6 GB GPUs de 8 GB com contexto curto; 12 GB é mais confortável
12B 8,0 GB GPUs de 12 GB; 16 GB para contextos mais longos
26B A4B 18 GB GPUs de 24 GB, ou Macs e PCs Strix Halo com 32 GB ou mais
31B 20 GB GPUs de 24 GB com contexto modesto, ou memória unificada de 32 GB ou mais

A regra de ouro é nossa estimativa a partir dos tamanhos de arquivo, não um limite medido. Para um valor que leve em conta seu comprimento de contexto, use o calculadora de VRAM, e veja Requisitos de VRAM por modelo para outras famílias.

Qual é a velocidade do Gemma 4? Estimativas marcadas

Nem o modelo card do Google nem a página da biblioteca do Ollama publicam números de tokens por segundo para Gemma 4 em GPUs de consumidor. O que pode ser calculado é um teto. Quando um usuário está gerando texto, cada novo token requer leitura dos pesos do modelo da memória, portanto a largura de banda da memória dividida pelos gigabytes lidos por token é um limite superior na velocidade de geração.

Modelo (q4_K_M) NVIDIA RTX 4090 (1.008 GB/s, 24 GB) Apple M4 Pro (273 GB/s) AMD Ryzen AI Max+ 395 (256 GB/s)
Gemma 4 12B (8,0 GB) ~126 tokens/s teto ~34 tokens/s teto ~32 tokens/s (limite teórico)
Gemma 4 31B (20 GB) ~50 tokens/s de limite ~14 tokens/s (limite teórico) ~13 tokens/s teto

Suposições: um usuário, todo o download lido uma vez por token gerado, e sem margem para o KV cache, limites de computação ou overhead de software. Estes são tetos aritméticos, não medições por Convly AI, e velocidades reais são menores. Como ponto de calibração, o scoreboard CUDA público do llama.cpp mostra uma RTX 4090 gerando cerca de 186 tokens/s no Llama 2 7B em Q4_0, um arquivo de 3,83 GB. Seu teto pela mesma aritmética é cerca de 263 tokens/s, portanto esse resultado é aproximadamente 70% do teto.

Dois tamanhos não se encaixam neste modelo simples. O 26B A4B lê apenas seus aproximadamente 3,8B parâmetros ativos para cada token, então gera muito mais rápido do que seu arquivo de 18 GB sugere; Google descreve como rodando quase tão rápido quanto um modelo 4B. E2B e E4B incluem Per-Layer Embeddings que não são todos lidos para cada token, então um teto baseado em seu tamanho de arquivo subestimaria. Para conselhos de compra de GPU, veja o melhores GPUs para executar LLMs localmente, e para como a memória unificada Apple e AMD se comparam, nossa comparação Strix Halo vs M4 Pro.

Gerações anteriores do Gemma no Ollama

Gemma 3 e Gemma 2 ainda estão na biblioteca Ollama. Gemma 4 substitui ambos para novos projetos, com contexto mais longo e licença mais permissiva.

Família Tags Ollama (tamanho de download) Contexto Entrada Licença
Gemma 3 (março de 2025; 270M adicionado em agosto de 2025) gemma3:270m (292 MB), gemma3:1b (806 MB), gemma3:4b (3,4 GB), gemma3:12b (8,2 GB), gemma3:27b (17 GB) 32K (270M, 1B); 128K (4B, 12B, 27B) Texto (270M, 1B); texto e imagem (4B e acima) Termos de Uso do Gemma
Gemma 2 (junho e julho de 2024) gemma2:2b (1,6 GB), gemma2:9b (5,4 GB), gemma2:27b (16 GB) 8K Texto Termos de Uso do Gemma

Google’s Gemma 4 model card, whose table Ollama’s Gemma 4 page reproduces, puts Gemma 4 31B at 85.2% on MMLU Pro and 84.3% on GPQA Diamond, against 67.6% and 42.4% for Gemma 3 27B (sem pensamento). Essas são pontuações reportadas pelo fornecedor. Nosso página do modelo Gemma 3 27B tem as especificações desse modelo, e o Lista de modelos do Ollama e melhores modelos locais para Ollama cobrem alternativas como Llama, Mistral e Qwen.

Ajustando Gemma 4 com um Modelfile

O cartão do modelo do Google recomenda uma configuração de amostragem para cada caso de uso: temperature 1.0, top_p 0.95 e top_k 64. Você pode incorporar essas configurações, um comprimento de contexto e um prompt de sistema em seu próprio modelo com um Modelfile:

FROM gemma4:12b

PARAMETER temperature 1.0
PARAMETER top_p 0.95
PARAMETER top_k 64
PARAMETER num_ctx 32768

SYSTEM You are a technical documentation assistant. Give accurate, concise answers with code examples.

Depois crie e execute:

ollama create my-gemma -f ./Modelfile
ollama run my-gemma
  • temperature: valores mais altos tornam as respostas mais criativas.
  • top_p e top_k: limita quais tokens o modelo faz amostragem.
  • num_ctx: a janela de contexto; valores maiores usam mais memória.
  • num_predict: o número máximo de tokens a gerar.

Para comparar a execução do Gemma localmente contra uma API hospedada, o calculadora de self-hosting vs API encontra o ponto de equilíbrio para seu uso.

Solução de problemas

«Model not found» ou o pull falha: verifique a ortografia da tag contra a página gemma4 do Ollama e atualize o Ollama.

A geração está lenta: executar ollama ps. Se a coluna PROCESSOR mostrar parte do modelo na CPU, o modelo e seu contexto não cabem na memória GPU. Reduza o contexto com OLLAMA_CONTEXT_LENGTH ou desça para um tamanho menor. Nosso guia para Ollama não usando a GPU cobre as outras causas.

GPU não detectada: A documentação do Ollama lista GPUs NVIDIA com capacidade de computação 5.0 ou mais recente e driver 550 ou mais recente. No AMD, precisa do stack de driver ROCm v7; no Windows, sua lista ROCm cobre cartões Radeon RX 7000 e Radeon PRO W7000, e Vulkan oferece suporte GPU adicional no Windows e Linux. Em Macs, o Ollama usa a Metal API do Apple para aceleração GPU.

A API não retorna nada: verifique se o servidor está em execução e acessível em http://localhost:11434, e que o modelo foi baixado.

Perguntas frequentes

O Gemma 4 está disponível no Ollama?

Sim. Está na biblioteca do Ollama como gemma4, em tamanhos E2B, E4B, 12B, 26B e 31B. O Google lançou o Gemma 4 em 31 de março de 2026 e adicionou o modelo Unified 12B em 3 de junho de 2026. Execute ollama run gemma4 para o modelo E4B padrão, ou adicione uma tag de tamanho.

Qual tamanho do Gemma 4 devo começar?

Nossa sugestão: E4B, o padrão, em laptops e GPUs de 8 GB; 12B em GPUs de 12 a 16 GB; 26B A4B em GPUs de 24 GB se você quer velocidade; 31B em GPUs de 24 GB ou Macs de 32 GB ou mais se você quer o modelo denso mais forte. A tabela acima lista cada tamanho de download.

Posso usar Gemma 4 comercialmente?

O cartão do modelo do Google lista o Gemma 4 sob a licença Apache 2.0, que permite uso comercial, modificação e redistribuição sob seus termos. Gemma 3 e Gemma 2 usam os Termos de Uso Gemma separados do Google, então leia-os antes de lançar um produto em um modelo mais antigo.

O Gemma 4 no Ollama compreende imagens e áudio?

Imagens, sim: a página de tags do Ollama lista entrada de texto e imagem para cada tag do Gemma 4. Áudio depende do tamanho. O cartão do modelo do Google lista entrada de áudio para E2B, E4B e o modelo Unified de 12B, mas não para 26B A4B ou 31B. A página da biblioteca do Ollama mostra um badge de áudio para a família, então se você precisar de áudio, escolha um dos três tamanhos menores.

Como ativar ou desativar o pensamento do Gemma 4?

O Google diz que o pensamento é ativado colocando o token de pensamento no início do prompt do sistema e desativado removendo-o. Através da API do Ollama, você também pode definir o parâmetro think como true ou false, ou deixá-lo indefinido para usar o padrão do modelo.

O Gemma 4 pode ser executado sem uma GPU?

Sim. O Ollama pode executar um modelo na CPU, mas a geração é então limitada pela largura de banda de memória do sistema, que é muito mais baixa do que a de uma GPU moderna. E2B e E4B são as escolhas realistas apenas na CPU.

Escrito por Mustafa Ihsan

Mustafa Ihsan é o fundador e editor de Convly.ai. Ele construiu e mantém o banco de dados de modelos de IA ao vivo do site, seu índice de desempenho por preço e seus calculadores gratuitos para requisitos de VRAM, custos de API e economia de self-hosting. Ele escreve sobre preços de modelos, resultados de benchmarks e o hardware necessário para executar modelos de IA localmente, e consistentemente prefere números medidos a afirmações de fornecedores.

Scroll to Top