Como o Ollama Lida com Solicitações Paralelas

Este guia explica como o Ollama gerencia solicitações paralelas (concorrência, filas e limites de recursos) e como ajustá-lo usando a variável de ambiente OLLAMA_NUM_PARALLEL (e configurações relacionadas).

Links rápidos: O que é OLLAMA_NUM_PARALLEL? · Receitas de ajuste rápido · Como funciona a fila · Solução de problemas · Relacionado: Guia de comandos Ollama CLI

Para mais informações sobre vazão, latência, VRAM e benchmarks em diferentes runtimes e hardware, consulte Desempenho de LLM: Benchmarks, Gargalos & Otimização.

Tratamento de Solicitações Concorrentes

• Processamento Paralelo: O Ollama suporta o processamento concorrente de solicitações. Se o sistema tiver memória suficiente (RAM para inferência de CPU, VRAM para inferência de GPU), vários modelos podem ser carregados simultaneamente, e cada modelo carregado pode lidar com várias solicitações em paralelo. Isso é controlado pela variável de ambiente OLLAMA_NUM_PARALLEL, que define o número máximo de solicitações paralelas que cada modelo pode processar simultaneamente. Por padrão, isso é definido como 4 (ou 1, dependendo da disponibilidade de memória), mas pode ser ajustado.

• Agrupamento (Batching): Quando múltiplas solicitações para o mesmo modelo chegam simultaneamente, o Ollama as agrupa e as processa juntas. Isso significa que ambas as solicitações são tratadas em paralelo e os usuários verão as respostas sendo transmitidas ao mesmo tempo. O servidor não espera intencionalmente para preencher um lote; o processamento começa assim que as solicitações estão disponíveis.

Filas e Limites

• Filas (Queuing): Se o número de solicitações concorrentes exceder o paralelismo configurado (por exemplo, mais de OLLAMA_NUM_PARALLEL solicitações para um modelo), as solicitações adicionais são colocadas em fila. A fila opera de forma primeira a entrar, primeiro a sair (FIFO).

• Limites de Fila: O número máximo de solicitações em fila é controlado por OLLAMA_MAX_QUEUE (padrão: 512). Se a fila estiver cheia, novas solicitações recebem um erro 503 indicando que o servidor está sobrecarregado.

• Carregamento de Modelos: O número de modelos diferentes que podem ser carregados ao mesmo tempo é controlado por OLLAMA_MAX_LOADED_MODELS. Se uma solicitação exigir o carregamento de um novo modelo e a memória for insuficiente, o Ollama descarregará modelos ociosos para liberar espaço, e a solicitação ficará em fila até que o modelo seja carregado.

Cenário de Exemplo

Se duas solicitações para o mesmo modelo chegarem ao mesmo tempo e o paralelismo do servidor estiver definido para pelo menos 2, ambas as solicitações serão processadas juntas em um lote, e ambos os usuários receberão respostas de forma concorrente. Se o paralelismo estiver definido para 1, uma solicitação será processada imediatamente e a outra ficará em fila até que a primeira termine.

Se as solicitações forem para modelos diferentes e houver memória suficiente, ambos os modelos podem ser carregados e as solicitações tratadas em paralelo. Caso contrário, um modelo pode precisar ser descarregado e a solicitação ficará em fila.

Tabela Resumo

Em resumo, o Ollama é projetado para lidar com múltiplas solicitações simultâneas de forma eficiente, desde que o servidor esteja configurado para concorrência e tenha recursos suficientes. Caso contrário, as solicitações são colocadas em fila e processadas em ordem.

Tratamento de Insuficiência de Memória

Quando o Ollama encontra memória insuficiente para lidar com solicitações recebidas, ele emprega uma combinação de mecanismos de fila e estratégias de gerenciamento de recursos para manter a estabilidade:

Fila de Solicitações

• Novas solicitações são colocadas em uma fila FIFO (Primeiro a Entrar, Primeiro a Sair) quando a memória não pode ser alocada imediatamente.
• O tamanho da fila é controlado por OLLAMA_MAX_QUEUE (padrão: 512 solicitações).
• Se a fila atingir a capacidade, novas solicitações recebem erros 503 “Servidor Sobrecarregado”.

