SSD Nodes Learn Hosting plans →
Guide Matt ConnorDi Matt Connor

Ollama: NUM_PARALLEL e MAX_QUEUE spiegati

Scopri quando la seconda richiesta Ollama resta in coda o riceve HTTP 503, cosa controllano OLLAMA_NUM_PARALLEL e OLLAMA_MAX_QUEUE e perché ogni slot usa memoria.

Cosa succede alla seconda richiesta Ollama mentre la prima sta generando

La concorrenza di Ollama è determinata da tre variabili d’ambiente e, nella configurazione predefinita, un modello caricato serve una richiesta alla volta. La seconda richiesta non viene rifiutata e non riceve una risposta parziale. Rimane in coda finché non si libera uno slot, quindi viene elaborata alla velocità normale.

Una richiesta in ingresso può avere tre esiti. Può iniziare immediatamente in uno slot libero. Può rimanere in coda. Oppure la coda può essere già piena e il server può rifiutarla con HTTP 503. L’esito dipende da OLLAMA_NUM_PARALLEL, OLLAMA_MAX_QUEUE e OLLAMA_MAX_LOADED_MODELS. Esiste però un dettaglio importante nelle versioni attuali, a ottobre 2026. Le FAQ descrivono la coda in termini generali, ma il codice sorgente dello scheduler è più specifico. L’errore 503 si applica soltanto alle richieste che arrivano mentre il relativo modello deve ancora essere caricato oppure deve essere ricaricato con impostazioni diverse. Ollama non rifiuta una richiesta che il modello già caricato può servire senza modifiche. La richiesta attende uno slot per tutto il tempo necessario.

La configurazione predefinita è sicura. Spiega anche perché un secondo utente può segnalare che il server si è "bloccato" quando in realtà non si è verificato alcun problema. Aggiungere slot richiede due sole righe di modifica. Il problema è la memoria. Ogni slot parallelo richiede una propria cache key/value (cache KV), cioè il blocco di memoria in cui il modello conserva i token già elaborati. Se si aggiungono slot senza aumentare la VRAM (memoria video della GPU), una risposta lenta può trasformarsi in un caricamento fallito. Su un server che usa solo la CPU, la stessa cache viene allocata nella RAM di sistema.

Che cosa controllano OLLAMA_NUM_PARALLEL, OLLAMA_MAX_QUEUE e OLLAMA_MAX_LOADED_MODELS

Questi sono i valori predefiniti nelle versioni correnti di Ollama a ottobre 2026. Verifica i tuoi invece di affidarti a questo numero, usando la riga del log mostrata più avanti.

  • OLLAMA_NUM_PARALLEL indica quante richieste può gestire contemporaneamente un singolo modello caricato. Il valore predefinito è 1, quindi le richieste vengono servite una dopo l'altra.
  • OLLAMA_MAX_LOADED_MODELS indica quanti modelli diversi restano residenti contemporaneamente. Il valore predefinito è 0, che significa che Ollama sceglie automaticamente: tre modelli per GPU e tre su una macchina senza GPU.
  • OLLAMA_MAX_QUEUE indica, secondo la formulazione delle FAQ, il numero massimo di richieste che Ollama accoda quando è occupato prima di rifiutare le richieste aggiuntive. Il valore predefinito è 512. La richiesta che arriva quando la coda è piena viene rifiutata immediatamente. Tuttavia, nel codice corrente dello scheduler, entrano in questa coda solo le richieste il cui modello deve essere caricato o ricaricato. Le richieste per un modello già caricato saltano questa coda e attendono invece uno slot libero; questa attesa non ha un limite. Un maintainer ha descritto il comportamento come un effetto collaterale dell'implementazione dello scheduler. I maintainer di Ollama tracciano una correzione come richiesta di funzionalità (issue #7758), ancora aperta a ottobre 2026.

