Rodando um LLM local com Ollama

O problema real#

Você está em uma empresa que processa dados sensíveis — boletos de clientes, diagnósticos médicos, documentação financeira. A política de dados (LGPD no Brasil) proíbe enviar tudo para uma API em cloud. Descobre que pode rodar um modelo localmente com Ollama, mas não sabe: qual modelo escolher, quanto RAM precisa, como integrar com seu código. Fica paralisado escolhendo entre instalar no servidor, em um container, ou na máquina de dev. Resultado: acaba mandando tudo para ChatGPT de qualquer jeito, e a auditoria cobra.

Ou você tem uma app que precisa de latência < 500ms e quer evitar custos de API. Neste artigo: como começar em 5 minutos, entender trade-offs reais, e quando local não compensa.

Como rodar um LLM localmente com Ollama?#

Ollama é um runtime que abstrai toda a complexidade: download, quantização, inferência, API HTTP. Você roda ollama pull mistral e pronto — não precisa compilar CUDA ou mexer em flags obscuras.

Quantização é a chave: reduz o modelo em tamanho/RAM sem perder muita qualidade. Um modelo de 7B parâmetros:

• Sem quantizar: ~14GB RAM (32-bit float)
• Q8 (8-bit): ~7GB RAM, 95% qualidade
• Q6 (6-bit): ~5GB RAM, 90% qualidade
• Q4 (4-bit): ~3.5GB RAM, 80-85% qualidade

Não é mágica — é tradeoff. Mais compressão = menos qualidade, menos RAM.

Mão na massa#

1. Instalar Ollama#

# macOS
curl -fsSL https://ollama.ai/install.sh | sh

# Linux
curl -fsSL https://ollama.ai/install.sh | sh

# Windows
# Download direto em https://ollama.ai

Verifica instalação:

ollama --version

2. Baixar e rodar um modelo#

# Baixa Mistral 7B (4.2GB com Q4)
ollama pull mistral

# Roda no terminal (sai com Ctrl+D)
ollama run mistral

Teste:

>>> Qual é a capital do Brasil?
A capital do Brasil é Brasília.

Pronto. Latência típica: 100-500ms para gerar uma resposta curta, dependendo da GPU.

3. Usar via API HTTP#

Ollama roda uma API em localhost:11434. Integre com código Python:

import requests
import json
from typing import Generator

def chat_with_ollama(
    prompt: str,
    model: str = "mistral",
    temperature: float = 0.7,
    stream: bool = False
) -> str:
    """Envia prompt para Ollama local."""
    
    url = "http://localhost:11434/api/generate"
    
    payload = {
        "model": model,
        "prompt": prompt,
        "temperature": temperature,
        "stream": stream
    }
    
    response = requests.post(url, json=payload)
    
    if stream:
        # Retorna generator para processar chunks
        for line in response.iter_lines():
            if line:
                chunk = json.loads(line)
                yield chunk["response"]
    else:
        return response.json()["response"]

# Uso bloqueante (mais simples)
result = chat_with_ollama("Explique IA em uma frase", model="mistral")
print(result)

# Uso com stream (mais interativo)
for chunk in chat_with_ollama("Conte uma história", stream=True):
    print(chunk, end="", flush=True)

4. Com conversação (context window)#

def chat_with_history(
    user_message: str,
    history: list = None,
    model: str = "mistral"
) -> str:
    """Conversa mantendo histórico."""
    
    if history is None:
        history = []
    
    # Reconstrói prompt com histórico
    conversation = ""
    for role, content in history:
        conversation += f"{role}: {content}\n"
    
    conversation += f"user: {user_message}\nassistant:"
    
    url = "http://localhost:11434/api/generate"
    response = requests.post(url, json={
        "model": model,
        "prompt": conversation,
        "temperature": 0.7,
        "stream": False
    })
    
    answer = response.json()["response"]
    
    # Atualiza histórico
    history.append(("user", user_message))
    history.append(("assistant", answer))
    
    return answer, history

# Uso
history = []

response, history = chat_with_history("Qual é a capital do Brasil?", history)
print(f"Bot: {response}")

response, history = chat_with_history("Qual é a moeda?", history)
print(f"Bot: {response}")

5. Com Docker para produção#

FROM ollama/ollama:latest

# Pronta para usar — exponha porta 11434
EXPOSE 11434

# Comando padrão (já vem no base image)
# Se quiser pré-carregar um modelo:
RUN ollama pull mistral

Deploy:

docker run -d \
  -p 11434:11434 \
  -v ollama_data:/root/.ollama \
  --name ollama-server \
  ollama/ollama:latest

# Dentro do container
docker exec ollama-server ollama pull mistral
docker exec ollama-server ollama run mistral "Oi"

Modelos e RAM necessário#

Guia prático para decidir qual modelo usar:

Modelo	Params	Q4 (GB)	Q8 (GB)	Latência	Qualidade
Phi 3	3.8B	2.3	3.8	50ms	⭐⭐⭐
Mistral	7B	4.2	7.0	150ms	⭐⭐⭐⭐
Llama 2	7B	4.2	7.0	150ms	⭐⭐⭐⭐
Neural Chat	7B	4.2	7.0	150ms	⭐⭐⭐ (chatbot)
Llama 2	13B	8.0	13.5	300ms	⭐⭐⭐⭐⭐
CodeLlama	7B	4.2	7.0	200ms	⭐⭐⭐⭐ (código)

Recomendações:

• GPU NVIDIA? Use Q4 em 7B — melhor relação speed/qualidade.
• Só CPU? Teste Phi 3 em Q4 (2.3GB, roda em qualquer laptop).
• Dado sensível crítico? Use 13B em Q8 (mais preciso).
• Desenvolvimento? Mistral em Q4 (padrão ouro).

Custo: local vs. API#

Local (TCO — Total Cost of Ownership)#

Hardware: GPU NVIDIA A6000 = USD 4.000 (amortizado 3 anos = USD 1.333/ano)
Energia: 300W × 24h × 365 dias × USD 0,10/kWh = USD 262/ano
Manutenção: USD 200/ano
Total/ano: ~USD 1.800
Custo/1M tokens: USD 1.800 / (365 dias × 100k tokens/dia × 365) = ~USD 0,0001

API (OpenAI)#

1M tokens = USD 0,10 a USD 0,60 (modelo + tier)
1M tokens/dia × USD 0,15 = USD 150/mês = USD 1.800/ano

Breakeven: 1-2 anos de uso intenso. Depois, local é grátis (só energia).

Armadilhas comuns#

Armadilha 1: Modelo muito pequeno perde contexto#

Phi 3 é rápido mas tem 2k context window. Se seu chat tem histórico de 10k tokens, ele vai esquecer. Teste com seus dados reais.

Armadilha 2: Confundir quantização com compressão#

Q4 não é compressão reversível. Você não consegue recuperar a qualidade original. Use Q8 se for crítico, Q4 se for tolerável perder 10-15% de qualidade.

Armadilha 3: CPU chega lentamente#

Rodar em CPU sem GPU é viável, mas lento:

• 7B em CPU: 5-10 segundos por token (insuportável).
• Use GPU ou reduz modelo.

# Check se encontrou GPU
ollama run mistral
# Log shows: "llm: Load model from GPU" (bom) ou "cpu" (ruim)

Armadilha 4: Não monitorar consumo de RAM#

Se deixar Ollama rodando sem limite, pode estourar RAM compartilhada.

# Limita RAM a 8GB
ollama serve --memory 8gb

# Verifica consumo
watch -n 1 'ps aux | grep ollama'

Quando não usar LLM local#

• Qualidade crítica com dados estranhos: API (GPT-4) generaliza melhor.
• Custo-benefício de desenvolvimento baixo: Não vale manter uma infra nova só para IA.
• Latência < 50ms é crítico: Local é lento, API com cache Redis é melhor.
• Seu modelo precisa tuning frequente: OpenAI Fine-tuning é mais fácil que recompilação local.
• Escalabilidade horizontal: Rodar Ollama em 100 servidores é complexo; API é trivial.

Próximos passos#

1. Integre com RAG na prática usando Ollama para embeddings locais (modelo nomic-embed-text).
2. Combine com engenharia de prompt em produção para estruturar prompts que funcionam em modelos menores.
3. Jogue Caça-Tokens para entender quantização e tokens na prática.

Resumo prático#

LLM local com Ollama é prático para:

• Prototipar rápido sem sair de casa (5 min setup)
• Processar dados sensíveis (LGPD, médica, financeira)
• Economizar em larga escala (> 1B tokens/ano)
• Latência previsível (controla tudo)

Não use para:

• Qualidade de ponta (GPT-4 é melhor)
• Produção crítica sem know-how DevOps
• Quando custo total for menor em cloud

Comece com ollama pull mistral e teste. Se a qualidade passar no seu eval (veja avaliação de LLM com evals), escale para produção. Leva uma sexta-feira.