IA Local no Seu Servidor: Do Zero à Solução Real com Ollama + n8n

IA que roda no SEU servidor, não na nuvem dos outros

Você já imaginou ter um assistente de IA rodando 24h por dia no seu próprio servidor, sem depender de OpenAI, sem enviar dados do cliente pra fora, e sem pagar por token? Não é só possível — é mais simples do que parece.

Este tutorial é prático. Todos os comandos abaixo foram executados de verdade num VPS; as saídas são reais. Você vai sair daqui com um modelo de IA rodando, uma API pronta pra integrar, e o caminho pra montar uma solução completa.

Arquitetura: O Mapa do Lego (6 peças)

Antes de qualquer comando: não existe "uma plataforma mágica única". Uma solução de IA local é um Lego de 6 peças. Entender cada uma é o segredo para montar QUALQUER solução:

O diagrama da arquitetura:

   [ CANAL ]            [ ORQUESTRADOR ]         [ MOTOR ]         [ CÉREBRO ]
 WhatsApp / CRM   →    n8n / código / OpenClaw →  Ollama (API)  →  LFM2 (modelo)
 formulário/site       (recebe, chama, decide)    porta :11434     730 MB no disco
       ↑                        │
       └────── resposta ────────┤
                                ↓
                        [ MEMÓRIA / RAG ]
                     embedder + base privada
                       (tudo no SEU servidor)

As 6 peças individuais:

Modelo (cérebro) — o "operário" que pensa. Ex: LFM2, Llama 3, Mistral. Fica no disco do VPS (~730 MB).
Motor / Runtime (Ollama) — quem roda o modelo e expõe uma API. Instalado no servidor.
API (porta 11434) — o encaixe universal. Todo mundo fala com o modelo por aqui.
Orquestrador — recebe a mensagem do mundo, chama a API, faz algo com a resposta. Pode ser n8n, Python, ou até curl.
RAG (memória) — embedder + base de dados privada. Dá contexto ao modelo.
Canal — de onde vem a pergunta (WhatsApp, CRM, site).

Regra de ouro: o motor (Ollama) é sempre o mesmo. Você só troca a "cola" (orquestrador) conforme a necessidade.

1. Instalação do Ollama (funciona em QUALQUER Linux)

O Ollama precisa do zstd (descompactador). O bloco abaixo funciona em qualquer distribuição — ele detecta automaticamente o gerenciador de pacotes:

# 1. Instala o zstd no gerenciador que sua máquina tiver
(command -v apt-get && apt-get install -y zstd) \
  || (command -v dnf && dnf install -y zstd) \
  || (command -v yum && yum install -y zstd) \
  || (command -v apk && apk add zstd) \
  || (command -v zypper && zypper install -y zstd)

# 2. Instala o Ollama
curl -fsSL https://ollama.com/install.sh | sh

# 3. Confere
ollama --version

Erros comuns:

"ERROR: This version requires zstd" → você pulou o passo 1. Rode-o e reinstale.
"apt-get: command not found" → sua máquina não é Ubuntu/Debian; o bloco acima cobre isso (usa dnf/yum/apk conforme o caso).
"No NVIDIA/AMD GPU detected" → esperado e não é erro — ele roda perfeitamente em CPU.

2. Puxando o Modelo (730 MB de cérebro)

Vamos usar o LFM2.5-1.2B da Liquid AI, um modelo de 1.2 bilhão de parâmetros otimizado para dispositivos e servidores leves. Ele roda bem até em VPS com 2 GB de RAM:

# Puxar o modelo
ollama pull hf.co/LiquidAI/LFM2.5-1.2B-Instruct-GGUF

# Testar no terminal interativo
ollama run hf.co/LiquidAI/LFM2.5-1.2B-Instruct-GGUF

3. Os 3 Jeitos de Usar

3.1. Terminal (a verdade crua)

Perfeito para testar e aprender. Conecte-se ao VPS e use o chat interativo:

ssh -p 22022 root@SEU_IP_DA_VPS \
  'ollama run hf.co/LiquidAI/LFM2.5-1.2B-Instruct-GGUF'

Digite sua mensagem no >>> e veja a resposta. /bye para sair.

3.2. API REST (o que um sistema de verdade usa)

O Ollama expõe uma API compatível com OpenAI na porta 11434. Você pode chamá-la com qualquer linguagem:

curl http://localhost:11434/api/chat -d '{
  "model": "hf.co/LiquidAI/LFM2.5-1.2B-Instruct-GGUF",
  "messages": [{"role": "user", "content": "oi"}],
  "stream": false
}'

3.3. Open WebUI (interface gráfica tipo ChatGPT)

Uma tela bonita no navegador, com histórico, upload de arquivos e suporte multimodal:

docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data --name open-webui \
  ghcr.io/open-webui/open-webui:main

Acesse http://SEU_IP:3000. Atenção: pesa ~1 GB de RAM. Em VPS apertado, use só para demonstrar e depois pare o container.

4. System Message — A Regra Fixa do Modelo

O system message é a instrução permanente que define o papel e o formato da resposta. É o que transforma um tagarela num operário disciplinado.

Onde configurar (3 lugares):

# a) No chat interativo (temporário):
>>> /set system "Você extrai leads. Devolva só JSON {nome, intencao}. Nunca invente."

# b) Via API (por requisição):
# "messages": [{"role": "system", "content": "Você extrai leads..."},
#              {"role": "user", "content": "..."}]

# c) Permanente, no Modelfile — o jeito de produção (veja seção 6).

Evidência real (mesmo input, "Pedro da Auto Peças Silva, quero preço"):

SEM system (cru): "Olá Pedro! Muito bom vê-lo aqui. Aqui estão algumas dicas..." — inútil para um sistema.
COM system: {"nome": "Pedro", "intencao": "orcamento", ...} — usável por qualquer automação.

5. Few-shot — Ensinar pelo Exemplo

Modelos pequenos aprendem muito mais com exemplos do que com instruções abstratas. Colocar 2 a 5 pares de entrada→saída no prompt é a maior alavanca de qualidade que você tem.

MESSAGE user Oi, aqui é a Ana da Clínica Sorriso, meu agente tá fora do ar!
MESSAGE assistant {"nome": "Ana", "empresa": "Clinica Sorriso", "intencao": "suporte", "urgencia": "alta"}

Foram esses exemplos que fizeram o modelo devolver JSON em vez de prosa. Quer que ele separe melhor nome de empresa? Adicione exemplos que mostrem exatamente isso.

6. JSON Forçado — A Saída Não Escapa do Formato

O campo format da API do Ollama obriga a resposta a seguir um schema JSON. Isso elimina JSON quebrado e valores inventados.

"format": {
  "type": "object",
  "properties": {
    "nome": {"type": "string"},
    "intencao": {"type": "string", "enum": ["orcamento", "suporte", "cancelamento"]},
    "urgencia": {"type": "string", "enum": ["alta", "media", "baixa"]}
  },
  "required": ["nome", "intencao", "urgencia"]
}

Evidência real: sem forçar, o modelo copiava os pipes do schema ("intencao": "orcamento|suporte|cancelamento"). Com schema + enum, escolheu o valor certo: "intencao": "orcamento".

7. Modelfile — Crie o SEU Modelo (com nome)

O Modelfile é um arquivo que empacota FROM + parâmetros + system + few-shot num modelo novo. Depois de criado, você usa ollama run nome-do-seu-modelo. Este é o "momento aula": você cria uma IA.

# 1. Crie o arquivo Modelfile
cat > Modelfile << 'EOF'
FROM hf.co/LiquidAI/LFM2.5-1.2B-Instruct-GGUF
PARAMETER temperature 0.1
SYSTEM """Voce extrai leads de agencia de automacao. Devolva SOMENTE JSON:
{"nome":"","empresa":"","intencao":"orcamento|suporte|cancelamento","urgencia":"alta|media|baixa","assunto":""}
Campo ausente = "". Nunca invente. Nada fora do JSON."""
MESSAGE user Oi, aqui e a Ana da Clinica Sorriso, meu agente ta fora do ar!
MESSAGE assistant {"nome":"Ana","empresa":"Clinica Sorriso","intencao":"suporte","urgencia":"alta","assunto":"agente fora do ar!"}
EOF

# 2. Crie o modelo
ollama create extrator-leads -f Modelfile

# 3. Use num caso novo
ollama run extrator-leads "Sou o Pedro da Auto Pecas Silva, quero preco de um agente"

Saída real: {"nome":"Pedro","intencao":"orcamento","urgencia":"media",...} — agora é um extrator de verdade, não um chatbot.

A escada de qualidade (o que provamos):

🚶 Cru → prosa (inútil para sistemas)
📋 + System (Modelfile) → vira JSON
🔒 + JSON forçado → valores válidos
📚 + Few-shot → campos mais precisos

Suba um degrau por vez até ficar bom o bastante. Fine-tuning (seção 9) só se ainda faltar.

8. RAG — Dando Memória Privada ao Modelo

O modelo não sabe nada do seu cliente. RAG (Retrieval-Augmented Generation) busca o trecho certo da sua base e cola no contexto na hora da pergunta.

Peças necessárias: um embedder + a base de dados + o modelo.

# Instale o embedder (roda local, no VPS)
ollama pull nomic-embed-text

# Loop de RAG (guarde este esqueleto):
import requests, numpy as np