Nel caso peggiore, la memoria necessaria è il prodotto dei primi due valori. Due modelli caricati con quattro slot ciascuno richiedono otto allocazioni di slot per la cache KV, tutte residenti contemporaneamente, e Ollama tenterà di soddisfare questa richiesta. Su una macchina con una sola GPU, di solito è preferibile mantenere un solo modello e assegnargli più slot, perché il calcolo resta semplice da fare a mente.

Perché ogni slot parallelo richiede VRAM

Quando Ollama carica un modello, avvia un processo runner separato. Due degli argomenti passati sono importanti in questo caso: -c indica il contesto totale per il quale il runner alloca una cache KV, mentre -np indica il numero di sequenze parallele. Ollama imposta -c moltiplicando la lunghezza del contesto per richiesta per il numero di slot. Il runner divide quindi questo totale in parti uguali tra gli slot, così ogni richiesta riceve comunque la lunghezza del contesto richiesta.

Questo è l'intero vincolo e spiega perché il parallelismo non è gratuito. Passare da uno slot a quattro richiede una cache KV quattro volte più grande, a parità di contesto per richiesta. Gli slot non condividono nulla e la quota di uno slot inattivo non viene assegnata a uno slot occupato, perché la suddivisione è fissa quando il runner viene avviato. Su una GPU quella memoria è VRAM. Su un server con sola CPU è RAM di sistema e si applica lo stesso fattore di moltiplicazione.

Puoi leggere i valori effettivi invece di quelli che intendevi impostare:

journalctl -u ollama --no-pager -n 500 | grep "starting llama-server"

Quella riga contiene l'intera riga di comando del runner, inclusi -c e -np. Se -np è 1 dopo aver impostato la variabile, controlla prima il tipo di modello. Ollama v0.40.15 ha aggiunto il supporto alle richieste parallele per i modelli GGUF ricorrenti e con visione, quindi la precedente limitazione a uno slot per questi modelli non si applica più. I modelli di embedding ricevono ancora uno slot nello scheduler. Per un modello GGUF di completamento, verifica che l'impostazione venga ricevuta dal server, come spiegato nella sezione successiva.

Se i pesi del modello più la cache KV non entrano nella VRAM, Ollama sposta alcuni layer nella RAM di sistema e questi vengono eseguiti dalla CPU. I layer eseguiti dalla CPU sono molto più lenti di quelli eseguiti dalla GPU, quindi ogni richiesta diventa più lenta, inclusa l'unica richiesta con cui avevi iniziato. Aumentare il parallelismo può quindi ridurre il throughput invece di aumentarlo. Con un modello abbastanza grande, i soli pesi determinano già il risultato prima di qualsiasi calcolo sugli slot. Per questo l'hosting autonomo di qualcosa delle dimensioni di Kimi K3 riguarda il numero di schede disponibili, non il numero di slot impostati.

ollama ps

La colonna PROCESSOR mostra 100% GPU quando tutto il modello entra nella memoria disponibile. Una suddivisione come 35%/65% CPU/GPU indica che una parte del modello viene eseguita sulla CPU. La colonna SIZE include la cache KV, quindi aumenta quando incrementi il numero di slot e ricarichi il modello. Incrementa OLLAMA_NUM_PARALLEL, riavvia, invia una richiesta ed esegui di nuovo ollama ps: in questo modo misuri il costo in memoria della modifica invece di stimarlo. Se la misurazione indica che il modello non entra più nella memoria disponibile, ricorda che i pesi costituiscono l'altra metà dello stesso budget. Passare da una build fp16 a una q8 o q4 spesso libera più VRAM di quanta ne richieda lo slot che stavi cercando di aggiungere.

La lunghezza del contesto e il numero di slot si moltiplicano, quindi devono essere scelti insieme. Un contesto grande con quattro slot equivale a quattro contesti grandi. Se stai anche configurando la finestra di contesto num_ctx per il modello, modifica un solo valore alla volta. In caso contrario non saprai quale dei due ha riempito la scheda.

