Cómo configurar Muse Glimmer MLX en Mac: guía del backend SGLang

Meta lanzó Muse Glimmer 30B el 10 de agosto de 2026 como un modelo multimodal denso de pesos abiertos. En Mac, sin embargo, los primeros intentos se toparon con el mismo obstáculo: varios runtimes de MLX devolvían model type muse_glimmer not supported, ya que sus cargadores aún no reconocían una arquitectura tan reciente.

El backend MLX de SGLang ofrece una vía funcional. Hay que compilarlo desde el código fuente, usar Python 3.11 y activar una única variable de entorno. A cambio, tendrás una API compatible con OpenAI a la que pueden conectarse directamente agentes de programación e interfaces de chat. Esta guía reúne en un solo recorrido los pasos y soluciones del issue de hoja de ruta #19137 de SGLang.

Requisitos para empezar

Muse Glimmer 30B es un modelo multimodal denso de 30.000 millones de parámetros. Con cuantización MLX de 4 bits, solo los pesos ocupan aproximadamente 16-18 GB; si añades la caché KV para una ventana de contexto de 32K tokens, necesitarás unos 18-20 GB de memoria de trabajo. Además, la hoja de ruta de SGLang limita el uso de memoria al tamaño máximo recomendado del conjunto de trabajo por Metal (PR #21539), por lo que el límite práctico queda por debajo de la memoria unificada total del equipo.

Como señaló un usuario de Reddit en r/opencodeCLI cuando se publicaron los pesos:

"Los Mac con 32 GB o más de memoria unificada deberían poder usar cuantizaciones más altas."

También necesitas macOS 13.5 o posterior para disponer de soporte Metal, las Xcode Command Line Tools y Homebrew. El backend MLX de SGLang solo se ha verificado con Python 3.11; otras versiones pueden fallar, tal como advierte expresamente la hoja de ruta.

Paso 1: instala Python 3.11, uv y MLX

La instalación de SGLang en Mac comienza con dos paquetes de Homebrew y un entorno virtual de Python 3.11 administrado con uv.

1. Instala las dependencias de Homebrew:

brew install ffmpeg uv

ffmpeg se ocupa de las canalizaciones de procesamiento de audio y contenido multimodal; uv es el gestor rápido de paquetes de Python que la hoja de ruta de SGLang recomienda para crear el entorno virtual.

1. Clona el repositorio de SGLang:

git clone https://github.com/sgl-project/sglang.git
cd sglang

1. Crea y activa un entorno con Python 3.11:

uv venv -p 3.11 my-venv
source my-venv/bin/activate
python -m pip install --upgrade pip

No uses Python 3.12 ni 3.13. El issue de la hoja de ruta documenta que las importaciones de stubs de Triton fallan en Python 3.12+; se corrigió en la PR #21551, pero no se ha verificado por completo. La cadena de compilación de MLX, por su parte, solo se ha probado con 3.11.

1. Instala las versiones más recientes de los paquetes runtime de MLX:

pip install mlx mlx-lm mlx-vlm --upgrade

La hoja de ruta advierte específicamente que usar versiones antiguas de mlx o mlx-lm genera trazas de perfilado ruidosas y fallos al detectar la arquitectura. La PR #22162 los añadió como dependencias explícitas de SGLang. mlx-vlm es necesario para modelos multimodales como Muse Glimmer; sin él aparecerá el error model type muse_glimmer not supported al iniciar.

Paso 2: compila SGLang desde el código fuente con MLX

El paquete estándar pip install sglang no incluye soporte MLX. En macOS debes compilar desde el código fuente con los extras de Apple MPS.

1. Sustituye el pyproject.toml:

cp python/pyproject.toml python/pyproject.toml.bak
cp python/pyproject_other.toml python/pyproject.toml

El archivo pyproject_other.toml elimina las dependencias exclusivas de CUDA que no se pueden compilar en macOS y las reemplaza por alternativas compatibles con MPS.

1. Instala SGLang en modo editable con los extras MPS:

uv pip install -e "python[all_mps]"

Esto compila los stubs de kernel Metal e instala la ruta de ejecución para Apple Silicon. La compilación tarda varios minutos según el Mac; las compilaciones Metal de sgl-kernel (PR #23449) son la parte más lenta.

1. Comprueba la instalación:

python -c "import sglang; print(sglang.__version__)"

Si se importa sin un error de Triton, la ruta MPS está correctamente configurada.

Paso 3: descarga el modelo Muse Glimmer para MLX

MLX Community ha publicado en Hugging Face una versión cuantizada a 4 bits de Muse Glimmer:

huggingface-cli download mlx-community/Muse-Glimmer-30B-4bit

Si no tienes instalado huggingface-cli, añádelo primero:

pip install huggingface-hub

La descarga ocupa aproximadamente 16-17 GB. De forma predeterminada, huggingface-cli download guarda el modelo en ~/.cache/huggingface/hub/. SGLang puede resolver directamente el ID del repositorio de Hugging Face en --model-path, aunque también puedes indicar la ruta del directorio de caché local.

Cálculo rápido de memoria:

Esto permite a un Mac de 32 GB cargar el modelo, pero deja poco margen para ventanas de contexto grandes. Si el servidor inicia pero se cierra al procesar el primer prompt largo, reduce --context-length a 8192 o 16384.

Paso 4: inicia el servidor de SGLang

Con las dependencias instaladas y el modelo descargado, el comando de inicio ocupa una sola línea, pero la variable de entorno es imprescindible:

SGLANG_USE_MLX=1 python -m sglang.launch_server \
  --model-path mlx-community/Muse-Glimmer-30B-4bit \
  --port 30000 \
  --context-length 32768

Para qué sirve cada opción:

• SGLANG_USE_MLX=1 activa el backend de ejecución nativo de MLX, en lugar de recurrir a PyTorch MPS o a la CPU. Sin esta variable, el servidor inicia, pero funciona a una fracción de la velocidad.
• --model-path señala el modelo de 4 bits en formato MLX. La PR #25191 de SGLang añadió la detección automática de quantization_config en formato MLX, por lo que debería reconocerlo sin opciones adicionales.
• --context-length establece el límite de la ventana de contexto. Reduce este valor si tienes presión de memoria. Según las pruebas de la comunidad y las notas de lanzamiento de Meta, Muse Glimmer admite teóricamente hasta 262K tokens, pero en un Mac con memoria unificada el límite práctico es bastante menor.

Avanzado: SGLang también permite cuantizar sobre la marcha pesos BF16 mediante --quantization mlx_q4 o mlx_q8 (PR #24907). El arranque tarda más que al cargar un modelo de 4 bits ya preparado, así que úsalo solo si necesitas controlar el proceso de cuantización.

Paso 5: comprueba la API compatible con OpenAI

Cuando el servidor muestre Server is ready, prueba el endpoint compatible con OpenAI mediante una petición curl:

curl http://localhost:30000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "muse-glimmer",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "Explain how GQA reduces KV cache size in one sentence."}
    ],
    "max_tokens": 200
  }'

Una respuesta correcta devuelve un objeto JSON con la completación. En un M5 Pro con el modelo de 4 bits, puedes esperar aproximadamente 17.6 tokens/second en decodificación para un único usuario, según los datos de benchmark de la hoja de ruta de SGLang.

Importante: asigna un valor generoso a max_tokens (200+). Muse Glimmer sigue un diseño de razonamiento previo, donde los tokens de cadena de pensamiento pueden consumir gran parte del presupuesto de salida. Si parece generar respuestas vacías o truncadas, la causa más habitual es que max_tokens sea demasiado bajo: el razonamiento agota todo el presupuesto antes de que aparezca la respuesta.

Variables de ajuste de MLX

SGLang expone tres variables de entorno específicas de MLX documentadas en la referencia oficial de variables de entorno. Las tres vienen desactivadas o con valores conservadores de forma predeterminada.

Ejemplo con los ajustes activados:

SGLANG_USE_MLX=1 \
SGLANG_MLX_USE_CUSTOM_ROPE=true \
SGLANG_MLX_FUSE_SWIGLU=true \
SGLANG_MLX_CLEAR_CACHE_STEPS=128 \
python -m sglang.launch_server \
  --model-path mlx-community/Muse-Glimmer-30B-4bit \
  --port 30000 \
  --context-length 32768

Son funciones experimentales incluidas en la hoja de ruta. Si al activar cualquiera de las opciones de fusión de kernels se produce un cierre inesperado, desactívala y envía un informe: el backend MLX sigue en desarrollo activo.

Errores habituales y cómo resolverlos

"Model type muse_glimmer not supported"

Es el error más frecuente durante los primeros días. Indica que tu runtime MLX, mlx-lm o mlx-vlm, no reconoce el tipo de arquitectura muse_glimmer. Solución:

pip install mlx-lm mlx-vlm --upgrade

Si el error continúa, comprueba si tu copia de SGLang incluye la PR de soporte MLX para Qwen3 dense (#25754), que añadió reescrituras de arquitectura para modelos transformer densos. Puede que necesites ejecutar git pull en la rama main más reciente para incorporar el soporte necesario.

Fallo de stubs de Triton con Python 3.12

La configuración de SGLang importa stubs de Triton incompatibles con Python 3.12+. La solución consiste en recrear el entorno virtual con Python 3.11:

deactivate
rm -rf my-venv
uv venv -p 3.11 my-venv
source my-venv/bin/activate
uv pip install -e "python[all_mps]"

La PR #21551 corrigió la ruta de importación de Triton, pero Python 3.11 sigue siendo la única versión verificada por completo.

El servidor inicia, pero usa la CPU

Si la generación es extremadamente lenta, por debajo de 2 tokens por segundo, es probable que SGLang haya recurrido a la CPU porque no se exportó SGLANG_USE_MLX=1. Compruébalo:

echo $SGLANG_USE_MLX

Si no devuelve nada, exporta la variable antes de iniciar el servidor o añádela al principio del comando de inicio.

Cierre por memoria MLX o reinicio del sistema

Superar el tamaño de conjunto de trabajo recomendado por Metal puede provocar el cierre del servidor o, en los casos más graves, un reinicio completo de macOS. La hoja de ruta añadió el límite de conjunto de trabajo en la PR #21539 para mitigarlo, pero las ventanas de contexto grandes aún pueden excederlo. Solución:

• Reduce --context-length a 8192 o menos
• Configura SGLANG_MLX_CLEAR_CACHE_STEPS=64 para limpiar la caché con mayor frecuencia
• Usa el modelo de 4 bits en lugar de cuantizar sobre la marcha desde pesos BF16
• Cierra otras aplicaciones intensivas para la GPU, especialmente Safari con aceleración por hardware

Bucles de llamadas a herramientas o resultados vacíos

Hilos de la comunidad en r/LocalLLaMA informan de que las llamadas a herramientas de Muse Glimmer son inconsistentes entre cuantizaciones. Usuarios que probaron tanto las variantes MLX como GGUF han detectado bucles de tool calling. El problema no es exclusivo de MLX: aparece en distintos runtimes. Configura max_tokens en 500+ al usar llamadas a funciones, prueba primero flujos de una sola llamada y considera Qwen 3.6 27B si necesitas sobre todo llamadas a herramientas fiables.

Preguntas frecuentes

¿El backend MLX de SGLang admite decodificación especulativa para Muse Glimmer?

Aún no. La hoja de ruta de SGLang menciona la decodificación especulativa EAGLE como una función prevista, pero todavía no implementada para el backend MLX. En Mac estás limitado a la decodificación autorregresiva estándar, a aproximadamente 17.6 tokens por segundo en un M5 Pro con Q4, según los benchmarks de la discusión de la hoja de ruta.

¿Conviene usar MLX o GGUF para Muse Glimmer en Mac?

MLX es la ruta nativa para Apple Silicon: utiliza Metal directamente y aprovecha la memoria unificada sin copias explícitas entre CPU y GPU. GGUF mediante llama.cpp es la alternativa si tu runtime MLX no incorpora soporte para la arquitectura muse_glimmer. La compilación de 4 bits de MLX Community y la compilación GGUF de Unsloth, disponible en Hugging Face, son las dos opciones principales. MLX suele ofrecer mayor velocidad de decodificación cuando funciona; GGUF es compatible con más herramientas, como LM Studio y Ollama.

¿Cómo se compara SGLang MLX con mlx-lm u Ollama para servir el modelo?

SGLang proporciona un servidor de API compatible con OpenAI, caché radix y las variables de ajuste descritas anteriormente. mlx-lm es más sencillo: carga el modelo y genera texto con menos opciones de configuración, pero sin abstracción de servidor. Un usuario de Reddit en r/LocalLLM informó de una etiqueta de Ollama muse-glimmer:30b-mlx con su propia capa de API. Si necesitas una API lista para integrar con agentes de programación como OpenCode CLI, SGLang u Ollama son las opciones prácticas; para una generación rápida y puntual, mlx-lm es suficiente.