Rodando LLM local na empresa com Ollama: quando faz sentido

A ferramenta que tornou isso trivial chama-se Ollama: open source, um comando pra instalar, um comando pra baixar o modelo, e uma API local que fala o mesmo idioma da API da OpenAI. O que era projeto de fim de semana de entusiasta virou opção séria de arquitetura — inclusive aqui: a Rhodium planeja a própria infraestrutura de inferência local exatamente pelas razões deste artigo.

Mas "dá pra rodar" e "vale a pena rodar" são perguntas diferentes, e a segunda quase nunca é respondida com honestidade por quem escreve sobre o assunto. Vamos às duas.

Quando o LLM local faz sentido?

1. Quando o dado não pode sair de casa. Escritório jurídico processando contratos, clínica lidando com prontuário, financeiro com folha e extrato — tem categoria de dado que a LGPD trata como sensível e tem cliente que simplesmente não aceita ver o documento dele viajando pra um datacenter fora do país, sob jurisdição alheia e com política de retenção que muda por e-mail. No LLM local a discussão acaba antes de começar: o dado não sai da máquina. Não é "o fornecedor promete não treinar com seus dados" — é fisicamente impossível, porque não há tráfego.

2. Quando o volume corrói a margem. Classificar 50 mil documentos por mês, resumir cada chamado de suporte, extrair campos de cada nota que entra — tarefas repetitivas de volume alto multiplicam qualquer preço por token. A conta que fazemos em projeto é sempre a mesma: custo mensal da API no seu volume real × 12, contra o preço do hardware que roda um modelo aberto suficiente pra tarefa. Quando a primeira coluna passa a segunda, a inferência local se paga — e o hardware continua seu no ano 2.

3. Quando latência ou conexão mandam. Operação em chão de fábrica, em campo, embarcada ou simplesmente paranóica com disponibilidade: modelo local responde sem depender de internet, de status page de terceiro ou de rate limit alheio na sua hora de pico.

4. Quando depender de meia dúzia de fornecedores é o risco. Preço dobra, modelo é descontinuado, política de uso muda, conta é suspensa por engano — quem construiu o negócio inteiro em cima de uma API alugada já conhece o frio na barriga. É o que por aqui chamamos de tech-feudalismo: você planta na terra do senhor e reza pra renda não subir. Modelo aberto rodando em hardware seu é a única variável dessa equação que ninguém pode revogar.

Quando NÃO faz sentido (a parte que os entusiastas pulam)

Quando a tarefa exige o topo da inteligência. Os modelos abertos evoluíram absurdamente, mas para raciocínio longo, código complexo e tarefas de agente sofisticadas, os modelos de fronteira pagos ainda entregam um degrau acima. Se o seu produto depende da melhor resposta possível — e o cliente percebe a diferença —, economizar token no modelo errado custa mais caro em retrabalho.

Quando o volume é pequeno. Pra centenas de chamadas por mês, o modelo barato de qualquer provedor custa centavos. Comprar e operar uma máquina de R$ 15–30 mil pra economizar R$ 40/mês é a pior troca do mundo — a API paga com modelo econômico é imbatível nesse regime.

Quando não há quem opere. LLM local é infraestrutura: alguém precisa atualizar modelo, monitorar memória, reiniciar o serviço que travou de madrugada e planejar capacidade. Sem esse alguém (interno ou contratado), a "independência" vira um servidor esquecido rodando um modelo de 2 gerações atrás.

Cenário	Local ou API paga?	Por quê
Documentos sob sigilo (jurídico, saúde, financeiro)	Local	Dado não sai da máquina; LGPD e cliente dormem em paz
Volume alto de tarefa repetitiva (classificar, extrair, resumir)	Local	Token pago × volume × 12 meses > hardware próprio
Operação offline ou latência crítica	Local	Sem dependência de internet e de status page alheia
Poucas centenas de chamadas/mês	API paga	Centavos por mês; hardware não se paga nunca
Raciocínio de fronteira, código complexo, agente sofisticado	API paga	Modelos topo de linha ainda têm um degrau de vantagem
Sem ninguém pra operar infraestrutura	API paga	LLM local é infra: exige dono técnico
Meio-termo comum	Híbrido	Local pro volume e pro sensível; API de fronteira pro difícil

Repare que a última linha é onde a maioria das empresas de verdade termina: híbrido. O classificador de documentos roda local; a síntese difícil que acontece 10 vezes por dia vai pro modelo de fronteira. É o desenho que usamos em projeto — e é exatamente o tipo de decisão que fazemos com o cliente na Fase 1 antes de qualquer compra de hardware.