Come impostare queste variabili in modo che persistano dopo un riavvio

Su Linux, Ollama viene eseguito come servizio systemd. L'esecuzione di export OLLAMA_NUM_PARALLEL=4 nella shell non modifica nulla, perché systemd avvia il servizio con il proprio ambiente e non vede mai quello della shell. Usare un file drop-in.

sudo systemctl edit ollama.service

Aggiungere questo contenuto nell'editor che si apre:

[Service]
Environment="OLLAMA_NUM_PARALLEL=4"
Environment="OLLAMA_MAX_LOADED_MODELS=1"
Environment="OLLAMA_MAX_QUEUE=32"

Quindi ricaricare la configurazione e riavviare il servizio:

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

systemctl show stampa ciò che systemd passerà al processo. Se la variabile manca, il file drop-in non è stato salvato oppure daemon-reload è stato omesso. Verificare anche dal server:

journalctl -u ollama --no-pager | grep "server config" | tail -1

All'avvio, Ollama registra la configurazione del server in una riga il cui messaggio è server config. Questa mappa mostra i valori configurati dell'ambiente rilevati da Ollama ed è il modo più rapido per verificare se una variabile è stata applicata. Mostra il valore impostato, non il numero di slot assegnati a un modello specifico. Per questo dato, leggere il valore -np nella riga del runner precedente.

Un modello già caricato mantiene il numero di slot con cui è stato avviato, perché il valore viene fissato nel processo runner al momento dell'avvio. Il riavvio precedente scarica tutti i modelli, quindi la richiesta successiva ricarica il modello con la nuova impostazione e sostiene una sola volta il tempo di caricamento. Per quanto tempo il modello rimane residente dopo il caricamento è un controllo separato, descritto in mantenere un modello Ollama caricato tra le richieste.

Come appaiono dal client le richieste servite, accodate e rifiutate

Invia più richieste contemporaneamente e misura i tempi. Questo comando esegue in parallelo otto richieste in streaming e stampa lo stato e i tempi di ciascuna:

for i in $(seq 1 8); do
  curl -s -o /dev/null \
    -w "req$i http=%{http_code} ttfb=%{time_starttransfer}s total=%{time_total}s\n" \
    http://127.0.0.1:11434/api/generate \
    -d '{"model":"llama3.2:3b","prompt":"Explain what a KV cache is.","stream":true}' &
done
wait

ttfb è il tempo al primo byte dello stream. È vicino al tempo al primo token (TTFT), perché il primo blocco trasmesso contiene il primo token.

Servite in parallelo. Ogni richiesta restituisce un valore ttfb simile e total aumenta contemporaneamente per tutte. La GPU viene condivisa tra gli slot in esecuzione. Di conseguenza, ogni risposta è più lenta rispetto all'esecuzione singola, ma vengono completate più richieste al minuto. Questo è il comportamento che si ottiene aumentando OLLAMA_NUM_PARALLEL.

Accodate. Le prime richieste ricevono rapidamente una risposta, mentre quelle successive mostrano un valore ttfb elevato, seguito da una generazione normale. L'attesa dipende dalla coda, non dal modello. In una finestra di chat l'utente vede una lunga pausa senza output, seguita da testo alla velocità massima. Questo andamento, lento all'avvio e poi rapido, indica una coda più che una GPU sovraccarica.

Rifiutate. Il client riceve http=503 quasi immediatamente e il corpo della risposta è:

{"error":"server busy, please try again.  maximum pending requests exceeded"}

Il messaggio indica che la coda di scheduling era piena quando è arrivata la richiesta. Non fornisce informazioni sulla VRAM né sul modello. Nelle versioni attuali, questa coda contiene solo le richieste per cui il modello non è ancora stato caricato oppure deve essere ricaricato con impostazioni diverse. Se il modello è già residente quando esegui il ciclo precedente, tutte le richieste restituiranno 200, indipendentemente dal valore basso assegnato a OLLAMA_MAX_QUEUE. In questo caso l'overflow si manifesta invece come un valore ttfb più elevato.

