Muse Glimmer 30B’yi Yerelde AI Kodlama İçin Nasıl Çalıştırırsınız

Blog yazımızda incelediğimiz gibi, Muse Glimmer 30B, ajans ve kodlama iş yükleri için oluşturulmuş yeni bir açık modeldir. 

Onu özellikle ilginç kılan, tüm kurulumu tek bir NVIDIA RTX 5090 (32 GB VRAM) üzerinde llama.cpp kullanarak yerelde çalıştırabilmenizdir.

Model GGUF formatında sunuluyor; bu rehberde daha kaliteli olan dinamik nicelemeyi kullanacağım. 

Tam kurulum şunlardan oluşur:

• muse-glimmer-30B-kquant-dynamic.gguf: 19,7 GB ana model
• dflash-kquant.gguf: 1,63 GB spekülatif çözümleme için taslak model
• mmproj-kquant.gguf: 1,4 GB görsel ve algı kodlayıcı

Model kartına göre, 19,7 GB’lık dinamik niceleme tam kesinliğe kıyasla yalnızca yaklaşık %0,2 kıyaslama bozulmasına sahip. 

Kendi testlerimde, modeli 64K bağlam penceresiyle çalıştırmak yaklaşık 24 GB VRAM kullandı ve RTX 5090’da faydalı bir boşluk bıraktı.

Bu rehberde şunları öğreneceksiniz:

1. CUDA desteğiyle llama.cpp derlemek
2. Muse Glimmer 30B’yi yerelde indirip çalıştırmak
3. DFlash spekülatif çözümleme ve görsel girdiyi etkinleştirmek
4. Modeli API ve yerleşik Web UI üzerinden test etmek
5. Yerel modeli OpenCode’a bağlamak
6. Muse Glimmer ile eksiksiz bir uygulama geliştirmek ve hata ayıklamak

Sonunda, Muse Glimmer’ın yerel bir kodlama modeli olarak nerede iyi performans gösterdiğine ve nerede zorlandığına dair pratik bir fikir de edineceğiz. Ayrıca en son özelliklerini öğrenmek için Muse Spark 1.3 rehberimize göz atmanızı öneririm.

1. GPU Çıkarımı için llama.cpp’yi Kurun

Muse Glimmer’ı yerelde çalıştırmadan önce, modelin RTX 5090 GPU’yu kullanabilmesi için llama.cpp’yi CUDA desteğiyle derlememiz gerekiyor.

Önce gerekli sistem paketlerini kurun:

apt-get update

apt-get install -y \
    build-essential \
    cmake \
    curl \
    git \
    libcurl4-openssl-dev

Ardından llama.cpp deposunu klonlayın ve proje dizinine geçin:

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp

CUDA etkin olacak şekilde derlemeyi yapılandırın:

cmake -B build \
    -DBUILD_SHARED_LIBS=OFF \
    -DGGML_CUDA=ON

Komut satırı araçlarını, çok kipli CLI’yi ve sunucuyu derleyin:

cmake --build build --config Release -j \
    --target llama-cli llama-mtmd-cli llama-server

Derleme tamamlandıktan sonra, llama-server’ı her dizinden çalıştırabilmek için sisteme genel olarak erişilebilir hale getirin:

ln -sf "$(pwd)/build/bin/llama-server" /usr/local/bin/llama-server

Son olarak, kurulumun çalıştığını doğrulayın:

llama-server --version

Benzer bir çıktı görmelisiniz:

version: 10373 (38406d597)
built with GNU 13.3.0 for Linux x86_64

Bu noktada, llama.cpp CUDA desteğiyle derlenmiş olur ve llama-server GPU üzerinde Muse Glimmer’ı çalıştırmaya hazırdır.

2. Muse Glimmer’ı İndirin

Şimdi ana Muse Glimmer modelini, spekülatif çözümleme ve görsel girdi için gerekli ek GGUF dosyalarıyla birlikte indirin.

İlk olarak Hugging Face CLI’ı kurun:

pip install -U huggingface_hub

Sonra Hugging Face hesabınıza giriş yapın:

hf auth login

Tarayıcıyla giriş seçeneğini seçin, yetkilendirme sayfasını açın ve tarayıcınızda bağlantıyı onaylayın.

Şimdi gerekli üç dosyayı indirin:

hf download meta-models/Muse-Glimmer-30B-GGUF \
    --local-dir Muse-Glimmer-30B-GGUF \
    --include "muse-glimmer-30B-kquant-dynamic.gguf" \
    --include "dflash-kquant.gguf" \
    --include "mmproj-kquant.gguf"

