Meta 发布 Muse Glimmer：30B 本地智能体多模态开源模型

来自开源 LLM 元老们的重大好消息！今天发布的 Muse Glimmer 是 Meta 全新的多模态模型，专为本地智能体用例设计。它从 Muse 蒸馏至 30B 参数，并以 Apache 2.0 许可证发布，非常适合本地部署以实现隐私保护、降低成本，或单纯用于折腾尝试。它面向隐私敏感型应用，如编码、文档分析、个人助手，以及类似 Claw 或 Hermes 的配置。

为庆祝这一发布，我们在 transformers、llama.cpp、vLLM、Inference Endpoints 及其他库中提供了 Meta day-0 支持。我们构建了一些很酷的东西，并在这篇博客中解释我们的发现。

查看下方演示以获取灵感。

你可以在 HF Mirror Hub 上找到 Muse Glimmer。

基准测试

基准测试结果

分数按已发布数据报告。粗体表示所比较模型中的最佳结果；↓ 表示越低越好。

架构

Muse Glimmer 是一个稠密的 30B 参数模型，由以下部分组成：

• 2B ViT 风格视觉编码器（Perception Encoder）
• 28B 参数文本解码器

除主 VLM 外，还有一个基于 DFlash 实现的推测解码草稿模型。该模块的使用是可选的，它可以以一定的内存开销换取更快的生成速度。我们发现该草稿模型特别适合结构化内容生成，例如编码。

文本解码器

该语言模型使用以下架构组件：

• 混合注意力：在三个使用旋转位置嵌入的滑动窗口层（2,048 个 token）之间交替，随后是第四个使用全注意力和 NoPE（无位置嵌入）的层。因此模式为（SWA、SWA、SWA、Full），重复 13 次，共 52 层。这使模型能够通过 RoPE 保留相对顺序和距离信息，并通过 NoPE 全局保留信息。
• 门控分组查询注意力：每个键值头由 16 个查询头共享，这使 KV 缓存内存减少 16 倍，并使生成更快、更便宜。
• 带额外查询缩放的 Q-K 归一化：在计算注意力之前，Muse Glimmer 对每个查询头和键头应用 RMS 归一化，以保持注意力 logits 稳定。之后，查询会乘以一个缩放因子，以在归一化后设定目标 logit 尺度。额外的查询缩放在 softmax 层面起到类似逆温度的作用。

感知编码器

Muse Glimmer 使用一个图像编码器同时处理图像和视频。与其他 VLM 中使用的相对较小的视觉编码器不同，这是一个规模可观的 2B ViT 类模型，按照 Perception Encoder 架构设计。Perception Encoder 此前由 Meta 推出，作为各种下游空间和多模态任务的骨干。
编码器将图像分块为 2 帧 x 3 通道 x 14 x 14 的形状，并通过一个线性层进行投影。随后，从学习到的位置表中插值得到的绝对位置嵌入会被加到这些嵌入上。然后这些嵌入被送入由 50 层和 GELU MLP 组成的视觉塔。与语言模型类似，注意力模式由三个窗口注意力层后接一个全注意力层组成。在注意力层内部，2D RoPE 被应用于查询和键。

在 transformer 之后，像素重排将相邻空间 token 的 2x2 分组拼接起来，在不丢弃其通道的情况下将图像 token 数量减少 4 倍。合并后的特征随后被投影到文本解码器的共享嵌入空间。

视频逐帧经过同一个编码器，其中每一帧都被转换为 patch（形状为 [batch, temporal groups, grid height, grid width, 2 frames, 3 channels, 14, 14]）。处理器目标为每秒 2 帧，并将视频片段上限设为在视频中均匀采样的 96 帧。处理器创建带时间戳的视频占位符，将文本与帧交错，例如 “Time: 0.0s <|video|> x N”，其中最终视频嵌入会在最终投影层之前被替换。

Transformers

将 transformers 升级到最新版本，以便使用 Muse Glimmer。

pip install --upgrade transformers accelerate

Muse Glimmer 在 transformers 中提供首日支持，包括主模型和推测解码草稿模型。你可以使用 AutoModelForMultimodalLM 和 AutoProcessor 类来加载模型和处理器。

from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "meta-models/Muse-Glimmer-30B"

# Load model
processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForMultimodalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto"
)

同一段代码在 NVIDIA (CUDA)、AMD (ROCm) 和 Intel (XPU) GPU 上无需修改即可运行，device_map="auto" 会将模型放到任意可用的加速器上。

纯文本推理

加载模型后，你可以按如下方式进行纯文本推理。