Un limite importante: Ollama non pubblica la profondità della coda. ollama ps e l'endpoint /api/ps riportano i modelli caricati, non le richieste in attesa. Devi quindi misurare la coda dal lato client, osservando il tempo al primo byte, oppure contare le risposte 503 nel componente che si trova davanti al servizio.

Perché un valore MAX_QUEUE più basso è spesso l’impostazione migliore

Una coda da 512 richieste sembra ampia, ma con un solo slot è quasi inutile. La richiesta 300 resta in attesa dietro 299 generazioni complete. Nel migliore dei casi, l’attesa dura diversi minuti. Qualsiasi client HTTP va in timeout molto prima. Il chiamante riceve quindi un timeout lato client, che non indica la causa e non fornisce al monitoraggio alcun evento utile da segnalare.

Una coda più piccola converte il superamento della capacità in una risposta 503 immediata, ma solo per le richieste in attesa che un modello venga caricato o ricaricato, ad esempio il picco di richieste dopo un riavvio o durante la sostituzione dei modelli. A ottobre 2026, le richieste a un modello già caricato bypassano OLLAMA_MAX_QUEUE e attendono uno slot libero senza un limite. Ridurre la coda, quindi, non abbrevia l’attesa su un server occupato con un solo modello residente. Per rifiutare rapidamente anche queste richieste, limita la concorrenza davanti a Ollama, come descritto nella sezione successiva. Una risposta 503 è utile: un reverse proxy può riprovare, un client può applicare un backoff, una dashboard può conteggiarla e una persona può leggerla. Definisci il limite sulla base delle tue misurazioni. Se una generazione richiede circa dieci secondi e il client attende sessanta secondi, in quella finestra possono essere completate circa sei richieste per slot. Consentire a un numero superiore di richieste di restare in attesa produce soltanto timeout.

Quando mettere una coda davanti a Ollama

La coda integrata usa l'ordine di arrivo (FIFO) e non distingue il chiamante. Per un'applicazione che comunica con un solo server è sufficiente; aggiungere altra infrastruttura introdurrebbe soltanto nuovi punti di errore. È opportuno aggiungere un componente davanti a Ollama quando si verifica una delle seguenti condizioni.

  • Serve una priorità. Una chat interattiva non dovrebbe attendere dietro a un processo batch di riepilogo. La coda di Ollama non supporta priorità, quindi i lavori batch devono essere trattenuti all'esterno e inviati gradualmente.
  • Serve equità. Un client può occupare tutti gli slot e accumulare da solo richieste in attesa. Tutti gli altri client dovranno quindi attendere dietro a quel client oppure riceveranno 503 se la loro richiesta richiede il caricamento di un modello.
  • Serve un tempo di attesa limitato. Ollama mantiene indefinitamente le richieste relative a un modello già caricato, quindi l'unico limite affidabile è quello configurato davanti al server.
  • I lavori devono sopravvivere a un riavvio. La coda risiede nella memoria del server. Se si riavvia Ollama, tutte le richieste in attesa vengono perse.
  • Servono nuovi tentativi con backoff, registrati in un punto consultabile successivamente.

La soluzione leggera è un reverse proxy. In nginx, limit_conn limita il numero di connessioni simultanee e limit_req limita la frequenza di arrivo per client, quindi le richieste oltre il limite vengono rifiutate dal proxy e non raggiungono mai Ollama. La soluzione più complessa è una coda di lavori con un database davanti a un worker che chiama Ollama. È la scelta corretta quando le richieste devono sopravvivere al riavvio di un processo. Dimensionare questa architettura per traffico reale richiede un'analisi separata: la pianificazione di un LLM self-hosted per utenti simultanei illustra i calcoli, mentre eseguire Ollama su un VPS descrive l'installazione di base presupposta da queste variabili.

Quando la risposta corretta è usare un server diverso

