Resumo de Comandos do Ollama CLI: ls, serve, run, ps + comandos (atualização de 2026)

Este resumo de comandos 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 e 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 do Ollama foca em comandos de linha de comando, gerenciamento de modelos e personalização, Mas temos aqui também algumas chamadas de curl.

Para uma visão completa de onde o Ollama se encaixa entre as opções locais, auto-hospedadas e em nuvem — incluindo vLLM, Docker Model Runner, LocalAI e provedores de nuvem — veja Hospedagem de LLM: Infraestrutura Local, Auto-Hospedada e em Nuvem Comparadas. Se você está comparando diferentes soluções de hospedagem de LLM locais, confira nosso comparativo abrangente do Ollama, vLLM, LocalAI, Jan, LM Studio e mais. Para aqueles que buscam alternativas a interfaces de linha de comando, o Docker Model Runner oferece uma abordagem diferente para a implantação de LLM.

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

• Opção 1: Download do Site
  • Visite ollama.com e baixe o 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 insira sua senha se solicitado.

Requisitos de sistema do Ollama (RAM, armazenamento, CPU)

• Sistema Operacional: Mac, Linux ou Windows
• Memória (RAM): 8GB mínimo, 16GB ou mais recomendado
• Armazenamento: Pelo menos ~10GB de espaço livre (os arquivos de modelo podem ser muito grandes, veja aqui mais sobre Mover Modelos do Ollama para Outra Unidade )
• Processador: Uma CPU relativamente moderna (dos últimos 5 anos). Se você está 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 Eficiência da CPU Intel.

Para cargas de trabalho de IA sérias, você pode querer comparar opções de hardware. Testamos desempenho do NVIDIA DGX Spark vs Mac Studio vs RTX-4080 com Ollama, e se você está considerando investir em hardware de alta ponta, nossa comparação de preços e capacidades do DGX Spark oferece 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) · Mergulho profundo em solicitações paralelas

CLI do Ollama (o que é)

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

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

Gerenciamento de modelos do Ollama: comandos pull e list

Listar Modelos:

ollama list

o mesmo que:

ollama ls

Este comando lista todos os modelos que foram baixados para o 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 o seu sistema. Os arquivos de modelo podem ser bastante grandes, então fique atento ao espaço usado pelos modelos no disco rígido ou SSD. Você pode até querer mover todos os modelos Ollama do diretório home para outra unidade maior e melhor

Enviar um Modelo: ollama push

ollama push my-custom-model

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

ollama push myuser/my-model --insecure

Copiar um Modelo: ollama cp

ollama cp llama3.2 my-llama3-variant

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

ollama cp qwen3:14b qwen3-14b-custom
ollama create qwen3-14b-custom -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 de 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 amigável ao systemd):

# defina variáveis de ambiente, depois inicie o servidor
# torne 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. Devo responder como ChatGPT, um modelo de linguagem de IA, treinado pela OpenAI, 
etc. Forneça uma breve introdução. Provavelmente pergunte se precisam de ajuda.
...pensamento concluído.

Sou o ChatGPT, um modelo de linguagem de IA criado pela OpenAI. Foi treinado em uma ampla gama de textos para que eu possa ajudar 
a responder perguntas, gerar ideias, explicar conceitos, redigir textos, solucionar problemas e muito mais. Pense 
em mim como um assistente virtual versátil — aqui para fornecer informações, suporte e conversação sempre que precisar. Como posso ajudar você 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 modo não interativo:

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

Se você quiser ver uma resposta detalhada do LLM na sessão do 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 manter amigável.
...pensamento concluído.

Sou o ChatGPT, um grande modelo de linguagem criado pela OpenAI. Estou aqui para ajudar a responder perguntas, oferecer explicações, 
gerar ideias e conversar sobre uma ampla gama de tópicos — de ciência e história a 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 de carregamento:        106.690543ms
contagem de avaliação de prompt:    71 token(s)
duração de avaliação de prompt: 30.507392ms
taxa de avaliação de prompt:     2327.30 tokens/s
contagem de avaliação:           132 token(s)
duração de avaliação:        945.801569ms
taxa de avaliação:            139.56 tokens/s
>>> /bye
$ 

Sim, é isso mesmo, 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 vários aplicativos, inicie o servidor com ollama serve e use o cliente da API em vez de sessões interativas longas.

Flags do comando 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 várias flags -p:

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

# Execute 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 múltiplas linhas no REPL

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

