DEV Community

Cover image for Como Usar o Gemma 4 12B Grátis: 6 Métodos que Funcionam em 2026
Lucas
Lucas

Posted on • Originally published at apidog.com

Como Usar o Gemma 4 12B Grátis: 6 Métodos que Funcionam em 2026

Gemma 4 12B tem pesos abertos e licença Apache 2.0. Na prática, isso significa: sem cobrança de API, sem assinatura e sem dependência obrigatória de nuvem. Você baixa o modelo e executa localmente, ou testa primeiro em uma demo no navegador. O custo real é o hardware que você já tem disponível.

Experimente o Apidog hoje

Antes de começar: o 12B foi pensado para uso local e em dispositivos. Os modelos maiores, 31B e 26B, são os que o Google hospeda para chat gratuito no AI Studio. O ponto forte do 12B é rodar em um laptop com 16GB de memória. Se você ainda não conhece o modelo, veja as especificações em o que é Gemma 4 12B.

Gemma 4 12B sendo executado em um laptop

Abaixo estão seis formas práticas de usar o Gemma 4 12B gratuitamente: da demo em navegador até uma API local compatível com OpenAI.

Resumo rápido

Método O que você obtém Melhor para
Hugging Face Space Chat no navegador, zero instalação Teste rápido
Ollama Modelo local + API compatível com OpenAI Desenvolvimento local
LM Studio Aplicativo desktop com GUI Quem não quer usar terminal
llama.cpp Servidor local leve Baixo overhead e ajustes avançados
HF Transformers Python, controle total, Colab gratuito Notebooks e fine-tuning
Google AI Edge Execução em dispositivo Celulares e edge devices

Método 1: testar no navegador, sem instalação

A forma mais rápida de validar o Gemma 4 12B é usar o Space oficial no Hugging Face. Você não precisa instalar nada, criar conta ou configurar GPU.

Captura de tela da demo do Gemma 4 12B no Hugging Face Spaces

Passos:

  1. Abra o Space de demonstração do Gemma 4 12B
  2. Digite um prompt
  3. Opcionalmente, envie uma imagem ou clipe de áudio
  4. Leia a resposta gerada

Use este método para uma verificação inicial. Como o Space aceita imagem e áudio, ele também serve para testar rapidamente o comportamento multimodal antes de configurar algo local.

Método 2: Ollama para rodar localmente com API

Ollama é o caminho mais direto para desenvolvedores: instala, baixa o modelo e expõe uma API local compatível com OpenAI.

Captura de tela de Ollama mostrando o Gemma 4 12B em execução no terminal

1. Instale o Ollama

No macOS ou Linux:

curl -fsSL https://ollama.com/install.sh | sh
Enter fullscreen mode Exit fullscreen mode

No Windows, baixe o instalador em ollama.com e execute-o.

2. Baixe e execute o Gemma 4 12B 

ollama pull gemma4:12b
ollama run gemma4:12b
Enter fullscreen mode Exit fullscreen mode

O primeiro comando baixa o modelo. Por padrão, o Ollama usa uma build quantizada em 4 bits, Q4_K_M, com cerca de 8GB. O segundo comando abre um chat interativo no terminal.

Para sair:

/bye
Enter fullscreen mode Exit fullscreen mode

3. Chame a API local

O Ollama expõe uma API REST compatível com OpenAI em:

http://localhost:11434
Enter fullscreen mode Exit fullscreen mode

Exemplo com curl:

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4:12b",
    "messages": [
      {
        "role": "user",
        "content": "Explique como os transformers funcionam em duas frases."
      }
    ]
  }'
Enter fullscreen mode Exit fullscreen mode

Como o endpoint segue o formato OpenAI, você pode reaproveitar SDKs, clientes de API, editores e frameworks que permitem configurar uma base_url.

Use:

http://localhost:11434/v1
Enter fullscreen mode Exit fullscreen mode

E defina o modelo como:

gemma4:12b
Enter fullscreen mode Exit fullscreen mode

Se você usa uma IDE ou editor com configuração estilo OpenAI, o fluxo é parecido com o mostrado neste tutorial de DeepSeek V4 no Cursor. Basta trocar o nome do modelo por gemma4:12b.

Comandos úteis:

ollama list
ollama ps
ollama show gemma4:12b
Enter fullscreen mode Exit fullscreen mode
  • ollama list: lista modelos baixados
  • ollama ps: mostra modelos em execução
  • ollama show gemma4:12b: exibe detalhes do modelo

Método 3: LM Studio sem terminal

Se você prefere uma interface gráfica, use o LM Studio, disponível para Windows, macOS e Linux.

Passos:

  1. Baixe e instale o LM Studio
  2. Procure por Gemma 4 12B no catálogo de modelos
  3. Escolha uma quantização compatível com sua RAM
  4. Baixe o modelo
  5. Abra a aba de chat e envie prompts

