Comment exécuter Bonsai 27B en local avec 8 Go de mémoire

Remarque : Bonsai 2 27B est désormais disponible, basé sur Qwen3.8 27B

Qwen3.6-27B est devenu un choix prisé pour exécuter en local un modèle performant en raisonnement et en code. Il est rapide et puissant, mais un modèle de 27 milliards de paramètres demande tout de même beaucoup de mémoire. 

L’approche classique de quantification réduit ces exigences, mais peut aussi dégrader sensiblement les performances.

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

Prism ML a abordé le problème autrement avec Bonsai 27B, une version 1 bit fortement compressée de Qwen3.6-27B. 

D’après Prism ML, Bonsai conserve près de 90 % des performances de référence du modèle original tout en réduisant les poids à environ 3,9 Go. 

Cela permet d’expérimenter un modèle de raisonnement de classe 27B sur du matériel grand public bien plus accessible.

Dans ce tutoriel, j’utilise le modèle 1 bit Bonsai-27B-Q1_0.gguf et le script d’installation personnalisé de Prism ML. Le script télécharge automatiquement le modèle, sélectionne un runtime précompilé compatible et le configure selon le matériel disponible. 

Je testerai ensuite Bonsai en ligne de commande, lancerai son interface web locale, y accéderai via une API compatible OpenAI, puis le connecterai à l’agent de code Pi.

Qu’est-ce qui rend Bonsai 27B si particulier ?

L’intérêt de Bonsai 27B, c’est qu’il ne s’agit pas simplement d’un autre modèle Qwen quantifié de manière conventionnelle. 

La plupart des modèles GGUF locaux sont compressés après l’entraînement en réduisant la précision numérique d’un modèle existant. 

Bonsai adopte une approche plus agressive en adaptant le modèle autour de poids binaires, permettant à une grande partie du réseau de fonctionner avec des valeurs proches de –1 ou +1.

C’est important car l’exécution de grands modèles de langage est souvent limitée par la capacité mémoire et la bande passante mémoire, plus que par la seule puissance de calcul. 

Réduire la précision des poids diminue la quantité de données à stocker et à déplacer durant l’inférence. 

Avec un runtime optimisé, cela peut rendre un modèle 27B réellement exploitable sur du matériel grand public qui aurait normalement du mal à le charger ou à l’exécuter.

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

Bonsai préserve aussi des capacités au-delà du simple chat. 

Il prend en charge le raisonnement, le code, les appels d’outils structurés, les prompts à long contexte et des workflows agentiques.

Il peut aussi tourner derrière une API compatible OpenAI, ce qui facilite la connexion avec des agents de code, des systèmes de recherche, des outils d’automatisation et des applications qui utilisent déjà des endpoints au format OpenAI.

Cependant, Bonsai ne doit pas être considéré comme identique au modèle Qwen3.6-27B en pleine précision. 

Une compression extrême implique des compromis et peut affecter différemment, selon les tâches, le suivi des consignes, le choix des outils, la cohérence du raisonnement et la qualité des sorties. 

Son principal atout reste l’équilibre qu’il offre : des capacités de grand modèle avec des exigences matérielles bien plus faibles.

Prérequis pour exécuter Bonsai 27B en local

Avant de commencer, vérifiez que votre système dispose :

• D’au moins 8 Go de RAM système, 16 Go ou plus étant recommandés
• D’environ 8 Go d’espace de stockage libre pour le modèle, le runtime et les fichiers associés
• Git pour cloner le dépôt de démonstration Bonsai
• D’un système d’exploitation pris en charge : Linux, Windows ou macOS
• D’un GPU NVIDIA, AMD, compatible Vulkan, ou Apple Silicon pour une inférence plus rapide

Un GPU dédié est optionnel : Bonsai peut aussi tourner sur CPU. 

Cependant, l’inférence sur CPU sera généralement plus lente, surtout lorsque le modèle produit de longues chaînes de raisonnement.