Mão na massa: Ollama rodando em 10 minutos

Onde baixar: tudo sai de ollama.com/download ou dos comandos oficiais abaixo — não instale de fonte alternativa. O passo a passo por sistema, direto da documentação oficial:

macOS

Baixe o app em ollama.com/download (arrasta pra Aplicativos e pronto — fica um ícone na barra de menu) ou, se você vive no terminal, pelo Homebrew:

brew install ollama
brew services start ollama   # sobe como serviço e volta sozinho no boot

Windows

Baixe o OllamaSetup.exe — instala na sua conta sem exigir administrador. Requisitos oficiais: Windows 10 22H2 ou mais novo, ~4 GB pro binário e dezenas de GB livres pros modelos. Pra instalar em outro disco: OllamaSetup.exe /DIR="d:\ollama".

Linux

# script oficial (instala e configura o serviço)
curl -fsSL https://ollama.com/install.sh | sh

# alternativa manual, sem script
curl -fsSL https://ollama.com/download/ollama-linux-amd64.tar.zst | sudo tar x -C /usr
ollama serve

# atualizar = rodar o script de novo

Docker (servidor)

# CPU
docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

# GPU NVIDIA — antes, instale o nvidia-container-toolkit e rode:
#   sudo nvidia-ctk runtime configure --runtime=docker && sudo systemctl restart docker
docker run -d --gpus=all -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

Um detalhe que evita susto de disco cheio: os modelos ficam em ~/.ollama/models no macOS, /usr/share/ollama/.ollama/models no Linux e C:\Users\%username%\.ollama\models no Windows — e cada modelo tem gigabytes. Pra guardar em outro disco, aponte a variável de ambiente OLLAMA_MODELS pro diretório escolhido (no Linux, dê permissão ao usuário do serviço: sudo chown -R ollama:ollama <diretório>).

Instalado, baixar um modelo e conversar com ele é um comando só — o download acontece na primeira execução:

ollama run qwen3:8b
# >>> me explique o que é inferência local em uma frase

Sobre quais modelos valem hoje: a biblioteca do Ollama muda toda semana, então cito famílias, não veredictos. As mais baixadas incluem Llama 3.1 (8B/70B), DeepSeek-R1 (de 1.5B a 671B, forte em raciocínio, licença MIT com uso comercial explícito), Qwen3 (de 0.6B a 235B, denso e MoE), Gemma (Google) e o gpt-oss — os modelos de pesos abertos da própria OpenAI, em 20B e 120B, sob Apache 2.0. A regra prática: comece com um 8B pra validar o fluxo, suba de tamanho só se a qualidade não bastar.

A API compatível com OpenAI: troque o endpoint e pronto

O Ollama expõe em http://localhost:11434/v1 uma API compatível com a da OpenAI — chat completions com streaming, JSON mode, visão, tools e embeddings. Teste com curl:

curl -X POST http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3:8b",
    "messages": [{ "role": "user", "content": "Resuma a LGPD em 2 frases." }]
  }'

E o pulo do gato pra quem já tem aplicação usando o SDK da OpenAI — troca o baseURL e o nome do modelo, o resto do código fica intacto:

// Node.js — o mesmo SDK que você já usa
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "http://localhost:11434/v1",
  apiKey: "ollama", // exigido pelo SDK, ignorado pelo Ollama
});

const reply = await client.chat.completions.create({
  model: "qwen3:8b",
  messages: [{ role: "user", content: "Classifique este chamado: 'sistema fora do ar'" }],
});
console.log(reply.choices[0].message.content);

Isso significa que migrar (ou fazer o híbrido) não é reescrever a aplicação — é configuração. Nas limitações, a doc é transparente: logprobs, tool_choice e logit_bias não são suportados, e endpoints como geração de imagem estão marcados como experimentais.

Hugging Face: quando a biblioteca do Ollama não basta

Pense no Hugging Face como o GitHub dos modelos de IA: é onde autores e comunidade publicam os pesos, as variações e os ajustes finos de praticamente tudo que existe em modelo aberto. A biblioteca do Ollama é a prateleira curada; o Hugging Face é o depósito inteiro — a própria documentação do Hub conta dezenas de milhares de checkpoints públicos no formato certo pra rodar local.

