SSD Nodes Learn Hosting plans →
Guide Matt ConnorDi Matt Connor · Aggiornato 2026-11-16

Come bloccare una release di llama.cpp sul server

Scopri la differenza tra tag bNNNN e v0.6.0, registra tag, GGUF e quantizzazione e rendi ogni aggiornamento reversibile senza sorprese.

Cosa è cambiato nella gestione delle versioni di llama.cpp

Bloccare le release di llama.cpp significa compilare un tag specifico e registrare quel nome accanto al file del modello. Il tag non cambia autonomamente, quindi il server continua a produrre domani lo stesso risultato prodotto oggi. Per anni era disponibile un solo tipo di tag: un numero di build come b10502, creato automaticamente a partire da master. Dal 2026 esiste un secondo tipo, un tag di versione come v0.6.0, e i due percorsi non avanzano in parallelo. I tag di build vengono creati quasi a ogni commit su master. I tag di versione vengono creati manualmente da un maintainer, con una frequenza inferiore, e ogni release di versione indica il tag di build corrispondente.

Inizialmente i tag di versione erano provvisori. Le note di rilascio di v0.1.2, pubblicate il 18 agosto 2026, lo dichiaravano in una riga:

Il versionamento semantico è ancora in fase di sviluppo. Ulteriori informazioni sono disponibili in https://github.com/ggml-org/ggml/discussions/1579

Tre giorni dopo v0.2.0 ha definito il modello in modo più preciso. Le relative note di rilascio dichiarano che la release "segna l'inizio di un versionamento semantico coerente per llama.cpp". Descrivono i tag vX.Y.Z come versioni stabili con una frequenza di rilascio inferiore, consigliate per la distribuzione da parte di progetti downstream e per gli utenti non specialisti, e i tag b[NUM] come build nightly o di sviluppo con le funzionalità più recenti, consigliate per sviluppatori e utenti tecnici. Al 14 novembre 2026, l'ultimo tag di versione è v1.0.0, rilasciato il 13 novembre, e le relative note indicano b12359 come tag di build corrispondente.

La discussione su ggml alla base di quel collegamento contiene ancora le motivazioni dello schema e, al 21 ottobre 2026, è ancora aperta per raccogliere commenti. La numerazione delle versioni ha raggiunto 1.x, quindi è opportuno leggere le note prima di ogni aggiornamento, invece di valutare una release in base alla cifra modificata.

Il numero contenuto in un tag di build non ha alcun significato relativo alla versione. Deriva dal conteggio dei commit, quindi aumenta autonomamente, indipendentemente dal fatto che sia cambiato qualcosa di rilevante per la propria configurazione.

Non compilare mai dal branch master su un server che fornisce servizi

git pull seguito da una nuova compilazione ti fornisce tutto ciò che è stato aggiunto nelle ultime ore. Su un laptop può andare bene. Su un server elimina la possibilità di rispondere alla domanda più importante quando il comportamento cambia: che cosa è in esecuzione ora e che cosa era in esecuzione la settimana scorsa. Sia il testo prodotto da un modello sia la velocità con cui lo produce cambiano in base alla build. Se un utente segnala che le risposte sono peggiorate martedì scorso, non puoi individuare la causa se il commit di martedì non è mai stato registrato.

Blocca invece una versione tramite un tag. Il progetto li crea automaticamente e gli archivi di release precompilati riportano un tag di build nei nomi dei file, ad eccezione dei bundle del runtime CUDA per Windows (cudart-llama-bin-win-...).

A quale tag si devono bloccare le release di llama.cpp?

Blocca un tag di build quando vuoi mantenere uno specifico stato noto. È la linea con la cronologia più lunga, quella da cui prendono il nome gli archivi delle release e che viene citata nella maggior parte delle segnalazioni di bug. Per questo, il numero di build è il valore più semplice da confrontare con quello di un altro sistema.