Pour ce guide, j’utilise une NVIDIA RTX 5070 Ti avec 16 Go de VRAM. 

Cela suffit pour charger les ~3,9 Go de poids du modèle entièrement sur le GPU, tout en laissant de la marge pour le cache KV, les activations et le surcoût du runtime.

La VRAM disponible conditionne toutefois la taille de contexte exploitable. 

Bien que Bonsai 27B prenne en charge des conversations dépassant 256 K tokens, charger l’intégralité de ce contexte d’entraînement peut consommer beaucoup de mémoire supplémentaire et saturer les systèmes à la RAM/VRAM limitée. 

Prism ML utilise donc par défaut une taille de contexte adaptée à la mémoire, plutôt que d’allouer automatiquement la fenêtre complète de 262 K tokens.

Dans ce tutoriel, nous commencerons avec une fenêtre de contexte de 8 192 tokens pour les tests en ligne de commande. Nous l’augmenterons ensuite lors du lancement du serveur, selon la mémoire disponible. 

Une fenêtre de contexte plus petite suffit pour la plupart des tâches de code et de chat, et offre un démarrage plus rapide avec une empreinte mémoire réduite.

Étape 1 : télécharger et installer Bonsai 27B

Ouvrez un terminal et clonez le dépôt officiel de démonstration Bonsai :

git clone https://github.com/PrismML-Eng/Bonsai-demo.git
cd Bonsai-demoPropulsé par

Le dépôt inclut des scripts pour télécharger le modèle, détecter votre matériel, sélectionner le binaire runtime adéquat, exécuter le modèle depuis le terminal et lancer un serveur local.

Exécutez la commande d’installation suivante :

BONSAI_FAMILY=bonsai \
BONSAI_MODEL=27B \
BONSAI_OPENWEBUI=0 \
BONSAI_CODE_INTERPRETER=0 \
./setup.shPropulsé par

Pendant l’installation, il se peut qu’on vous demande un jeton d’accès Hugging Face. 

C’est optionnel pour les fichiers publics, vous pouvez donc passer en appuyant sur Entrée. 

Cependant, l’utilisation d’un jeton peut éviter les limites de téléchargement anonymes.

Le script télécharge environ 7,15 Go de fichiers, dont :

• Le modèle de langue Bonsai-27B-Q1_0.gguf
• Le projecteur multimodal (mmproj)
• Des fichiers liés à D-Spark
• Un binaire runtime précompilé et testé pour votre matériel

Définir BONSAI_FAMILY=bonsai sélectionne le modèle Bonsai compact en 1 bit au lieu de la version ternaire plus volumineuse.

Les options suivantes désactivent deux environnements additionnels :

BONSAI_OPENWEBUI=0
BONSAI_CODE_INTERPRETER=0Propulsé par

Open WebUI n’est pas nécessaire ici, car le binaire de serveur inclus propose déjà une interface de chat web légère.

L’environnement « code-interpreter » est également inutile pour une configuration locale de base.

Pendant l’installation, le script :

• Installe les paquets Linux requis
• Crée un environnement Python virtuel
• Télécharge les fichiers du modèle Bonsai 27B
• Télécharge le runtime précompilé adéquat
• Détecte le backend CPU ou GPU disponible
• Configure le projet pour votre matériel

Cette installation automatisée est précieuse : vous n’avez pas à compiler manuellement llama.cpp ni à choisir vous‑même un binaire CUDA, ROCm, Vulkan, Metal ou CPU.

Je vous recommande ce tutoriel llama.cpp pour une remise à niveau rapide. 

Étape 2 : tester Bonsai 27B depuis la CLI

Après l’installation, testez le modèle directement depuis le terminal avec l’interface en ligne de commande incluse de llama.cpp :

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

Cette commande :

• Sélectionne la famille Bonsai 1 bit
• Charge le modèle 27B
• Fixe la fenêtre de contexte à 8 192 tokens
• Démarre le terminal interactif llama.cpp
• Envoie la demande sur l’intérêt composé comme premier prompt