Você sai da biblioteca do Ollama e vai ao Hugging Face em três situações: o modelo acabou de sair e ainda não entrou na biblioteca; você quer um fine-tune específico (um modelo ajustado pra área jurídica, pra saúde, pra português brasileiro); ou quer uma quantização exata que a biblioteca não oferece.

O formato que interessa chama GGUF: um arquivo único com o modelo já comprimido, feito pra rodar em máquina comum — é o formato do llama.cpp, o motor que trabalha por baixo do Ollama. E rodar um GGUF do Hugging Face é um comando, sem configuração nenhuma:

# sintaxe oficial: ollama run hf.co/{usuario}/{repositorio}
ollama run hf.co/bartowski/Llama-3.2-1B-Instruct-GGUF

# escolhendo a quantização (tag depois dos dois-pontos, case-insensitive)
ollama run hf.co/bartowski/Llama-3.2-3B-Instruct-GGUF:Q8_0

Sem a tag, o Ollama usa a quantização Q4_K_M quando ela existe no repositório — que é exatamente o default sensato: o melhor equilíbrio entre tamanho e qualidade pra maioria dos casos. Se a sua máquina tem memória sobrando, Q8_0 preserva mais qualidade em troca do dobro do espaço; abaixo de Q4, só descendo com teste ao lado do original.

O caminho clássico — pra quando você baixou o .gguf na mão ou quer customizar o comportamento — é o Modelfile, o "Dockerfile dos modelos":

# Modelfile
FROM ./meu-modelo-baixado.gguf

# cria e roda com o nome que você quiser
ollama create meu-modelo
ollama run meu-modelo

Duas notas de segurança que valem dinheiro. Procedência: você vai executar esse arquivo dentro da sua rede — prefira o repositório do próprio autor do modelo ou quantizadores estabelecidos da comunidade, como o bartowski (citado nominalmente pela documentação do Hugging Face) e a unsloth (organização verificada, milhares de quantizações publicadas); repositório aleatório sem histórico, deixa passar. E se o modelo for privado (um fine-tune seu), dá pra rodar direto do seu Hugging Face adicionando a chave SSH do Ollama na sua conta do Hub — está na mesma doc.

Como escolher o modelo: o funil de decisão

"Qual o melhor modelo?" é a pergunta errada — a certa é "qual o melhor modelo pra ESTA tarefa neste hardware?". O funil que usamos, na ordem:

#	Filtro	Pergunta
1	Tarefa	Chat interno? Extração estruturada de documentos? Código? RAG em português? Tarefa simples não precisa de gigante — um 4B que classifica bem vale mais que um 70B ocioso.
2	Candidatos	Escolha 2–3 famílias adequadas à tarefa na biblioteca do Ollama ou no Hugging Face. Sem casamento: o pódio muda todo mês.
3	Hardware	O maior modelo que roda confortável na sua máquina (tabela abaixo) — não o maior que cabe espremido.
4	Quantização	Q4_K_M como padrão. Espremer demais degrada: um 70B esmagado pra caber pode responder pior que um 14B limpo.
5	Licença	MIT e Apache 2.0 = paz total. Licenças próprias (Llama, Gemma) costumam permitir uso comercial, mas têm cláusulas — a página do modelo no Ollama/Hugging Face traz a licença; leia antes de produção.
6	Português	Ranking gringo mede inglês. Se a sua operação fala pt-BR, esse é o critério que os benchmarks ignoram — só o seu teste responde.

E o teste que decide de verdade — o A/B honesto de 30 minutos: separe 10 casos REAIS do seu negócio (5 típicos, 5 dos difíceis), rode o mesmo prompt nos 2 finalistas e avalie em 4 colunas numa planilha: acertou o conteúdo? seguiu o formato pedido? inventou alguma coisa? em quanto tempo? Isso vale mais que qualquer ranking da internet, por três motivos que os benchmarks não contam: contaminação (modelos treinados nas respostas dos próprios testes inflam nota), variantes "uncensored" de procedência duvidosa circulando com nome parecido ao original, e o fato de que tamanho não é qualidade pra tarefa específica — só o seu dado, no seu prompt, diz quem ganha.

Que máquina eu preciso? A tabela honesta

Antes da tabela, um parágrafo sobre quantização, sem jargão: os modelos da biblioteca do Ollama vêm comprimidos — os números internos do modelo são armazenados com menos casas, tipicamente 4 bits em vez de 16. Isso corta o tamanho pra cerca de um quarto com perda de qualidade pequena, e é o que permite rodar um modelo de 8 bilhões de parâmetros em ~5 GB. Os tamanhos abaixo são os downloads reais da biblioteca (Qwen3 e DeepSeek-R1) — a regra de bolso é ter memória livre ≥ tamanho do arquivo + 20–50% de folga pro contexto:

Tamanho do modelo	Download (quantizado)	Memória confortável	Pra que serve
~1–4B	0,5–2,5 GB	8 GB	Classificação simples, roteamento, tarefas curtas — roda em quase tudo
7–8B	~5 GB	8–16 GB	O ponto de partida: resumo, extração, chat interno decente
14B	~9 GB	16 GB	Qualidade visivelmente melhor nas mesmas tarefas
20B (gpt-oss)	14 GB	16 GB (oficial)	Raciocínio sério — a OpenAI declara 16 GB como piso
30–32B	19–20 GB	32 GB	Perto do teto do que roda bem em máquina de mesa
70B	~43 GB	64 GB+	Exige estação de trabalho ou servidor com GPU parruda

Dois destaques dessa tabela. Primeiro, o Mac virou opção séria de servidor de inferência: a memória unificada do Apple Silicon serve de memória de vídeo, então um Mac com 48–64 GB roda modelos que exigiriam GPU cara no mundo PC — silencioso e econômico na tomada. Segundo, a conta de padaria: se a sua fatura de API passa de uns R$ 800/mês em tarefas que um modelo de 8–20B resolve, uma máquina de R$ 10–20 mil se paga dentro do primeiro ano — e no segundo ano a inferência custa energia elétrica.

Um exemplo trabalhado pra deixar concreto. Imagine uma operação que classifica e resume 3.000 documentos por dia útil — chamados, notas, e-mails. São ~66 mil chamadas/mês. Numa API paga, mesmo com modelo econômico, isso vira uma fatura mensal de três a quatro dígitos que cresce junto com o negócio — e pra sempre. A mesma carga, num modelo de 8–14B rodando numa máquina de R$ 12–18 mil, é confortável: a máquina processa em lote de madrugada, o custo marginal é energia, e dobrar o volume não dobra a conta. A inversão da lógica é essa: na API você aluga capacidade pra sempre; no local você compra capacidade uma vez. Nenhum dos dois é certo em abstrato — é por isso que a decisão começa medindo o SEU volume, não lendo benchmark.

Segurança e operação: o que ninguém te conta

• O Ollama não tem autenticação nativa. A porta 11434 aberta pra rede é um LLM grátis pra qualquer um que a encontre — e tem scanner varrendo a internet atrás disso. Regra: escute só em localhost; se outras máquinas precisam acessar, ponha um reverse proxy com autenticação na frente (ou um gateway, abaixo) e feche a porta no firewall. O esqueleto no nginx é este:

# nginx na frente do Ollama: só entra quem tem o token
server {
  listen 443 ssl;
  server_name ia.suaempresa.com.br;
  # ... certificados ...

  location / {
    if ($http_authorization != "Bearer SEU_TOKEN_LONGO_AQUI") {
      return 401;
    }
    proxy_pass http://127.0.0.1:11434;
    proxy_read_timeout 300s;   # geração longa não pode dar timeout
  }
}

(O proxy_read_timeout generoso importa: resposta de modelo grande pode levar dezenas de segundos, e o timeout padrão do nginx derruba a conexão no meio da geração.)

• Modelo também se atualiza. ollama pull <modelo> traz a versão nova. Trate como dependência: atualize de propósito, teste antes, não deixe apodrecer 2 gerações.
• Pra gerenciar local + nuvem junto, um gateway como o LiteLLM (open source) unifica mais de 100 provedores — incluindo Ollama — atrás do mesmo formato OpenAI, com chaves virtuais e rastreio de custo. É a peça que transforma "um experimento na minha máquina" em "infraestrutura da empresa".
• Princípio de casa que vale dobrado no local: o modelo não pode inventar dado fora da base. Local ou pago, agente em produção precisa de guarda-corpos — se esse tema é novo, comece pelo nosso guia de agentes de IA em produção.

Onde isso encosta no seu negócio

O LLM local não substitui a discussão de automação — ele é uma opção de infraestrutura dentro dela. O desenho certo continua começando pela pergunta de sempre (regra fixa ou contexto? RPA ou agente?) e só depois vem o "roda onde". Errar essa ordem é como comprar o forno antes de decidir o cardápio.

Perguntas frequentes