Ollama CLI Cheatsheet: ls, serve, run, ps + comandos (atualização 2026)

Este resumo de comandos (cheatsheet) da CLI do Ollama foca nos comandos que você usa todos os dias (ollama ls, ollama serve, ollama run, ollama ps, gerenciamento de modelos e fluxos de trabalho comuns), com exemplos que você pode copiar/colar.

Ele também inclui uma breve seção de “ajustes de desempenho” para ajudar você a descobrir (e depois aprofundar) OLLAMA_NUM_PARALLEL e configurações relacionadas.

Este resumo de comandos do Ollama foca em comandos de linha de comando (CLI), gerenciamento de modelos e personalização, mas aqui também temos algumas chamadas curl.

Para uma visão completa de onde o Ollama se encaixa entre opções locais, auto-hospedadas e em nuvem — incluindo vLLM, Docker Model Runner, LocalAI e provedores de nuvem — veja Hospedagem de LLMs: Infraestrutura Local, Auto-hospedada e em Nuvem Comparada. Se você está comparando diferentes soluções de hospedagem de LLMs locais, confira nossa comparação abrangente de Ollama, vLLM, LocalAI, Jan, LM Studio e mais. Para aqueles que buscam alternativas às interfaces de linha de comando, Docker Model Runner oferece uma abordagem diferente para a implantação de LLMs. Se o tráfego concorrente ou o enfileiramento começarem a sobrecarregar uma única instância do Ollama, Ollama para vLLM: Quando Migrar Seu Servidor Local de LLM descreve os sinais de migração e um plano de lançamento em etapas.

Instalação do Ollama (download e instalação via CLI)

• Opção 1: Download do Site
  • Acesse ollama.com e faça o download do instalador para seu sistema operacional (Mac, Linux ou Windows).
• Opção 2: Instalação via Linha de Comando
  • Para usuários de Mac e Linux, use o comando:

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

• Siga as instruções na tela e digite sua senha se solicitado.

Requisitos do sistema Ollama (RAM, armazenamento, CPU)

• Sistema Operacional: Mac, Linux ou Windows
• Memória (RAM): Mínimo de 8GB, 16GB ou mais recomendado
• Armazenamento: Pelo menos ~10GB de espaço livre (os arquivos de modelo podem ser realmente grandes, veja mais aqui Mover Modelos Ollama para Outro Drive )
• Processador: Um CPU relativamente moderno (dos últimos 5 anos). Se você estiver curioso sobre como o Ollama utiliza diferentes arquiteturas de CPU, veja nossa análise de como o Ollama usa os Núcleos de Desempenho e Eficientes da CPU Intel.

Para cargas de trabalho de IA sérias, você pode querer comparar opções de hardware. Nós benchmarkamos NVIDIA DGX Spark vs Mac Studio vs RTX-4080 desempenho com Ollama, e se você estiver considerando investir em hardware de alta gama, nossa comparação de preços e capacidades do DGX Spark fornece uma análise detalhada de custos.

Comandos Básicos da CLI do Ollama

Links rápidos: Comando ollama serve · Comando ollama launch · Comando ollama run · Flags do ollama run · Comando ollama ps · Comando ollama show · Ollama signin · Básicos da CLI Ollama · Ajustes de desempenho (OLLAMA_NUM_PARALLEL) · Aprofundamento em solicitações paralelas

CLI do Ollama (o que é)

Ollama CLI é a interface de linha de comando para gerenciar modelos e executá-los/serví-los localmente. A maioria dos fluxos de trabalho resume-se a:

• Iniciar o servidor: ollama serve
• Executar um modelo: ollama run <modelo>
• Ver o que está carregado/em execução: ollama ps
• Gerenciar modelos: ollama pull, ollama list, ollama rm

Gerenciamento de modelos Ollama: comandos pull e list

Listar Modelos:

ollama list

o mesmo que:

ollama ls

Este comando lista todos os modelos que foram baixados para seu sistema, com seus tamanhos de arquivo no seu hdd/ssd, como