from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "meta-models/Muse-Glimmer-30B"

# Load model
processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForMultimodalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto"
)

# Prompt
messages = [
    {"role": "user", "content": "Write a short joke about saving RAM."},
]

# Process input
inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
    reasoning_strength="low"
).to(model.device)
input_len = inputs["input_ids"].shape[-1]

# Generate output
outputs = model.generate(**inputs)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
print(response)

使用图像和文本提示模型

我们需要 torchvision 才能使用图像和文本。

pip install torchvision

Muse Glimmer 接受图像作为输入，如下所示：

from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "meta-models/Muse-Glimmer-30B"

# Load model
processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForMultimodalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto"
)

# Images + Text
messages = [
    {
        "role": "user", "content": [
            {"type": "image", "image": "https://hf-mirror.com/datasets/merve/vl-test-suite/resolve/main/SF.png"},
            {"type": "text", "text": "What is shown in this image?"}
        ]
    }
]

inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
    reasoning_strength="low"
).to(model.device)
input_len = inputs["input_ids"].shape[-1]

# Generate output
outputs = model.generate(**inputs)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
print(response)

视频推理

要处理视频，我们建议在环境中安装 torchcodec。

pip install torchcodec

Muse Glimmer 可以回答关于无音频视频的复杂问题。你可以按如下方式进行视频推理，这里有一个来自 VideoMME2 的示例，它是最流行的视频问答基准。

from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "meta-models/Muse-Glimmer-30B"

# Load model
processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForMultimodalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto"
)

# Videos + Text
messages = [
    {
        "role": "user",
        "content": [
            {"type": "video", "video": "https://hf-mirror.com/datasets/merve/vl-test-suite/resolve/main/IMG_8137.mp4"},
            {"type": "text", "text": "Describe what happens in this video."},
        ],
    },
]

inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
    reasoning_strength="low",
    processor_kwargs={"num_frames": 96},
).to(model.device)

input_len = inputs["input_ids"].shape[-1]
outputs = model.generate(**inputs)

response = processor.decode(
    outputs[0, input_len:],
    skip_special_tokens=False,
)
print(response)

多模态工具调用

Muse Glimmer 可以进行多模态工具调用，方法如下。在下面的示例中，我们要求模型根据图像中的城市调用天气工具。

import json
import re
from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "meta-models/Muse-Glimmer-30B"

# Load model
processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForMultimodalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto"
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "weather.get",
            "description": "Get the current weather for a city.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string"},
                },
                "required": ["city"],
            },
        },
    }
]


messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": "https://hf-mirror.com/datasets/merve/vl-test-suite/resolve/main/SF.png"},
            {"type": "text", "text": "I'm going to the city in this picture. What clothes should I wear?"},
        ],
    },
]

inputs = processor.apply_chat_template(
    messages,
    tools=tools,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
    reasoning_strength="low"
).to(model.device)

input_len = inputs["input_ids"].shape[-1]
outputs = model.generate(**inputs)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
print(response)

目标检测

你可以使用 Muse Glimmer 按如下方式在图像中进行开放式目标检测。

from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "meta-models/Muse-Glimmer-30B"

# Load model
processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForMultimodalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto"
)

messages = [{
    "role": "user",
    "content": [
        {"type": "image", "image": "https://hf-mirror.com/datasets/merve/vl-test-suite/resolve/main/SF.png"},
        {
            "type": "text",
            "text": (
                "Detect the bridge. Return only the detection in the model's "
                "native object-detection format, with no explanation."
            ),
        },
    ],
}]

inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
    reasoning_strength="low",
).to(model.device)

input_len = inputs["input_ids"].shape[-1]
outputs = model.generate(**inputs, max_new_tokens=128)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)

detections = json.loads(response.removesuffix("<|eot|>"))
print(detections)

这里有一个执行目标检测的端到端脚本 GitHub Gist

Llama.cpp

Muse Glimmer 从发布首日即支持 llama.cpp。Meta 在这个 repo 中发布了校准后的量化版本，Unsloth 也在发布优化后的量化版本。同时还支持 DFlash 推测解码。你可以使用预构建的 llama 二进制文件来启动 llama server 或 CLI。要安装 llama.cpp，请运行：

curl -LsSf https://llama.app/install.sh | sh

然后你可以按如下方式启动服务器。

llama serve -hf meta-models/Muse-Glimmer-30B-GGUF

服务器启动后，你可以前往 localhost:8080 使用内置 WebUI 进行对话。

你也可以按如下方式查询服务器。

