Sovereign & Private AI 2026

IA Local & Inferência de Borda de Alta Performance

Rode pesos abertos na sua máquina ou num servidor privado: Ollama, vLLM, GGUF e uma stack que não manda o prompt para fora.

Stack Privativa Zero Cloud Dependency
Engine Rápido: Ollama CLI / Desktop
Alta Produção: vLLM (Continuous Batching)
Pesos abertos: Llama 4, Gemma 4, Qwen, DeepSeek
Formatos Otimizados: GGUF (Q4_K_M) / AWQ
100% Privado

Dados confidenciais nunca saem da rede

R$ 0,00

Custo por token em escala

> 120 t/s

Velocidade de geração com vLLM

OpenAPI Native

Compatível com /v1/chat/completions

Soberania & Economia

1. Por Que Rodar Modelos de IA Localmente?

Pesos abertos é que tornam a inferência local viável. Em setembro de 2026 os nomes que mais aparecem em quadro público são Llama 4, Gemma 4 e gpt-oss, além de Qwen e DeepSeek na versão que o model card ainda recomenda. Ollama e vLLM continuam os dois runtimes práticos. A escolha é o card do modelo, não um apelido de 2024.

Conformidade & LGPD

Segurança máxima para dados médicos, financeiros ou código proprietário sem risco de vazamento para nuvens externas.

Custo Zero por Token

Pipelines de automação em lote, agentes de código e bots internos rodam ilimitadamente sem surpresas na fatura.

Operação 100% Offline

Sistemas industriais, submarinos, hospitais ou trabalho em campo operam perfeitamente sem conexão com a internet.

Desenvolvimento Rápido

2. Ollama: Execução Prática e Modelfiles Personalizados

O Ollama é a forma mais simples e robusta de rodar LLMs no macOS (com aceleração Metal), Linux e Windows (com CUDA/ROCm).

Comandos Essenciais no Terminal:

# Exemplos de tag. O nome atual está em https://ollama.com/library
ollama run deepseek-r1:8b
ollama run qwen2.5-coder:7b

# Listar modelos instalados localmente
ollama list

# O Ollama expõe automaticamente uma API REST compatível com OpenAI na porta 11434
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-r1:8b",
    "messages": [{"role": "user", "content": "Explique o algoritmo Raft em 3 frases."}]
  }'

Criando um Modelo Especializado com Modelfile

Crie um arquivo chamado Modelfile para definir system prompts imutáveis, temperatura e parâmetros de amostragem:

FROM qwen2.5-coder:7b

# Parâmetros de Inferência
PARAMETER temperature 0.2
PARAMETER top_p 0.95
PARAMETER stop "```"

# System Prompt Especialista
SYSTEM """
Você é um Arquiteto de Software Sênior especializado em TypeScript, Rust e Docker.
Responda sempre com código estritamente tipado e testes unitários.
Nunca faça suposições sem validar contratos de schema.
"""
# Compilar e criar o modelo customizado
ollama create dev-senior -f ./Modelfile
ollama run dev-senior
Escala de Produção

3. vLLM: Inferência de Altíssimo Throughput com PagedAttention

Enquanto o Ollama é ideal para desenvolvimento individual, o vLLM é o padrão da indústria para servir APIs de IA em servidores de produção com múltiplos usuários concorrentes. Seu mecanismo inovador de PagedAttention gerencia a memória KV Cache como memória virtual de sistema operacional, aumentando o throughput em até 24x.

Iniciando um Servidor vLLM de Produção (OpenAI Compatible):

# Instalação com suporte a CUDA
pip install vllm

# Subir servidor para atender múltiplos clientes concorrentes na porta 8000
python3 -m vllm.entrypoints.openai.api_server \
  --model deepseek-ai/DeepSeek-R1-Distill-Qwen-14B \
  --tensor-parallel-size 1 \
  --max-model-len 8192 \
  --gpu-memory-utilization 0.90 \
  --port 8000
Hardware & Eficiência

4. Guia de Quantização: GGUF vs AWQ e Dimensionamento de VRAM

Modelos de IA em precisão total (FP16 ou BF16) exigem cerca de 2 GB de VRAM por bilhão de parâmetros. A quantização para 4-bit ou 8-bit comprime o modelo em até 75% com perda praticamente imperceptível de qualidade (< 1% de degradação semântica).

Formato de Quantização Tamanho do Modelo VRAM Mínima Recomendada Acelerador Indicado
GGUF (Q4_K_M) 7B / 8B parâmetros ~6 GB VRAM ou RAM unificada CPU + GPU (Apple Silicon / RTX 3060/4060)
GGUF (Q4_K_M) 14B parâmetros ~10 GB VRAM RTX 3060 12GB / RTX 4070 / Apple M2/M3 Pro
AWQ / GPTQ (4-bit) 32B / 70B parâmetros ~24 GB a 48 GB VRAM 1x ou 2x NVIDIA RTX 3090 / 4090 / A100
Calculadora Interativa de VRAM & Hardware Simulação em Tempo Real
Pesos do Modelo 7.88 GB
KV Cache Estimado 1.05 GB
VRAM Total Recomendada 10.27 GB
Hardware Ideal: RTX 3060 12GB / Apple M2 Pro 16GB
Integração de Agentes

5. Chamada de Ferramentas (Function Calling) com Modelos Locais

Modelos com saída JSON estável (Llama 4, Gemma 4, Qwen recente e outros do card que você baixou) executam ferramentas. O agente local chama API ou script sem sair da máquina.

