Como usar o Ollama: IA local no seu computador sem assinaturas

Índice

• O que é o Ollama (e o que não é)
• Por que rodar IA localmente pode valer a pena para o seu negócio

  • Seus dados não saem do computador
  • O custo para de crescer com o uso
  • Funciona offline e sem depender de um provedor
  • Quando não compensa
• Qual hardware você precisa para rodar um LLM local

  • CPU, GPU NVIDIA ou Apple Silicon
  • O que é quantização
  • Como calcular a memória necessária
• Qual modelo instalar primeiro
• Como instalar o Ollama passo a passo

  • No macOS
  • No Windows
  • No Linux
• Os comandos essenciais do Ollama
• Como personalizar um modelo com um Modelfile
• Como usar a API local do Ollama (porta 11434)

  • Conectar a editores e agentes de código
  • Conectar ao Open WebUI, ao Docker ou a outros computadores da rede
• Ollama vs LM Studio vs Jan: qual escolher
• Calcule quanto você economiza
• O que fica

A resposta curta: o Ollama é um programa gratuito que baixa modelos de IA abertos e os executa no seu próprio computador. Você instala em poucos minutos, baixa um modelo com um comando e ganha um chat e uma API local que não enviam nada para servidores de terceiros. O que define se ele vai bem não é o processador: é quanta memória você tem para carregar o modelo.

Este guia cobre o caminho completo: por que uma pequena empresa ou uma startup iria querer rodar IA localmente, qual hardware você precisa, como instalar e configurar o Ollama, como conectá-lo a outras ferramentas e quando o LM Studio ou o Jan fazem mais sentido. Se o que você procura é qual modelo instalar, isso está em detalhe em Melhores modelos do Ollama em 2026.

O que é o Ollama (e o que não é)

O Ollama é um motor que empacota, baixa e serve modelos de linguagem localmente. Ele se instala como um serviço em segundo plano e oferece três formas de uso:

• O terminal, com comandos como ollama run e ollama pull.
• Um app de desktop com chat no Mac e no Windows (no Linux, só terminal).
• Uma API HTTP em http://localhost:11434, compatível com o formato da OpenAI, para conectar editores, automações ou seus próprios apps.

O que ele não é: o Ollama não é um modelo. É o programa que roda modelos de terceiros: Qwen, Gemma, gpt-oss, Llama, DeepSeek e outros. A qualidade das respostas depende do modelo que você escolher e do seu hardware.

Por que rodar IA localmente pode valer a pena para o seu negócio

Para uma pequena empresa ou uma startup no começo, a IA local não é modismo técnico. Ela resolve três problemas concretos do modelo de assinatura.

Seus dados não saem do computador

Quando você usa o Ollama localmente, o prompt e a resposta são processados na sua máquina. Não há um provedor guardando conversas nem políticas de uso de dados para ler com lupa. Isso importa quando você trabalha com código-fonte próprio, modelos financeiros, contratos ou bases de clientes, que é justamente o que você não deveria colar num chat público (explico isso em o que não compartilhar com o ChatGPT).

A privacidade local tem um limite: ela protege o dado enquanto ele está no seu computador. Se o disco não está criptografado ou meio time divide a máquina, o risco muda de lugar; não desaparece.

O custo para de crescer com o uso

Numa API comercial você paga por token: quanto mais automatiza, mais paga. Com um modelo local, o custo já foi feito (o equipamento), e cada consulta a mais custa o que consome de eletricidade. Sem limites de uso por hora e sem surpresas na fatura do fim do mês.

Isso não quer dizer que seja de graça. Entram na conta o hardware, o tempo de configuração e o fato de que um modelo local de 9B não rende como um de fronteira. Comparo os cenários com números em preços reais da IA em 2026.

Funciona offline e sem depender de um provedor

Um modelo local continua respondendo quando a internet cai ou o provedor tem uma interrupção. Para processos em lote (classificar centenas de e-mails, extrair dados de notas fiscais, resumir documentos internos) isso significa poder deixá-lo trabalhando sem se preocupar com cotas nem quedas.

Quando não compensa

Seja honesto com a tarefa. Se você precisa de raciocínio longo, de um agente programando num repositório grande ou de respostas em que um erro custa dinheiro, um modelo de fronteira na nuvem continua sendo melhor. A estratégia mais sensata para a maioria é mista: local para o volume e o que é sensível, nuvem para o que é difícil. É a mesma lógica de não depender de um único provedor de IA.

Qual hardware você precisa para rodar um LLM local

A pergunta-chave não é qual processador você tem, e sim quanta memória o modelo pode usar e com que velocidade os dados se movem dentro dessa memória.

CPU, GPU NVIDIA ou Apple Silicon