Bu işlem şunları indirir:

• muse-glimmer-30B-kquant-dynamic.gguf: 19,7 GB ana model
• dflash-kquant.gguf: spekülatif çözümlemede kullanılan taslak model
• mmproj-kquant.gguf: görsel girdi için gereken algı kodlayıcı

Dosyalar oldukça büyük; internet bağlantınıza bağlı olarak indirme işlemi biraz zaman alabilir.

Üç dosyanın tümü indirildiğinde, metin üretimi, görsel destek ve DFlash spekülatif çözümleme ile Muse Glimmer’ı çalıştırmak için gereken her şeye sahip olacaksınız.

3. Muse Glimmer’ı Görsel ve Spekülatif Çözümleme ile Sunun

Üç GGUF dosyasını da indirdikten sonra, şimdi llama-server kullanarak Muse Glimmer’ı başlatabiliriz.

Aşağıdaki komut ana modeli yükler, spekülatif çözümleme için DFlash taslak modelini etkinleştirir ve görsel girdi için algı kodlayıcıyı ekler:

llama-server \
    -m /workspace/Muse-Glimmer-30B-GGUF/muse-glimmer-30B-kquant-dynamic.gguf \
    -md /workspace/Muse-Glimmer-30B-GGUF/dflash-kquant.gguf \
    --mmproj /workspace/Muse-Glimmer-30B-GGUF/mmproj-kquant.gguf \
    --spec-type draft-dflash \
    --spec-draft-n-max 15 \
    -ngl 99 \
    --spec-draft-ngl all \
    -fa on \
    --temp 1.0 \
    --top-p 0.95 \
    --top-k 64 \
    --ctx-size 64000 \
    --alias muse-glimmer-30B \
    --host 0.0.0.0 \
    --port 8910 \
    --jinja

Bu yapılandırma 64K bağlam penceresi kullanır, modeli GPU’ya aktarır, Flash Attention’ı etkinleştirir ve sunucuyu 8910 portunda çalıştırır.

Model yüklendikten sonra şu adreste kullanılabilir:

http://127.0.0.1:8910

Her şeyin doğru çalıştığını, OpenAI uyumlu API’ye basit bir istek göndererek doğrulayabilirsiniz:

curl -s http://127.0.0.1:8910/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "muse-glimmer-30B",
        "messages": [
            {
                "role": "user",
                "content": "Explain speculative decoding in three simple sentences."
            }
        ]
    }'

Bu testte, Muse Glimmer 83,94 token/saniye hızla 364 tamamlama token’ı oluşturdu; istem ise 147,48 token/saniye hızında işlendi. 

DFlash spekülatif çözümleme etkinleştirildiğinde, taslak model 1.665 token önerdi; bunların 253’ü kabul edildi ve yaklaşık %15,2 kabul oranı elde edildi. 

64 token’lık istem yaklaşık 434 ms’de işlendi; üretim ise yaklaşık 4,34 saniye sürdü. 

Bu yanıt, modelin yerel API üzerinden doğru şekilde çalıştığını doğrular.

Ayrıca, tam kurulumuın ne kadar GPU belleği kullandığını da kontrol edebilirsiniz:

nvidia-smi

30B dinamik nicelemeli model, DFlash taslak model, görsel kodlayıcı ve 64K bağlam penceresi birlikte yüklendiğinde, kurulumum RTX 5090 üzerinde yaklaşık 23,8 GB VRAM kullandı.

Bu da yaklaşık 8 GB VRAM’i boşta bırakır; ileride daha büyük bağlam pencereleriyle denemeler yapmamız için alan sağlar.

4. Muse Glimmer’ı Web UI’de Görsel ve Kodlama İstemleriyle Test Edin

llama-server yerleşik bir Web UI ile gelir; bu sayede modele elle API isteği göndermeden kolayca test yapabilirsiniz.

Şunu açın:

http://127.0.0.1:8910

Arayüzü normal metin istemleri, görsel anlama ve hızlı kodlama denemeleri için kullanabilirsiniz.

Görsel kodlayıcıyı şu seçenekle yüklediğimiz için:

--mmproj /workspace/Muse-Glimmer-30B-GGUF/mmproj-kquant.gguf

Muse Glimmer görsel girdi de kabul edebilir.

Görsel yeteneğini test etmek için, kitaplarımdan birinin kapağını yükledim ve şu istemi kullandım:

Describe what you see in this image and point out the most important details.

Model, kapağa dair ayrıntılı bir açıklama üretti ve birkaç küçük görsel unsuru da yakaladı. 

