Os melhores modelos de Ollama para o dia a dia (guia 2026)

Guia 2026 para escolher modelos de Ollama: tabela comparativa de Qwen 3.5, Gemma 4, gpt-oss, qwen3-coder e mais, com quantização, RAM necessária e o que instalar conforme seu equipamento.

Índice

A tabela comparativa
Como ler esta tabela sem errar
O que torna um modelo "eficiente" em 2026
Os modelos, um por um
O que instalar conforme seu equipamento
Quantização, em dois minutos
Erros frequentes que arruínam a experiência
Um stack recomendado para começar hoje
Perguntas frequentes
O que realmente mudou

A tabela comparativa

Modelo (tag)	Tamanho do download	Contexto	RAM recomendada	Multimodal	Ferramentas / raciocínio	Melhor para
`qwen3.5:2b`	2.7 GB	256K	8 GB	Texto + imagem	Sim / Sim	O coringa mínimo. Resumos, reescrita, classificação
`llama3.2:3b`	2.0 GB	128K	8 GB	Só texto	Sim / Não	Respostas instantâneas, autocompletar, tarefas simples na CPU
`qwen3.5:4b`	3.4 GB	256K	8–12 GB	Texto + imagem	Sim / Sim	O melhor ponto de partida para a maioria das pessoas
`gemma4:e2b-it-qat`	4.3 GB	128K	8–12 GB	Texto + imagem	Sim / Sim	Redação e tom natural em equipamentos modestos
`qwen3.5:9b`	6.6 GB	256K	16 GB	Texto + imagem	Sim / Sim	O melhor equilíbrio qualidade/peso de toda a lista
`gemma4:12b`	7.6 GB	256K	16 GB	Texto + imagem	Sim / Sim	Textos longos, análise de documentos, multilíngue
`gpt-oss:20b`	14 GB	128K	16–24 GB	Só texto	Sim / Sim (ajustável)	Raciocínio explícito e fluxos agenticos
`qwen3-coder:30b`	19 GB	256K	24 GB	Só texto	Sim / Não	Programação em escala de repositório (MoE, 3.3B ativos)
`qwen3.5:27b`	17 GB	256K	24 GB	Texto + imagem	Sim / Sim	Qualidade de "assistente sério" sem depender da nuvem
`qwen3.6:35b`	24 GB	256K	32 GB+	Texto + imagem	Sim / Sim	O melhor que você consegue rodar em hardware de consumo alto
`gemma4:31b-it-qat`	19 GB	256K	24–32 GB	Texto + imagem	Sim / Sim	Alternativa ao Qwen com licença e tom diferentes
`glm-ocr`	2.2 GB	128K	8 GB	Imagem → texto	Sim / Não	OCR de notas fiscais, tabelas e documentos escaneados
`embeddinggemma:300m`	622 MB	2K	8 GB	Embeddings	—	Busca semântica e RAG sobre seus arquivos
`nomic-embed-text`	274 MB	8K	8 GB	Embeddings	—	O clássico de RAG, rápido e testado

A coluna "RAM recomendada" não é o tamanho do arquivo: inclui o espaço que o contexto ativo precisa e a margem para o seu sistema operacional continuar respirando. Mais sobre isso daqui a pouco.

Como ler esta tabela sem errar

Existem três números que as pessoas confundem o tempo todo, e confundi-los é o motivo número um pelo qual alguém baixa um modelo e conclui que "modelos locais são ruins".

O tamanho do download não é a RAM que ele consome. Um modelo de 6.6 GB ocupa esses 6.6 GB na memória mais a cache de atenção (KV cache), que cresce com o tamanho da conversa. Uma regra prática razoável: some 20–30 % ao tamanho do arquivo para uso normal e deixe pelo menos 2 GB livres para o sistema. Se você for usar contextos muito longos, a margem precisa ser maior.

O número de parâmetros já não prevê a velocidade. Um qwen3-coder:30b tem 30 bilhões de parâmetros totais, mas só ativa 3.3 bilhões por token, porque é uma arquitetura mixture of experts (MoE). Gera texto na velocidade de um modelo pequeno e responde com o critério de um modelo grande. O preço você paga em RAM, não em tempo de espera. O mesmo vale para qwen3.5:35b-a3b e gemma4:26b-a4b.

