Ollama e llama.cpp, sullo stesso file GGUF, vanno quasi alla stessa velocità: nel banco sul ROG Ollama è avanti del 2-6%. La scelta si fa sul contesto. Con meno di 24 GiB di VRAM Ollama parte con un contesto di 4096 token, e su un endpoint taglia il prompt lungo senza errore; llama-server parte invece con 4 slot e una cache che occupa circa un terzo della memoria video del banco.
Dentro Ollama gira llama.cpp
Ollama si appoggia a llama.cpp, il motore che esegue i modelli in formato GGUF. Nelle prove si vede dal log: Ollama avvia un llama-server suo, preso dalla propria cartella, con -b 512 -ub 512 --flash-attn auto, e ollama ps indica il runner llamacpp. Le note di rilascio della 0.40.16 (9 novembre 2026) dicono «Updated llama.cpp» senza indicare la build.
Il rapporto fra i due progetti è discusso. Zetaphor, nel pezzo «Friends Don't Let Friends Use Ollama» del 15 aprile 2026, scrive che il README di Ollama è rimasto per oltre un anno senza menzione di llama.cpp e che da metà 2025 Ollama ha un'implementazione propria costruita su ggml. Con i due GGUF importati in questa prova, la 0.40.16 ha usato llama-server.
Installazione e uso quotidiano
Ollama si installa con un comando e si usa senza scegliere i flag: per questa prova l'ho installato con winget. La parte che richiede un passaggio in più è portare i propri GGUF, perché Ollama lavora con un registro suo. I due file li ho caricati in Ollama con un Modelfile di una sola riga.
text
FROM C:\percorso\del\modello.gguf
FROM punta al file GGUF già sul disco. Ollama ne fa una copia nella propria cartella, e dopo l'import i due modelli occupano 20 GB. llama-server invece apre il file dove si trova, senza copiarlo, e su un disco piccolo risparmia lo spazio della copia.
Per l'avvio ho misurato il tempo dal comando che lancia il server alla prima risposta su un prompt corto, con un solo avvio per configurazione. Il primo giro di Ollama aveva dato 39,9 secondi con gpt-oss e 76,0 con Qwen, ma era la prima lettura dei file dal disco. A file già in memoria i tempi sono questi:
gpt-oss 20B: Ollama 11,3 s, llama-server 11,6 s
Qwen3.5 9B: Ollama 16,0 s, llama-server 7,2 s
Per tenere più modelli dietro un solo indirizzo Ollama è più comodo: carica il modello alla prima richiesta e lo scarica da solo dopo qualche minuto di inattività (ollama ps
Iscriviti alla newsletter per ricevere i migliori articoli direttamente nella tua inbox.
Intelligenza Artificiale
voicebox: lo studio vocale AI che gira tutto in locale
voicebox è uno studio vocale AI open source che gira tutto in locale: clona voci, genera speech in oltre venti lingue e dà voce agli agenti AI, senza che un byte audio lasci il tuo dispositivo. L'alternativa self-hosted a ElevenLabs e Wispr Flow.
lo mostra nella colonna UNTIL). llama-server serve il modello scritto nella riga di avvio; le versioni recenti hanno anche una modalità router per più modelli.
Contesto e memoria video
Sul controllo del contesto i due programmi si separano, e qui il banco ha dato i risultati più rilevanti. Il contesto è il numero massimo di token, prompt più risposta, che il modello tiene in memoria, e occupa VRAM in proporzione alla sua dimensione, nella cache KV.
Ollama: 4096 token se la VRAM è sotto i 24 GiB
La documentazione di Ollama dice che con meno di 24 GiB di VRAM il contesto predefinito è di 4k, tra 24 e 48 GiB di 32k e da 48 GiB in su di 256k. Nel log del server compare la riga vram-based default context total_vram="15.9 GiB" default_num_ctx=4096. La documentazione non è coerente con sé stessa: la FAQ parla di 4096, la pagina del Modelfile di 2048.
Su /api/generate in modalità raw il prompt da 16.030 token di Qwen è arrivato al modello come 2.050 token. Ne va perso l'87%, la risposta è un normale 200 e gli unici segni sono prompt_eval_count a 2050 e una riga WARN «truncating input prompt» nel log del server, che chi usa l'API non vede. Con il prompt medio, da 4.021 token, Qwen ha generato 75 token invece dei 256 chiesti e si è fermato a 4.096: Ollama passa --context-shift al runner, ma il runner lo spegne con il messaggio «KV cache shifting is not supported for this context».
La stessa richiesta lunga su /api/chat, /v1/chat/completions e /v1/responses (anche con truncation: auto) restituisce invece un errore 400: «request (16033 tokens) exceeds the available context size (4096 tokens), try increasing it». Nella 0.40.16 il taglio senza errore l'ho quindi visto solo su /api/generate. Il problema è segnalato da tempo nel progetto: l'issue #7043, aperta il 30 settembre 2024 con etichetta bug e ancora aperta, chiedeva un avviso quando l'input supera il contesto supportato. L'issue #14259, aperta il 14 febbraio 2026 con etichetta documentation, descrive Ollama che scarta in silenzio i messaggi più vecchi, senza alcun campo nella risposta API che segnali il troncamento. Le note della 0.40.16 dicono che /v1/responses ora rispetta truncation e non tronca più in silenzio per impostazione predefinita, coerente con quello che ho visto.
Il rimedio è alzare il contesto sul server. La documentazione indica la variabile OLLAMA_CONTEXT_LENGTH, oppure il cursore nell'app:
text
OLLAMA_CONTEXT_LENGTH=32768 ollama serve
Con 32768 il prompt intero (16.023 token) arriva al modello sia su /api/generate sia su /v1/chat/completions, senza toccare le richieste, e la VRAM sale da 7.812 a 8.790 MiB. Nelle prove di velocità a 32k ho invece passato num_ctx 32768 nella richiesta, così le due strade lavorano con lo stesso contesto.
llama-server: 4 slot e una cache enorme
llama-server ha il problema opposto: parte con un contesto ampio e riserva memoria per più slot. Dalla PR #16736, fusa il 2 novembre 2025, il server si avvia per impostazione predefinita con 4 slot e cache KV unificata; il README indica -np a -1 (automatico), --kv-unified abilitato quando gli slot sono in automatico e -c a 0, cioè letto dal modello. Georgi Gerganov ha scritto il 19 novembre 2025: «The silent default to 4 slots is a bit problematic, but IMO the advantages are worth it.»
Con il solo -m ho trovato 4 slot con cache condivisa e un contesto per slot di 192.768 token con Qwen e 121.856 con gpt-oss. Con Qwen la memoria a riposo è di 14.148 MiB, contro 8.992 con -c 32768. Togliere gli slot non basta: -np 1 da solo dà uno slot da 201.984 token e la memoria resta a 14.190 MiB. A far scendere il consumo è -c:
Con -np 1 -c 32768 la memoria cala a 8.738 MiB, cioè 5.452 MiB in meno, e la velocità non cambia: 76,1 e 76,6 token al secondo nelle due configurazioni. Sulla GPU da 16 GB del banco sono circa un terzo della memoria video.
Ollama sceglie il contesto in base alla VRAM e lo tiene stretto; llama-server lo prende dal modello e riserva memoria per 4 slot. In tutti e due i casi conviene sceglierlo a mano.
Le API dei due server
Ollama espone la propria API (/api/generate, /api/chat) e una parte compatibile con OpenAI (/v1/chat/completions, /v1/responses), tutte dietro un unico processo che può tenere più modelli. llama-server ha un suo server HTTP, anche lui con rotte compatibili con OpenAI, sopra il modello caricato con il comando.
La differenza che ho misurato sta nel comportamento quando la richiesta supera il contesto. Su Ollama lo stesso prompt può produrre un 200 con il testo tagliato oppure un 400, a seconda dell'endpoint scelto. Su llama-server il limite è quello deciso con -c, e con le impostazioni predefinite il contesto è abbastanza ampio da non farsi notare, ma costa memoria.
Per chi espone Ollama su un server con GPU sotto i 24 GiB, il passo concreto è fissare OLLAMA_CONTEXT_LENGTH sul server e controllare prompt_eval_count nelle risposte, altrimenti i prompt lunghi di un sistema RAG o di un agente rischiano il taglio su /api/generate. Chi usa llama-server deve decidere -c e -np insieme: i default riservano memoria per 4 slot e un contesto enorme, e su una GPU condivisa con altri servizi il costo si vede.
La velocità misurata sul ROG
Il metodo è lo stesso per i due motori. Tre prompt sintetici da circa 100, 4.000 e 16.000 token (un elenco numerato da continuare), temperatura 0, seed 1, un giro di riscaldamento e 5 giri misurati per caso, con la mediana riportata. Su llama-server la cache del prompt è spenta, su Ollama uso /api/generate in modalità raw.
Token generati al secondo a contesto 32k, Ollama contro llama.cpp:
gpt-oss 20B, prompt corto: 181,4 contro 172,5
gpt-oss 20B, prompt medio: 169,2 contro 160,2
gpt-oss 20B, prompt lungo: 164,5 contro 157,1
Qwen3.5 9B, prompt corto: 82,0 contro 80,2
Qwen3.5 9B, prompt medio: 78,7 contro 76,0
Qwen3.5 9B, prompt lungo: 74,8 contro 71,3
Ollama è avanti dal 2,2% al 5,6% in tutti e sei i casi. Sul prompt da 16.000 token Qwen elabora 4.166 token al secondo in lettura del prompt con Ollama e 3.839 con llama.cpp. llama-bench sullo stesso PC dà 188,1 token al secondo con gpt-oss e 82,3 con Qwen, un riferimento senza il livello HTTP. Il motivo del vantaggio di Ollama resta aperto, e l'unica differenza nei log è il batch: llama-server girava con i suoi valori predefiniti, che il log riporta come n_batch 2048 e n_ubatch 512 con flash attention automatica, mentre Ollama lancia il suo con -b 512 -ub 512. Una prova con gli stessi valori nei due motori manca.
InventiveHQ (26 giugno 2026, aggiornato il 13 agosto) ha misurato lo stesso GGUF di Qwen2.5-Coder-7B Q4 su due macchine. Su una RTX 5060 Ti da 16 GB: llama.cpp 77,0 token al secondo, LM Studio 76,8, Ollama 69,1 (il 10,3% sotto). Su un M3 Max: llama.cpp 53,5, Ollama 46,2 (il 14% sotto). È un tempo misurato dall'esterno, che comprende anche il costo del livello HTTP. Le differenze possono dipendere da hardware, modello, metodo di misura e versioni: nel mio banco il segno è opposto e lo scarto è piccolo, quindi il +2-6% vale per questo PC, questi due modelli e queste versioni.
Verdetto per profilo e quando passare a llama.cpp
La velocità non decide: nel mio banco Ollama è avanti in tutti e sei i casi, ma di pochi punti percentuali, e quello di InventiveHQ va in direzione opposta. Decidono contesto, memoria, avvio e gestione dei modelli.
Ollama resta la scelta sensata per iniziare, per tenere più modelli dietro un solo endpoint e per chi non vuole scegliere i flag, a patto di fissare OLLAMA_CONTEXT_LENGTH quando la GPU sta sotto i 24 GiB e di non fidarsi del contesto predefinito con prompt lunghi. Per chi lavora con RAG o agenti su /api/generate la verifica di prompt_eval_count è obbligatoria.
Il passaggio a llama.cpp ha senso quando serve il controllo su contesto, cache KV e memoria: un singolo modello servito da un'unica GPU condivisa, il file GGUF tenuto dov'è senza una copia da 20 GB. Si paga con una riga di avvio da scrivere e con default da capire, in particolare -c e -np.
Come ho provato
Il banco è un ASUS ROG Strix G18 con RTX 5080 Laptop da 16 GB di VRAM (Ollama ne vede 15,9 GiB), Core Ultra 9 275HX, Windows 11 e driver NVIDIA 621.14, con Ollama 0.40.16 e llama.cpp alla build b11569. Le prove le ha lanciate uno script il 13 novembre 2026, tutte nella stessa sera. I due modelli sono gpt-oss 20B in MXFP4 e Qwen3.5 9B in Q6_K (file Unsloth UD-Q6_K_XL), gli stessi della prova di LM Studio Bionic.
Restano fuori dalla prova: Linux, Mac e GPU AMD, più utenti o richieste in parallelo, la qualità delle risposte, i modelli scaricati dal registro di Ollama (ho usato i GGUF importati) e quelli che passano dall'implementazione propria di Ollama, la modalità router di llama-server, una conversazione a più messaggi più lunga del contesto (il caso della issue #14259), /api/generate senza raw e versioni di Ollama diverse dalla 0.40.16. Anche la build di llama.cpp contenuta in Ollama non è nota. Per un'azienda o per un lab con un'altra GPU o un altro sistema operativo, i numeri di velocità vanno rifatti.