> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tokios.com/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Tokios exposes private local models through https://api.tokios.com using an outbound-only connector tunnel.
> Use 'connector' for the local tokios-connector process.
> Use 'deployment' for the public model name in the API model field.
> Use 'upstream model id' for the model served by Ollama, llama.cpp, vLLM, LM Studio, or another local backend.
> API keys use the prefix sk-tok-. Connector tokens use the prefix ct-tok-.

# Exécutez Muse Spark Open 816B en local : matériel, quantification et configuration

> Muse Spark Open de Meta est un MoE de 816B/42B actifs avec un contexte de 1M, une entrée multimodale (texte, image, vidéo, audio) et des scores de codage agentique de niveau frontier. Matériel, variantes GGUF et configuration.

> [!NOTE]
>
> Dernière vérification : 2026-10-16

Muse Spark Open est le modèle frontier à poids ouverts de Meta Superintelligence Labs, publié le 15 octobre 2026. C'est un transformer **mixture-of-experts** avec **816B paramètres au total** et **\~42B actifs par token**, une fenêtre de contexte de 1 million de tokens, et des entrées natives pour le texte, les images, la vidéo et l'audio. Meta l'a entraîné sur des workflows réels de développeurs — refactorisations multi-fichiers, longues sessions de débogage, scaffolds d'appels d'outils — et il domine le domaine des poids ouverts sur les benchmarks de programmation agentique et d'utilisation d'outils.

Le chiffre important pour l'auto-hébergement est **226 GB**. C'est le téléchargement du GGUF 2 bits, et c'est pourquoi ce modèle fonctionne sur un Mac Studio au maximum plutôt que sur un cluster de datacenter. La version 4 bits fait 506 GB, et le BF16 complet est d'environ \~1.5 TB.

> [!TIP]
>
> Vous exécutez déjà ce modèle ? [Enregistrez-le dans Tokios](/fr/setup/register-model.md) pour y accéder via `https://api.tokios.com` depuis n'importe quel client.

## Muse Spark Open en un coup d'œil

