Come eseguire Bonsai 27B in locale con 8 GB di memoria

Nota: Bonsai 2 27B è ora disponibile, basato su Qwen3.8 27B

Qwen3.6-27B è diventato una scelta popolare per eseguire in locale un modello capace di ragionamento e coding. È veloce e potente, ma un modello completo da 27 miliardi di parametri richiede comunque una quantità significativa di memoria. 

L’uso della quantizzazione tradizionale può ridurre tali requisiti, ma può anche causare un degrado delle prestazioni percepibile.

Fonte: prism-ml/Bonsai-27B-gguf

Prism ML ha affrontato questo problema in modo diverso con Bonsai 27B, una versione a 1 bit altamente compressa di Qwen3.6-27B. 

Secondo Prism ML, Bonsai conserva quasi il 90% delle prestazioni nei benchmark del modello originale, riducendo i pesi a circa 3,9 GB. 

Questo rende possibile sperimentare un modello di ragionamento di classe 27B su hardware consumer molto più accessibile.

In questo tutorial userò il modello a 1 bit Bonsai-27B-Q1_0.gguf e lo script di setup personalizzato di Prism ML. Lo script scarica automaticamente il modello, seleziona un runtime precompilato compatibile e lo configura per l’hardware disponibile. 

Poi testerò Bonsai dalla riga di comando, avvierò la sua interfaccia web locale, lo accederò tramite un’API compatibile con OpenAI e lo collegherò all’agente di coding Pi.

Cosa rende speciale Bonsai 27B?

Ciò che rende Bonsai 27B interessante è che non è semplicemente un altro modello Qwen quantizzato in modo convenzionale. 

La maggior parte dei modelli GGUF locali viene compressa dopo l’addestramento riducendo la precisione numerica di un modello esistente. 

Bonsai adotta un approccio più aggressivo adattando il modello attorno a pesi binari, consentendo a gran parte della rete di operare con valori prossimi a −1 o +1.

Questo è importante perché l’esecuzione di grandi modelli linguistici è spesso limitata da capacità e banda della memoria, più che dalla sola potenza di calcolo. 

Ridurre la precisione dei pesi diminuisce la quantità di dati da memorizzare e spostare durante l’inferenza. 

Con un runtime ottimizzato, questo può rendere pratico un grande modello da 27B su hardware consumer che normalmente faticherebbe a caricarlo o eseguirlo.

Fonte: prism-ml/Bonsai-27B-gguf · Hugging Face 

Bonsai preserva anche le capacità necessarie per andare oltre la semplice chat. 

Supporta ragionamento, coding, chiamate a strumenti strutturate, prompt con contesto lungo e workflow agentici.

Può anche funzionare dietro un’API compatibile con OpenAI, rendendo più semplice la connessione con agenti di coding, sistemi di retrieval, strumenti di automazione e applicazioni che già supportano endpoint in stile OpenAI.

Tuttavia, non bisogna considerare Bonsai identico al modello Qwen3.6-27B a piena precisione. 

La compressione estrema comporta comunque compromessi e può influenzare in modo diverso, a seconda dei task, l’aderenza alle istruzioni, la selezione degli strumenti, la coerenza del ragionamento e la qualità dell’output. 

Il suo principale vantaggio è l’equilibrio che offre: capacità da large model con requisiti hardware sostanzialmente inferiori.

Prerequisiti per eseguire Bonsai 27B in locale

Prima di iniziare, assicurati che il tuo sistema abbia:

• Almeno 8 GB di RAM di sistema, anche se sono consigliati 16 GB o più
• Circa 8 GB di spazio di archiviazione libero per il modello, il runtime e i file di supporto
• Git per clonare il repository demo di Bonsai
• Un sistema operativo supportato, come Linux, Windows o macOS
• Una GPU NVIDIA, AMD, compatibile con Vulkan o Apple Silicon per un’inferenza più veloce

Una GPU dedicata è opzionale perché Bonsai può anche essere eseguito tramite CPU. 

Tuttavia, l’inferenza su CPU sarà in genere più lenta, soprattutto quando il modello genera risposte di ragionamento lunghe.

Per questa guida utilizzo una NVIDIA RTX 5070 Ti con 16 GB di VRAM. 

Questo offre memoria sufficiente per caricare interamente sulla GPU i pesi del modello da circa 3,9 GB e lascia memoria aggiuntiva per la KV cache, le attivazioni del modello e l’overhead del runtime.

