Como rodar seu próprio LLM localmente: guia completo com Ollama e Qwen 3

O que mudou em 2026: LLMs locais finalmente são viáveis

Há dois anos, rodar um modelo de linguagem de 8 bilhões de parâmetros localmente exigia uma workstation com GPU dedicada de pelo menos 24 GB de VRAM, configuração complexa de drivers CUDA e um investimento mínimo de R$ 15.000 em hardware. Hoje, você faz o mesmo em um MacBook Air M4 de 24 GB — um laptop ultrafino que pesa 1,24 kg — com apenas 5 GB de espaço em disco e zero configuração de GPU.

Esta é a maior transformação silenciosa da inteligência artificial em 2026: a democratização real dos LLMs. Não é mais sobre “será que roda?”, mas sobre “qual modelo escolher para qual tarefa?”

Neste guia, você vai transformar seu computador em um servidor de IA privado em menos de 15 minutos. Sem APIs, sem assinaturas mensais, sem enviar seus dados para servidores de terceiros. Apenas você, seu hardware e um modelo open source de ponta.

Por que rodar um LLM local em 2026?

Antes de abrir o terminal, entenda o que você ganha — e o que não ganha — com um setup local.

✅ O que você ganha

• Soberania digital total: seus dados nunca saem da máquina. Desligue o Wi-Fi e o modelo continua funcionando. Sem chaves de API para gerenciar, sem termos de serviço que mudam da noite para o dia, sem políticas de retenção de dados obscuras.
• Custo zero por uso: depois da instalação, cada prompt é gratuito. Compare com APIs cloud: GPT-4o custa US$ 2,50 por milhão de tokens de input; o Qwen 3 8B local custa exatamente zero — apenas o consumo elétrico do seu computador.
• Latência previsível: sem filas de servidor, sem rate limiting, sem “serviço temporariamente indisponível”. A resposta chega em velocidade constante de 15-20 tokens por segundo no MacBook M4.
• Independência de infraestrutura: sem risco de bloqueio de acesso, interrupção de serviço, mudança de preços ou descontinuação de modelo. SeuLLM local é seu para sempre.
• Privacidade real para dados sensíveis: contratos, código proprietário, dados de pacientes, estratégias de negócio — nada disso pertence a um servidor de terceiros. Com um modelo local, a garantia é arquitetural, não contratual.

⚠️ O que você NÃO ganha (e tudo bem)

• Desempenho de modelo de fronteira: o Qwen 3 8B não compete com GPT-4o ou Claude Opus em raciocínio complexo ou criatividade literária. Mas para sumarização, geração de código, chat técnico e análise de documentos — tarefas que representam 80% do uso diário — ele entrega com folga.
• Conhecimento enciclopédico: modelos locais rodam com pesos congelados. Não sabem o que aconteceu depois do cutoff de treino. Para fatos recentes, combine com RAG (Retrieval-Augmented Generation) ou use a busca web integrada do Ollama (com ressalvas de privacidade — veja abaixo).
• Plug-and-play total: a instalação leva 15 minutos, mas entender os parâmetros (context window, temperatura, quantização) exige alguma curva de aprendizado. Este guia cobre o essencial.

Hardware: o que você precisa (e o que não precisa)

💡 Surpresa para usuários Windows/Linux: o guia original usa Mac, mas todo o fluxo funciona identicamente em Windows (via WSL2) e Linux. O Ollama detecta automaticamente a GPU disponível — NVIDIA CUDA no Linux/Windows, Metal no macOS, e até ROCm para GPUs AMD.

Passo a passo completo da instalação

Cada comando abaixo é executado no Terminal (macOS/Linux) ou WSL2 (Windows). Não pule etapas — a ordem importa.

1. Instalar o Ollama (sem Homebrew)

O Ollama é um framework open source que combina três componentes em um único binário: o motor de inferência llama.cpp com aceleração GPU via Metal da Apple, um registro de modelos no estilo Docker (ollama pull, ollama list), e uma API HTTP REST pronta para produção em localhost:11434.

Por que sem Homebrew? O download direto garante a versão mais recente, evita conflitos de dependências do Homebrew e instala em ~30 segundos.

cd ~/Downloads
curl -L -o Ollama-darwin.zip https://ollama.com/download/Ollama-darwin.zip
unzip -o -q Ollama-darwin.zip
mv Ollama.app /Applications/

🪟 Usuários Windows: baixe o instalador .msi em ollama.com/download/windows. O instalador configura o PATH e registra o serviço automaticamente.

🐧 Usuários Linux:

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

2. Configurar o PATH

O binário do Ollama fica dentro do .app bundle do macOS. Para acessá-lo de qualquer lugar no terminal:

mkdir -p ~/.local/bin
ln -sf /Applications/Ollama.app/Contents/Resources/ollama ~/.local/bin/ollama
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc
export PATH="$HOME/.local/bin:$PATH"

🔍 Verificação rápida: feche e reabra o terminal, depois execute:

ollama --version
# Deve retornar: ollama version 0.13.x (ou superior)

3. Iniciar o servidor Ollama

O Ollama roda como um servidor HTTP em background. O comando nohup mantém o processo vivo mesmo se você fechar o terminal:

mkdir -p ~/.ollama/logs
nohup ollama serve > ~/.ollama/logs/serve.log 2>&1 &
curl -s http://127.0.0.1:11434/api/version

Se o curl retornar {"version":"0.13.x"}, o servidor está no ar. O log fica em ~/.ollama/logs/serve.log para debugging.

🔄 Para iniciar automaticamente no boot (macOS):

# Crie um LaunchAgent para iniciar o Ollama no login
cat > ~/Library/LaunchAgents/com.ollama.serve.plist << 'EOF'
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.ollama.serve</string>
    <key>ProgramArguments</key>
    <array>
        <string>/Users/seu-usuario/.local/bin/ollama</string>
        <string>serve</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
</dict>
</plist>
EOF
launchctl load ~/Library/LaunchAgents/com.ollama.serve.plist

4. Baixar o modelo Qwen 3 8B

Este é o passo mais demorado — o download tem 5,2 GB. Com uma conexão de 100 Mbps, leva cerca de 7 minutos.

ollama pull qwen3:8b

O que é o Qwen 3? Desenvolvido pelo Alibaba, é um modelo de raciocínio híbrido: ele pode operar em dois modos — "pensar" (cadeia de raciocínio interna, tokens <think>) ou responder diretamente. São 8 bilhões de parâmetros com janela de contexto de 32K tokens nativa, suporte multilíngue (incluindo português excelente) e licença Apache 2.0 — pode usar comercialmente sem restrições.

⚡ Quanto ocupa? Cerca de 6 GB em memória RAM quando carregado. Nos 24 GB do MacBook M4, sobram 18 GB confortáveis para o sistema e outros aplicativos.

🔢 Modelos alternativos que você pode testar depois:

5. Interagir com o modelo

Três modos de interação, do mais simples ao mais poderoso:

Modo 1: Chat interativo (terminal)

ollama run qwen3:8b

Digite suas mensagens e pressione Enter. Para sair: /bye ou Ctrl+D. O chat mantém contexto da conversa.

Modo 2: Comando único (one-shot)

ollama run qwen3:8b "Explique o padrão de design Observer em Python com um exemplo prático"

Ideal para scripts, automações e respostas rápidas. O modelo processa, responde e encerra.

Modo 3: API HTTP (produção)

Endpoint REST completo em http://127.0.0.1:11434/api/generate. Compatível com OpenAI API via adaptadores como litellm ou open-webui.

# Exemplo com curl
curl -s http://127.0.0.1:11434/api/generate -d '{
  "model": "qwen3:8b",
  "prompt": "Gere um script Python para validar CPF",
  "stream": false
}' | python3 -c "import sys,json; print(json.load(sys.stdin)['response'])"

⚡ Performance:

• Modo economia de bateria (MacBook Air M4): ~5,7 tokens/segundo
• Desempenho máximo (alimentado): 15-20 tokens/segundo
• Contexto: para referência, o GPT-4o entrega ~80 tokens/s via API — mas você paga por cada um deles.

Ajustes essenciais para o Qwen 3

Desabilitar tokens de pensamento (<think>)

O Qwen 3 é um modelo de raciocínio híbrido — por padrão, ele gera tokens internos de pensamento (<think>...</think>) antes de cada resposta. Esses tokens são úteis para tarefas complexas de raciocínio (matemática, lógica, debugging), mas poluem a saída em conversas comuns.

No chat interativo:

ollama run qwen3:8b --think=false

Via API (Python):

import requests, json

response = requests.post("http://127.0.0.1:11434/api/generate", json={
    "model": "qwen3:8b",
    "prompt": "Qual a capital da Noruega?",
    "stream": False,
    "options": {"think": False}
})
print(json.loads(response.text)["response"])

⚠️ Alerta de privacidade: busca web do Ollama

O Ollama oferece integração com ferramenta de busca (/search no chat interativo), mas atenção: as consultas de busca são enviadas para o serviço em nuvem do Ollama, não processadas localmente. Se você desligou o Wi-Fi justamente para garantir privacidade, não use esse recurso — ele quebra completamente o isolamento do setup local.

Alternativa segura: use um servidor RAG local com llama-index ou langchain + embeddings locais (ex: nomic-embed-text via Ollama).

Integração com VS Code: assistente de código offline

O ecossistema de plugins para desenvolvimento local com LLMs explodiu em 2026. A extensão Continue.dev (open source, MIT) é a melhor opção para VS Code — ela transforma o Qwen 3 no seu par de programação offline.

# 1. Instale a extensão no VS Code
#    Extensions (Cmd+Shift+X) → busque "Continue" → Install

# 2. Configure o arquivo ~/.continue/config.yaml
#    (o Continue cria este arquivo na primeira execução)

# 3. Edite o config.yaml com este bloco:

models:
  - name: Qwen 3 8B (local)
    provider: ollama
    model: qwen3:8b
    apiBase: http://127.0.0.1:11434
    roles:
      - chat       # conversa geral sobre código
      - autocomplete  # sugestões inline
      - apply      # aplicar edições sugeridas
    requestOptions:
      think: false  # respostas diretas, sem tokens de pensamento

