---
title: "Dá para rodar um LLM num Mac mini de 16 GB? O que medi com quantização"
description: "Dá: com quantização de 4 bits, modelos de 4 a 12 bilhões de parâmetros rodaram inteiros na GPU de um Mac mini M4 de 16 GB, de 13 a 36 tokens por segundo, nas minhas medições de outubro de 2026."
author: "João Thaira"
author_url: "https://joaothaira.com"
url: "https://joaothaira.com/writing/da-para-rodar-um-llm-num-mac-mini-de-16-gb"
published: "2026-10-25T00:00:00.000Z"
updated: "2026-10-25T13:58:46.079Z"
language: "pt-BR"
tags: ["quantização","LLM local","Mac mini","Ollama","GGUF"]
---

# Dá para rodar um LLM num Mac mini de 16 GB? O que medi com quantização

> Dá: com quantização de 4 bits, modelos de 4 a 12 bilhões de parâmetros rodaram inteiros na GPU de um Mac mini M4 de 16 GB, de 13 a 36 tokens por segundo, nas minhas medições de outubro de 2026.

**TL;DR:** Dá. Com **quantização de 4 bits** (o formato Q4_K_M), modelos de 4 a 12 bilhões de parâmetros couberam inteiros na GPU do meu Mac mini M4 de 16 GB e geraram **de 13 a 36 tokens por segundo** (medi em 25 de outubro de 2026, com o Ollama). Sem quantizar, só os pesos de um modelo de 9,7 bilhões de parâmetros ocupariam cerca de 19 GB, mais do que a máquina inteira tem.

Eu uso um Mac mini M4 de 16 GB como servidor em casa. É nele que roda o agente que escolhe pautas e escreve rascunhos para as contas da ThairaHub, com um Qwen de 9,7 bilhões de parâmetros. Eu queria saber, com número, o que cabe nessa máquina e quanto cada degrau de tamanho custa em velocidade. Então medi.

## O que é quantização, em uma frase?

Um modelo de linguagem é, em grande parte, uma lista enorme de números: os pesos. Depois de treinados, eles costumam ser guardados em 16 bits cada. Quantizar é guardar cada peso com menos bits, **trocando um pouco de precisão por muito menos memória.**

A conta é direta. 16 bits são 2 bytes, então um modelo de 9,7 bilhões de parâmetros em 16 bits ocupa uns 19,4 GB só de pesos. O formato Q4_K_M usa **cerca de 4,9 bits por peso** (4,8944, segundo a documentação do llama.cpp), e o mesmo modelo cai para perto de 6 GB. Na tabela do próprio llama.cpp, o Llama 3.1 de 8 bilhões de parâmetros vai de 14,96 GiB em 16 bits para 4,58 GiB em Q4_K_M: **pouco mais de três vezes menor.**

Os quatro modelos que medi estão em GGUF, o formato do llama.cpp, que é o que o Ollama roda por baixo.

## Quanto de memória e de velocidade cada modelo usou?

| Modelo | Parâmetros | Quantização | Memória carregado | Geração (tokens/s) |
| --- | --- | --- | --- | --- |
| Gemma 3 4B | 4,3 bilhões | Q4_K_M | 2,3 GB | 35,8 |
| Qwen 3.5 9B | 9,7 bilhões | Q4_K_M | 5,5 GB | 18,5 |
| Qwen 3.5 9B, contexto de 64 mil tokens | 9,7 bilhões | Q4_K_M | 7,8 GB | 18,5 |
| Gemma 3 12B | 12,2 bilhões | Q4_K_M | 7,2 GB | 13,1 |

Como medi: Mac mini M4 com 16 GB de memória unificada, macOS 15.5, Ollama 0.40.9, em 25 de outubro de 2026. O mesmo pedido em português para todos, até 300 tokens de resposta, temperatura 0. Rodei cada modelo duas vezes e contei a segunda, para o tempo de carregar o modelo não entrar na velocidade. A memória é a que o `ollama ps` informa com o modelo carregado, e **os quatro rodaram 100% na GPU.** O contexto foi o padrão de 4.096 tokens, menos na terceira linha.

A velocidade cai mais ou menos na proporção do tamanho: **o de 12 bilhões gerou pouco mais de um terço da velocidade do de 4 bilhões.** Carregar o modelo do zero levou de 10 a 16 segundos, o que só pesa na primeira chamada.

## Por que o contexto também ocupa memória?

O mesmo Qwen, com os mesmos pesos e a mesma quantização, ocupou 5,5 GB com contexto de 4.096 tokens e **7,8 GB com contexto de 65.536 tokens.** Os 2,3 GB a mais são a memória que o modelo reserva para guardar o que já leu da conversa, o chamado KV cache.

No Mac de 16 GB, então, a pergunta não é só se o modelo cabe. É se cabem **o modelo, o contexto e o resto do sistema** ao mesmo tempo. Eu uso a versão de 64 mil tokens porque o agente lê material longo antes de escrever, e mesmo assim sobra memória para a máquina continuar servindo o resto.

## Quantizar estraga o modelo?

Um pouco, e quanto menos bits, mais. A documentação da Unsloth explica que a quantização feita depois do treino (PTQ) muitas vezes piora a precisão, principalmente em 4 bits ou menos. Ela aponta dois caminhos: quantizações dinâmicas, que usam um conjunto de calibração para dar mais bits aos pesos que importam mais, e o treino ciente da quantização (QAT), em que o modelo aprende já sabendo que vai ser arredondado.

> "QAT has no extra overhead during inference, and uses the same disk and memory usage as normal naive quantization!"
> — Unsloth, documentação de Quantization-Aware Training

Em português: o QAT não deixa a inferência mais lenta e usa o mesmo disco e a mesma memória da quantização comum. Segundo a mesma página, ele recuperou **66,9% da precisão perdida** pelo Gemma 3 4B no teste GPQA. Eu ainda não testei QAT. É o próximo passo, e conto aqui quando fizer.

## Qual tamanho escolher num Mac de 16 GB?

Pelo que medi, e para o que eu faço:

- **9 bilhões em Q4_K_M** é o meu equilíbrio para um agente que roda sozinho: cabe com folga mesmo com 64 mil tokens de contexto e gera 18,5 tokens por segundo.
- **12 bilhões** cabe, mas sobra menos memória para contexto e para o resto da máquina.
- **4 bilhões** é para quando a resposta precisa ser rápida e a tarefa é simples.

Não é uma regra geral. Outra tarefa, outro modelo ou outra versão do Ollama dão outros números, e por isso deixei o método acima: dá para repetir a medição na sua máquina.

**Sources:**

- llama.cpp, README do `llama-quantize` (bits por peso e tamanhos por formato): https://github.com/ggml-org/llama.cpp/blob/master/tools/quantize/README.md
- Unsloth, Quantization-Aware Training (QAT): https://unsloth.ai/docs/blog/quantization-aware-training-qat
- Minhas medições: Mac mini M4 de 16 GB, macOS 15.5, Ollama 0.40.9, 25 de outubro de 2026.

---

By [João Thaira](https://joaothaira.com). Canonical: https://joaothaira.com/writing/da-para-rodar-um-llm-num-mac-mini-de-16-gb