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

Este guia rápido da CLI 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 a referência completa das variáveis de ambiente do ollama serve (OLLAMA_NUM_PARALLEL, OLLAMA_CONTEXT_LENGTH, OLLAMA_KV_CACHE_TYPE e afins), as flags de modelos de raciocínio (--think, --hidethinking) e as integrações expandidas do ollama launch para assistentes de codificação com IA. Os comandos e flags abaixo foram verificados contra a Ollama v0.33.2 (outubro de 2026).

Este guia rápido da Ollama foca em comandos de CLI, gerenciamento de modelos e personalização, mas também inclui algumas chamadas curl.

Para uma visão completa de como a Ollama se encaixa entre as opções locais, auto-hospedadas e em nuvem — incluindo vLLM, Docker Model Runner, LocalAI e provedores em nuvem — veja Hospedagem de LLMs: Infraestrutura Local, Auto-Hospedada e em Nuvem Comparada. Se você está comparando diferentes soluções de hospedagem local de LLMs, confira nossa comparação abrangente de 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 LLMs. Se o tráfego concorrente ou a fila começar a sobrecarregar uma única instância da Ollama, Ollama para vLLM: Quando Migrar Seu Servidor Local de LLMs aborda os sinais de migração e um plano de implantação gradual.

Instalação da Ollama (download e instalação via 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 da Ollama (RAM, armazenamento, CPU)

• Sistema Operacional: Mac, Linux ou Windows
• Memória (RAM): mínimo de 8GB, recomendado 16GB ou mais
• Armazenamento: pelo menos ~10GB de espaço livre (os arquivos de modelos podem ser muito grandes — veja a seção de gerenciamento de modelos abaixo para relocá-los)
• Processador: Uma CPU relativamente moderna (dos últimos 5 anos). Se você está curioso sobre como a Ollama utiliza diferentes arquiteturas de CPU, veja nossa análise de como a Ollama usa os núcleos de desempenho e eficientes da CPU Intel.

Comandos básicos da CLI da Ollama

Executar apenas ollama sem argumentos agora abre o mesmo menu de lançador interativo que ollama launch — você escolhe uma integração e um modelo de uma lista.

CLI da Ollama (o que é)

A CLI da Ollama é a interface de linha de comando para gerenciar modelos e executá-los/serve-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/em execução: ollama ps
• Gerenciar modelos: ollama pull, ollama list, ollama rm
• Lançar um assistente de codificação com IA: ollama launch

Gerenciamento de modelos da 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 weeks ago     
gemma3:12b-it-qat                                       5d4fa005e7bb    8.9 GB    2 weeks ago     
LoTUs5494/mistral-small-3.1:24b-instruct-2503-iq4_NL    4e994e0f85a0    13 GB     3 weeks ago     
dengcao/Qwen3-Embedding-8B:Q4_K_M                       d3ca2355027f    4.7 GB    4 weeks ago     
dengcao/Qwen3-Embedding-4B:Q5_K_M                       7e8c9ad6885b    2.9 GB    4 weeks ago     
qwen3:8b                                                500a1f067a9f    5.2 GB    5 weeks ago     
qwen3:14b                                               bdbd181c33f2    9.3 GB    5 weeks ago     
qwen3:30b-a3b                                           0b28110b7a33    18 GB     5 weeks ago     
devstral:24b                                            c4b2fa0c33d7    14 GB     5 weeks ago  

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 mantenha um olho no espaço usado pelos modelos no disco rígido, ou ssd. Você pode até querer mover todos os modelos da Ollama do seu diretório home para outro drive maior e melhor

Enviar um Modelo: ollama push

ollama push my-custom-model

Envia um modelo local para o registro da 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 da Ollama, por exemplo myuser/my-model. Use --insecure se você 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 com 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

Remover Modelos: ollama rm

ollama rm qwen3:8b
# versões mais novas aceitam vários modelos em uma única chamada:
ollama rm qwen3:8b qwen3:14b

ollama rm exclui o manifesto do modelo e quaisquer blobs que não sejam mais referenciados por outros modelos, para que as camadas base compartilhadas de modelos derivados sejam mantidas.

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 de contexto, comprimento de incorporação, quantização, etc.). Há seis flags úteis:

# Veja exatamente com qual prompt do 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

# Apenas o prompt do sistema de um modelo personalizado
ollama show mymodel --system

# Verifique a licença antes de distribuir um modelo dentro de um produto
ollama show llama3.2 --license

# Detalhe completo de 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 dele em vez de escrever um do zero.

