> ## 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 MiMo V2.6 en local — le modèle d'agent multimodal de Xiaomi

> Exécutez MiMo V2.6 en local — le MoE de 1.02T de Xiaomi avec 42B actifs, multimodal natif (texte/image/vidéo/audio), contexte de 1M, licence MIT. La distillation 9B tient sur un seul GPU.

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

MiMo V2.6 est la famille de modèles agents multimodaux de Xiaomi, publiée le 22 septembre 2026 sous la **licence MIT**. La gamme comprend 3 variantes — un modèle phare de 1.02 billion de paramètres (Pro), un cheval de bataille de production de 309B (Flash), et une distillation de 9B qui tient dans un seul GPU grand public — tous partageant une entrée multimodale native (texte, images, vidéo et audio), jusqu'à 128K tokens de sortie, et une fenêtre de contexte de 1M tokens.

La combinaison de l'échelle, de la couverture de modalités et de la licence est remarquable. Pro et Flash sont des architectures sparse mixture-of-experts qui nécessitent du matériel multi-GPU sérieux, mais la **9B Distill** ramène la famille à un seul GPU de 24 GB — c'est la première fois qu'un modèle de cette lignée fonctionne sur du matériel grand public que vous possédez probablement déjà.

> [!TIP]
>
> Vous hébergez déjà une variante MiMo ? [Enregistrez-la dans Tokios](/fr/setup/register-model.md) via `https://api.tokios.com` depuis n'importe quel client.

## La gamme MiMo V2.6

| Variante | Total paramètres | Paramètres actifs | Contexte | Idéal pour | Matériel |
| - | - | - | - | - | - |
| **Pro** | 1.02T | 42B | 1M | Programmation difficile, planification à long terme, cybersécurité, orchestration multi-outils | Serveur multi-GPU (\~520 GB+) |
| **Flash** | 309B | 15B | 1M | Automatisation à grand volume, boucles d'agents sensibles au coût | Système à grande mémoire (\~160 GB+) |
| **Distill** | 9B | 9B (dense) | 1M | Expériences locales, éducation, travail sur GPU unique | Un seul GPU de 24 GB |

Les 3 variantes sont sous licence MIT, acceptent le texte, les images, la vidéo et l'audio en entrée, produisent du texte en sortie, et prennent en charge jusqu'à 128K tokens de sortie.

## Quel MiMo exécuter ?

Votre matériel décide :

* **Un seul GPU de 24 GB** (RTX 3090, 4090 ou similaire) — exécutez la **Distill**. C'est un modèle dense de 9B distillé à partir de l'architecture Qwen, et c'est la seule variante MiMo qui tient sur du matériel grand public sans déchargement. Commencez ici pour les expériences, l'apprentissage et le travail léger d'agent.
* **Système à grande mémoire** (192 GB+ de mémoire unifiée, ou 2+ GPU de datacenter) — exécutez **Flash**. Avec 309B au total et 15B actifs par token, c'est le choix rentable pour les boucles d'agents en production où vous avez besoin d'entrée multimodale et de contexte long sans le plancher matériel de Pro.
* **Serveur multi-GPU** (4× H100 ou équivalent) — exécutez **Pro**. Le modèle phare de 1.02T est conçu pour les tâches les plus difficiles : programmation complexe, analyse de cybersécurité et orchestration multi-outils sur de longs horizons.