Tuttavia, la VRAM disponibile determina anche quanto contesto puoi usare. 

Anche se Bonsai 27B supporta conversazioni superiori a 256.000 token, caricare il suo contesto di addestramento completo può consumare molta memoria aggiuntiva ed esaurire i sistemi con RAM o VRAM limitate. 

Per questo, Prism ML usa una dimensione di contesto predefinita in base alla memoria invece di allocare automaticamente l’intera finestra da 262.000 token.

In questo tutorial, useremo inizialmente una finestra di contesto da 8.192 token per i test da riga di comando. Poi la aumenteremo all’avvio del server, in base alla memoria disponibile. 

Una finestra di contesto più piccola è sufficiente per la maggior parte dei task di coding e chat e garantisce un avvio più rapido con un minore uso di memoria.

Passo 1: Scarica e installa Bonsai 27B

Apri un terminale e clona il repository demo ufficiale di Bonsai:

git clone https://github.com/PrismML-Eng/Bonsai-demo.git
cd Bonsai-demoOfferto da

Il repository include script per scaricare il modello, rilevare il tuo hardware, selezionare il runtime corretto precompilato, eseguire il modello dal terminale e avviare un server locale.

Esegui il seguente comando di setup:

BONSAI_FAMILY=bonsai \
BONSAI_MODEL=27B \
BONSAI_OPENWEBUI=0 \
BONSAI_CODE_INTERPRETER=0 \
./setup.shOfferto da

Durante il setup, potrebbe esserti chiesto di inserire un token di accesso a Hugging Face. 

È opzionale per i file pubblici del modello, quindi puoi saltarlo premendo Invio. 

Tuttavia, usare un token può aiutare a evitare i limiti di download anonimi.

Lo script scarica circa 7,15 GB di file, tra cui:

• Il modello linguistico Bonsai-27B-Q1_0.gguf
• Il proiettore multimodale (mmproj)
• Ulteriori file correlati a D-Spark
• Un runtime precompilato testato per il tuo hardware

Impostare BONSAI_FAMILY=bonsai seleziona il modello Bonsai compatto a 1 bit invece della versione ternaria più grande.

Le seguenti opzioni disabilitano due ambienti aggiuntivi:

BONSAI_OPENWEBUI=0
BONSAI_CODE_INTERPRETER=0Offerto da

Open WebUI non è richiesto per questo tutorial perché il server incluso fornisce già una semplice interfaccia di chat via browser.

 L’ambiente code-interpreter non è necessario per la configurazione locale di base.

Durante l’installazione, lo script di setup esegue automaticamente:

• Installazione dei pacchetti Linux richiesti
• Creazione di un ambiente virtuale Python
• Download dei file del modello Bonsai 27B
• Download del runtime precompilato appropriato
• Rilevamento del backend CPU o GPU disponibile
• Configurazione del progetto per il tuo hardware

Questo setup automatico è particolarmente utile perché non devi compilare manualmente llama.cpp o scegliere tu stesso un binario CUDA, ROCm, Vulkan, Metal o CPU.

Consiglio il tutorial su llama.cpp se ti serve un ripasso veloce. 

Passo 2: Testa Bonsai 27B dalla CLI

Dopo l’installazione, testa il modello direttamente dal terminale usando l’interfaccia a riga di comando di llama.cpp inclusa:

BONSAI_FAMILY=bonsai \
BONSAI_MODEL=27B \
BONSAI_CTX=8192 \
./scripts/run_llama.sh \
-p "Create a simple Python function that calculates compound interest."Offerto da

Questo comando:

• Seleziona la famiglia di modelli Bonsai a 1 bit
• Carica il modello 27B
• Imposta la finestra di contesto a 8.192 token
• Avvia il terminale interattivo di llama.cpp
• Invia la richiesta sugli interessi composti come primo prompt

Il primo avvio può richiedere qualche istante mentre il modello viene caricato nella memoria di sistema o nella VRAM della GPU. 

Una volta pronto, il terminale mostra il modello attivo, le informazioni di build e i comandi disponibili prima di generare la risposta.

Come mostrato nell’output, Bonsai produce prima il suo processo di ragionamento e poi genera un esempio Python completo, inclusa la funzione, le istruzioni d’uso e il risultato calcolato. 

