O objetivo deste guia é dar alguns fundamentos para aqueles que desejam trilhar os caminhos da IA local. Repare que eu coloquei a data no título, e isso tem um motivo: as coisas andam tão rápido nesse campo que, hoje, podemos fazer coisas que eram impossíveis há três meses. Logo, o mesmo deve ocorrer nos próximos três meses. Para efeitos didáticos, a primeira parte do artigo vai explorar todos os conceitos para que você tenha uma noção clara do que vamos fazer e, a partir daí, vai passar para considerações mais práticas de como rodar uma IA no seu computador. Estou assumindo que você já tenha tido algum contato com uma IA, como o ChatGPT ou o Grok.

O que é a IA generativa?

Primeiro, o que é a inteligência artificial, ou melhor ainda, o que são os LLMs (Large Language Models, ou Grandes Modelos de Linguagem)? Um LLM é um tipo de inteligência artificial chamada generativa. A ideia é que o modelo produza respostas em linguagem natural, ou seja, a que falamos no nosso dia-a-dia, e que essas respostas sejam a melhor combinação possível de palavras que correspondam à pergunta que foi feita, que chamamos de prompt.

Por exemplo, se você faz uma pergunta sobre as cores dos periquitos, a máquina gera inicialmente alguns vetores aleatórios que são confrontados com o prompt. Conforme esses vetores vão caindo dentro de uma determinada probabilidade, eles são escolhidos para compor um texto. E como esses vetores são escolhidos? Você passa o vetor inicial por uma série de operações matemáticas, e avalia o resultado que sai do outro lado. Essas operações matemáticas possuem uma forma definida, que é o modelo. O modelo nada mais é do que as perguntas feitas ao contrário. Se eu sei uma pergunta e uma respostas, eu posso moldar o modelo para que ele faça o caminho pergunta-reposta adequadamente. Este processo é chamado de treinamento.

Isso não é uma operação matemática arbitrária, existe método, e o mais comum é a descida de gradiente (do inglês gradient descent). O truque todo é relativamente simples, mas usa muita força bruta. Você parte do maior conjunto possível de perguntas e respostas e usa um conjunto de matrizes com bilhões de parâmetros, os pesos, para codificar todo o conhecimento possível como uma distribuição de probabilidades. Esses modelos e o volume de dados são tão grandes que são precisos supercomputadores para treinar um modelo. Um modelo de ponta, como o OpenAI GPT 5.5, Anthropic Opus 4.6, Grok 4.3, etc., precisam de supercomputadores não somente para serem treinados, mas também para gerarem respostas. Esse processo de colocar a pergunta de um lado, processar com o modelo e obter a resposta é chamado de inferência. Até pouco tempo atrás, somente os modelos de ponta tinham performance, no sentido de acertar o suficiente as respostas, que eram usáveis. Mas isso mudou.

IA generativa local

Esse cenário mudou em janeiro de 2024 com a chegada do DeepSeek. Ele inseriu uma série de inovações que permitiram comprimir o conhecimento em um modelo menor. Os modelos passaram de centenas de bilhões de parâmetros, ou até mesmo mais de um trilhão, para alguns bilhões. Hoje, existem modelos que são bastante usáveis com apenas 3 bilhões de parâmetros, como o Mistral Ministral 3 3B, o Nvidia Nemotron 3 Nano 4B e o Google Gemma 4 E2B. Porém, essa tecnologia é só a ponta dos desdobramentos dos últimos anos. Estes modelos são chamados de pesos abertos (do inglês open weights), porque eles funcionam da mesma forma que o software livre, eles são publicados totalmente abertos e podem ser modificados, distribuídos e até comercializados sem nenhum custo. Entretanto, sempre verifique a licença do modelo que você pretende usar, especialmente se for comercializar um serviço com ele.

Uma outra tecnologia também foi crucial nesse desenvolvimento, que é a quantização. Inicialmente, cada peso é um número que usa entre 32 e 64 bits. A quantização reduz a precisão desses pesos para 2, 4 ou 8 bits. Quanto mais agressiva a quantização, menor a qualidade do modelo, evidentemente, Porém, incrivelmente, a quantização mostrou que seu efeito na qualidade era muito menor que o esperado, assim modelos de 4 bits possuem, muitas vezes, 80% a 90% da taxa de acertos do modelo original com precisão completa. Para nossos propósitos, 4 bits é a quantia ideal que faz um equilíbrio muito bom entre tamanho e performance. Você vai encontrar a quantização nos nomes do modelos com sufixos como Q4_K_M ou Q8_0.

