Bonsai 27B lokaal draaien met 8 GB geheugen

Let op: Bonsai 2 27B is nu beschikbaar, gebaseerd op Qwen3.8 27B

Qwen3.6-27B is een populaire keuze geworden om lokaal een capabel redeneer- en codeermodel te draaien. Het is snel en krachtig, maar een volledig 27-miljard-parameter model vereist nog steeds een aanzienlijke hoeveelheid geheugen. 

Met conventionele kwantisatie kun je die vereisten verlagen, maar dat kan ook merkbare prestatiedaling veroorzaken.

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

Prism ML heeft dit probleem anders benaderd met Bonsai 27B, een sterk gecomprimeerde 1-bit versie van Qwen3.6-27B. 

Volgens Prism ML behoudt Bonsai bijna 90% van de benchmarkprestaties van het oorspronkelijke model, terwijl de modelgewichten worden teruggebracht tot ongeveer 3,9 GB. 

Daardoor kun je met een 27B-klasse redeneermodel experimenteren op veel toegankelijkere consumentenhardware.

In deze tutorial gebruik ik het 1-bit Bonsai-27B-Q1_0.gguf-model en de aangepaste setupscript van Prism ML. Het script downloadt automatisch het model, kiest een compatibele vooraf gebouwde runtime en configureert die voor de beschikbare hardware. 

Vervolgens test ik Bonsai via de command line, start ik de lokale webinterface, benader ik het via een OpenAI-compatibele API en koppel ik het aan de Pi coding agent.

Wat is er zo bijzonder aan Bonsai 27B?

Wat Bonsai 27B interessant maakt, is dat het niet gewoon weer een conventioneel gekwantiseerd Qwen-model is. 

De meeste lokale GGUF-modellen worden na training gecomprimeerd door de numerieke precisie van een bestaand model te verlagen. 

Bonsai kiest een agressievere aanpak door het model aan te passen rond binaire gewichten, waardoor een groot deel van het netwerk kan werken met waarden in de buurt van −1 of +1.

Dit is belangrijk omdat het draaien van grote taalmodellen vaak wordt beperkt door geheugencapaciteit en geheugenbandbreedte in plaats van alleen ruwe rekenkracht. 

Het verlagen van de precisie van de gewichten vermindert de hoeveelheid data die tijdens inferentie moet worden opgeslagen en verplaatst. 

Met een geoptimaliseerde runtime kan dit een groot 27B-model praktisch maken op consumentenhardware die het normaal moeilijk zou hebben om het te laden of te draaien.

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

Bonsai behoudt ook capaciteiten die verder gaan dan basis-chat. 

Het ondersteunt redeneren, coderen, gestructureerde tool-calls, long-context prompts en agentische workflows.

Het kan ook achter een OpenAI-compatibele API draaien, waardoor het makkelijker te koppelen is aan coding agents, retrievalsystemen, automatiseringstools en applicaties die al OpenAI-achtige endpoints ondersteunen.

Toch moet je Bonsai niet behandelen als identiek aan het full-precision Qwen3.6-27B-model. 

Extreme compressie brengt nog steeds trade-offs met zich mee en kan de instructieopvolging, toolselectie, consistentie van redeneren en outputkwaliteit per taak verschillend beïnvloeden. 

Het belangrijkste voordeel is de balans: mogelijkheden van een groot model met aanzienlijk lagere hardware-eisen.

Vereisten om Bonsai 27B lokaal te draaien

Controleer voordat je begint of je systeem beschikt over:

• Minstens 8 GB systeem-RAM, al zijn 16 GB of meer aanbevolen
• Ongeveer 8 GB vrije opslag voor het model, de runtime en ondersteunende bestanden
• Git om de Bonsai-demo repository te klonen
• Een ondersteund besturingssysteem, zoals Linux, Windows of macOS
• Een NVIDIA-, AMD-, Vulkan-compatibele of Apple Silicon GPU voor snellere inferentie

Een dedicated GPU is optioneel omdat Bonsai ook op de CPU kan draaien. 

CPU-inferentie is echter over het algemeen langzamer, vooral wanneer het model lange redeneerantwoorden genereert.