Dopo la prima risposta, la sessione rimane aperta, consentendoti di inserire ulteriori prompt senza riavviare il modello.

Passo 3: Avvia il server di Bonsai

Per prima cosa, premi Ctrl+C per chiudere la sessione CLI interattiva del passaggio precedente.

Poi avvia il server locale di Bonsai:

BONSAI_FAMILY=bonsai \
BONSAI_MODEL=27B \
BONSAI_CTX=100000 \
./scripts/start_llama_server.sh \
--alias bonsai-27b \
--host 0.0.0.0 \
--port 8910Offerto da

Questo comando:

• Carica il modello Bonsai 27B a 1 bit
• Alloca una finestra di contesto da 100.000 token
• Registra il modello con il nome bonsai-27b
• Avvia il server sulla porta 8910
• Lo rende accessibile dalla macchina locale e da altri dispositivi sulla stessa rete

Una finestra di contesto da 100.000 token richiede molta più memoria rispetto al test CLI precedente da 8.192 token. Riduci BONSAI_CTX se il modello non si avvia o il sistema esaurisce RAM o VRAM.

Poiché --host 0.0.0.0 espone il server alla rete locale, evita di usarlo su reti non affidabili. Per l’accesso solo locale, sostituiscilo con:

--host 127.0.0.1Offerto da

Tieni aperto questo terminale mentre usi il modello. Chiuderlo interromperà il server.

Il server di Bonsai fornisce:

• Una leggera interfaccia web locale
• Un’ API compatibile con OpenAI
• Risposte in streaming
• Chiamate a strumenti strutturate
• Controlli di ragionamento specifici del modello

L’API compatibile con OpenAI è disponibile su:

http://127.0.0.1:8910/v1Offerto da

Passo 4: Testa Bonsai 27B con CURL

Apri un secondo terminale e invia una richiesta all’endpoint chat-completions:

curl http://127.0.0.1:8910/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "bonsai-27b",
    "messages": [
      {
        "role": "user",
        "content": "Write a Python function for loading and validating a CSV file."
      }
    ],
    "max_tokens": 1000
  }'Offerto da

La richiesta usa la stessa struttura dell’API OpenAI Chat Completions:

• model seleziona l’alias di server creato in precedenza
• messages contiene la conversazione
• max_tokens limita il numero di token generati

L’API ha restituito JSON a circa 95 token al secondo, ma la risposta si è fermata al limite di 1.000 token, quindi aumenta "max_tokens" a 3000 per una risposta completa prima di collegare Bonsai ad applicazioni, agenti o programmi Python.

Passo 5: Testa la Web UI di Bonsai 27B

Apri il seguente indirizzo nel browser:

http://127.0.0.1:8910Offerto da

L’interfaccia integrata di llama.cpp ti consente di chattare con Bonsai, caricare file e regolare lo sforzo di ragionamento da Off a Max.

Provalo con un prompt di coding come:

Create a Python command-line application that converts CSV files to JSON.Offerto da

Bonsai ha generato uno script Python completo a circa 92 token al secondo sulla mia RTX 5070 Ti. 

Gli ho anche chiesto di creare un sito portfolio personale. 

Sebbene il codice funzionasse, non ero soddisfatto dell’interfaccia generata, poiché il design sembrava basilare e generico. 

Questo suggerisce che Bonsai è in grado di produrre codice funzionale, ma potrebbe richiedere prompt più dettagliati e diverse revisioni per creare un’interfaccia rifinita.

Passo 6: Installa l’agente di coding Pi

Pi è un agente di coding basato su terminale che usiamo per testare Bonsai 27B in un vero workflow di coding agentico tramite la sua API locale compatibile con OpenAI.

Apri un nuovo terminale e installa il Pi coding agent:

curl -fsSL https://pi.dev/install.sh | shOfferto da

Quando richiesto, premi Invio o digita y per continuare con l’installazione predefinita.

Conferma che Pi sia stato installato correttamente:

pi --versionOfferto da

Al momento del test, la versione installata era:

0.82.0Offerto da

Passo 7: Aggiungi Bonsai 27B a Pi

Assicurati che il server di Bonsai sia ancora in esecuzione, poi avvia un nuovo terminale e crea la directory di configurazione di Pi:

mkdir -p ~/.pi/agentOfferto da

Crea il file di configurazione del modello personalizzato:

nano ~/.pi/agent/models.jsonOfferto da