$ ollama ls
NAME                                                    ID              SIZE      MODIFIED     
deepseek-r1:8b                                          6995872bfe4c    5.2 GB    2 semanas atrás     
gemma3:12b-it-qat                                       5d4fa005e7bb    8.9 GB    2 semanas atrás     
LoTUs5494/mistral-small-3.1:24b-instruct-2503-iq4_NL    4e994e0f85a0    13 GB     3 semanas atrás     
dengcao/Qwen3-Embedding-8B:Q4_K_M                       d3ca2355027f    4.7 GB    4 semanas atrás     
dengcao/Qwen3-Embedding-4B:Q5_K_M                       7e8c9ad6885b    2.9 GB    4 semanas atrás     
qwen3:8b                                                500a1f067a9f    5.2 GB    5 semanas atrás     
qwen3:14b                                               bdbd181c33f2    9.3 GB    5 semanas atrás     
qwen3:30b-a3b                                           0b28110b7a33    18 GB     5 semanas atrás     
devstral:24b                                            c4b2fa0c33d7    14 GB     5 semanas atrás  

Baixar um Modelo: ollama pull

ollama pull mistral-nemo:12b-instruct-2407-q6_K

Este comando baixa o modelo especificado (por exemplo, Gemma 2B, ou mistral-nemo:12b-instruct-2407-q6_K) para seu sistema. Os arquivos de modelo podem ser bastante grandes, então fique de olho no espaço usado pelos modelos no disco rígido ou ssd. Você pode até querer mover todos os modelos Ollama do seu diretório home para outro drive maior e melhor

Enviar um Modelo: ollama push

ollama push meu-modelo-personalizado

Envia um modelo local para o repositório Ollama para que outros possam baixá-lo. Você precisa estar conectado primeiro (ollama signin) e o nome do modelo deve ser prefixado com seu nome de usuário do Ollama, por exemplo, meu-usuario/meu-modelo. Use --insecure se estiver enviando para um repositório privado via HTTP:

ollama push meu-usuario/meu-modelo --insecure

Copiar um Modelo: ollama cp

ollama cp llama3.2 minha-varian-llama3

Cria uma cópia local de um modelo sob um novo nome sem rebaixar nada. Isso é útil antes de editar um Modelfile — copie primeiro, personalize a cópia e mantenha o original intacto:

ollama cp qwen3:14b qwen3-14b-personalizado
ollama create qwen3-14b-personalizado -f ./Modelfile

Comando ollama show

ollama show imprime informações sobre um modelo baixado.

ollama show qwen3:14b

Por padrão, ele imprime o cartão do modelo (arquitetura, comprimento do contexto, comprimento do embedding, quantização, etc.). Há três flags úteis:

# Veja exatamente com qual prompt de sistema e template um modelo foi construído
ollama show deepseek-r1:8b --modelfile

# Verifique o tamanho da janela de contexto e outros parâmetros de inferência
ollama show qwen3:14b --parameters

# Detalhes completos em nível de tensor (útil ao depurar quantização)
ollama show llama3.2 --verbose

A saída de --modelfile é especialmente útil antes de personalizar um modelo: você pode copiar o Modelfile base e editar a partir daí, em vez de escrever um do zero.

Comando ollama serve

ollama serve inicia o servidor local Ollama (porta HTTP padrão 11434).

ollama serve

Comando “ollama serve” (exemplo compatível com systemd):

# definir variáveis de ambiente e, em seguida, iniciar o servidor
# tornar o ollama disponível no endereço IP do host
export OLLAMA_HOST=0.0.0.0:11434
export OLLAMA_NUM_PARALLEL=2
ollama serve

Comando ollama run

Executar um Modelo:

ollama run gpt-oss:20b

Este comando inicia o modelo especificado e abre um REPL interativo para interação. Quer entender como o Ollama gerencia múltiplas solicitações concorrentes? Saiba mais sobre como o Ollama lida com solicitações paralelas em nossa análise detalhada.

ollama run executa um modelo em uma sessão interativa, então, no caso de gpt-oss:120b, você veria algo como

$ ollama run gpt-oss:120b
>>> Envie uma mensagem (/? para ajuda)

você pode digitar suas perguntas ou comandos e o modelo responderá.