A janela de contexto anunciada não é de graça. O fato de um modelo suportar 256K tokens não significa que você consiga usar 256K no seu notebook. Esse contexto se materializa em memória. Na prática, em um equipamento de 16 GB você vai trabalhar confortável entre 8K e 32K tokens, o que é mais do que suficiente para praticamente qualquer tarefa cotidiana.

O que torna um modelo "eficiente" em 2026

Vale entender por que a lista acima parece tão diferente da de dois anos atrás.

A maior mudança é a quantização consciente do treinamento (QAT). Em vez de treinar um modelo em precisão total e depois comprimi-lo — perdendo qualidade no processo —, os laboratórios agora treinam o modelo sabendo que ele vai rodar em 4 bits. O Google publica variantes -it-qat da Gemma 4 que pesam bem menos que as Q4 tradicionais: gemma4:e4b-it-qat ocupa 6.1 GB frente aos 9.6 GB da versão padrão, com uma degradação muito menor do que você esperaria. Se você vai usar a Gemma 4, comece sempre pela tag QAT.

A segunda mudança é o MXFP4, o formato que a OpenAI usa no gpt-oss. Os pesos MoE estão quantizados a 4.25 bits por parâmetro desde o pós-treinamento, e o Ollama os executa nativamente, sem conversões adicionais. É o motivo pelo qual um modelo de 20B cabe em 14 GB e funciona em um equipamento de 16 GB de memória.

A terceira é a proliferação de tamanhos intermediários. O Qwen 3.5 sai em 0.8B, 2B, 4B, 9B, 27B, 35B e 122B. Essa granularidade importa: em vez de escolher entre "bobo demais" e "não cabe", você consegue encontrar o degrau exato para o seu hardware.

E o quarto, no Mac: as tags MLX e nvfp4. Se você tem Apple Silicon, as variantes -mlx são compiladas para o motor da Apple e costumam dar melhor desempenho por watt do que os GGUF genéricos. qwen3.5:9b-mlx (8.9 GB) é uma excelente opção num MacBook com 16 GB de memória unificada.

Os modelos, um por um

Qwen 3.5 — a família que você deveria instalar primeiro

Se você for ler só um parágrafo deste guia, que seja este. A família Qwen 3.5 cobre de 0.8B até 122B, todos com 256K de contexto nativo e todos com entrada de texto e imagem. É multimodal, suporta chamada de ferramentas e tem modo de raciocínio. Na prática, é o modelo que resolve 80 % do que as pessoas pedem a um assistente local.

ollama pull qwen3.5:4b     # 3.4 GB — o ponto de entrada
ollama pull qwen3.5:9b     # 6.6 GB — o ponto doce
ollama pull qwen3.5:27b    # 17 GB  — se sua GPU aguenta

O 9b é provavelmente a melhor relação qualidade/tamanho de todo o catálogo neste momento. Cabe em 16 GB com espaço para trabalhar, entende imagens, e a diferença para o 27b em tarefas cotidianas — redigir, resumir, traduzir, explicar — é bem menor do que a diferença de peso sugere.

Quando não usar: se a sua tarefa principal é escrever código agéntico sobre um repositório grande, o qwen3-coder:30b foi treinado especificamente para isso.

Gemma 4 — a alternativa do Google, com áudio

A Gemma 4 é a resposta do Google e traz algo que o Qwen não tem: entrada de áudio, além de visão, ferramentas e raciocínio. Os tamanhos vão de e2b a 31b, onde as variantes "e" são modelos de parâmetros efetivos — projetados para que o custo computacional real seja menor do que o nominal.

ollama pull gemma4:e2b-it-qat   # 4.3 GB
ollama pull gemma4:12b          # 7.6 GB, 256K de contexto
ollama pull gemma4:31b-it-qat   # 19 GB

O gemma4:12b merece atenção especial: 7.6 GB para 256K de contexto é uma densidade excelente, e a Gemma tende a escrever num registro mais natural e menos "de manual" do que outras famílias. Para e-mails, artigos e textos que vão ser lidos por gente, muita gente prefere ela.

Quando não usar: em tarefas de raciocínio matemático ou código, o Qwen e o gpt-oss costumam estar à frente.