| Propriété | Muse Spark Open 816B |
| - | - |
| Dépôt Hugging Face | [`meta-models/Muse-Spark-Open-816B-A42B`](https://huggingface.co/meta-models/Muse-Spark-Open-816B-A42B) |
| Licence | Muse Model License |
| Architecture | Transformer mixture-of-experts — 256 experts par couche, 8 actifs par token |
| Paramètres | \~816B au total, \~42B actifs par token |
| Couches | 62 |
| Dimension cachée | 8,192 |
| Attention | Grouped-query — 128 têtes de requête, 16 têtes KV, dim de tête 64, QK-norm, portes résiduelles apprises |
| Fenêtre de contexte | 1,048,576 tokens |
| Vocabulaire | 202,048 tokens |
| Modalités | Texte, image, vidéo et audio en entrée — texte en sortie |
| Langues | 100+ |
| Raisonnement | Contrôlable — `low`, `medium`, `high`, `xhigh` (par défaut `xhigh`) |
| Appel d'outils | Oui, chat template natif basé sur des canaux (`to=self` pour le raisonnement, `to=user` pour la réponse finale) |
| Encodeur de perception | ViT de 1.8B paramètres, 50 couches, patches 14×14, 2D RoPE, attention clairsemée |
| Encodeur audio | Pyramide convolutionnelle, forme d'onde brute à 24 kHz mono, 1 token par 80 ms |
| Cache KV | \~250 KB par token en BF16 (\~266 GB pour le contexte 1M complet) |
| Entraînement | Sources publiques, crawls internet, acquisitions tierces, produits Meta, données synthétiques ; post-entraînement de sécurité |

Sources : [article de blog de Meta sur Muse Spark Open](https://huggingface.co/blog/meta-muse-spark-open) et la [fiche du modèle](https://huggingface.co/meta-models/Muse-Spark-Open-816B-A42B).

## Variantes et identifiants de modèle

Unsloth publie des versions GGUF de 2 bits à 4 bits. Meta publie des checkpoints BF16 et NVFP4 (Blackwell). La communauté MLX fournit des quantifications optimisées pour Apple Silicon.

### GGUF (compatible llama.cpp / Ollama)

| Quantification | Taille approximative | Notes |
| - | - | - |
| `UD-IQ1_S` | 176 GB | Compression extrême ; perte de qualité significative |
| `UD-IQ1_M` | 209 GB | Précision légèrement supérieure |
| `UD-IQ2_XXS` | 226 GB | Fonctionne sur Mac M3 Ultra 512 GB à \~18 tok/s |
| `UD-IQ2_S` | 275 GB | |
| `UD-Q2_K_XL` | 311 GB | |
| `UD-IQ3_XXS` | 340 GB | |
| `UD-Q3_K_XL` | 401 GB | |
| `UD-Q4_K_XL` | 506 GB | Recommandé — meilleur équilibre qualité/taille |

Source GGUF : [`unsloth/Muse-Spark-Open-816B-A42B-GGUF`](https://huggingface.co/unsloth/Muse-Spark-Open-816B-A42B-GGUF).

### Pleine précision et Blackwell

| Checkpoint | Taille | Cible matérielle |
| - | - | - |
| BF16 (`meta-models/Muse-Spark-Open-816B-A42B`) | \~1.5 TB | 4 nœuds × 8× H200 (TP=32) |
| NVFP4 (`meta-models/Muse-Spark-Open-816B-A42B-NVFP4`) | \~700 GB | Un seul nœud B200/GB300 |

### MLX (Apple Silicon)

| Quantification | RAM approximative | Notes |
| - | - | - |
| `oQ3e` (3 bits) | \~344 GB | \~21 tok/s en génération sur M3 Ultra |
| `oQ4e` (4 bits) | \~450 GB | |

Source MLX : [`mlx-community/Muse-Spark-Open-816B-A42B-oQ3e`](https://huggingface.co/mlx-community/Muse-Spark-Open-816B-A42B-oQ3e) et [`-oQ4e`](https://huggingface.co/mlx-community/Muse-Spark-Open-816B-A42B-oQ4e).

## Calcul mémoire MoE

Le MoE a un piège mémoire : le routage active une fraction des paramètres par token, mais **tous** les poids des experts restent en mémoire. Muse Spark Open active 42B de ses 816B par token, mais l'empreinte totale des poids est ce que vous devez charger. L'arithmétique :

* 816B paramètres × \~0.5 octets en 4 bits ≈ **408 GB** de poids
* \~506 GB tel que livré en `UD-Q4_K_XL`, une fois les embeddings, l'encodeur de perception, l'encodeur audio et les métadonnées inclus
* Ajoutez le cache KV en plus — à \~250 KB par token en BF16, un contexte de 131K ajoute \~33 GB ; le contexte 1M complet ajoute \~266 GB

Il n'y a pas de moyen de contourner le coût mémoire des paramètres totaux. La voie pratique est une quantification agressive (2 bits à 226 GB pour un Mac Studio, 4 bits à 506 GB pour un boîtier multi-GPU) ou NVFP4 sur Blackwell. Consultez [Routage MoE et parallélisme d'experts](/fr/concepts/moe-routing-and-expert-parallelism.md) pour comprendre le fonctionnement de l'architecture et [Mémoire et déchargement](/fr/concepts/memory-and-offloading.md) pour ce qui change lorsque les poids débordent du GPU.

## Adéquation matérielle

Les verdicts supposent que le modèle est entièrement résident (pas de déchargement CPU) à une longueur de contexte modeste.

| Cible | GGUF Q2 (226 GB) | GGUF Q4 (506 GB) | NVFP4 (\~700 GB) | BF16 (\~1.5 TB) |
| - | - | - | - | - |
| Mac Studio M3/M4 Ultra (192 GB) | Ne tient pas | Ne tient pas | Ne tient pas | Ne tient pas |
| Mac Studio M3/M5 Ultra (512 GB) | À l'aise | Serré | Ne tient pas | Ne tient pas |
| 2× Mac Studio M5 Ultra (MLX en cluster) | À l'aise | À l'aise | Ne tient pas | Ne tient pas |
| 8× RTX Pro 6000 (98 GB chacun, 784 GB au total) | À l'aise | À l'aise | À l'aise (ctx 131K) | Ne tient pas |
| 8× H200 (141 GB chacun, 1,128 GB au total) | À l'aise | À l'aise | À l'aise | Serré (ctx 1M) |
| 4×8× H200 (TP=32) | À l'aise | À l'aise | À l'aise | À l'aise |

Sur un Mac Studio de 512 GB, le GGUF 2 bits tient avec de la place pour un contexte modéré. La version 4 bits à 506 GB ne laisse presque aucune marge sur une seule machine de 512 GB — prévoyez le contexte dont vous avez réellement besoin. Pour la méthode de dimensionnement, consultez [quel modèle tient dans votre GPU ?](/fr/guides/model-fit.md).

> **[Picked a model? Connect it](/fr/quickstart.md)**
>
> Un seul point de terminaison authentifié à `https://api.tokios.com` — aucun port entrant, environ 5 minutes.

## Exécutez-le — du débutant à l'avancé

**llama.cpp (GGUF)**

```bash macOS / Linux theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -LsSf https://llama.app/install.sh | sh
llama serve -hf unsloth/Muse-Spark-Open-816B-A42B-GGUF:UD-Q4_K_XL
```

```powershell Windows theme={"theme":{"light":"github-light","dark":"css-variables"}}
winget install llama.cpp
llama serve -hf unsloth/Muse-Spark-Open-816B-A42B-GGUF:UD-Q4_K_XL
```

Le serveur démarre une interface web à `localhost:9931` et un point de terminaison compatible OpenAI. Remplacez l'étiquette de quantification par `UD-IQ2_XXS` pour la version de 226 GB sur un Mac de 512 GB. Consultez [Accès à distance llama.cpp](/fr/guides/llama-cpp-remote-access.md) pour y accéder depuis une autre machine.

**vLLM (NVFP4, Blackwell)**

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
export CKPT=meta-models/Muse-Spark-Open-816B-A42B-NVFP4
VLLM_PLUGINS=musespark1x_models,ptq_nvfp4 \
vllm serve "$CKPT" \
  --tensor-parallel-size 4 \
  --enable-expert-parallel \
  --max-model-len 131072 \
  --reasoning-parser musespark1x \
  --tool-call-parser musespark1x \
  --port 8000
```

Cela sert le checkpoint NVFP4 sur des GPU Blackwell avec parallélisme d'experts. Ajustez `--tensor-parallel-size` et `--max-model-len` selon votre matériel. Consultez [Accès à distance vLLM](/fr/guides/vllm-remote-access.md).

**SGLang (NVFP4, Blackwell)**

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
export CKPT=meta-models/Muse-Spark-Open-816B-A42B-NVFP4
uv run sglang_meta serve \
  --model-path "$CKPT" \
  --quantization modelopt_fp4 \
  --moe-runner-backend flashinfer_trtllm \
  --tp-size 4 --ep-size 4 \
  --port 30000
```

SGLang cible le checkpoint NVFP4 sur Blackwell avec le backend MoE FlashInfer TRT-LLM. Consultez la documentation du projet SGLang pour la syntaxe et les réglages actuels.

**MLX (Apple Silicon)**

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
pip install mlx-lm
mlx_lm.generate --model mlx-community/Muse-Spark-Open-816B-A42B-oQ3e \
  --prompt "Explain convolutional networks like I am 5" \
  --max-tokens 5000
```

La version `oQ3e` en 3 bits nécessite \~344 GB de mémoire unifiée et fonctionne à \~21 tok/s sur un M3 Ultra. La version `oQ4e` en 4 bits est de meilleure qualité mais nécessite \~450 GB. Meta rapporte des tests sur deux Mac Studios avec M5 Ultra en cluster via oMLX.

**Transformers (multi-GPU)**

```python theme={"theme":{"light":"github-light","dark":"css-variables"}}
from transformers import AutoModelForMultimodalLM, AutoTokenizer, DistributedConfig
import os

distributed_config = DistributedConfig(
    tp_size=int(os.environ["WORLD_SIZE"]),
    ep_size=int(os.environ["WORLD_SIZE"]),
)

model = AutoModelForMultimodalLM.from_pretrained(
    "meta-models/Muse-Spark-Open-816B-A42B",
    distributed_config=distributed_config,
)
tokenizer = AutoTokenizer.from_pretrained("meta-models/Muse-Spark-Open-816B-A42B")

messages = [{"role": "user", "content": "Explain quantum physics."}]
inputs = tokenizer.apply_chat_template(
    messages,
    reasoning_effort="medium",
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
).to(model.device).to(model.dtype)

outputs = model.generate(**inputs, max_new_tokens=2000)
```

Nécessite une inférence distribuée sur plusieurs GPU. Définissez `WORLD_SIZE` selon votre nombre de GPU. Le checkpoint BF16 nécessite \~1.5 TB au total sur tous les appareils.

### Paramètres d'échantillonnage

Meta recommande `temperature = 1.0`, `top_p = 1.0`, et `top_k` désactivé. L'effort de raisonnement est par défaut à `xhigh` — baissez-le à `high` ou `medium` pour des tâches plus simples afin d'économiser des tokens. Il n'y a pas de moyen de désactiver entièrement le raisonnement ; réglez-le sur `low` pour le chemin le plus court.

## Capacités

* **Raisonnement contrôlable.** Définissez l'effort dans le chat template avec `reasoning_effort="low"` (ou `medium`, `high`, `xhigh`). Les paramètres plus élevés dépensent plus de tokens à raisonner avant de répondre. Le modèle utilise un template basé sur des canaux : `to=self` pour le raisonnement interne, `to=user` pour la réponse finale.
* **Entrée multimodale complète.** Le texte, les images, la vidéo et l'audio entrent ; le texte sort. L'encodeur de perception gère la vision (ViT de 1.8B paramètres), et une pyramide convolutionnelle séparée gère l'audio à 24 kHz mono.
* **Programmation agentique.** Meta a entraîné sur des workflows réels de développeurs : refactorisations multi-fichiers, sessions de débogage, scaffolds d'appels d'outils. Il domine les modèles à poids ouverts sur MCP-Atlas (89.2), DeepSWE 1.1 (68), Terminal-Bench 2.1 (85.0), et Toolathlon Verified (76.5).
* **Appel d'outils natif.** Le chat template prend en charge les appels d'outils structurés avec adherence au schéma. Utilisez `--tool-call-parser musespark1x` dans vLLM ou l'équivalent dans votre environnement d'exécution.
* **Multilingue.** 100+ langues.

### Benchmarks

Rapportés par Meta avec un effort de raisonnement `xhigh`, sur un modèle publié le 15 octobre 2026. Aucune reproduction indépendante n'existe encore — considérez ces chiffres comme des affirmations du fabricant jusqu'à ce que des évaluations tierces apparaissent.

| Benchmark | Score | Meilleur concurrent |
| - | - | - |
| MCP-Atlas | 89.2 | Qwen3.8 (84.5) |
| DeepSWE 1.1 | 68 | GLM 5.3 (67) |
| Terminal-Bench 2.1 | 85.0 | Qwen3.8 (82.0) |
| SWE-Atlas-QnA | 66 | Mistral Large 4 (59) |
| Toolathlon Verified | 76.5 | GLM 5.3 (73.0) |
| GPQA Diamond | 93.5 | Qwen3.8 (93.5) |
| HLE (w/ tools) | 62.5 | Qwen3.8 (56.2) |
| HLE-Diamond (sans outils) | 26.1 | Kimi K3 (22.2) |
| JobBench | 61.8 | GLM 5.3 (61.4) |
| OSWorld Verified | 80.4 | Kimi K3 (84.8) |
| SciCode | 59.5 | GLM 5.3 (59.0) |
| Artificial Analysis Intelligence Index | 39 | Beam (40) |

## Connectez-le avec Tokios

Un modèle frontier sur du matériel dédié est un modèle que vous voulez atteindre de partout sans exposer de ports. Tokios se place après votre environnement d'exécution : il ne télécharge pas le modèle et ne remplace pas vLLM.

**1. Keep your local runtime running**

Démarrez Muse Spark Open dans vLLM, SGLang, llama.cpp ou Transformers et laissez-le lié à la boucle locale (ou votre réseau interne).

**2. Pair the Tokios connector**

Connectez-vous à [tokios.com/console](https://tokios.com/console), ouvrez l'onglet **Setup** et cliquez sur **Start pairing** pour obtenir un code d'appairage à usage unique (`TKS-XXXX-XXXX`). Exécutez l'installateur sur la machine qui exécute le modèle :

```powershell Windows theme={"theme":{"light":"github-light","dark":"css-variables"}}
irm https://tokios.com/downloads/install/windows | iex; tokios-install -Code 'TKS-XXXX-XXXX'
```

```bash macOS theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -fsSL https://tokios.com/downloads/install/macos | sh -s -- --code TKS-XXXX-XXXX
```

```bash Linux theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX
```

Ensuite **approve** l'appareil dans l'onglet **Setup** ou **Connectors**.

**3. Register a deployment**

Dans l'onglet [Models](https://tokios.com/console/models), enregistrez l'identifiant du modèle amont (par exemple `meta-models/Muse-Spark-Open-816B-A42B`) sous un nom de déploiement public comme `muse-spark`. Les clients envoient le nom de déploiement dans le champ `model`, jamais l'identifiant local — ainsi une re-quantification ultérieure ne change rien côté client.

**4. Create an API key**

Dans l'onglet [Keys](https://tokios.com/console/keys), cliquez sur **Create key**. Copiez la clé `sk-tok-…` maintenant — elle n'est affichée qu'une seule fois.

### Appelez-le de n'importe où

```bash curl (OpenAI-compatible) theme={"theme":{"light":"github-light","dark":"css-variables"}}
curl https://api.tokios.com/v1/chat/completions \
  -H "Authorization: Bearer sk-tok-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "muse-spark",
    "stream": true,
    "messages": [
      {"role": "user", "content": "Audit this repository and propose a phased refactor."}
    ]
  }'
```

```bash Claude Code (Anthropic-compatible) theme={"theme":{"light":"github-light","dark":"css-variables"}}
export ANTHROPIC_BASE_URL=https://api.tokios.com
export ANTHROPIC_API_KEY=sk-tok-YOUR_KEY
claude --model muse-spark
```

## Mises en garde

* **Ce n'est pas un modèle pour GPU grand public.** La plus petite quantification utilisable (2 bits à 226 GB) nécessite un Mac Studio de 512 GB ou équivalent. La version 4 bits recommandée nécessite 506 GB. Planifiez votre matériel avant de télécharger.
* **Les benchmarks sont rapportés par le fabricant.** Meta les a publiés le jour de la sortie. Attendez les évaluations indépendantes avant de considérer les scores de programmation comme définitifs.
* **La licence n'est pas Apache 2.0.** Muse Spark Open est distribué sous la **Muse Model License**, qui diffère de la licence Apache 2.0 de [Muse Glimmer](/fr/models/muse-glimmer.md). Lisez la licence vous-même avant de construire dessus.
* **Pas encore de support Ollama.** À la date de sortie, Ollama n'a pas publié d'étiquette Muse Spark Open. Utilisez les versions GGUF llama.cpp directement, vLLM, SGLang ou MLX.
* **Le contexte 1M est un plafond, pas une cible.** Le cache KV au contexte complet est de \~266 GB en BF16 — c'est en plus des poids du modèle. Dimensionnez votre contexte selon ce dont vous avez réellement besoin.
* **L'entrée multimodale dépend de votre environnement d'exécution.** Tokios transmet le contenu d'images, de vidéo et d'audio au point de terminaison amont — il n'ajoute pas de capacités que votre environnement d'exécution ou votre quantification ne possède pas. Consultez les [backends pris en charge](/fr/setup/supported-backends.md).
* **Le raisonnement ne peut pas être désactivé.** Le réglage le plus bas est `low`, qui dépense quand même des tokens pour le raisonnement interne. Pour les réponses les plus courtes possibles, utilisez `low` et acceptez la surcharge.

## FAQ

> **How much memory does Muse Spark Open need?**
>
> La plus petite version utilisable est le GGUF 2 bits à 226 GB, qui fonctionne sur un Mac Studio M3/M5 Ultra avec 512 GB de mémoire unifiée. Le GGUF 4 bits recommandé fait 506 GB. NVFP4 nécessite \~700 GB (un seul nœud B200). Le BF16 complet est d'environ \~1.5 TB sur 4 nœuds de 8× GPU H200. Le calcul transparent : 816B paramètres × \~0.5 octets en 4 bits ≈ 408 GB de poids, plus l'encodeur de perception, l'encodeur audio, les embeddings et la surcharge.

> **Can Muse Spark Open run on a single GPU?**
>
> Non. Même la quantification 2 bits la plus agressive à 226 GB dépasse la mémoire de n'importe quel GPU unique. Les chemins pratiques sur une seule machine sont un Mac Studio de 512 GB (GGUF Q2 via llama.cpp) ou une station de travail 8× GPU (GGUF Q4 ou NVFP4). Consultez [quel modèle tient dans votre GPU ?](/fr/guides/model-fit.md) pour le calcul de dimensionnement.

> **Is Muse Spark Open open source?**
>
> Les poids sont publiés sous la **Muse Model License**, qui n'est pas Apache 2.0 ni MIT. Cela diffère de [Muse Glimmer](/fr/models/muse-glimmer.md), qui est distribué sous Apache 2.0. Poids ouverts et open source ne sont pas la même chose — les données d'entraînement et le pipeline ne sont pas publiés. Lisez la licence vous-même avant de construire dessus.

> **What is the difference between Muse Spark Open and Muse Glimmer?**
>
> Muse Glimmer est un modèle dense de 30B qui tient dans un seul GPU de 24 GB, distillé à partir du professeur Muse Spark. Muse Spark Open est le professeur lui-même — 816B au total, 42B actifs, MoE, contexte 1M, multimodal (texte/image/vidéo/audio). Glimmer est pour le matériel grand public ; Spark Open est pour le matériel de station de travail et de serveur. Ils partagent la lignée architecturale Muse mais diffèrent en échelle, capacité et exigences matérielles.

> **Can I use Ollama with Muse Spark Open?**
>
> Pas encore. À la date de sortie du 15 octobre 2026, Ollama n'a pas publié d'étiquette Muse Spark Open. Utilisez les versions GGUF llama.cpp directement (`llama serve -hf unsloth/Muse-Spark-Open-816B-A42B-GGUF:UD-Q4_K_XL`), vLLM, SGLang ou MLX. Le support Ollama pourrait suivre — consultez [ollama.com/library](https://ollama.com/library) pour les mises à jour.

> **How do I control how much Muse Spark Open thinks?**
>
> Définissez `reasoning_effort` sur `low`, `medium`, `high` ou `xhigh` (par défaut) dans le chat template ou l'appel API. Les paramètres plus élevés dépensent plus de tokens à raisonner avant de répondre. Il n'y a pas de moyen de désactiver entièrement le raisonnement — `low` est le minimum. Cela fonctionne aussi à travers Tokios — définissez-le dans les paramètres de l'appel API.

> **Is Muse Spark Open better than Kimi K3 or GLM 5.3?**
>
> Les benchmarks de Meta le comparent à Kimi K3, GLM 5.3, Qwen3.8 et d'autres, et favorisent Muse Spark Open sur la plupart des tâches agentiques et de programmation. Mais ce sont des chiffres du fabricant le jour de la sortie. Tous ces modèles nécessitent du matériel sérieux (multi-GPU ou 512 GB+ de mémoire unifiée), donc la réponse pratique est de servir chacun et de tester votre charge de travail réelle — consultez [Kimi](/fr/models/kimi.md), [GLM](/fr/models/glm.md) et [Qwen3.8](/fr/models/qwen3.8.md).

> **Can I fine-tune Muse Spark Open?**
>
> Meta documente le fine-tuning LoRA sur les couches d'attention uniquement (les experts restent gelés), mais cela nécessite 64 GPU (8 nœuds × 8× H100). La configuration d'entraînement utilise FSDP avec parallélisme d'experts. Consultez la fiche du modèle pour la recette complète de fine-tuning et la configuration `DistributedConfig`.

> **[Muse Glimmer](/fr/models/muse-glimmer.md)**
>
> Le frère dense de 30B qui tient dans un seul GPU de 24 GB — même lignée Muse, matériel grand public.

> **[Routage MoE et parallélisme d'experts](/fr/concepts/moe-routing-and-expert-parallelism.md)**
>
> Comment les modèles mixture-of-experts routent les tokens et comment paralléliser sur plusieurs GPU.

> **[Agents de programmation avec des modèles locaux](/fr/guides/coding-agents-local-models.md)**
>
> Pointez Claude Code, Cline ou Aider vers un modèle que vous hébergez.

> **[Quel modèle tient dans votre GPU ?](/fr/guides/model-fit.md)**
>
> Dimensionnez le modèle et le contexte selon votre VRAM ou mémoire unifiée.

> **[Llama 4](/fr/models/llama-4.md)**
>
> L'autre lignée à poids ouverts de Meta, et pourquoi 17B actifs nécessitent quand même 67 GB.

> **[Démarrage rapide](/fr/quickstart.md)**
>
> Associez un connecteur et enregistrez votre premier modèle de bout en bout.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.