Blocca un tag di versione se preferisci seguire un elenco più breve di punti definiti intenzionalmente. È la linea che il progetto ora consiglia per la distribuzione downstream. Ogni release di versione indica il tag di build corrispondente e i binari precompilati sono associati a quel tag di build. Registra quindi il numero di build accanto alla versione. Leggi le note prima di eseguire l'aggiornamento, anche se la numerazione ha raggiunto la versione 1.x.

In entrambi i casi, la regola operativa è identica. La stringa del tag si trova in un file, il sistema viene ricostruito solo quando quella stringa cambia e la modifica deve essere una decisione intenzionale.

Compilare il tag fissato

sudo apt update
sudo apt install -y build-essential cmake git
git clone --depth 1 --branch b10502 https://github.com/ggml-org/llama.cpp.git ~/src/llama.cpp-b10502
cd ~/src/llama.cpp-b10502
git describe --tags

git describe --tags dovrebbe stampare b10502. Un clone superficiale eseguito su un tag contiene quel commit e nessun commit successivo, quindi in seguito nessuno può spostarlo accidentalmente con un semplice git pull. Se il passaggio di configurazione si interrompe perché manca una dipendenza, installate il pacchetto indicato ed eseguitelo di nuovo.

Compilate con le opzioni richieste dall'hardware. Solo CPU:

cmake -B build
cmake --build build --config Release -j $(nproc)

GPU NVIDIA, con il toolkit CUDA installato in precedenza:

cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j $(nproc)

OpenBLAS su un sistema con sola CPU:

cmake -B build -DGGML_BLAS=ON -DGGML_BLAS_VENDOR=OpenBLAS
cmake --build build --config Release -j $(nproc)

I binari vengono inseriti in build/bin, accanto alle librerie condivise che caricano (libllama.so e i file libggml). Verificate che la compilazione funzioni prima di installarla:

./build/bin/llama-server --version

Installate l'intera directory in un percorso denominato in base al tag, quindi puntate un symlink a quella directory:

sudo install -d /opt/llama.cpp/b10502
sudo cp -a build/bin /opt/llama.cpp/b10502/bin
sudo ln -sfn /opt/llama.cpp/b10502 /opt/llama.cpp/current

Copiate la directory, non il singolo file. Un llama-server isolato non riesce alla prima esecuzione con error while loading shared libraries: libllama.so: cannot open shared object file, perché le librerie necessarie si trovano nella stessa directory.

Configurate il servizio in modo che punti al symlink, mai a una directory del tag:

[Service]
ExecStart=/opt/llama.cpp/current/bin/llama-server -m /srv/models/model-q4_k_m.gguf -c 8192 -ngl 99 --host 127.0.0.1 --port 8080

systemd risolve il symlink quando avvia il processo, quindi per cambiare compilazione basta modificare la destinazione del symlink ed eseguire sudo systemctl restart llama-server. Il resto del file dell'unità e del reverse proxy che lo precede sono descritti nella guida completa per un server llama.cpp su un VPS.

Registra il tag accanto al file GGUF e alla quantizzazione

La build è solo una delle componenti che determinano l'output. L'altra è il file del modello. GGUF (GGML universal file format) è il contenitore in cui vengono distribuiti i pesi, e lo stesso modello viene pubblicato a molti livelli di quantizzazione. Per questo, due server con lo stesso tag possono comunque produrre risultati diversi: uno può contenere un file Q4_K_M e l'altro un file Q8_0. Conserva accanto al modello un piccolo file con tutte le informazioni necessarie per ricreare esattamente la configurazione:

tag: b10502
commit: 0adcc3b
model_file: model-q4_k_m.gguf
model_sha256: <output of sha256sum>
quant: Q4_K_M
cmake_args: -DGGML_CUDA=ON
cuda: <output of nvcc --version>
bench_cmd: llama-bench -p 512 -n 128 -r 5
bench_result: <fill in from the run on this box>

