Italian language LLM: state of the art 2026

Quale modello linguistico italiano scegliere: la risposta dipende dalla licenza

Se devi usare un modello linguistico aperto per l'italiano, la prima domanda non è «quale è più bravo?» ma «che cosa mi è permesso farne?». Tra i modelli italiani più citati, uno è addestrato da zero con dati e pesi aperti (Minerva), uno ha licenza MIT sul file ma condizioni d'uso a parte (Modello Italia), uno è adattato da Mistral con licenza Apache 2.0 (Cerbero), uno è dichiarato solo per la ricerca (Camoscio). Scegliere in base ai punteggi senza guardare questo significa rischiare di costruire un prodotto che non puoi distribuire.

Questo articolo non riporta classifiche. Riporta quello che si può controllare: che cosa dichiara ciascuna scheda del modello, e come leggerla con un programma che puoi rilanciare. Per il quadro storico leggi LLM italiani nel 2024 e il panorama del 2025.

Tre modi di arrivare a un modello che parla italiano

Immagina di dover far scrivere in italiano un nuovo collega. Puoi assumere chi è cresciuto in Italia, puoi prendere un bravo collega straniero e fargli fare un corso di lingua, oppure fargli semplicemente tradurre il lavoro. I modelli seguono le stesse strade. Cambiano costo, qualità e, soprattutto, ciò che eredita dal punto di partenza: licenza, limiti e difetti.

• Addestrare da zero sull'italiano: Minerva (Sapienza NLP con FAIR e CINECA) e Modello Italia (iGenius con CINECA).
• Continuare l'addestramento di un modello straniero: Cerbero parte da Mistral 7B, LLaMAntino-3 da Llama 3 8B.
• Adattare con poco calcolo: Camoscio applica LoRA a LLaMA 7B con istruzioni tradotte in italiano.

L'elenco è ordinato dal più costoso al più economico, e l'ordine cambia il senso: chi parte da zero decide i dati ma deve pagare mesi di calcolo; chi adatta paga poco ma eredita la licenza e gli eventuali limiti del modello di partenza. Per un'azienda piccola, la strada realistica è quasi sempre la seconda o la terza, e per questo la licenza del modello di base pesa più della qualità in italiano.

Che cosa dichiara ciascun modello

Le informazioni qui sotto vengono dalle schede pubbliche (le «model card») e dai repository degli autori, consultati il 2026-11-12. Dove la scheda stessa avverte che un dato non è ufficiale, lo scrivo.

• Modello Italia 9B: primo modello di iGenius in collaborazione con CINECA. I pesi sul Hub sono una conversione non ufficiale del checkpoint ufficiale, con etichetta di licenza MIT, ma l'uso richiede di accettare i termini e le condizioni di iGenius. Secondo la scheda, i dati di addestramento sono sconosciuti.
• Minerva 7B: famiglia «pretrained from scratch on Italian» di Sapienza NLP con FAIR e CINECA; la scheda del 7B indica quasi 2,5 mila miliardi di token (1,14 mila miliardi in italiano, 1,14 in inglese, 200 miliardi di codice), licenza Apache 2.0.
• Cerbero 7B: costruito su Mistral 7B, licenza Apache 2.0, dichiarato dagli autori utilizzabile anche in ambito commerciale; descritto nel paper «Cerbero-7B: A Leap Forward in Language-Specific LLMs Through Enhanced Chat Corpus Generation and Evaluation».
• Camoscio 7B: LLaMA adattato con LoRA sul dataset Stanford Alpaca tradotto in italiano con l'API di ChatGPT; la scheda lo destina alla ricerca e scrive che l'uso in produzione non è consentito.
• LLaMAntino-3 ANITA 8B: derivato da Meta Llama 3 8B Instruct, con etichetta di licenza llama3, quindi sottoposto alla licenza di Meta.

Il filo che lega le voci è che la riga più importante non è quella sulle prestazioni, ma quella sulla licenza e sull'origine dei dati. Due casi meritano attenzione. Il primo è Modello Italia: l'etichetta MIT descrive la conversione, mentre le condizioni di iGenius restano un vincolo a parte, ed è una distinzione che un controllo automatico delle licenze non coglie. Il secondo è Camoscio: nasce dalle risposte di un altro modello (le istruzioni tradotte con ChatGPT), e i termini d'uso di quel servizio possono limitare ciò che ne ricavi. Per usi commerciali, leggi i testi originali e, se serve, chiedi un parere legale: questo articolo non lo sostituisce.

Leggere le schede con un programma, non a memoria

