Tutorial Bonsai AI: rode um LLM de 1 bit localmente em um notebook antigo

Executar modelos de linguagem localmente está ficando cada vez mais fácil, mesmo em hardwares mais antigos. O Bonsai é um modelo de 1 bit projetado para ser pequeno, rápido e eficiente — uma ótima opção para uso local em um notebook com Windows.

Neste tutorial, vou explicar o que é o Bonsai e como funcionam os modelos de 1 bit de um jeito simples. Também vou te guiar por todo o processo de configuração, passo a passo. 

Isso inclui baixar o modelo Bonsai 8B GGUF, configurar o fork PrismML do llama.cpp, testar o modelo no terminal, rodá-lo como servidor local e verificar se tudo está funcionando tanto com curl quanto pelo WebUI integrado.

Eu recomendo conferir também nossos guias para rodar localmente o GLM-5.1 e o Qwen3.5-27B.

O que é o modelo Bonsai AI?

Bonsai é uma família de modelos de linguagem compactos de 1 bit da PrismML que inclui variantes de 1,7B, 4B e 8B, oferecendo opções de tamanho conforme o dispositivo e a performance desejada. 

A linha Bonsai é pensada para inferência local eficiente, com suporte no llama.cpp e runtimes relacionados. O modelo destaque Bonsai 8B GGUF é bem menor que um modelo 8B típico em FP16, mantendo-se competitivo em capacidade.

Como funcionam os modelos de 1 bit?

Um modelo de 1 bit armazena cada peso em um único bit, em vez de usar valores de precisão total. No formato Q1_0 do Bonsai, o valor 0 mapeia para uma escala negativa e o valor 1 mapeia para uma escala positiva, com uma escala FP16 compartilhada a cada 128 pesos. 

Essa abordagem reduz bastante o uso de memória, mantendo o modelo funcional e eficiente para inferência. O Bonsai aplica o design de 1 bit em embeddings, projeções de atenção, projeções do MLP e na cabeça de LM, tornando-o um modelo de 1 bit de ponta a ponta.

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

Em benchmarks, o Bonsai 8B mostra que um modelo muito menor, de 1 bit, ainda consegue competir com modelos de precisão total na faixa de 6B a 9B. O model card informa pontuação média de 70,5 em seis categorias de avaliação, ficando próximo de vários modelos 8B padrão. Ou seja, o Bonsai se destaca não só pelo tamanho e velocidade, mas também por manter uma boa performance.

Requisitos do sistema e pré-requisitos do Bonsai

Para este tutorial, estou rodando o Bonsai em um notebook Windows mais antigo com processador Intel de 12ª geração e GPU NVIDIA RTX 3070. Uma das maiores vantagens do Bonsai 8B é poder rodar com cerca de 2 GB de VRAM ou RAM do sistema, o que o torna prático para notebooks antigos e máquinas com menos memória. 

Para mais velocidade, recomendo instalar o driver mais recente da NVIDIA e o CUDA Toolkit na página oficial de downloads da NVIDIA. O CUDA Toolkit é o ambiente oficial da NVIDIA para aplicações aceleradas por GPU.

Depois de instalar tudo, abra o Prompt de Comando ou o Terminal e execute:

nvidia-smi

Esse comando mostra sua GPU NVIDIA, a versão do driver e o suporte a CUDA. Se a GPU aparecer corretamente, seu sistema está pronto para usar aceleração por GPU ao rodar o Bonsai localmente.

1. Baixe o modelo Bonsai 8B GGUF

Primeiro, acesse o repositório do Bonsai 8B GGUF no Hugging Face e baixe o arquivo do modelo GGUF diretamente pelo botão de download.

Em seguida, crie uma pasta chamada “Bonsai” no seu sistema. Dentro dela, crie outra pasta chamada “model” e coloque o arquivo GGUF baixado dentro dessa pasta.

2. Baixe o build do PrismML para o llama.cpp

Depois, abra a página de release do PrismML para o llama.cpp e baixe o build pré-compilado para Windows x64 que corresponda à sua versão do CUDA. Para este tutorial, você deve baixar o arquivo Windows x64 (CUDA 13.1) e também as DLLs do CUDA 13.1 na mesma página de release.

3. Prepare a pasta do projeto Bonsai

Após baixar os dois arquivos ZIP, extraia-os dentro da pasta “Bonsai” que você criou.

Quando terminar, a pasta deve incluir o diretório do modelo com o arquivo GGUF do Bonsai, além dos arquivos do llama.cpp necessários para rodar o modelo no terminal e como servidor local.

4. Teste o modelo com o llama-cli

Agora abra a pasta “Bonsai”, clique com o botão direito em uma área vazia e selecione Abrir no Terminal. Assim você roda o modelo direto da pasta que contém os arquivos do llama.cpp e o diretório “model”.

Em seguida, execute o comando abaixo para testar o Bonsai com o llama-cli:

.\llama-cli -m model/Bonsai-8B.gguf -p "Explain quantum computing in simple terms." -n 256 --temp 0.5 --top-p 0.85 --top-k 20 -ngl 99