Recupera il commit con git rev-parse --short HEAD all'interno del checkout bloccato. Ottieni il checksum con sha256sum model-q4_k_m.gguf e confrontalo anche con il valore pubblicato dal fornitore al momento del download, perché verificare un download rispetto al checksum pubblicato permette di rilevare un file troncato prima che diventi un bug difficile da diagnosticare. Quanto il livello di quantizzazione modifichi le risposte è una questione distinta; quale costo comporta ogni livello di quantizzazione la approfondisce.

Come aggiornare senza compromettere il server?

Eseguire l’aggiornamento come una prova operativa. Compilare il nuovo tag accanto a quello precedente, misurare entrambi e conservare il precedente finché il nuovo non ha dimostrato di funzionare correttamente.

  1. Clonare il nuovo tag in una directory dedicata. Non riutilizzare il checkout precedente.
  2. Compilarlo usando gli stessi argomenti cmake registrati nel manifest.
  3. Eseguire llama-bench su entrambe le build usando lo stesso file del modello, la stessa lunghezza del prompt e lo stesso numero di ripetizioni.
  4. Inviare a entrambi i server un prompt con una risposta già nota e leggere le due risposte.
  5. Spostare il link simbolico, riavviare il servizio e lasciare la directory precedente sul disco.
/opt/llama.cpp/b10502/bin/llama-bench -m /srv/models/model-q4_k_m.gguf -p 512 -n 128 -r 5
/opt/llama.cpp/<new tag>/bin/llama-bench -m /srv/models/model-q4_k_m.gguf -p 512 -n 128 -r 5

llama-bench stampa una riga per ogni test, con una colonna backend, una colonna ngl e una colonna di token al secondo con la relativa deviazione standard. Confrontare la stessa riga tra le due build, non la riga del prompt di una build con la riga della generazione dell’altra. Un valore ottenuto con una lunghezza del prompt diversa è una misurazione diversa. Per questo misurare i token al secondo sempre nello stesso modo è più importante del valore in sé.

Il rollback richiede due comandi e funziona soltanto perché la directory precedente è ancora presente:

sudo ln -sfn /opt/llama.cpp/b10502 /opt/llama.cpp/current
sudo systemctl restart llama-server

Conservare almeno la build precedente. Occupa una frazione dello spazio su disco già utilizzato dal file del modello che la accompagna.

Cosa si rompe negli aggiornamenti di llama.cpp

Un file modello smette di essere caricato. Di solito è questo il motivo per cui si esegue l'aggiornamento: un modello pubblicato di recente usa un'architettura che la build fissata non riconosce, quindi non viene mai caricato. llama-server termina durante l'avvio. Al 21 ottobre 2026 il codice sorgente del server registra failed to load model, '/srv/models/model-q4_k_m.gguf' in questo caso, con una virgola e il percorso racchiuso tra apici singoli; l'ultima riga stampata è exiting due to model loading error e non contiene alcun percorso. Cerca nel journal failed to load model invece dell'intera riga. Leggi le righe stampate subito prima, inclusa la riga error loading model: del loader, che indicano fino a che punto è arrivato il caricamento e perché si è interrotto. GGUF contiene inoltre una versione del formato nell'header (il valore attuale nella specifica è 3 e la versione 2 ha ampliato i campi della lunghezza da 32 a 64 bit), anche se nella pratica un nome di architettura sconosciuto interrompe il caricamento molto prima del controllo della versione del formato. La correzione consiste nell'usare un tag più recente, scelto e annotato.

