SSD Nodes Learn Hosting plans →
Guide Matt ConnorDi Matt Connor

Come eseguire il server llama.cpp su un VPS

Compila llama.cpp al tag b10488, servi modelli GGUF con API compatibile con OpenAI, limita l'ascolto a localhost e gestisci la memoria con systemd.

Cosa stai configurando

Eseguire il server llama.cpp su un VPS significa usare un unico binario, llama-server, che carica un singolo file di modello GGUF e risponde alle richieste HTTP tramite un'API compatibile con OpenAI. Indica http://127.0.0.1:8080/v1 a un client compatibile, quindi verifica le funzionalità utilizzate dalla tua applicazione: la compatibilità è parziale. L'installazione è la parte più semplice.

Il resto del lavoro riguarda la gestione operativa: bloccare una versione, mantenere la porta in ascolto solo su localhost, creare un'unità systemd e decidere cosa deve accadere quando il server esaurisce la memoria. Questa guida tratta questi aspetti. Se non hai ancora scelto tra le due opzioni più evidenti, leggi prima il confronto tra Ollama e llama.cpp, perché questa guida descrive proprio la procedura che quel confronto lascia volutamente da parte.

Scegli un tag di release e annotalo

llama.cpp usa tag con il numero di build, come b10488, per le build nightly di sviluppo e tag con versione semantica, vX.Y.Z, per le release ufficiali. b10488 è la build fissata utilizzata in questa procedura, rilasciata il 18 agosto 2026. "Latest" cambia nel tempo e l’unica versione che puoi supportare è quella che hai testato. Scegli un tag, annotalo e usa la stessa stringa nel clone, nel nome del binario e nelle note.

Il tag b10488 include anche archivi precompilati. Per una VPS x86 solo CPU, l’archivio è llama-b10488-bin-ubuntu-x64.tar.gz; se usi una VPS ARM invece di x86, accanto trovi anche un archivio arm64.

curl -LO https://github.com/ggml-org/llama.cpp/releases/download/b10488/llama-b10488-bin-ubuntu-x64.tar.gz
tar tf llama-b10488-bin-ubuntu-x64.tar.gz | head

Elenca l’archivio prima di estrarlo, così sai dove verranno posizionati i file. Questi binari sono collegati alla libreria C dell’immagine utilizzata per compilarli; su una distribuzione più datata non si avviano e mostrano un errore che indica una versione di GLIBC_ non installata. Compilare dai sorgenti richiede pochi minuti su una VPS di piccole dimensioni ed elimina questa classe di problemi, quindi di seguito viene utilizzato questo approccio.

Compilare llama-server da un tag fissato

sudo apt update
sudo apt install -y build-essential cmake git libssl-dev
git clone --depth 1 --branch b10488 https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF -DLLAMA_BUILD_TESTS=OFF -DLLAMA_BUILD_EXAMPLES=OFF
cmake --build build --config Release -t llama-server -j 2

--branch b10488 su un clone --depth 1 estrae quel tag e nient'altro, quindi la build non può cambiare durante il lavoro.

libssl-dev è importante perché l'opzione LLAMA_OPENSSL è attiva per impostazione predefinita. È questa opzione che consente al binario di scaricare in seguito i modelli tramite HTTPS. Senza i file di sviluppo di OpenSSL, questa build fissata segnala che il supporto HTTPS è disabilitato invece di interrompere la configurazione.

-DBUILD_SHARED_LIBS=OFF collega llama.cpp e GGML all'eseguibile, ma le dipendenze dalle librerie di sistema rimangono. La build predefinita colloca le librerie condivise accanto all'eseguibile. Se copi soltanto l'eseguibile in /usr/local/bin, l'avvio fallisce con error while loading shared libraries: libllama.so.

-t llama-server compila soltanto la destinazione server. La build predefinita compila anche gli altri strumenti e i test. Su una VPS con due core, questo richiede diversi minuti aggiuntivi per file che non verranno mai eseguiti.

-j 2 è una scelta intenzionale. Ogni processo di compilazione parallelo utilizza una propria working set. Su un piano con poche risorse, -j $(nproc) può quindi terminare con c++: fatal error: Killed signal terminated program cc1plus, quando il kernel interrompe il compilatore tramite l'out-of-memory killer. Riduci il numero di processi paralleli oppure aggiungi uno swap per la build.