curl http://localhost:8080/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "messages": [
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": "Write a limerick about python exceptions"}
        ]
    }'

你还可以将 llama server 与 Pi 等编码智能体配合使用。

推测解码

DFlash 使用轻量级的块扩散草稿模型，在解码阶段提供额外加速的同时保持相同输出。Transformers 和 llama.cpp 从发布首日就支持 Muse Glimmer 的 DFlash 草稿模型。

下面你可以看到推测解码在真实场景中如何加速生成。视频左侧展示了使用 DFlash 的 llama.cpp webui，右侧是常规生成。

使用 transformers 进行推测解码

你可以按如下方式加载草稿模型和模型，并像使用基础模型一样进行推理，只需额外添加一个参数（将在接下来的代码片段中展示）。

import torch
from transformers import AutoProcessor, MuseGlimmerAssistantModel, MuseGlimmerForConditionalGeneration

model_id = "meta-models/Muse-Glimmer-30B"
assistant_model_id = "meta-models/Muse-Glimmer-30B-assistant"
target = MuseGlimmerForConditionalGeneration.from_pretrained(model_id, dtype=torch.bfloat16, device_map="auto")
assistant = MuseGlimmerAssistantModel.from_pretrained(assistant_model_id, dtype=torch.bfloat16, device_map="auto")
processor = AutoProcessor.from_pretrained(model_id)

messages = [
    {
        "role": "user", "content": [
            {"type": "image", "url": "https://hf-mirror.com/datasets/merve/vl-test-suite/resolve/main/SF.png"},
            {"type": "text", "text": "What is shown in this image?"}
        ]
    }
]

inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
    reasoning_strength="low"
).to(target.device)
input_len = inputs["input_ids"].shape[-1]

outputs = target.generate(
    **inputs,
    assistant_model=assistant,
    speculation_type="dflash",
    do_sample=True
)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
print(response)

使用 llama.cpp 进行推测解码

你可以使用以下命令启动 llama server。--spec-draft-n-max 参数控制 DFlash 在每个推测解码步骤中提议多少个未来 token。Muse Glimmer 的 DFlash 模型以块大小 16 进行训练，即一个锚点 token 加 15 个提议 token，因此任何大于 15 的值都会被钳制为 15。

llama serve -hf meta-models/Muse-Glimmer-30B-GGUF --spec-type draft-dflash --spec-draft-n-max 15

你还可以按如下方式将 llama cli 与推测解码草稿模型配合使用。

llama cli -hf meta-models/Muse-Glimmer-30B-GGUF --spec-type draft-dflash

推理端点

如需托管式、自动扩缩容的部署，请打开 Muse Glimmer 30B Inference Endpoints 预设。模型已预先选好：选择组织、云服务提供商、区域、兼容的 GPU 实例、身份验证和自动扩缩容设置，然后查看每小时价格并点击 Create Endpoint。当其状态变为 Running 后，你可以在 Playground 中测试，并从 Overview 中复制端点 URL 和模型名称。

部署后的模型会暴露一个 OpenAI 兼容的 Chat Completions API。将你的 HF Mirror token 保存在环境变量中，将 HF_ENDPOINT_URL 设置为 Overview 中显示的 URL（不带 /v1），并将 HF_ENDPOINT_MODEL 设置为该端点的模型名称。

export HF_TOKEN="hf_..."
export HF_ENDPOINT_URL="https://<endpoint-id>.<region>.<cloud>.endpoints.huggingface.cloud"
export HF_ENDPOINT_MODEL="<endpoint-model-name>"
pip install --upgrade openai

import os
from openai import OpenAI

client = OpenAI(
    base_url=f"{os.environ['HF_ENDPOINT_URL'].rstrip('/')}/v1/",
    api_key=os.environ["HF_TOKEN"],
)

response = client.chat.completions.create(
    model=os.environ["HF_ENDPOINT_MODEL"],
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Write a limerick about Python exceptions."},
    ],
    max_tokens=256,
)
print(response.choices[0].message.content)

配置、自动扩缩容、安全性、日志和监控相关信息请参阅Inference Endpoints 文档。

通过 transformers 后端支持 Muse Glimmer vLLM

在此次发布中，我们提供了对 vLLM 搭配 transformers 后端的支持。

# tensor parallel serving across 4 GPUs
vllm serve meta-models/Muse-Glimmer-30B --model-impl transformers --tensor-parallel-size 4