Gerenciamento de Modelos

• Modelos ativos podem ser descarregados da memória quando ficam ociosos para liberar recursos para solicitações em fila.
• O número de modelos carregados simultaneamente é limitado por OLLAMA_MAX_LOADED_MODELS (padrão: 3× contagem de GPUs ou 3 para CPU).

Otimização de Memória

• Tentativas de processar solicitações em lote para o mesmo modelo para maximizar a eficiência de memória.
• Para inferência de GPU, requer alocação completa de VRAM por modelo - cargas parciais não são suportadas.

Cenários de Falha

Esgotamento Crítico de Memória: Quando até mesmo as solicitações em fila excedem os recursos disponíveis, o Ollama pode:

• Paginar para o disco (degradando severamente o desempenho)
• Retornar erros “memória insuficiente”
• Encerrar a instância do modelo em casos extremos

Os administradores devem monitorar o uso de memória e ajustar esses parâmetros com base nas capacidades de seu hardware. O tratamento de memória insuficiente torna-se crucial ao executar modelos maiores (7B+ parâmetros) ou processar múltiplas solicitações concorrentes.

Estratégias de otimização do Ollama

Ative a aceleração de GPU com export OLLAMA_CUDA=1 e defina os threads de CPU via export OLLAMA_NUM_THREADS=84.

Melhorias de Hardware

• RAM: 32GB+ para modelos de 13B, 64GB+ para modelos de 70B
• Armazenamento: SSDs NVMe para carregamento/swap de modelos mais rápidos
• GPU: NVIDIA RTX 3080/4090 com 16GB+ VRAM para modelos maiores

Estratégias Operacionais

• Agrupamento de Solicitações: Processar múltiplas consultas simultaneamente para amortizar a sobrecarga de memória
• Descarregamento Automático de Modelos: Permite que o Ollama limpe modelos ociosos da memória
• Cache de Modelos Frequentemente Usados: Mantém modelos comuns residentes na memória

Monitoramento e Solução de Problemas

• Use nvidia-smi (GPU) e htop (CPU/RAM) para identificar gargalos
• Para erros de memória:
• Atualize para modelos quantizados
• Reduza solicitações concorrentes
• Aumente o espaço de swap

Exemplo de fluxo de otimização:

### Usar modelo quantizado com aceleração de GPU
export OLLAMA_CUDA=1
ollama run llama2:7b-q4_0 --context-size 2048

### Limitar modelos carregados e solicitações paralelas
export OLLAMA_MAX_LOADED_MODELS=2
export OLLAMA_NUM_PARALLEL=4

Estes ajustes podem reduzir o uso de memória em 30-60%, mantendo a qualidade das respostas, o que é particularmente benéfico ao executar múltiplos modelos ou lidar com alto volume de solicitações.

Variável de ambiente OLLAMA_NUM_PARALLEL

OLLAMA_NUM_PARALLEL controla quantas solicitações o Ollama executará em paralelo. Se você enviar múltiplas solicitações para o mesmo servidor Ollama, esta configuração decide em grande parte se elas rodam de forma concorrente ou ficam em fila.

• Valores maiores podem aumentar a vazão se você tiver CPU/GPU/VRAM suficientes, mas podem aumentar a latência e a pressão na memória.
• Valores menores reduzem a contenda e podem melhorar a estabilidade, mas as solicitações ficarão em fila com mais frequência.

Como definir OLLAMA_NUM_PARALLEL

Linux / macOS (serviço systemd ou shell):

export OLLAMA_NUM_PARALLEL=2
ollama serve

Execução única (prefixo apenas para este comando):

OLLAMA_NUM_PARALLEL=2 ollama serve

Docker (exemplo):

docker run --rm -e OLLAMA_NUM_PARALLEL=2 -p 11434:11434 ollama/ollama

Como escolher um valor

Comece com 1–2 para uma única GPU / VRAM limitada, então aumente gradualmente enquanto monitora:

• Uso de VRAM da GPU (OOM / expulsões)
• Uso de CPU e média de carga
• Latência p95 das suas solicitações típicas
• Taxa de erros / tempo limite (timeouts)

Se você está otimizando uma página específica para uso de CLI, consulte a seção Ollama CLI no guia de comandos, além de exemplos de comandos para ollama serve, ollama ps e ollama run.

Receitas de ajuste rápido

Foco em Estabilidade

• OLLAMA_NUM_PARALLEL=1
• Use modelos menores / quantizados
• Prefira tamanhos de contexto menores

Foco em Vazão (Throughput)

• OLLAMA_NUM_PARALLEL=2 (ou maior se você tiver margem)
• Considere o agrupamento de solicitações na camada do cliente
• Garanta VRAM e threads de CPU suficientes

“Fico sem VRAM quando duas solicitações chegam”

• Reduza OLLAMA_NUM_PARALLEL
• Use um modelo mais agressivamente quantizado
• Reduza o comprimento do contexto / tokens máximos

Solução de Problemas

Sintomas de que OLLAMA_NUM_PARALLEL está muito alto

• Solicitações falham intermitentemente sob carga
• OOM de GPU / descarregamento de modelo acontece frequentemente
• Picos de latência quando a segunda solicitação chega

Sintomas de que OLLAMA_NUM_PARALLEL está muito baixo

• CPU/GPU está subutilizado
• Atrasos de fila dominam o tempo total de resposta

Dica: Se você também controla seu cliente, adicione re-tentativas com jitter e conexões keep-alive. Muitos problemas de “Ollama está lento” são realmente sobre filas + sobrecarga de conexão.

Ollama: Agrupamento de Solicitações vs Execução Paralela

Agrupamento (Batching) no Ollama refere-se à prática de agrupar múltiplas solicitações recebidas e processá-las como uma unidade. Isso permite um uso mais eficiente dos recursos computacionais, especialmente ao executar em hardware que se beneficia de operações paralelizadas (como GPUs).

Quando múltiplas solicitações para o mesmo modelo chegam simultaneamente, o Ollama pode processá-las juntas em um lote se a memória permitir. Isso aumenta a vazão e pode reduzir a latência para cada solicitação, pois o modelo pode aproveitar operações de matriz otimizadas sobre o lote.

O agrupamento é particularmente eficaz quando as solicitações são semelhantes em tamanho e complexidade, pois isso permite melhor utilização de hardware.

Execução paralela no Ollama significa lidar com múltiplas solicitações ao mesmo tempo, seja para o mesmo modelo ou para modelos diferentes, dependendo da memória disponível e da configuração.

O Ollama suporta dois níveis de paralelismo:

• Carregamento de Múltiplos Modelos: Se houver memória suficiente, vários modelos podem ser carregados e atender solicitações simultaneamente.
• Solicitações Paralelas por Modelo: Cada modelo carregado pode processar várias solicitações em paralelo, controlado pela configuração OLLAMA_NUM_PARALLEL (padrão é 1 ou 4, dependendo da memória).

Quando as solicitações excedem o limite de paralelismo, elas são colocadas em fila (FIFO) até OLLAMA_MAX_QUEUE.

Conclusão

O Ollama aproveita tanto o agrupamento quanto a execução paralela para processar múltiplas solicitações de forma eficiente. O agrupamento agrupa solicitações para processamento simultâneo, enquanto a execução paralela permite que múltiplas solicitações (ou modelos) rodem de forma concorrente. Ambos os métodos dependem da memória do sistema e são configuráveis para desempenho ideal.

Para mais benchmarks, ajuste de concorrência e orientações de desempenho, confira nosso hub Desempenho de LLM: Benchmarks, Gargalos & Otimização.

Links Úteis

• Guia de Comandos Ollama
• Comparação de desempenho de LLM - Ollama em GPU com 16GB VRAM
• Mover Modelos Ollama para Outra Unidade ou Pasta
• Como o Ollama usa o Desempenho da CPU Intel e Núcleos Eficientes