64 gigabytes de memória procuram trabalho. De preferência, intelectual.

Basta ler alguns guias sobre como rodar inteligência artificial em casa para logo ficar com a impressão de que o primeiro passo é comprar uma placa de vídeo. Depois você descobre que seria melhor comprar outra. Depois, que ela vai exigir uma fonte nova. A essa altura, dá vontade de fechar o navegador: afinal, você só queria experimentar conversar com um modelo, não remontar o computador e rever o orçamento da família.

E, durante todo esse tempo, há uma máquina perfeitamente boa embaixo da mesa.

Talvez ela já tenha alguns anos. Talvez seja uma estação de trabalho antiga, comprada na época para tarefas sérias. Tem gente que até guardou um servidor: dois processadores, muita memória, um gabinete de metal que impõe respeito. Antes, ele mantinha o escritório funcionando. Hoje, mantém principalmente as próprias ventoinhas funcionando.

Dá pena, não dá? O computador funciona, tem 32, 64 ou até 128 gigabytes de memória. Será que, sem uma placa de vídeo cara, tudo isso é inútil para um modelo de linguagem?

Não, não é inútil. E é aqui que a história começa a ficar interessante.

É possível rodar modelos de linguagem no processador, usando a memória RAM comum. Existem programas para isso, entre eles o llama.cpp, que oferecem suporte a cálculos na CPU. O modelo escolhido precisa ser compatível com a versão do programa utilizada, mas essa possibilidade já deixou de ser apenas uma demonstração bonita faz tempo. Documentação do llama.cpp

Às vezes dizemos “rodar o modelo na RAM”, e é uma forma prática de resumir. Só que a memória não faz cálculos sozinha. Ela guarda os pesos do modelo e os dados de trabalho, enquanto o processador executa as operações. É mais ou menos como uma despensa e um cozinheiro: uma despensa espaçosa ajuda, mas o jantar não aparece só porque ela está ali.

Aliás, não é preciso manter uma conexão permanente com a internet para conversar com um modelo assim. Depois que os arquivos são baixados, ele pode funcionar localmente, desde que o próprio aplicativo não use a nuvem ou ferramentas externas. A internet já ajudou a entregar alguns gigabytes e agora pode muito bem descansar.

Tudo isso parece animador, mas é melhor ver o que aconteceu com quem realmente tentou.

Encontramos alguns exemplos publicados. Nós mesmos não repetimos essas medições, então os resultados a seguir são os dos autores, com seus equipamentos, programas e configurações.

O segundo exemplo dessa seleção me chama especialmente a atenção. Um processador de 2013, DDR3, uma estação de trabalho antiga: tudo aquilo que é fácil descartar quando a conversa é sobre IA moderna. E alguém simplesmente foi lá e tentou.

O terceiro exemplo, é claro, já está em outra categoria de peso. Só a memória RAM dele ocupa mais espaço na minha imaginação do que toda a ideia original deste artigo. Mas não é preciso começar com um servidor desses. Afinal, ninguém precisa alugar o oceano Atlântico para aprender a nadar.

E mais uma coisa: essas linhas não devem ser lidas como uma competição entre processadores. Os modelos são diferentes, os programas também, assim como as condições de medição. Seria ousado demais declarar o velho Xeon vencedor do Ryzen só porque, em uma das linhas, o número ficou maior.

Mas dá para perceber outra coisa: a falta de uma placa de vídeo moderna ainda não significa que o experimento não vai acontecer. Até a DDR3, pelo visto, não vira abóbora no dia em que a DDR5 é lançada.

Agora vamos voltar a uma situação mais familiar. Digamos que você tenha um computador com 64 gigabytes de RAM. Você abre um catálogo de modelos, encontra um arquivo de cerca de 60 gigabytes e pensa: pronto, quase sob medida. Vai até sobrar um pouco.

Aqui eu tiraria um pouco o pé do acelerador.

Afinal, o sistema operacional não vai se mudar para outro lugar. O navegador também fica, junto com todas as abas que você com certeza vai ler, só não hoje. E o programa que roda o modelo ainda vai precisar de espaço para trabalhar.

Além dos pesos, os buffers de trabalho e os dados da conversa em processamento ocupam memória. Em muitos modelos, boa parte desses dados corresponde ao cache KV: resultados intermediários armazenados para evitar repetir parte dos cálculos sobre o texto já lido. O tamanho dele depende da arquitetura do modelo, do tamanho do contexto e das configurações. Explicação do cache KV

Por isso, o tamanho do arquivo na página de download é uma informação útil, mas não é a resposta definitiva para “de quanta memória vou precisar?”.