O LM Studio também pode executar um servidor local com endpoint compatível com OpenAI, geralmente na porta 1234.

Exemplo de URL base:

http://localhost:1234/v1
Enter fullscreen mode Exit fullscreen mode

Use este método se você quer testar o modelo localmente sem configurar terminal, scripts ou arquivos de ambiente.

Método 4: llama.cpp para um servidor leve

llama.cpp executa modelos GGUF com baixo overhead e também fornece um servidor compatível com OpenAI.

1. Instale o llama.cpp

No macOS:

brew install llama.cpp
Enter fullscreen mode Exit fullscreen mode

No Windows:

winget install llama.cpp
Enter fullscreen mode Exit fullscreen mode

2. Inicie o servidor local

Navegue pela coleção ggml-org/gemma-4 no Hugging Face para confirmar o nome exato do repositório 12B em GGUF. Depois, inicie o servidor:

llama-server -hf ggml-org/gemma-4-12B-it-GGUF
Enter fullscreen mode Exit fullscreen mode

A API fica disponível em:

http://localhost:8080/v1
Enter fullscreen mode Exit fullscreen mode

Este método é indicado quando você quer dependências mínimas, mais controle de flags ou execução em hardware modesto.

Método 5: Hugging Face Transformers com Python

Para notebooks, scripts e fine-tuning, use Transformers. Se você não tiver GPU local, pode começar com um notebook gratuito no Google Colab.

1. Instale as dependências 

pip install transformers torch accelerate torchvision

# Para entrada de áudio e vídeo
pip install librosa
Enter fullscreen mode Exit fullscreen mode

2. Carregue o modelo e gere texto 

from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "google/gemma-4-12B-it"

processor = AutoProcessor.from_pretrained(MODEL_ID)

model = AutoModelForMultimodalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto",
)

messages = [
    {"role": "system", "content": "Você é um assistente útil."},
    {"role": "user", "content": "Escreva uma piada curta sobre como economizar RAM."},
]

inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
    enable_thinking=False,
).to(model.device)

input_len = inputs["input_ids"].shape[-1]

outputs = model.generate(
    **inputs,
    max_new_tokens=1024
)

response = processor.decode(
    outputs[0][input_len:],
    skip_special_tokens=False
)

print(processor.parse_response(response))
Enter fullscreen mode Exit fullscreen mode

Para ativar raciocínio passo a passo:

enable_thinking=True
Enter fullscreen mode Exit fullscreen mode

Use esse modo para tarefas de matemática, planejamento ou raciocínio multi-etapas. Para chat rápido, mantenha False.

Para imagem ou áudio, adicione conteúdo multimodal na lista de mensagens, por exemplo:

{"type": "image", ...}
{"type": "audio", ...}
Enter fullscreen mode Exit fullscreen mode

Os pesos também estão disponíveis no Kaggle. Exemplos completos estão no guia do desenvolvedor.

Método 6: Google AI Edge para dispositivos

Para executar o Gemma 4 12B em celulares ou hardware de borda, use a stack Google AI Edge. O Google AI Edge Gallery e a CLI LiteRT-LM permitem executar o modelo no dispositivo.

Exemplo com LiteRT-LM:

litert-lm import \
  --from-huggingface-repo=litert-community/gemma-4-12B-it-litert-lm \
  gemma-4-12B-it.litertlm gemma4-12b

litert-lm serve
Enter fullscreen mode Exit fullscreen mode

Este é o caminho adequado para assistentes offline, apps móveis e cenários em que os dados não devem sair do dispositivo.

Teste sua API local do Gemma 4 12B com Apidog

Depois que o Gemma 4 12B estiver rodando via Ollama ou llama.cpp, você terá uma API HTTP local. Antes de integrar isso ao seu app, teste a requisição e a resposta em um cliente de API. Apidog é útil para validar payloads, streaming e variáveis de ambiente.

Captura de tela do Apidog mostrando como testar um endpoint de API local

Configuração recomendada:

  1. Baixe o Apidog
  2. Crie um novo projeto HTTP
  3. Adicione uma requisição POST
  4. Use a URL do Ollama: 
http://localhost:11434/v1/chat/completions
Enter fullscreen mode Exit fullscreen mode

Ou a URL do llama.cpp:

http://localhost:8080/v1/chat/completions
Enter fullscreen mode Exit fullscreen mode
  1. Defina o corpo como JSON
  2. Cole este payload: 
{
  "model": "gemma4:12b",
  "messages": [
    {
      "role": "user",
      "content": "Retorne um objeto JSON com dois campos: cidade e país."
    }
  ],
  "stream": false
}
Enter fullscreen mode Exit fullscreen mode

