Pular para o conteúdo principal

Execute modelos de IA localmente com o Ollama

Intermediário

Os modelos de fronteira vivem na nuvem, mas toda uma classe de modelos de pesos abertos — Llama, Mistral, Qwen, DeepSeek, Gemma — você pode baixar e executar no seu próprio notebook ou servidor. O Ollama é a forma mais simples de fazer isso: uma instalação, um comando e um modelo rodando localmente. Esta página leva você do zero a um modelo em execução, a chamá-lo a partir do código e a conhecer os trade-offs, para que você não espere que um modelo local de 7B se comporte como um de fronteira.

What you'll learn
  • Saber POR QUE rodar um modelo localmente — e os trade-offs honestos em relação aos modelos de fronteira na nuvem
  • Instalar o Ollama e executar seu primeiro modelo com dois comandos
  • Usar a CLI principal: pull, run, list, ps, rm, stop
  • Chamar seu modelo local a partir do código pela API do Ollama compatível com a OpenAI
  • Entender necessidades de RAM, tamanhos de modelo e quantização — para escolher um modelo que sua máquina realmente consiga executar
  • Saber quando o LM Studio (uma GUI) é o melhor ponto de partida

Por que rodar um modelo localmente (e quando não)​

Rodar um modelo no seu próprio hardware traz quatro coisas:

  • Privacidade — seus prompts e dados nunca saem da sua máquina. É o motivo pelo qual equipes em áreas regulamentadas ou sensíveis recorrem a modelos locais. (Veja a bifurcação privacidade/self-host em Como escolher um modelo.)
  • Offline — sem internet, sem API, sem dependência de quedas de serviço. O modelo é um arquivo no seu disco.
  • Custo — sem cobrança por token. Depois de baixado, rodá-lo é "de graça" (você paga em eletricidade e hardware, não em gasto com API). Se o gasto com tokens é sua restrição em escala, o local pode vencer.
  • Controle — fixe uma versão exata, personalize o comportamento e integre sem limites de taxa nem surpresas nos termos de serviço.

Os trade-offs honestos:

  • Lacuna de capacidade. Um modelo que você consegue rodar num notebook (1B–14B parâmetros) não está na mesma liga de um modelo de fronteira na nuvem em raciocínio difícil, contexto longo ou tarefas agênticas. Em muitas tarefas do dia a dia a lacuna é pequena; nas mais difíceis ela é grande.
  • Hardware. Modelos maiores e mais capazes exigem mais RAM/VRAM do que uma máquina típica tem. Muitas vezes você está escolhendo o maior modelo que seu hardware consegue rodar, não o melhor que existe.
  • Você o opera. Sem escalonamento gerenciado, sem upgrades automáticos — esse é o preço do controle.

Um padrão comum e duradouro: prototipe e escolha com uma avaliação minúscula (mesmo método dos modelos na nuvem — veja Como escolher um modelo), use o local para trabalho privado/offline/barato em escala e recorra a uma API de fronteira quando a tarefa realmente precisar da capacidade extra.

Instale o Ollama e execute seu primeiro modelo​

Guided walkthrough1 of 4
  1. macOS e Windows: baixe o instalador em ollama.com/download e execute-o. Linux: use o script de instalação oficial (abaixo). Isso instala o comando ollama e um serviço local em segundo plano.

Instalação no Linux (macOS/Windows usam, em vez disso, o instalador baixado):

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

Baixe e execute um modelo pequeno (boa primeira escolha)

ollama run gemma4:e2b

Esse único comando baixa o gemma4:e2b — o modelo com o qual o próprio quickstart do Ollama começa, uma variante do Gemma 4 em tamanho edge, com ~2,3B parâmetros efetivos e alguns GB em disco — e inicia um chat interativo. Para baixar sem conversar ainda, use ollama pull.

A CLI principal​

Um punhado de comandos cobre quase tudo. Execute ollama --help para ver a lista completa.

# Download a model without starting a chat
ollama pull qwen3

# Start an interactive chat (downloads first if needed)
ollama run qwen3

# One-shot: pass the prompt inline, get the answer, exit
ollama run qwen3 "Summarize the CAP theorem in two sentences."

# List models you've downloaded
ollama list

# Show models currently loaded in memory
ollama ps

# Stop a running/loaded model (frees memory)
ollama stop qwen3

# Delete a downloaded model to reclaim disk
ollama rm qwen3

Dentro de uma sessão interativa do ollama run, digite /bye para sair e /? para ver os comandos da sessão. O serviço em segundo plano que de fato serve os modelos é iniciado por ollama serve (o app de desktop o inicia automaticamente para você).

Chame-o a partir do código (API compatível com a OpenAI)​

Esta é a parte que torna os modelos locais realmente úteis em aplicativos. O serviço em segundo plano do Ollama expõe uma API HTTP local em http://localhost:11434, na porta padrão 11434. Ele tem endpoints nativos próprios (/api/generate, /api/chat) e uma camada compatível com a OpenAI em /v1 — assim, a maior parte do código escrito para o SDK da OpenAI funciona com o seu modelo local trocando duas linhas.

