Kolibri-1 in self-hosting: requisiti e costi
Kolibri-1 è Apache 2.0: FP8 richiede circa 78 GB di VRAM, mentre Q4_K_M può usare la RAM. Requisiti, costi e quando basta un modello più piccolo.
Self-hosting di Kolibri-1: la risposta breve
È possibile eseguire l'hosting autonomo di Kolibri-1 con i pesi ufficiali FP8, ma non su un normale VPS. Aleph Alpha di Heidelberg rilascia il modello sotto licenza Apache 2.0. I pesi in formato FP8 occupano circa 78 GB. La Model Card descrive due metodi ufficiali: vLLM e, dal 20 ottobre 2026, Transformers a partire dalla versione 5.20. Come requisito minimo vengono indicate una H200, una B200 o B300, oppure due schede grafiche con 80 GB di memoria ciascuna. La card non menziona percorsi ufficiali per CPU, GGUF, llama.cpp o Ollama. Dalla release b11709 del 17 ottobre 2026, la versione standard di llama.cpp supporta l'architettura kolibri1; non è più necessaria alcuna patch dell'architettura. Per i file GGUF provenienti dalla community, la compatibilità dipende tuttavia dalla conversione.
Per molti lettori in Germania, la domanda principale è: i dati rimangono all'interno dell'infrastruttura locale? Con Kolibri-1 è possibile e la licenza non pone ostacoli. L'ostacolo è l'hardware.
Stato delle informazioni: la base dell'installazione con pinning è la Model Card di Aleph-Alpha/Kolibri-1 nella revisione 5bb7075ba22db733e3834b1c71d2245537cc14ed (Hugging Face, 20 ottobre 2026) e il pacchetto aleph-alpha-inference nella versione 1.0.0, verificato il 30 ottobre 2026. I valori predefiniti di memoria di vLLM e la Model Card aggiornata sono stati verificati il 6 novembre 2026. Il comando di avvio riportato di seguito mantiene il pinning alla revisione e52eb4627d11516b0c01de49210ab5a4e4061444. I commit successivi hanno modificato solo README, config.json e tokenizer_config.json, non i pesi. Le revisioni successive potrebbero indicare valori differenti. Verificali prima di noleggiare o acquistare hardware.
Cosa stabilisce la Model Card su Kolibri-1
- Architettura: MoE (Mixture of Experts). Il modello è composto da molte sottoreti, gli esperti. Per ogni token ne vengono utilizzati solo pochi.
- Dimensioni: 78 miliardi di parametri totali, di cui 3,46 miliardi attivi per token. 50 strati con 384 esperti instradati ciascuno e un esperto condiviso, per un totale di 385 per strato. Per ogni token vengono selezionati 6 esperti instradati; l'esperto condiviso viene utilizzato in aggiunta.
- Contesto: 262.144 token nella configurazione del modello. La card attuale indica 1.048.576 token di contesto e raccomanda un massimo di 262.144 token per un serving efficiente e per compiti complessi.
- Pesi: FP8 (numeri in virgola mobile a 8 bit) nel formato
float8_e4m3fn, in blocchi da 128×128. Embedding e LM-Head sono in bfloat16. Complessivamente, secondo la card, si tratta di circa 78 GB. Il repository stesso ha una dimensione di 78,9 GB. - Dati di addestramento: 62,5% inglese, 23,9% tedesco e 13,6% codice, con 20 trilioni di token di pre-addestramento. È incluso un tokenizer che, secondo la card, è ottimizzato per la struttura delle parole tedesche.
- Licenza: Apache 2.0. Il repository non è protetto (non gated). Non è quindi necessaria alcuna richiesta di accesso.
Il punto più importante si trova nelle prime due righe. 3,46 miliardi di parametri attivi significano un carico di calcolo ridotto per token. Il fabbisogno di memoria, tuttavia, dipende da tutti i 78 miliardi di parametri. Il router seleziona esperti diversi per ogni token. Durante l'esecuzione su GPU qui descritta, tutti gli esperti risiedono nella memoria video; llama.cpp supporta anche lo scaricamento degli esperti nella RAM. Un modello MoE calcola quindi come un modello piccolo, ma occupa memoria come un modello grande.
Anche il tokenizer ha un effetto pratico. Un tokenizer scompone il testo in token. Se non è adatto alla lingua, una parola tedesca lunga viene suddivisa in molti piccoli pezzi. Ciò consuma contesto e tempo di calcolo. Un tokenizer ottimizzato per il tedesco richiede meno token per lo stesso testo.
I dati di benchmark della Card
Aleph Alpha indica due valori complessivi per il modello post-addestrato. Si tratta di cifre derivanti dalla valutazione interna del produttore, non da un test indipendente.
I dati alla base di questo grafico
[
{
"label": "Deutsch (Overall DE)",
"overall": 70.8
},
{
"label": "Englisch (Overall EN)",
"overall": 75.5
}
]In tedesco, Kolibri-1 raggiunge secondo la card 70.8 punti, in inglese 75.5. Anche questo modello risulta quindi leggermente più forte in inglese. Solo un test con i propri documenti potrà stabilire se sia sufficiente per i propri compiti.
Cosa è cambiato rispetto a Pharia
La precedente serie di modelli di Aleph Alpha si chiamava Pharia. La card di Pharia-1-LLM-7B-control menzionava la Open Aleph License. Questa consentiva la ricerca e l'insegnamento non commerciali. Per l'uso commerciale era necessario contattare direttamente Aleph Alpha. Kolibri-1, al contrario, è distribuito sotto licenza Apache 2.0. È quindi possibile utilizzare il modello in azienda e ridistribuirlo anche se modificato, a condizione di includere il testo della licenza e le note informative.
Quale GPU richiede Kolibri-1?
La scheda tecnica indica due livelli. Minimo: 2× A100 80 GB, 2× H100 SXM5, 1× H200, 1× B200 oppure 1× B300. Consigliato: 2× H100 SXM5, 2× H200, 1× B200 oppure 1× B300.
Perché una singola H100 non è sufficiente? Il calcolo è semplice. Sottrai i pesi dalla memoria video, ovvero la VRAM (video random access memory). Ciò che rimane è necessario a vLLM principalmente per il KV-Cache. Il KV-Cache memorizza le chiavi e i valori (keys e values) degli strati di attenzione per ogni token nel contesto. Senza di esso, il modello non può mantenere il contesto.
I dati alla base di questo grafico
[
{
"config": "1\u00d7 H100 80 GB",
"vram_gb": 80,
"gewichte_gb": 79,
"rest_gb": 1
},
{
"config": "1\u00d7 H200",
"vram_gb": 141,
"gewichte_gb": 79,
"rest_gb": 62
},
{
"config": "2\u00d7 A100 80 GB",
"vram_gb": 160,
"gewichte_gb": 79,
"rest_gb": 81
},
{
"config": "2\u00d7 H100 SXM5",
"vram_gb": 160,
"gewichte_gb": 79,
"rest_gb": 81
},
{
"config": "2\u00d7 H200",
"vram_gb": 282,
"gewichte_gb": 79,
"rest_gb": 203
}
]Una H100 dispone di 80 GB, i pesi occupano 79 GB. Matematicamente rimangono 1 GB. Questo non è sufficiente per un contesto utile. Una H200 lascia liberi 62 GB, due H200 lasciano liberi 203 GB. La riserva reale è inferiore. La versione di vLLM 0.29 qui fissata utilizza per impostazione predefinita il 92% della memoria video (--gpu-memory-utilization, valore predefinito 0.92) e anche le attivazioni richiedono spazio. Nella documentazione attuale, in assenza di un valore esplicito, si applica invece 1.0 con il KV-Cache espandibile, dimensionato in base alla memoria libera misurata, e 0.92 in caso contrario. I valori sono stime arrotondate, non misurazioni.
Due caratteristiche dell'architettura alleggeriscono il KV-Cache. Primo, secondo la scheda, Kolibri-1 combina strati con Sliding-Window-Attention e strati con attenzione completa in un rapporto di 4:1. Uno strato Sliding-Window memorizza solo i token di una finestra fissa. Pertanto, il suo cache non cresce con l'intera lunghezza del contesto. Secondo, la scheda consiglia --kv-cache-dtype fp8. In questo modo, ogni voce del cache occupa la metà della memoria rispetto ai 16 bit. Gli strati con attenzione completa crescono comunque con ogni token. Con 262.144 token, lo spazio su una singola H200 diventa limitato.
Quando un VPS normale può eseguire Kolibri-1
Nella Card, Aleph Alpha descrive soltanto vLLM e Transformers, entrambi destinati a GPU con una quantità sufficiente di memoria video. La Card non menziona l'esecuzione su CPU né GGUF, llama.cpp o Ollama. Un normale VPS con CPU non dispone di memoria video. Manca quindi il presupposto per questi metodi. Con un file GGUF adatto e llama.cpp, invece, l'esecuzione su CPU è possibile se la RAM è sufficiente. Hob-forge documenta test riusciti su CPU e 46,6 GB di RAM per i pesi Q4_K_M caricati senza mmap. Serve inoltre memoria per il contesto e per il sistema operativo. Non è necessaria una GPU.
Su Hugging Face sono comunque disponibili conversioni GGUF realizzate dalla community. A seconda del repository, il file Q4_K_M ha dimensioni comprese tra circa 47,5 e 49,8 GB e, in teoria, entrerebbe in un server con 64 GB di RAM. Dal 17 ottobre 2026 anche llama.cpp standard riconosce l'architettura kolibri1: la Pull Request #30673 è stata integrata ed è inclusa nella release b11709 e successive. Tuttavia, le GGUF più vecchie non vengono caricate automaticamente. Il 25 ottobre 2026 Hob-forge richiede ancora una versione patchata di llama.cpp al commit 836d571. Un contributo nella discussione di Hugging Face su Kolibri-1 segnala che soltanto 7 dei 40 quantizzati verificati vengono caricati senza modifiche dal normale llama.cpp. Per alcuni sono sufficienti due opzioni --override-kv; altri devono essere riconvertiti con il convert_hf_to_gguf.py del normale llama.cpp. Le GGUF di bartowski sono state compilate con llama.cpp b11716 e richiedono b11716 o una versione successiva. Controlla quindi nel repository pertinente quale versione è richiesta. Alcuni autori hanno effettivamente testato contesti lunghi. Hob-forge recupera tre fatti nascosti fino a 253.646 token, in un'esecuzione con -c 262144. Si tratta di test di recupero, non di benchmark. Hob-forge specifica che manca un confronto prestazionale con l'originale FP8. Questo non costituisce una base adeguata per i dati aziendali. È un esperimento.
La guida su quanta RAM può richiedere un LLM in base alla quantizzazione calcola passo per passo la memoria necessaria per un modello con ciascun livello di quantizzazione. Il confronto tra Ollama e vLLM spiega perché in questo caso vLLM è lo strumento adatto: vLLM è progettato per gestire molte richieste parallele su GPU, mentre Ollama è pensato per avviare facilmente modelli quantizzati.
Installazione di Kolibri-1 con vLLM
È necessario un server Linux con una GPU NVIDIA adeguata e i relativi driver installati. Per i requisiti da verificare durante il noleggio, consultare la panoramica sui VPS con GPU. Per prima cosa, verificare le specifiche effettive della macchina:
nvidia-smi --query-gpu=name,memory.total --format=csvL'output indica il nome e la memoria in MiB per ogni scheda. Se il comando non restituisce alcun driver, il driver NVIDIA non è installato. In tal caso, anche vLLM non rileverà alcuna GPU.
Creare quindi un ambiente Python dedicato. Il pacchetto scaricherà vLLM e PyTorch rispettando intervalli di versione specifici. L'uso di un ambiente separato evita conflitti con altri programmi presenti sul server.
sudo apt update && sudo apt install -y python3-venv
python3 -m venv ~/kolibri
source ~/kolibri/bin/activate
pip install 'aleph-alpha-inference==1.0.0'
pip show vllm aleph-alpha-inferenceLa card specifica pip install 'aleph-alpha-inference>=1' per vLLM inferiore alla 0.33.0. Qui la versione è fissata alla 1.0.0. In questo modo, una versione successiva non modificherà inavvertitamente la configurazione. La versione 1.0.0 richiede Python 3.10 o superiore e vLLM dalla 0.29.0, ma inferiore alla 0.30.0. pip show dovrebbe quindi mostrare una versione di vLLM 0.29.x. Il pacchetto è un plugin per vLLM. Esso registra i parser kolibri1 per il ragionamento e le chiamate a strumenti. Senza il plugin, la versione 0.29 di vLLM qui bloccata non riconosce tali nomi.
La card, aggiornata il 6 novembre 2026, descrive inoltre il supporto nativo a partire da vLLM 0.33.0 tramite il suo backend Transformers. Questo metodo utilizza i parser hf e il template di risposta nel checkpoint corrente. L'installazione bloccata di seguito continua a utilizzare il plugin e i parser kolibri1.
Aleph Alpha offre anche un'immagine container: ghcr.io/aleph-alpha/aleph-alpha-inference. Chi gestisce server GPU tramite container può utilizzare questa opzione.
Dal 20 ottobre 2026, la card indica anche Transformers come metodo: pip install "transformers[kernels,torch]>=5.20", con esempi per pipeline e AutoModelForCausalLM. Questa soluzione è adatta per script ed esperimenti in Python. Per un'API compatibile con OpenAI che gestisca molte richieste parallele, vLLM rimane il metodo consigliato in questa guida.
Disattivare la telemetria di vLLM
Per impostazione predefinita, vLLM invia statistiche di utilizzo anonime. Se l'obiettivo è impedire qualsiasi comunicazione in uscita dal server, disattivare questa funzione prima dell'avvio:
export VLLM_NO_USAGE_STATS=1
export DO_NOT_TRACK=1Avviare il server
Il comando segue le indicazioni della card, con due aggiunte: una revisione fissa e il binding su localhost.
vllm serve Aleph-Alpha/Kolibri-1 \
--revision e52eb4627d11516b0c01de49210ab5a4e4061444 \
--host 127.0.0.1 --port 8000 \
--kv-cache-dtype fp8 \
--reasoning-parser kolibri1 \
--tool-call-parser kolibri1 \
--enable-auto-tool-choice--revision definisce quale versione dei pesi caricare. Senza questa opzione, vLLM carica la versione corrente da main. Se Aleph Alpha modifica il repository, il modello cambierà al download successivo. --host 127.0.0.1 rende l'API accessibile solo localmente. Anche l'apertura della porta 8000 nel firewall non modificherà tale comportamento. Per l'accesso diretto da altri computer, sostituire --host 127.0.0.1 con --host 0.0.0.0; in tal caso, anche il firewall dovrà consentire l'accesso.
In presenza di due GPU, aggiungere --tensor-parallel-size 2. Questa opzione distribuisce ogni strato su entrambe le schede. Senza di essa, vLLM utilizza una sola GPU e i pesi non entrerebbero in una singola scheda da 80 GB.
Al primo avvio, vLLM scarica circa 79 GB da Hugging Face in ~/.cache/huggingface. Pianificare spazio su disco sufficiente per questa operazione e per l'ambiente Python. Dopo il primo download completato, è possibile impedire ogni ulteriore contatto con Hugging Face tramite export HF_HUB_OFFLINE=1. I pesi verranno quindi caricati esclusivamente dalla cache locale.
Se la memoria non è sufficiente per il contesto completo di 262.144 token, vLLM non si avvia. Il messaggio di errore indicherà che il KV-cache è troppo piccolo per la lunghezza massima della sequenza. In tal caso, impostare un limite inferiore, ad esempio --max-model-len 65536. La card avvia il contesto esteso fino a 1.048.576 token con --max-model-len 1048576 e --hf-overrides '{"max_position_embeddings": 1048576}'. Questa operazione richiede molta più memoria e va eseguita sulle configurazioni raccomandate.
Verificare la risposta del modello
Non appena il log indica che il server è in esecuzione sulla porta 8000, testare l'API compatibile con OpenAI:
curl http://127.0.0.1:8000/v1/models
curl http://127.0.0.1:8000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{"model": "Aleph-Alpha/Kolibri-1", "messages": [{"role": "user", "content": "Was ist die Hauptstadt von Frankreich?"}], "chat_template_kwargs": {"enable_thinking": false}}'La prima chiamata dovrebbe elencare Aleph-Alpha/Kolibri-1 come modello. La seconda dovrebbe restituire un JSON in cui choices[0].message.content indica Parigi. enable_thinking: false disattiva la modalità di ragionamento per questa richiesta. Per impostazione predefinita, è attiva. Secondo la card, anche reasoning_effort con il valore none ha effetto. Per il campionamento, la card consiglia temperature=1.0, top_p=0.97 e top_k=128.
Per l'accesso dal proprio computer non è necessaria una porta aperta. È sufficiente un tunnel SSH:
ssh -L 8000:127.0.0.1:8000 user@dein-serverSuccessivamente, l'API sarà raggiungibile sul proprio computer all'indirizzo http://127.0.0.1:8000. Se altri servizi nella rete devono accedere, impostare anche --api-key e anteporre un reverse proxy con TLS (transport layer security). Se il reverse proxy viene eseguito sullo stesso server, vLLM rimane vincolato a 127.0.0.1; gli altri servizi si connetteranno al proxy.
Quanto costa un’ora di Kolibri-1 in euro?
I prezzi del noleggio GPU variano molto in base al provider e alla regione. Il calcolo seguente usa due ipotesi scelte a titolo esemplificativo: 3,50 euro all’ora per una H200 e 2,50 euro all’ora per una H100 SXM5, in entrambi i casi senza IVA. Sono esempi di calcolo, non prezzi verificati presso i provider. Inserisci le tue offerte. Il metodo di calcolo resta invariato.
I dati alla base di questo grafico
[
{
"plan": "1\u00d7 H200, rund um die Uhr",
"eur_pro_stunde": 3.5,
"stunden_pro_monat": 730,
"eur_pro_monat": 2555
},
{
"plan": "2\u00d7 H100 SXM5, rund um die Uhr",
"eur_pro_stunde": 5,
"stunden_pro_monat": 730,
"eur_pro_monat": 3650
},
{
"plan": "1\u00d7 H200, nur B\u00fcrozeit",
"eur_pro_stunde": 3.5,
"stunden_pro_monat": 176,
"eur_pro_monat": 616
}
]Un mese ha in media 730 ore. Se una H200 è in esecuzione 24 ore su 24, il costo è di 2555 euro al mese. La variante consigliata con due H100 costa 3650 euro. Se fai funzionare la macchina soltanto durante l’orario di lavoro, cioè 8 ore per 22 giorni lavorativi, per un totale di 176 ore, il costo è di 616 euro. In questo caso, però, a ogni avvio i pesi devono essere ricaricati nella memoria della GPU.
Quando conviene rispetto ai token API?
Kolibri-1 è ormai disponibile anche tramite un’API ospitata: Aleph Alpha pubblicizza l’accesso API e Munito documenta il modello aleph-alpha/kolibri-1. Puoi quindi confrontare lo stesso modello eseguito su una GPU propria con il modello utilizzato tramite API. Per il calcolo assumiamo due prezzi per milione di token, considerando insieme input e output: 0,50 euro per un modello economico e 2 euro per un modello più costoso.
I dati alla base di questo grafico
[
{
"plan": "1\u00d7 H200, rund um die Uhr",
"mio_token_bei_0_50_eur": 5110,
"mio_token_bei_2_eur": 1277.5,
"token_pro_sekunde_bei_0_50_eur": 1944
},
{
"plan": "2\u00d7 H100 SXM5, rund um die Uhr",
"mio_token_bei_0_50_eur": 7300,
"mio_token_bei_2_eur": 1825,
"token_pro_sekunde_bei_0_50_eur": 2778
},
{
"plan": "1\u00d7 H200, nur B\u00fcrozeit",
"mio_token_bei_0_50_eur": 1232,
"mio_token_bei_2_eur": 308,
"token_pro_sekunde_bei_0_50_eur": 1944
}
]Con un costo di 0,50 euro per milione di token, una H200 in esecuzione continua copre i propri costi soltanto a partire da 5110 milioni di token al mese. Si tratta in media di 1944 token al secondo, giorno e notte senza interruzioni. Con un costo di 2 euro per milione di token, la soglia della variante utilizzata durante l’orario di lavoro scende a 308 milioni di token. Devi misurare se una singola scheda riesce a raggiungere questo throughput con la tua combinazione di lunghezza del prompt e lunghezza della risposta. Il calcolo indica soltanto a partire da quale volume il confronto diventa rilevante.
Il metodo completo, che considera utilizzo e inattività, è descritto in nel calcolo del punto di pareggio tra server GPU e token API. Per Kolibri-1 c’è un ulteriore aspetto che nessuna tabella può rappresentare. Chi vuole eseguire Kolibri-1 in autonomia per motivi legati ai dati spesso non lo confronta affatto con un’API. Se i documenti non possono lasciare l’organizzazione, l’API non è un’opzione. La domanda reale diventa quindi: noleggiare una GPU in un data center dell’UE con un accordo di nomina a responsabile del trattamento (AVV) oppure acquistare hardware di proprietà. Anche una GPU noleggiata si trova presso un soggetto terzo.
Quando un modello locale più piccolo è la scelta corretta
Kolibri-1 è utile se ti servono i suoi punti di forza. Secondo la model card, tra questi rientrano le chiamate agli strumenti e l'elaborazione di documenti con contesto esteso. 262.144 token possono contenere un'intera cartella di contratti in un'unica richiesta. Se le tue attività sono più brevi, il calcolo cambia.
Per ordinare le e-mail o creare brevi riepiloghi, spesso è sufficiente un modello con 7-14 miliardi di parametri. Quantizzato a 4 bit, può essere eseguito con Ollama su un VPS con CPU e 16-32 GB di RAM. La procedura è descritta in questa guida per eseguire autonomamente Ollama su un VPS. Il costo corrisponde quindi al normale prezzo mensile di un server, non a una tariffa oraria per GPU.
Il modello più piccolo della stessa organizzazione sarebbe Pharia-1-LLM-7B-control. Tuttavia, secondo il testo della licenza, la sua licenza, Open Aleph License, consente soltanto utilizzi non commerciali e non amministrativi. Per l'impiego in azienda non è quindi una soluzione.
Puoi prendere una decisione corretta soltanto con un test. Seleziona 50 attività reali del tuo lavoro quotidiano. Fai risolverle a Kolibri-1 su una GPU noleggiata a ore e a un modello più piccolo sul VPS con CPU. Confronta quindi le risposte. Alcune ore di noleggio per il test costano poco rispetto all'acquisto di hardware inadatto.
Questa guida mostra cosa serve per eseguire autonomamente Kimi K3 e permette di vedere come si comporta la stessa domanda con un altro modello open. Il confronto aiuta a valutare le dimensioni: con circa 78 GB di pesi, Kolibri-1 appartiene ai modelli che possono ancora essere eseguiti su una singola scheda.
FAQ
Posso utilizzare Kolibri-1 per scopi commerciali?
Sì. Secondo la Model Card, Kolibri-1 è rilasciato sotto licenza Apache 2.0. È possibile utilizzarlo in ambito aziendale e ridistribuirlo anche in forma modificata, a condizione di includere il testo della licenza e le note informative. Questo differenzia Kolibri-1 dalla precedente serie Pharia: la Card di Pharia-1-LLM-7B-control cita la Open Aleph License, che secondo il testo della licenza consente esclusivamente scopi non commerciali e non amministrativi.
Kolibri-1 funziona con Ollama o su CPU?
Nella Card, Aleph Alpha descrive solo vLLM e Transformers a partire dalla versione 5.20, entrambi su GPU; il plugin aleph-alpha-inference è previsto per vLLM versione 0.33.0. Il funzionamento su CPU con file GGUF compatibili è possibile tramite llama.cpp; da ciò non deriva un supporto ufficiale per Ollama. Hob-forge documenta test CPU riusciti e un consumo di 46,6 GB di RAM per i pesi Q4_K_M caricati senza mmap, oltre al contesto e al sistema operativo. Esistono file GGUF in diversi repository della community, con dimensioni variabili tra 47,5 e 49,8 GB in formato Q4_K_M. Il llama.cpp standard supporta l'architettura kolibri1 a partire dalla release b11709 del 17 ottobre 2026. Molti file GGUF meno recenti richiedono comunque il llama.cpp patchato, due opzioni --override-kv o una nuova conversione. Verifica nel rispettivo repository quale versione è richiesta. Hob-forge segnala test di recupero superati con un massimo di 253.646 token. Tuttavia, secondo quanto dichiarato, non esiste un confronto di benchmark con l'originale FP8.
Una singola H100 da 80 GB è sufficiente per Kolibri-1?
Per l'esecuzione tramite vLLM qui descritta, con i pesi FP8 caricati interamente nella VRAM, non è sufficiente. I pesi FP8 occupano già circa 78 GB. Per il KV-cache, che gestisce il contesto, non rimane praticamente spazio. La Card indica come requisito minimo, tra le altre configurazioni, due H100 SXM5 o una H200. Con due schede, vLLM si avvia utilizzando --tensor-parallel-size 2.
Come disattivo la modalità di riflessione (thinking mode) di Kolibri-1?
La modalità di riflessione è attiva per impostazione predefinita. Per ogni richiesta, è possibile disattivarla inserendo "chat_template_kwargs": {"enable_thinking": false} nel corpo JSON. Secondo la Card, è efficace anche reasoning_effort con il valore none. Quando la modalità è attiva, --reasoning-parser kolibri1 separa il testo di riflessione dalla risposta effettiva.