Comando Ollama serve

ollama serve inicia o servidor local da 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 a ollama disponível no endereço IP do host
export OLLAMA_HOST=0.0.0.0:11434
export OLLAMA_NUM_PARALLEL=2
ollama serve

ollama start é um apelido para ollama serve, então ambos iniciam o mesmo servidor.

Vincular a 0.0.0.0 expõe o servidor à sua rede sem autenticação — coloque um proxy reverso com TLS na frente dele, como descrito em Ollama atrás de um proxy reverso com Caddy ou Nginx, ou acesse-o por um túnel privado seguindo os padrões de acesso remoto da Ollama. Para executar o servidor em um container em vez disso, veja Ollama em Docker Compose com GPU e armazenamento persistente de modelos.

Variáveis de ambiente do Ollama serve (referência completa)

Estas são as variáveis de ambiente que ollama serve lê na inicialização (como na Ollama v0.33):

Por exemplo, para aumentar a janela de contexto padrão para cada modelo:

OLLAMA_CONTEXT_LENGTH=32768 ollama serve

Comprimento de contexto padrão por VRAM

Quando OLLAMA_CONTEXT_LENGTH não está definido, o servidor escolhe um padrão em camadas com base na VRAM total da sua máquina (adicionado na Ollama v0.15.5):

A Ollama recomenda pelo menos 64.000 tokens para cargas de trabalho famintas por contexto — pesquisa web, agentes e ferramentas de codificação — e a pegada de memória escala com OLLAMA_NUM_PARALLEL, então uma configuração de paralelo alta combinada com um contexto padrão grande pode empurrar camadas de modelo para fora da VRAM. O servidor registra o valor escolhido como vram-based default context na inicialização.

O tipo de cache KV troca memória por velocidade — quantizar a cache KV para q8_0 reduz aproximadamente pela metade sua pegada de VRAM e se adequa a execuções de contexto longo; nosso teste de cache KV em GPU de 16GB com contexto longo mede o efeito real. OLLAMA_NUM_PARALLEL e OLLAMA_MAX_QUEUE são detalhados em Como a Ollama lida com solicitações paralelas.

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 a Ollama gerencia múltiplas solicitações concorrentes? Aprenda mais sobre como a 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ê?" Simples pergunta. Devo responder como ChatGPT, um modelo de linguagem de IA, treinado por OpenAI, 
etc. Fornecer breve introdução. Provavelmente perguntar se precisam de ajuda.
...terminou de pensar.

Eu sou o ChatGPT, um modelo de linguagem de IA criado pela OpenAI. Fui treinado em uma ampla variedade de textos para que eu possa ajudar 
a responder perguntas, brainstorm de 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. Como posso ajudar você hoje?

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

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

>>> /bye
$ 

Exemplos de comandos Ollama run

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

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

Se você quer ver a resposta detalhada do LLM em modo verboso 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 modelo de linguagem grande treinado pela OpenAI. Podemos também mencionar capacidades. O usuário provavelmente espera 
uma breve introdução. Vamos mantê-la amigável.
...terminou de pensar.

Eu sou o ChatGPT, um modelo de linguagem grande criado pela OpenAI. Estou aqui para ajudar a responder perguntas, oferecer explicações, 
brainstorm de ideias e conversar sobre uma ampla variedade 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!

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, 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 de LLM em Melhores LLMs para Ollama em GPU de 16GB 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 longas sessões interativas.

Flags do Ollama run (referência completa)

Duas variáveis de ambiente afetam o ollama run em si: OLLAMA_EDITOR define o editor aberto por Ctrl+G no REPL, e OLLAMA_NOHISTORY=1 desabilita a persistência de histórico do readline.

Modelos de raciocínio: –think e –hidethinking

Modelos com capacidade de raciocínio (deepseek-r1, qwen3, gpt-oss e afins) pensam por padrão na CLI, e o rastro de raciocínio é impresso antes da resposta:

ollama run qwen3:14b --think=false "Responda diretamente, sem rastro de raciocínio"
ollama run deepseek-r1:8b --hidethinking "9.9 é maior que 9.11?"   # pensa, mas imprime apenas a resposta

Modelos GPT-OSS aceitam níveis em vez de um booleano — eles ajustam o comprimento do rastro em vez de ligá-lo ou desligá-lo:

ollama run gpt-oss:20b --think=low "Rascunhe um título"

Dentro da sessão interativa, alterne o raciocínio com /set think e /set nothink.

Sobrescrever parâmetros de modelo sem um Modelfile