Un flag del server viene rinominato o dichiarato obsoleto. Un flag non riconosciuto interrompe llama-server durante l'avvio invece di essere ignorato; con systemd questo appare come un servizio che si avvia e termina in un ciclo continuo. journalctl -u llama-server -n 50 mostra il messaggio effettivo. Al 19 agosto 2026 la documentazione del server indicava --mlock e --mmap come obsoleti a favore di -lm, --load-mode. Al 21 ottobre 2026 nessuno dei due flag compare più nella documentazione del server o nell'elenco degli argomenti su master; trasferisci quindi il comportamento usando --load-mode, che accetta auto (il valore predefinito), none, mmap, mlock, mmap+mlock e dio. Il flag per l'offload sulla GPU è documentato come -ngl, --gpu-layers, --n-gpu-layers, quindi la forma estesa nelle guide meno recenti è ancora accettata. Anche i valori predefiniti cambiano: da v0.7.0 llama-server è in ascolto per impostazione predefinita sulla porta 9931 invece che sulla 8080 (le immagini Docker mantengono la porta 8080 all'interno del container); di conseguenza, un file unit che omette --port smette di rispondere sulla porta attesa dal reverse proxy. La release v1.0.0 rimuove inoltre il flag obsoleto --defrag-thold. Prima di spostare il symlink, esegui /opt/llama.cpp/<new tag>/bin/llama-server --help e verifica ogni flag del file unit rispetto all'elenco mostrato.

Un'opzione di build viene rinominata. Le opzioni CMake sono passate da un prefisso LLAMA_ a un prefisso GGML_ e il file root CMakeLists.txt mantiene ancora la mappatura. LLAMA_CUBLAS è ora un errore fatale che indica GGML_CUDA come sostituzione, mentre LLAMA_CUDA e LLAMA_METAL generano un avviso e vengono convertite automaticamente. Se uno script di build si interrompe durante il passaggio di configurazione, il risultato è corretto. Il problema più grave è un errore silenzioso: se ometti accidentalmente -DGGML_CUDA=ON, la build riesce, il server si avvia e tutto viene eseguito sulla CPU. llama-bench lo mostra immediatamente, perché la colonna backend riporta CPU.

La build per l'acceleratore non è portabile. Al 19 agosto 2026 gli asset Linux associati a un tag di build erano le varianti CPU, Vulkan, SYCL e OpenVINO per x64, arm64 e s390x, senza alcun archivio CUDA per Linux. Da allora la situazione è cambiata. Al 21 ottobre 2026 b11669, il tag di build alla base di v0.7.0, include anche archivi CUDA per Ubuntu con CUDA 12.8 e 13.4 su x64 e CUDA 13.4 su arm64, ciascuno con un archivio runtime cudart- corrispondente, oltre a una build ROCm. Su Linux e Windows gli archivi CUDA vengono pubblicati per ogni versione del toolkit. Questo fornisce un'indicazione utile: la versione del toolkit fa parte degli elementi che identificano il binario, quindi annotala insieme agli argomenti cmake.

Bloccare invece l'immagine del container

Stessa regola, nome diverso. Le immagini pubblicate (ghcr.io/ggml-org/llama.cpp:server e le relative varianti con acceleratore) hanno nomi mobili, quindi eseguendo il pull di :server il mese prossimo si otterrà un programma diverso con la stessa etichetta. Eseguire il pull una volta e leggere il digest:

docker pull ghcr.io/ggml-org/llama.cpp:server

docker pull stampa una riga Digest: sha256:.... Inserire quel digest nel file Compose al posto del tag: l'immagine non potrà cambiare senza preavviso la prossima volta che qualcuno esegue docker compose pull. Conservare il digest precedente in un commento, così un rollback richiede una sola modifica, come nella procedura di aggiornamento e rollback per uno stack Compose, che applica lo stesso approccio a ogni altro servizio.

Il significato del pin

Un pin consente di indicare con precisione che cosa è in esecuzione e di ripristinare la build precedente in meno di un minuto quando una modifica causa problemi. Per farlo, llama.cpp richiede di tracciare due elementi: il tag della build e il file del modello, perché li fornisce separatamente. I runtime che li includono in un unico pacchetto funzionano in modo diverso; il confronto tra Ollama e llama.cpp come server analizza questo compromesso: un unico numero di versione per l'intero insieme è più semplice da registrare e da controllare.

FAQ

Devo bloccare il tag di build bNNNN o il tag v0.x?

