LLMs locais: um guia do zero

Quando alguém usa o ChatGPT, o Gemini ou o Claude, o texto digitado sai do computador, viaja pela internet até um centro de dados de uma empresa, é processado lá e a resposta volta. Uma LLM local faz o mesmo trabalho sem essa viagem: o modelo fica guardado no próprio computador e roda nele, mesmo sem internet. Este artigo explica, do zero, o que isso significa, quando vale a pena, quais modelos são os mais conhecidos e qual escolher para cada tarefa — inclusive com o que aprendi usando um modelo local num projeto real, o EduData.

§1O que é uma LLM, sem jargão

LLM é a sigla em inglês para Large Language Model, ou “modelo de linguagem grande”. Na prática, é um programa que aprendeu a continuar textos. Ele foi treinado lendo uma quantidade enorme de texto — livros, sites, código, artigos — e, nesse processo, aprendeu padrões: que palavras costumam vir depois de quais, como uma pergunta costuma ser respondida, como um código costuma ser escrito.

Quando você escreve “A capital do Brasil é”, o modelo calcula quais continuações são mais prováveis e escolhe “Brasília”. Uma conversa inteira com um chatbot é isso repetido muitas vezes: o modelo gera a resposta um pedaço de cada vez. Esses pedaços se chamam tokens — algo entre uma sílaba e uma palavra. Em português, uma página de texto tem algo em torno de 600 a 900 tokens.

Três ideias ajudam a entender todo o resto do artigo:

• Parâmetros. São os “números ajustáveis” dentro do modelo — o que ele aprendeu fica guardado neles. Um modelo de 7B tem 7 bilhões de parâmetros; um de 70B, 70 bilhões. De forma geral, mais parâmetros = mais conhecimento e raciocínio melhor, mas também mais memória e mais lentidão.
• Pesos. É o arquivo que contém esses parâmetros. “Baixar um modelo” é baixar esse arquivo, que pode ter de 1 a mais de 100 GB.
• Contexto. É quanto texto o modelo consegue “ter em mente” de uma vez: a conversa até agora, o documento que você colou, as instruções. É medido em tokens (ex.: 8 mil, 32 mil, 128 mil).

Uma analogia útil: o modelo é como um estudante que leu uma biblioteca inteira e depois a biblioteca foi retirada. Ele lembra de muita coisa, escreve bem e raciocina, mas não consulta fontes — então às vezes lembra errado com toda a confiança. Isso tem nome: alucinação, e vale para modelos locais e da nuvem.

§2Local × nuvem: qual é a diferença

Os assistentes famosos (ChatGPT, Gemini, Claude) rodam na nuvem: em computadores enormes, com placas de vídeo que custam o preço de um carro cada uma. Uma LLM local roda no seu notebook, no seu desktop ou num servidor da sua empresa. Isso só é possível porque várias empresas e laboratórios publicam os pesos dos seus modelos para qualquer pessoa baixar — os chamados modelos abertos (ou open-weight).

Resumindo: a nuvem ganha em qualidade máxima e conveniência; o local ganha em privacidade, custo previsível, funcionamento offline e controle. Não é uma escolha de time — muita gente usa os dois, cada um para o que faz melhor.

§3Para que serve, e quando usar

Uma LLM local faz quase tudo que um chatbot faz: responder perguntas, resumir, traduzir, reescrever, corrigir texto, explicar código, escrever código, extrair informações de documentos e classificar textos. A pergunta certa não é “o que ela faz”, mas quando ela é a melhor escolha.

Vale a pena usar local quando:

• Os dados são sensíveis. Prontuários, contratos, dados de clientes, documentos internos, informações protegidas pela LGPD. Se o texto não pode sair da empresa, a nuvem já está fora.
• O volume é alto e repetitivo. Classificar 50 mil comentários, extrair campos de milhares de PDFs, resumir um arquivo inteiro de atas. Na nuvem, cada chamada custa; no local, o custo é a energia do computador.
• Não há internet confiável — em campo, num avião, numa rede corporativa fechada.
• Você precisa de previsibilidade. Um sistema que depende de um modelo deve dar a mesma resposta amanhã. Com o arquivo do modelo guardado, ele não muda sozinho.
• Você quer aprender. Rodar um modelo local é a melhor forma de entender, na prática, como essas ferramentas funcionam e onde elas falham.

É melhor usar a nuvem quando:

• A tarefa exige o raciocínio mais forte possível: problemas difíceis de matemática, programação complexa em projetos grandes, análises longas e sutis.
• Você precisa de informação atualizada e pesquisa na web integrada.
• O computador disponível é modesto e a tarefa é ocasional — pagar por uso sai mais barato do que comprar hardware.
• Muitas pessoas vão usar ao mesmo tempo e ninguém quer manter um servidor.

§4O que é preciso para rodar

O fator decisivo é memória. O modelo inteiro precisa caber na memória para rodar com velocidade razoável — de preferência na memória da placa de vídeo (a VRAM), que é muito mais rápida; se não couber, ele usa a memória comum (RAM) e o processador, e fica bem mais lento.

Aqui entra o truque que tornou tudo isso possível: a quantização. Originalmente, cada parâmetro ocupa 16 bits. Quantizar é guardá-lo com menos precisão — 8, 5 ou 4 bits —, mais ou menos como salvar uma foto em JPEG em vez de RAW: o arquivo fica bem menor e a diferença quase não se nota. Um modelo de 7B, que teria cerca de 14 GB, cai para uns 4 a 5 GB em 4 bits. Os nomes que você vai ver, como Q4_K_M ou Q8_0, indicam o nível: Q4 é o equilíbrio mais usado; Q8 é quase idêntico ao original, mas o dobro do tamanho.

Uma regra de bolso: em 4 bits, cada 1 bilhão de parâmetros ocupa cerca de 0,6 GB, mais 1 a 2 GB de folga para o contexto da conversa.

Duas observações práticas. Macs com chip Apple (M1 em diante) são surpreendentemente bons nisso, porque a memória é compartilhada entre processador e vídeo — um Mac com 32 GB roda modelos que exigiriam uma placa de vídeo cara num PC. E dá para rodar sem placa de vídeo: no EduData, o modelo de 7B roda só no processador. Funciona, mas cada resposta leva segundos em vez de frações de segundo.

§5As ferramentas: Ollama e companhia

O modelo é só um arquivo. Para conversar com ele, é preciso um programa que o carregue e o execute. Os mais conhecidos:

• Ollama — o mais popular e o mais simples para começar. Instala-se como qualquer programa (Windows, Mac ou Linux) e baixa modelos com um comando. Ele também cria um pequeno servidor no computador (no endereço localhost:11434), o que permite que outros programas usem o modelo — é assim que o EduData conversa com o Qwen. Tem também uma interface de chat própria.
• LM Studio — a opção mais amigável para quem não quer usar terminal. Tem interface gráfica, busca de modelos embutida e mostra se cada modelo cabe no seu computador antes de baixar.
• llama.cpp — o “motor” por trás de muitas dessas ferramentas (o Ollama começou em cima dele). Mais técnico, porém o mais flexível e eficiente. Foi ele que popularizou o formato de arquivo GGUF, o padrão dos modelos quantizados.
• Jan e GPT4All — aplicativos de desktop de código aberto, com foco em privacidade e simplicidade.
• Open WebUI — uma interface parecida com a do ChatGPT, que roda no navegador e se conecta ao Ollama. Boa para usar em família ou numa equipe pequena.
• vLLM — para servidores: atende muitas pessoas ao mesmo tempo com eficiência. É o que empresas usam para colocar um modelo aberto em produção.

Começar com o Ollama leva poucos minutos. Depois de instalado, no terminal:

ollama pull qwen3:8b      # baixa o modelo (~5 GB)
ollama run qwen3:8b       # abre um chat no terminal
ollama list               # mostra os modelos baixados
ollama rm qwen3:8b        # apaga um modelo para liberar espaço

O que vem depois dos dois-pontos é a etiqueta (tag): o tamanho e, às vezes, a quantização. qwen3:8b é o Qwen3 com 8 bilhões de parâmetros; qwen3:4b seria a versão menor. A biblioteca completa fica em ollama.com/library.

§6As famílias de modelos mais conhecidas

Os modelos abertos vêm em famílias: uma empresa lança várias versões de tamanhos diferentes, às vezes com variantes especializadas (para código, para imagens, para raciocínio). As principais:

• Qwen (Alibaba). Provavelmente a família aberta mais completa hoje. Tem de tudo: modelos minúsculos (0,6B) e enormes, versões para código (Qwen-Coder), para imagens (Qwen-VL) e para embeddings. É forte em vários idiomas, incluindo português, e muito bom em seguir formatos estritos, como JSON. O Qwen2.5 consolidou a família; o Qwen3 acrescentou um modo de “pensar antes de responder” que pode ser ligado e desligado. É o que uso no EduData.
• Llama (Meta). A família que popularizou os modelos abertos, em 2023. O Llama 3 (8B e 70B, depois versões 3.1–3.3) virou referência e tem um ecossistema gigante de versões ajustadas pela comunidade. O Llama 4 trouxe modelos maiores, mais pesados para computadores domésticos.
• Gemma (Google). Versões abertas e compactas da tecnologia por trás do Gemini. O Gemma 3 (1B a 27B) entende imagens e se sai muito bem para o tamanho; há ainda variantes feitas para celulares.
• Mistral (Mistral AI, França). Conhecida por modelos eficientes. O Mistral Small (cerca de 24B) é um ótimo meio-termo, e o Mistral Nemo (12B) fez sucesso pela qualidade em idiomas europeus. Tem também o Codestral, para código.
• DeepSeek (China). Ficou famosa com o DeepSeek-R1, um modelo de raciocínio que competiu com os melhores do mundo. O original é grande demais para casa, mas existem versões “destiladas” — modelos menores treinados para imitá-lo — que rodam no Ollama.
• gpt-oss (OpenAI). Os primeiros modelos de pesos abertos da OpenAI desde o GPT-2. A versão de 20B roda num computador com uns 16 GB de memória e é boa em raciocínio e em usar ferramentas.
• Phi (Microsoft). Modelos pequenos treinados com dados muito selecionados. O Phi-4 (14B) e o Phi-4-mini se destacam em raciocínio e matemática para o tamanho, mas são mais fracos em conhecimento geral e em português.

Além desses, há modelos que não conversam, mas são peças essenciais: modelos de embedding (como nomic-embed-text, bge-m3 e qwen3-embedding), que transformam textos em listas de números para buscar por significado, e o Whisper (OpenAI), que transcreve áudio em texto e também roda localmente.

§7Qual é bom para cada coisa

A tabela abaixo é um ponto de partida. A melhor escolha depende sempre do seu computador: comece pelo maior modelo que roda com folga na sua máquina e teste com as suas próprias tarefas.

Alguns termos que aparecem nos nomes dos modelos:

• instruct ou chat: ajustado para conversar e seguir instruções — é quase sempre o que você quer. O modelo base só continua texto e serve para quem vai treiná-lo.
• coder, vl/vision: especializado em código ou em imagens.
• MoE (mixture of experts), como em qwen3:30b-a3b: o modelo tem 30B no total, mas usa só 3B por token. Ocupa a memória de um modelo grande, mas responde na velocidade de um pequeno.
• distill: um modelo menor treinado para imitar um maior.

§8Na prática: o caso EduData

No EduData, um motor de consultas sobre as estatísticas da educação superior do INEP, testei se um modelo local conseguia entender perguntas em português e transformá-las numa consulta estruturada. O modelo nunca calcula nada: ele só devolve um JSON dizendo o que foi perguntado, e o código valida esse JSON e busca os números no banco.

