Como rodar um LLM local: guia do zero com Ollama

Dá pra rodar um modelo de linguagem decente no seu notebook. Sem mandar um byte pra nuvem, sem chave de API, sem fatura no fim do mês. O modelo baixa, sobe na sua máquina e responde ali, no localhost.

A pergunta não é mais "dá pra rodar um LLM local?". Dá. A pergunta é: quando isso faz sentido, o que roda de verdade no seu hardware, e como subir sem sofrer com driver, quantização e VRAM estourando.

Neste guia você vai instalar o Ollama, rodar seu primeiro modelo local em dois comandos, entender a conta de hardware (quanto de RAM/VRAM cada tamanho de modelo pede) e saber decidir, caso a caso, quando o local ganha da API e quando não.

TL;DR

O que é: rodar um LLM local é executar o modelo na sua própria máquina, sem chamar uma API externa. O texto nunca sai do seu hardware.
Stack: Ollama (runner + servidor), modelos abertos tipo Llama, Qwen, Gemma, gpt-oss, DeepSeek.
Custo/Acesso: gratuito e open-source. O custo é o hardware que você já tem (ou vai comprar).
Mínimo: 8 GB de RAM, 10 GB de disco livre e uma CPU 64-bit com AVX2 — sem GPU obrigatória. GPU acelera muito, mas não é pré-requisito pra começar.

O contexto — por que "LLM local" voltou a ser assunto

Dois anos atrás, rodar modelo local era hobby de gente com placa de vídeo cara e paciência pra compilar llama.cpp na unha. Isso mudou.

Primeiro, os modelos abertos fecharam o gap. Um Qwen ou Llama de 7–8B hoje resolve boa parte do trabalho do dia a dia — resumo, extração, classificação, rascunho de código — num nível que há pouco tempo só a API de fronteira entregava. Segundo, a ferramenta ficou boba de usar: o Ollama esconde a parte chata (quantização, aceleração de GPU, servidor HTTP) atrás de um comando só.

E tem o timing. O Ollama v0.32 saiu em 11 de julho, com um modo agente interativo embutido (chat, código, web search e delegação de tarefa direto do terminal), flash attention pra GPUs NVIDIA mais antigas (compute capability 6.x) e offload de visão em iGPU. Traduzindo: rodar local ficou mais rápido justamente no hardware modesto, que é onde a maioria da galera está.

Se você quer a conta fria de quando open source compensa de verdade — custo, privacidade e velocidade lado a lado —, já cobrimos isso em Modelos de IA open source valem a pena em 2026. Aqui o foco é a mão na massa: subir e usar.

Pré-requisitos

Antes de baixar qualquer coisa:

[ ] RAM: 8 GB é o piso pra um modelo pequeno (1–3B). 16 GB abre a porta pros 7–8B com folga.
[ ] Disco: 10 GB livres pro começo. Cada modelo pesa de ~2 GB (3B quantizado) a dezenas de GB (70B+).
[ ] GPU (opcional, mas muda tudo): qualquer NVIDIA/AMD com VRAM decente, ou um Mac com Apple Silicon (a memória unificada é ótima pra isso). Sem GPU, roda na CPU — só que mais devagar.
[ ] Terminal: você vai viver nele. Nada de setup de IDE.

Uma regra de bolso pra dimensionar: no formato original (FP16), o modelo pede cerca de 2 GB de VRAM por bilhão de parâmetros. Um 8B em FP16 são ~16 GB. É aí que entra a quantização — e é ela que torna o local viável no seu notebook.

Mão na massa — do zero ao primeiro token

Passo 1: instalar o Ollama

No Linux, um comando:

curl -fsSL https://ollama.com/install.sh | sh

No macOS e Windows, baixe o instalador em ollama.com/download. Ele sobe um servidor local ouvindo em http://localhost:11434 — guarde essa porta, ela importa daqui a pouco.

Passo 2: rodar seu primeiro modelo

Um comando baixa e abre o chat:

ollama run qwen3:8b

Se o modelo ainda não estiver na máquina, o Ollama puxa sozinho (uns 5 GB) e abre um prompt interativo. Digite sua pergunta e pronto: está conversando com um LLM que roda 100% na sua máquina. Para sair, /bye.

Se 8B for pesado pro seu hardware, comece menor:

ollama run qwen3:1.7b

Passo 3: entender a quantização (a parte que salva sua RAM)

Quantizar é reduzir a precisão dos pesos do modelo pra ocupar menos memória. O padrão de ouro no hardware de consumo é o Q4_K_M: comprime os pesos pra 4 bits e corta ~75% da VRAM em relação ao FP16, com perda de qualidade que na prática você quase não sente. Aquele 8B de 16 GB vira ~5–6 GB.

A conta por faixa de hardware fica assim (referência):

VRAM	Roda bem (Q4_K_M)
6–8 GB	modelos 7–8B
16 GB	modelos 13B
24 GB	modelos 32B
48 GB+	modelos 70B+