Potresti voler modificare un'opzione: GGML_NATIVE è attiva per impostazione predefinita, quindi il compilatore ottimizza il programma per la CPU esatta su cui viene eseguita la build. È la scelta corretta quando compili sulla macchina che eseguirà il programma. Se compili una sola volta e copi il binario su un host diverso, aggiungi -DGGML_NATIVE=OFF. Un binario che usa istruzioni non supportate dall'altra CPU termina con Illegal instruction (core dumped) alla prima inferenza.

Installalo con un nome che includa il tag.

./build/bin/llama-server --version
sudo install -m 755 build/bin/llama-server /usr/local/bin/llama-server-b10488
sudo ln -sfn /usr/local/bin/llama-server-b10488 /usr/local/bin/llama-server

--version visualizza il numero della build e il commit. Devono corrispondere al tag estratto. In caso contrario, hai compilato qualcos'altro. Mantenere il numero nel nome del file e puntare a quel file tramite un symlink consente di eseguire un aggiornamento con un ln -sfn e un riavvio, mentre il rollback usa lo stesso comando con il numero precedente.

Scaricare un modello GGUF e controllare prima lo spazio su disco

GGUF è il formato a file singolo caricato da llama.cpp. Un unico file contiene i pesi, il tokenizzatore e i metadati, quindi non è necessario installare altro. Il suffisso del nome file indica la quantizzazione, cioè la precisione con cui sono memorizzati i pesi: Q4_K_M è un formato misto a 4 bit, Q8_0 è a 8 bit e f16 è il file non quantizzato a precisione dimezzata.

Creare un account di servizio e una directory per i modelli prima di scaricare qualsiasi file.

sudo useradd --system --home /srv/llama --create-home --shell /usr/sbin/nologin llama
sudo install -d -o llama -g llama /srv/models
df -h /srv

Il server può scaricare autonomamente un modello con -hf. È il modo più rapido per verificare che la build funzioni.

sudo -u llama env LLAMA_CACHE=/srv/models /usr/local/bin/llama-server \
  -hf ggml-org/gemma-3-1b-it-GGUF:Q4_K_M --host 127.0.0.1 --port 8080

LLAMA_CACHE imposta la directory di download. Senza questa opzione o XDG_CACHE_HOME, il file viene salvato in ~/.cache/llama.cpp, usando l'account che ha eseguito il comando; l'unità riportata sotto rende /srv/llama di sola lettura. Eseguire poi ls -lh /srv/models, perché il nome del file nella cache deriva dal nome del repository e non dal semplice nome del file.

Per un servizio, scaricare il modello in un percorso scelto, così il file dell'unità può puntare a un percorso stabile.

sudo -u llama curl -L --output-dir /srv/models -O \
  https://huggingface.co/ggml-org/gemma-3-1b-it-GGUF/resolve/main/gemma-3-1b-it-Q4_K_M.gguf

Lo spazio su disco è il primo limite che si incontra. Queste sono le dimensioni pubblicate di due modelli, verificate il 18 agosto 2026.

GraficoGGUF file size on disk, published figures, 18 August 2026
I dati alla base di questo grafico
[
  {
    "label": "gemma-3-1b-it Q4_K_M",
    "size_gb": 0.81
  },
  {
    "label": "gemma-3-1b-it Q8_0",
    "size_gb": 1.07
  },
  {
    "label": "gemma-3-1b-it f16",
    "size_gb": 2.01
  },
  {
    "label": "gpt-oss-20b MXFP4",
    "size_gb": 12.11
  }
]

Il file a 4 bit del modello 1B è di 0.81 GB. Lo stesso modello senza quantizzazione è di 2.01 GB, quindi la scelta del formato modifica il valore di oltre un fattore due. Un modello 20B in MXFP4 occupa 12.11 GB e, dopo il download, deve comunque essere caricato in memoria. Se si sta valutando una famiglia specifica, lo stesso confronto delle dimensioni per GLM mostra quanto rapidamente il modello principale possa diventare troppo oneroso per un VPS, mentre un modello più piccolo della stessa famiglia resta compatibile.