Bu, görsel kodlayıcının doğru çalıştığını teyit etmek için faydalı bir ilk testti.

Sonraki adımda, basit bir web sitesi oluşturma göreviyle kodlama yeteneğini test ettim:

Build a modern luxury watch website for VELORÉ, 
with a minimalist V logo, black/ivory/deep-green palette, 
cinematic hero, premium watches, smooth animations, 
and elegant Swiss-inspired styling.

Bu kodlama görevinde üretim ortalama olarak saniyede 121 token civarındaydı; bu da önceki genel metin testinden belirgin biçimde daha hızlıydı. 

DFlash spekülatif çözümleme, bu tür sıralı kod üretimi iş yükünde özellikle iyi çalışıyor gibi göründü.

Model, kullanılabilir bir lüks saat web sitesi üretti. 

Son çıktıda hâlâ birkaç sorun vardı; bu, 30B bir model için çok da şaşırtıcı değil; ancak çok hızlı biçimde eksiksiz bir proje ortaya koyabildi.

Muse Glimmer bir ajans kodlama modeli olarak konumlandırılıyor; bu yüzden daha önemli test, dosya oluşturması, komut çalıştırması, kendi işini test etmesi ve sorunları düzeltmesi gerektiğinde nasıl performans gösterdiği. Bunu, OpenCode’a bağlayarak test edeceğiz.

5. Muse Glimmer’ı OpenCode’a Bağlayın ve Ajans Kodlamayı Test Edin

Muse Glimmer artık yerelde çalıştığına göre, sonraki adım onu OpenCode’a bağlamak ve ajans kodlama modeli olarak nasıl performans gösterdiğini görmektir.

Önce OpenCode’u kurun:

curl -fsSL https://opencode.ai/install | bash

Kabuğu yeniden yükleyin ve kurulumu doğrulayın:

exec bash
opencode --version

Bu testte kullandığım sürüm:

1.18.16

OpenCode yapılandırma dizinini oluşturun:

mkdir -p ~/.config/opencode

Bir metin düzenleyici açmak yerine, yapılandırma dosyasını doğrudan terminalden oluşturun:

cat > ~/.config/opencode/opencode.json <<'EOF'
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "llama.cpp": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Muse Glimmer Local",
      "options": {
        "baseURL": "http://127.0.0.1:8910/v1"
      },
      "models": {
        "muse-glimmer-30B": {
          "name": "Muse Glimmer 30B"
        }
      }
    }
  },
  "model": "llama.cpp/muse-glimmer-30B"
}
EOF

Bu, OpenCode’a yerel llama-server örneğimizin sunduğu OpenAI uyumlu API’yi kullanmasını söyler.

Şimdi yeni bir proje oluşturun:

mkdir muse-app
cd muse-app
git init
opencode

OpenCode, terminal arayüzünü Muse Glimmer 30B ana model olarak zaten yapılandırılmış şekilde başlatacaktır.

Eksiksiz bir uygulama oluşturun

Modeli daha gerçekçi bir şey üzerinde test etmek için, ondan bir tıbbi araştırma uygulaması oluşturmasını istedim:

Build a modern medical AI web app called MedSearch AI.
Use Python FastAPI for the backend and HTML, CSS and JavaScript for the frontend.
Create a clean dark interface where users can ask medical research questions. 
Send prompts to my local Muse Glimmer server at:http://127.0.0.1:8910/v1/chat/completions
Add web search for the latest reliable medical information, show sources clearly, 
support streaming responses and Markdown, and include a clear-chat button and server status indicator.

Create all files, install dependencies, test the app, and tell me how to run it.

İlk sonuç etkileyiciydi. Tüm projeyi oluşturması yalnızca yaklaşık bir dakika sürdü. 

Arka uç, ön uç, bağımlılıklar ve genel uygulama yapısını çok hızlı bir şekilde oluşturdu.

Ardından, hem arka ucu hem de arayüzü test etmesini istedim.

İşte bu noktada modelin zayıf yönlerini fark etmeye başladım.

Oluşturmada hızlı, hata ayıklamada zayıf

Yapay kodlama kıyaslamalarında, Muse Glimmer Qwen3.6 27B modeliyle benzer sıralarda yer alıyor; ancak kendi testlerime göre, gerçek bir kodlama görevini yürütürken belirgin biçimde daha zayıf.

En büyük sorun hata ayıklamaydı.