Entrambe le opzioni sono valide, purché si blocchi un tag. I tag di build come b10502 rappresentano il ramo seguito nel tempo: gli archivi di release precompilati riportano uno di questi tag nel nome del file (a eccezione dei bundle del runtime CUDA per Windows) e la maggior parte delle segnalazioni di bug ne indica uno. Per questo, il numero di build è il riferimento più semplice da confrontare con quello di un altro amministratore. I tag di versione come v0.6.0 costituiscono invece un elenco più breve di punti selezionati che il progetto consiglia per la distribuzione downstream, una scelta adatta a un server che viene modificato solo alcune volte all'anno. Ogni tag indica il tag di build corrispondente, quindi è necessario registrare entrambi. La cosa più importante non è la scelta del tag, ma registrare la stringa del tag accanto al file del modello e fare in modo che l'aggiornamento sia una decisione esplicita, non un effetto collaterale di git pull.

llama.cpp segue ora il versionamento semantico?

Sì, da v0.2.0, il 21 agosto 2026. Le note di release indicano che questo segna l'inizio di un versionamento semantico coerente per llama.cpp e sostituisce l'avvertenza relativa allo stato di sviluppo che accompagnava v0.1.2. Al 14 novembre 2026, la numerazione delle versioni ha raggiunto la serie 1.x; l'ultima versione è v1.0.0, rilasciata il 13 novembre. Consultare le note di release prima di procedere e testare il nuovo tag con il proprio file del modello prima di adottarlo, indipendentemente dalla cifra modificata.

Come posso verificare quale build di llama.cpp è in esecuzione sul server?

llama-server --version stampa la versione e le informazioni sulla build. Eseguirlo quindi sul binario utilizzato dal servizio: /opt/llama.cpp/current/bin/llama-server --version. Al 21 ottobre 2026, la riga di avvio che contiene il numero di build, l'hash del commit e il compilatore viene registrata al livello trace. Non è quindi garantito trovarla in journalctl -u llama-server con il livello di log predefinito. In un'installazione dai sorgenti, git describe --tags eseguito nella copia di lavoro bloccata stampa il tag, mentre readlink /opt/llama.cpp/current mostra a quale directory punta effettivamente il servizio.

Perché il modello ha smesso di essere caricato dopo l'aggiornamento di llama.cpp?

Un errore di caricamento subito dopo un aggiornamento indica un'incompatibilità tra la build e il file GGUF. Il log contiene una riga failed to load model, '<path>' che identifica il file e termina con exiting due to model loading error; le righe precedenti mostrano fino a quale punto è arrivato il loader. Procedendo verso una versione più recente, un file del modello molto nuovo richiede una build che ne riconosca l'architettura. Tornando a una versione precedente, un rollback a un tag anteriore a quello per cui è stato creato il file può rendere inutilizzabile un file che funzionava il giorno prima. Puntare il symlink alla build precedente, riavviare e verificare quale combinazione di build e file è stata associata correttamente prima di decidere quale dei due modificare.

Esistono binari Linux precompilati che posso bloccare invece di compilare?

Sì. Ogni tag di build include archivi di release denominati in base al tag, ad esempio llama-b10502-bin-ubuntu-x64.tar.gz. Il tag è quindi presente nel nome del file e il blocco della versione è semplice. Il 19 agosto 2026 il set Linux comprendeva CPU, arm64, s390x, Vulkan, SYCL e OpenVINO, senza alcun archivio CUDA. Al 21 ottobre 2026, il nuovo b11669 include anche archivi Ubuntu CUDA 12.8 e 13.4 con i corrispondenti bundle runtime cudart-. Un server NVIDIA che usa un tag recente non deve quindi più compilare dai sorgenti con -DGGML_CUDA=ON né eseguire un'immagine container CUDA. Se si blocca un tag di versione, scaricare gli archivi dal tag di build indicato nelle relative note di release.

Questo articolo ti è stato utile?