Naquele mesmo experimento com o HP Z420, o autor apresenta uma comparação esclarecedora: o arquivo do modelo tem aproximadamente 29,3 GB, enquanto a memória do processo, medida como RSS, fica em torno de 34,8 GB. E isso ainda não é o consumo do computador inteiro. Não convém transformar a diferença entre esses números em um acréscimo universal, mas o princípio fica bem claro. Medições do autor

É claro que dá vontade de ter uma regra simples: “deixe tantos gigabytes livres e tudo vai dar certo”. Seria conveniente. Mas uma conversa curta com um modelo pequeno e um documento grande processado por um modelo completamente diferente exigem margens diferentes.

Podemos pelo menos começar com um plano fácil de entender. Vamos usar um orçamento hipotético de 64 GiB, nas unidades da nossa calculadora, e distribuí-lo assim:

Isso é um exemplo, não uma instrução para todos os computadores. Oito gigabytes para os dados de trabalho podem ser uma folga generosa em um caso e insuficientes em outro. É melhor observar o consumo do seu próprio sistema e estimar o cache e as demais necessidades para o modelo e a tarefa escolhidos.

Repare na última linha. Sobrou espaço livre, e está tudo bem. Ninguém ganha medalha por ocupar cem por cento da RAM.

Se a memória começar a faltar, o sistema pode transferir parte dos dados para o disco. Às vezes isso permite continuar o trabalho, mas a troca constante com o disco pode transformar a conversa em uma correspondência muito lenta. O processo também pode parar por falta de memória. Um SSD é útil na hora de carregar o modelo, mas não é uma boa ideia contar com ele como substituto equivalente à RAM.

Certo, entendemos a questão da capacidade. Suponhamos que o modelo tenha cabido com folga. Por que, então, ele ainda pode responder devagar?

É aqui que o processador volta à conversa, depois de termos passado boa parte dela contando gigabytes.

A CPU precisa executar muitas operações e buscar na memória os dados necessários. Importam a arquitetura, as instruções suportadas, as frequências, o cache, o número de núcleos e o quanto o programa consegue aproveitar tudo isso.

Com os núcleos, é especialmente fácil chegar a uma conclusão apressada. Oito é bom, dezesseis é melhor, trinta e dois quer dizer mais duas vezes a velocidade?

Às vezes, núcleos extras realmente ajudam. Mas, se os cálculos esbarram no limite de transferência de dados da memória, parte das threads vai ficar esperando. E um número excessivo de threads pode até piorar o resultado: os desenvolvedores do llama.cpp chamam atenção especificamente para isso. Recomendações dos desenvolvedores

Trinta e dois cozinheiros em volta de uma única tábua de cortar formam uma equipe impressionante. Só não quer dizer que o almoço vai ficar pronto mais cedo.

Com a memória, a história é parecida. Estamos acostumados a perguntar quanto está instalado, mas para o modelo também importa com que velocidade o processador consegue obter os dados dela.

Por isso, DDR3, DDR4 ou DDR5 são apenas parte da descrição. A velocidade real da memória e o número de canais utilizados também importam. E quatro pentes não significam necessariamente quatro canais: tudo depende da plataforma e de como os módulos foram instalados. A largura de banda está relacionada à taxa de transferência, à largura da interface e à quantidade de canais. Explicação da Intel

É por isso que uma plataforma de servidor antiga às vezes se mostra mais interessante do que o ano de lançamento faz supor. Ela pode ter vantagens próprias na organização da memória. Também pode ter desvantagens que só aparecem ao rodar um programa específico.

Com dois processadores, também vale conhecer um pouco melhor a situação. Em geral, cada um tem sua própria memória local, e acessar a memória do processador vizinho custa mais. Isso se chama NUMA. A utilidade da segunda CPU depende de como o programa distribui os cálculos e os dados. Documentação da Intel

Chegou um segundo cozinheiro à nossa cozinha, com sua própria despensa. Boa notícia. Só que, às vezes, ele precisa atravessar o quintal para buscar os ingredientes.

Não é preciso entender todos esses detalhes antes de rodar o primeiro modelo. Mas vale lembrar deles quando os resultados de repente não combinam com a bela conta de “duas vezes mais processadores, duas vezes mais rápido”.

Há ainda outra coisa que é fácil confundir com um defeito.

Você faz uma pergunta, o programa fica em silêncio. As ventoinhas continuam funcionando. Na tela, nada por enquanto.

Pode ser que o modelo ainda esteja lendo o seu pedido. Antes de gerar a resposta, ele precisa processar o texto de entrada, e uma pergunta curta não dá o mesmo trabalho que um contrato de cinquenta páginas anexado.

Volte por um instante à primeira linha da nossa tabela. A geração acontecia a 7,2 tokens por segundo, mas o primeiro token levou quase cem segundos para aparecer. Esses números não se contradizem: eles descrevem etapas diferentes.