# infer
curl -s http://127.0.0.1:8000/v1/chat/completions \
    -H 'Content-Type: application/json' \
    -d '{
      "model": "meta-models/Muse-Glimmer-30B",
      "messages": [
        {"role": "user", "content": "Explain tensor parallelism briefly."}
      ],
      "temperature": 0.0,
      "max_tokens": 256
    }'

使用 TRL 进行微调

你可以使用 TRL 通过从 SFT 到 Async GRPO 的各种方法对 Muse Glimmer 进行微调。我们在 bf16 下使用每张 80GB VRAM 的 Hopper 级 GPU 进行了两组实验。

作为此次发布的一部分，我们提供了一个示例，用于在 MolmoWeb 数据集的小型拆分上微调 Muse Glimmer。该示例展示了如何让模型生成结构化输出，以及如何在图像上进行微调。

我们还尝试了在 OpenCode 上运行模型，并使用了 AsyncGRPO 示例。模型展现出强大的编码能力，因此我们鼓励你在 OpenEnv 和 TRL 中尝试使用编码环境进行训练。

演示

以下是一些体验 Muse Glimmer 的有趣方式。在我们看来，这个模型最酷的地方在于：它是一个本地规模的个人助手，而且还能写代码。这意味着你可以让它做一些事情，比如量化自己、在 Hub 上寻找量化权重、将自己部署到推理端点，甚至针对特定硬件优化自己！让我们一起来拥抱本地吧 🚀

将 OpenClaw 连接到 Muse Glimmer

假设该 Inference Endpoint 暴露了一个与 OpenAI 兼容的 /v1 API。

在 OpenClaw 网关环境中设置 HF_TOKEN，然后将以下内容添加到 ~/.openclaw/openclaw.json 中：

OpenClaw 配置

{
  models: {
    mode: "merge",
    providers: {
      muse: {
        baseUrl: "https://YOUR-ENDPOINT.endpoints.huggingface.cloud/v1",
        apiKey: {
          source: "env",
          provider: "default",
          id: "HF_TOKEN"
        },
        api: "openai-completions",
        authHeader: true,
        models: [{
          id: "meta-models/Muse-Glimmer-30B",
          name: "Muse Glimmer",
          reasoning: false,
          input: ["text", "image"],
          contextWindow: 32768,
          maxTokens: 8192
        }]
      }
    }
  },
  agents: {
    defaults: {
      model: { primary: "muse/meta-models/Muse-Glimmer-30B" }
    }
  }
}

重启 OpenClaw：

openclaw gateway restart

在一个全新会话中验证：

openclaw agent --message "Reply with: muse-ready"

如果模型 ID 与端点 /v1/models 响应返回的不一致，请使用端点返回的确切模型 ID。

嘿 Muse Glimmer，把自己量化一下

如果我们将 Muse Glimmer 连接到 HF Mirror MCP 并更新其 AGENTS.md，我们就赋予了它在 Hub 上找到自身的量化版本并在本地运行的能力。如果你想处理一些私密的事情，或者只是降低成本，这会很方便。

如果你再次执行此操作，Muse Glimmer 会找到缓存的权重并切换到它们，所以不妨添加一个方便的命令，例如 /spawn。

Muse Glimmer 会检查机器和 Hub，选择或创建一个 Q4_K_M GGUF，启动 llama-server，并验证模型发现和对话补全。结果是在一个与 OpenAI 兼容的 API 背后运行一个更小的本地构建。以下是我们添加到 AGENTS.md 中的提示词。

https://hf-mirror.com/buckets/huggingface/muse-glimmer-assets/resolve/Muse%20Glimmer%20Quantisation%20Demo%20-%20explained.mp4?download=true

将此添加到 AGENTS.md 后，openclaw 或 hermes 就能解决剩余的问题。

本地量化提示词

## Local model deployment

When asked to deploy locally, perform the work; do not give instructions.

1. Inspect hardware and the HF Mirror cache.
2. Search the Hub for compatible GGUF weights using `apps=llama.cpp`; confirm exact filenames through the model-tree API.
3. Prefer an existing suitable GGUF, normally `Q4_K_M`. Treat `mmproj-*.gguf` as projector weights.
4. If no GGUF exists, download the source weights, convert with `convert_hf_to_gguf.py`, then quantize with `llama-quantize`.
5. Preserve source weights and record the repository, revision, filenames, and quantization.
6. Start `llama-server` with an `onyx` alias and an OpenAI-compatible endpoint.
7. Validate `/v1/models` and `/v1/chat/completions`, requiring non-empty, correct content.
8. Report concise progress and logs. Claim completion only after validation passes.

嘿 Muse Glimmer，把自己部署一下

