SSD Nodes Learn Hosting plans →
Guide Matt ConnorDi Matt Connor · Aggiornato 2026-10-13

Livello di ragionamento per LLM locali: costi reali

Scopri come il livello di ragionamento cambia token, latenza e uso della finestra di contesto su CPU o GPU locali, senza modificare pesi e quantizzazione.

Quali effetti ha il livello di ragionamento su un LLM locale

Il livello di ragionamento indica per quanto tempo il modello deve elaborare la risposta prima di fornirla. Modifica soltanto la lunghezza della fase di ragionamento. I pesi salvati su disco sono identici a ogni livello, così come la quantizzazione, e la risposta viene prodotta dallo stesso passaggio forward. Cambia il numero di token che il modello utilizza inizialmente per il proprio blocco note interno.

Questa distinzione è importante per il modo in cui vengono utilizzati questi token. In un'API hosted, i token di ragionamento compaiono in fattura. Su un VPS di tua proprietà, consumano tempo di generazione sulla tua CPU o GPU e spazio nella finestra di contesto. Un modello configurato al livello di ragionamento massimo può utilizzare gran parte dell'output per elaborare la risposta prima di produrre la prima parola. Su hardware self-hosted, questo può fare la differenza tra una risposta in due secondi e una risposta in due minuti.

Dove risiede il livello: nel template della chat, non nei pesi

Un modello di ragionamento è addestrato a generare un segmento di ragionamento, generalmente racchiuso nei tag <think> e </think>, prima della risposta finale. Il livello di impegno è un'istruzione che il template della chat del modello inserisce nel prompt. Il template è un file Jinja distribuito insieme al modello. Legge una variabile come reasoning_effort e genera una diversa riga a livello di sistema per ogni valore; il modello è stato addestrato ad accorciare o allungare il proprio scratchpad in risposta a quella riga.

Da questo derivano due conseguenze. I nomi dei livelli appartengono al modello, non al runtime, quindi un nome indicato nella scheda di un modello può non avere alcun significato per un altro. Inoltre, se un elemento della catena sostituisce il template della chat del modello con uno generico, la variabile non viene mai interpretata e l'impostazione non produce alcun effetto, senza errori visibili.

Verificata il 2026-10-12, la scheda del modello Qwen3.8-27B documenta tre livelli di impegno: low, medium e xhigh, con xhigh come valore predefinito. Non esiste high. Il ragionamento si abilita con enable_thinking, attivo per impostazione predefinita; la scheda documenta anche preserve_thinking, anch'esso attivo per impostazione predefinita, che mantiene nella cronologia della conversazione il ragionamento dei turni precedenti. gpt-oss usa invece low, medium e high. Molte altre famiglie accettano soltanto un valore booleano. Consultate la scheda relativa alla versione esatta che avete scaricato, perché questi nomi non sono standard. Prima viene l'avvio di un modello 27B su un VPS. Questa pagina riguarda ciò che va configurato dopo che il modello risponde.

Perché un carico di elaborazione elevato costa di più su un VPS

Token di output. I token di ragionamento vengono generati come i token della risposta. Vengono quindi elaborati alla stessa velocità, determinata dall'hardware. Supponiamo che un'attività produca 200 token di risposta e 4,000 token di ragionamento. In totale vengono generati 4,200 token, ma il lettore ne vede 200. La velocità di generazione dipende dalla larghezza di banda della memoria, dalla quantizzazione scelta e dal numero di thread: le note di ottimizzazione di llama.cpp avvertono che un valore --threads superiore al numero di core fisici può sovraccaricare la CPU e rallentare drasticamente la generazione. Dopo avere regolato questi parametri, l'unica leva rimasta è il numero di token.

Tempo reale. L'utente attende il primo token della risposta, perché tutto ciò che viene prima appare come una schermata vuota o un indicatore di caricamento fermo. I token di ragionamento vengono emessi per primi. L'attesa è quindi approssimativamente pari al numero di token di ragionamento diviso per la velocità di generazione, più il tempo di elaborazione del prompt. Se raddoppi la lunghezza del ragionamento, raddoppi anche questa attesa.