>>> """Resuma isso em uma frase:
... O rápido raposa pula sobre o preguiçoso cão.
... 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 geram um array JSON em vez de texto. Encaminhe texto diretamente para embeddings rápidos:

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 encaminhar saída para jq ou um script que espera dados estruturados.

Comando Ollama stop

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

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

O Ollama expulsa modelos automaticamente após algum tempo. Você pode especificar este tempo, mas o padrão é 4 minutos. Se você não quiser esperar o tempo restante, pode querer usar este comando ollama stop. Você também pode remover 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 os modelos e sessões em execução atualmente (útil para depurar “por que minha VRAM está cheia?”).

ollama ps

O exemplo da saída do 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 VRAM de 16GB da minha GPU e ocupou apenas 14GB.

Se eu executar ollama run gpt-oss:120b e depois chamar o ollama ps, o resultado não será tão brilhante: 78% das camadas estão na CPU, e isso é apenas com a janela de contexto de 4096 tokens. Será maior 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 de uma linha, sem configuração, para assistentes de codificação de IA populares executados contra seu servidor Ollama local.

Por que usar ollama launch?

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

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

Integrações suportadas

Uso básico

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

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

# Inicie com um modelo específico
ollama launch claude --model qwen3-coder

# Configure 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 o histórico de conversas de várias voltas. O Ollama recomenda modelos com pelo menos 64 000 tokens de contexto:

Se sua GPU não puder acomodar o modelo, o Ollama também oferece variantes hospedadas na nuvem (por exemplo, qwen3-coder:480b-cloud), que se integram da mesma forma, mas roteiam 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. Inicie o 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 normalmente faria — a única diferença é que a inferência ocorre no seu próprio hardware.

Ajustes de desempenho (OLLAMA_NUM_PARALLEL)

Se você vir filas ou tempos de espera sob carga, a primeira alavanca a aprender é OLLAMA_NUM_PARALLEL.

• OLLAMA_NUM_PARALLEL = quantas solicitações o Ollama executa em paralelo.
• Um valor mais alto pode aumentar a vazão, 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 após você terminar 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 vários modelos e quer gerenciar o uso de 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 de roteador do llama-server cobre a abordagem nativa do llama.cpp para alternância 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, responda em inglês simples, evitando jargão técnico sempre que possível
  >>> /save ipe
  >>> /bye
  

  Depois, 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, custom_model.txt) com a seguinte estrutura:

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

  Depois, execute:

  ollama create mymodel -f custom_model.txt
  ollama run mymodel
  

  Isso cria um modelo personalizado baseado nas instruções do 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 logado, o cliente armazena as credenciais localmente e as reutiliza automaticamente para comandos subsequentes.

O que signin desbloqueia:

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

Alternativa: autenticação por chave de API

Se você estiver executando o Ollama em um pipeline de CI ou um servidor headless onde a interação ollama signin não é prática, 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 myorg/private-model

A variável OLLAMA_API_KEY é captada 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." < input.txt
  

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

• Registrar Respostas do Modelo em um Arquivo:

  ollama run llama3.2 "Fale-me sobre energia renovável." > output.txt
  

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

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

• Geração de Texto:

  • Resumindo um arquivo de texto grande:

    ollama run llama3.2 "Resuma o seguinte texto:" < long-document.txt
    

  • Gerando conteúdo:

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

  • Respondendo 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:

  • Classificando texto em sentimento positivo, negativo ou neutro:

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

  • Categorizando 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 do 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 trecho de código gera texto usando o modelo e o prompt especificados.

Para integração avançada com Python, explore [usando a API de Pesquisa Web do Ollama em Python](https://www.glukhov.org/pt/llm-hosting/ollama/ollama-web-search-in-python/ “Domine a API nativa de Pesquisa Web do Ollama com Python. Aprenda a usar funções web_search e web_fetch, construa agentes de pesquisa inteligentes com chamada de ferramentas e integre com servidores MCP para Cline e Codex. Inclui exemplos completos de código.), que cobre capacidades de pesquisa na web, chamada de ferramentas e integração com servidores MCP. Se você está construindo aplicativos alimentados por IA, nosso comparativo 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 Ollama com outras opções de infraestrutura de LLM local e em nuvem, veja Hospedagem de LLM: Infraestrutura Local, Auto-Hospedada e em Nuvem Comparadas.

Links Úteis

Configuração e Gerenciamento

• Mover Modelos do Ollama para Outra Unidade ou Pasta

Alternativas e Comparações

• Hospedagem de LLM Local: Guia Completo 2026 - Ollama, vLLM, LocalAI, Jan, LM Studio & Mais
• Início Rápido vLLM: Servindo LLM de Alto Desempenho
• Docker Model Runner vs Ollama: Qual Escolher?
• Primeiros Sinais da Enshittificação do Ollama

Desempenho e Hardware

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

Integração e Desenvolvimento

• Usando a API de Pesquisa Web do Ollama em Python
• Comparação de Assistente de Codificação de IA
• Open WebUI: Interface LLM Auto-Hospedada
• Interfaces de Chat Open-Source 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