Le calcul transparent de dimensionnement pour les modèles MoE — la mémoire évolue avec les paramètres **totaux**, pas les actifs, car tous les poids des experts restent en mémoire même si le routage n'en active qu'une fraction par token (consultez [comment fonctionne l'inférence](/fr/concepts/how-inference-works.md)) :

* Pro : 1.02T × \~0.5 octets en 4 bits ≈ **\~510 GB** de poids, \~520 GB+ avec la surcharge
* Flash : 309B × \~0.5 octets en 4 bits ≈ **\~155 GB** de poids, \~160 GB+ avec la surcharge
* Distill : 9B × \~0.5 octets en 4 bits ≈ **\~4.5 GB** de poids, \~6 GB tel que livré

Ajoutez le [cache KV](/fr/concepts/kv-cache-and-context.md) pour votre longueur de contexte et votre concurrence en plus des poids.

## Exécutez-le en local

**vLLM — Pro (serveur multi-GPU)**

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
vllm serve XiaomiMiMo/MiMo-V2.6-Pro-RL \
  --tensor-parallel-size 8 \
  --trust-remote-code
```

Le parallélisme tensoriel s'applique à tous les GPU du serveur. Prévoyez \~520 GB+ de VRAM combinée pour les poids 4 bits plus le cache KV. vLLM sert une API compatible OpenAI sur `http://127.0.0.1:8000/v1` — c'est vers ce point que le connecteur Tokios se dirige. Confirmez les drapeaux pour votre version de vLLM auprès de la [fiche du modèle](https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Pro-RL) avant de standardiser. Consultez [Accès à distance vLLM](/fr/guides/vllm-remote-access.md).

**vLLM — Flash (serveur à grande mémoire)**

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
vllm serve XiaomiMiMo/MiMo-V2.6-Flash-MOPD \
  --tensor-parallel-size 4 \
  --trust-remote-code
```

Prévoyez \~160 GB+ de VRAM combinée. Une version communautaire NVFP4 ([`ProCreations/MiMo-V2.6-Flash-RL-NVFP4`](https://huggingface.co/ProCreations/MiMo-V2.6-Flash-RL-NVFP4)) est disponible pour les GPU Blackwell et peut réduire davantage l'empreinte mémoire. Confirmez auprès de la fiche du modèle avant de servir. Consultez [Accès à distance vLLM](/fr/guides/vllm-remote-access.md).

**SGLang — Pro ou Flash**

```bash Pro theme={"theme":{"light":"github-light","dark":"css-variables"}}
sglang serve XiaomiMiMo/MiMo-V2.6-Pro-RL \
  --tp 8 \
  --trust-remote-code
```

```bash Flash theme={"theme":{"light":"github-light","dark":"css-variables"}}
sglang serve XiaomiMiMo/MiMo-V2.6-Flash-MOPD \
  --tp 4 \
  --trust-remote-code
```

SGLang est une alternative à vLLM avec des caractéristiques de performance comparables. Ajustez `--tp` selon votre nombre de GPU. Consultez [Accès à distance SGLang](/fr/guides/sglang-remote-access.md).

**llama.cpp — Distill (GPU unique)**

```bash theme={"theme":{"light":"github-light","dark":"css-variables"}}
llama serve -hf XiaomiMiMo/MiMo-V2.6-Distill-9B
```

La Distill 9B tient dans un seul GPU de 24 GB en 4 bits. Confirmez le nom exact du dépôt HuggingFace sur [la page HuggingFace de XiaomiMiMo](https://huggingface.co/XiaomiMiMo) — des versions GGUF communautaires pourraient également apparaître une fois le modèle publié. Consultez [Accès à distance llama.cpp](/fr/guides/llama-cpp-remote-access.md).

> [!WARNING]
>
> N'inventez pas de noms de dépôt ou de drapeaux CLI pour les variantes MiMo. Les dépôts Pro et Flash ci-dessus sont confirmés. Le nom du dépôt Distill est une meilleure hypothèse basée sur le schéma de nommage de Xiaomi — vérifiez-le sur [la page HuggingFace de XiaomiMiMo](https://huggingface.co/XiaomiMiMo) avant de l'exécuter.

## Variantes et spécifications

Toutes les valeurs ci-dessous proviennent des fiches de modèle de Xiaomi sur Hugging Face. Vérifiez auprès de la fiche du modèle avant de standardiser sur l'une d'elles.

| Propriété | Pro | Flash | Distill |
| - | - | - | - |
| Hugging Face | [`XiaomiMiMo/MiMo-V2.6-Pro-RL`](https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Pro-RL) | [`XiaomiMiMo/MiMo-V2.6-Flash-MOPD`](https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Flash-MOPD) | Consultez [XiaomiMiMo](https://huggingface.co/XiaomiMiMo) |
| Paramètres | 1.02T au total / **42B actifs** | 309B au total / **15B actifs** | 9B (dense) |
| Architecture | Sparse MoE | Sparse MoE | Dense (distillation basée sur Qwen) |
| Fenêtre de contexte | 1M (1,048,576) | 1M (1,048,576) | 1M (1,048,576) |
| Tokens de sortie max | 128K | 128K | 128K |
| Modalités d'entrée | Texte, image, vidéo, audio | Texte, image, vidéo, audio | Texte, image, vidéo, audio |
| Sortie | Texte | Texte | Texte |
| Licence | MIT | MIT | MIT |
| Quantifications communautaires | — | [`ProCreations/MiMo-V2.6-Flash-RL-NVFP4`](https://huggingface.com/ProCreations/MiMo-V2.6-Flash-RL-NVFP4) | — |
| Idéal pour | Programmation difficile, planification à long terme, cybersécurité, orchestration multi-outils | Automatisation à grand volume, boucles d'agents sensibles au coût | Expériences locales, éducation, travail sur GPU unique |

Sources : [`XiaomiMiMo/MiMo-V2.6-Pro-RL`](https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Pro-RL), [`XiaomiMiMo/MiMo-V2.6-Flash-MOPD`](https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Flash-MOPD).

> [!NOTE]
>
> MiMo V2.6 est publié sous la **licence MIT**, qui est permissive et ne comporte pas de politique d'utilisation acceptable ni de seuil de nombre d'utilisateurs. Lisez le fichier `LICENSE` sur la fiche du modèle avant de construire un produit commercial dessus.

## Capacités

* **Entrée multimodale native.** Le texte, les images, la vidéo et l'audio entrent ; le texte sort. Ce n'est pas un module de vision ajouté — il fait partie de l'architecture de base pour les 3 variantes.
* **128K tokens de sortie.** Assez long pour le raisonnement étendu, la génération de code à l'échelle d'un dépôt et l'analyse détaillée sans troncature.
* **Fenêtre de contexte de 1M.** Assez grande pour des sessions de programmation à l'échelle d'un dépôt, de longs documents ou des heures d'audio. Prévoyez de la [mémoire du cache KV](/fr/concepts/kv-cache-and-context.md) en plus des poids lors du dimensionnement d'un déploiement à contexte long.
* **Appel d'outils et workflows agentiques.** Toutes les variantes prennent en charge l'utilisation d'outils et les boucles d'agents multi-étapes. Lorsque vous servez avec vLLM ou SGLang, activez le parseur d'appels d'outils que la fiche du modèle recommande pour que les requêtes `tools` fonctionnent via votre point de terminaison.
* **Licence MIT.** Permissive pour les 3 variantes — pas de politique d'utilisation acceptable, pas de seuil de nombre d'utilisateurs.

### Benchmarks

Rapportés par Xiaomi, sur un modèle publié récemment. Aucune reproduction indépendante n'existe encore — considérez ces chiffres comme des affirmations du fabricant jusqu'à ce que des évaluations tierces apparaissent.

| Benchmark | Pro | Flash |
| - | - | - |
| Programmation (style HumanEval) | Rapporté par le fabricant | Rapporté par le fabricant |
| Tâches agentiques | Rapporté par le fabricant | Rapporté par le fabricant |
| Compréhension multimodale | Rapporté par le fabricant | Rapporté par le fabricant |

Les scores spécifiques seront ajoutés une fois les évaluations indépendantes publiées. Pour l'instant, comparez Pro et Flash avec [Kimi K2.6](/fr/models/kimi.md) et [Qwen3.8-27B](/fr/models/qwen3.8.md) sur votre propre charge de travail.

## Adéquation matérielle

Les verdicts supposent une quantification 4 bits à une longueur de contexte modeste.

| Cible | Pro (\~520 GB+) | Flash (\~160 GB+) | Distill (\~6 GB) |
| - | - | - | - |
| RTX 4070 Ti Super / 4080 (16 GB) | Ne tient pas | Ne tient pas | À l'aise |
| RTX 3090 / 4090 (24 GB) | Ne tient pas | Ne tient pas | À l'aise |
| RTX 5090 (32 GB, Blackwell) | Ne tient pas | Ne tient pas | À l'aise, contexte long |
| 2× RTX 4090 (48 GB regroupés) | Ne tient pas | Serré, contexte court | À l'aise |
| 4× RTX 4090 (96 GB regroupés) | Ne tient pas | Faisable | À l'aise |
| Apple Silicon (64 GB unifiée) | Ne tient pas | Ne tient pas | À l'aise |
| Apple Silicon (192 GB+ unifiée) | Ne tient pas | Faisable | À l'aise |
| DGX Spark (128 GB unifiée) | Ne tient pas | Serré | À l'aise |
| 2× DGX Spark (256 GB regroupés) | Ne tient pas | À l'aise | À l'aise |
| Serveur multi-GPU (8× H100, 640 GB) | À l'aise | À l'aise | À l'aise |

Le modèle Pro nécessite \~520 GB+ de VRAM combinée — c'est un système 4× H100 ou 8× A100, ou un grand pool de GPU grand public avec une quantification agressive. Flash à \~160 GB tient dans un Mac Studio à grande mémoire, 2 DGX Sparks, ou un serveur 4-GPU. La Distill à \~6 GB tient dans n'importe quel GPU moderne avec 24 GB de VRAM et laisse encore de la marge pour le contexte.

Sur du matériel partagé, les variantes Flash et Distill se disputent le même pool mémoire que le cache KV à de longues longueurs de contexte. Commencez par un contexte modeste, mesurez, puis augmentez-le. 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.

## Connectez-le avec Tokios

Un modèle local toujours actif est un modèle que vous voulez atteindre lorsque vous n'êtes pas devant la machine qui l'exécute. 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 MiMo V2.6 dans vLLM, SGLang ou llama.cpp et laissez-le lié à la boucle locale.

**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 `XiaomiMiMo/MiMo-V2.6-Flash-MOPD`) sous un nom de déploiement public comme `mimo-flash`. 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": "mimo-flash",
    "stream": true,
    "messages": [
      {"role": "user", "content": "Analyze this codebase and propose a refactoring plan."}
    ]
  }'
```

```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 mimo-flash
```

## Mises en garde

* **Pro et Flash sont des modèles MoE.** Les 1.02T (Pro) ou 309B (Flash) paramètres doivent tenir en mémoire même si seuls 42B ou 15B sont actifs par token — consultez [comment fonctionne l'inférence](/fr/concepts/how-inference-works.md).
* **Le contexte 1M est un plafond, pas une cible.** Les contextes longs ajoutent de la mémoire de cache KV en plus des poids du modèle. Sur du matériel partagé, cette marge est aussi ce que le modèle utilise pour l'inférence.
* **Les benchmarks sont rapportés par le fabricant.** Xiaomi les a publiés le jour de la sortie. Attendez les évaluations indépendantes avant de considérer les scores comme définitifs.
* **Flash est le choix pratique pour la plupart des configurations de production.** Pro nécessite \~520 GB+ de VRAM combinée — un serveur multi-GPU sérieux. Flash à \~160 GB tient dans une station de travail à grande mémoire ou un serveur plus petit, et couvre la plupart des charges de travail de boucles d'agents.
* **La Distill est une distillation, pas l'architecture complète.** Elle échange l'échelle MoE contre une tenue sur GPU unique. Attendez-vous à ce qu'elle soit plus faible que Pro et Flash sur les tâches les plus difficiles, mais c'est la seule variante qui fonctionne sur du matériel grand public.
* **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).

## FAQ

> **How much VRAM does MiMo V2.6 Pro need?**
>
> \~520 GB+ de VRAM combinée en 4 bits. Le calcul transparent : 1.02T paramètres × \~0.5 octets en 4 bits ≈ \~510 GB de poids, plus la surcharge pour les embeddings et les métadonnées. Cela signifie un serveur multi-GPU — 4× H100 (320 GB) ne suffit pas ; prévoyez 8× A100 (640 GB) ou équivalent.

> **Can I run MiMo V2.6 on a single GPU?**
>
> Oui — la variante **Distill** est un modèle dense de 9B qui tient dans un seul GPU de 24 GB en 4 bits (\~6 GB). Elle est distillée à partir de l'architecture Qwen et c'est la seule variante MiMo qui fonctionne sur du matériel grand public. Pro et Flash nécessitent des systèmes multi-GPU.

> **Is MiMo V2.6 open source?**
>
> Les 3 variantes sont publiées sous la **licence MIT**, qui est permissive et ne comporte pas de politique d'utilisation acceptable ni de seuil de nombre d'utilisateurs. Notez que 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.

> **What is the difference between Pro, Flash, and Distill?**
>
> **Pro** (1.02T au total, 42B actifs) est le modèle phare pour la programmation difficile, la cybersécurité et la planification à long terme. **Flash** (309B au total, 15B actifs) est le cheval de bataille de production pour les boucles d'agents à grand volume. **Distill** (9B, dense) tient dans un seul GPU pour les expériences et l'éducation. Les 3 partagent les mêmes capacités d'entrée multimodale et la licence MIT.

> **How does MiMo V2.6 compare to Kimi or Qwen?**
>
> MiMo V2.6 Pro et Flash sont des modèles MoE dans la même classe d'échelle que [Kimi K2.6](/fr/models/kimi.md) (1T au total, 32B actifs) mais avec une entrée audio native et une fenêtre de contexte plus grande. La Distill à 9B est en concurrence avec [Qwen3.8-27B](/fr/models/qwen3.8.md) et [Muse Glimmer](/fr/models/muse-glimmer.md) pour le travail sur GPU unique, bien qu'elle soit plus petite. Comparez-les sur votre propre charge de travail — la licence MIT les rend tous faciles à tester.

> **Can I use MiMo V2.6 with a coding agent?**
>
> Oui — toutes les variantes prennent en charge l'appel d'outils et les workflows agentiques. Le fait qu'un agent spécifique fonctionne dépend de la façon dont votre environnement d'exécution expose les appels d'outils. Consultez [compatibilité des agents de programmation](/fr/guides/coding-agent-compatibility.md) pour la matrice et [agents de programmation avec des modèles locaux](/fr/guides/coding-agents-local-models.md) pour la configuration.

> **What audio formats does MiMo V2.6 accept?**
>
> Consultez la fiche du modèle pour les formats audio et les taux d'échantillonnage spécifiques pris en charge. Tokios transmet le contenu audio au point de terminaison amont sans modification — il ne transcode ni ne rééchantillonne.

> **[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.

> **[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.

> **[Kimi](/fr/models/kimi.md)**
>
> La famille MoE 1T de Moonshot AI — échelle comparable, licence différente.

> **[Qwen3.8](/fr/models/qwen3.8.md)**
>
> Le modèle dense vision-langage de 27B d'Alibaba, également Apache-2.0.

> **[Accédez-y depuis votre téléphone](/fr/use-cases/local-model-on-your-phone.md)**
>
> Utilisez un modèle local toujours actif lorsque vous êtes éloigné de la machine.

> **[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.