>>> quem é você?
Pensando...
O usuário pergunta "quem é você?". Pergunta simples. Deveria responder como ChatGPT, um modelo de linguagem de IA, treinado pela OpenAI, 
etc. Fornecer uma breve introdução. Provavelmente perguntar se eles precisam de ajuda.
...terminou de pensar.

Sou o ChatGPT, um modelo de linguagem de IA criado pela OpenAI. Fui treinado em uma ampla gama de textos para que possa ajudar 
a responder perguntas, brainstormar ideias, explicar conceitos, rascunhar textos, solucionar problemas e muito mais. Pense 
em mim como um assistente virtual versátil — aqui para fornecer informações, suporte e conversa sempre que você precisar 
disto. Como posso ajudá-lo hoje?

>>> Envie uma mensagem (/? para ajuda)

Para sair da sessão interativa do ollama, pressione Ctrl+D, ou você pode digitar /bye, o mesmo resultado:

>>> /bye
$ 

Exemplos do comando ollama run

Para executar um modelo e fazer uma única pergunta em um modo não interativo:

printf "Me dê 10 one-liners bash para análise de logs.\n" | ollama run llama3.2

Se você quiser ver uma resposta LLM detalhada e verbosa na sessão ollama - execute o modelo com o parâmetro --verbose ou -v:

$ ollama run gpt-oss:20b --verbose
>>> quem é você?
Pensando...
Precisamos responder a uma pergunta simples: "quem é você?". O usuário está perguntando "quem é você?". Podemos responder que 
somos o ChatGPT, um grande modelo de linguagem treinado pela OpenAI. Também podemos mencionar capacidades. O usuário provavelmente espera 
uma breve introdução. Vamos mantê-la amigável.
...terminou de pensar.

Sou o ChatGPT, um grande modelo de linguagem criado pela OpenAI. Estou aqui para ajudar a responder perguntas, oferecer explicações, 
brainstormar ideias e conversar sobre uma ampla gama de tópicos — desde ciência e história até escrita criativa 
e conselhos do dia a dia. Basta me dizer sobre o que você gostaria de conversar!

duração total:       1.118585707s
duração do carregamento:        106.690543ms
contagem de eval do prompt:    71 token(s)
duração do eval do prompt: 30.507392ms
taxa de eval do prompt:     2327.30 tokens/s
contagem de eval:           132 token(s)
duração do eval:        945.801569ms
taxa de eval:            139.56 tokens/s
>>> /bye
$ 

Sim, está correto, são 139 tokens por segundo. O gpt-oss:20b é muito rápido. Se você, como eu, tem uma GPU com 16GB de VRAM - veja os detalhes da comparação de velocidade dos LLMs em Melhores LLMs para Ollama em GPU com 16GB de VRAM.

Dica: Se você quiser o modelo disponível via HTTP para múltiplos aplicativos, inicie o servidor com ollama serve e use o cliente de API em vez de sessões interativas longas.

Flags do ollama run (referência completa)

Substituir parâmetros do modelo sem um Modelfile (-p / –parameters)

A flag -p permite alterar parâmetros de inferência em tempo de execução sem criar um Modelfile. Você pode empilhar múltiplas flags -p:

# Aumentar a janela de contexto e reduzir a temperatura
ollama run qwen3:14b -p num_ctx=32768 -p temperature=0.5

# Executar uma tarefa de codificação com saída determinística
ollama run devstral:24b -p temperature=0 -p num_ctx=65536

Parâmetros comuns que você pode definir assim:

Entrada de várias linhas no REPL