Como funciona

Para usar um modelo de IA, primeiro nós precisamos de um servidor, que é quem vai receber o prompt, processá-lo com um determinado modelo e devolver a resposta. Uma coisa muito importante a se notar é que o chat com o LLM não possui uma única entrada e uma única saída. Ou seja, normalmente se faz um bate-papo com idas e voltas com o modelo. Você pede para ele gerar um script em Python, por exemplo, você roda o script, repassa eventuais erros ou modificações, ele te respondem com uma nova versão e assim por diante.

Como o modelo faz para saber do que vocês estão falando toda vez que você responde? O modelo mesmo não sabe. Acontece que, junto com a sua nova pergunta, é passado para o servidor todo o histórico anterior da conversa, que chamamos de contexto. Quando o modelo é usado para gerar uma nova resposta, ele recebe todo o contexto até a nova pergunta e, baseado em todo o desenvolvimento, é que ele fornece a melhor resposta possível.

Esse é um detalhe importante, toda resposta que um LLM dá é a melhor possível para aquele prompt com aquele modelo, mas a melhor possível não quer dizer correta, só quer dizer que, dentro das possibilidades do modelo, aquela combinação de palavras é a mais provável. O quanto essa resposta mais provável para o modelo se aproxima da resposta real depende, principalmente, de como o modelo foi treinado, de quantos parâmetros ele tem, e da qualidade do prompt. Ou seja, é preciso usar o modelo adequado e fazer as perguntas certas. Isso vale para todos os modelos, dos mais básicos locais até os mais sofisticados na nuvem.

Voltando ao contexto, é muito importante notar que o tamanho da conversa depende do tamanho do contexto. Quanto maior o contexto, evidentemente, mais respostas o modelos vai conseguir gerar lembrando desde a pergunta inicial. Portanto, para pesquisas mais profundas, por exemplo, é muito importante ter um contexto grande. Mas como é medido o contexto? É bem simples. Toda palavra pode ser quebrada em pedaços. Por exemplo, podemos ter o radical constr– e podemos ligá-lo a sufixos como -ir ou -irem. Cada pedaço de uma palavra, as pontuações, números e espaços são representados por tokens.

Portanto, o contexto é medido pelo número de tokens. Para você ter uma ideia, um contexto de 100 mil tokens equivale a um livro, mais ou menos. Isso pode até parecer bastante para uma pesquisa, mas para desenvolvimento de software, por exemplo, é relativamente pouco. Vou voltar nesse assunto, o vibe coding, num outro artigo. Por enquanto basta saber que é bom ter um contexto relativamente grande, levando-se em conta que a velocidade do processamento e qualidade das respostas cai conforme o contexto cresce.

As ferramentas

Muito bem, vamos então ao que interessa. Para rodar uma IA local você vai precisar de alguns ingredientes. O mais importante é um computador potente o suficiente. Felizmente, dados os últimos desenvolvimentos, os requisitos de hardware caíram tanto que já dá até pra usar no celular. Para Android, você pode baixar o Google AI Edge Gallery. Ele vai escolher o melhor modelo para o seu celular, se for possível, e você vai ter um chat bastante funcional disponível, apesar de ser muito simples e não ter nem busca, por exemplo.

O Hardware

Para você ter uma ideia clara do que é preciso para fazer isso tudo funcionar, é preciso entender como o hardware funciona. Um computador moderno é uma máquina que opera a partir da chamada Arquitetura de Von Neumman. De modo concreto, estamos falando de computadores baseados em Intel e AMD, a famosa x86_64. Nela, temos uma unidade central de processamento, a CPU. Os dados ficam numa unidade de armazenamento, comumente um SSD (do inglês solid state drive), mas os dados que a CPU usa ficam na memória RAM (do inglês random access memory). Assim, temos esses três componentes principais: CPU, SSD e RAM. Quando você executa um programa, a CPU vai no SSD, o pega e o coloca na RAM. A partir daí ele faz todo o processamento nos dados que estão na RAM. Quando você salva uma planilha do Excel, por exemplo, a CPU pega os dados da RAM e coloca no SSD. Quando você abre o arquivo, ele faz o caminho contrário. Na Arquitetura de von Neumman, durante a execução, os dados do usuário ficam na mesma memória que os próprios programas que estão sendo executados.