Para facilitar a troca entre servidores locais, salve a URL base como variável de ambiente:

{{base_url}}/chat/completions
Enter fullscreen mode Exit fullscreen mode

Exemplos de valores:

http://localhost:11434/v1
http://localhost:8080/v1
Enter fullscreen mode Exit fullscreen mode

Depois, adicione uma asserção para confirmar que a resposta contém JSON válido no campo content.

Para testar streaming, altere:

"stream": true
Enter fullscreen mode Exit fullscreen mode

Assim você valida o comportamento de tokens transmitidos antes de implementar uma UI.

Esse fluxo evita descobrir erros de payload, nomes de campos ou formato de resposta apenas dentro da aplicação. Se você estiver comparando ferramentas, veja também as ferramentas gratuitas de teste de API online, as melhores alternativas ao Postman e este guia sobre como testar APIs com fluxos de trabalho estilo Postman.

Qual quantização escolher?

A escolha da quantização depende da memória disponível.

Build Memória necessária Compromisso
Precisão total ~16GB Melhor qualidade
8-bit ~14GB Qualidade quase total
4-bit, Q4_K_M ~8GB Leve queda de qualidade, roda em mais máquinas

O Ollama usa a build de 4 bits por padrão. Por isso, ele costuma rodar bem em uma GPU de 8GB ou em um MacBook com 16GB de memória unificada.

Se você tiver memória suficiente, teste a build de 8 bits para obter melhor qualidade.

Qual método gratuito usar?

Use esta árvore de decisão:

  • Só quer testar? Use o Hugging Face Space
  • Vai desenvolver uma aplicação? Use Ollama
  • Não quer terminal? Use LM Studio
  • Quer baixo overhead? Use llama.cpp
  • Vai usar Python, notebooks ou fine-tuning? Use Transformers
  • Vai rodar em celular ou edge device? Use Google AI Edge

Para a maioria dos desenvolvedores, a combinação mais prática é:

  • Ollama para uso local diário
  • Transformers para experimentos avançados
  • Apidog para testar a API antes de integrar ao app

Dicas práticas para usar o Gemma 4 12B localmente

  • Escolha a quantização pela RAM disponível. Se o sistema começar a usar swap em disco, a execução ficará lenta.
  • Comece com 4 bits. É a opção mais segura para laptops e máquinas com menos memória.
  • Ative o modo de pensamento apenas quando necessário. Use enable_thinking=True para tarefas difíceis; para chat simples, mantenha desativado.
  • Controle o tamanho do contexto. Mesmo com janela de 256K, transcrições longas e bases de código grandes aumentam custo de memória e latência.
  • Valide requisições no Apidog antes de codar a integração. Confirme payload, headers, resposta e streaming.
  • Reaproveite o mesmo padrão com outros modelos locais. O fluxo também se aplica a Qwen 3.7, MiniMax M3 e Claude Opus 4.8.

FAQ

Gemma 4 12B é realmente grátis?

Sim. Ele tem pesos abertos com licença Apache 2.0. Você pode baixar e executar gratuitamente, inclusive em uso comercial. Você paga apenas pelo hardware local ou pela nuvem onde decidir executá-lo.

Preciso de uma GPU?

Não obrigatoriamente, mas ajuda. A build de 4 bits roda em uma GPU de 8GB ou em um Mac com 16GB de memória unificada. Em CPU, funciona, mas será mais lento.

Posso usar Gemma 4 12B no Google AI Studio?

Atualmente, não. O AI Studio hospeda os modelos 31B e 26B para chat gratuito no navegador. O 12B foi construído para uso local e em dispositivos.

A API local precisa de chave de API?

Não. Ollama e llama.cpp servem o modelo em localhost sem chave. Se alguma ferramenta exigir um campo de API key, use qualquer string placeholder; o servidor local deve ignorá-la.

Posso chamar o Gemma 4 12B a partir do meu código OpenAI existente?

Sim. Ollama e llama.cpp expõem endpoints compatíveis com OpenAI.

Use uma destas URLs base:

http://localhost:11434/v1
http://localhost:8080/v1
Enter fullscreen mode Exit fullscreen mode

Depois, ajuste o nome do modelo para:

gemma4:12b
Enter fullscreen mode Exit fullscreen mode

Como uso entrada de imagem e áudio?

Use Transformers, LM Studio ou apps do AI Edge com suporte multimodal. Em geral, adicione conteúdo de imagem antes do texto e conteúdo de áudio depois dele na estrutura da mensagem.

Qual é mais rápido: Ollama ou llama.cpp?

Eles usam o mesmo motor subjacente. O llama.cpp oferece menos overhead e mais opções de ajuste. O Ollama é mais simples de instalar e operar. Para a maioria dos usos locais, a diferença prática é pequena.

Top comments (0)