Le premier lancement peut prendre un court instant, le temps de charger le modèle en mémoire système ou en VRAM GPU. 

Une fois prêt, le terminal affiche le modèle actif, les informations de build et les commandes disponibles avant de générer la réponse.

Comme le montre la sortie, Bonsai produit d’abord son raisonnement puis génère un exemple Python complet, incluant la fonction, les instructions d’utilisation et le résultat calculé. 

Après la première réponse, la session reste ouverte et vous pouvez saisir d’autres prompts sans redémarrer le modèle.

Étape 3 : démarrer le serveur Bonsai

Commencez par appuyer sur Ctrl+C pour fermer la session CLI interactive précédente.

Puis démarrez le serveur local Bonsai :

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

Cette commande :

• Charge le modèle Bonsai 27B en 1 bit
• Alloue une fenêtre de contexte de 100 000 tokens
• Enregistre le modèle sous le nom bonsai-27b
• Démarre le serveur sur le port 8910
• Le rend accessible depuis la machine locale et les appareils du même réseau

Une fenêtre de 100 000 tokens requiert bien plus de mémoire que le test CLI à 8 192 tokens. Réduisez BONSAI_CTX si le modèle ne démarre pas ou si votre système manque de RAM/VRAM.

Comme --host 0.0.0.0 expose le serveur à votre réseau local, évitez de l’utiliser sur un réseau non fiable. Pour un accès local uniquement, remplacez‑le par :

--host 127.0.0.1Propulsé par

Laissez ce terminal ouvert pendant l’utilisation du modèle. Le fermer arrêtera le serveur.

Le serveur Bonsai fournit :

• Une interface web locale légère
• Une API compatible OpenAI
• Des réponses en streaming
• Des appels d’outils structurés
• Des contrôles de raisonnement spécifiques au modèle

L’API compatible OpenAI est disponible à :

http://127.0.0.1:8910/v1Propulsé par

Étape 4 : tester Bonsai 27B avec CURL

Ouvrez un second terminal et envoyez une requête à l’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
  }'Propulsé par

La requête reprend la structure de l’API OpenAI Chat Completions :

• model sélectionne l’alias de serveur créé plus tôt
• messages contient la conversation
• max_tokens limite le nombre de tokens générés

L’API a renvoyé du JSON à environ 95 tokens par seconde, mais la réponse a été coupée à la limite de 1 000 tokens ; augmentez "max_tokens" à 3000 pour obtenir une réponse complète avant de connecter Bonsai à des applications, des agents ou des programmes Python.

Étape 5 : tester l’interface web de Bonsai 27B

Ouvrez l’adresse suivante dans votre navigateur :

http://127.0.0.1:8910Propulsé par

L’interface intégrée de llama.cpp permet de dialoguer avec Bonsai, d’envoyer des fichiers et d’ajuster le niveau d’effort de raisonnement de Off à Max.

Essayez avec un prompt de code tel que :

Create a Python command-line application that converts CSV files to JSON.Propulsé par

Bonsai a généré un script Python complet à environ 92 tokens par seconde sur ma RTX 5070 Ti. 

Je lui ai aussi demandé de créer un site de portfolio personnel. 

Même si le code fonctionnait, je n’étais pas satisfait de l’interface générée : le design était basique et générique. 

Cela suggère que Bonsai sait produire du code fonctionnel, mais qu’il faudra des prompts plus précis et plusieurs itérations pour aboutir à une interface aboutie.

Étape 6 : installer l’agent de code Pi

Pi est un agent de code en terminal que nous utilisons pour tester Bonsai 27B dans un véritable workflow agentique via son API locale compatible OpenAI.

Ouvrez un nouveau terminal et installez l’agent de code Pi :

curl -fsSL https://pi.dev/install.sh | shPropulsé par

Quand l’assistant vous le demande, appuyez sur Entrée ou tapez y pour poursuivre avec l’installation par défaut.