Você já deve estar se perguntando, porque a CPU simplesmente não faz as operações diretamente no SSD? A resposta é que a memória RAM é muito mais rápida do que o SSD. Uma memória DDR5 de 5600MHz consegue transferir até 89,6 Gb/s, enquanto um SSD de ponta vai conseguir, no máximo 5 a 6 Gb/s, ou seja, 10 vezes menos na melhor das hipóteses. Além disso o SSD e a RAM têm naturezas diferentes: enquanto a RAM perde os dados quando ela é desligada, o SSD não. Então existe esse compromisso entre armazenar os dados e ter velocidade, e a hierarquia de memória é uma resposta para esse problema. O importante aqui é saber que todo programa é carregado do SSD para a RAM para ser processado.

Existe ainda um outro componente que é chave na nossa história, que a placa de vídeo, também conhecida por GPU (do inglês Graphics Processing Unit), Elas foram concebidas para calcular as cores de cada pixel que será mostrado na tela, portanto, são processadores que permitem executar muitas operações simples de uma vez só, que chamamos de execução em paralelo. A CPU, ao contrário, é feita para executar poucas operações complexas, uma de cada vez, de modo a ter a maior flexibilidade possível. Ao invés de serem rivais, GPU e CPU são complementares, cada um faz um trabalho diferente.

Porém, a GPU utiliza uma arquitetura um pouco diferente, já que ela não tem armazenamento permanente, mas possui a sua própria RAM, chamada de VRAM (do inglês Video Random Access Memory). A VRAM exerce, para a GPU, o mesmo papel que a RAM exerce para a CPU, ou seja, ela mantém os dados que a GPU realiza as operações requeridas. Como as GPUs são excelentes para realizar as mesmas operações em paralelo, elas são a escolha natural para se fazer operações matriciais e, por isso, são usadas para rodar os modelos de IA.

A partir daqui, já dá pra ter uma ideia do que vai ser preciso de hardware para rodar uma IA. Vamos explorar primeiro o caso de uma IA que será executada somente pela GPU. Primeiro, precisamos colocar o modelo inteiro dentro da VRAM e, depois disso, precisamos reservar espaço para o contexto. Assim, por exemplo, o Devstral 2 24B precisa de pelo menos 14.3Gb de VRAM somente para o modelo, mais um 8Gb para um contexto decente. Neste caso, seria preciso cerca de 22Gb para rodar o modelo todo em uma única GPU. Via de regra, você sempre precisa de aproximadamente 1,5 vezes o tamanho do modelo para rodar exclusivamente na GPU.

Você deve estar fazendo a pergunta correta nesse momento: 22Gb é bastante coisa, não tem como usar a memória do sistema para isso? A resposta é sim. Você pode, por exemplo, dividir o modelo entre GPU e CPU. Esse método é chamado de offloading. Qual a pegadinha então? A CPU é cerca de 10 vezes mais lenta que a GPU na inferência. Quando você divide o modelo, as partes que ficaram na CPU serão processadas nela, criando um gargalo. É possível conviver com isso? Algumas vezes sim, mas veremos mais adiante que existem tecnologias recentes que amenizam muito o problema.

Aqui temos que mencionar também a nova arquitetura do Apple Silicon, lançado a partir dos chips M1. Ela não é necessariamente uma novidade, já que foi herdada dos chips móveis baseados em ARM. A arquitetura Apple é basicamente a mesma de um celular, mas com poder de processamento de um desktop. A diferença principal para um PC baseado na arquitetura da Intel x86_64 é que a RAM fica dentro do mesmo encapsulamento do processador, o que aumenta muito não só a eficiência energética, mas também melhora a relação sinal ruído e resolve problemas de propagação de ondas eletromagnéticas por condutores muito longos (num PC Intel, o sinal tem que caminhar por vários centímetros ida e volta da CPU até os pentes de memória. No Apple Silicon, esse caminho cai para alguns milímetros).

Na prática isso quer dizer que esquenta menos e o sinal é passado com maior clareza, o que permitiu à Apple obter taxas de transferência entre CPU e RAM bem maiores do que nos x86_64. Além disso, não existe mais a separação entre RAM e VRAM, assim todos os programas ficam num único pool, ou piscinão de dados. O compromisso aqui é que os chips da Apple são muito bons tanto em processamento serial quanto paralelo, mas são um meio termo. Quando é preciso de força bruta mesmo, A combinação Intel/AMD com Nvidia ainda é melhor, apesar de consumir mais energia. Quem possui um Macbook a partir do chip M1 com pelo menos 16 Gb de RAM tem um excelente sistema para IA local.

