SSD Nodes Learn Hosting plans →
Guias Matt ConnorPor Matt Connor · Atualizado 2026-10-16

Como manter um modelo Ollama carregado na memória

O Ollama descarrega o modelo após 5 minutos sem uso. Configure keep_alive em um override do systemd e faça um preload para evitar a recarga no próximo pedido.

Por que o Ollama descarrega o modelo depois de alguns minutos?

O Ollama mantém um modelo carregado na memória durante cinco minutos após o último pedido e, depois, libera-o. O pedido seguinte precisa carregar novamente os pesos na RAM ou na VRAM, o que causa uma espera antes de o primeiro token ser gerado. É por isso que uma interface de chat ou um agente de programação parece rápido, fica inativo durante algum tempo e volta a parecer lento na mensagem seguinte. Não há nenhuma falha. O temporizador de inatividade expirou.

O temporizador chama-se keep_alive. A definição é aplicada individualmente a cada modelo e reinicia sempre que um pedido termina. Um modelo que está a responder a um pedido nunca é descarregado, porque o servidor só expira um modelo sem pedidos ativos. Em outubro de 2026, o valor predefinido é cinco minutos e aplica-se a todos os modelos carregados por este servidor.

Há dois locais onde pode definir keep_alive: no pedido individual ou como predefinição do servidor. Um drop-in do systemd faz com que a predefinição do servidor se mantenha após um reinício. Este guia pressupõe que o Ollama já está a ser executado como um serviço. Se não estiver, comece por instalar o Ollama numa VPS e volte aqui.

Quais modelos estão residentes agora e quando expiram?

ollama ps
NAME        ID              SIZE      PROCESSOR    CONTEXT    UNTIL
qwen3:8b    500a1f067a9f    6.6 GB    100% GPU     4096       4 minutes from now

Uma saída vazia significa que não há nada carregado, portanto a próxima solicitação terá de carregar primeiro o modelo. PROCESSOR indica onde ficaram os pesos. 100% GPU e 100% CPU são os casos claros. Uma divisão como 25%/75% CPU/GPU significa que apenas parte do modelo está na VRAM; o restante é executado no processador e a geração é mais lenta. Normalmente, isso acontece porque o modelo não coube, mas uma configuração num_gpu que limita o número de camadas enviadas para a GPU produz o mesmo tipo de divisão.

UNTIL é a contagem decrescente e mostra um tempo relativo, como 4 minutes from now. Mostra Forever quando o modelo foi carregado com um keep_alive negativo. Mostra Stopping... durante o curto período em que o servidor está a descarregar o modelo.

O conjunto de colunas mudou entre versões, por isso leia o cabeçalho em vez de contar os campos num script. O Ollama v0.40.2, a versão atual quando esta verificação foi feita em 2026-10-10, também mostra uma coluna RUNNER entre CONTEXT e UNTIL. Essa coluna identifica o runner que serve o modelo, pelo que o cabeçalho pode ter mais uma coluna do que o exemplo acima. Para qualquer processo automatizado, consulte a API:

curl -s http://localhost:11434/api/ps

Cada entrada inclui expires_at, um timestamp absoluto como 2026-08-09T14:38:31.83753Z, e size_vram, a parte desse modelo que está na memória da GPU. Um size_vram de 0 significa que o modelo está a ser executado na CPU.

O custo real do reload

Não faça suposições. O Ollama informa o tempo de carregamento em todas as respostas, no campo load_duration, em nanossegundos.

sudo apt install -y jq
ollama stop qwen3:8b
curl -s http://localhost:11434/api/generate -d '{"model": "qwen3:8b", "prompt": "hi", "stream": false}' | jq '{load_duration, total_duration}'
curl -s http://localhost:11434/api/generate -d '{"model": "qwen3:8b", "prompt": "hi", "stream": false}' | jq '{load_duration, total_duration}'