Por isso, na hora de comparar, vale olhar tanto o tempo até o início da resposta quanto a velocidade de geração depois disso. No llama-bench, o processamento do texto de entrada e a geração são medidos separadamente. Descrição das medições

Uma resposta longa, naturalmente, também vai levar tempo. Se o modelo oferece um modo de raciocínio, ele pode gerar tokens adicionais antes da resposta final. Às vezes isso é útil. Às vezes você só precisa encontrar a data de entrega em um e-mail, e o modelo já está abrindo um simpósio filosófico sobre a natureza do tempo.

Então, por onde começar para não passar a primeira noite inteira só esperando?

Eu escolheria um modelo instruct pequeno, em um formato quantizado compatível, e daria a ele uma tarefa curta e conhecida. Entre as opções para explorar estão Qwen3.5-4B e Phi-4-mini, com 3,8 bilhões de parâmetros. Depois, você pode experimentar a faixa de 7–8B e ver se um modelo maior traz alguma vantagem para o seu trabalho. Todas essas opções estão disponíveis nos catálogos dos programas que rodam modelos. Qwen3.5-4B, Phi-4-mini, Qwen3-8B

Para um primeiro teste, você pode considerar Q4_K_M, se esse tipo de arquivo for compatível, e depois comparar com outro nível de precisão. A quantização reduz o tamanho dos pesos, mas pode afetar as respostas. O quanto isso fica perceptível e importa depende do modelo e da tarefa. Documentação sobre quantização

E não precisa ter vergonha de usar um modelo pequeno em um computador com muita memória. O computador não vai ficar ofendido. Se o modelo faz bem o trabalho necessário, os gigabytes livres podem continuar livres tranquilamente.

Os modelos MoE também são interessantes para quem tem uma máquina com bastante memória. Ao processar cada token, eles usam parte dos especialistas, o que permite reduzir a carga de cálculo em comparação com um modelo denso de tamanho total semelhante. Mas o conjunto completo de pesos ainda precisa ser armazenado.

Por exemplo, o Qwen3.6-35B-A3B declara cerca de 35 bilhões de parâmetros no total e 3 bilhões de parâmetros ativos. Em termos de memória, ele não é um modelo pequeno de 3B; em termos de carga de cálculo, também não pode ser automaticamente equiparado a um modelo denso comum de 35B. Ficha do modelo

Os especialistas se revezam no trabalho, mas ninguém se mudou do apartamento.

Talvez a coisa mais útil no começo seja pensar em algumas tarefas cujo resultado você consiga avaliar. Pedir um resumo de um documento curto. Extrair nomes, datas e valores de um e-mail. Fazer uma pergunta para a qual você já sabe a resposta certa.

Comece com um contexto pequeno, um pedido por vez e um limite para o tamanho da resposta. Veja quanto tempo você teve de esperar, quanta memória sobrou e, acima de tudo, se o resultado ajudou.

Depois, mude uma coisa de cada vez: o modelo, a precisão dos pesos, o tamanho do contexto ou o número de threads. Assim, aos poucos, fica claro o que realmente influencia o seu sistema. Se você mudar tudo de uma vez, o experimento vai parecer uma mudança de móveis em família: ficou diferente, mas ninguém mais lembra por que começou.

Rodar modelos na CPU tem limitações bem reais. Documentos grandes e raciocínios longos exigem paciência. Atender muitos usuários ao mesmo tempo é uma carga diferente de uma pessoa sozinha no computador de casa. Um servidor antigo pode consumir uma quantidade considerável de energia e anunciar isso com o barulho de um avião decolando.

Mas, para trabalhar com textos sem pressa, extrair dados, fazer pequenas automações e conhecer a IA local, a máquina que você já tem merece pelo menos uma tentativa.

É exatamente essa a ideia da nossa calculadora: ajudar a estimar a memória e escolher opções para começar. Ela não emite certificado de velocidade e não sabe em qual segundo de espera você começa a tamborilar os dedos na mesa.

Talvez, depois de algumas noites, você fique com um modelo pequeno que faz bem um trabalho específico. Talvez encontre um MoE adequado. Ou talvez conclua que, para as suas tarefas, uma placa de vídeo é mesmo necessária. Isso também acontece, e não torna o experimento um fracasso.

Pelo menos agora você vai saber exatamente por qual melhoria está prestes a pagar.

E, se encontrar um modelo adequado, o velho computador vai ganhar um trabalho novo. Eu o imagino sendo aposentado alguns anos atrás, levado para casa, colocado embaixo da mesa — e agora ajudando a analisar documentos.

Para um servidor, é uma boa virada na carreira.

Até então, a descrição do cargo só dizia: “Fazer barulho”.