def embed(t):
    return requests.post("http://localhost:11434/api/embeddings",
        json={"model": "nomic-embed-text", "prompt": t}).json()["embedding"]

base = [(doc, embed(doc)) for doc in meus_documentos]  # 1x (indexar)

def responder(pergunta):
    q = embed(pergunta)
    top = sorted(base, key=lambda c: -np.dot(q, c[1]))[:3]  # top-3 mais parecidos
    contexto = "\n".join(d for d, _ in top)
    return requests.post("http://localhost:11434/api/chat", json={
        "model": "extrator-leads",
        "messages": [{"role": "system", "content": f"Responda SO com base em:\n{contexto}"},
                     {"role": "user", "content": pergunta}],
        "stream": False}).json()

Evidência real: sem RAG o modelo inventou um preço; com RAG respondeu o dado correto da base. Dica: o número de trechos injetados (top-k) importa — no teste, top-2 perdeu o trecho de preço. Se a resposta veio incompleta, aumente para top-3 ou top-4.

9. Fine-tuning — O Degrau Final (Honesto)

Quando fazer: SÓ depois que System + Few-shot + JSON forçado + RAG não bastarem numa tarefa estreita e repetitiva, E você tiver centenas de exemplos rotulados.

A real: 95% dos casos param nos degraus anteriores.

Aviso duro: fine-tuning NÃO roda neste VPS. Precisa de GPU. Sua máquina é CPU-only.

1. DATASET  → Junte centenas de exemplos num arquivo .jsonl:
              {"input": "msg do cliente...", "output": "{json esperado}"}
2. GPU      → Google Colab (GPU gratis) ou servico de treino
3. TREINO   → LoRA: treina um "adaptador" leve (nao o modelo todo),
              com Unsloth/TRL ou a receita oficial da Liquid (LEAP)
4. EXPORTAR → Converta o resultado pra GGUF
5. TRAZER   →Suba o .gguf pro VPS e crie o modelo:
              FROM ./meu-modelo-treinado.gguf
              ollama create meu-fino -f Modelfile

A diferença em 1 frase: system/few-shot/RAG mudam o comportamento (grátis, na hora); fine-tuning muda os pesos (caro, GPU, dados). Comece sempre pelo barato.

10. Solução Real: Agente de WhatsApp com n8n + Ollama

O caso prático: um fluxo que recebe lead pelo WhatsApp, extrai dados com IA local e salva no CRM. Tudo no seu servidor.

1. Cliente manda msg no WhatsApp
2. → n8n recebe (webhook)                    [ORQUESTRADOR, no seu VPS]
3. → n8n chama a API do 'extrator-leads'     [MOTOR Ollama :11434 + CEREBRO LFM2]
4. ← recebe {nome, empresa, intencao, ...}   (JSON limpo, em ~0,5 s)
5. → n8n grava no CRM (Sheets/Notion/etc)    [DESTINO]
6. → n8n responde o cliente no WhatsApp

O n8n tem integração nativa com Ollama — você adiciona um nó "Ollama Chat Model", seleciona o modelo e configura o prompt. Pronto. 422+ integrações disponíveis.

Onde cada peça mora: apenas o WhatsApp está fora. n8n + Ollama + LFM2 + base rodam no SEU servidor → privado (dado não vai pra OpenAI) e barato (zero custo por mensagem).

Cola Rápida de Comandos

ollama list                                  # O que esta instalado
ollama run extrator-leads "mensagem..."      # Usar seu modelo (one-shot)
ollama run extrator-leads                    # Chat interativo (/bye sai)
ollama create NOME -f Modelfile              # Criar/atualizar um modelo
ollama rm NOME                               # Apagar um modelo
ollama ps                                    # O que esta carregado na RAM agora

# API (o que o n8n/codigo usa):
curl http://localhost:11434/api/chat -d '{
  "model": "extrator-leads",
  "messages": [{"role": "user", "content": "..."}],
  "stream": false
}'

Conclusão

Rodar IA localmente no seu servidor não é só viável — é mais barato, mais privado e mais previsível do que depender de APIs externas.

Você viu neste tutorial:

✅ Como instalar o Ollama em qualquer distribuição Linux
✅ Os 3 jeitos de usar: terminal, API e interface gráfica
✅ Como criar seu próprio modelo com Modelfile
✅ System message, few-shot e JSON forçado na prática
✅ RAG para dar memória privada ao modelo
✅ Uma solução real com n8n + WhatsApp

O ecossistema de IA local está amadurecendo rápido. Ferramentas como Ollama, Open WebUI e n8n formam uma stack poderosa que qualquer desenvolvedor pode montar em algumas horas.

O próximo passo natural: montar o fluxo do n8n ao vivo — é onde o Lego vira uma solução que você consegue vender no dia seguinte.