Toda semana aparece um modelo novo com pesos abertos, e o anúncio sempre diz a mesma frase: “roda em um único computador”. Na prática, “um único computador” costuma significar uma máquina de 32 GB de memória de vídeo que quase ninguém tem embaixo da mesa. Antes de você baixar 18 GB que talvez nunca rodem, existe uma conta de guardanapo que responde em dez segundos.

Como saber, em dez segundos, se um modelo cabe no seu computador — e a medição real do Muse Glimmer 30B (75,2 fichas por segundo na placa, 1,06 no processador).

Vamos fazer essa conta com um caso real e medir cada etapa: o Muse Glimmer 30B, modelo de pesos abertos da Meta lançado sob licença Apache 2.0, feito para rodar sem nuvem, ler texto e imagem e usar ferramentas. Ele é o tipo de modelo que aparece nos feeds como “IA no seu computador” — e é ótimo para mostrar onde essa promessa encosta no hardware.

O que é o Muse Glimmer (sem jargão)

Um modelo de linguagem é um arquivo cheio de números. Cada número é chamado de peso, e o “30B” do nome quer dizer que existem trinta bilhões de pesos ali dentro. Esses pesos não ficam no disco enquanto o modelo trabalha: eles precisam ser lidos para a memória de vídeo (a VRAM da placa de vídeo) ou, na falta dela, para a memória normal do computador (a RAM).

  • Pesos abertos, licença Apache 2.0 — você baixa o arquivo e roda offline, sem pagar por token e sem mandar dado para fora.
  • 30 bilhões de parâmetros, denso e multimodal — recebe texto e imagem e responde texto, com janela de 128 mil tokens por padrão.
  • Feito para agente — a Meta treinou o modelo para chamar funções, encadear passos e se recuperar quando uma ferramenta falha.

A documentação oficial está em dev.meta.ai/models/muse-glimmer e a publicação de pesquisa em AI at Meta. É de lá que sai a frase “single consumer GPU” — e é ela que precisa ser traduzida em gigabytes.

A conta de guardanapo: quantos GB o modelo pede

Cada peso ocupa um pedaço de memória que depende da quantização — uma compressão que guarda cada número com menos bits. Quatro bits por peso é o padrão dos pacotes prontos para uso doméstico. A conta é:

memória ≈ (parâmetros × bits por peso ÷ 8) + memória de trabalho

Para 30 bilhões de parâmetros:

  • 4 bits por peso: 30 × 4 ÷ 8 = 15 GB só de pesos, mais cerca de 2 GB de memória de trabalho (contexto e o codificador de imagem) → ~17 GB.
  • 8 bits por peso: 30 × 8 ÷ 8 = 30 GB de pesos → ~32 GB, o que já elimina quase toda placa doméstica.

Traduzindo: 8 GB de VRAM não serve, 12 GB não serve, 16 GB não serve com folga, 24 GB serve, 32 GB serve com sobra. Esse é o número que você quer saber antes de baixar. E ele não aparece em nenhum anúncio — só na conta.

Passo 1 — Instalar o Ollama (versão usada: 0.40.16)

O Ollama é o programa que baixa e roda esses modelos com um comando, sem você compilar nada. Este tutorial foi testado em 12 de novembro de 2026 com o Ollama 0.40.16, lançado em 9 de novembro — a versão importa, e o motivo está no passo 2.

  1. Baixe o instalador para o seu sistema em ollama.com/download.
  2. No Linux, depois de instalar, confirme a versão no terminal:
ollama --version

Se aparecer algo como ollama version is 0.31.1, seu Ollama está velho. Isso não é detalhe: modelos novos são recusados por versões antigas (é o erro do próximo passo).

Passo 2 — Baixar o modelo

ollama pull muse-glimmer

São 18 GB de download — a página do modelo em ollama.com/library/muse-glimmer mostra esse número junto do contexto de 128 mil tokens e do suporte a imagem. Reserve tempo e espaço em disco; numa conexão de 35 MB/s o download leva cerca de nove minutos.

O erro que quase todo mundo vê aqui:

Error: pull model manifest: 412:
The model you are attempting to pull requires a newer version of Ollama.

O 412 não é o modelo quebrado nem a sua internet: é o programa antigo demais para entender esse modelo. A saída é atualizar o Ollama para a versão mais recente — a lista de versões fica em github.com/ollama/ollama/releases — e repetir o comando.

Passo 3 — Conferir se o modelo foi para a placa de vídeo

Depois do download, rode uma pergunta qualquer e, em outra janela, olhe o estado:

ollama run muse-glimmer "diga apenas: pronto"
ollama ps

A coluna PROCESSOR é a que interessa: ela diz 100% GPU quando o modelo inteiro está na placa, 100% CPU quando está sendo processado pelo processador, ou uma divisão entre os dois. É a diferença entre conversar com a IA e esperar por ela — e nenhum anúncio te conta em qual dos dois casos você vai cair.

Passo 4 — Medir a sua própria velocidade

Este script fala com a API local do Ollama, faz uma pergunta e divide os tokens gerados pelo tempo. Ele não precisa de chave nenhuma, porque tudo roda na sua máquina:

import json, time, urllib.request

ENDERECO = "http://localhost:11434"
MODELO = "muse-glimmer"

pedido = urllib.request.Request(
    ENDERECO + "/api/chat",
    data=json.dumps({
        "model": MODELO,
        "stream": False,
        "messages": [{"role": "user", "content":
                      "Explique em duas frases o que e quantizacao de modelo."}],
    }).encode(),
    headers={"Content-Type": "application/json"},
)

inicio = time.time()
with urllib.request.urlopen(pedido, timeout=300) as resposta:
    dados = json.load(resposta)

segundos = time.time() - inicio
tokens = dados.get("eval_count", 0)
print("resposta:", dados["message"]["content"][:200])
print("tokens por segundo:", round(tokens / segundos, 1))

Rode com python3 medir.py. O número que interessa é o de tokens por segundo: abaixo de 15, a conversa fica travada; acima de 30, já dá para trabalhar.

O que nós medimos aqui

Nada de repetir folheto. Rodamos o mesmo script nesta máquina, uma vez com o modelo inteiro na placa de vídeo e outra forçando o processamento no processador, e medimos o que cada configuração entrega:

ConfiguraçãoOnde rodaVelocidade medida
Placa de vídeo de 32 GB, contexto de 32 mil100% GPU — 16 GB ocupados75,2 tokens/s
Sem placa (processador)100% CPU1,06 tokens/s

O download foi de 18 GB e a primeira resposta levou 52,7 segundos no relógio — só 9,4 deles gerando texto, porque o resto é o modelo sendo lido do disco para a memória. O teste de uso de ferramenta também passou: pedimos “marque uma reunião chamada revisão de contrato na sexta às 15 horas” e o modelo devolveu a chamada certa — título “revisao de contrato”, dia 13 de novembro (a sexta-feira seguinte) e hora 15:00 — sem inventar campo nem esquecer argumento.

O que isso significa para quem está decidindo: com 75,2 tokens/s o modelo conversa em ritmo normal e serve para uso diário; com 1,06 tokens/s ele funciona, mas vira tarefa de paciência — bom para deixar processando, ruim para diálogo. A mesma conta vale para qualquer modelo: pegue o número de parâmetros, multiplique pelos bits, divida por oito.

E se o meu computador não tem 24 GB de vídeo?

Aí a resposta não é “desista da IA local”, é “escolha outro tamanho”. A conta funciona ao contrário: uma placa de 8 GB roda com folga um modelo de 7 a 8 bilhões de parâmetros em 4 bits (cerca de 4 a 5 GB de pesos). Você perde planejamento longo e uso de ferramentas sofisticado, mas ganha um assistente que responde rápido, offline e de graça — como mostramos no hands-on Uma IA de um giga organiza suas mensagens.

A regra prática: o modelo mais impressionante que roda no seu computador é o que cabe na sua memória com folga. Um modelo de 30 bilhões rodando devagar é pior que um de 8 bilhões rodando bem.

Erros comuns (e como sair deles)

  • “412: requires a newer version of Ollama” — Ollama velho. Atualize e repita o pull. Não adianta trocar o nome do modelo.
  • “model not found” ou 404 na API — o nome do modelo tem de ser exatamente o que o script usa. muse-glimmer:30b e muse-glimmer apontam para o mesmo pacote hoje, mas um nome com erro de digitação devolve 404 e o script só diz que falhou.
  • Resposta lenta e ollama ps mostrando 100% CPU — o modelo não coube na placa e foi dividido com o processador. Reduza o contexto (ele come memória) ou escolha um modelo menor.
  • Disco cheio antes do fim do download — 18 GB de modelo pedem espaço livre de verdade; o Ollama guarda uma cópia por pacote baixado.
  • Primeira resposta muito demorada — o modelo é lido do disco para a memória na primeira execução. Isso acontece uma vez por sessão, não em toda pergunta.

Referências