Esiste un limite che non si può superare modificando la configurazione. Ollama suddivide la KV cache in slot fissi di dimensione uguale quando carica il modello. La memoria di uno slot inattivo non può essere utilizzata da uno slot occupato e il numero di slot non può cambiare senza scaricare il modello. Questo approccio è adatto a una singola persona, a un piccolo team o a un agente di programmazione.

I server progettati per molti utenti simultanei funzionano in modo diverso. Allocano la KV cache in piccole pagine su richiesta e aggiungono le richieste in arrivo a un batch già in esecuzione. In questo modo la memoria segue il carico effettivo invece di essere suddivisa in modo fisso. Se l'obiettivo è gestire molti utenti simultanei su una singola GPU, questa differenza architetturale è più importante di qualsiasi valore di OLLAMA_NUM_PARALLEL. Il confronto tra Ollama e vLLM è il punto in cui prendere questa decisione. Non cambiare server per principio. Un server diverso richiede più attività operative e, se il traffico proviene da poche persone, il comportamento integrato è la scelta corretta. Se la domanda reale è se convenga gestire autonomamente un model server, il confronto tra un server AI privato disponibile solo su preventivo e la realizzazione dello stesso stack su una GPU a noleggio analizza questa decisione, compresi i casi in cui un'API è l'acquisto più conveniente.

Misura il throughput e il time to first token

I valori pubblicati in token al secondo provengono dalla GPU, dal modello, dalla quantizzazione, dalla lunghezza del contesto e dal prompt utilizzati da qualcun altro. Nessuno di questi parametri coincide con i tuoi. Considera quindi ogni valore letto come una semplice indicazione e misura direttamente la macchina che stai utilizzando.

Ollama restituisce i tempi nell'oggetto JSON finale di ogni risposta. eval_count indica il numero di token generati e eval_duration il tempo impiegato per generarli, espresso in nanosecondi.

sudo apt install -y jq
curl -s http://127.0.0.1:11434/api/generate \
  -d '{"model":"llama3.2:3b","prompt":"Explain what a KV cache is.","stream":false}' \
  | jq '{prompt_eval_count, eval_count, eval_duration, tokens_per_second: (.eval_count / (.eval_duration / 1000000000))}'

Esegui il test con uno slot, quindi ripetilo usando il livello di concorrenza previsto in condizioni reali. Confronta i due valori che determinano la soddisfazione degli utenti: il time to first token e il numero di token al secondo per richiesta. Il throughput per richiesta diminuisce sempre quando aggiungi slot. La domanda è se diminuisce oltre il limite che gli utenti sono disposti ad accettare. Misurare i token al secondo con un LLM locale descrive il metodo in modo più dettagliato, incluso come mantenere costante il prompt tra le esecuzioni.

Un endpoint pubblico con una coda generosa è un obiettivo per attacchi denial of service

L'impostazione OLLAMA_HOST=0.0.0.0:11434 espone l'API su ogni interfaccia e l'API locale non richiede autenticazione. Ollama dispone di un sistema di accesso integrato per modelli cloud, pubblicazione e download privati. L'inferenza cloud diretta su https://ollama.com/api e https://ollama.com/v1 richiede una API key. Con la coda predefinita, un endpoint aperto accetterà fino a 512 richieste in attesa del caricamento di un modello, da chiunque lo trovi. Per un modello già caricato, tratterrà ogni richiesta che si connette, senza alcun limite, per tutto il tempo in cui ogni client resta connesso. Occupare il server in questo modo costa quasi nulla a un attaccante: prompt lunghi, nessun login, nessun rate limit, nessun costo. I tuoi utenti riceveranno quindi risposte 503 o attese prolungate, e la macchina risulterà costantemente occupata.

Mantieni il listener su loopback e raggiungilo tramite un tunnel SSH o una rete privata, oppure anteponi un sistema di autenticazione e rate limiting. Mettere in sicurezza un endpoint API Ollama copre entrambi gli aspetti. Regola la coda dopo aver completato queste operazioni, poiché la lunghezza della coda è un'impostazione di capacità e non offre alcuna protezione.