A primeira chamada carrega o modelo, por isso o valor de load_duration é elevado. Divida-o por 1000000000 para o ler em segundos. A segunda chamada é executada enquanto o modelo permanece residente e apresenta um valor muito menor. A diferença entre esses dois valores é o custo suportado por todos os utilizadores depois de o temporizador expirar. Essa é a razão para alterar keep_alive. Depois de um unload, a page cache do kernel ainda contém frequentemente o ficheiro do modelo. Por isso, num servidor com RAM disponível, um reload pode ser mais rápido do que o primeiro carregamento depois de um boot. Quando essa cache é recuperada, os pesos são lidos do disco. Se moveu o diretório do modelo para um segundo volume, a velocidade desse volume define o limite mínimo de cada carregamento a frio. Para conhecer a velocidade de geração antes e depois dessa pausa, consulte como medir tokens por segundo no seu próprio servidor.

Manter um modelo Ollama carregado na memória numa única solicitação

Envie keep_alive com a solicitação. Esta opção aplica-se a esse modelo a partir do momento em que a solicitação termina.

curl -s http://localhost:11434/api/chat -d '{
  "model": "qwen3:8b",
  "messages": [{"role": "user", "content": "hello"}],
  "keep_alive": "30m"
}'

São aceites quatro formatos de valor:

  • uma cadeia de duração: "30m", "24h", "90s"
  • um número simples, interpretado como segundos: 3600
  • um valor negativo, -1 ou "-1m", que significa que não existe tempo limite de inatividade
  • 0, que significa descarregar o modelo assim que esta solicitação terminar

Um valor definido na solicitação substitui o valor predefinido do servidor, em ambas as direções. Isto é mais importante do que parece: um cliente que envie o seu próprio keep_alive prevalece sobre qualquer configuração definida no servidor.

Também pode carregar um modelo sem gerar conteúdo. Envie apenas o nome do modelo. O servidor carrega-o e devolve uma resposta vazia com "done": true.

curl -s http://localhost:11434/api/generate -d '{"model": "qwen3:8b", "keep_alive": "30m"}'

Esse é o comando a executar depois de um reboot ou depois de obter um modelo novo, para que a primeira solicitação real de um utilizador não tenha de esperar pelo carregamento. A CLI faz o mesmo com uma flag:

ollama run --keepalive 30m qwen3:8b "hello"

Mantenha o modelo carregado por padrão com OLLAMA_KEEP_ALIVE

O servidor lê OLLAMA_KEEP_ALIVE no arranque e usa esse valor para todos os modelos que não tenham um valor próprio. Ele aceita os mesmos formatos que o campo do pedido, por isso 30m, 3600 e -1 funcionam.

A questão é em que ambiente a variável tem de estar definida. Executar export OLLAMA_KEEP_ALIVE=30m na sua sessão SSH não produz efeito, porque a instalação empacotada executa o servidor como um serviço systemd, com o seu próprio utilizador e ambiente. A sua shell de início de sessão e esse serviço não partilham o mesmo ambiente. Esta é a razão mais comum para a configuração parecer ser ignorada.

Faça a configuração sobreviver a um reinício com um drop-in do systemd

sudo systemctl edit ollama.service

O editor abre com dois marcadores de comentário. Escreva entre eles: o systemd descarta tudo o que for escrito abaixo do segundo marcador.

[Service]
Environment="OLLAMA_KEEP_ALIVE=30m"

Guardar grava /etc/systemd/system/ollama.service.d/override.conf. Isto é um drop-in, e não uma edição da unidade fornecida pelo pacote. Por isso, uma atualização do pacote Ollama que substitua ollama.service mantém a sua configuração. Se os drop-ins e os ficheiros de unidade forem novidade para si, o guia de serviços e temporizadores do systemd explica o funcionamento.

sudo systemctl daemon-reload
sudo systemctl restart ollama
systemctl show ollama --property=Environment

O último comando apresenta o ambiente com que o serviço será realmente executado. Se OLLAMA_KEEP_ALIVE=30m não aparecer nessa linha, o drop-in não foi aplicado. A causa quase sempre é um cabeçalho [Service] em falta ou linhas escritas abaixo do marcador. O reinício descarrega todos os modelos carregados, por isso o pedido seguinte faz um carregamento a frio. Aqueça o modelo com a chamada de pré-carregamento acima. O drop-in mantém a configuração após um reboot, mas não mantém o modelo: o serviço inicia ollama serve sem nenhum modelo carregado. Execute a mesma chamada de pré-carregamento depois de cada arranque.