Contesto. I token di ragionamento occupano la finestra di contesto come qualsiasi altro token. Con preserve_thinking attivo, il blocco di lavoro del primo turno è ancora presente nel prompt al quinto turno. Di conseguenza, l'elaborazione del prompt rallenta a ogni turno, mentre la finestra si riempie da entrambe le estremità. Aumentare num_ctx per contenerlo richiede più memoria per la cache KV. Su un VPS senza GPU, questa memoria viene allocata nella RAM di sistema, che potrebbe non essere disponibile.

Quando aumentare il livello e quando mantenerlo basso

Aumentalo per le attività in cui un passaggio intermedio errato compromette il risultato: calcoli in più passaggi e conversioni di unità, pianificazione di una modifica su più file, codice che deve essere compilato e problemi con vincoli in cui un'unica risposta deve soddisfare più condizioni contemporaneamente. In questi casi il ragionamento svolge un lavoro effettivo e una sequenza più lunga è un modo economico per rilevare un errore che il modello altrimenti consoliderebbe.

Mantienilo basso quando la risposta è già presente nell'input e il compito consiste nel trasferirla. Rientrano in questa categoria l'estrazione, la classificazione, l'assegnazione di tag, la traduzione, la riscrittura, la sintesi e la formattazione. La fase di ragionamento si limita per lo più a riformulare il compito e lascia al modello lo spazio per mettere in discussione un'intuizione iniziale corretta.

Mantienilo basso anche per tutte le attività interattive. In una chat o in un editor partecipi direttamente al processo: una risposta rapida che puoi correggere è preferibile a una risposta lenta che devi attendere. Questo è il compromesso reale alla base del collegamento di un agente di programmazione a un modello locale: un agente effettua molte chiamate di piccole dimensioni e il costo del ragionamento viene applicato a ognuna di esse.

Come impostare il livello in llama.cpp

llama.cpp scrive direttamente la variabile nel template. Questo lo rende il livello di esecuzione in cui è possibile verificare con certezza che il livello sia stato ricevuto. Impostare -m sul file GGUF già disponibile.

llama-server -m ./qwen3.8-27b-Q4_K_M.gguf \
  --jinja \
  --reasoning-effort medium \
  --reasoning-format deepseek \
  -c 32768 \
  --host 127.0.0.1 --port 8080

--jinja usa il template di chat del modello ed è abilitato per impostazione predefinita nelle build attuali. --reasoning-effort accetta default, minimal, low, medium, high, xhigh o max, dove default significa lasciare invariato il valore predefinito del template. Questo elenco appartiene al vocabolario di llama.cpp, non a quello del modello. Passare quindi solo un nome elencato nella model card: un livello non definito dal template può causare un errore del template al momento della richiesta. --reasoning-format deepseek sposta il ragionamento da message.content a message.reasoning_content. Questo consente di misurare la suddivisione nella sezione successiva.

Per disattivare il ragionamento invece di accorciarlo, impostare direttamente la variabile del template:

llama-server -m ./qwen3.8-27b-Q4_K_M.gguf --jinja \
  --chat-template-kwargs '{"enable_thinking": false}'

--reasoning-budget è un meccanismo diverso. Limita in token il segmento di ragionamento: 0 lo termina immediatamente, mentre -1 lo lascia senza limiti. Non chiede quindi al modello di pianificare un ragionamento più breve. Entrambi i flag impostano il valore predefinito del server. Al 2026-10-12, /v1/chat/completions di llama-server accetta anche reasoning_effort e chat_template_kwargs nel corpo della richiesta e passa il livello al template per quella singola chiamata. none disattiva il ragionamento. Un singolo processo può quindi gestire due livelli di impegno.

vLLM espone la stessa variabile per ogni richiesta, nel corpo compatibile con OpenAI:

{"model": "Qwen/Qwen3.8-27B",
 "messages": [{"role": "user", "content": "Summarise this changelog in two lines."}],
 "chat_template_kwargs": {"reasoning_effort": "medium"}}

Come impostare il livello in Ollama

Ollama usa il campo think, disponibile in /api/chat e /api/generate. Accetta true, false oppure il nome di un livello. Al 2026-10-12, per un modello che pubblica metadati sul ragionamento, i nomi sono quelli definiti dal modello: /api/show li elenca in thinking.values, indicando anche il valore predefinito, e un nome non presente nell'elenco viene sostituito dal valore predefinito senza generare errori. I modelli privi di questi metadati usano il precedente insieme fisso di Ollama: low, medium, high e max. Se ometti think, viene applicato il valore predefinito del modello, che per Qwen3.8 corrisponde all'attivazione del ragionamento.

ollama run qwen3.8:27b --think=low "Draft a one line commit message for a README typo fix"
{"model": "qwen3.8:27b",
 "messages": [{"role": "user", "content": "Which HTTP status code means the request body was too large?"}],
 "think": "low",
 "stream": false}

Il ragionamento viene restituito in message.thinking e la risposta in message.content, già separati. All'interno di una sessione ollama run interattiva, /set think e /set nothink attivano o disattivano questa funzione senza riavviare la sessione, mentre /set think low seleziona un livello.

Ora verifica dove può verificarsi un errore senza messaggi. Il template di Qwen3.8 definisce i livelli low, medium e xhigh. Un modello Ollama contiene un template incluso nel proprio tag, non il file Jinja del repository originale, e Ollama inoltra un livello solo se il modello incluso lo elenca. Controlla prima quali livelli espone il tuo tag:

curl -s http://localhost:11434/api/show -d '{"model": "qwen3.8:27b"}' | jq .thinking

Un nome che non compare in values, ad esempio high o max per questo modello, viene eseguito usando il valore predefinito. Non dare per scontato che l'impostazione sia stata applicata. La verifica richiede circa un minuto.

Come verificare se il livello è stato effettivamente applicato

Invia lo stesso prompt a più livelli con temperature impostato su 0, quindi confronta i conteggi dei token. I tre nomi riportati di seguito sono quelli indicati dalla scheda di Qwen3.8; se /api/show elenca nomi diversi per il tuo tag, usa quelli. In questo caso jq costruisce il corpo della richiesta, quindi non devi fare manualmente l'escape delle virgolette.

for level in low medium xhigh; do
  body=$(jq -n --arg lvl "$level" '{
    model: "qwen3.8:27b",
    messages: [{role: "user", content: "A pump fills a 4500 litre tank in 25 minutes. A second pump is 40 percent slower. How long do both together take? Answer in minutes."}],
    think: $lvl,
    stream: false,
    options: {temperature: 0, num_ctx: 8192}
  }')
  echo "== $level"
  curl -s http://localhost:11434/api/chat -d "$body" | jq '{
    thinking_chars: (.message.thinking // "" | length),
    answer_chars: (.message.content | length),
    eval_count: .eval_count,
    seconds: (.total_duration / 1e9),
    tok_per_sec: (.eval_count / (.eval_duration / 1e9))
  }'
done

eval_count indica ogni token generato, incluso il ragionamento, quindi la differenza tra due livelli corrisponde quasi interamente al ragionamento. thinking_chars fornisce direttamente la suddivisione. Devono verificarsi due condizioni: i numeri devono cambiare tra i livelli e la risposta deve restare corretta anche al livello più basso. Se eval_count resta entro il rumore in tutte e tre le esecuzioni, il livello viene ignorato. Prima verifica i nomi rispetto a /api/show, perché Ollama esegue un nome non elencato usando il valore predefinito; se i nomi corrispondono, la correzione consiste nell'usare un runtime che trasmetta il livello.

Il tempo totale è solo una parte del risultato. Misura anche l'intervallo prima del primo token della risposta, usando lo streaming e interrompendo al primo blocco content non vuoto. Per questo servono jq e bc.