Controllare df -h prima di ogni download. Se il filesystem root si riempie durante un trasferimento di 12 GB, tutti gli altri componenti che devono scrivere, incluso il journal, smettono di funzionare.

Eseguilo una volta manualmente e controllalo

sudo -u llama /usr/local/bin/llama-server \
  --model /srv/models/gemma-3-1b-it-Q4_K_M.gguf \
  --host 127.0.0.1 --port 8080 \
  --ctx-size 4096 --parallel 1 --threads 2 --no-webui

In una seconda sessione, chiedi al server se è pronto.

curl -s http://127.0.0.1:8080/health

Mentre il file viene caricato, ricevi HTTP 503 con questo corpo:

{"error":{"code":503,"message":"Loading model","type":"unavailable_error"}}

Quando è pronto, il corpo è {"status": "ok" }. Invia quindi una richiesta reale.

curl -s http://127.0.0.1:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"local","messages":[{"role":"user","content":"Say hello in five words."}]}'

Un oggetto JSON con un array choices indica che il server funziona. Il campo model è presente perché i client OpenAI lo inviano sempre. Questo server ha un solo modello caricato, quindi il valore non viene usato per selezionare alcun modello.

L’API compatibile con OpenAI e gli altri endpoint disponibili sulla porta

POST /v1/chat/completions, POST /v1/completions, POST /v1/responses e POST /v1/embeddings sono route compatibili con OpenAI, mentre GET /v1/models restituisce il modello caricato. Per generare embedding è necessario un modello con un pooling diverso da none. GET /health è il controllo di disponibilità descritto sopra, GET /props restituisce le impostazioni correnti del server e GET /metrics espone i contatori Prometheus quando si avvia il server con --metrics.

Per le chiamate compatibili con gli SDK OpenAI, impostare l’URL di base su http://127.0.0.1:8080/v1 e fornire una stringa non vuota come chiave API se lo SDK la richiede. Questo non garantisce la compatibilità con tutte le funzionalità dello SDK. La chiave non viene verificata finché non si imposta personalmente --api-key o --api-key-file.

Non usare le stime delle prestazioni dichiarate da altri come riferimento per il proprio piano. La velocità dell’inferenza sulla CPU dipende dal numero di core, dalla larghezza di banda della memoria e dagli altri carichi che condividono l’host. Misurare i token al secondo sul proprio server e considerare questo risultato come il dato di riferimento. Il tempo sottratto da un vicino rumoroso si manifesta come una velocità di generazione che varia da un’ora all’altra.

Mantienilo su 127.0.0.1 e anteponi un proxy

--host utilizza già 127.0.0.1 come impostazione predefinita, quindi il server non è raggiungibile dall'esterno finché non modifichi questa impostazione. Lasciala invariata. Usa il proxy per gli account utente, i limiti di frequenza delle richieste e il logging di audit; l'autenticazione API integrata usa chiavi statiche: --api-key accetta una chiave o un elenco separato da virgole, mentre --api-key-file legge una chiave per riga. Una porta di inferenza esposta offre risorse di calcolo gratuite a chiunque la individui, e lo stesso errore commesso con Ollama ha la stessa dinamica: mettere in sicurezza un'API di modelli self-hosted si applica qui riga per riga.

Termina TLS (transport layer security) in nginx e inoltra le richieste alla porta di loopback.

server {
    listen 443 ssl;
    server_name llm.example.com;

    location /v1/ {
        proxy_pass http://127.0.0.1:8080;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_buffering off;
        proxy_read_timeout 600s;
    }
}

proxy_buffering off inoltra al client le risposte in streaming non appena nginx le riceve. Con il buffering attivo, nginx memorizza i dati ricevuti dall'upstream invece di inoltrare immediatamente ogni evento. proxy_read_timeout 600s lascia più tempo alle risposte lente. È l'intervallo massimo che nginx attende tra due letture dal server, non un limite per l'intera risposta; quindi, con il valore predefinito di 60 secondi, una richiesta non in streaming che non invia dati per quell'intervallo va in timeout. In b10488, le risposte in streaming inviano per impostazione predefinita ping SSE di keepalive ogni 30 secondi, anche durante l'elaborazione prolungata del prompt. Ottieni il certificato con Certbot e Let's Encrypt su nginx.