Existem também alguns produtos com arquitetura semelhante à da Apple, como o AMD Ryzen AI e o Nvidia DGX. Eles são um tópico muito interessante de mini computadores especializados em IA local. Também é preciso notar que a Nvidia não é a única fabricante de GPUs. Também existem as da AMD e da Intel, mas elas correm por fora, ainda.

Configurações

Acho que agora podemos entrar numa discussão mais completa. Aqui no meu laboratório já testei várias configurações. Elas vão desde um i5 de 4a geração 4670K com 10 Gb de RAM e uma Nvidia RTX 3050 de 6 Gb até um Ryzen 5950x com 128 Gb de RAM com uma RTX 4090 de 24 Gb e uma RTX 5060ti de 16 Gb. Porém, o hardware mais interessante que tenho aqui, no contexto deste artigo, é um laptop Asus TUF F15 com um i5 de 11a geração 11260H com 32 Gb de RAM e uma RTX de 3050 de 4 Gb. Esse notebook é interessante porque é uma combinação bastante comum, não é absurdamente cara e, como vou mostrar daqui a pouco, ele faz coisas realmente impressionantes. Porém, uma das melhores arquiteturas para IA local é o Apple Silicon, disponível nos Macs a partir do chip M1. Qualquer um com pelo menos 16 Gb de RAM é suficiente. Porém, vou focar na plataforma x86_64, que é o que tenho aqui.