Envolve o texto em aspas triplas (""") para inserir um prompt de várias linhas sem enviar prematuramente:

>>> """Resuma isso em uma frase:
... O rapido cão marrom salta sobre o cão preguiçoso.
... Aconteceu numa terça-feira.
... """

Modelos multimodais (imagens)

Para modelos com capacidade de visão (por exemplo, gemma3, llava), passe um caminho de imagem diretamente no prompt:

ollama run gemma3 "O que há nesta imagem? /home/user/screenshot.png"

Gerando embeddings via CLI

Modelos de embedding saem com um array JSON em vez de texto. Redirecione texto diretamente para embeddings rápidos e únicos:

echo "Olá mundo" | ollama run nomic-embed-text

Para cargas de trabalho de embedding em produção, use o endpoint REST /api/embeddings ou o cliente Python.

Forçar saída JSON (–format)

ollama run llama3.2 --format json "Liste 5 capitais como JSON"

O modelo é instruído a retornar JSON válido. Útil ao redirecionar saída para jq ou um script que espera dados estruturados.

Comando ollama stop

Este comando para o modelo especificado em execução.

ollama stop llama3.1:8b-instruct-q8_0

O Ollama ejetar modelos automaticamente após algum tempo. Você pode especificar este tempo, por padrão é 4 minutos. Se você não quiser esperar o tempo restante, você pode querer usar este comando ollama stop. Você também pode expulsar o modelo da VRAM chamando o endpoint da API /generate com o parâmetro keep_alive=0, veja abaixo a descrição e o exemplo.

Comando ollama ps

ollama ps mostra modelos e sessões atualmente em execução (útil para depurar “por que minha VRAM está cheia?”).

ollama ps

O exemplo da saída de ollama ps está abaixo:

NAME           ID              SIZE     PROCESSOR    CONTEXT    UNTIL
gpt-oss:20b    17052f91a42e    14 GB    100% GPU     4096       4 minutos a partir de agora

Você vê aqui no meu PC que o gpt-oss:20b se encaixa muito bem na minha GPU de 16GB de VRAM, ocupando apenas 14GB.

Se eu executar ollama run gpt-oss:120b e depois chamar ollama ps, o resultado não será tão bom: 78% das camadas estão na CPU, e isso é apenas com a janela de contexto de 4096 tokens. Será mais se eu precisar aumentar o contexto.

NAME            ID              SIZE     PROCESSOR          CONTEXT    UNTIL
gpt-oss:120b    a951a23b46a1    66 GB    78%/22% CPU/GPU    4096       4 minutos a partir de agora

Comando ollama launch (integrações de codificação de IA)

ollama launch é um comando introduzido no Ollama v0.15 (Janeiro de 2026) que oferece configuração zero-config, de uma linha, para assistentes de codificação de IA populares executando contra seu servidor local Ollama.

Por que usar ollama launch?

Antes do ollama launch, configurar um agente de codificação como Claude Code ou Codex em um backend local Ollama significava definir manualmente variáveis de ambiente, apontar a ferramenta para o endpoint da API correto e escolher um modelo compatível. ollama launch lida com tudo isso para você de forma interativa.

Se você já executa o Ollama localmente e deseja um assistente de codificação agêntico sem pagar por chamadas de API ou enviar código para a nuvem, ollama launch é o caminho mais rápido.

Integrações suportadas

Uso básico

# Seletor interativo — escolha uma integração de um menu
ollama launch

# Lançar uma integração específica diretamente
ollama launch claude

# Lançar com um modelo específico
ollama launch claude --model qwen3-coder

# Configurar a integração sem lançá-la (útil para inspecionar configurações)
ollama launch droid --config

Modelos recomendados

Agentes de codificação precisam de uma janela de contexto longa para manter o contexto de arquivos inteiros e histórico de conversas multi-turno. O Ollama recomenda modelos com pelo menos 64 000 tokens de contexto:

Se sua GPU não consegue caber o modelo, o Ollama também oferece variantes hospedadas em nuvem (por exemplo, qwen3-coder:480b-cloud) que se integram da mesma maneira, mas encaminham a inferência para a camada de nuvem do Ollama — exigindo ollama signin.

Exemplo: executando Claude Code localmente com Ollama

# 1. Certifique-se de que o modelo está disponível
ollama pull qwen3-coder

# 2. Lançar Claude Code contra ele
ollama launch claude --model qwen3-coder

O Ollama define as variáveis de ambiente necessárias e inicia o Claude Code apontando para http://localhost:11434 automaticamente. Você pode então usar o Claude Code exatamente como faria normalmente — a única diferença é que a inferência acontece no seu próprio hardware.

Ajustes de desempenho (OLLAMA_NUM_PARALLEL)

Se você vê enfileiramento ou timeouts sob carga, o primeiro ajuste a aprender é OLLAMA_NUM_PARALLEL.

• OLLAMA_NUM_PARALLEL = quantas solicitações o Ollama executa em paralelo.
• Um valor mais alto pode aumentar o throughput, mas pode aumentar a pressão na VRAM e picos de latência.

Exemplo rápido:

OLLAMA_NUM_PARALLEL=2 ollama serve

Para uma explicação completa (incluindo estratégias de ajuste e modos de falha), veja:

• Como o Ollama lida com solicitações paralelas

Liberando modelo Ollama da VRAM (keep_alive)

Quando um modelo é carregado na VRAM (memória da GPU), ele permanece lá mesmo depois que você termina de usá-lo. Para liberar explicitamente um modelo da VRAM e liberar memória da GPU, você pode enviar uma solicitação à API do Ollama com keep_alive: 0.

• Liberar Modelo da VRAM usando curl:

curl http://localhost:11434/api/generate -d '{"model": "NOMEDOMODELO", "keep_alive": 0}'

Substitua NOMEDOMODELO pelo nome real do seu modelo, por exemplo:

curl http://localhost:11434/api/generate -d '{"model": "qwen3:14b", "keep_alive": 0}'

• Liberar Modelo da VRAM usando Python:

import requests

response = requests.post(
    'http://localhost:11434/api/generate',
    json={'model': 'qwen3:14b', 'keep_alive': 0}
)

Isso é particularmente útil quando:

• Você precisa liberar memória da GPU para outros aplicativos
• Você está executando múltiplos modelos e quer gerenciar o uso da VRAM
• Você terminou de usar um modelo grande e quer liberar recursos imediatamente

Nota: O parâmetro keep_alive controla por quanto tempo (em segundos) um modelo permanece carregado na memória após a última solicitação. Definir para 0 descarrega imediatamente o modelo da VRAM.

Se você preferir evitar completamente a camada de abstração do Ollama e quiser controle direto sobre qual modelo GGUF está residente a qualquer momento, o modo roteador do llama-server cobre a abordagem nativa do llama.cpp para troca dinâmica de modelos.

Personalizando modelos Ollama (prompt de sistema, Modelfile)

• Definir Prompt de Sistema: Dentro do REPL do Ollama, você pode definir um prompt de sistema para personalizar o comportamento do modelo:

  >>> /set system Para todas as perguntas feitas, responda em inglês simples, evitando jargão técnico tanto quanto possível
  >>> /save ipe
  >>> /bye
  

  Então, execute o modelo personalizado:

  ollama run ipe
  

  Isso define um prompt de sistema e salva o modelo para uso futuro.

• Criar Arquivo de Modelo Personalizado: Crie um arquivo de texto (por exemplo, modelo_personalizado.txt) com a seguinte estrutura:

  FROM llama3.1
  SYSTEM [Suas instruções personalizadas aqui]
  

  Então, execute:

  ollama create meu-modelo -f modelo_personalizado.txt
  ollama run meu-modelo
  

  Isso cria um modelo personalizado baseado nas instruções no arquivo.

Ollama signin e signout (autenticação do repositório)

ollama signin
ollama signout

ollama signin autentica sua instalação local do Ollama com o repositório Ollama em ollama.com. Uma vez conectado, o cliente armazena credenciais localmente e reutiliza-as automaticamente para comandos subsequentes.

O que signin desbloqueia:

• Baixar e enviar modelos privados da sua conta ou organização.
• Usar modelos hospedados em nuvem (por exemplo, qwen3-coder:480b-cloud) que são muito grandes para executar localmente.
• Publicar modelos no repositório com ollama push.

Alternativa: Autenticação por chave de API

Se você está executando o Ollama em um pipeline de CI ou em um servidor headless onde ollama signin interativo não é prático, crie uma chave de API nas configurações da sua conta Ollama e exponha-a como uma variável de ambiente:

export OLLAMA_API_KEY=ollama_...
ollama pull minhaorg/modelo-privado

A variável OLLAMA_API_KEY é pegada automaticamente por cada comando e solicitação de API do Ollama — sem necessidade de executar ollama signin em cada máquina.

Usando o comando ollama run com arquivos (resumir, redirecionar)

• Resumir Texto de um Arquivo:

  ollama run llama3.2 "Resuma o conteúdo deste arquivo em 50 palavras." < entrada.txt
  

  Este comando resume o conteúdo de entrada.txt usando o modelo especificado.

• Registrar Respostas do Modelo em um Arquivo:

  ollama run llama3.2 "Conte-me sobre energia renovável." > saida.txt
  

  Este comando salva a resposta do modelo em saida.txt.

Casos de uso da CLI Ollama (geração de texto, análise)

• Geração de Texto:

  • Resumir um arquivo de texto grande:

    ollama run llama3.2 "Resuma o seguinte texto:" < documento-longo.txt
    

  • Gerar conteúdo:

    ollama run llama3.2 "Escreva um artigo curto sobre os benefícios de usar IA na saúde." > artigo.txt
    

  • Responder perguntas específicas:

    ollama run llama3.2 "Quais são as últimas tendências em IA e como elas afetarão a saúde?"
    

  .

• Processamento e Análise de Dados:

  • Classificar texto em sentimento positivo, negativo ou neutro:

    ollama run llama3.2 "Analise o sentimento desta avaliação do cliente: 'O produto é fantástico, mas a entrega foi lenta.'"
    

  • Categorizar texto em categorias predefinidas: Use comandos semelhantes para classificar ou categorizar texto com base em critérios predefinidos.

Usando Ollama com Python (cliente e API)

• Instalar Biblioteca Python Ollama:

  pip install ollama
  

• Gerar Texto Usando Python:

  import ollama
  
  response = ollama.generate(model='gemma:2b', prompt='o que é um qubit?')
  print(response['response'])
  

  Este snippet de código gera texto usando o modelo e prompt especificados.

Para integração avançada em Python, explore usando a API de Busca na Web do Ollama em Python, que cobre capacidades de busca na web, chamada de ferramentas e integração com servidores MCP. Se você está construindo aplicativos alimentados por IA, nossa comparação de Assistentes de Codificação de IA pode ajudar você a escolher as ferramentas certas para o desenvolvimento.

Procurando uma interface baseada na web? Open WebUI fornece uma interface auto-hospedada com capacidades RAG e suporte multi-usuário. Para implantações de produção de alto desempenho, considere vLLM como uma alternativa. Para comparar o Ollama com outras escolhas de infraestrutura de LLM local e em nuvem, veja Hospedagem de LLMs: Infraestrutura Local, Auto-hospedada e em Nuvem Comparada.

Links úteis

Configuração e Gerenciamento

• Mover Modelos Ollama para Outro Drive ou Pasta

Alternativas e Comparações

• Hospedagem Local de LLMs: Guia Completo 2026 - Ollama, vLLM, LocalAI, Jan, LM Studio & Mais
• Início Rápido vLLM: Servimento de LLM de Alto Desempenho
• Docker Model Runner vs Ollama: Qual Escolher?
• Primeiros Sinais da Enshittification do Ollama
• Ollama para vLLM: Quando Migrar Seu Servidor Local de LLM

Desempenho e Hardware

• Como o Ollama Lida com Solicitações Paralelas
• Como o Ollama Usa os Núcleos de Desempenho e Eficientes da CPU Intel
• NVIDIA DGX Spark vs Mac Studio vs RTX-4080: Comparação de Desempenho Ollama
• DGX Spark vs. Mac Studio: Uma Análise Prática e Verificada de Preço do Supercomputador Pessoal de IA da NVIDIA

Integração e Desenvolvimento

• Usando a API de Busca na Web do Ollama em Python
• Comparação de Assistentes de Codificação de IA
• Open WebUI: Interface de LLM Auto-hospedada
• UIs de Chat de Código Aberto para LLMs em Instâncias Locais do Ollama
• Restringindo LLMs com Saída Estruturada: Ollama, Qwen3 & Python ou Go
• Integrando Ollama com Python: Exemplos de API REST e Cliente Python
• SDKs Go para Ollama - comparação com exemplos