L’unità systemd

Scrivi /etc/systemd/system/llama-server.service.

[Unit]
Description=llama.cpp server
After=network-online.target
Wants=network-online.target

[Service]
User=llama
Group=llama
Environment=LLAMA_ARG_MODEL=/srv/models/gemma-3-1b-it-Q4_K_M.gguf
Environment=LLAMA_ARG_HOST=127.0.0.1
Environment=LLAMA_ARG_PORT=8080
Environment=LLAMA_ARG_CTX_SIZE=4096
Environment=LLAMA_ARG_N_PARALLEL=1
Environment=LLAMA_ARG_THREADS=2
ExecStart=/usr/local/bin/llama-server --no-webui
Restart=on-failure
RestartSec=5
TimeoutStopSec=30
MemoryHigh=3G
MemoryMax=3500M
OOMPolicy=stop
NoNewPrivileges=yes
PrivateTmp=yes
ProtectSystem=strict
ProtectHome=yes

[Install]
WantedBy=multi-user.target

Le impostazioni si trovano nelle righe Environment= perché llama-server legge le variabili LLAMA_ARG_* per la maggior parte dei flag; un argomento della riga di comando sovrascrive la variabile corrispondente. In questo modo puoi modificare la dimensione del contesto in un unico punto e mantenere ExecStart abbastanza breve da poterlo leggere a colpo d’occhio.

ProtectSystem=strict rende il filesystem di sola lettura per questa unità, con eccezioni tra cui le directory temporanee private. Questo è sufficiente perché il server legge soltanto il modello. Aggiungi ReadWritePaths=/srv/models e Environment=LLAMA_CACHE=/srv/models se vuoi che il servizio scarichi direttamente i modelli con -hf. ProtectHome=yes nasconde /home, /root e /run/user; non nasconde la home di questo account di servizio in /srv/llama, ma ProtectSystem=strict rende quella directory di sola lettura.

sudo systemctl daemon-reload
sudo systemctl enable --now llama-server
systemctl status llama-server
curl -s http://127.0.0.1:8080/health
journalctl -u llama-server -n 50 --no-pager

enable --now è la parte che spesso viene saltata. Senza enable, il server non sarà più disponibile dopo il riavvio successivo. Se vuoi pianificare attività relative al servizio, ad esempio un controllo notturno per verificare la disponibilità di una nuova release, un servizio systemd con il relativo timer è il meccanismo da usare.

Decidi cosa deve accadere in caso di OOM prima che si verifichi

L'uso della memoria ha due componenti, che si comportano in modo diverso quando è presente un limite. Per impostazione predefinita, il file del modello viene mappato in memoria, quindi le relative pagine sono supportate dal file: il kernel può rilasciarle e rileggerle dal disco. La cache KV, cioè lo stato per token che il server conserva per ogni conversazione attiva, è memoria anonima. Non può essere rilasciata, quindi è questa memoria a causare l'uccisione del processo.

Per questo i due limiti nell'unità svolgono funzioni diverse. MemoryHigh=3G è un limite flessibile: oltre questo valore il kernel sottopone il cgroup a pressione di reclaim, quindi le pagine del modello mappate vengono espulse e rilette dal disco al token successivo. Il servizio continua a funzionare, ma diventa più lento. MemoryMax=3500M è il limite massimo: il kernel recupera prima tutta la memoria possibile e, se l'uso non può comunque rientrare nel limite, l'OOM killer viene eseguito all'interno dell'unità e il journal lo indica chiaramente.

llama-server.service: A process of this unit has been killed by the OOM killer.

Imposta autonomamente --ctx-size. Il valore predefinito è 0, cioè la dimensione del contesto con cui il modello è stato addestrato; nei modelli moderni con contesto lungo questo valore alloca una cache KV molto grande all'avvio. Il servizio termina quindi prima di gestire una sola richiesta. --parallel non moltiplica da solo questo costo: --ctx-size imposta la dimensione totale della cache KV, condivisa da tutti gli slot, quindi --ctx-size 4096 --parallel 4 assegna a ogni conversazione circa 1,024 token invece di quadruplicare la memoria. Assegnare a ogni slot l'intero contesto significa moltiplicare --ctx-size per il numero di slot, facendo crescere anche la memoria. Lascia quindi --parallel a 1 finché non ti serve la concorrenza.

