O problema real
Sua empresa trata dados sensíveis, como contratos, prontuários e documentos financeiros. A política interna e a LGPD pedem cuidado com o que sai da rede, e o time fica travado diante de perguntas básicas. Qual modelo escolher? Quanta memória eu preciso? Como integro com o meu código? Sem resposta, alguém acaba colando o dado em uma ferramenta pública, e a auditoria descobre depois.
Rodar um modelo na sua própria máquina ou servidor resolve parte do problema de privacidade. Neste artigo você vai instalar o Ollama, conversar com um modelo pelo terminal e pela API HTTP, entender quantização e estimar a memória que precisa. No fim, você também verá quando local não compensa.
O que é o Ollama
O Ollama é um runtime que baixa modelos de pesos abertos, escolhe uma versão quantizada, roda a inferência e expõe uma API HTTP em localhost:11434. Ele usa a GPU quando encontra uma compatível e cai para a CPU quando não encontra.
Quantização é a técnica que reduz a precisão numérica dos pesos para o modelo ocupar menos memória. Em vez de 16 bits por peso, você usa 8, 5 ou 4 bits. A conta de bolso é parâmetros multiplicados por bits e divididos por 8. Um modelo de 7 bilhões de parâmetros em 16 bits ocupa cerca de 14 GB, em 8 bits cerca de 7 GB e em 4 bits cerca de 3,5 a 4,5 GB, e ainda é preciso somar o cache de contexto e o overhead. Quanto menor a precisão, maior a chance de perder qualidade, e o efeito varia por modelo e tarefa. Por isso, o certo é testar com os seus casos.
Mão na massa
1. Instalar
No Linux, use o script oficial. No macOS e no Windows, baixe o instalador em https://ollama.com/download.
curl -fsSL https://ollama.com/install.sh | sh
ollama --version
Como rodar um script baixado da internet exige confiança, leia-o antes ou prefira o pacote da sua distribuição quando existir.
2. Baixar e conversar com um modelo
A biblioteca de modelos muda rápido, então consulte https://ollama.com/library e escolha um modelo que caiba na sua máquina. Os exemplos usam llama3.2, uma família pequena e popular, mas qualquer outro funciona do mesmo jeito.
ollama pull llama3.2
ollama run llama3.2
No prompt >>>, escreva uma pergunta. Saia com /bye ou Ctrl+D. Para ver o que já está baixado, use ollama list, e para ver o que está carregado na memória, ollama ps. A coluna PROCESSOR mostra se o modelo está na GPU, na CPU ou dividido entre as duas.
Cada nome pode ter variações de tamanho e de quantização, como llama3.2:3b. Veja as tags disponíveis na página do modelo.
3. Usar pela API HTTP
A rota /api/chat recebe uma lista de mensagens e é a mais adequada para conversas. Parâmetros como temperatura vão dentro de options.
import requests
URL = "http://localhost:11434/api/chat"
def conversar(mensagens: list[dict], modelo: str = "llama3.2") -> str:
resp = requests.post(URL, json={
"model": modelo,
"messages": mensagens,
"stream": False,
"options": {"temperature": 0.3},
}, timeout=120)
resp.raise_for_status()
return resp.json()["message"]["content"]
historico = [{"role": "user", "content": "Qual é a capital do Brasil?"}]
resposta = conversar(historico)
print(resposta)
historico += [
{"role": "assistant", "content": resposta},
{"role": "user", "content": "E qual é a moeda do país?"},
]
print(conversar(historico))
O modelo não guarda memória entre chamadas. O histórico que você envia é a memória, e ele consome contexto. Para respostas em fluxo, use "stream": true e leia o corpo linha a linha, cada linha sendo um JSON com um pedaço da resposta.
O Ollama também oferece uma API compatível com a da OpenAI em http://localhost:11434/v1. Isso permite reaproveitar o SDK openai apenas trocando base_url, o que facilita testar um código de nuvem contra um modelo local.
4. Rodar em Docker
docker run -d --name ollama \
-p 127.0.0.1:11434:11434 \
-v ollama_data:/root/.ollama \
ollama/ollama
docker exec ollama ollama pull llama3.2
docker exec -it ollama ollama run llama3.2
Dois cuidados. O primeiro é publicar a porta só em 127.0.0.1, como acima, porque a API não tem autenticação, e expô-la na rede é abrir seu modelo para qualquer um. Se precisar de acesso remoto, coloque um proxy reverso com autenticação na frente. O segundo é que, para usar GPU NVIDIA, é preciso instalar o NVIDIA Container Toolkit e adicionar --gpus=all ao comando. Não use RUN ollama pull em um Dockerfile, porque o servidor não está rodando durante o build. Baixe os modelos em tempo de execução, num volume.
Quanta memória eu preciso
Os valores abaixo são aproximados e servem como ponto de partida. Eles variam por modelo, quantização e tamanho do contexto.
| Tamanho do modelo | Memória aproximada em 4 bits | Onde costuma rodar |
|---|---|---|
| 1B a 3B | 1 a 3 GB | Notebook comum, só CPU |
| 7B a 8B | 4 a 6 GB | GPU de entrada ou notebook com 16 GB |
| 13B a 14B | 8 a 10 GB | GPU intermediária |
| 30B ou mais | 18 GB ou mais | GPU grande ou máquina com muita memória |
Regras práticas para decidir.
- Sem GPU, comece com um modelo pequeno. Modelos grandes na CPU funcionam, mas ficam lentos.
- Com GPU, escolha o maior modelo que caiba inteiro na memória da placa. Se ele transbordar para a RAM, a velocidade despenca.
- Para tarefas simples, como classificar e extrair campos, um modelo pequeno costuma bastar.
- Para raciocínio mais difícil, os modelos de ponta em nuvem ainda tendem a ir melhor, e vale comparar com o seu conjunto de testes.
Local ou API: como comparar custo
Em vez de confiar em uma conta pronta, monte a sua com estes itens.
- No local, hardware amortizado, energia, tempo de quem opera e disponibilidade (o que acontece quando a máquina cai).
- Na API, o volume de tokens de entrada e de saída vezes o preço atual da tabela do provedor.
Local tende a compensar quando o volume é alto e constante, quando os dados não podem sair, ou quando você precisa operar sem internet. Para volume baixo ou irregular, a API costuma sair mais barata, porque você não paga por hardware ocioso. A calculadora de custo de LLM ajuda no lado da API.
Armadilhas comuns
Contexto menor do que você imagina
O tamanho de contexto padrão do Ollama depende da versão, e conversas longas ou documentos grandes podem ser cortados em silêncio. Defina num_ctx em options conforme a necessidade, lembrando que contextos maiores consomem mais memória.
Quantização não é compressão reversível
Você não recupera a precisão perdida. Se a qualidade cair no seu teste, suba para uma quantização maior ou para um modelo maior.
Achar que está na GPU sem conferir
Rode ollama ps com o modelo carregado e olhe a coluna PROCESSOR. Se aparecer CPU, a resposta será bem mais lenta.
Deixar modelos ocupando memória
O Ollama mantém o modelo carregado por alguns minutos depois do uso. Ajuste com a variável OLLAMA_KEEP_ALIVE ou com keep_alive na requisição, e limite quantos modelos ficam carregados com OLLAMA_MAX_LOADED_MODELS. Essas variáveis são definidas no ambiente do servidor, e não existe uma flag de memória no comando ollama serve.
Quando não usar LLM local
- Você precisa da melhor qualidade disponível em tarefas difíceis, e a diferença para modelos de ponta importa.
- Não há ninguém para operar o servidor, atualizar modelos e monitorar.
- A carga é muito irregular, com picos que exigiriam muito hardware.
- Você precisa de escala horizontal simples. Uma API gerenciada resolve isso sem esforço.
Próximos passos
Use o nomic-embed-text do Ollama para gerar embeddings locais no pipeline de RAG na prática. Modelos pequenos pedem prompts mais explícitos, e Engenharia de prompt em produção ajuda nisso. Antes de levar para produção, meça a qualidade com Avaliação de LLM com evals. Para entender melhor como o texto vira tokens, jogue Caça-Tokens.
Quer aplicar isso na sua empresa? Marque uma conversa de 45 minutos em https://iauaicloud.com.br/consultoria