IA local em VPS acessada por SSH via Termux

Arquitetura típica

O padrão mais usado: uma VPS GPU (ou CPU para modelos pequenos) hospeda o runtime de inferência; o Termux abre um túnel SSH e fala com a API HTTP local (geralmente 127.0.0.1:11434 do Ollama). Nada é exposto à internet pública.

1. Provedor com GPU dedicada ou compartilhada (Hetzner GEX, RunPod, Vast.ai, Lambda).
2. Sistema Debian/Ubuntu LTS, usuário não-root com sudo, firewall ufw permitindo apenas SSH.
3. Runtime de inferência: Ollama (mais simples), llama.cpp (mais leve), vLLM (mais rápido em GPU).
4. Túnel SSH reverso ou local port-forward para acesso seguro a partir do Termux.

Hardening básico da VPS

# Atualiza e instala essenciais
apt update && apt -y upgrade
apt -y install ufw fail2ban curl git unattended-upgrades

# Usuário operacional
adduser ops && usermod -aG sudo ops

# SSH: somente chave, sem root direto
sed -i 's/^#\?PermitRootLogin.*/PermitRootLogin no/' /etc/ssh/sshd_config
sed -i 's/^#\?PasswordAuthentication.*/PasswordAuthentication no/' /etc/ssh/sshd_config
systemctl restart ssh

# Firewall — só SSH público
ufw default deny incoming && ufw default allow outgoing
ufw allow 22/tcp && ufw --force enable

Instalando Ollama

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

# Modelos recomendados (pesos abertos)
ollama pull llama3.1:8b           # geral
ollama pull qwen2.5-coder:7b      # código / scripts
ollama pull mistral-nemo:12b      # raciocínio
ollama pull nomic-embed-text      # embeddings (RAG)

Acesso do Termux por SSH

pkg update && pkg install -y openssh
ssh-keygen -t ed25519 -C "termux"
ssh-copy-id ops@SEU_IP

# Túnel local: porta 11434 do servidor vira 127.0.0.1:11434 no celular
ssh -N -L 11434:127.0.0.1:11434 ops@SEU_IP &

# Testa o endpoint
curl http://127.0.0.1:11434/api/generate \
  -d '{"model":"llama3.1:8b","prompt":"Resuma OWASP Top 10"}'

Por que existe IA local: o contexto que ninguém te conta

Até 2022, rodar um modelo de linguagem de qualidade exigia clusters caríssimos e exclusividade comercial. Quando a Meta liberou o LLaMA (e depois LLaMA 2 com licença aberta), e a comunidade começou a quantizar pesos para 4 e 5 bits via llama.cpp, virou viável carregar modelos de 7 a 13 bilhões de parâmetros em uma única GPU consumer — ou mesmo CPU com 16 GB de RAM. Esse é o ponto de virada que tornou a 'IA local' uma escolha técnica real, não hobby.

Para quem trabalha com pentest, OSINT, antifraude ou pesquisa de segurança, a diferença é estratégica: cada prompt mandado para a OpenAI, Anthropic ou Google é, na prática, exfiltração voluntária. Você está mandando trechos de relatório, dumps de banco, listas de alvos e hipóteses de ataque para um servidor externo que registra logs por política contratual. Mesmo com cláusulas de privacidade, isso fere acordos de confidencialidade típicos de contratos de pentest (NDA, RoE) e pode te tirar do escopo legal.

Dimensionando a VPS: a matemática da VRAM

A regra prática é simples: VRAM necessária ≈ (parâmetros em bilhões) × (bytes por parâmetro) + overhead de contexto. Em quantização Q4_K_M (4 bits aproximados), cada parâmetro consome ~0.5 byte. Então um modelo 8B pesa ~4 GB em VRAM, mais 1-2 GB para o KV-cache do contexto. Um 13B Q4 cabe em 8 GB. Um 70B Q4 precisa de 40 GB ou multi-GPU.

• CPU-only (sem GPU): viável até ~7B Q4 com 16 GB RAM, latência de 5-15 tokens/s — bom para batch, ruim para chat ao vivo.
• RTX 3060 12 GB: confortável para 8B Q5 e 13B Q4 — custo/benefício imbatível para desenvolvedor solo.
• RTX 4090 24 GB: roda 34B Q4 e 70B Q3 com folga; ~80 tokens/s em 8B.
• A100 40/80 GB ou H100: território de produção e fine-tuning; alugue por hora (RunPod, Vast.ai, Lambda) se for esporádico.

Quantização: o truque que tornou tudo possível

