Folha de Dicas da CLI do Ollama: ls, serve, run, ps + comandos (atualização de 2026)

Este Guia Rápido do CLI do Ollama se concentra 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 sobre “parafusos de desempenho” para ajudá-lo a descobrir (e depois mergulhar profundamente) OLLAMA_NUM_PARALLEL e configurações relacionadas.

Este guia do Ollama se concentra em comandos do CLI, gerenciamento de modelos e personalização, Mas também tem aqui alguns curl chamadas.

Para uma visão geral 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 Hostagem de LLM: Comparação entre Local, Auto-Hospedado e Infraestrutura em Nuvem. Se você está comparando diferentes soluções locais de hostagem de LLM, consulte nossa comparação abrangente entre Ollama, vLLM, LocalAI, Jan, LM Studio e mais. Para aqueles que buscam alternativas a interfaces de linha de comando, Docker Model Runner oferece uma abordagem diferente para a implantação de LLM.

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

• Opção 1: Faça o download do site
  • Visite ollama.com e faça o download do instalador para seu sistema operacional (Mac, Linux ou Windows).
• Opção 2: Instale 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 do sistema do Ollama (RAM, armazenamento, CPU)

• Sistema Operacional: Mac, Linux ou Windows
• Memória (RAM): Mínimo 8GB, recomendado 16GB ou mais
• Armazenamento: Pelo menos ~10GB de espaço livre (os arquivos do modelo podem ser realmente grandes, veja mais Mova os Modelos do Ollama para um Disco Diferente)
• 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 utiliza o desempenho e núcleos 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 alto desempenho, nossa comparação de preços e capacidades do DGX Spark fornece análise detalhada de custos.

Comandos Básicos do CLI do Ollama

Links de pulo: Comando Ollama serve · Comando Ollama launch (integrações de assistentes de codificação AI) · Comando Ollama run · Flags do comando Ollama run · Comando Ollama ps · Comando Ollama show · Ollama signin e signout (autenticação no registro) · Comandos básicos do CLI do Ollama · Parafusos de desempenho (OLLAMA_NUM_PARALLEL) · Análise detalhada de solicitações paralelas

CLI do Ollama (o que é)

CLI do Ollama é a interface de linha de comando para gerenciar modelos e executar/servir localmente. A maioria dos fluxos de trabalho se reduz 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 models

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 do modelo podem ser bastante grandes, então fique atento ao espaço usado pelos modelos no disco rígido, ou SSD. Você pode até mesmo querer mover todos os modelos do Ollama de seu diretório de casa para outro disco maior e melhor

Enviar um Modelo: ollama push

ollama push my-custom-model

Envia um modelo local para o registro Ollama para que outros possam baixá-lo. Você precisa estar autenticado 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 registro 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 sob um novo nome sem re-baixar 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-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 do embedding, quantização, etc.). Há três flags úteis:

# Veja exatamente 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 no nível de tensor (útil ao depurar a 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 do Ollama (porta HTTP padrão 11434).

ollama serve

“Comando ollama serve” (exemplo amigável para systemd):

# defina variáveis de ambiente, depois inicie o servidor
# torne 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 uma sessão interativa REPL para interação. Quer entender como o Ollama gerencia múltiplas solicitações simultâneas? Aprenda 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 o ChatGPT, um modelo de linguagem AI treinado pela OpenAI, 
etc. Forneça uma breve introdução. Provavelmente pergunte se precisam de ajuda.
...terminou de pensar.

Sou o ChatGPT, um modelo de linguagem AI criado pela OpenAI. Fui treinado em uma ampla gama de texto para ajudar 
responder perguntas, brainstorming de ideias, explicar conceitos, redigir textos, resolver problemas e muito mais. Pense 
em mim como um assistente virtual versátil — aqui para fornecer informações, suporte e conversa sempre que precisar 
dele. 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 pergunta única em modo não interativo:

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

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

$ 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. Podemos também mencionar capacidades. O usuário provavelmente espera uma breve introdução. Manteremos 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, 
brainstorming de 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 o que você gostaria de conversar!

total duration:       1.118585707s
load duration:        106.690543ms
prompt eval count:    71 token(s)
prompt eval duration: 30.507392ms
prompt eval rate:     2327.30 tokens/s
eval count:           132 token(s)
eval duration:        945.801569ms
eval rate:            139.56 tokens/s
>>> /bye
$ 

Sim, está certo, é 139 tokens por segundo. O gpt-oss:20b é muito rápido. Se você, como eu, tiver 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 quiser que o modelo esteja disponível por 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 Comando Ollama run (referência completa)

Sobrescrever parâmetros de 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:

# Aumente a janela de contexto e reduza 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 dessa forma:

Entrada de múltiplas linhas no REPL