Para executar a IA, como vimos, precisamos de um servidor. Para os novatos, eu recomendo o LM Studio (lmstudio.ai). Para quem quiser ir mais a fundo, recomendo o Llama.cpp, especificamente o fork do The Tom (https://github.com/TheTom/llama-cpp-turboquant), que já retorno nele. Existem outros, como o Ollama, mas prefiro os dois primeiros. Com o LM Studio, tudo é muito intuitivo, você pode inclusive baixar os modelos dentro dele próprio. Eu vou deixar tutoriais específicos para outros artigos, já que esse aqui está ficando muito longo. Porém vou fazer um compilado do que consegui com cada uma dessas configurações.

i5 de 4a geração, 10Gb de RAM e uma RTX 3050 de 6Gb

O maior limitante dessa máquina, por incrível que pareça, é o Windows. Com ela eu consegui cerca de 40 tokens/segundo com o Gemma 4 E4B rodando 100% na GPU e com um contexto de cerca de 60 mil tokens rodando no LM Studio. Muito usável, esse modelo é bastante eficiente e gera respostas muito boas. Um teste muito surpreendente foi que eu pedi para ele gerar um clone da calculadora do Windows em Python com Tkinter, e ele acertou de primeira, sem errors.

Contudo, o grande problema foi o Windows. Como o gerenciamento de memória dele é horrendo, mesmo carregando tudo na GPU, ele ainda usava uma boa parte da RAM do sistema. Como esse PC tem somente 8Gb, isso acaba atrapalhando a usabilidade, apesar de ser perfeitamente possível usar o modelo, navegar na internet e editar planilhas ao mesmo tempo. Na verdade, nada mal para uma máquina já bem antiga e que eu montei para ser a rainha do custo-benefício.

Já modelos mais pesados, como o Qwen 3.5 9B até rodaram, mas como tive que fazer um offload parcial para a CPU, a velocidade sofreu muito, ficando na casa dos 8 tokens por segundo. Até é usável, mas fica muito sofrido e ele consome praticamente toda a RAM.

Aqui cabe uma importante ressalva. A velocidade de inferência depende muito da largura de banda de memória. Neste caso, além de ser uma DDR3, um padrão antigo, ainda está configurado com dois pentes diferentes, um de 8 Gb e um de 2 Gb. Como disse, essa máquina era pra ser a rainha do custo-benefício, então eu catei coisas que tinha sobrando aqui. Uma coisa que deve melhorar muito a performance é adicionar outro pente idêntico de 8 Gb. Além de expandir a capacidade, dois pentes idênticos trabalham no chamado modo dual-channel, efetivamente dobrando a largura de banda.

Porém, como veremos, o upgrade mesmo seria rodar Linux nela. Porém, pelo perfil das aplicações, ela precisa rodar Windows.

Já outros modelos maiores não rodaram.

Laptop Asus TUF F15, i5 de 11a geração, 32 Gb de RAM, RTX 3050 de 4 Gb

Esse aqui realmente eu não esperava muita coisa por causa dos 4 Gb de VRAM. Mal cabe o Gemma E2B que, convenhamos, é simples demais. Porém, nos últimos meses surgiu uma nova tecnologia da Google, o TurboQuant. O que ela faz é comprimir o contexto sem perda de qualidade, assim você consegue colocar um monte de contexto em pouca VRAM. Além disso, nos últimos meses surgiram os chamados modelos MoE (do inglês mixture of experts). Esses ao invés de ativar todos os pesos de uma vez como nos modelos convencionais, chamados densos, separa em sub amostras menores, com 3 ou 4 bilhões de parâmetros.

Os dois mas conhecidos são o Google Gemma 4 26B A4B e o Qwen 3.5 35B A3B. Eles permitem um truque muito inteligente: você pode carregar somente algumas partes, as mais pesadas, na GPU e colocar as camadas menores, os experts, na CPU. Assim, com pouca VRAM você consegue uma performance excelente mesmo num hardware modesto. E mais um truque importante é que no Linux é possível usar um recurso chamado mmap (do inglês memory map). Ao invés de carregar o modelo todo para a RAM, ele mapeia partes menos usadas do modelo diretamente no SSD. Assim, com pouco impacto na velocidade, você não precisa nem de muita RAM e nem de muita VRAM. Neste exato momento em que escrevo, estou com o Gemma 4 26 A4B rodando, e ele está ocupando pouco mais de 3,0 Gb de RAM 2,9 Gb de VRAM e gerando cerca de 20 tokens por segundo! Essa taxa já é suficiente para gerar texto mais rápido do que eu consigo ler, ou seja, é mais do que adequado. Esse modelo é tão bom, que eu simplesmente parei de usar o Grok e o Claude. Recorro a esses só quando o Gemma não dá conta, o que é extremamente raro.

O truque todo aqui consiste em usar esses modelos MoE com o Llama.cpp do The Tom compilado na minha máquina com Linux e com os parâmetros corretos ativados. O i5 de 4a geração só não fez o mesmo porque o mmap do Llama.cpp não funciona no Windows, e o LM Studio não suporta o TurboQuant.

Ryzen 5950x, 128 Gb de RAM, RTX 4090 de 24 Gb e RTX 5060ti de 16 Gb

Já essa máquina é a que eu uso para desenvolver software. A vantagem é que eu consigo usar modelos densos especializados com bastante contexto, já que posso dividir um modelo em duas GPUs. Ou posso rodar um modelo em cada GPU com velocidade máxima. Ou ainda, posso rodar modelos enormes (para os padrões da IA local!), com mais de 70 bilhões de parâmetros fazendo offloading para a CPU.

Para que você tenha uma ideia do que uma GPU potente é capaz, consigo carregar o Gemma 4 26B inteiro na 4090. Dependendo do prompt, consigo algo entre 100 e 200 tokens por segundo! Só que essa GPU sozinha puxa cerca de 480 watts!

Porém, o que realmente uso aqui é o Devstral Small 2 24B, Q8_0 dividido entre as duas GPUs e com um contexto de 256 mil tokens, que é o ideal para desenvolvimento de software. Todo protótipo de software do meu laboratório já é feito com vibe coding nessa máquina, portanto, para a minha empresa, a IA local já é uma realidade cotidiana. E isso que eu ainda nem explorei os agentes como o OpenClaw.

Outro uso desta máquina é a criação de imagens e vídeos também com modelos locais, usando o ComfyUI.

Conclusão

Espero ter dado os principais fundamentos da IA local e uma breve ideia de como fazer. Com esses conceitos e um pouco de ajuda de uma IA na nuvem, como o ChatGPT e o Grok, são suficientes para você começar a brincar se tiver um hardware disponível e, como mostrei, com a combinação correta de ferramentas e modelos dá pra fazer muita coisa mesmo com uma máquina relativamente modesta.

Este artigo foi revisado no meu Asus TUF rodando o Gemma 4 26B A4B, mas foi escrito por mim mesmo.