Quantização é a arte de representar os pesos do modelo com menos bits sem destruir a qualidade. Os formatos GGUF (sucessor do GGML) suportam variantes Q2 a Q8. Na prática: Q4_K_M é o sweet spot — perda de qualidade praticamente imperceptível em tarefas de raciocínio e código, com 4x menos VRAM que FP16.

• Q2_K — agressivo, só use para experimentos; perceptível degradação.
• Q4_K_M — recomendado para uso geral; 95-98% da qualidade do FP16.
• Q5_K_M — quando sobra VRAM e você quer margem em prompts longos.
• Q8_0 — quase idêntico ao FP16; útil quando o modelo é pequeno (≤3B).
• FP16/BF16 — sem quantização; para fine-tuning ou alvo de avaliação.

Ollama, llama.cpp e vLLM: quando usar cada um

Ollama é um wrapper amigável sobre llama.cpp com gerenciamento automático de modelos, API HTTP estilo OpenAI e suporte a Modelfiles (system prompts versionados). Para 90% dos casos de pesquisa pessoal, é a escolha certa. llama.cpp puro entrega controle fino — flags de mmap, locked memory, batch size, tensor split entre GPUs — e é a base de quase tudo. vLLM brilha em produção: paged attention, continuous batching, throughput 5-10x maior em GPUs A100/H100 servindo múltiplos usuários em paralelo.

# Salve como Modelfile
FROM llama3.1:8b
PARAMETER temperature 0.3
PARAMETER num_ctx 8192
SYSTEM """
Você é um assistente sênior de pentest e Red Team. Sempre:
- Cite a fase PTES correspondente
- Sugira o comando exato (com flags) para Termux/Linux
- Avise sobre requisitos de autorização legal
- Nunca execute nada — apenas oriente
"""

# Construa
ollama create pentest-helper -f Modelfile
ollama run pentest-helper "Tenho /24 autorizado. Como faço varredura discreta?"

RAG privado: dando memória ao modelo

RAG (Retrieval-Augmented Generation) é o padrão para o modelo 'lembrar' do seu conhecimento — relatórios anteriores, anotações de OSINT, transcrições de reuniões. O fluxo é: (1) dividir documentos em chunks de 500-1000 tokens; (2) gerar embeddings com nomic-embed-text ou bge-large; (3) armazenar em um vetor — sqlite-vss para projetos pessoais, Qdrant ou Weaviate para escala; (4) na hora da pergunta, buscar os top-k chunks similares e enviar como contexto ao LLM.

pip install ollama sqlite-vss
python <<'PY'
import ollama, sqlite3
db = sqlite3.connect('rag.db')
db.enable_load_extension(True); db.load_extension('vss0')
db.execute("create virtual table if not exists docs using vss0(emb(768))")
# indexar
for chunk in open('relatorio.md').read().split('\n\n'):
    e = ollama.embeddings(model='nomic-embed-text', prompt=chunk)['embedding']
    db.execute("insert into docs(rowid, emb) values (?, ?)", (hash(chunk)&0xfffffff, str(e)))
PY

Observabilidade e custo operacional

• Use 'nvidia-smi dmon' ou 'nvtop' para acompanhar VRAM e potência em tempo real.
• Logue cada prompt/resposta com timestamp e modelo num SQLite local — vira dataset de fine-tuning depois.
• Configure alerta de temperatura (>83°C em GPU consumer) para evitar throttling silencioso.
• Crie um cron que desliga a VPS após N minutos ociosos — economia de 60-80% no custo mensal.

Riscos, armadilhas e o que evita dor de cabeça

• Modelos podem alucinar comandos perigosos — sempre revise antes de executar (ainda mais 'sudo', 'rm', 'iptables').
• Pesos baixados de fontes não-oficiais podem conter código malicioso embarcado no Modelfile — baixe só de ollama.com/library ou HuggingFace verificado.
• Logs do Ollama (em ~/.ollama/logs) guardam prompts em texto puro; rote-os e criptografe a partição.
• Quantização agressiva (Q2/Q3) silenciosamente degrada raciocínio matemático e código — teste antes de confiar.

Roteiro prático: do zero ao primeiro prompt em 15 minutos

1. Alugue VPS com GPU (RunPod 'Community Cloud' RTX 3090 ~US$ 0,22/h é ideal para começar).
2. Conecte via SSH e rode o bloco de hardening acima.
3. Instale Ollama e baixe llama3.1:8b (cerca de 4,7 GB — leva 2-3 minutos).
4. No Termux, gere chave ed25519 e copie a chave pública para o servidor.
5. Abra túnel local: ssh -N -L 11434:127.0.0.1:11434 ops@SEU_IP.
6. Teste com curl no celular — se responder, você tem GPT pessoal pelo celular.
7. Crie um Modelfile com seu system prompt e versione no git pessoal.