Como rodar IA no seu computador com Ollama: guia completo

Para rodar IA no seu computador com o Ollama, você instala o programa (um comando no Linux e no macOS, um instalador ou um comando de PowerShell no Windows), baixa um modelo aberto com ollama pull e conversa com ele com ollama run. A partir daí, o mesmo modelo fica disponível numa API local na porta 11434, inclusive com endpoints compatíveis com a API da OpenAI, o que permite plugar o modelo em scripts, automações e interfaces gráficas sem enviar dados para fora da máquina.

O que define a experiência é o hardware: a memória disponível (RAM ou, melhor, VRAM da placa de vídeo) limita o tamanho do modelo que roda com velocidade aceitável. Este guia cobre instalação, comandos, escolha de modelo, API, personalização com Modelfile, interfaces gráficas e, com franqueza, onde modelos locais ainda ficam atrás dos serviços de nuvem.

Resumo rápido

• Instale pelo site oficial, baixe um modelo com ollama pull e teste com ollama run.
• Escolha o tamanho do modelo pela memória: em 4 bits, cada bilhão de parâmetros ocupa por volta de meio gigabyte, mais a memória do contexto.
• A API local responde em http://localhost:11434, com rotas nativas e rotas compatíveis com OpenAI em /v1.
• Use Modelfile para fixar prompt de sistema e parâmetros, e Open WebUI ou LM Studio se quiser interface gráfica.
• Rodar local é ótimo para dados sensíveis e custo previsível, mas modelos que cabem num notebook costumam ficar atrás dos maiores modelos de nuvem.

Instalação no Windows, macOS e Linux

Os comandos abaixo são os publicados no repositório oficial do Ollama. Confira ollama.com/download antes de instalar, porque o processo pode mudar.

Executar um script baixado da internet direto no terminal exige confiança na origem. Se a política de TI da empresa não permite, use o instalador ou a instalação manual.

Aceleração por GPU

Segundo a documentação, o Ollama usa GPUs NVIDIA (com compute capability 5.0 ou superior e driver recente), GPUs AMD via ROCm, o Metal nos Macs com Apple Silicon e, como opção adicional, Vulkan no Windows e no Linux. Sem GPU compatível, ele roda na CPU, só que bem mais devagar. Para saber onde o modelo foi carregado, rode ollama ps: a coluna PROCESSOR mostra “100% GPU”, “100% CPU” ou uma divisão entre os dois.

Primeiros comandos

ollama pull gemma4        # baixa o modelo
ollama run gemma4         # abre um chat no terminal
ollama ls                 # lista os modelos baixados
ollama ps                 # mostra os modelos carregados na memória
ollama stop gemma4        # descarrega o modelo
ollama rm gemma4          # apaga o modelo do disco

Os nomes de modelo são exemplos tirados da documentação oficial; a lista do que está disponível, com tamanhos e variantes, fica em ollama.com/search. Muitos modelos têm várias etiquetas (tags), indicando tamanho em parâmetros ou nível de quantização, no formato nome:tag.