# Opcional: modelo de embeddings local para busca de contexto
embeddingsProvider:
  provider: ollama
  model: nomic-embed-text  # baixe com: ollama pull nomic-embed-text

O que você ganha com essa integração:

• Autocomplete offline: sugestões de código inline sem latência de rede
• Chat no editor: selecione código, pressione Cmd+L, faça perguntas sobre ele
• Edições inline: peça "refatore esta função para usar async/await" e o Continue aplica a mudança
• Indexação local: com embeddings, o modelo entende o contexto de TODO o seu projeto
• Custo: zero. Nenhum token enviado para servidor externo.

Casos de uso reais (além do chat)

Um LLM local não substitui só o ChatGPT. Ele habilita fluxos de trabalho inteiros que antes dependiam de serviços cloud:

📄 Análise de documentos offline

Contratos, PDFs, laudos médicos — processe tudo localmente com llama-index + Qwen 3. Sem vazar dados confidenciais para APIs de terceiros.

🖥️ Automação de terminal

Pipes Unix com IA: cat error.log | ollama run qwen3:8b "explique este erro em português"

📧 Classificação de e-mails

Rode localmente um classificador de e-mails que entende português, sem enviar suas mensagens para o Google ou Microsoft.

🎓 Tutor de programação offline

Estudando em um voo ou local sem internet? O Qwen 3 vira seu professor particular de Python, Rust, ou qualquer linguagem.

🏢 ERP com IA privada

Integre o endpoint localhost:11434 com sistemas internos da empresa. A IA roda on-premise, dentro da rede corporativa.

Custo real: Local vs. Cloud (comparação honesta)

O custo de energia de um MacBook M4 rodando inferência contínua é de aproximadamente R$ 0,15 por hora (considerando tarifa média brasileira de R$ 0,75/kWh e consumo de ~15W do chip M4 sob carga).

Solução de problemas comuns

❌ "ollama: command not found"

Causa: PATH não configurado ou terminal não recarregado.
Solução: execute source ~/.zshrc ou source ~/.bashrc e tente novamente.

❌ "Error: listen tcp 127.0.0.1:11434: bind: address already in use"

Causa: outra instância do Ollama já está rodando.
Solução:pkill ollama && sleep 2 && ollama serve

❌ Modelo muito lento ou travando

Causa: RAM insuficiente — outros apps competindo por memória.
Solução: feche navegadores com muitas abas, Docker, ou IDEs pesadas. Verifique com htop ou Monitor de Atividade.

❌ "Error: model requires more system memory"

Causa: tentou rodar um modelo maior do que sua RAM suporta.
Solução: use a versão quantizada menor: ollama pull qwen3:8b-q4_K_M (ocupa ~5 GB em vez de 6 GB).

❌ Respostas em inglês mesmo com prompts em português

Causa: o modelo não recebeu contexto suficiente do idioma.
Solução: comece o prompt com "Responda em português brasileiro:" ou configure o system prompt via API.

A tendência é irreversível

Em janeiro de 2024, rodar um LLM de 7B localmente exigia uma RTX 4090 (24 GB VRAM, ~R$ 12.000). Em julho de 2026, o mesmo acontece em um laptop de R$ 8.000 que cabe na mochila. A cada 12 meses, a barreira de hardware cai pela metade.

O guia do cientista de dados Ivo Bernardo captura este momento de inflexão: IA privada e offline saiu do laboratório e chegou ao usuário comum. O Qwen 3 com Ollama é a combinação mais acessível hoje, mas a direção é clara — em 2027, modelos de 32B rodarão em celulares.

O futuro da IA não está apenas nos data centers. Parte dele já está no seu computador, esperando você apertar Enter.

Perguntas frequentes (FAQ)

Preciso de placa de vídeo dedicada?

Não. O Ollama usa GPU integrada (Apple Metal, Intel iGPU) e até CPU pura como fallback. A GPU dedicada acelera, mas não é obrigatória.

Posso rodar em um PC com 8 GB de RAM?

Modelos de 1.5B-3B (como Qwen 3 1.5B ou Gemma 3 1B) rodam em 8 GB. O Qwen 3 8B exige pelo menos 16 GB.

Dá para usar em produção?

Sim — o endpoint localhost:11434 é uma API HTTP padrão. Empresas usam Ollama atrás de balanceadores de carga para servir modelos open source internamente.

O modelo entende português brasileiro?

Excelentemente bem. O Qwen 3 foi treinado com dados multilíngues e performa em português muito acima da média dos modelos open source ocidentais.

Como atualizar o modelo?

ollama pull qwen3:8b — o Ollama baixa apenas o delta (camadas modificadas), como um docker pull.

Posso rodar vários modelos ao mesmo tempo?

Sim, cada um consome sua própria fatia de RAM. Com 24 GB, você mantém 2-3 modelos de 8B carregados simultaneamente.

Este guia é baseado no tutorial publicado por Ivo Bernardo, com expansões, dados comparativos e fluxos adicionais pela equipe do NoticIA. O objetivo é oferecer um recurso completo para quem quer sair do zero à produção com LLMs locais em 2026.