DEV Community

Cover image for Como Executar Gemma 4 Localmente com Ollama: Guia Completo
Lucas
Lucas

Posted on • Originally published at apidog.com

Como Executar Gemma 4 Localmente com Ollama: Guia Completo

Resumo

Gemma 4 foi lançado em 3 de abril de 2026, e o Ollama v0.20.0 adicionou suporte no mesmo dia. Você pode baixar e executar o modelo padrão gemma4:e4b em apenas dois comandos. Este guia apresenta todos os passos práticos para configurar, escolher variantes, usar a API e testar endpoints locais do Gemma 4 com o Apidog.

Experimente o Apidog hoje

Introdução

Google lançou o Gemma 4 em 2 de abril de 2026. Em 24 horas, o Ollama lançou a v0.20.0 com suporte a todas as quatro variantes do modelo.

Para desenvolvedores, isso é uma grande mudança: o Gemma 4 salta de 20,8% (Gemma 3) para 89,2% no AIME 2026, e de 110 para 2150 ELO no Codeforces. Ele oferece chamada de função nativa, modos de raciocínio configuráveis, contexto de 256K em variantes maiores — tudo rodando localmente.

Se você está criando aplicações API-first, rodar o Gemma 4 localmente oferece uma camada de IA rápida e privada para gerar dados de mock, escrever cenários de teste e validar respostas sem expor dados a servidores remotos.

💡 Dica: Com o Gemma 4 rodando localmente, o Smart Mock do Apidog gera dados realistas para respostas de API usando inferência baseada em IA. Basta definir o schema da API e o Apidog gera mocks compatíveis — útil para testes consistentes sem fixtures manuais.

Este guia cobre da instalação à sua primeira chamada de API local.

O que há de novo no Gemma 4

Gemma 4 vem em quatro variantes, cada uma com capacidades distintas.

Gráfico comparando o desempenho do Gemma 3 e Gemma 4 em vários benchmarks de IA.

Principais novidades:

  • Raciocínio e codificação: O modelo 31B atinge 80% no LiveCodeBench v6 (vs. 29,1% do 27B anterior).
  • Mixture-of-Experts (MoE): A variante 26B usa apenas 4B de parâmetros ativos por inferência, entregando ótima qualidade com menor custo computacional.
  • Contexto longo: Modelos E2B/E4B suportam 128K tokens; 26B/31B suportam 256K.
  • Chamada de função nativa: Todos os modelos aceitam schemas de função e retornam JSON válido.
  • Entrada multimodal: E2B/E4B aceitam áudio e imagem.
  • Modos de raciocínio: Ative/desative chain-of-thought por requisição.

Variantes do modelo Gemma 4 explicadas

Escolha o modelo certo para seu hardware:

Modelo Tamanho em disco Contexto Arquitetura Melhor para
gemma4:e2b 7.2 GB 128K Densa Laptops, edge, áudio/imagem
gemma4:e4b 9.6 GB 128K Densa Maioria dos desenvolvedores
gemma4:26b 18 GB 256K MoE (4B) Qualidade por GB
gemma4:31b 20 GB 256K Densa Máxima qualidade

e4b é o modelo padrão ao rodar ollama run gemma4. Cabe em GPUs com 10+ GB de VRAM ou memória unificada do Apple Silicon.

O 26b (MoE) vale testar se você tem 20+ GB de RAM: qualidade próxima a modelos grandes com desempenho de 4B.

Pré-requisitos

  • Ollama v0.20.0 ou superior

    • Verifique: 
      ollama --version
    • Atualize se necessário: 
      # macOS
  brew upgrade ollama

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

  • Hardware mínimo:

    • gemma4:e2b: 8 GB RAM (16 GB recomendado)
    • gemma4:e4b: 10 GB VRAM ou 16 GB unificada
    • gemma4:26b: 20+ GB RAM/unificada
    • gemma4:31b: 24 GB VRAM ou 32 GB unificada

Instalando e executando o Gemma 4

Execute o modelo padrão:

ollama run gemma4
Enter fullscreen mode Exit fullscreen mode

Captura de tela da execução do comando 'ollama run gemma4'.