gpt-oss:20b — raciocínio com esforço ajustável

Os modelos de pesos abertos da OpenAI chegaram com duas características que os tornam diferentes: cadeia de pensamento completa e visível, e esforço de raciocínio configurável em três níveis (baixo, médio, alto). Você pode pedir que ele pense pouco quando quer velocidade, e muito quando o problema justifica.

ollama pull gpt-oss:20b   # 14 GB, 128K de contexto

Licença Apache 2.0, sem restrições copyleft, apto para uso comercial. É a opção padrão se o seu caso de uso envolve agentes, chamadas de funções, saídas estruturadas ou depuração de raciocínio — porque você consegue ler exatamente como ele chegou à conclusão.

Quando não usar: ele não processa imagens. Se você precisa de multimodalidade, volte para o Qwen ou a Gemma.

qwen3-coder:30b — o especialista em código

30B totais, 3.3B ativos, 256K de contexto nativo (extrapolável para 1M). Treinado com 7,5 trilhões de tokens, com 70 % de proporção de código, e com aprendizado por reforço voltado para a execução real de código. É projetado para tarefas de engenharia em escala de repositório, não para autocompletar linhas soltas.

ollama pull qwen3-coder:30b   # 19 GB
ollama launch opencode --model qwen3-coder

Numa GPU de 24 GB é a melhor opção de programação local que existe hoje. Por ser MoE, gera na velocidade de um modelo pequeno apesar do tamanho.

Quando não usar: para perguntas gerais é desperdício de RAM. Mantenha um modelo de propósito geral carregado em paralelo.

Qwen 3.6 — o degrau de cima

A geração mais recente do Qwen, disponível em 27b (17 GB) e 35b (24 GB). As melhorias se concentram em codificação agéntica — fluxos de frontend e raciocínio em nível de repositório — e em preservação de raciocínio, uma opção que mantém o contexto de pensamento das mensagens anteriores para não repetir trabalho em conversas iterativas.

ollama pull qwen3.6:27b

Se você tem 32 GB ou mais e quer o melhor que roda em hardware de consumo, é este. Se tem 16 GB, fique com o qwen3.5:9b e não sofra.

Llama 3.2 (1B e 3B) — o peso-pena

A Llama 3.2 já não é a mais nova, mas continua relevante por um motivo concreto: 1.3 GB e 2.0 GB com suporte a ferramentas e 128K de contexto. É o modelo que você deixa carregado permanentemente numa máquina modesta ou num servidor pequeno, o que responde em menos de um segundo, o que roda bem mesmo sem GPU.

ollama pull llama3.2:3b   # 2.0 GB
ollama pull llama3.2:1b   # 1.3 GB

Para reescrever um parágrafo, classificar um texto, extrair entidades ou gerar uma resposta curta, é perfeitamente adequado. Para raciocinar sobre um problema, não.

glm-ocr — o especialista que quase ninguém conhece

Só 0.9B de parâmetros, 2.2 GB de download, e faz uma coisa extraordinariamente bem: converter documentos em texto estruturado. Tabelas complexas, fórmulas, carimbos, documentos com muito código, layouts difíceis. Tem modos específicos que são invocados no próprio prompt:

ollama run glm-ocr Text Recognition: ./nota-fiscal.png
ollama run glm-ocr Table Recognition: ./relatorio.png
ollama run glm-ocr Figure Recognition: ./diagrama.png

Se você digitaliza notas fiscais, recibos ou documentos escaneados com frequência, este modelo sozinho justifica ter o Ollama instalado.

Os modelos de embeddings — invisíveis, mas necessários

Se você quer buscar entre seus próprios documentos — "onde eu mencionei o orçamento de março?" — você precisa de um modelo de embeddings, não de um chatbot. São minúsculos e fazem um trabalho diferente: converter texto em vetores para poder compará-lo por significado.

ollama pull embeddinggemma:300m      # 622 MB, do Google
ollama pull nomic-embed-text         # 274 MB, o padrão de fato
ollama pull qwen3-embedding:0.6b     # se você já usa a família Qwen

Atenção à janela de contexto aqui: embeddinggemma aceita 2K tokens e nomic-embed-text chega a 8K. Isso condiciona como fatiar seus documentos — fragmentos de 500 a 1000 tokens funcionam bem com qualquer um dos dois.

