Costa meno farlo in casa? Dipende da quattro numeri
«Self-hosted costa meno del cloud» è una frase che si ripete senza numeri. La risposta onesta è che dipende da quattro cose che solo tu puoi misurare: quanti token consuma una richiesta, quanto ti fa pagare il fornitore ogni milione, quanto costa la macchina al mese, e quante richieste quella macchina riesce davvero a servire. Le prime tre le legge chiunque; la quarta si dimentica, e cambia il risultato. In questo articolo non trovi un listino: trovi un modello di calcolo eseguibile, con ipotesi dichiarate come tali, da rieseguire con i tuoi prezzi il giorno in cui decidi.
Una precisazione sul contenuto. I prezzi dei fornitori e dei server cambiano, e un articolo che li riporta invecchia in settimane: per questo i valori nel programma sono segnati come ipotesi e nessuna cifra in euro dell'esempio è un listino. Le grandezze che invece si possono derivare da fonti primarie, come la memoria di un modello o i valori predefiniti di Ollama, sono riportate con la loro fonte.
Perché un agente consuma più token di un chatbot
Un agente non fa una chiamata, ne fa una per ogni turno, e a ogni turno rimanda al modello tutta la storia: istruzioni di sistema, messaggi, risultati degli strumenti. Se le istruzioni sono 800 token e ogni turno ne aggiunge 350 (150 di messaggio, 200 di risposta), al sesto turno la richiesta d'ingresso è di 2.550 token e la somma dei sei turni arriva a oltre diecimila, contro i 1.200 generati. L'ingresso cresce come una somma aritmetica, non come un multiplo: è per questo che un ciclo con molti giri costa molto più di quanto suggerisca la lunghezza della risposta finale.
Il conto cambia se il fornitore o il motore riusa la parte iniziale del prompt già elaborata. L'API di Ollama distingue, nella risposta, i token del prompt valutati da zero (prompt_eval_duration riguarda i token «non in cache»); e la documentazione di Mastra avverte che, superato il limite di messaggi della finestra, ogni turno invalida la cache dei prompt del fornitore. Il modello qui sotto non tiene conto di questi sconti: considera il caso peggiore, quello in cui tutto l'ingresso viene pagato.
Il modello di costo, eseguibile
Il programma ha una SCHEDA con sei ipotesi (prezzo per milione di token in ingresso e in uscita, costo mensile della macchina, ore di gestione, valore di un'ora, token al secondo della macchina) e quattro funzioni: i token di una richiesta, il costo cloud, il costo proprio e la capacità. Ogni valore della scheda è inventato da me per il calcolo, non è un listino: sostituiscili con i tuoi. L'uscita è identica a ogni esecuzione.
"""Modello di costo: agenti in cloud (a token) contro una macchina propria.
Ogni numero in SCHEDA e' un'IPOTESI da sostituire con i tuoi: non e' un listino."""
SCHEDA = {
"prezzo_in_eur_per_milione": 0.50, # ipotesi: token di prompt
"prezzo_out_eur_per_milione": 1.50, # ipotesi: token generati
"macchina_eur_mese": 40.0, # ipotesi: server dedicato all'inferenza
"ore_gestione_mese": 3.0, # ipotesi: aggiornamenti, monitoraggio, incidenti
"costo_ora_eur": 50.0, # ipotesi: valore del tuo tempo
"token_s_macchina": 10.0, # ipotesi: generazione, un flusso alla volta
}
SECONDI_MESE = 30 * 24 * 3600
def token_di_una_richiesta(sistema=800, messaggio=150, turni=6, risposta=200):
"""Un agente rimanda a ogni turno tutta la storia: l'ingresso cresce a scala."""
ingresso = sum(sistema + k * (messaggio + risposta) for k in range(turni))
return ingresso, turni * risposta
def costo_cloud(richieste, ing, usc, s=SCHEDA):
return richieste * (ing * s["prezzo_in_eur_per_milione"]
+ usc * s["prezzo_out_eur_per_milione"]) / 1e6
def costo_proprio(macchine=1, s=SCHEDA):
return macchine * s["macchina_eur_mese"] + s["ore_gestione_mese"] * s["costo_ora_eur"]
def capacita_richieste(usc, utilizzo=0.5, s=SCHEDA):
"""Limite fisico: quante richieste genera la macchina, contando solo i token in uscita."""
return int(s["token_s_macchina"] * SECONDI_MESE * utilizzo // usc)
def macchine_necessarie(richieste, usc):
cap = capacita_richieste(usc)
return -(-richieste // cap) # divisione per eccesso: mezza macchina non esiste
ing, usc = token_di_una_richiesta()
cap = capacita_richieste(usc)
per_richiesta = costo_cloud(1, ing, usc)
print(f"una richiesta: {ing} token in ingresso, {usc} in uscita (6 turni)")
print(f"cloud: {per_richiesta:.6f} EUR a richiesta")
print(f"una macchina regge {cap:,} richieste/mese al 50% di utilizzo")
print(f"costo fisso con una macchina: {costo_proprio(1):.2f} EUR/mese")
print("\nrichieste/mese | cloud EUR | macchine | proprio EUR | piu' economico")
for r in (1_000, 10_000, 50_000, 100_000, 200_000, 400_000):
n = macchine_necessarie(r, usc)
c, p = costo_cloud(r, ing, usc), costo_proprio(n)
print(f"{r:>14,} | {c:>9.2f} | {n:>8} | {p:>11.2f} | {'cloud' if c < p else 'proprio'}")
def primo_pareggio(passo=100):
"""Prima quota di richieste/mese in cui la macchina propria costa meno del cloud."""
r = passo
while costo_cloud(r, ing, usc) <= costo_proprio(macchine_necessarie(r, usc)):
r += passo
return r
print(f"\npareggio ingenuo (una sola macchina, capacita' ignorata): {costo_proprio(1) / per_richiesta:,.0f}")
print(f"pareggio con la capacita' (macchine aggiunte quando servono): {primo_pareggio():,}")
def token_al_secondo(risposta):
"""Formula della documentazione Ollama: eval_count / eval_duration * 10^9."""
return risposta["eval_count"] / risposta["eval_duration"] * 1e9
# Risposta di esempio presa dalla documentazione dell'API di Ollama: NON e' una misura mia.
esempio = {"prompt_eval_count": 26, "prompt_eval_duration": 130079000,
"eval_count": 259, "eval_duration": 4232710000}
print(f"\nesempio della documentazione: {token_al_secondo(esempio):.1f} token/s in generazione")
# Output:
# una richiesta: 10050 token in ingresso, 1200 in uscita (6 turni)
# cloud: 0.006825 EUR a richiesta
# una macchina regge 10,800 richieste/mese al 50% di utilizzo
# costo fisso con una macchina: 190.00 EUR/mese
#
# richieste/mese | cloud EUR | macchine | proprio EUR | piu' economico
# 1,000 | 6.83 | 1 | 190.00 | cloud
# 10,000 | 68.25 | 1 | 190.00 | cloud
# 50,000 | 341.25 | 5 | 350.00 | cloud
# 100,000 | 682.50 | 10 | 550.00 | proprio
# 200,000 | 1365.00 | 19 | 910.00 | proprio
# 400,000 | 2730.00 | 38 | 1670.00 | proprio
#
# pareggio ingenuo (una sola macchina, capacita' ignorata): 27,839
# pareggio con la capacita' (macchine aggiunte quando servono): 51,300
#
# esempio della documentazione: 61.2 token/s in generazione
La funzione che fa la differenza è capacita_richieste: una macchina che genera 10 token al secondo, usata al 50%, produce in un mese circa 13 milioni di token in uscita, cioè 10.800 richieste da 1.200 token. Senza quel limite il conto sarebbe ingenuo: 190 euro fissi divisi per 0,006825 euro a richiesta danno un pareggio di 27.839 richieste al mese, ma una sola macchina ne regge 10.800. L'ultima riga lo dice: tenendo conto delle macchine da aggiungere, il pareggio si sposta a 51.300 richieste al mese, quasi il doppio.
Leggi la tabella per scaglioni. Fino a 10.000 richieste il cloud costa una frazione del fisso della macchina; a 50.000 i due costi quasi coincidono (341,25 contro 350); da 100.000 in su la macchina propria vince. La conclusione vale per queste ipotesi e per nessun'altra, ma la forma è robusta: il costo del cloud cresce in modo lineare con le richieste, quello proprio a scalini, e il primo punto d'incrocio è sempre più in là di quanto dica il conto senza capacità. Cambia i token al secondo e vedrai spostarsi tutto.
Il numero che più conviene misurare è proprio quello. L'API di Ollama riporta per ogni risposta eval_count ed eval_duration (in nanosecondi), e la documentazione dà la formula dei token al secondo: eval_count diviso eval_duration per 109. L'ultima riga del programma la applica alla risposta di esempio della documentazione, 259 token in 4,23 secondi, che danno 61,2 token al secondo: è un esempio della documentazione, non la velocità di una tua macchina, e di sicuro non la 10 dell'ipotesi. Sostituisci il numero con quello che misuri sul tuo hardware e sul tuo modello.
La memoria: perché la macchina regge meno di quanto pensi
Il collo di bottiglia non è solo la velocità, è la memoria. Un modello occupa memoria per i pesi e, in più, per la cache chiave-valore (KV cache) che cresce con il contesto e con il numero di richieste servite insieme. La cache per token si calcola dalla configurazione del modello: due tensori (chiavi e valori) per ogni strato, per ogni testa di attenzione chiave-valore, per la dimensione della testa, per i byte di ciascun valore. Il programma usa la configurazione pubblicata di un modello di esempio, Qwen2.5-7B-Instruct su Hugging Face, perché serve un caso concreto: è un esempio e non un consiglio di modello.
# Valori letti da config.json di Qwen/Qwen2.5-7B-Instruct su Hugging Face (2026-11-13)
HIDDEN, HEADS, LAYERS, KV_HEADS = 3584, 28, 28, 4
PARAMETRI = 7_615_616_512 # totale dichiarato dal sito del modello
head_dim = HIDDEN // HEADS
def kv_cache_byte(contesto, byte_per_valore=2, parallele=1):
# 2 = chiavi e valori; f16 = 2 byte (default di Ollama per la cache K/V)
return 2 * LAYERS * KV_HEADS * head_dim * byte_per_valore * contesto * parallele
GIB = 1024 ** 3
print("head_dim:", head_dim)
print("cache per token:", kv_cache_byte(1), "byte")
for ctx, par in [(4096, 1), (32768, 1), (8192, 4), (32768, 4)]:
print(f"contesto {ctx:>6} x {par} richieste in parallelo: {kv_cache_byte(ctx, parallele=par) / GIB:5.2f} GiB")
for bit in (16, 8, 4):
print(f"pesi a {bit:>2} bit nominali: {PARAMETRI * bit / 8 / GIB:5.2f} GiB (senza overhead)")
# Output:
# head_dim: 128
# cache per token: 57344 byte
# contesto 4096 x 1 richieste in parallelo: 0.22 GiB
# contesto 32768 x 1 richieste in parallelo: 1.75 GiB
# contesto 8192 x 4 richieste in parallelo: 1.75 GiB
# contesto 32768 x 4 richieste in parallelo: 7.00 GiB
# pesi a 16 bit nominali: 14.19 GiB (senza overhead)
# pesi a 8 bit nominali: 7.09 GiB (senza overhead)
# pesi a 4 bit nominali: 3.55 GiB (senza overhead)
Le costanti in cima vengono dal config.json del modello: 28 strati, 28 teste, 4 teste chiave-valore (è la tecnica detta GQA, che riduce la cache) e dimensione nascosta 3584, quindi dimensione della testa 3584 diviso 28, cioè 128. Il risultato: 57.344 byte, 56 KiB, per ogni token di contesto. Con un contesto di 32.768 token la cache di una sola richiesta pesa 1,75 GiB; con 4 richieste in parallelo, 7 GiB. I pesi a 4 bit nominali valgono 3,55 GiB, ma è un limite inferiore senza overhead: il file vero lo trovi sulla pagina del modello. Il totale ha un solo colpevole, il contesto lungo moltiplicato per le richieste in parallelo.
Ollama espone proprio queste leve, con valori predefiniti che la sua FAQ dichiara:
OLLAMA_CONTEXT_LENGTH: la finestra di contesto, 4096 token se non la imposti;OLLAMA_NUM_PARALLEL: le richieste elaborate insieme da ciascun modello, 1 di default; la RAM necessaria scala con questo valore per la lunghezza del contesto;OLLAMA_MAX_QUEUE: le richieste in coda prima di rifiutare le successive, 512 di default (oltre, risponde 503);OLLAMA_KEEP_ALIVE: per quanto un modello resta in memoria dopo l'ultima richiesta, 5 minuti di default;OLLAMA_KV_CACHE_TYPE: la precisione della cache,f16di default;q8_0usa circa la metà della memoria.
Tutte e cinque le leve spostano costo e comportamento. Alzare il parallelismo moltiplica la memoria della cache, come mostra il programma. La coda di 512 posti trasforma un picco in latenza invece che in errore, fino a un punto. Un KEEP_ALIVE di cinque minuti vuol dire che il primo utente dopo una pausa paga il caricamento del modello. E la cache quantizzata riduce la memoria a spese della precisione: la stessa FAQ avverte che modelli con molte teste per gruppo, come la famiglia Qwen2, possono risentirne di più. Non c'è un valore giusto: c'è quello che hai misurato sul tuo carico.
OLLAMA_CONTEXT_LENGTH=8192 ollama serve # contesto per richiesta
OLLAMA_NUM_PARALLEL=2 # richieste in parallelo per modello
OLLAMA_MAX_QUEUE=64 # coda piu' corta: rifiuta presto invece di accumulare
OLLAMA_KEEP_ALIVE=30m # modello caldo per mezz'ora
Le variabili sono quelle della FAQ di Ollama; i valori sono esempi da adattare e non sono stati eseguiti, perché avviare il servizio apre una porta. Una nota di sicurezza dalla stessa FAQ: Ollama si lega a 127.0.0.1:11434 e cambiarlo con OLLAMA_HOST lo espone alla rete, quindi se più macchine devono raggiungerlo mettigli davanti un'autenticazione tua: non ho verificato che ne offra una propria.
Che cosa il modello non conta
Il modello di costo è volutamente piccolo, e i suoi limiti sono la parte onesta dell'analisi. Non conta:
- il tempo per valutare il prompt: su CPU può superare il tempo di generazione, e il programma lo ignora, quindi la capacità reale è inferiore a quella stimata;
- la qualità: un modello piccolo e uno grande non rispondono allo stesso modo, e rifare le richieste fallite ha un costo che non compare;
- l'affidabilità di una sola macchina: manutenzione, aggiornamenti, un guasto di notte;
- i dati: costo non è il solo motivo per tenere le richieste in casa, e per alcuni carichi è quello decisivo;
- la manutenzione del software dell'agente, che cambia a ogni versione, come mostrano gli articoli precedenti della serie.
Il primo punto spiega perché l'esito va letto come ottimistico per la macchina propria: se la capacità reale è più bassa, le macchine necessarie crescono e il pareggio si sposta ancora più in là. Gli altri quattro non hanno una cifra, e questo non li rende secondari: sono le ragioni per cui la scelta si fa di rado solo sul costo. Se ti accorgi che la decisione dipende da uno di essi, il modello non serve più: serve una prova sul tuo carico, per una settimana, con i tuoi dati.
Come usare i risultati
La procedura che ne esce è breve. Primo, registra per una settimana i token in ingresso e in uscita di ogni richiesta, che i fornitori di norma riportano nella risposta (Ollama lo fa con prompt_eval_count ed eval_count). Secondo, misura i token al secondo del tuo hardware con i campi della risposta di Ollama. Terzo, inserisci i prezzi di quel giorno nella SCHEDA e rilancia il programma. Quarto, confronta il costo con il valore di ciò che sposti in casa: privacy, indipendenza dal fornitore, tempi. Un'architettura ibrida, con le richieste semplici in locale e quelle difficili presso un fornitore, è un'opzione da valutare dopo la misura, non prima.
Che cosa sai fare adesso
Sai scomporre il costo di un agente in token, macchina e tempo di gestione, sai perché i token crescono a ogni turno e perché la capacità sposta il pareggio, e sai calcolare la memoria di un modello dalla sua configurazione. Hai un programma che puoi rieseguire con prezzi tuoi. Per ciò che l'agente ricorda tra una sessione e l'altra, e quanto pesa nel prompt, c'è l'articolo su Letta; per i tool e i workflow in TypeScript, quello su Mastra. Prima di spendere, guarda il confronto fra i framework, perché il framework decide quanti giri fa il tuo agente; dopo, l'articolo sull'osservabilità ti mostra come misurare i giri. Per i dettagli di Ollama in produzione c'è anche l'articolo sul setup di Ollama.
Domande frequenti
Un modello self-hosted costa meno del cloud?
Dipende da quattro numeri: token per richiesta, prezzo del cloud al milione di token, costo mensile della macchina e richieste che la macchina riesce a servire. Con le ipotesi dell'articolo il pareggio cade a 51.300 richieste al mese, ma sono ipotesi: riesegui il programma con i tuoi prezzi del giorno.
Quanta memoria serve per far girare un modello da 7 miliardi di parametri?
Per i pesi, parametri per bit diviso otto: a 4 bit nominali un modello da 7,6 miliardi occupa circa 3,5 GiB, a cui si aggiunge la cache chiave-valore, 56 KiB per token di contesto nel modello di esempio. Il file reale del modello e l'overhead del motore cambiano il totale, quindi misuralo.
Posso fidarmi dei prezzi e dei token al secondo dell'esempio?
No: sono ipotesi dichiarate per far girare il calcolo. Le uniche cifre prese da fonti sono quelle del config.json del modello e i valori predefiniti di Ollama, letti il 13 novembre 2026. Prezzi e velocità vanno sostituiti con ciò che leggi e misuri tu.
Fonti
- Hugging Face: config.json di Qwen2.5-7B-Instruct - strati, teste di attenzione, teste chiave-valore e dimensione nascosta per il calcolo della cache, consultata il 2026-11-13
- Hugging Face: scheda di Qwen2.5-7B-Instruct - licenza Apache-2.0 e totale dei parametri (7.615.616.512) dall'API del sito, consultata il 2026-11-13
- Ollama: FAQ - contesto di 4096 token, NUM_PARALLEL, MAX_QUEUE, KEEP_ALIVE, KV_CACHE_TYPE, indirizzo di ascolto, consultata il 2026-11-13
- Ollama: documentazione dell'API - campi eval_count, eval_duration, prompt_eval_duration e la formula dei token al secondo, consultata il 2026-11-13
- Mastra docs: Memory class - la finestra scorrevole invalida la cache dei prompt del fornitore, consultata il 2026-11-13
I valori in euro e i token al secondo nel programma dei costi sono ipotesi dell'autore e non provengono da alcuna fonte; il programma è stato eseguito due volte con python3 -I e la stessa uscita. Il programma della memoria usa le costanti del config.json elencato, lette il 2026-11-13.

Commenti
Caricamento commenti...
Accedi per commentare