Nel mondo dell’intelligenza artificiale locale c’è una regola non scritta, ovvero che i modelli davvero grandi restano fuori dalla portata dei comuni mortali. Per far girare un modello di classe frontier servono decine di GPU professionali, il cui prezzo si misura in centinaia di migliaia di euro. Colibrì, un progetto open source pubblicato su GitHub dallo sviluppatore italiano JustVugg (alias Vincenzo) , prova a ribaltare questa regola.
Il suo motore, scritto interamente in linguaggio C e senza alcuna dipendenza esterna, riesce a eseguire GLM-5.2, un modello da 744 miliardi di parametri, su una macchina con circa 25 GB di RAM e un buon SSD. Non è un trucco che degrada il modello, né una versione ridotta, perché il modello resta quello originale, quantizzato in int4, e risponde in locale, senza cloud e senza abbonamenti.
Il prezzo da pagare è la velocità, e su questo il progetto è trasparente, tanto che una sezione del README si intitola proprio “Honest numbers”. In questa guida vedremo come funziona il meccanismo di streaming degli esperti che rende possibile tutto questo, cosa serve per provarlo, quali numeri aspettarsi e perché, anche con i suoi limiti, è uno dei progetti più interessanti del panorama AI in locale di quest’anno.
Mixture of Experts spiegato semplice
Per capire il trucco di Colibrì bisogna prima capire com’è fatto GLM-5.2. I modelli moderni di grandi dimensioni usano quasi tutti un’architettura chiamata Mixture of Experts (MoE), che si può immaginare come un enorme ufficio pieno di specialisti. Invece di un unico cervello monolitico che si attiva per intero a ogni parola, il modello è diviso in diversi piccoli “esperti”, e un componente chiamato router decide di volta in volta quali interpellare.
Nel caso di GLM-5.2 gli esperti sono 19.456, distribuiti su 75 livelli, ma per generare ogni singolo token ne viene attivata solo una piccola frazione. Dei 744 miliardi di parametri totali, quelli effettivamente al lavoro in un dato momento sono circa 40 miliardi. C’è di più, perché tra un token e il successivo la parte che cambia davvero è ancora più piccola, ovvero circa 11 GB di dati relativi agli esperti selezionati dal router.
Qui sta l’intuizione. Se in ogni istante serve solo una fetta sottile del modello, non è necessario tenere tutto in memoria contemporaneamente. È la stessa logica per cui una biblioteca non fotocopia l’intero catalogo sulla tua scrivania, ma ti porta i volumi che chiedi, uno alla volta.
I motori tradizionali per l’AI locale, tuttavia, non ragionano così, perché vogliono l’intero modello in RAM o in VRAM prima di partire. Per un colosso come GLM-5.2, che occupa circa 370 GB già compresso in int4, questo significa semplicemente non partire mai su hardware consumer. Colibrì nasce esattamente per rompere questo vincolo.
L’idea alla base, tenere gli esperti sul disco
La soluzione di Colibrì è trattare VRAM, RAM e disco come un’unica gerarchia di memoria, gestita dal motore. La parte “densa” del modello, cioè quella che serve sempre (attenzione, embeddings e alcuni esperti condivisi), viene caricata in RAM una volta sola e occupa appena 9,9 GB in int4. Tutti gli altri esperti, ovvero il grosso di quei 370 GB, restano sul disco e vengono letti su richiesta, nel momento esatto in cui il router li chiama.
Per non morire di lentezza, il motore usa una serie di accorgimenti. Gli esperti usati di recente restano in una cache LRU in RAM, dimensionata automaticamente in base alla memoria disponibile, così le richieste su argomenti simili riusano ciò che è già stato caricato. Inoltre, mentre un blocco di esperti viene elaborato, il motore sta già leggendo il successivo in modo asincrono, e la cache del sistema operativo fa da secondo livello gratuito.
A tutto questo si aggiunge la decodifica speculativa MTP, una tecnica in cui una testa dedicata del modello “abbozza” più token in anticipo e il modello principale li verifica in un colpo solo, con un guadagno misurato di 2,2-2,8 token per passaggio. Chi ha una scheda NVIDIA può anche attivare un livello CUDA opzionale per tenere gli esperti più usati in VRAM.
La parte che colpisce di più è l’implementazione. Il motore è un singolo file C più qualche header, senza BLAS, senza framework e senza Python a runtime (serve solo per la conversione iniziale del modello). Il paragone con progetti come llama.cpp, che pure resta molto più veloce sui modelli che entrano in memoria, viene naturale, ma la filosofia è diversa, perché qui l’intento dichiarato è non toccare mai la precisione del modello o le decisioni del router. Se la memoria veloce non basta, cala la velocità, non la qualità.
Cosa serve e come si installa
I requisiti sono meno estremi di quanto ci si aspetterebbe. Servono circa 25 GB di RAM, un SSD NVMe con 400 GB liberi e un sistema Linux, WSL2 oppure Windows 11 nativo, dove il progetto compila con MinGW-w64. La velocità del disco è il vero collo di bottiglia, quindi più l’unità è rapida, meglio è.
La compilazione richiede pochi comandi:
git clone https://github.com/JustVugg/colibri
cd colibri/c
./setup.sh # verifica gcc/OpenMP, compila e lancia i test
Per il modello ci sono due strade. La prima è la conversione automatica, dove un solo comando scarica GLM-5.2 uno shard alla volta (circa 5 GB ciascuno), lo converte in int4 e cancella man mano gli originali, senza mai richiedere i 756 GB del checkpoint completo su disco. Il processo è riprendibile se si interrompe:
pip install torch safetensors huggingface_hub numpy
./coli convert --model /nvme/glm52_i4
La seconda strada, più comoda, è scaricare da Hugging Face il modello già convertito (repository mateogrgic/GLM-5.2-colibri-int4-with-int8-mtp). Attenzione a un dettaglio importante, segnalato dallo stesso progetto, cioè che la testa MTP deve essere in int8. Un vecchio mirror la distribuiva in int4 e in quel caso la decodifica speculativa non si attiva mai, facendo perdere circa metà della velocità.
A quel punto si parte con un comando solo:
COLI_MODEL=/nvme/glm52_i4 ./coli chat
Prima di caricare tutto, vale la pena usare due strumenti inclusi. Il comando coli plan mostra in anticipo come verranno distribuiti i pesi tra disco, RAM ed eventuale VRAM, mentre coli doctor esegue un controllo di compatibilità completo, dal modello alla memoria disponibile, senza avviare nulla.
I numeri, dichiarati onestamente
Il README dedica una sezione intera ai numeri reali, misurati su una macchina di sviluppo modesta, con 12 core, 25 GB di RAM e un NVMe. Riassumiamo i valori principali in tabella.
| Metrica | Valore misurato |
|---|---|
| Modello su disco (int4) | ~370 GB |
| RAM residente | 9,9 GB |
| Tempo di caricamento | ~30 secondi |
| Picco RAM in chat | ~20 GB (auto-limitato) |
| Letture disco a cache fredda | ~11 GB per token |
| Velocità a cache fredda | 0,05-0,1 token/s |
| Speculazione MTP (testa int8) | 2,2-2,8 token per passaggio |
Il progetto non gira intorno alla questione, e lo scrive nero su bianco, ovvero che non è veloce. A cache fredda si parla di un token ogni dieci-venti secondi, un ritmo da telegrafo. Con la cache calda, gli esperti “caldi” fissati in RAM e la speculazione MTP attiva, la latenza delle risposte utili scende parecchio, ma resta un’esperienza che richiede pazienza, adatta a domande secche più che a lunghe conversazioni.
Il quadro però cambia con hardware migliore. In un esperimento documentato nel repository, su una macchina con 6 RTX 5090 e l’intero set di esperti distribuito tra VRAM e RAM, il motore raggiunge 6,84 token al secondo in decodifica singola. Non sono numeri da datacenter, ma per un modello di questa stazza su hardware da appassionati è un risultato notevole.
Una nota rassicurante riguarda l’SSD. Lo streaming di Colibrì è in sola lettura, e le letture non consumano le celle di memoria come fanno le scritture. I veri punti di attenzione sono lo swap, da evitare con un budget RAM sensato (il motore lo calcola da solo), e le temperature dell’unità durante sessioni lunghe, che conviene tenere d’occhio sui drive più economici.
La dashboard web e il cervello in diretta
Oltre alla chat da terminale, il comando ./coli web avvia una dashboard nel browser che è uno dei tratti più riusciti del progetto. La schermata principale mostra le metriche in tempo reale, tra cui token al secondo, occupazione di RAM e VRAM e la distribuzione degli esperti tra i tre livelli di memoria, con un pannello hardware che fotografa lo stato della macchina.
La pagina più affascinante si chiama Brain: visualizza tutti i 19.456 esperti del modello come una specie di corteccia viva, dove il colore indica il livello di memoria in cui risiede ciascun esperto (VRAM, RAM o disco) e la luminosità riflette quanto viene interpellato dal router. Ogni volta che un esperto partecipa a una risposta, il suo puntino lampeggia in bianco.
L’effetto è anche didattico, perché guardando la pagina Brain mentre il modello risponde si vede letteralmente quali zone del “cervello” si accendono a seconda dell’argomento. Passando il mouse su un esperto compare persino la sua affinità tematica misurata, frutto di un’analisi documentata in una delle issue del progetto. Per chi ha sempre trovato i modelli linguistici delle scatole nere, è un modo insolitamente chiaro di vederli lavorare.
Non manca la persistenza delle conversazioni, gestita in modo intelligente. Il motore salva su disco la memoria interna della chat (la cosiddetta KV-cache) dopo ogni scambio, così alla riapertura la conversazione riparte già calda, senza dover rielaborare tutto lo storico.
Un laboratorio affascinante per smanettoni
Colibrì per ora non sostituirà i servizi cloud. A cache fredda è lento in modo quasi disarmante, richiede 400 GB di spazio su un NVMe veloce e dà il meglio solo dopo qualche scambio, quando cache e speculazione entrano a regime. Chi cerca un assistente reattivo per il lavoro di tutti i giorni farà meglio a guardare altrove, magari verso modelli più piccoli che stanno comodamente in RAM.
Il valore del progetto sta altrove. Primo, dimostra nei fatti che la barriera tra hardware consumer e modelli frontier è meno solida di quanto sembri, perché la fisica del disco impone lentezza, non impossibilità. Come recita il README con una punta di orgoglio, è un modello da 744 miliardi di parametri che risponde correttamente su una macchina che costa meno di una singola ventola di un acceleratore da datacenter.
Secondo, è software scritto con una cura d’altri tempi, in puro C, con zero dipendenze, test di fedeltà contro l’implementazione di riferimento e una documentazione che dichiara i limiti con la stessa precisione dei pregi. Se hai un SSD capiente, una domenica libera e la curiosità di vedere un gigante camminare nel tuo studio, Colibrì merita il download. Anche solo per guardare la pagina Brain accendersi.