Voor deze gids gebruik ik één NVIDIA RTX 5070 Ti met 16 GB VRAM. 

Dit biedt genoeg geheugen om de circa 3,9 GB aan modelgewichten volledig op de GPU te laden en laat extra geheugen over voor de KV-cache, modelactivaties en runtime-overhead.

De beschikbare VRAM bepaalt echter ook hoeveel context je kunt gebruiken. 

Hoewel Bonsai 27B gesprekken ondersteunt die meer dan 256K tokens overschrijden, kan het laden van de volledige trainingscontext veel extra geheugen verbruiken en systemen met beperkte RAM of VRAM uitputten. 

Prism ML gebruikt daarom een geheugenbewuste standaard contextgrootte in plaats van automatisch het volledige 262K-token venster toe te wijzen.

In deze tutorial gebruiken we aanvankelijk een kleiner contextvenster van 8.192 tokens voor testen via de command line. Vervolgens vergroten we het bij het starten van de server, afhankelijk van het beschikbare geheugen. 

Een kleiner contextvenster is voldoende voor de meeste codeer- en chat-taken en zorgt voor een snellere start met lager geheugengebruik.

Stap 1: Download en installeer Bonsai 27B

Open een terminal en kloon de officiële Bonsai-demo repository:

git clone https://github.com/PrismML-Eng/Bonsai-demo.git
cd Bonsai-demoMogelijk gemaakt door

De repository bevat scripts om het model te downloaden, je hardware te detecteren, het juiste runtime-binary te selecteren, het model vanuit de terminal te draaien en een lokale server te starten.

Voer het volgende setup-commando uit:

BONSAI_FAMILY=bonsai \
BONSAI_MODEL=27B \
BONSAI_OPENWEBUI=0 \
BONSAI_CODE_INTERPRETER=0 \
./setup.shMogelijk gemaakt door

Tijdens de setup kan je gevraagd worden om een Hugging Face-toegangstoken in te voeren. 

Dit is optioneel voor publieke modelbestanden, dus je kunt het overslaan door op Enter te drukken. 

Met een token voorkom je echter mogelijk limieten voor anonieme downloads.

Het script downloadt ongeveer 7,15 GB aan bestanden, waaronder:

• Het Bonsai-27B-Q1_0.gguf-taalmodel
• De multimodale projector (mmproj)
• Aanvullende D-Spark-gerelateerde bestanden
• Een geteste vooraf gebouwde runtime voor jouw hardware

Met BONSAI_FAMILY=bonsai kies je het compacte 1-bit Bonsai-model in plaats van de grotere ternaire versie.

De volgende opties schakelen twee extra omgevingen uit:

BONSAI_OPENWEBUI=0
BONSAI_CODE_INTERPRETER=0Mogelijk gemaakt door

Open WebUI is voor deze tutorial niet nodig omdat de meegeleverde server-binary al een lichte browsergebaseerde chatinterface biedt.

 De code-interpreter-omgeving is ook niet nodig voor de basis lokale setup.

Tijdens de installatie doet het setupscript automatisch het volgende:

• Installeert de vereiste Linux-pakketten
• Maakt een Python-virtual environment aan
• Downloadt de Bonsai 27B-modelbestanden
• Downloadt de juiste vooraf gebouwde runtime
• Detecteert de beschikbare CPU- of GPU-backend
• Configureert het project voor jouw hardware

Deze geautomatiseerde setup is vooral handig omdat je llama.cpp niet handmatig hoeft te compileren of zelf een CUDA-, ROCm-, Vulkan-, Metal- of CPU-binary hoeft te kiezen.

Ik raad de llama.cpp-tutorial aan als je een korte inleiding nodig hebt. 

Stap 2: Test Bonsai 27B via de CLI

Test na installatie het model direct vanuit de terminal met de meegeleverde llama.cpp command-line interface:

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

Dit commando:

• Selecteert de 1-bit Bonsai-modelfamilie
• Laadt het 27B-model
• Stelt het contextvenster in op 8.192 tokens
• Start de interactieve llama.cpp-terminal
• Stuurt het samengestelde-rente-verzoek als eerste prompt