Incolla la seguente configurazione:

{
  "providers": {
    "bonsai-local": {
      "baseUrl": "http://127.0.0.1:8910/v1",
      "api": "openai-completions",
      "apiKey": "local",
      "compat": {
        "supportsDeveloperRole": false,
        "supportsReasoningEffort": false
      },
      "models": [
        {
          "id": "bonsai-27b",
          "name": "Bonsai 27B Local",
          "reasoning": true,
          "input": ["text"],
          "contextWindow": 100000,
          "maxTokens": 50000,
          "cost": {
            "input": 0,
            "output": 0,
            "cacheRead": 0,
            "cacheWrite": 0
          }
        }
      ]
    }
  }
}Offerto da

Questa configurazione collega Pi all’endpoint locale compatibile con OpenAI, registra il modello come Bonsai 27B Local e allinea l’impostazione di contesto a 100.000 token del server.

Salva e chiudi il file:

Ctrl + O
Enter
Ctrl + XOfferto da

Pi carica automaticamente i provider di modelli personalizzati da ~/.pi/agent/models.json.

Passo 8: Esegui Pi con Bonsai 27B

Assicurati che il server di Bonsai sia ancora in esecuzione, poi crea una nuova directory di progetto:

mkdir simple-python
cd simple-pythonOfferto da

Avvia Pi usando il modello locale di Bonsai:

pi --provider bonsai-local --model bonsai-27bOfferto da

Inserisci un prompt come:

Build a simple Python application with a FastAPI backend and a modern, 
responsive web interface that accepts user input, processes it, 
and displays the result.Offerto da

Pi ha iniziato a ragionare, ha creato i file del progetto, installato i pacchetti richiesti e prodotto un’applicazione di analisi del testo con backend FastAPI e frontend responsivo.

Mentre il modello era in esecuzione con una finestra di contesto da 100.000 token, nvidia-smi mostrava circa 11,9 GB di utilizzo della VRAM sulla mia RTX 5070 Ti:

Al termine dell’esecuzione, Pi ha confermato che il task era completato e ha prodotto un riepilogo chiaro di tutto ciò che aveva fatto. 

Questo includeva i file creati, le funzionalità principali dell’applicazione, i test effettuati e i comandi esatti necessari per eseguire il progetto in locale. 

Dopo la generazione, Pi ha riepilogato i file e le funzionalità create. 

Ho testato il backend usando:

curl -s -X POST http://localhost:10100/analyze \
  -H "Content-Type: application/json" \
  -d '{"text":"Hello world! This is a test."}'Offerto da

L’API ha funzionato e l’interfaccia era migliore rispetto al sito generato in precedenza tramite la web UI di base. 

Tuttavia, l’applicazione era ancora incompleta: mancavano alcuni pulsanti e controlli, e il frontend non mostrava tutte le statistiche disponibili dall’API del backend. 

Questo dimostra che Bonsai può costruire un’applicazione full-stack funzionale, ma il risultato necessita comunque di test e rifinitura.

Considerazioni finali

Nei miei test, Bonsai 27B dà ancora l’impressione di un modello fortemente compresso. 

La qualità dell’output non è proprio al livello di un Qwen3.6-27B quantizzato in Q4, che ho testato in precedenza e ho trovato più affidabile per i workflow con agenti di coding. 

La versione Q4 richiede più memoria, ma offre un ragionamento più solido, una generazione di codice migliore e risultati più coerenti.

Detto questo, Bonsai 27B rimane straordinariamente capace per un modello con un’impronta di circa 3,8 GB.

Capisce le istruzioni, crea file di progetto, esegue comandi, testa il proprio lavoro e può costruire applicazioni funzionali in locale. In questa categoria di dimensioni, è uno dei modelli più capaci che abbia provato.

Per un lavoro con agenti di coding serio, sceglierei comunque la versione Q4 di Qwen3.6-27B, soprattutto perché la mia RTX 3090 ha 24 GB di VRAM e può gestire comodamente il modello più grande. 

Detto ciò, mi è piaciuto molto usare Bonsai 27B e sono rimasto colpito dall’ecosistema più ampio di Prism ML. Il setup automatizzato, il runtime ottimizzato, l’interfaccia web integrata, l’API compatibile con OpenAI e le integrazioni con agenti rendono molto più semplice per più persone eseguire e sperimentare in locale un grande modello di ragionamento su hardware consumer.