O custo de manter um modelo residente

A coluna SIZE em ollama ps representa a memória mantida durante toda a janela de inatividade, e não apenas durante um pedido. Um modelo 8B com quantização de 4 bits ocupa cerca de 5 a 6 GB. Um modelo 27B é uma situação diferente, e vale a pena calcular a memória necessária para executar um modelo num VPS apenas com CPU antes de decidir mantê-lo residente. Defina keep_alive como -1 e estará a decidir que o modelo mantém essa memória enquanto o servidor estiver em execução, a menos que o pedido de outro modelo o force a sair. Num VPS pequeno, isto representa uma utilização concorrente direta da memória com a base de dados, a aplicação web e os trabalhos de compilação.

Observe os valores reais em vez de confiar numa estimativa. Execute este comando enquanto um modelo estiver carregado e depois novamente após ollama stop:

free -h

A coluna available representa a memória que o kernel ainda pode atribuir a um processo novo. Num servidor com GPU NVIDIA, nvidia-smi mostra a mesma situação na VRAM. Se o servidor ficar sem memória, o kernel termina um processo para a recuperar:

sudo dmesg -T | grep -i "out of memory"

Uma linha que indique ollama significa que o servidor do modelo foi a vítima. Uma linha que indique a sua base de dados significa que o modelo ganhou e que algo importante para si foi perdido. Ambos os resultados provêm da mesma decisão: uma janela longa de keep-alive num servidor sem margem de memória.

É fácil não notar dois custos. Um comprimento de contexto maior reserva uma cache KV maior (key value cache, o estado de atenção por token que o modelo mantém durante a geração), e essa cache faz parte do tamanho residente. O tamanho depende de num_ctx, pelo que aumentar a janela de contexto aumenta a memória mantida por um modelo residente durante todo o período de inatividade, e não apenas enquanto este responde. Valores de OLLAMA_NUM_PARALLEL superiores a 1 reservam essa cache uma vez por slot paralelo. Se pretende servir várias pessoas a partir de um único modelo, dimensione a memória para os slots, e não apenas para os pesos.

Um valor predefinido razoável: um modelo num servidor com margem de memória pode usar -1. Um servidor partilhado deve usar uma janela que cubra os intervalos entre os seus pedidos, como 30m, para que a memória seja libertada quando deixar de trabalhar.

Descarregar um modelo imediatamente

ollama stop qwen3:8b

O comando termina sem saída e o modelo desaparece de ollama ps. Também termina sem saída para um modelo que foi transferido, mas que não está carregado neste momento. O comando nunca verifica o que está residente: envia o pedido de descarga, e o servidor responde com sucesso, independentemente de haver algo na memória. O erro couldn't find model "qwen3:8b" to stop só aparece quando não existe nenhum modelo com esse nome instalado neste servidor, o que normalmente significa um erro de digitação no nome ou na tag. Por isso, um ollama stop silencioso não prova que alguma coisa foi libertada. ollama ps prova. Na API, o pedido não inclui um prompt e keep_alive é definido como 0:

curl -s http://localhost:11434/api/chat -d '{"model": "qwen3:8b", "messages": [], "keep_alive": 0}'

A resposta contém "done_reason": "unload". Use esta opção em vez de reiniciar o serviço. systemctl restart ollama também liberta a memória, mas remove todos os outros modelos carregados e termina todos os pedidos em execução.

Executar mais de um modelo no mesmo servidor

OLLAMA_MAX_LOADED_MODELS limita quantos modelos permanecem carregados ao mesmo tempo. Em outubro de 2026, o valor predefinido é três por GPU ou três num sistema apenas com CPU. O limite conta modelos, mas a memória é o limite real. Por isso, um segundo modelo grande pode não ter espaço disponível muito antes de chegar aos três modelos.