Esse comando segue as configurações recomendadas de prompt e geração mostradas no quickstart oficial do Bonsai, incluindo temperature 0.5, top-p 0.85, top-k 20 e -ngl 99 para descarregar camadas na GPU. 

No meu teste, o modelo carregou na memória da GPU em menos de um segundo, e a resposta foi rápida e assertiva.

Eu também atingi cerca de 88,6 tokens por segundo — bem impressionante para um modelo local em um notebook antigo.

5. Rode o Bonsai como servidor de inferência local

Depois de testar o modelo no CLI, você pode rodá-lo como servidor de inferência local com o llama-server:

.\llama-server -m model/Bonsai-8B.gguf -ngl 99 --host 127.0.0.1 --port 8033

Isso segue a mesma configuração de servidor local mostrada na página oficial do modelo Bonsai, onde a PrismML usa o llama-server para servir o modelo via endpoint HTTP local.

No meu teste, o modelo carregou na memória em menos de 5 segundos.

Quando a carga termina, o terminal mostra que o servidor está rodando em 127.0.0.1:8033, ou seja, o Bonsai agora está disponível por um endpoint de API local na sua máquina.

6. Teste o servidor com curl

Com o servidor do Bonsai em execução, o próximo passo é testar a API local com o curl. O endpoint do llama-server é compatível com OpenAI, então você pode enviar uma requisição para /v1/chat/completions e receber uma resposta normal de chat completion.

Execute o comando abaixo no seu terminal:

curl -X POST "http://127.0.0.1:8033/v1/chat/completions" -H "Content-Type: application/json" --data-raw '{"model":"Bonsai-8B","messages":[{"role":"system","content":"You are a helpful assistant."},{"role":"user","content":"Write a short Python function to reverse a string."}],"temperature":0.7,"max_tokens":200,"stream":false}'

Se tudo estiver certo, o servidor vai retornar uma resposta JSON com a saída gerada.

7. Abra e teste o WebUI

Com o servidor rodando, abra http://127.0.0.1:8033/ no navegador. O servidor do llama.cpp inclui uma interface web integrada.

Você terá uma interface simples, ao estilo do ChatGPT, para testar o modelo local. No meu caso, a interface abriu na hora e pude começar a conversar com o Bonsai direto do navegador. 

Teste 1: escreva um conto curto

Pedi primeiro para escrever uma história e, em poucos segundos, ele respondeu a cerca de 85 tokens por segundo.

Teste 2: programe um jogo simples

Para ver como ele lida com uma tarefa real de código, dei este prompt:

Write Python code to build a command-line number guessing game where the user guesses a randomly selected number, receives "too high" or "too low" hints after each guess, and sees the total number of attempts once they guess correctly.

De novo, a resposta foi rápida. O modelo gerou o código com instruções simples de como salvar o arquivo e rodá-lo com Python.

Copiei o código para um arquivo Python, rodei no terminal e funcionou de primeira, sem nenhum problema.

Teste 3: gere um site simples

Também testei um segundo prompt para ver como ele se sai gerando front-end:

Create a simple, clean HTML personal profile website for Abid Ali Awan, a Data Scientist, with sections for a hero intro, about, skills, projects, and contact, using modern styling and placeholder content that can be customized later.

A resposta foi rápida novamente. Copiei o código gerado para um arquivo HTML, abri no navegador e a página renderizou corretamente.

Para um modelo desse tamanho, o resultado foi realmente impressionante.

Considerações finais

O que mais me surpreendeu no Bonsai foi a combinação de velocidade, tamanho e inteligência. Eu não esperava que um modelo tão pequeno fosse tão rápido e utilizável em um notebook Windows antigo. 

A configuração completa também foi muito mais simples do que eu imaginava. Eu só precisei baixar o arquivo GGUF no Hugging Face e os arquivos do build do PrismML para o llama.cpp, colocar tudo em uma pasta e rodar os comandos no terminal para testar e servir o modelo localmente. Do início ao fim, levei menos de dois minutos para sair do zero e começar a usar o modelo. 

O WebUI do llama.cpp deixou tudo ainda mais acessível, especialmente para quem tem pouca familiaridade com setup local de IA ou com compute. Com o servidor rodando, pude testar prompts, gerar código e experimentar tarefas de escrita criativa em uma interface simples no navegador, sem ferramentas extras.

Também gostei da qualidade das respostas. Para um modelo desse porte, o Bonsai lidou muito bem com código e escrita criativa. Foi rápido no CLI, rápido pelo servidor local e rápido no WebUI. Dito isso, não acho que um modelo tão pequeno seja a melhor escolha para coding agentic ou tarefas mais complexas que exijam raciocínio mais profundo e contexto mais longo.

Ainda assim, se você quer rodar um modelo localmente, acredito que os modelos de 1 bit são um caminho bem promissor. Eles oferecem um ótimo equilíbrio entre eficiência e inteligência e tornam a IA local muito mais prática no hardware do dia a dia. Eu adoraria testar um modelo de 1 bit maior na sequência, algo mais próximo do Qwen3.5-27B, porque isso pode trazer um equilíbrio ainda melhor entre velocidade, uso de memória e capacidade.