8GB मेमोरी पर Bonsai 27B लोकली कैसे चलाएँ

नोट: Bonsai 2 27B अब उपलब्ध है, जो Qwen3.8 27B पर आधारित है

Qwen3.6-27B, लोकली एक सक्षम रीजनिंग और कोडिंग मॉडल चलाने के लिए एक लोकप्रिय विकल्प बन गया है। यह तेज़ और शक्तिशाली है, लेकिन 27 बिलियन पैरामीटर वाला पूर्ण मॉडल अब भी काफ़ी मेमोरी मांगता है। 

पारंपरिक क्वांटाइज़ेशन इन आवश्यकताओं को कम कर सकता है, लेकिन इससे प्रदर्शन में ध्यान देने योग्य गिरावट भी आ सकती है।

स्रोत: prism-ml/Bonsai-27B-gguf

Prism ML ने Bonsai 27B के साथ इस समस्या को अलग तरह से लिया—यह Qwen3.6-27B का अत्यधिक संपीड़ित 1-बिट संस्करण है। 

Prism ML के अनुसार, Bonsai मूल मॉडल के बेंचमार्क प्रदर्शन का लगभग 90% बनाए रखता है, जबकि मॉडल वेट्स को लगभग 3.9 GB तक घटा देता है। 

इससे 27B-श्रेणी के रीजनिंग मॉडल के साथ अधिक सुलभ कंज़्यूमर हार्डवेयर पर प्रयोग करना संभव हो जाता है।

इस ट्यूटोरियल में, मैं 1-बिट Bonsai-27B-Q1_0.gguf मॉडल और Prism ML की कस्टम सेटअप स्क्रिप्ट का उपयोग करूँगा। यह स्क्रिप्ट अपने आप मॉडल डाउनलोड करती है, संगत प्रीबिल्ट रनटाइम चुनती है, और उपलब्ध हार्डवेयर के लिए कॉन्फ़िगर करती है। 

इसके बाद मैं कमांड लाइन से Bonsai का परीक्षण करूँगा, इसका लोकल वेब इंटरफ़ेस शुरू करूँगा, OpenAI-संगत API के माध्यम से एक्सेस करूँगा, और इसे Pi कोडिंग एजेंट से जोड़ूँगा।

Bonsai 27B में ऐसा क्या ख़ास है?

जो Bonsai 27B को दिलचस्प बनाता है, वह यह है कि यह सिर्फ़ एक और पारंपरिक रूप से क्वांटाइज़्ड Qwen मॉडल नहीं है। 

अधिकांश लोकल GGUF मॉडल प्रशिक्षण के बाद मौजूदा मॉडल की संख्यात्मक प्रिसीजन घटाकर कंप्रेस किए जाते हैं। 

Bonsai इससे आगे बढ़कर मॉडल को बाइनरी वेट्स के इर्द-गिर्द अनुकूलित करता है, जिससे नेटवर्क का बड़ा हिस्सा ऐसे मानों पर चल सकता है जो या तो −1 या +1 के क़रीब होते हैं।

यह इसलिए मायने रखता है क्योंकि बड़े भाषा मॉडल चलाना अक्सर मेमोरी क्षमता और मेमोरी बैंडविड्थ से सीमित होता है, न कि केवल कच्ची कम्प्यूटिंग शक्ति से। 

वेट्स की प्रिसीजन घटाने से इन्फ़रेंस के दौरान स्टोर और मूव किए जाने वाले डेटा की मात्रा कम हो जाती है। 

एक ऑप्टिमाइज़्ड रनटाइम के साथ, इससे 27B जैसा बड़ा मॉडल कंज़्यूमर हार्डवेयर पर भी व्यावहारिक हो जाता है, जहाँ सामान्यतः इसे लोड या रन करना मुश्किल होता।

स्रोत: prism-ml/Bonsai-27B-gguf · Hugging Face 

Bonsai बुनियादी चैट से आगे की क्षमताएँ भी बनाए रखता है। 

यह रीजनिंग, कोडिंग, स्ट्रक्चर्ड टूल कॉल, लांग-कॉन्टेक्स्ट प्रॉम्प्ट, और एजेंटिक वर्कफ़्लो सपोर्ट करता है।