Muse Glimmer sıfırdan eksiksiz bir proje oluşturmada çok hızlıydı; ancak bir şeyler ters gittiğinde, sorunu kendi başına çözüme kavuşturmakta zorlandı. Çok fazla zaman harcayıp farklı şeyler denediği halde fazla ilerleme kaydedemedi.

Sonunda ona ne yapması gerektiğini tam olarak söylemek zorunda kaldım. 

Örneğin, açıkça şu talimatları verdim:

1. Arka uç sunucusunu arka planda başlat.
2. Sunucunun kullanılabilir olmasını bekle.
3. Çalışan uygulamaya bir istek gönder.
4. Yanıtı kontrol et.
5. Karşılaştığı hataları düzelt.
6. Uygulamayı tekrar test et.

Bu somut adımları verdiğimde, görevi anladı ve başarıyla uyguladı.

Muhtemelen OpenCode ile Muse Glimmer’ı kullanmaktan çıkardığım en büyük ders buydu. 

Ondan ne yapmasını istediğinizi çok net şekilde belirtmeniz gerekiyor. 

“Uygulamayı test et” veya “sorunu düzelt” demek yerine, atması gereken adımların tam sırasını tarif ettiğinizde çok daha iyi çalışıyor.

Bu modelde istem mühendisliği bu nedenle özellikle önemli.

Nihai uygulama

Hata ayıklama sorunlarını aştıktan sonra, ortaya çıkan MedSearch AI uygulaması çok iyi çalıştı.

Uygulama hızlı, zengin özellikli ve şaşırtıcı derecede yalındı. 

Büyük bir ön uç çerçevesine dayanmak yerine yalın HTML, CSS ve JavaScript ile hafif bir FastAPI arka ucu kullandı.

Aslında bu sadelik, sonuçta hoşuma giden unsurlardan biriydi. 

Muse Glimmer, gereksiz karmaşıklık katmadan işlevsel bir AI uygulaması oluşturdu.

Şu ana kadarki deneyimim, Muse Glimmer’ın çok kısa sürede çok miktarda çalışan kod üretmede mükemmel olduğu; ancak sorun teşhisi, çok adımlı hata ayıklama planlama ve hatalardan kendi başına toparlanma konularında çok daha az güvenilir olduğudur.

Yerel kodlama için bu ayrım önemlidir. 

Açık ve ayrıntılı talimatlar verirseniz, oldukça yetkin olabilir. 

Her adımı kendi başına bulmasını beklerseniz, özellikle hata ayıklama sırasında sınırlamalar çok daha belirginleşir.

Son Düşünceler

Muse Glimmer 30B hâlâ çok yeni bir model ve bu, testlerimde de ortaya çıktı. 

Kod üretmede çok hızlıydı; ancak hata ayıklama ve çok adımlı görevlerde daha fazla zorlandı. İlerleyebilmesi için ona sıklıkla tam olarak ne yapması gerektiğini söylemek zorunda kaldım.

Bu sorunlara rağmen, modelin büyük bir potansiyele sahip olduğunu düşünüyorum. 

Daha iyi istemler ve gelecekteki iyileştirmelerle, Qwen3.6 27B ile yaşadığım deneyime benzer şekilde, oldukça kullanılabilir bir yerel kodlama modeli haline gelebilir.

Meta AI için bunun harika bir yönelim olduğunu da düşünüyorum. 

Yerel kodlama ajanlarına yönelik net bir ilgi var; çünkü şunları sunabiliyorlar:

• API ücreti olmadan daha düşük maliyet
• Kodunuz ve verileriniz için daha iyi gizlilik
• Çıktı üzerinde daha fazla kontrol
• Harici bir model API’sine bağlı olmadan yerelde çalışma imkânı

Benim kurulumumda model yaklaşık 24 GB GPU belleği kullandı; bu da yüksek seviye yerel donanım için onu pratik kılıyor. 

Bunun gibi modelleri sistem belleği veya birleştirilmiş bellekle de çalıştırabilirsiniz; ancak performans daha yavaş olacaktır.

Bu rehberde, llama.cpp’yi derledik, Muse Glimmer GGUF dosyalarını indirdik, görsel ve spekülatif çözümlemeyi etkinleştirdik, API ve Web UI’yi test ettik ve modeli OpenCode’a bağladık. 

Ayrıca bunu kullanarak eksiksiz bir uygulama geliştirip test ettik. 

Ana çıkarımım; Muse Glimmer’ın kod oluşturma konusunda çok hızlı olduğu; ancak hata ayıklarken veya daha karmaşık ajans görevlerinde net talimatlara hâlâ ihtiyaç duyduğudur.