Na primeira execução, ~9,6 GB serão baixados. Você entra em uma shell interativa:

>>> Quais são os códigos de status HTTP para erros de cliente?
Enter fullscreen mode Exit fullscreen mode

Para variantes específicas:

# Modelo edge, menor
ollama run gemma4:e2b

# Modelo MoE
ollama run gemma4:26b

# Flagship
ollama run gemma4:31b
Enter fullscreen mode Exit fullscreen mode

Para baixar sem rodar:

ollama pull gemma4
ollama pull gemma4:26b
Enter fullscreen mode Exit fullscreen mode

Liste modelos baixados:

ollama list
Enter fullscreen mode Exit fullscreen mode

Usando a API Gemma 4 localmente

Ollama expõe uma API REST em http://localhost:11434.

Gerar uma conclusão 

curl http://localhost:11434/api/generate \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "prompt": "Escreva uma resposta JSON para um endpoint de API de perfil de usuário",
    "stream": false
  }'
Enter fullscreen mode Exit fullscreen mode

Chat (endpoint OpenAI) 

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "messages": [
      {
        "role": "user",
        "content": "Gere um mock JSON realista para uma resposta de API de pedido de e-commerce"
      }
    ]
  }'
Enter fullscreen mode Exit fullscreen mode

Cliente Python (requests) 

import requests

def ask_gemma4(prompt: str, model: str = "gemma4") -> str:
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False
        }
    )
    response.raise_for_status()
    return response.json()["response"]

result = ask_gemma4("Liste os campos que uma resposta de API de pagamento deve incluir")
print(result)
Enter fullscreen mode Exit fullscreen mode

Usando o SDK Python do OpenAI 

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # requerido pelo SDK
)

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {
            "role": "system",
            "content": "Você gera dados de resposta de API realistas em formato JSON."
        },
        {
            "role": "user",
            "content": "Gere uma resposta de exemplo para um endpoint GET /users/{id}"
        }
    ]
)

print(response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Usando chamada de função com o Gemma 4

Gemma 4 suporta chamada de função nativa. Defina um schema e o modelo retornará JSON validado.

Exemplo:

from openai import OpenAI

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

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_user",
            "description": "Recuperar um usuário por ID da API",
            "parameters": {
                "type": "object",
                "properties": {
                    "user_id": {
                        "type": "integer",
                        "description": "O ID de usuário único"
                    },
                    "include_orders": {
                        "type": "boolean",
                        "description": "Se deve incluir o histórico de pedidos"
                    }
                },
                "required": ["user_id"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {"role": "user", "content": "Obter usuário 42 com seu histórico de pedidos"}
    ],
    tools=tools,
    tool_choice="auto"
)

tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.function.name)       # get_user
print(tool_call.function.arguments)  # {"user_id": 42, "include_orders": true}
Enter fullscreen mode Exit fullscreen mode

Ativando o modo de raciocínio

Para tarefas complexas (ex: testes, análise de specs), ative o raciocínio chain-of-thought:

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {
            "role": "user",
            "content": "Projetar um cenário de teste completo para uma API de processamento de pagamentos com casos extremos"
        }
    ],
    extra_body={"think": True}
)

print(response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Para prompts simples, desative para ganhar desempenho.

Testando respostas da API Gemma 4 com Apidog

Com o Gemma 4 rodando, teste seus endpoints via Apidog:

Captura de tela do Apidog mostrando um cenário de teste para API Ollama.

Passos práticos:

  1. Importe a especificação da API do Ollama

    • No Apidog, crie projeto e use a base http://localhost:11434.

  2. Defina endpoints

    • POST /api/generate (resposta única)
    • POST /v1/chat/completions (chat multi-turno)
    • GET /api/tags (listar modelos)

  3. Configure Cenário de Teste

    • Passo 1: GET /api/tags — afirme que gemma4 está na lista.
    • Passo 2: POST /api/generate — afirme que response não está vazio.
    • Passo 3: POST /v1/chat/completions — valide formato da resposta.

Use o processador "Extrair Variável" para passar respostas entre passos e simular conversas multi-turno.

  1. Valide esquemas de resposta

    • Ative o Teste de Contrato do Apidog para garantir aderência ao OpenAPI.

  2. Smart Mock para dev paralelo

    • Gere respostas mock automáticas e compatíveis com o schema, sem precisar do modelo local rodando.

Entrada multimodal com o Gemma 4

E2B/E4B aceitam imagens (base64) junto ao texto:

import base64

with open("api_diagram.png", "rb") as f:
    image_data = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="gemma4:e4b",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{image_data}"
                    }
                },
                {
                    "type": "text",
                    "text": "Descreva o fluxo da API mostrado neste diagrama e identifique possíveis caminhos de erro"
                }
            ]
        }
    ]
)
Enter fullscreen mode Exit fullscreen mode