यह OpenAI-संगत API के पीछे भी चल सकता है, जिससे इसे कोडिंग एजेंट्स, रिट्रीवल सिस्टम, ऑटोमेशन टूल्स, और उन ऐप्लिकेशनों से जोड़ना आसान हो जाता है जो पहले से OpenAI-स्टाइल एंडपॉइंट्स सपोर्ट करते हैं।

हालाँकि, Bonsai को पूर्ण-प्रिसीजन Qwen3.6-27B मॉडल के समान नहीं मानना चाहिए। 

अत्यधिक कंप्रेशन में समझौते होते हैं और यह विभिन्न कार्यों में निर्देशों का पालन, टूल चयन, रीजनिंग की स्थिरता, और आउटपुट गुणवत्ता को अलग-अलग तरीक़े से प्रभावित कर सकता है। 

इसका मुख्य लाभ संतुलन है: बड़े मॉडल की क्षमताएँ, पर हार्डवेयर आवश्यकताएँ काफ़ी कम।

Bonsai 27B को लोकली चलाने के लिए पूर्वापेक्षाएँ

शुरू करने से पहले, सुनिश्चित करें कि आपके सिस्टम में ये हैं:

• कम से कम 8 GB सिस्टम RAM, हालाँकि 16 GB या अधिक की अनुशंसा की जाती है
• लगभग 8 GB खाली स्टोरेज मॉडल, रनटाइम और सपोर्टिंग फ़ाइलों के लिए
• Git Bonsai डेमो रिपॉज़िटरी क्लोन करने के लिए
• समर्थित ऑपरेटिंग सिस्टम, जैसे Linux, Windows, या macOS
• तेज़ इन्फ़रेंस के लिए एक NVIDIA, AMD, Vulkan-संगत, या Apple Silicon GPU

डेडिकेटेड GPU वैकल्पिक है क्योंकि Bonsai CPU पर भी चल सकता है। 

हालाँकि, CPU इन्फ़रेंस आम तौर पर धीमा होगा, विशेषकर जब मॉडल लंबी रीजनिंग प्रतिक्रियाएँ बनाता है।

इस गाइड के लिए, मैं एक NVIDIA RTX 5070 Ti (16 GB VRAM) इस्तेमाल कर रहा हूँ। 

यह GPU पर लगभग 3.9 GB मॉडल वेट्स पूरी तरह लोड करने और KV कैश, मॉडल एक्टिवेशन्स, और रनटाइम ओवरहेड के लिए अतिरिक्त मेमोरी छोड़ने के लिए पर्याप्त है।

हालाँकि, उपलब्ध VRAM यह भी निर्धारित करती है कि आप कितना कॉन्टेक्स्ट उपयोग कर सकते हैं। 

यद्यपि Bonsai 27B 256K टोकन्स से अधिक की बातचीत सपोर्ट करता है, इसका पूरा प्रशिक्षण कॉन्टेक्स्ट लोड करना अतिरिक्त मेमोरी का बड़ा हिस्सा ले सकता है और सीमित RAM या VRAM वाले सिस्टम को थका सकता है। 

इसलिए Prism ML स्वतः 262K-टोकन विंडो आवंटित करने के बजाय मेमोरी-जागरूक डिफ़ॉल्ट कॉन्टेक्स्ट साइज़ का उपयोग करता है।

इस ट्यूटोरियल में, हम शुरुआती कमांड-लाइन परीक्षण के लिए छोटा 8,192-टोकन कॉन्टेक्स्ट विंडो उपयोग करेंगे। फिर उपलब्ध मेमोरी के अनुसार सर्वर शुरू करते समय इसे बढ़ाएँगे। 

छोटा कॉन्टेक्स्ट विंडो अधिकांश कोडिंग और चैट कार्यों के लिए पर्याप्त है और कम मेमोरी उपयोग के साथ तेज़ स्टार्टअप देता है।

चरण 1: Bonsai 27B डाउनलोड और इंस्टॉल करें

एक टर्मिनल खोलें और आधिकारिक Bonsai डेमो रिपॉज़िटरी क्लोन करें:

git clone https://github.com/PrismML-Eng/Bonsai-demo.git
cd Bonsai-demoसंचालित द्वारा

रिपॉज़िटरी में मॉडल डाउनलोड करने, आपके हार्डवेयर का पता लगाने, सही रनटाइम बाइनरी चुनने, टर्मिनल से मॉडल चलाने और लोकल सर्वर लॉन्च करने के लिए स्क्रिप्ट शामिल हैं।

निम्नलिखित सेटअप कमांड चलाएँ:

BONSAI_FAMILY=bonsai \
BONSAI_MODEL=27B \
BONSAI_OPENWEBUI=0 \
BONSAI_CODE_INTERPRETER=0 \
./setup.shसंचालित द्वारा

सेटअप के दौरान, आपसे Hugging Face एक्सेस टोकन दर्ज करने के लिए कहा जा सकता है। 

यह सार्वजनिक मॉडल फ़ाइलों के लिए वैकल्पिक है, इसलिए आप Enter दबाकर इसे छोड़ सकते हैं। 

हालाँकि, टोकन का उपयोग करने से अनाम डाउनलोड सीमाओं से बचने में मदद मिल सकती है।

स्क्रिप्ट लगभग 7.15 GB फ़ाइलें डाउनलोड करती है, जिनमें शामिल हैं:

• Bonsai-27B-Q1_0.gguf भाषा मॉडल
• मल्टिमोडल प्रोजेक्टर (mmproj)
• अतिरिक्त D-Spark-संबंधित फ़ाइलें
• आपके हार्डवेयर के लिए परीक्षण किया हुआ प्रीबिल्ट रनटाइम बाइनरी

BONSAI_FAMILY=bonsai सेट करने से बड़े टर्नरी संस्करण के बजाय कॉम्पैक्ट 1-बिट Bonsai मॉडल चुना जाता है।

निम्नलिखित विकल्प दो अतिरिक्त एन्वायरनमेंट्स को निष्क्रिय करते हैं:

BONSAI_OPENWEBUI=0
BONSAI_CODE_INTERPRETER=0संचालित द्वारा

Open WebUI इस ट्यूटोरियल के लिए आवश्यक नहीं है क्योंकि शामिल सर्वर बाइनरी पहले से ही एक हल्का ब्राउज़र-आधारित चैट इंटरफ़ेस प्रदान करता है।

कोड-इंटरप्रेटर एन्वायरनमेंट भी बेसिक लोकल सेटअप के लिए ज़रूरी नहीं है।

इंस्टॉलेशन के दौरान, सेटअप स्क्रिप्ट स्वचालित रूप से:

• आवश्यक Linux पैकेज इंस्टॉल करती है
• Python वर्चुअल एन्वायरनमेंट बनाती है
• Bonsai 27B मॉडल फ़ाइलें डाउनलोड करती है
• उपयुक्त प्रीबिल्ट रनटाइम डाउनलोड करती है
• उपलब्ध CPU या GPU बैकएंड का पता लगाती है
• आपके हार्डवेयर के लिए प्रोजेक्ट कॉन्फ़िगर करती है

यह स्वचालित सेटअप विशेष रूप से उपयोगी है क्योंकि आपको llama.cpp को मैन्युअली कम्पाइल करने या स्वयं CUDA, ROCm, Vulkan, Metal, या CPU बाइनरी चुनने की ज़रूरत नहीं होती।

यदि आपको एक त्वरित परिचय चाहिए, तो मैं llama.cpp ट्यूटोरियल की सिफ़ारिश करता हूँ। 

चरण 2: CLI से Bonsai 27B का परीक्षण करें

इंस्टॉलेशन के बाद, शामिल 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."संचालित द्वारा

यह कमांड:

• 1-बिट Bonsai मॉडल फ़ैमिली चुनता है
• 27B मॉडल लोड करता है
• कॉन्टेक्स्ट विंडो को 8,192 टोकन्स पर सेट करता है
• इंटरैक्टिव llama.cpp टर्मिनल शुरू करता है
• कंपाउंड-इंटरेस्ट अनुरोध को पहला प्रॉम्प्ट बनाकर भेजता है

पहली बार लॉन्च में कुछ पल लग सकते हैं, जबकि मॉडल सिस्टम मेमोरी या GPU VRAM में लोड हो रहा हो। 