FAQ

Perché la seconda richiesta Ollama attende il completamento della prima?

Perché OLLAMA_NUM_PARALLEL è impostato su 1 per impostazione predefinita. Un modello caricato gestisce una richiesta alla volta e le altre attendono in ordine. La richiesta in attesa mantiene aperta la connessione HTTP e non invia byte finché non si libera uno slot. Dal lato client, questo appare identico a un modello lento. L'indizio è la forma dei tempi: una lunga pausa seguita da testo alla massima velocità indica una coda, mentre un flusso lento fin dal primo token indica un modello lento. Aumenta il numero di slot con un drop-in di systemd e riavvia il servizio. Controlla quindi il valore di -np nella riga del runner, perché anche i modelli di embedding ricevono comunque un solo slot nello scheduler.

Che cosa significa "server busy, please try again. maximum pending requests exceeded"?

È l'errore di overflow della coda di Ollama, restituito con stato HTTP 503. Il numero di richieste in attesa di essere pianificate, cioè in attesa che il relativo modello venga caricato o ricaricato, ha raggiunto OLLAMA_MAX_QUEUE, che per impostazione predefinita è 512. Per questo la richiesta più recente è stata rifiutata invece di essere aggiunta alla coda. Le richieste a un modello già caricato non vengono conteggiate in questo limite. Questo errore compare soprattutto durante picchi di richieste all'avvio o mentre i modelli vengono sostituiti. Non è un errore di memoria e non è un errore del modello. Aumentare la coda fa soltanto attendere più a lungo i chiamanti prima dello stesso rifiuto. Le soluzioni effettive sono aumentare il numero di slot, se la VRAM disponibile lo consente, ridurre il carico in ingresso oppure usare una coda davanti a Ollama che possa ritentare le richieste e assegnare loro una priorità.

Aumentare OLLAMA_NUM_PARALLEL rende Ollama più veloce?

No. Consente di eseguire più richieste contemporaneamente, ma ciascuna richiesta è più lenta rispetto all'esecuzione isolata perché tutte condividono una GPU. Inoltre moltiplica la cache KV, perché Ollama avvia il runner con un contesto totale pari alla lunghezza del contesto moltiplicata per il numero di slot. Se il risultato non entra più nella VRAM, Ollama sposta alcuni layer sulla CPU e tutte le richieste diventano più lente, inclusa una singola richiesta senza concorrenza. Dopo la modifica, controlla ollama ps e verifica che la colonna PROCESSOR riporti ancora 100% GPU.

Devo riavviare Ollama dopo aver modificato queste variabili?

Sì. Il server le legge all'avvio e un modello in esecuzione mantiene il numero di slot definito nel processo runner al momento dell'avvio. Modifica il drop-in con sudo systemctl edit ollama.service, quindi esegui sudo systemctl daemon-reload e sudo systemctl restart ollama. Verifica con systemctl show ollama --property=Environment, quindi controlla la riga server config in journalctl -u ollama, che elenca i valori dell'ambiente configurati e riportati da Ollama.

Quanti slot paralleli devo configurare?

Inizia da 1 e aumenta il valore di un'unità alla volta. Dopo ogni modifica, riavvia Ollama, invia una richiesta per caricare il modello ed esegui ollama ps. Fermati all'ultimo valore per cui PROCESSOR riporta ancora 100% GPU e la colonna SIZE mantiene margine sufficiente per il contesto più lungo che gestisci. A quel valore, misura il tempo al primo token e i token al secondo con la concorrenza effettiva dell'ambiente. Riduci quindi il valore di un'unità se la velocità per richiesta è scesa al di sotto di quanto i tuoi utenti possono tollerare.

Questo articolo ti è stato utile?

#ollama#concurrency#vram#queueing#self-hosted-llm