Con Restart=on-failure un servizio terminato viene riavviato. Systemd smette di riavviarlo con start request repeated too quickly solo quando il numero di avvii supera il limite di frequenza configurato; il ritardo di cinque secondi tra i riavvii, usato qui, non raggiunge il limite predefinito di cinque avvii in dieci secondi. Arresta un ciclo di riavvii persistente con sudo systemctl stop llama-server, correggi il limite o la dimensione del contesto, quindi cancella lo stato di errore con sudo systemctl reset-failed llama-server e avvia nuovamente il servizio.

Controlla il valore effettivo con systemctl show llama-server -p MemoryCurrent mentre è in esecuzione una richiesta. Limitare la memoria e la CPU del processo con systemd descrive queste direttive in maggiore dettaglio.

Evita lo swap per questo carico di lavoro. Un modello trasferito nello swap trasforma ogni token in letture dal disco a offset casuali. La mappatura in memoria del file del modello produce un effetto analogo con un impatto minore, perché il kernel legge le pagine necessarie direttamente dal file.

Quando Ollama è la scelta migliore

Questo è un bivio. Scegli llama-server quando vuoi un solo processo con i flag che hai impostato, una build fissata e un file scelto da te. Nulla cambia sotto il processo perché non è in esecuzione nient’altro.

Scegli Ollama quando vuoi gestire i modelli: scaricarli in base al nome, conservarne diversi sul disco, scaricare dalla memoria quello inattivo ed eseguire l’aggiornamento con un solo comando invece di ricompilare. Sono attività reali che altrimenti dovresti automatizzare con script. Eseguire Ollama su un VPS svolge lo stesso compito, ma con una scelta operativa opposta. Entrambe le soluzioni espongono un’API compatibile con OpenAI, ma prima di passare da una all’altra verifica gli endpoint e le funzionalità usati dal tuo client.

Aggiornare una build bloccata

Sostituire bNNNNN con il tag della build nightly a cui si vuole passare; per i tag delle release ufficiali usare invece vX.Y.Z.

cd llama.cpp
git fetch --tags
git checkout bNNNNN
cmake -B build -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF -DLLAMA_BUILD_TESTS=OFF -DLLAMA_BUILD_EXAMPLES=OFF
cmake --build build --config Release -t llama-server -j 2
sudo install -m 755 build/bin/llama-server /usr/local/bin/llama-server-bNNNNN
sudo ln -sfn /usr/local/bin/llama-server-bNNNNN /usr/local/bin/llama-server
sudo systemctl restart llama-server

Il vecchio binario resta sul disco, quindi per eseguire il rollback bastano un ln -sfn a llama-server-b10488 e un riavvio. Leggere le note di rilascio prima di procedere. I file GGUF sono sottoposti a versionamento, ma la compatibilità all'indietro non è universale: il loader corrente rifiuta GGUFv1. Anche i flag vengono rinominati: in b10488, --mlock e --no-mmap erano già deprecati a favore di --load-mode e, dall'11 ottobre 2026, la documentazione corrente del server non li elenca più. Di conseguenza, un unit file che passa un flag rimosso non si avvia e restituisce un messaggio relativo a un argomento non riconosciuto. Anche i valori predefiniti cambiano: le build correnti sono in ascolto sulla porta 9931 per impostazione predefinita, mentre b10488 usava la porta 8080. Per questo ogni comando e l'unit file riportati qui impostano esplicitamente la porta.

Modalità di errore e stringhe visualizzate

error while loading shared libraries: libllama.so dopo aver copiato il binario in un'altra posizione. La build predefinita produce anche librerie condivise. Ricompilare con -DBUILD_SHARED_LIBS=OFF oppure copiare l'intera directory build/bin.

Illegal instruction (core dumped) all'avvio o alla prima richiesta. Il binario è stato compilato con GGML_NATIVE attivo per una CPU diversa da quella in uso. Ricompilare su questa macchina oppure configurare con -DGGML_NATIVE=OFF.

c++: fatal error: Killed signal terminated program cc1plus durante la build. Il compilatore è stato terminato perché utilizzava troppa memoria. Ridurre -j oppure aggiungere spazio di swap per la build e rimuoverlo al termine.