तैयार होने पर, टर्मिनल सक्रिय मॉडल, बिल्ड जानकारी, और उपलब्ध कमांड दिखाता है, फिर प्रतिक्रिया जनरेट करता है।

जैसा कि आउटपुट में दिखता है, Bonsai पहले अपना रीजनिंग प्रोसेस देता है और फिर एक संपूर्ण Python उदाहरण जनरेट करता है, जिसमें फ़ंक्शन, उपयोग निर्देश और कैलक्युलेटेड परिणाम शामिल है। 

पहली प्रतिक्रिया के बाद सेशन खुला रहता है, जिससे आप मॉडल को दोबारा शुरू किए बिना अतिरिक्त प्रॉम्प्ट दर्ज कर सकते हैं।

चरण 3: Bonsai सर्वर शुरू करें

पहले, पिछली स्टेप के इंटरैक्टिव CLI सेशन को बंद करने के लिए Ctrl+C दबाएँ।

फिर लोकल Bonsai सर्वर शुरू करें:

BONSAI_FAMILY=bonsai \
BONSAI_MODEL=27B \
BONSAI_CTX=100000 \
./scripts/start_llama_server.sh \
--alias bonsai-27b \
--host 0.0.0.0 \
--port 8910संचालित द्वारा

यह कमांड:

• 1-बिट Bonsai 27B मॉडल लोड करता है
• 100,000-टोकन कॉन्टेक्स्ट विंडो आवंटित करता है
• मॉडल को bonsai-27b नाम से रजिस्टर करता है
• पोर्ट 8910 पर सर्वर शुरू करता है
• इसे लोकल मशीन और उसी नेटवर्क के अन्य डिवाइस से सुलभ बनाता है

100,000-टोकन कॉन्टेक्सस्ट विंडो पहले किए गए 8,192-टोकन CLI परीक्षण से कहीं अधिक मेमोरी मांगती है। यदि मॉडल शुरू नहीं होता या आपका सिस्टम RAM/VRAM से बाहर हो जाता है, तो BONSAI_CTX कम करें।

क्योंकि --host 0.0.0.0 सर्वर को आपके लोकल नेटवर्क पर एक्सपोज़ करता है, किसी अविश्वसनीय नेटवर्क पर इसका उपयोग करने से बचें। केवल लोकल एक्सेस के लिए, इसे इस प्रकार बदलें:

--host 127.0.0.1संचालित द्वारा

मॉडल का उपयोग करते समय यह टर्मिनल खुला रखें। इसे बंद करने पर सर्वर रुक जाएगा।

Bonsai सर्वर प्रदान करता है:

• हल्का लोकल वेब इंटरफ़ेस
• एक OpenAI-संगत API
• स्ट्रीमिंग प्रतिक्रियाएँ
• स्ट्रक्चर्ड टूल कॉलिंग
• मॉडल-विशिष्ट रीजनिंग कंट्रोल्स

OpenAI-संगत API यहाँ उपलब्ध है:

http://127.0.0.1:8910/v1संचालित द्वारा

चरण 4: CURL से Bonsai 27B का परीक्षण

दूसरा टर्मिनल खोलें और चैट-कम्प्लीशन एंडपॉइंट पर एक अनुरोध भेजें:

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
  }'संचालित द्वारा

यह अनुरोध OpenAI Chat Completions API जैसी ही संरचना का उपयोग करता है:

• model पहले बनाए गए सर्वर उपनाम (एलिएस) का चयन करता है
• messages बातचीत (कन्वर्सेशन) रखता है
• max_tokens जनरेट किए जाने वाले टोकन्स की अधिकतम संख्या सीमित करता है

API ने लगभग 95 टोकन्स प्रति सेकंड की दर से JSON लौटाया, लेकिन प्रतिक्रिया 1,000-टोकन सीमा पर रुक गई, इसलिए Bonsai को ऐप्लिकेशनों, एजेंट्स, या Python प्रोग्राम्स से जोड़ने से पहले "max_tokens" को 3000 तक बढ़ाएँ ताकि पूरा उत्तर मिल सके।