Quando é solicitado um modelo novo e não existe memória suficiente para o carregar, ou quando o limite já foi atingido, o agendador descarrega um dos modelos residentes para libertar espaço. Dá preferência a um modelo sem pedidos ativos. Também pode remover um modelo cujo temporizador ainda não expirou, incluindo um modelo carregado com -1, embora tente primeiro os modelos com janelas mais curtas. Portanto, um valor negativo de keep_alive significa que não existe tempo limite de inatividade. O modelo não fica fixado na memória contra pedidos destinados a outro modelo.

Essas decisões aparecem no log do serviço, mas o caso do limite só é registado no nível de depuração. Adicione uma segunda linha Environment="OLLAMA_DEBUG=1" ao mesmo drop-in, reinicie o serviço e monitorize:

sudo journalctl -u ollama -f

Leia o motivo apresentado junto ao pedido que provocou o descarregamento. max runners achieved, unloading one to make room significa que o limite OLLAMA_MAX_LOADED_MODELS foi atingido. Isso pode acontecer mesmo quando os dois modelos caberiam na memória. Aumente o limite se free -h mostrar que existe margem disponível. Uma linha que indique que o novo modelo deverá exceder a memória disponível, seguida de um descarregamento, mostra que estes dois modelos não cabem em conjunto nesta máquina. Nesse caso, a solução é executar menos modelos neste servidor ou definir uma janela longa para o modelo que tem de responder rapidamente e usar 0 para o modelo que é chamado raramente.

Orientações que continuam válidas após a próxima versão

Ollama lança versões com frequência e os valores predefinidos mudam. Por isso, consulte a versão instalada em vez de memorizar números:

ollama --version
ollama serve --help

ollama serve --help lista as variáveis de ambiente que essa versão realmente lê, incluindo OLLAMA_KEEP_ALIVE. Duas regras mantiveram-se entre versões e são seguras para usar. Um valor definido no pedido tem precedência sobre o valor predefinido do servidor. E ollama ps mostra o que está efetivamente carregado, independentemente do que um ficheiro de configuração indique.

Se um editor ou agente controlar o servidor, verifique o que esse cliente envia antes de atribuir a causa ao servidor. Apontar um agente de programação para o seu próprio servidor Ollama explica onde essas definições do pedido ficam.

FAQ

Por que o Ollama descarrega o meu modelo depois de 5 minutos?

Cinco minutos é o valor predefinido de keep_alive, o temporizador de inatividade que o Ollama inicia quando um pedido termina. Quando expira, o servidor liberta os pesos. Por isso, o pedido seguinte tem de os carregar novamente, e esse carregamento é a pausa que sente. Aumente o valor para um pedido enviando "keep_alive": "30m" no corpo JSON, ou para todo o servidor com a variável de ambiente OLLAMA_KEEP_ALIVE.

Como mantenho um modelo do Ollama carregado permanentemente na memória?

Use um valor negativo: "keep_alive": -1 no pedido ou OLLAMA_KEEP_ALIVE=-1 para o servidor. ollama ps mostra então Forever na coluna UNTIL. Isto remove apenas o temporizador de inatividade. Se for solicitado outro modelo e não houver memória suficiente, o scheduler ainda descarrega este modelo para libertar espaço. Um reinício ou reboot também o remove da memória. Carregue novamente o modelo depois disso.

Por que OLLAMA_KEEP_ALIVE está a ser ignorada?

Verifique onde a definiu. Execute systemctl show ollama --property=Environment. Se a variável não aparecer nesse resultado, o servidor nunca a recebeu, porque uma variável exportada na sua shell não é transmitida a um serviço systemd. Defina-a com sudo systemctl edit ollama.service e execute sudo systemctl daemon-reload e sudo systemctl restart ollama. A outra causa possível é um cliente que envia o seu próprio valor de keep_alive no pedido, substituindo o valor predefinido do servidor.

Como liberto a memória sem reiniciar o Ollama?

ollama stop qwen3:8b descarrega imediatamente esse modelo e mantém o servidor e todos os outros modelos carregados em execução. Pela API, envie um pedido sem prompt e com "keep_alive": 0. A resposta será devolvida com "done_reason": "unload". Confirme com ollama ps. O modelo já não deverá aparecer na lista.

Este artigo foi útil?