Le schede cambiano: un modello viene ritirato, una licenza aggiornata. Se scrivi in un documento «Cerbero è Apache 2.0» e non rileggi mai, il documento invecchia. Il programma sotto interroga l'API pubblica di Hugging Face Hub (descritta nella documentazione dell'API del Hub) e stampa licenza, modello di base e architettura dichiarati. Usa solo la libreria standard di Python: niente PyTorch, niente token, nessun download dei pesi.

import json
import urllib.request

MODELLI = [
    "sapienzanlp/modello-italia-9b",
    "sapienzanlp/Minerva-7B-base-v1.0",
    "galatolo/cerbero-7b",
    "teelinsan/camoscio-7b-llama",
    "swap-uniba/LLaMAntino-3-ANITA-8B-Inst-DPO-ITA",
]

def scheda(modello):
    url = "https://huggingface.co/api/models/" + modello
    with urllib.request.urlopen(url, timeout=20) as risposta:
        dati = json.load(risposta)
    carta = dati.get("cardData") or {}
    config = dati.get("config") or {}
    return {
        "modello": modello,
        "licenza": carta.get("license", "non dichiarata"),
        "base": carta.get("base_model", "non dichiarata"),
        "architettura": config.get("model_type", "non indicata"),
        "creato": (dati.get("createdAt") or "")[:10],
    }

for m in MODELLI:
    print(scheda(m))

# Uscita reale (python3 -I schede.py, 2026-11-12):
# {'modello': 'sapienzanlp/modello-italia-9b', 'licenza': 'mit', 'base': 'non dichiarata', 'architettura': 'gpt_neox', 'creato': '2024-06-06'}
# {'modello': 'sapienzanlp/Minerva-7B-base-v1.0', 'licenza': 'apache-2.0', 'base': 'non dichiarata', 'architettura': 'mistral', 'creato': '2024-05-26'}
# {'modello': 'galatolo/cerbero-7b', 'licenza': 'apache-2.0', 'base': 'non dichiarata', 'architettura': 'mistral', 'creato': '2023-10-26'}
# {'modello': 'teelinsan/camoscio-7b-llama', 'licenza': 'openrail', 'base': 'non dichiarata', 'architettura': 'non indicata', 'creato': '2023-03-24'}
# {'modello': 'swap-uniba/LLaMAntino-3-ANITA-8B-Inst-DPO-ITA', 'licenza': 'llama3', 'base': 'meta-llama/Meta-Llama-3-8B-Instruct', 'architettura': 'llama', 'creato': '2024-04-29'}

Le righe che contano sono quelle dentro scheda(). cardData è il blocco di metadati scritto dall'autore nella scheda; config è il file di configurazione del modello, da cui si legge model_type. Il valore predefinito di .get() (qui «non dichiarata») evita un errore quando il campo manca, e rende visibile l'assenza. Se togli il timeout, un Hub lento blocca il programma senza messaggi.

Nell'uscita si vede che l'architettura non coincide sempre con l'origine: Minerva risulta mistral come tipo di modello, ma è addestrata da zero, cioè usa l'architettura di Mistral, non i suoi pesi. Allo stesso modo, il campo base è «non dichiarata» per Cerbero, anche se la scheda dice in testo che è costruito su Mistral 7B: i metadati sono incompleti, quindi una verifica solo automatica non basta. Inoltre la colonna «creato» è la data di creazione del repository, non della pubblicazione del modello: Modello Italia compare nel 2024-06-06 perché la conversione è stata caricata quel giorno.

Che cosa dicono i numeri, e perché non li confrontiamo

Le schede riportano dei risultati, ma ciascuna con benchmark, versione e metodo propri. La scheda di Modello Italia indica un risultato medio di 0,4350 su tre test in italiano (hellaswag_it, arc_it, m_mmlu_it) e rimanda alla classifica Open Italian LLM Leaderboard. La scheda di Cerbero riporta, per il suo benchmark SQuAD-it (comprensione di un testo), un F1 del 72,55% contro il 37,42% di Camoscio. Sono numeri dichiarati dagli autori, su test diversi: mettere i due valori in una stessa tabella darebbe l'impressione di un confronto che non esiste.

Per decidere sul tuo caso, il benchmark migliore è un centinaio di esempi tuoi: domande che i tuoi utenti fanno davvero, con la risposta attesa. Un modello che vince su SQuAD-it può sbagliare sulle tue fatture. Come costruire quella valutazione lo trovi in Fine-tuning di un LLM per l'italiano, e per i casi in cui servono documenti propri guarda RAG in italiano, che spesso evita il fine-tuning.

Caricare un modello: cosa serve e cosa può andare storto

Il codice qui sotto è l'esempio della scheda di Modello Italia, con i miei commenti. Non l'ho eseguito: richiede PyTorch e un computer con molta memoria, e la macchina su cui ho preparato l'articolo non ha né l'uno né l'altra. Prendilo come schema da provare, non come output garantito.