चरण 5: Bonsai 27B वेब UI का परीक्षण

अपने ब्राउज़र में निम्न पता खोलें:

http://127.0.0.1:8910संचालित द्वारा

इन-बिल्ट llama.cpp इंटरफ़ेस आपको Bonsai से चैट करने, फ़ाइलें अपलोड करने और रीजनिंग प्रयास को Off से Max तक समायोजित करने देता है।

इसे ऐसे कोडिंग प्रॉम्प्ट से परखें:

Create a Python command-line application that converts CSV files to JSON.संचालित द्वारा

Bonsai ने लगभग 92 टोकन्स प्रति सेकंड की दर से एक पूरा Python स्क्रिप्ट जनरेट किया, मेरे RTX 5070 Ti पर। 

मैंने इसे पर्सनल पोर्टफोलियो वेबसाइट बनाने को भी कहा। 

हालाँकि कोड काम कर गया, मैं बने हुए UI से संतुष्ट नहीं था, क्योंकि डिज़ाइन बुनियादी और जनरिक लगा। 

इससे संकेत मिलता है कि Bonsai फ़ंक्शनल कोड बना सकता है, पर एक परिष्कृत इंटरफ़ेस के लिए अधिक विस्तृत प्रॉम्प्ट और कई संशोधनों की आवश्यकता हो सकती है।

चरण 6: Pi कोडिंग एजेंट इंस्टॉल करें

Pi एक टर्मिनल-आधारित कोडिंग एजेंट है, जिसका उपयोग हम उसके लोकल OpenAI-संगत API के माध्यम से एक वास्तविक एजेंटिक कोडिंग वर्कफ़्लो में Bonsai 27B का परीक्षण करने के लिए करते हैं।

एक नया टर्मिनल खोलें और Pi कोडिंग एजेंट इंस्टॉल करें:

curl -fsSL https://pi.dev/install.sh | shसंचालित द्वारा

प्रॉम्प्ट आने पर, डिफ़ॉल्ट इंस्टॉलेशन जारी रखने के लिए Enter दबाएँ या y टाइप करें।

सुनिश्चित करें कि Pi सफलतापूर्वक इंस्टॉल हुआ है:

pi --versionसंचालित द्वारा

टेस्ट के समय, इंस्टॉल्ड संस्करण था:

0.82.0संचालित द्वारा

चरण 7: Pi में Bonsai 27B जोड़ें

सुनिश्चित करें कि Bonsai सर्वर अभी भी चल रहा है, फिर एक नया टर्मिनल लॉन्च करें और Pi का कॉन्फ़िगरेशन डायरेक्टरी बनाएँ:

mkdir -p ~/.pi/agentसंचालित द्वारा

कस्टम मॉडल कॉन्फ़िगरेशन फ़ाइल बनाएँ:

nano ~/.pi/agent/models.jsonसंचालित द्वारा

निम्नलिखित कॉन्फ़िगरेशन पेस्ट करें:

{
  "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
          }
        }
      ]
    }
  }
}संचालित द्वारा

यह कॉन्फ़िगरेशन Pi को लोकल OpenAI-संगत एंडपॉइंट से जोड़ता है, मॉडल को Bonsai 27B Local के रूप में रजिस्टर करता है, और सर्वर की 100,000-टोकन कॉन्टेक्स्ट सेटिंग से मेल खाता है।

फ़ाइल को सेव करें और बंद करें:

Ctrl + O
Enter
Ctrl + Xसंचालित द्वारा

Pi, ~/.pi/agent/models.json से कस्टम मॉडल प्रोवाइडर्स को अपने आप लोड कर लेता है।

चरण 8: Bonsai 27B के साथ Pi चलाएँ

सुनिश्चित करें कि Bonsai सर्वर अभी भी चल रहा है, फिर नया प्रोजेक्ट डायरेक्टरी बनाएं:

mkdir simple-python
cd simple-pythonसंचालित द्वारा

लोकल Bonsai मॉडल के साथ Pi शुरू करें:

pi --provider bonsai-local --model bonsai-27bसंचालित द्वारा

ऐसा प्रॉम्प्ट दर्ज करें:

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.संचालित द्वारा