curl: (7) Failed to connect ... Connection refused dal laptop. È il comportamento corretto: il server è in ascolto sull'indirizzo di loopback della VPS. Eseguire il test direttamente sulla VPS oppure aprire un tunnel con ssh -L 8080:127.0.0.1:8080 user@your-vps e usare http://127.0.0.1:8080 localmente.

HTTP 503 con "message":"Loading model" nei primi secondi o minuti dopo un riavvio. La lettura di un file di diversi gigabyte richiede tempo e systemd considera l'unità attiva non appena il processo viene avviato, molto prima che il modello sia stato caricato in memoria.

Le richieste si bloccano e poi restituiscono 504 Gateway Time-out. Il server non ha inviato dati per più tempo di proxy_read_timeout. Questo può accadere con le richieste non in streaming. Le richieste in streaming in b10488 inviano ping keepalive ogni 30 secondi per impostazione predefinita durante l'elaborazione di prompt lunghi. Aumentare proxy_read_timeout e disattivare proxy_buffering, in modo che i token raggiungano il client man mano che vengono prodotti.

L'unità si riavvia ripetutamente e poi si arresta con start request repeated too quickly. Il numero di avvii ha superato il limite di frequenza configurato. Controllare journalctl -u llama-server per individuare la riga relativa all'OOM killer, quindi ridurre --ctx-size oppure aumentare MemoryMax.

FAQ

Devo eseguire il server di llama.cpp o Ollama sul mio VPS?

Esegui llama-server quando vuoi fissare una build esatta, passare flag precisi e mantenere un modello in un singolo file che non venga aggiornato automaticamente. Usa Ollama quando vuoi la gestione dei modelli e gli aggiornamenti con un solo comando, perché scaricare i modelli per nome, mantenerne diversi sul disco e scaricare dalla memoria quelli inattivi sono attività che altrimenti dovresti gestire tramite script. Entrambi espongono un'API compatibile con OpenAI, ma per passare da uno all'altro devi verificare gli endpoint e le funzionalità utilizzate dal client.

Quale versione di llama.cpp devo fissare?

Qualsiasi tag che hai effettivamente compilato e testato. Le build di sviluppo nightly usano tag con il numero di build, come b10488, rilasciato il 18 August 2026; le release ufficiali usano tag con versionamento semantico, vX.Y.Z. Clona il repository con --branch <tag>, installa il binario con un nome che contenga quel tag e punta a quel file tramite un link simbolico, così aggiornamento e rollback richiedono un solo comando ciascuno.

Quanta RAM richiede llama-server?

Parti dalla dimensione del file GGUF, poi aggiungi la cache KV, che cresce con --ctx-size. Questo valore rappresenta il budget totale di token condiviso da tutti gli slot --parallel, quindi più slot richiedono un valore --ctx-size maggiore se ciascuno deve mantenere lo stesso contesto. I valori pubblicati non sostituiscono le misurazioni sul tuo ambiente, perché il totale dipende dal modello, dalla quantizzazione e dal contesto consentito. Esegui systemctl show llama-server -p MemoryCurrent mentre è in corso una richiesta e usa il valore visualizzato.

Perché /health restituisce 503 con "Loading model"?

Il processo è stato avviato, ma il file del modello non è ancora in memoria, quindi il server restituisce {"error":{"code":503,"message":"Loading model","type":"unavailable_error"}}. Questo comportamento è normale dopo ogni riavvio e dura per tutto il tempo necessario a leggere il file. Diventa un problema solo quando un client o un proxy considera quel primo 503 un errore definitivo. Interroga ripetutamente /health finché non restituisce {"status": "ok" }.

Posso esporre direttamente llama-server su Internet?

Non associarlo a 0.0.0.0 e non aprire la porta. Usa il proxy per gestire gli account, i limiti di frequenza delle richieste e il logging degli accessi; l'autenticazione API integrata usa chiavi statiche impostate con --api-key o --api-key-file. Mantieni il bind predefinito 127.0.0.1, configura nginx davanti al servizio con TLS e imposta anche --api-key, così un errore nella configurazione del proxy non lascia il modello esposto a chiunque.

Questo articolo ti è stato utile?