HTTP puro com curl (endpoint nativo):

curl http://localhost:11434/api/chat -d '{
  "model": "gemma4:e2b",
  "messages": [
    { "role": "user", "content": "Why is the sky blue?" }
  ],
  "stream": false
}'

Em Python, usando o SDK oficial da OpenAI — basta apontar base_url para o Ollama e passar qualquer api_key não vazia (o Ollama exige o campo, mas ignora o valor):

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # required by the SDK, ignored by Ollama
)

response = client.chat.completions.create(
    model="gemma4:e2b",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Explain gradient descent in two sentences."},
    ],
)

print(response.choices[0].message.content)

Por ser compatível com a OpenAI, os mesmos padrões que você usaria com uma API hospedada se aplicam — inclusive streaming e uso de ferramentas / function calling, que funcionam localmente do mesmo jeito que na nuvem (desde que o modelo seja de fato bom nisso). A camada /v1 do Ollama cobre /v1/chat/completions, /v1/completions, /v1/responses, /v1/models (e /v1/models/{model}) e /v1/embeddings.

Hardware, tamanhos de modelo e quantização​

O número que você vê associado a um modelo — 1B, 7B, 8B, 70B — é a sua contagem de parâmetros (em bilhões). Mais parâmetros geralmente significam mais capaz e mais faminto por memória. O limite prático do que você consegue rodar é a RAM (e, numa GPU, a VRAM).

A quantização é o truque essencial que torna isso viável em máquinas comuns. Os pesos do modelo são originalmente armazenados em alta precisão (p. ex., 16 bits), mas podem ser comprimidos para ~4 bits com um custo de qualidade pequeno, muitas vezes quase imperceptível. O Ollama distribui a maioria dos modelos quantizados por padrão — é por isso que um modelo com bilhões de parâmetros cabe em poucos GB. Uma regra prática aproximada (confira na página do modelo específico):

  • Modelos de ~1B–3B: rodam confortavelmente na maioria dos notebooks modernos (alguns GB de RAM).
  • Modelos de ~7B–8B: o ponto ideal entre capaz e executável; reserve vários GB de RAM livre.
  • Modelos de ~13B–14B: exigem uma máquina bem equipada.
  • Modelos de ~70B+: exigem uma workstation/servidor com muita RAM ou uma GPU potente — não é território típico de notebook.

Uma receita prática: comece com um modelo pequeno (gemma4:e2b), confirme o fluxo de ponta a ponta e então suba para o maior modelo que ainda rode com fluidez no seu hardware — não o maior que existe.

Vocabulário de modelos locais
Pressione Enter ou Espaço para virar o cartão. Use as setas esquerda e direita para navegar entre os cartões.Termo exibido.
1 / 6

LM Studio: uma alternativa com interface gráfica​

Se a linha de comando não é a sua praia, o LM Studio é um aplicativo de desktop (macOS, Windows, Linux) que faz o mesmo trabalho por meio de uma interface gráfica: navegue e baixe modelos abertos, converse com eles numa UI integrada e — assim como o Ollama — execute um servidor local compatível com a OpenAI para que seu código possa conversar com ele. É a porta de entrada mais fácil para quem não é desenvolvedor ou prefere apontar e clicar a usar o terminal; o Ollama tende a vencer quando você quer uma CLI scriptável e um serviço leve em segundo plano. Ambos executam os mesmos tipos de modelos de pesos abertos, então os conceitos desta página se transferem diretamente.

Teste você mesmo

0/4
  1. Qual é o maior trade-off honesto de rodar um modelo localmente em vez de um modelo de fronteira na nuvem?
  2. Qual comando baixa um modelo (se necessário) E começa a conversar com ele?
  3. Para chamar seu modelo local a partir de código com o SDK da OpenAI, o que você configura?
  4. Por que um modelo com bilhões de parâmetros pode caber em apenas alguns GB de RAM?
Key takeaways
  • Local = privacidade + offline + sem custo por token + controle; o trade-off é uma lacuna real de capacidade e limites de hardware.
  • Dois comandos colocam você para rodar: instale o Ollama e depois ollama run gemma4:e2b.
  • CLI principal: pull (baixar), run (conversar), list, ps, stop, rm — isso é quase tudo.
  • Chame-o a partir do código pelo endpoint compatível com a OpenAI: base_url http://localhost:11434/v1, qualquer api_key não vazia.
  • Contagem de parâmetros + quantização decidem se sua máquina consegue rodar um modelo — comece pequeno e suba até o que rodar com fluidez.
  • Prefere uma GUI? O LM Studio faz o mesmo trabalho apontando e clicando e também expõe um servidor local compatível com a OpenAI.

Fontes e leitura adicional​

Próximos passos​