Envolva o texto em aspas triplas (`" "" “) para entrar em um prompt de múltiplas linhas sem submeter cedo:

>>> """Resuma isso em uma frase:
... O raposo marrom rápido pula sobre o cão preguiçoso.
... Isso 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 embeddings saída um array JSON em vez de texto. Encaminhe o texto diretamente para embeddings rápidos de uma só vez:

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

Para trabalhos de embedding de produção use o endpoint REST /api/embeddings ou o cliente Python em vez disso.

Forçar saída JSON (–format)

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

O modelo é instruído a retornar JSON válido. Útil quando encaminhar a 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

Ollama evita modelos automagicamente após algum tempo. Você pode especificar este tempo, o padrão é 4 minutos. Se 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 /generate API com o parâmetro keep_alive=0, veja abaixo para a descrição e 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

Um 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 o gpt-oss:20b se encaixa muito bem no meu GPU de 16GB de VRAM 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 bom: 78% das camadas estão no CPU, e isso é apenas com a janela de contexto de 4096 tokens. Seria pior 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 assistentes de codificação AI)

ollama launch é um comando introduzido em Ollama v0.15 (Janeiro de 2026) que fornece configuração zero, uma linha para assistentes de codificação AI populares executando 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 de API certo e escolher um modelo compatível. ollama launch lida com tudo isso para você interativamente.

Se você já executa Ollama localmente e quer um assistente de codificação agente 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 inteiro do arquivo e histórico de conversação multi-turno. Ollama recomenda modelos com pelo menos 64 000 tokens de contexto:

Se sua GPU não puder caber o modelo, Ollama também oferece variantes hospedadas em 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. Lançar Claude Code contra ele
ollama launch claude --model qwen3-coder

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 acontece no seu próprio hardware.

Parafusos de desempenho (OLLAMA_NUM_PARALLEL)

Se você vê filas ou timeout sob carga, o primeiro parafuso a aprender é OLLAMA_NUM_PARALLEL.

• OLLAMA_NUM_PARALLEL = quantas solicitações o Ollama executa em paralelo.
• Um valor mais alto pode aumentar a taxa de transferência, 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 o modelo do Ollama da VRAM (keep_alive)

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

• Libere o Modelo da VRAM usando curl:

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

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

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

• Libere o Modelo da VRAM usando Python:

import requests

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

Isso é especialmente útil quando:

• Você precisa liberar a memória da GPU para outros aplicativos
• Você está executando múltiplos 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 o modelo da VRAM imediatamente.

Personalizando modelos do 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 o jargão técnico tanto quanto possível
  >>> /save ipe
  >>> /bye
  

  Em seguida, 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]
  

  Em seguida, execute:

  ollama create mymodel -f custom_model.txt
  ollama run mymodel
  

  Isso cria um modelo personalizado com base nas instruções no arquivo”.

Ollama signin e signout (autenticação no registro)

ollama signin
ollama signout

ollama signin autentica sua instalação local do Ollama com o registro do Ollama em ollama.com. Após o login, o cliente armazena as credenciais localmente e as reutiliza automaticamente para comandos subsequentes.

O que o signin desbloqueia:

• Puxar e empurrar modelos privados de sua conta ou organização.
• Usar modelos hospedados em nuvem (por exemplo, qwen3-coder:480b-cloud) que são muito grandes para serem executados localmente.
• Publicar modelos no registro com ollama push.

Alternativa: Autenticação com chave API

Se você estiver executando Ollama em um pipeline de CI ou em um servidor sem cabeça onde a autenticação interativa ollama signin não é prática, crie uma chave API em suas configurações de conta do 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 é capturada automaticamente por cada comando do Ollama e solicitação de API — não é necessário executar ollama signin em cada máquina.

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

• Resumir o texto de um arquivo:

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

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

• Registrar respostas do modelo em um arquivo:

  ollama run llama3.2 "Me conte sobre energia renovável." > output.txt
  

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

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

• Geração de texto:

  • Resumir um grande arquivo de texto:

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

  • Gerar conteúdo:

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

  • Responder a 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 de dados e análise:

  • Classificar o texto em sentimentos positivos, negativos ou neutros:

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

  • Categorizar o texto em categorias pré-definidas: Use comandos semelhantes para classificar ou categorizar o texto com base em critérios pré-definidos.

Usando o Ollama com Python (cliente e API)

• Instalar a 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 usar a API de pesquisa da web do Ollama em Python, que abrange capacidades de pesquisa da web, chamada de ferramentas e integração com servidores MCP. Se você está construindo aplicações com IA, nossa comparação de assistentes de codificação AI pode ajudá-lo a escolher as ferramentas certas para o desenvolvimento.

Buscando uma interface baseada em web? Abra WebUI fornece uma interface auto-hospedada com capacidades de RAG e suporte multi-usuario. Para implantações de alto desempenho em produção, considere vLLM como alternativa. Para comparar Ollama com outras opções de infraestrutura local e em nuvem de LLM, veja Hostagem de LLM: Comparação entre Local, Auto-Hospedado e Infraestrutura em Nuvem.

Links úteis

Configuração e Gerenciamento

• Mover Modelos do Ollama para um Disco ou Pasta Diferente

Alternativas e Comparações

• Hostagem Local de LLM: Guia Completo de 2026 - Ollama, vLLM, LocalAI, Jan, LM Studio & Mais
• vLLM Quickstart: Serviço de LLM de Alto Desempenho
• Docker Model Runner vs Ollama: Qual Escolher?
• Primeiros Sinais de Enshittification do Ollama

Desempenho e Hardware

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

Integração e Desenvolvimento

• Usando a API de Pesquisa da Web do Ollama em Python
• Comparação de Assistentes de Codificação AI
• Open WebUI: Interface Auto-Hospedada para LLMs
• 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