Pi ने रीजनिंग शुरू की, प्रोजेक्ट फ़ाइलें बनाईं, आवश्यक पैकेज इंस्टॉल किए, और FastAPI बैकएंड तथा रेस्पॉन्सिव फ्रंटएंड के साथ एक टेक्स्ट-विश्लेषण ऐप्लिकेशन तैयार किया।

जब मॉडल 100,000-टोकन कॉन्टेक्स्ट विंडो के साथ चल रहा था, तो nvidia-smi ने मेरे RTX 5070 Ti पर लगभग 11.9 GB VRAM उपयोग दिखाया:

रन के अंत में, Pi ने पुष्टि की कि कार्य पूरा हो गया है और उसने जो भी किया उसका स्पष्ट सारांश दिया। 

इसमें बनाई गई फ़ाइलें, ऐप्लिकेशन की मुख्य विशेषताएँ, किए गए परीक्षण, और प्रोजेक्ट को लोकली चलाने के लिए आवश्यक सटीक कमांड शामिल थे। 

जनरेशन के बाद, Pi ने बनाई गई फ़ाइलों और फ़ीचर्स का सार भी दिया। 

मैंने बैकएंड को इस प्रकार टेस्ट किया:

curl -s -X POST http://localhost:10100/analyze \
  -H "Content-Type: application/json" \
  -d '{"text":"Hello world! This is a test."}'संचालित द्वारा

API ने काम किया, और इंटरफ़ेस, बेसिक वेब UI से जनरेट की गई पिछली वेबसाइट की तुलना में बेहतर दिखा। 

हालाँकि, ऐप अब भी अधूरा था: कुछ बटन और कंट्रोल गायब थे, और फ्रंटएंड बैकएंड API से उपलब्ध सभी आँकड़े प्रदर्शित नहीं कर रहा था। 

यह दिखाता है कि Bonsai एक फ़ंक्शनल फुल-स्टैक ऐप बना सकता है, लेकिन परिणाम को अब भी परीक्षण और परिष्करण की ज़रूरत होगी।

अंतिम विचार

मेरे परीक्षण में, Bonsai 27B अब भी एक भारी कंप्रेस्ड मॉडल जैसा महसूस होता है। 

इसकी आउटपुट गुणवत्ता Q4-क्वांटाइज़्ड Qwen3.6-27B के बराबर नहीं है, जिसे मैंने पहले टेस्ट किया है और कोडिंग-एजेंट वर्कफ़्लो के लिए अधिक भरोसेमंद पाया। 

Q4 संस्करण अधिक मेमोरी मांगता है, लेकिन बेहतर रीजनिंग, उच्च गुणवत्ता का कोड जनरेशन, और अधिक स्थिर परिणाम देता है।

फिर भी, लगभग 3.8 GB फ़ुटप्रिंट वाले मॉडल के लिए Bonsai 27B उल्लेखनीय रूप से सक्षम है।

यह निर्देश समझता है, प्रोजेक्ट फ़ाइलें बनाता है, कमांड चलाता है, अपना कार्य टेस्ट करता है, और लोकली फ़ंक्शनल ऐप्लिकेशन बना सकता है। इस साइज़ श्रेणी में, यह सबसे सक्षम मॉडलों में से एक है जो मैंने आज़माया है।

गंभीर कोडिंग-एजेंट कार्य के लिए, मैं अब भी Qwen3.6-27B के Q4 संस्करण को चुनूँगा, खासकर क्योंकि मेरे RTX 3090 में 24 GB VRAM है और वह बड़े मॉडल को आराम से संभाल सकता है। 

इसके बावजूद, मुझे Bonsai 27B का उपयोग करना बहुत अच्छा लगा और मैं व्यापक Prism ML इकोसिस्टम से प्रभावित हुआ। इसका ऑटोमेटेड सेटअप, ऑप्टिमाइज़्ड रनटाइम, इन-बिल्ट वेब इंटरफ़ेस, OpenAI-संगत API, और एजेंट इंटीग्रेशन—ये सब अधिक लोगों के लिए कंज़्यूमर हार्डवेयर पर लोकली एक बड़े रीजनिंग मॉडल को चलाना और अनुभव करना कहीं आसान बनाते हैं।