Para conteúdo em português ou multilíngue, nomic-embed-text-v2-moe e snowflake-arctic-embed2 são treinados especificamente para retrieval multilíngue e costumam dar resultados melhores do que as versões só em inglês.

O que instalar conforme seu equipamento

8 GB de RAM (sem GPU dedicada ou com GPU pequena)

Este é o cenário mais comum e o mais mal interpretado. Sim funciona, mas você precisa ser disciplinado: um modelo carregado de cada vez, quantização Q4, contexto moderado.

ollama pull qwen3.5:4b       # 3.4 GB — seu modelo principal
ollama pull llama3.2:3b      # 2.0 GB — para respostas instantâneas
ollama pull glm-ocr          # 2.2 GB — documentos e imagens
ollama pull nomic-embed-text # embeddings para busca local

A regra de ouro com 8 GB: um modelo pequeno em Q4 sempre supera um modelo grande em Q2. A tentação de forçar um 14B comprimido ao extremo termina em respostas incoerentes. Não faça isso.

16 GB de RAM

É aqui que a experiência começa a parecer confortável de verdade. Você consegue rodar um modelo de 9–12B com contexto amplo, ou manter dois modelos pequenos carregados ao mesmo tempo para compará-los.

ollama pull qwen3.5:9b       # 6.6 GB — seu cavalo de batalha
ollama pull gemma4:12b       # 7.6 GB — para textos longos
ollama pull gpt-oss:20b      # 14 GB — para raciocínio (um de cada vez)
ollama pull embeddinggemma:300m

Com 16 GB você também pode se dar ao luxo de subir para a quantização Q5 ou Q8 em modelos pequenos, o que recupera um pouco de fidelidade de raciocínio em troca de pouca velocidade.

24 GB de VRAM (RTX 4090 / 5090 ou similar)

A faixa em que os modelos locais deixam de parecer um compromisso.

ollama pull qwen3.5:27b      # 17 GB — assistente geral sério
ollama pull qwen3-coder:30b  # 19 GB — programação
ollama pull gemma4:31b-it-qat # 19 GB — alternativa multimodal

32 GB ou mais (incluindo memória unificada no Mac)

ollama pull qwen3.6:35b      # 24 GB — o teto prático de consumo
ollama pull qwen3.5:35b-a3b  # 24 GB — MoE, mais rápido do que o tamanho sugere

No Apple Silicon, teste primeiro as tags MLX: qwen3.6:35b-mlx (22 GB) e qwen3.5:27b-mlx (20 GB) são otimizadas para o hardware da Apple.

Quantização, em dois minutos

A quantização reduz a precisão dos pesos do modelo para que ele ocupe menos memória. É a alavanca mais importante que você tem, e é onde mais gente erra.

Q4_K_M é o padrão. Reduz o consumo em cerca de 70 % frente à precisão total, com uma perda de qualidade que em tarefas cotidianas é difícil de perceber. Se está em dúvida, escolha esta. Em equipamentos de 8 GB não é uma opção: é a única opção sensata.

Q8_0 aproximadamente dobra o tamanho em relação ao Q4 e recupera fidelidade em raciocínio e matemática. Faz sentido em modelos pequenos quando você tem memória sobrando — qwen3.5:4b-q8_0 pesa 5.3 GB e é notavelmente mais sólido que a versão Q4 em tarefas de lógica.

QAT (as tags -it-qat da Gemma) é quantização treinada, não comprimida depois. Quando existir, prefira em relação à Q4 equivalente.

MXFP4 é o formato nativo do gpt-oss. Você não precisa escolher nada: o modelo já vem assim.

MLX / nvfp4 são variantes para Apple Silicon e para GPUs NVIDIA com suporte a FP4. Se o seu hardware se enquadra, dão melhor desempenho com o mesmo ou menor consumo.

A hierarquia prática de decisão é simples: escolha primeiro o tamanho de modelo que cabe na sua memória com Q4, e só depois considere subir a quantização se tiver espaço sobrando. Nunca o contrário.

Erros frequentes que arruínam a experiência

Colocar o contexto no máximo "para garantir". Configurar 256K de contexto num equipamento de 16 GB enche a memória com cache vazia e deixa você sem espaço para o modelo. Comece em 8K e suba só se precisar.