Exemplo com OpenAI SDK apontando para o servidor local:

from openai import OpenAI

# Conexão direta com a instância local (Ollama ou vLLM)
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama" # Não requer autenticação externa
)

# Definição do schema da ferramenta
tools = [
    {
        "type": "function",
        "function": {
            "name": "consultar_saldo_bancario",
            "description": "Retorna o saldo bancário da conta corrente do cliente",
            "parameters": {
                "type": "object",
                "properties": {
                    "conta_id": {"type": "string", "description": "ID da conta corrente"}
                },
                "required": ["conta_id"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="qwen2.5:7b",
    messages=[{"role": "user", "content": "Qual é o saldo da conta C-9821?"}],
    tools=tools
)

print(response.choices[0].message.tool_calls)
Deploy Pronto

6. Stack Completa Privativa: Ollama + Open WebUI + Qdrant

Suba uma infraestrutura completa de ChatGPT privado com busca em documentos (RAG) e banco vetorial com um único comando docker compose up -d:

services:
  # 1. Engine de Inferência Ollama
  ollama:
    image: ollama/ollama:latest
    container_name: local_ai_ollama
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    # Descomente para suporte a GPU NVIDIA:
    # deploy:
    #   resources:
    #     reservations:
    #       devices:
    #         - driver: nvidia
    #           count: all
    #           capabilities: [gpu]

  # 2. Interface Visual estilo ChatGPT com RAG nativo
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: local_ai_webui
    restart: unless-stopped
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    volumes:
      - open_webui_data:/app/backend/data
    depends_on:
      - ollama

  # 3. Banco Vetorial para RAG Corporativo
  qdrant:
    image: qdrant/qdrant:latest
    container_name: local_ai_qdrant
    restart: unless-stopped
    ports:
      - "6333:6333"
    volumes:
      - qdrant_data:/qdrant/storage

volumes:
  ollama_data:
  open_webui_data:
  qdrant_data:
Hardware & Edge

7. Deploy em Mini PC & SBC: IA Privativa de Baixo Custo

Você não precisa de servidores caros na nuvem ou GPUs de data center para ter uma infraestrutura completa de IA privativa. Um Mini PC (Intel N100 / AMD Ryzen) ou SBC (Raspberry Pi 5 / Orange Pi 5) com consumo elétrico de apenas 6W a 15W pode operar 24/7 como servidor de IA, RAG corporativo e host da Central de Guias PWA offline.

Categoria de Dispositivo Exemplo de Hardware Faixa de Preço Modelos Recomendados Desempenho Real
Sweet Spot (Mini PC) Intel N100 / N95 / N97 (4 cores, 16 GB RAM DDR4/DDR5, 512 GB NVMe) R$ 700 – R$ 1.100 deepseek-r1:8b, qwen2.5-coder:7b, llama3.2:3b 6 a 12 tokens/s (Fluido para chat, dev e RAG local)
Ultra-Baixo Custo (SBC) Raspberry Pi 5 (8 GB) ou Orange Pi 5 (8 GB/16 GB RK3588 NPU) R$ 350 – R$ 650 llama3.2:1b, llama3.2:3b, qwen2.5:1.5b, phi-4-mini 8 a 15 tokens/s (Perfeito para agentes e bots)
Alto Throughput (Mini PC) AMD Ryzen 7 (5700U / 7730U / 7840HS, 32 GB DDR5, iGPU Radeon) R$ 1.800 – R$ 2.600 qwen2.5:14b, deepseek-r1:14b, mistral-nemo:12b 18 a 28 tokens/s (Velocidade de leitura humana rápida)

Stack Docker Compose Completa para Mini PC (IA + RAG + Guias PWA):

services:
  # 1. Motor de Inferência Ollama (CPU/iGPU)
  ollama:
    image: ollama/ollama:latest
    container_name: minipc_ollama
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - ./ollama_data:/root/.ollama

  # 2. Interface ChatGPT Privada com RAG
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: minipc_webui
    restart: unless-stopped
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    volumes:
      - ./webui_data:/app/backend/data
    depends_on:
      - ollama

  # 3. Banco Vetorial Qdrant para Busca Semântica
  qdrant:
    image: qdrant/qdrant:latest
    container_name: minipc_qdrant
    restart: unless-stopped
    ports:
      - "6333:6333"
    volumes:
      - ./qdrant_data:/qdrant/storage

  # 4. Servidor da Central de Guias PWA na Rede Local
  guias-pwa:
    image: nginx:alpine
    container_name: minipc_guias_pwa
    restart: unless-stopped
    ports:
      - "80:80"
    volumes:
      - ./guias:/usr/share/nginx/html:ro

Comandos de Inicialização Rápida no Mini PC:

# 1. Instalar Docker e Docker Compose no Ubuntu/Debian do Mini PC
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER

# 2. Subir todos os serviços com um único comando
docker compose up -d

# 3. Baixar os modelos recomendados dentro do container Ollama
docker exec -it minipc_ollama ollama pull deepseek-r1:8b
docker exec -it minipc_ollama ollama pull qwen2.5-coder:7b
docker exec -it minipc_ollama ollama pull nomic-embed-text

# 4. Acessar na sua rede local (Wi-Fi / Ethernet):
# - Central de Guias PWA: http://minipc.local (Porta 80)
# - Chatbot & RAG: http://minipc.local:3000 (Porta 3000)
# - API de Inferência: http://minipc.local:11434/v1 (Compatível com OpenAI)