Em 40 perguntas inéditas, o Qwen2.5 7B acertou 27; o Qwen2.5 3B, 21. Nenhum dos dois igualou as regras escritas à mão. Por isso o modelo ficou como opção, com aviso para o usuário conferir a interpretação. Três lições que valem para qualquer projeto:

• Meça antes de confiar. “Parece bom” numa conversa não é o mesmo que acertar 9 de 10 vezes. Monte um pequeno conjunto de perguntas com respostas corretas e teste.
• Tamanho importa mais que velocidade quando o erro custa caro: o 7B errou bem menos que o 3B.
• Deixe o modelo interpretar e o código calcular. LLMs são ótimas com linguagem e ruins com aritmética e fatos exatos. Usá-las só para o que fazem bem — e verificar a saída — é o que torna um sistema confiável.

§9Limitações e cuidados

• Elas inventam. Alucinação acontece em todos os modelos, e com mais frequência nos pequenos. Não use a resposta como fato sem conferir, principalmente números, nomes, leis e citações.
• Conhecimento congelado. O modelo só sabe o que havia nos dados de treino, até uma certa data. Ele não sabe o que aconteceu ontem, a menos que você entregue a informação no contexto.
• Contexto tem custo. Muitos modelos anunciam 128 mil tokens de contexto, mas cada token a mais ocupa memória. No Ollama, o padrão é bem menor, e pode ser preciso aumentá-lo para documentos longos.
• Licenças variam. “Aberto” não quer dizer “sem regras”. Qwen e Mistral costumam usar Apache 2.0 (bem livre); Llama e Gemma têm licenças próprias, com condições. Para uso comercial, leia a licença.
• Baixe de fontes confiáveis. Prefira a biblioteca oficial do Ollama ou as páginas oficiais dos laboratórios no Hugging Face.
• Privacidade depende do conjunto. O modelo é local, mas o aplicativo em volta dele pode não ser. Verifique se a interface que você usa não envia dados para fora.

§10Como começar hoje

• 1. Veja sua memória. No Windows: Gerenciador de Tarefas → Desempenho (RAM e, em “GPU”, a memória dedicada da placa de vídeo).
• 2. Instale o Ollama (ollama.com) ou, se preferir algo totalmente visual, o LM Studio.
• 3. Escolha pelo tamanho: 8 GB de RAM → qwen3:4b ou gemma3:4b; 16 GB → qwen3:8b; placa de vídeo de 12 GB ou mais → qwen3:14b ou gemma3:12b.
• 4. Teste com tarefas reais suas — um e-mail para reescrever, um texto para resumir, um código para explicar — e compare com um serviço de nuvem.
• 5. Troque e compare. Baixar outro modelo é um comando. A melhor forma de escolher é testar dois ou três com as mesmas perguntas.

§11Conclusões

• Uma LLM local é um modelo de linguagem que roda no seu computador: os dados não saem dele e funciona sem internet.
• Ela vale a pena quando há dados sensíveis, volume alto, falta de internet ou necessidade de controle; a nuvem continua melhor para o raciocínio mais difícil e para quem quer só abrir e usar.
• O que decide o que roda é a memória; a quantização (Q4) faz um modelo de 7–8B caber em uns 5 GB.
• Ollama é a porta de entrada mais simples; Qwen, Llama, Gemma, Mistral, DeepSeek, gpt-oss e Phi são as famílias principais, e o Qwen é a escolha mais versátil hoje, inclusive em português.
• Nenhum modelo dispensa verificação: teste com as suas tarefas, meça o acerto e deixe para o código o que precisa ser exato.

Referências: biblioteca do Ollama; llama.cpp; LM Studio; Qwen no Hugging Face. Resultados do EduData: decisão D17 em _arquitetura/02_decisoes.md do projeto. Memória e tamanhos são aproximações para quantização de 4 bits.