import torch
import transformers as tr

device = "cuda" if torch.cuda.is_available() else "cpu"

tokenizer = tr.AutoTokenizer.from_pretrained("sapienzanlp/modello-italia-9b")
model = tr.AutoModelForCausalLM.from_pretrained(
    "sapienzanlp/modello-italia-9b",
    device_map=device,
    torch_dtype=torch.bfloat16,
)

messages = [
    {"role": "system", "content": "Tu sei Modello Italia, un modello di linguaggio naturale addestrato da iGenius."},
    {"role": "user", "content": "Ciao, chi sei?"},
]
tokenized_chat = tokenizer.apply_chat_template(
    messages, tokenize=True, add_generation_prompt=True, return_tensors="pt"
).to(device)

AutoTokenizer e AutoModelForCausalLM arrivano dalla libreria transformers di Hugging Face; il primo trasforma il testo in numeri, il secondo è il modello che predice la parola successiva. La riga che pesa è torch_dtype=torch.bfloat16: ogni parametro occupa 2 byte invece di 4, e per un modello da circa 9 miliardi di parametri fa circa 18 GB solo per i pesi (9 miliardi per 2 byte, un calcolo mio, senza contare la memoria di lavoro). Senza quella riga, il caricamento userebbe il doppio e su molte schede video si fermerebbe con un errore di memoria.

apply_chat_template costruisce il testo nel formato che il modello ha visto in addestramento: il ruolo «system» imposta il comportamento, «user» è la domanda. Se passi un prompt libero senza questo formato, la risposta peggiora in modo difficile da spiegare. Con device = "cpu" il codice funziona ma è molto lento per un modello di queste dimensioni: sul tuo computer di lavoro, un modello più piccolo (Minerva ha versioni da 350 milioni, 1 e 3 miliardi di parametri, elencate nella sua scheda) è il punto di partenza più sensato per provare. E ricorda che, per Modello Italia, usare i pesi significa accettare le condizioni di iGenius.

Come decidere, in breve

Parti dall'uso. Se il modello deve stare in un prodotto che vendi, scarta per prima cosa ciò che non ha una licenza chiara per l'uso commerciale (Camoscio) o dipende da condizioni separate (Modello Italia, LLaMAntino con licenza Llama 3). Tra ciò che resta, Minerva ha dati e modello aperti, mentre Cerbero ha un'origine su Mistral e una licenza permissiva. A parità di licenza, la prova con i tuoi cento esempi decide. Per la ricerca e per imparare, invece, tutti vanno bene, ed è proprio lì che Camoscio nacque.

Che cosa sai fare adesso

Sai distinguere i tre modi in cui un modello diventa «italiano» e che cosa ciascuno eredita. Sai leggere licenza e origine di un modello con un programma che puoi rilanciare, e sai che i metadati possono essere incompleti. Sai perché non basta una percentuale di benchmark, e come costruire il tuo confronto. E sai stimare a mano la memoria per i pesi di un modello prima di scaricarlo.

Fonti

• Scheda di sapienzanlp/modello-italia-9b su Hugging Face - conversione non ufficiale di Modello Italia, licenza MIT, condizioni di iGenius, architettura GPT-NeoX (non ufficiale), risultati medi, esempio di caricamento, consultata il 2026-11-12
• Scheda di sapienzanlp/Minerva-7B-base-v1.0 su Hugging Face - addestramento da zero, token per lingua, licenza Apache 2.0, taglie della famiglia, consultata il 2026-11-12
• Scheda di galatolo/cerbero-7b su Hugging Face - base Mistral 7B, licenza Apache 2.0, risultati su SQuAD-it dichiarati dagli autori, consultata il 2026-11-12
• Cerbero-7B: A Leap Forward in Language-Specific LLMs Through Enhanced Chat Corpus Generation and Evaluation (arXiv 2311.15698) - il paper del modello, consultata il 2026-11-12
• Repository di Camoscio su GitHub - LoRA su LLaMA, dataset Alpaca tradotto con ChatGPT, uso limitato alla ricerca; il paper associato è arXiv 2307.16456, consultata il 2026-11-12
• Hugging Face Hub: API - l'endpoint usato da schede.py, consultata il 2026-11-12
• Misura nel repository: python3 -I schede.py, uscita riportata sopra, eseguita il 2026-11-12

Il blocco di caricamento con transformers non è stato eseguito (nessun PyTorch sulla macchina di lavoro), e le informazioni su LLaMAntino-3 vengono dai metadati del Hub, non da una lettura integrale della sua scheda.