Posts de blog mais antigos mostram uma flag -p / --parameters no ollama run; ela não existe mais em lançamentos atuais. O método suportado para alterar parâmetros de inferência sem editar um Modelfile é o REPL:

$ ollama run qwen3:14b
>>> /set parameter num_ctx 32768
Set parameter 'num_ctx' to '32768'
>>> /save qwen3-14b-32k
>>> /bye

/set parameter se aplica apenas à sessão atual, e /save o persiste em um novo modelo local que você pode executar depois com ollama run qwen3-14b-32k. /show parameters lista as configurações na sessão atual. Para todos os modelos em um servidor, OLLAMA_CONTEXT_LENGTH no ollama serve altera a janela de contexto padrão globalmente.

Parâmetros comuns que você pode definir desta forma:

ollama show <model> relata o comprimento de contexto que o modelo pode suportar, enquanto ollama ps mostra o contexto efetivamente alocado para a instância carregada — veja comando Ollama ps se um prompt longo parece estar sendo truncado silenciosamente.

Entrada multilinha no REPL

Envolva o texto em aspas triplas (""") para inserir um prompt multilinha sem enviar cedo demais:

>>> """Resuma isto em uma frase:
... O rapinante correu sobre o cachorro preguiçoso.
... Isso aconteceu numa terça-feira.
... """

Para prompts mais longos, Ctrl+G abre o prompt atual em um editor de texto completo ($EDITOR, ou para onde OLLAMA_EDITOR aponta) e o envia quando você salvar e sair — útil para iterar em um prompt de sistema longo (adicionado na Ollama v0.16).

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 incorporações via CLI

Modelos de incorporação produzem um array JSON em vez de texto. Encaminhe texto diretamente para incorporações rápidas de uso único:

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

Duas flags do ollama run são específicas para modelos de incorporação: --dimensions 512 trunca o vetor de saída para 512 dimensões (útil para modelos com capacidade Matryoshka como nomic-embed quando você quer vetores menores), e --truncate=false faz entradas mais longas que o contexto do modelo retornarem um erro em vez de serem truncadas silenciosamente.

Para cargas de trabalho de incorporação em produção, use o endpoint REST /api/embed ou o cliente Python em vez disso.

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 para o modelo especificado em execução.

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

A Ollama expulsa modelos automaticamente após algum tempo. O padrão é 5 minutos (OLLAMA_KEEP_ALIVE=5m); lançamentos mais antigos da Ollama usavam 4 minutos. Se você não quiser esperar o tempo restante, use o comando ollama stop. Ao iniciar o modelo, você também pode passar --keepalive para ollama run (por exemplo, --keepalive 30s, --keepalive -1 para manter o modelo carregado para sempre), ou chamar o endpoint de API /generate com o parâmetro keep_alive=0 para expulsar o modelo da VRAM imediatamente — veja abaixo a descrição e o exemplo.

Comando Ollama ps

ollama ps mostra os modelos em execução atuais e sessões (ú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 minutes from now

A coluna CONTEXT é o contexto efetivamente alocado para esta instância carregada. Differe de ollama show <model>, que relata o comprimento de contexto que o modelo suporta — se um modelo truncar seus prompts longos silenciosamente, ollama ps é o comando que revela o valor real de tempo de execução.

Você vê aqui no meu PC que o gpt-oss:20b cabe muito bem nos 16GB de VRAM da minha GPU, e ocupou apenas 14GB.

Se eu executar ollama run gpt-oss:120b e então chamar 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 — a pegada de memória cresce mais se eu aumentar o contexto.

NAME            ID              SIZE     PROCESSOR          CONTEXT    UNTIL
gpt-oss:120b    a951a23b46a1    66 GB    78%/22% CPU/GPU    4096       4 minutes from now

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

ollama launch é um comando introduzido na Ollama v0.15 (janeiro de 2026) que oferece configuração sem ajustes, em uma linha, para populares assistentes de codificação com IA executados contra seu servidor local da Ollama.

Por que usar ollama launch?

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

Se você já executa a Ollama localmente e quer 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 para lá.

Integrações suportadas

A lista cresceu muito além das quatro integrações da v0.15. Como na Ollama v0.33, ollama launch suporta:

Uso básico

# Seletor interativo — escolha uma integração e um modelo de um menu
# (o seletor de modelo é sempre mostrado desde a v0.16.3)
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

# Reiniciar uma integração para seu perfil padrão
ollama launch codex --restore

# Passar argumentos extras para a integração após --
ollama launch codex -- --sandbox workspace-write

--yes (-y) responde automaticamente aos prompts de confirmação, o que é útil em scripts e fluxos de onboarding.

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 conversa de múltiplas rodadas. A Ollama recomenda modelos com pelo menos 64 000 tokens de contexto:

Se sua GPU não consegue acomodar o modelo, a 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 da 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. Lance o Claude Code contra ele
ollama launch claude --model qwen3-coder

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

Alavancas de desempenho (OLLAMA_NUM_PARALLEL)

Se você vir enfileiramento ou timeouts sob carga, a primeira alavanca a aprender é OLLAMA_NUM_PARALLEL.

• OLLAMA_NUM_PARALLEL = quantas solicitações a Ollama executa em paralelo.
• Um valor mais alto pode aumentar a vazão, mas pode aumentar a pressão de VRAM e picos de latência.
• Solicitações que chegam enquanto todos os slots paralelos estão ocupados caem na fila; sua profundidade é limitada por OLLAMA_MAX_QUEUE.

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 a Ollama lida com solicitações paralelas

Liberando modelo da 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 explicitamente liberar um modelo da VRAM e libertar memória da GPU, você pode enviar uma solicitação para a API da Ollama com keep_alive: 0.

• Liberar Modelo da VRAM usando curl:

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

Substitua NOMEDODELMO 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 de VRAM
• Você terminou de usar um modelo grande e quer liberar recursos imediatamente

Nota: O parâmetro keep_alive controla 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, um valor negativo (por exemplo, -1) mantém o modelo carregado para sempre, e uma string de duração (por exemplo, 10m, 24h) também é aceita. O padrão global do servidor é OLLAMA_KEEP_ALIVE=5m, e um keep_alive por solicitação sempre o sobrescreve.

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

Personalizando modelos da Ollama (prompt do sistema, Modelfile)

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

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

  Então, execute o modelo personalizado:

  ollama run ipe
  

  Isso define um prompt do 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
  PARAMETER num_ctx 32768
  SYSTEM [Suas instruções personalizadas aqui]
  

  Então, execute:

  ollama create mymodel -f custom_model.txt
  ollama run mymodel
  

  Isso cria um modelo personalizado com base nas instruções no arquivo. ollama create também pode quantizar enquanto constrói — -q q4_K_M produz um GGUF Q4_K_M de uma fonte não quantizada (safetensors), --draft-quantize define a quantização para um modelo de rascunho (decodificação especulativa), e --experimental habilita recursos de criação de modelos safetensors que ainda são marcados como experimentais.

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

ollama signin
ollama signout

ollama signin autentica sua instalação local da Ollama com o registro da Ollama em ollama.com. Uma vez autenticado, o cliente armazena credenciais localmente e as reutiliza automaticamente para comandos subsequentes.

O que o 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 grandes demais para executar localmente.
• Publicar modelos no registro com ollama push.

Alternativa: autenticação por chave de API

Se você está executando a Ollama em um pipeline de CI ou em um servidor headless onde o ollama signin interativo não é prático, crie uma chave de API nas configurações da sua conta da 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 é pega automaticamente por cada comando da Ollama e solicitação de API — não é preciso 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 "Me conte sobre energia renovável." > output.txt
  

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

Casos de uso da CLI da 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:" < long-document.txt
    

  • Gerar conteúdo:

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

  • Respondendo 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?"
    

  • Respostas one-shot sem o rastro de raciocínio (em modelos de raciocínio):

    ollama run qwen3:14b --think=false --hidethinking "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 a Ollama com Python (cliente e API)

• Instalar Biblioteca Python da 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 prompt especificados.

Para integração avançada em Python, explore usando a API de Pesquisa Web da Ollama em Python, que cobre capacidades de pesquisa web, chamada de ferramentas e integração com servidores MCP.

Procurando uma interface baseada na web? Open WebUI fornece uma interface auto-hospedada com capacidades de RAG e suporte multi-usuário.

Links úteis

Configuração e Gerenciamento

• Mover Modelos da Ollama para Outro Drive ou Pasta
• Ollama em Docker Compose com GPU e Armazenamento Persistente de Modelos

Alternativas e Comparações

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

Desempenho e Hardware

• Como a Ollama Lida com Solicitações Paralelas
• Como a Ollama Está Usando os Núcleos de Desempenho e Eficientes da CPU Intel
• NVIDIA DGX Spark vs Mac Studio vs RTX-4080: Comparação de Desempenho da Ollama

Integração e Desenvolvimento

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