Dentro do chat, texto de várias linhas vai entre aspas triplas (""") e o comando /bye encerra a sessão. Também dá para passar a pergunta direto: ollama run gemma4 "Resuma este texto: ...". Em modelos com visão, basta incluir o caminho da imagem no prompt.

Depois do uso, o modelo fica na memória por cinco minutos por padrão, para responder rápido à próxima pergunta; a variável OLLAMA_KEEP_ALIVE muda isso. Os arquivos ficam em ~/.ollama/models no macOS, /usr/share/ollama/.ollama/models no Linux e C:\Users\%username%\.ollama\models no Windows. Para usar outro disco, defina OLLAMA_MODELS.

Qual modelo cabe no seu hardware

Modelos de linguagem são grandes arquivos de números (os parâmetros). A quantização reduz a precisão desses números, de 16 bits para 8 ou 4 bits por exemplo, diminuindo o tamanho e o consumo de memória com alguma perda de qualidade, que costuma ser pequena nos níveis moderados. A maioria dos modelos da biblioteca do Ollama já vem quantizada.

Dá para estimar o espaço só com aritmética: bilhões de parâmetros vezes bits por parâmetro, dividido por 8, resulta em gigabytes aproximados só para os pesos. Some a isso a memória do contexto (que cresce com o tamanho da janela de contexto) e a do sistema operacional.

Os valores são estimativas de ordem de grandeza, não especificações. Quando o modelo não cabe inteiro na VRAM, o Ollama divide entre GPU e CPU: funciona, mas a velocidade cai bastante. Em Macs com Apple Silicon, a memória é compartilhada entre CPU e GPU, por isso a RAM total conta. Comece por um modelo pequeno, meça a velocidade e suba de tamanho só se a qualidade não bastar. Para entender as famílias de modelos abertos, veja nosso guia sobre modelos open-weights.

Janela de contexto

A janela de contexto padrão do Ollama é bem menor que o máximo que muitos modelos suportam, para economizar memória. Para documentos longos, aumente com a variável OLLAMA_CONTEXT_LENGTH ao iniciar o servidor, com /set parameter num_ctx dentro do chat ou com num_ctx nas opções da API. Contexto maior consome mais memória.

A API local: nativa e compatível com OpenAI

Com o Ollama em execução, a API responde em http://localhost:11434. As rotas nativas mais usadas são /api/chat (conversa com mensagens), /api/generate (geração a partir de um prompt) e /api/embed (embeddings). Por padrão as respostas vêm em streaming; envie "stream": false para receber um único JSON.

curl http://localhost:11434/api/chat -d '{
  "model": "gemma4",
  "messages": [{"role": "user", "content": "Explique o que é DRE em duas frases."}],
  "stream": false
}'

O Ollama também expõe rotas compatíveis com a API da OpenAI em http://localhost:11434/v1/, incluindo /v1/chat/completions, /v1/embeddings, /v1/models e /v1/responses. Na prática, código escrito para a OpenAI passa a usar o modelo local trocando duas linhas. A chave é obrigatória no SDK, mas o Ollama local a ignora:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1/", api_key="ollama")

resp = client.chat.completions.create(
    model="gemma4",
    messages=[{"role": "user", "content": "Liste 3 cuidados ao emitir nota fiscal de serviço."}],
)
print(resp.choices[0].message.content)

A documentação também descreve compatibilidade com a API da Anthropic. Essa troca simples serve para testar se um modelo local dá conta de uma tarefa que hoje roda na nuvem, como a busca em documentos do nosso guia prático de RAG.

Por padrão, o servidor escuta só em 127.0.0.1, ou seja, só a própria máquina acessa. Para liberar na rede interna, a variável OLLAMA_HOST (por exemplo 0.0.0.0:11434) muda isso, mas a API não tem autenticação própria no uso local: não exponha à internet sem um proxy com controle de acesso.

Personalizando com Modelfile

O Modelfile é um arquivo de texto que cria uma variação de um modelo com prompt de sistema e parâmetros fixos. As instruções principais são FROM (obrigatória, o modelo base), PARAMETER (temperatura, tamanho do contexto e outros), SYSTEM (prompt de sistema), TEMPLATE, MESSAGE e LICENSE.

FROM gemma4
PARAMETER temperature 0.3
PARAMETER num_ctx 8192
SYSTEM """Você é assistente interno de uma imobiliária em Curitiba.
Responda em português, de forma objetiva.
Se não tiver certeza sobre cláusulas contratuais, diga que o jurídico deve revisar."""

Salve como Modelfile e crie o modelo:

ollama create assistente-imob -f ./Modelfile
ollama run assistente-imob

Temperatura mais baixa deixa as respostas mais consistentes, o que ajuda em tarefas como resumo e classificação. O modelo criado aparece em ollama ls e pode ser chamado pela API como qualquer outro.

Interfaces gráficas: Open WebUI e LM Studio

Nem todo mundo da equipe vai usar terminal. Duas opções populares:

• Open WebUI: interface web open source com cara de chat, histórico, vários usuários e envio de documentos. Conecta-se ao Ollama da mesma máquina. Pela documentação oficial, instala com Docker (acessível em http://localhost:3000) ou com pip install open-webui seguido de open-webui serve (em http://localhost:8080).
• LM Studio: aplicativo desktop que é uma alternativa ao Ollama, e não uma interface para ele. Tem busca e download de modelos, chat e um servidor local compatível com OpenAI, tudo pela interface gráfica. Bom para quem quer testar modelos sem linha de comando.

docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data -e WEBUI_SECRET_KEY=troque-esta-chave \
  --name open-webui --restart always ghcr.io/open-webui/open-webui:main

Casos de uso com dados sensíveis

O principal argumento para IA local é que o conteúdo não sai da máquina. A documentação do Ollama afirma que, rodando modelos localmente, a empresa não vê seus prompts nem seus dados. Exemplos em que isso pesa:

• Clínica: resumir anotações de prontuário ou padronizar laudos sem enviar dados de saúde a terceiros.
• Escritório de contabilidade: extrair campos de extratos e notas fiscais com CPF e CNPJ de clientes.
• Escritório de advocacia: fazer triagem de contratos e petições sob sigilo profissional.
• RH: classificar currículos e organizar feedbacks internos.

Dois cuidados. Primeiro, o Ollama também oferece modelos e recursos que rodam na nuvem dele; para garantir uso só local, a documentação indica a variável OLLAMA_NO_CLOUD=1. Segundo, local não significa automaticamente adequado à LGPD: controle de acesso à máquina, registro de uso e base legal continuam valendo. Veja nosso guia de segurança e LGPD na implantação de IA.

Limitações honestas e quando NÃO usar

• Qualidade: os modelos que cabem num notebook costumam ficar atrás dos maiores modelos de nuvem em raciocínio complexo, programação e textos longos. Teste com suas tarefas reais.
• Velocidade: sem GPU adequada, as respostas podem ser lentas demais para atendimento em tempo real.
• Escala: um computador atende poucas pessoas ao mesmo tempo. Para dezenas de usuários simultâneos, é preciso servidor dedicado e planejamento.
• Manutenção: atualizar modelos, monitorar e fazer backup ficam por sua conta.
• Custo escondido: GPU com muita memória custa caro; para uso esporádico, a API de nuvem pode sair mais barata. Faça a conta com o seu volume.

Uma estratégia comum é híbrida: tarefas com dados sensíveis e repetitivas no modelo local, tarefas difíceis e sem dados pessoais na nuvem.

Perguntas frequentes

O Ollama é gratuito?

O software é open source e gratuito para rodar modelos localmente. Os modelos têm licenças próprias, definidas por cada fornecedor; confira a licença antes de uso comercial. Recursos de nuvem do Ollama têm condições próprias, descritas no site oficial.

Preciso de placa de vídeo?

Não é obrigatório: modelos pequenos rodam na CPU. Mas uma GPU compatível, ou um Mac com Apple Silicon, faz grande diferença na velocidade, principalmente a partir de modelos de 7 bilhões de parâmetros.

Modelos locais entendem português?

Muitos modelos abertos recentes funcionam bem em português, mas a qualidade varia por família e cai em modelos muito pequenos. Teste com textos do seu dia a dia antes de decidir.

Posso usar o Ollama com ferramentas de automação?

Sim. Qualquer ferramenta que aceite uma API compatível com OpenAI e permita trocar a URL base pode apontar para http://localhost:11434/v1/. O mesmo vale para scripts em Python ou JavaScript.

Como atualizo um modelo?

Rode ollama pull de novo com o mesmo nome para buscar a versão publicada daquela etiqueta. Para remover versões que não usa mais, use ollama rm e libere espaço em disco.

Fontes e leitura recomendada

• Ollama: site oficial e downloads
• Ollama: documentação (CLI, API, Modelfile, FAQ)
• Ollama: compatibilidade com a API da OpenAI
• Ollama no GitHub
• Open WebUI: documentação
• LM Studio: site oficial