• Só CPU (x86): serve para testar e para modelos pequenos de 2B a 4B. Funciona, mas devagar, porque a RAM do sistema tem pouca largura de banda.
• GPU NVIDIA: a opção mais rápida em tokens por segundo, desde que o modelo caiba na VRAM da placa. Se não couber, o Ollama divide camadas entre GPU e CPU, e a velocidade cai muito.
• Apple Silicon (M1 a M4): a memória é unificada, então a GPU pode usar boa parte da RAM do computador. Um MacBook Pro com 64 ou 128 GB carrega modelos que num PC exigiriam várias placas de vídeo. É mais lento que uma NVIDIA topo de linha com o mesmo modelo, mas chega a tamanhos que o PC não alcança.

O que é quantização

A quantização reduz a precisão dos pesos do modelo para que ele ocupe menos memória. Os níveis que você vai ver:

• FP16: precisão completa, 2 bytes por parâmetro. Fidelidade máxima, muita memória.
• Q8: 8 bits, 1 byte por parâmetro. Metade da memória e uma perda de qualidade quase imperceptível.
• Q4_K_M: 4 bits, cerca de 0,5 byte por parâmetro. Um quarto da memória do FP16 e o padrão prático para uso local. A qualidade cai um pouco, mas em tarefas do dia a dia mal se nota.

Quase todos os modelos do Ollama são baixados em Q4 por padrão. No guia de modelos explico as variantes QAT e MLX, que melhoram esse equilíbrio.

Como calcular a memória necessária

Uma regra rápida:

Memória (GB) ≈ parâmetros em bilhões × bytes por peso + 2 a 4 GB para o contexto

Um modelo de 8B em Q4 ocupa uns 4 GB de pesos, mais o espaço do contexto (o KV cache): com 6 GB ele roda e com 8 GB vai com folga.

Tamanho do modelo	Quantização	Memória mínima	Memória confortável
7B / 8B	Q4_K_M	6 GB	8 GB
7B / 8B	Q8	9 GB	12 GB
7B / 8B	FP16	16 GB	20 GB
14B	Q4_K_M	12 GB	16 GB
32B	Q4_K_M	20 GB	24 GB
70B	Q4_K_M	40 GB	48–64 GB

São estimativas: o consumo real sobe com a janela de contexto que você configurar. Se um modelo está lento, a primeira coisa é verificar se ele cabe inteiro na GPU (mostro como mais abaixo).

Qual modelo instalar primeiro

Não precisa começar pelo maior. Como ponto de partida em 2026:

• 8 GB de RAM: qwen3.5:4b.
• 16 GB: qwen3.5:9b, o melhor equilíbrio entre qualidade e tamanho.
• 24 GB de VRAM ou Mac de 32 GB: qwen3.5:27b, ou qwen3-coder:30b se for para programar.

A comparação completa por memória, com Gemma 4, gpt-oss e os modelos de embeddings, está em Melhores modelos do Ollama em 2026. Se estiver em dúvida entre as duas famílias principais, veja Qwen vs Gemma.

Como instalar o Ollama passo a passo

No macOS

Baixe o instalador em ollama.com/download, arraste o app para Aplicativos e abra. O app deixa o serviço rodando e adiciona o comando ollama ao terminal.

No Windows

Baixe e execute o OllamaSetup.exe na mesma página. Não precisa de WSL: roda de forma nativa, detecta GPUs NVIDIA e AMD compatíveis e fica como ícone na bandeja do sistema.

No Linux

Um único comando instala o serviço:

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

Como em qualquer script que você passa para o sh, dá para baixá-lo e lê-lo antes de executar. No Linux, o Ollama fica como serviço do systemd.

Para conferir que funciona:

ollama --version

Os comandos essenciais do Ollama

Comando	O que faz
ollama run <modelo>	Baixa o modelo se você não o tiver e abre um chat no terminal
ollama pull <modelo>	Baixa o modelo sem abrir o chat
ollama list	Lista os modelos baixados, com tamanho e data
ollama ps	Mostra os modelos carregados na memória e se rodam na GPU ou na CPU
ollama show <modelo>	Mostra os detalhes do modelo: parâmetros, quantização e contexto
ollama rm <modelo>	Apaga um modelo para liberar disco

Um primeiro uso real:

ollama pull qwen3.5:9b
ollama run qwen3.5:9b

Dentro do chat, /bye sai. Confira o ollama ps na primeira vez: se a coluna de processador disser algo como 40%/60% CPU/GPU, o modelo não cabe inteiro na sua GPU. Escolha um menor ou reduza o contexto.

Como personalizar um modelo com um Modelfile

Um Modelfile é um arquivo de texto que define como um modelo se comporta: o prompt de sistema, a temperatura, o tamanho do contexto. Serve para ter um assistente fixo para uma tarefa sem repetir instruções em cada chat.

FROM qwen3.5:9b

# Temperatura: 0 = respostas mais determinísticas, 1 = mais criativas
PARAMETER temperature 0.2

# Janela de contexto em tokens
PARAMETER num_ctx 8192

SYSTEM """
Você é um arquiteto de software sênior com foco em segurança.
Responde de forma direta e tecnicamente precisa, sem enrolação, em Markdown.
"""

Salve como Modelfile e empacote:

ollama create meu-arquiteto -f ./Modelfile
ollama run meu-arquiteto

Sobre o contexto: por padrão, o Ollama ajusta a janela de contexto à sua VRAM, e com menos de 24 GB começa em 4.096 tokens. Para resumir documentos longos ou usar agentes de código, isso fica curto. Aumente com num_ctx no Modelfile, com a variável OLLAMA_CONTEXT_LENGTH para todo o servidor ou nas configurações do app. Mais contexto consome mais memória, então confira o ollama ps de novo depois de aumentar.

Como usar a API local do Ollama (porta 11434)

O Ollama expõe um servidor HTTP em http://localhost:11434 em dois sabores:

• API nativa: /api/generate e /api/chat.
• API compatível com OpenAI: /v1, para usar o Ollama com qualquer SDK ou ferramenta que já converse com a OpenAI.

Uma chamada de teste:

curl http://localhost:11434/api/generate -d '{
  "model": "qwen3.5:9b",
  "prompt": "Resuma em três pontos por que rodar IA localmente reduz custos",
  "stream": false
}'

Com a API compatível com OpenAI, no seu código você só muda a URL base:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
resposta = client.chat.completions.create(
    model="qwen3.5:9b",
    messages=[{"role": "user", "content": "Classifique este e-mail: ..."}],
)
print(resposta.choices[0].message.content)

A api_key é obrigatória para o SDK, mas o Ollama a ignora.

Conectar a editores e agentes de código

Ferramentas como o OpenCode aceitam um provedor personalizado: você aponta a URL base para http://localhost:11434/v1 e escolhe o modelo. Assim você tem autocompletar e ajuda com o código sem que ele saia do seu computador. Faço a configuração passo a passo em como instalar e configurar o OpenCode. Para agentes, use um modelo pensado para código e aumente o contexto para 32K ou mais.

Conectar ao Open WebUI, ao Docker ou a outros computadores da rede

Por padrão, o Ollama só escuta em 127.0.0.1. Se você conectar uma interface como o Open WebUI a partir de um contêiner Docker ou de outro computador da rede, configure estas variáveis de ambiente no serviço:

• OLLAMA_HOST=0.0.0.0 para que ele aceite conexões de fora do localhost.
• OLLAMA_ORIGINS com as origens permitidas, se um app web chamar a API pelo navegador.

Atenção à segurança: a API do Ollama não tem autenticação. Com 0.0.0.0, qualquer pessoa na sua rede pode usar seus modelos. Faça isso só em redes confiáveis ou atrás de um proxy com autenticação, e nunca abra a porta 11434 para a internet. Evite OLLAMA_ORIGINS="*" fora de testes.

Ollama vs LM Studio vs Jan: qual escolher

Os três rodam modelos localmente. A diferença está no que cada um se propõe a fazer.

Critério	Ollama	LM Studio	Jan
Foco	Serviço e API para integrar a IA em outras ferramentas	App gráfico para descobrir, testar e comparar modelos	App de chat open source, alternativa local ao ChatGPT
Interface	Terminal e API; app de chat simples no Mac e no Windows	Interface gráfica completa, com ajustes visuais	Interface gráfica de chat
API local	Sempre ativa na porta 11434	É preciso iniciar o servidor pelo app	Servidor compatível com OpenAI, ativável nas configurações
Modelos	Catálogo do Ollama e importação de GGUF	Baixa GGUF direto do Hugging Face	Download de modelos e conexão com outros backends
Ideal para	Automações, servidores sem tela, editores e agentes	Comparar modelos e quantizações, testar prompts	Usuários não técnicos que querem um chat privado

Minha recomendação: Ollama se você vai integrar a IA em algo (um editor, um script, um fluxo de trabalho). LM Studio se quer explorar modelos antes de decidir. Jan se o que você precisa é um chat privado para alguém que não vai abrir um terminal. Eles não se excluem.

Calcule quanto você economiza

Passar parte do trabalho para um modelo local só faz sentido se os números fecharem. Duas ferramentas gratuitas do Crea Cosas ajudam a ver isso:

1. Calculadora de margem: desconte do custo dos seus projetos o que você paga hoje em assinaturas e tokens e veja quanto a margem melhora.
2. Business Model Canvas: leve a mudança ao bloco de estrutura de custos. Um gasto que antes crescia com cada cliente vira um custo fixo que você amortiza.

Coloque na conta o hardware e o tempo de configuração. Se a economia mensal não paga o equipamento num prazo razoável, continue na nuvem e reavalie quando o volume crescer.

O que fica

Rodar IA localmente já não é coisa de laboratório. Com o Ollama, um computador de 16 GB e um modelo bem escolhido, você tem um assistente privado, sem mensalidade e com uma API que pode conectar às suas ferramentas. Ele não substitui os modelos de fronteira para tudo, mas pode tirar das suas costas boa parte do volume diário e os dados que não deveriam sair da empresa. Comece com um modelo pequeno, meça se ele ajuda e cresça a partir daí.