Avaliar um modelo pela primeira resposta. A primeira geração inclui o tempo de carregar o modelo na memória. A segunda é a que representa a velocidade real.

Usar um modelo de chat para busca semântica. São ferramentas diferentes. Se você quer buscar nos seus documentos, precisa de um modelo de embeddings mais um banco vetorial, não de um chatbot com o documento colado no prompt.

Ignorar as tags específicas. ollama pull gemma4 traz o latest, que é o e4b a 9.6 GB. gemma4:e4b-it-qat faz praticamente a mesma coisa em 6.1 GB. Vale a pena olhar a lista de tags antes de baixar.

Não limpar modelos antigos. Cada experimento deixa gigabytes no disco. ollama list mostra o que você tem e ollama rm <modelo> apaga.

Um stack recomendado para começar hoje

Se você quer uma configuração que funcione bem desde o primeiro dia sem pensar muito, num equipamento de 16 GB:

# Modelo principal: conversa, resumos, redação, imagens
ollama pull qwen3.5:9b

# Respostas rápidas e tarefas simples
ollama pull llama3.2:3b

# Documentos escaneados, notas fiscais, tabelas
ollama pull glm-ocr

# Busca semântica sobre seus arquivos
ollama pull embeddinggemma:300m

São cerca de 10 GB em disco e cobrem praticamente tudo o que uma pessoa faz com um assistente: escrever, resumir, traduzir, explicar, ler documentos e encontrar coisas. Quando alguma dessas tarefas ficar curta para você, já saberá exatamente qual modelo adicionar e por quê.

Perguntas frequentes

Quanta RAM eu preciso para rodar o Ollama?

Como mínimo prático, 8 GB com um modelo de 4B em quantização Q4 e contexto moderado. Para uma experiência confortável e sem compromisso, 16 GB permitem rodar modelos de 9–12B. Para uso sério de código ou um assistente geral de qualidade, mire em 24 GB de VRAM. Lembre de somar ao tamanho do modelo uns 20–30 % extra para o contexto e deixar 2 GB livres para o sistema.

Qual é o melhor modelo de Ollama para um notebook de 16 GB?

qwen3.5:9b (6.6 GB). É multimodal, tem 256K de contexto, suporta ferramentas e raciocínio, e deixa memória livre suficiente para trabalhar. É a melhor relação qualidade/peso do catálogo neste momento.

O Ollama é grátis?

Sim. O Ollama é software livre e os modelos recomendados por este guia têm licenças permissivas (Apache 2.0, derivadas de Apache 2.0 e similares, aptas para uso comercial). A única coisa que você paga é eletricidade e hardware.

Posso usar o Ollama sem conexão com a internet?

Sim. Depois de baixar o modelo com ollama pull, todo o processamento acontece localmente. Nada é enviado para a nuvem, o que o torna ideal para dados sensíveis, contratos, notas fiscais ou trabalho offline.

Qual é a diferença entre um modelo de chat e um de embeddings?

Um modelo de chat (como o qwen3.5:9b) gera texto a partir de uma instrução. Um modelo de embeddings (como nomic-embed-text ou embeddinggemma:300m) converte texto em vetores numéricos para comparar documentos por significado. Se você quer buscar "onde eu falei do orçamento de março?" nos seus arquivos, precisa de embeddings, não de um chatbot.

O que realmente mudou

Há dois anos, rodar um modelo local significava aceitar um assistente claramente inferior em troca de privacidade. Hoje a equação é diferente: para as tarefas cotidianas — redigir, resumir, reescrever, classificar, extrair, traduzir — um qwen3.5:9b de 6.6 GB faz um trabalho que a maioria das pessoas não distinguiria do de um serviço na nuvem.

A brecha continua existindo, mas se deslocou para cima: está no raciocínio profundo, em tarefas de código muito complexas e em conhecimento de mundo muito atualizado. Todo o resto já cabe no seu notebook, funciona offline e não conta nada a ninguém.

Todos os tamanhos, tags e janelas de contexto citados vêm do catálogo oficial do Ollama, consultado em agosto de 2026. Os modelos são atualizados com frequência: verifique as tags atuais em ollama.com antes de baixar.