start=$(date +%s.%N)
curl -sN http://localhost:11434/api/chat -d '{
  "model": "qwen3.8:27b",
  "messages": [{"role": "user", "content": "Explain what a reverse proxy does, in three sentences."}],
  "think": "low",
  "stream": true
}' |
while IFS= read -r line; do
  if [ -n "$(printf '%s' "$line" | jq -r '.message.content // ""')" ]; then
    echo "first answer token after $(echo "$(date +%s.%N) - $start" | bc)s"
    break
  fi
done

Eseguilo con low e di nuovo con xhigh. La differenza è il tempo di attesa aggiuntivo. Con llama.cpp gli stessi numeri vengono restituiti nella risposta, senza dover eseguire calcoli aritmetici nella shell:

curl -s http://localhost:8080/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model": "local", "temperature": 0,
       "messages": [{"role": "user", "content": "A pump fills a 4500 litre tank in 25 minutes. A second pump is 40 percent slower. How long do both together take?"}]}' | jq '{
  reasoning_chars: (.choices[0].message.reasoning_content // "" | length),
  answer_chars: (.choices[0].message.content | length),
  predicted_n: .timings.predicted_n,
  tok_per_sec: .timings.predicted_per_second
}'

Esegui questa verifica sul tuo server. Un confronto pubblicato delle prestazioni è stato misurato su hardware diverso dal tuo, mentre la velocità di decodifica effettiva è il valore che converte un conteggio di token in secondi. Misurare i token al secondo sul proprio server fornisce questo valore: i token di ragionamento divisi per la velocità di decodifica corrispondono al tempo di attesa aggiuntivo.

Cosa non funziona

La risposta viene troncata oppure content è vuoto mentre thinking è valorizzato. Il limite di generazione è stato consumato dal reasoning. Il parametro num_predict di Ollama limita l'intera generazione, incluso il reasoning, che viene elaborato per primo. Per questo, con un limite di 512 token e un livello di effort elevato, la generazione può terminare prima dell'inizio della risposta. Ollama restituisce "done_reason": "length" per quella risposta. Aumenta il limite oppure riduci il livello di effort. Come num_predict conta i token descrive in dettaglio questa interazione.

Il livello non cambia nulla. Il numero di token è identico a ogni livello. Il runtime potrebbe non passare la variabile, il template potrebbe non leggerla oppure, su Ollama, il nome potrebbe non essere tra quelli elencati dal tag e quindi potrebbe essere stato usato il valore predefinito. Controlla il template effettivamente utilizzato dal runtime, non quello presente nel repository originale. llama.cpp con --jinja e --chat-template-kwargs inserisce manualmente la variabile e costituisce quindi un buon controllo: se il livello funziona lì ma non altrove, il modello è corretto e il runtime in uso sta eliminando la variabile.

Il nome di un livello viene rifiutato. Un errore del template al momento della richiesta, oppure un errore al primo messaggio con un server altrimenti funzionante, indica in genere che hai passato un livello non definito dal template. Ad esempio, high potrebbe essere stato passato a un modello la cui scheda elenca soltanto low, medium e xhigh. Su Ollama, un modello senza metadati sul thinking accetta soltanto low, medium, high e max. Qualsiasi altro valore restituisce un errore invalid think value.

Le chat con più turni diventano lente a ogni turno. Il reasoning precedente viene mantenuto nella cronologia. Imposta preserve_thinking su false se il modello lo supporta, oppure rimuovi il campo thinking dai messaggi che invii nuovamente. In caso contrario, l'elaborazione del prompt aumenta a ogni turno mentre le risposte mantengono la stessa lunghezza.

La qualità diminuisce con un effort basso in un'attività che ritenevi semplice. Alcune operazioni di estrazione non sono semplici estrazioni. Se l'input richiede una conversione di unità o l'applicazione ordinata di una regola, si tratta di un'attività di reasoning con un output breve. Aumenta il livello per quella singola chiamata, invece di modificarlo per l'intero server.

Eseguire contemporaneamente due livelli

llama.cpp imposta un livello predefinito all'avvio con --reasoning-effort, ma le build attuali accettano anche reasoning_effort per ogni richiesta. Un singolo processo e una sola copia dei pesi possono quindi servire un editor con un livello basso e un job batch notturno con un livello più alto. Se si preferisce fissare ogni livello all'avvio, è possibile usare anche due processi su due porte, al costo di mantenere in memoria due copie dei pesi, a meno di eseguire i job in momenti diversi. In entrambi i casi, i job condividono la capacità di decodifica della stessa macchina. Su un VPS, l'opzione più economica consiste quindi di solito nell'usare un livello basso per le attività interattive, mentre le persone attendono il risultato, e nell'eseguire pianificazioni a livello più alto per le attività che nessuno sta monitorando. Cosa accade quando più utenti condividono un modello locale si applica anche in questo caso: i token di ragionamento richiedono lavoro di decodifica, quindi aumentare il livello riduce la concorrenza effettiva all'incirca dello stesso fattore con cui aumenta il numero di token.

FAQ

Quale livello di ragionamento dovrei usare per impostazione predefinita?

Inizia dal livello più basso disponibile nel modello e aumentalo solo per le attività in cui hai osservato errori. Diversi modelli di ragionamento vengono distribuiti con un livello predefinito elevato e, a ottobre 2026, Qwen3.8-27B usa xhigh, il livello massimo. Questa impostazione predefinita è scelta per ottenere buoni risultati nelle tabelle dei benchmark, ma una tabella di benchmark non tiene conto del tempo. Sul tuo hardware paghi quel tempo in secondi, quindi considera il livello più alto un'opzione da attivare per ogni attività, non l'impostazione ereditata da ogni richiesta.

I token di ragionamento vengono conteggiati nella finestra di contesto?

Sì. Sono normali token dell'output e occupano spazio nella finestra di contesto insieme a tutto il resto. Il fatto che rimangano nel turno successivo dipende dal runtime e dal modello. La scheda di Qwen3.8 documenta preserve_thinking, attivo per impostazione predefinita, che conserva nella cronologia il ragionamento precedente. Di conseguenza, una conversazione lunga include ogni area di lavoro temporanea generata dal modello. Impostalo su false oppure rimuovi il campo thinking dai messaggi che riproponi, così l'elaborazione del prompt non continua ad aumentare.

Perché modificare il livello di ragionamento non cambia il conteggio dei token?

L'impostazione non raggiunge il chat template. Il livello è una variabile del template, quindi funziona solo se il runtime la trasmette e il template distribuito la legge. Alcuni runtime distribuiscono un proprio template insieme al modello invece del file Jinja presente nel repository originale; in questo caso la variabile viene scartata senza stampare alcun errore. Anche Ollama esegue un nome di livello che il modello non elenca come livello predefinito, sempre senza segnalare errori. Verifica il comportamento inviando lo stesso prompt al livello più basso e a quello più alto, con temperature impostato su 0, e confronta eval_count. Se i conteggi coincidono entro il margine di variabilità, il livello viene ignorato.

Un livello di ragionamento più basso rende il modello meno accurato?

Dipende dall'attività. È meglio misurarlo anziché darlo per scontato. Quando la risposta è già presente nell'input, ad esempio nelle attività di estrazione o riscrittura, un'area di lavoro temporanea più breve di solito non cambia il risultato. Quando un passaggio intermedio deve essere corretto prima di poter completare quello finale, ad esempio nell'aritmetica in più passaggi o nel codice che deve essere compilato, l'accuratezza diminuisce con un'area di lavoro temporanea più breve. Crea un insieme di venti prompt tratti dal tuo carico di lavoro reale, eseguili a due livelli con temperature impostato su 0 e conta le risposte errate. Questo numero è specifico del tuo carico di lavoro e nessuna tabella pubblicata può fornirlo.

Questo articolo ti è stato utile?