Use para analisar diagramas de arquitetura, capturas de documentação ou extrair dados de imagens.

Problemas comuns e soluções

  • Modelo não encontrado: Rode ollama pull gemma4 ou cheque com ollama list.
  • Inferência lenta na CPU: Use gemma4:e2b para melhor desempenho.
  • Erros de memória: Veja VRAM/memória com ollama ps. Se necessário, troque para modelo menor.
  • Apple Silicon não carrega: Atualize Ollama (v0.20.0+).
  • Porta 11434 ocupada: Use porta customizada: OLLAMA_HOST=0.0.0.0:11435 ollama serve
  • Respostas cortadas: Aumente contexto com "options": {"num_ctx": 8192} no corpo JSON.

Gemma 4 vs outros modelos locais

Modelo Melhor tamanho Contexto Chamada de função Codificação (benchmark)
Gemma 4 e4b (9.6 GB) 128K-256K Nativa 80% LiveCodeBench
Llama 3.3 70B-Q4 (40 GB) 128K Nativa ~60% LiveCodeBench
Qwen3.6-Plus 72B-Q4 (44 GB) 128K Nativa Forte
Mistral Small 24B (14 GB) 128K Nativa Moderado

Destaque: O Gemma 4 26B MoE (18 GB) entrega tokens/s superiores aos modelos densos grandes, mantendo ótima qualidade.

Para codificação, o 31B é competitivo com modelos maiores. Para edge/laptops, use o e2b (<8 GB).

Conclusão

Gemma 4 com Ollama entrega uma das melhores experiências locais para desenvolvedores hoje. Instalação rápida, roda na maioria das máquinas, e qualidade de raciocínio/codificação muito superior ao Gemma 3.

Comece com ollama run gemma4, teste a API com Apidog para validar endpoints, e escolha a variante ideal conforme sua carga de trabalho.

Se sua equipe constrói features de API sobre o Gemma 4, combine inferência local com Smart Mock e Cenários de Teste do Apidog para um fluxo completo de desenvolvimento sem dependências remotas.

Perguntas Frequentes

Como atualizo o Gemma 4 no Ollama?

Rode ollama pull gemma4 — baixa só o que mudou.

Posso rodar o Gemma 4 sem GPU?

Sim, mas é lento (1-3 tokens/s). Use e2b para CPUs.

Qual a diferença entre gemma4:e2b e gemma4:e4b?

Ambos são densos para edge. E4B é maior e lida melhor com prompts complexos. E2B é menor e aceita áudio. Para texto, e4b é padrão.

Funciona com LangChain e LlamaIndex?

Sim. Configure o provider Ollama para http://localhost:11434 e use gemma4 como modelo.

A API local é compatível com código OpenAI?

Quase sempre. Só mude o base_url para http://localhost:11434/v1 e forneça qualquer api_key.

Como uso o modo de raciocínio?

Adicione "think": true no extra_body (SDK OpenAI) ou no JSON direto. Desative para tarefas simples.

Posso servir Gemma 4 para outras máquinas?

Sim. Use OLLAMA_HOST=0.0.0.0:11434 ollama serve e acesse pelo IP da máquina.

Qual o melhor modelo Gemma 4 para dev de API?

Para mocks e testes, e4b equilibra velocidade e qualidade. Para análise complexa, 26b entrega melhor custo-benefício.

Top comments (0)