Um 7–8B em Q4_K_M entrega 40+ tokens por segundo numa GPU de entrada — rápido o suficiente pra não te deixar esperando. E cuidado com o contexto: a KV cache come memória extra conforme a janela cresce (uns 2,5 GB a mais num 7B com 32k de contexto, ~10 GB em 128k). Contexto gigante não é de graça, mesmo local.

Passo 4: plugar no seu código

O terminal é o começo. O que interessa pra construir produto é a API. O Ollama expõe um endpoint compatível com OpenAI em /v1/chat/completions — ou seja, o mesmo SDK que você usaria pra GPT, apontado pro seu localhost:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # ignorado, mas o SDK exige algo
)

resp = client.chat.completions.create(
    model="qwen3:8b",
    messages=[{"role": "user", "content": "Resuma este texto em 3 bullets: ..."}],
)
print(resp.choices[0].message.content)

Trocou base_url e model, o resto do código continua igual. É isso que torna o local uma decisão de arquitetura, não um brinquedo: você pluga no mesmo lugar onde hoje chama a nuvem.

Comandos úteis pra gerenciar o que está na máquina: ollama list (o que você baixou), ollama ps (o que está carregado na memória agora) e ollama rm <modelo> pra liberar disco.

Quando local ganha da API (e quando não)

Local não é sempre a resposta. É uma ferramenta com trade-off claro.

Local ganha quando:

Privacidade é requisito. Dado sensível de cliente, PII, contrato, prontuário. Se não pode sair da sua infra, a discussão acaba aqui — o texto nunca vira request pra fora.
Volume alto e previsível. Milhares de classificações/resumos por dia. Na API isso vira fatura recorrente; local, o custo marginal por chamada é ~zero depois do hardware.
Offline ou latência baixa. Sem rede, sem round-trip pra outro continente.
Experimentação livre. Rodar eval, testar prompt em loop, sem medo do medidor girando.

API ganha quando:

Você precisa do topo de capacidade. Raciocínio pesado, código complexo, agente longo. O melhor modelo aberto que roda no seu notebook ainda perde pro frontier.
Carga esporádica. Poucas chamadas por dia não pagam o custo (e a dor) de manter hardware.
Você não quer ser o SRE. Local é você quem sobe, atualiza, monitora e conserta.

A leitura madura é híbrida: local pro que é volumoso, sensível ou repetitivo; API pro que exige o teto de capacidade. Não é religião, é engenharia.

Limitações e pontos de atenção

Qualidade tem teto. Um 8B local não é um modelo de fronteira. Pra tarefas que exigem raciocínio profundo, você vai sentir a diferença. Escolha a batalha certa.
Quantização agressiva degrada. Q4 é o ponto doce. Abaixo disso (Q3, Q2) a qualidade cai visível. Não force a barra só pra caber na VRAM.
CPU-only é lento. Roda, mas prepare-se pra esperar em modelos maiores. Pra uso sério, GPU ou Apple Silicon fazem diferença brutal.
Contexto longo custa memória. Aquela janela de 128k que a nuvem oferece de graça, local você paga em RAM/VRAM.
Você vira o responsável pela infra. Atualização de modelo, driver, monitoramento — tudo é seu. Não existe "someone else's computer" aqui.

FAQ rápido

Preciso de GPU pra rodar LLM local? Não. O mínimo do Ollama é CPU 64-bit com AVX2 e 8 GB de RAM. GPU acelera muito (a diferença entre segundos e dezenas de segundos por resposta), mas dá pra começar sem uma. Mac com Apple Silicon é um caminho excelente por causa da memória unificada.

Qual modelo escolher pra começar? Um 7–8B quantizado em Q4_K_M é o melhor equilíbrio pra hardware de consumo: cabe em ~6 GB e roda rápido. Qwen3, Llama e Gemma nesse tamanho cobrem a maioria dos casos do dia a dia.

Local é de graça mesmo? O software é. O modelo é. Mas o hardware não — e a eletricidade também não. Pra volume alto, ainda assim sai muito mais barato que API. Pra uso esporádico, provavelmente não compensa manter máquina ligada.

Consigo usar o Ollama no meu app existente? Sim. Ele expõe um endpoint compatível com OpenAI em localhost:11434/v1. Você troca a base_url do seu cliente atual e o resto do código continua igual.

Conclusão

Rodar um LLM local deixou de ser façanha. Instala o Ollama, roda ollama run qwen3:8b, e em minutos você tem um modelo respondendo sem mandar nada pra nuvem. O segredo não está no comando — está na decisão: entender a conta de VRAM, escolher a quantização certa e saber quando local ganha da API e quando não.

Esse é o pulo do gato. Rodar o modelo é fácil; transformar isso num produto que aguenta produção — com a arquitetura híbrida certa, avaliação e custo sob controle — é onde mora a engenharia de verdade. É exatamente esse tipo de decisão que a gente destrincha ao vivo no Clã Beer and Code, a maior comunidade de engenharia de IA do Brasil, com mentoria, labs práticos e a turma que coloca agente em produção. O próximo passo, se você já rodou seu primeiro modelo local, é fazer ele valer a pena: releia a conta real de rodar open source e desenhe seu setup híbrido.