Vérifiez que Pi est bien installé :

pi --versionPropulsé par

Au moment du test, la version installée était :

0.82.0Propulsé par

Étape 7 : ajouter Bonsai 27B à Pi

Assurez‑vous que le serveur Bonsai tourne toujours, puis lancez un nouveau terminal et créez le répertoire de configuration de Pi :

mkdir -p ~/.pi/agentPropulsé par

Créez le fichier de configuration du modèle personnalisé :

nano ~/.pi/agent/models.jsonPropulsé par

Collez la configuration suivante :

{
  "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
          }
        }
      ]
    }
  }
}Propulsé par

Cette configuration connecte Pi à l’endpoint local compatible OpenAI, enregistre le modèle sous Bonsai 27B Local et reflète la fenêtre de contexte à 100 000 tokens du serveur.

Enregistrez et fermez le fichier :

Ctrl + O
Enter
Ctrl + XPropulsé par

Pi charge automatiquement les fournisseurs de modèles personnalisés depuis ~/.pi/agent/models.json.

Étape 8 : exécuter Pi avec Bonsai 27B

Assurez‑vous que le serveur Bonsai tourne toujours, puis créez un nouveau répertoire de projet :

mkdir simple-python
cd simple-pythonPropulsé par

Démarrez Pi en utilisant le modèle local Bonsai :

pi --provider bonsai-local --model bonsai-27bPropulsé par

Entrez un prompt, par exemple :

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.Propulsé par

Pi a commencé à raisonner, créé les fichiers du projet, installé les dépendances requises et produit une application d’analyse de texte avec un backend FastAPI et un frontend responsive.

Avec une fenêtre de contexte de 100 000 tokens, nvidia-smi indiquait environ 11,9 Go de VRAM utilisée sur ma RTX 5070 Ti :

À la fin, Pi a confirmé l’achèvement de la tâche et fourni un récapitulatif clair de tout ce qui a été fait. 

Cela incluait les fichiers créés, les fonctionnalités principales de l’application, les tests effectués et les commandes exactes pour exécuter le projet en local. 

Après génération, Pi a synthétisé les fichiers et fonctionnalités créés. 

J’ai testé le backend avec :

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

L’API a fonctionné, et l’interface était plus aboutie que celle générée via la web UI basique. 

Cependant, l’application restait incomplète : certains boutons et contrôles manquaient, et le frontend n’affichait pas toutes les statistiques disponibles via l’API backend. 

Cela montre que Bonsai peut construire une application full‑stack fonctionnelle, mais le résultat requiert encore des tests et des affinages.

Conclusion

D’après mes tests, Bonsai 27B reste un modèle fortement compressé. 

Sa qualité de sortie n’atteint pas tout à fait celle d’un Qwen3.6-27B quantifié en Q4, que j’ai déjà testé et trouvé plus fiable pour des workflows d’agent de code. 

La version Q4 exige plus de mémoire, mais offre un meilleur raisonnement, une génération de code plus robuste et des résultats plus constants.

Cela dit, Bonsai 27B reste remarquablement capable pour un modèle d’environ 3,8 Go.

Il comprend les consignes, crée des fichiers de projet, exécute des commandes, teste son travail, et peut construire des applications fonctionnelles en local. Dans cette catégorie de taille, c’est l’un des modèles les plus convaincants que j’aie essayés.

Pour du travail d’agent de code sérieux, je choisirais encore la version Q4 de Qwen3.6-27B, d’autant que ma RTX 3090 dispose de 24 Go de VRAM et gère confortablement le modèle plus grand. 

Malgré tout, j’ai vraiment apprécié utiliser Bonsai 27B et été impressionné par l’écosystème plus large de Prism ML. Son installation automatisée, son runtime optimisé, son interface web intégrée, son API compatible OpenAI et ses intégrations agent facilitent grandement l’exécution d’un grand modèle de raisonnement en local sur du matériel grand public.