Het eerste opstarten kan even duren terwijl het model in het systeemgeheugen of de GPU-VRAM wordt geladen. 

Zodra het klaar is, toont de terminal het actieve model, build-informatie en beschikbare commando's, waarna de respons wordt gegenereerd.

Zoals in de output te zien is, produceert Bonsai eerst zijn redeneerproces en genereert daarna een compleet Python-voorbeeld, inclusief de functie, gebruiksinstructies en het berekende resultaat. 

Na de eerste respons blijft de sessie open en kun je extra prompts invoeren zonder het model te herstarten.

Stap 3: Start de Bonsai-server

Druk eerst op Ctrl+C om de interactieve CLI-sessie van de vorige stap te sluiten.

Start vervolgens de lokale Bonsai-server:

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

Dit commando:

• Laadt het 1-bit Bonsai 27B-model
• Reserveert een contextvenster van 100.000 tokens
• Registreert het model onder de naam bonsai-27b
• Start de server op poort 8910
• Maakt hem toegankelijk vanaf de lokale machine en andere apparaten op hetzelfde netwerk

Een contextvenster van 100.000 tokens vereist aanzienlijk meer geheugen dan de eerdere CLI-test met 8.192 tokens. Verlaag BONSAI_CTX als het model niet wil starten of als je systeem RAM of VRAM tekortkomt.

Omdat --host 0.0.0.0 de server blootstelt aan je lokale netwerk, gebruik dit niet op een onbetrouwbaar netwerk. Voor alleen lokale toegang vervang je het door:

--host 127.0.0.1Mogelijk gemaakt door

Laat deze terminal open staan terwijl je het model gebruikt. Sluit je hem, dan stopt de server.

De Bonsai-server biedt:

• Een lichte lokale webinterface
• Een OpenAI-compatibele API
• Streamingresponses
• Gestructureerde tool-calls
• Modelspecifieke redeneerinstellingen

De OpenAI-compatibele API is beschikbaar op:

http://127.0.0.1:8910/v1Mogelijk gemaakt door

Stap 4: Test Bonsai 27B met CURL

Open een tweede terminal en stuur een verzoek naar de chat-completions endpoint:

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
  }'Mogelijk gemaakt door

Het verzoek gebruikt dezelfde structuur als de OpenAI Chat Completions API:

• model selecteert de eerder gemaakte serveralias
• messages bevat het gesprek
• max_tokens beperkt het aantal gegenereerde tokens

De API retourneerde JSON met ongeveer 95 tokens per seconde, maar de respons stopte bij de limiet van 1.000 tokens, dus verhoog "max_tokens" naar 3000 voor een volledig antwoord voordat je Bonsai koppelt aan applicaties, agents of Python-programma's.

Stap 5: Test de Bonsai 27B Web-UI

Open het volgende adres in je browser:

http://127.0.0.1:8910Mogelijk gemaakt door

Met de ingebouwde llama.cpp-interface kun je chatten met Bonsai, bestanden uploaden en de redeinspanning aanpassen van Uit tot Max.

Test het met een codeerprompt zoals:

Create a Python command-line application that converts CSV files to JSON.Mogelijk gemaakt door

Bonsai genereerde een compleet Python-script met ongeveer 92 tokens per seconde op mijn RTX 5070 Ti. 

Ik vroeg het ook om een persoonlijke portfolio-website te maken. 

Hoewel de code werkte, was ik niet tevreden met de gegenereerde UI, omdat het ontwerp basic en generiek oogde. 

Dit suggereert dat Bonsai functionele code kan produceren, maar dat er meer gedetailleerde prompts en meerdere iteraties nodig kunnen zijn om een gepolijste interface te maken.

Stap 6: Installeer de Pi coding agent

Pi is een terminalgebaseerde coding agent waarmee we Bonsai 27B testen in een echte agentische codeerworkflow via de lokale OpenAI-compatibele API.

Open een nieuwe terminal en installeer de Pi coding agent:

curl -fsSL https://pi.dev/install.sh | shMogelijk gemaakt door

Wanneer daarom gevraagd, druk op Enter of typ y om door te gaan met de standaardinstallatie.

Controleer of Pi succesvol is geïnstalleerd:

pi --versionMogelijk gemaakt door

Op het moment van testen was de geïnstalleerde versie:

0.82.0Mogelijk gemaakt door

Stap 7: Voeg Bonsai 27B toe aan Pi

Controleer of de Bonsai-server nog draait, start dan een nieuwe terminal en maak Pi's configuratiemap aan:

mkdir -p ~/.pi/agentMogelijk gemaakt door

Maak het aangepaste modelconfiguratiebestand aan:

nano ~/.pi/agent/models.jsonMogelijk gemaakt door

Plak de volgende configuratie:

{
  "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
          }
        }
      ]
    }
  }
}Mogelijk gemaakt door

Deze configuratie verbindt Pi met het lokale OpenAI-compatibele endpoint, registreert het model als Bonsai 27B Local en komt overeen met de serverinstelling van 100.000 tokens context.

Sla het bestand op en sluit het:

Ctrl + O
Enter
Ctrl + XMogelijk gemaakt door

Pi laadt automatisch aangepaste modelproviders uit ~/.pi/agent/models.json.

Stap 8: Draai Pi met Bonsai 27B

Zorg dat de Bonsai-server nog draait en maak dan een nieuwe projectmap aan:

mkdir simple-python
cd simple-pythonMogelijk gemaakt door

Start Pi met het lokale Bonsai-model:

pi --provider bonsai-local --model bonsai-27bMogelijk gemaakt door

Voer een prompt in zoals:

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.Mogelijk gemaakt door

Pi begon te redeneren, maakte de projectbestanden aan, installeerde de vereiste pakketten en produceerde een tekstanalyse-app met een FastAPI-backend en een responsieve frontend.

Terwijl het model draaide met een contextvenster van 100.000 tokens, liet nvidia-smi ongeveer 11,9 GB VRAM-gebruik zien op mijn RTX 5070 Ti:

Aan het einde bevestigde Pi dat de taak voltooid was en gaf een duidelijke samenvatting van alles wat het had gedaan. 

Dit omvatte de aangemaakte bestanden, de belangrijkste features van de applicatie, de tests die zijn uitgevoerd en de exacte commando's om het project lokaal te draaien. 

Na de generatie gaf Pi een samenvatting van de bestanden en features die het had gemaakt. 

Ik testte de backend met:

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

De API werkte en de interface zag er beter uit dan de eerdere website die via de basis web-UI was gegenereerd. 

De applicatie was echter nog niet compleet: sommige knoppen en besturingselementen ontbraken, en de frontend toonde niet alle statistieken die beschikbaar waren via de backend-API. 

Dit laat zien dat Bonsai een functionele full-stack applicatie kan bouwen, maar dat het resultaat nog getest en verfijnd moet worden.

Tot slot

In mijn tests voelt Bonsai 27B nog steeds als een sterk gecomprimeerd model. 

De outputkwaliteit is niet helemaal op het niveau van een Q4-gekwantiseerde Qwen3.6-27B, die ik eerder heb getest en betrouwbaarder vond voor coding-agent workflows. 

De Q4-versie vereist meer geheugen, maar levert sterker redeneren, betere codegeneratie en consistenter resultaat.

Dat gezegd hebbende blijft Bonsai 27B opmerkelijk capabel voor een model met een omvang van ongeveer 3,8 GB.

Het begrijpt instructies, maakt projectbestanden aan, voert commando's uit, test zijn werk en kan lokaal functionele applicaties bouwen. Binnen deze grootteklasse is het een van de meest capabele modellen die ik heb geprobeerd.

Voor serieuze coding-agent taken zou ik nog steeds kiezen voor de Q4-versie van Qwen3.6-27B, vooral omdat mijn RTX 3090 24 GB VRAM heeft en het grotere model comfortabel aankan. 

Toch heb ik met veel plezier Bonsai 27B gebruikt en was ik onder de indruk van het bredere Prism ML-ecosysteem. De geautomatiseerde setup, geoptimaliseerde runtime, ingebouwde webinterface, OpenAI-compatibele API en agentintegraties maken het voor meer mensen veel eenvoudiger om lokaal op consumentenhardware een groot redeneermodel te draaien en te ervaren.