Muse Glimmer 也能处理相反的情况。让我们让 Glimmer 将自己部署到 HF Mirror Inference Endpoints 上。如果你想在某些前沿硬件上加速，这很有用。

注意：你也可以直接将 Muse Glimmer 部署到 Inference Endpoints 并连接你的智能体。

Muse Glimmer 会固定模型修订版本，将其部署到一个受保护的 HF Mirror Inference Endpoint，并验证健康状态、模型发现和对话补全。然后它会将 Claw 智能体与保留的密钥和回滚机制连接起来。以下是我们添加到 AGENTS.md 中的提示词。Muse Glimmer 还需要 HF Mirror MCP 和/或 HF Mirror CLI and Skills。

Inference Endpoint 部署提示词

## HF Mirror Inference Endpoint deployment

When asked to deploy on HF Mirror Inference Endpoints, perform the work; do
not give instructions.

1. Inspect HF Mirror authentication, the current model repository, and any
   existing endpoints.
2. Confirm the exact model repository and immutable revision through the Hub
   API; inspect its architecture, configuration, and chat template.
3. Confirm that the model is supported by vLLM, then deploy or update a
   protected Inference Endpoint using the managed native vLLM engine.
4. Choose an available region and the smallest suitable accelerator. Use one
   replica and enable scale-to-zero when supported.
5. Preserve the previous endpoint configuration for rollback. Do not expose
   tokens, publish private weights, or replace an unrelated endpoint.
6. Wait for the endpoint to become ready. If startup fails, inspect the logs
   and report the actual blocker rather than repeatedly changing settings.
7. Validate `/health`, `/v1/models`, and `/v1/chat/completions`, requiring the
   expected model and non-empty, correct content. When agent use is required,
   also validate a real structured tool call.
8. Configure the Claw agent to use the endpoint's OpenAI-compatible `/v1` URL,
   storing credentials as secrets and retaining the previous provider as
   rollback. Test the connection in a fresh session.
9. Report concise progress and finish with the repository, revision, engine,
   hardware, endpoint URL, scaling state, and validation results. Claim
   completion only after every required check passes.

嘿 Muse Glimmer，把自己优化一下

最后，让我们让 Muse Glimmer 进行一些轻量的 RSI。我们可以指示我们的智能体针对特定硬件优化自己的推理引擎，在这个例子中是 Nvidia H100。为此，智能体需要使用另一个推理引擎，比如上面提到的 Inference Endpoints。

Muse Glimmer 会在保持工作负载不变的情况下，对自己的单 H100 服务栈进行基准测试，一次测试一个可逆的改动。它只保留通过正确性验证的改进，并以最快且可复现的配置作为最终结果。以下是我们添加到 AGENTS.md 中的提示词。Muse Glimmer 需要 HF Mirror MCP 以及 HF Mirror CLI and Skills。

自我优化提示词

You are Muse Glimmer acting as an autonomous inference-optimization engineer for your own serving stack.

Goal: maximize valid single-H100 aggregate completion throughput in tokens/second.

Protocol:
1. Establish a correctness-passing baseline.
2. Test one reversible optimization at a time.
3. Keep the prompt, concurrency, sampling, request count, warm-up, and decode length fixed.
4. Reject results that fail correctness or prefix checks.
5. Record every experiment chronologically with its configuration, raw throughput, correctness, and delta.
6. Keep improvements and revert regressions.
7. Stop after six consecutive regressions or when the experiment budget is exhausted.
8. Report the best valid configuration and exact reproduction command.

Create a minimal scientific animation of the results:
- white background;
- raw tokens/second—never normalize;
- one point revealed per experiment;
- connect every point chronologically;
- begin with the lowest valid result;
- stop at the best result;
- export as a GIF.

Never fabricate, interpolate, or count correctness-failing measurements.

https://hf-mirror.com/buckets/huggingface/muse-glimmer-assets/resolve/onyx-optimization-progress.gif?download=true

Hey Muse Glimmer，研究一下 Hub

将 Muse Glimmer 作为 HF Mirror 研究代理来试用。该 Gradio Space 通过其兼容 OpenAI 的 API，将每个模型请求发送到私有的 HF Mirror Inference Endpoint。它还连接到官方 HF Mirror MCP 服务器，为代理提供只读工具，以搜索和检查 Hub 仓库、模型、数据集、Space、文档和论文。

总结

我们很高兴欢迎 Muse Glimmer 加入 HF Mirror Hub。今天就带着你的本地编码环境试试 Muse Glimmer 吧！