> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/minimax-m27.md).

# MiniMax M2.7 (codage MoE 229B)

Déployez MiniMax M2.7 (MoE 229B) sur Clore.ai — la version open-weight auto-hébergeable derrière l'offensive d'agent de codage de MiniMax, avec déploiement FP8 sur un seul nœud sur H100/H200

{% hint style="info" %}
**Statut (avril 2026) :** MiniMax M2.7 a été publié sur HuggingFace le **9 avril 2026** par MiniMaxAI et a atteint **496 k téléchargements en trois semaines** — en termes d’adoption, la plus grande version open-weight de notre rafraîchissement d’avril. Les poids sont disponibles à [huggingface.co/MiniMaxAI/MiniMax-M2.7](https://huggingface.co/MiniMaxAI/MiniMax-M2.7) sous une **licence MiniMax personnalisée** (`licence : autre`). C'est **pas** Apache/MIT — lire [le fichier LICENSE](https://huggingface.co/MiniMaxAI/MiniMax-M2.7/blob/main/LICENSE) avant tout déploiement commercial.
{% endhint %}

{% hint style="warning" %}
**Correction :** Les versions précédentes de notre index de modèles indiquaient M2.7 comme un modèle propriétaire accessible uniquement via API. C'était faux au 9 avril 2026 — les poids sont publics. Ce guide remplace cette entrée.
{% endhint %}

MiniMax M2.7 est un **Mixture-of-Experts à 229 milliards de paramètres** modèle (256 experts, 8 actifs par jeton) et la dernière entrée de la famille M2 de MiniMax — une ligne construite autour du **post-entraînement auto-évolutif / piloté par RL** et **codage agentique** charges de travail. La version 2.7 est la contrepartie publique, auto-hébergeable, de l'agent de codage hébergé de MiniMax et MiniMax la positionne comme compétitive avec Claude Sonnet 4.5 sur les benchmarks agentiques, tout en se rapprochant du territoire de Claude Opus 4.6 sur quelques-uns d'entre eux.

Le détail architectural intéressant est **Pensée entrelacée** (introduite dans M2.1 et affinée au fil de 2.5/2.7) : le modèle alterne `<think>` des blocs de raisonnement avec la génération normale sur plusieurs appels d'outils en plusieurs tours, de sorte que la chaîne de pensée survit aux allers-retours des appels de fonctions au lieu d'être jetée à chaque tour. C'est ce qui le rend intéressant pour les agents à long horizon — la trace de raisonnement ne se réinitialise pas à chaque fois que vous atteignez une `tool_use` limite.

Pour les utilisateurs de Clore.ai, la nouvelle pratique est que M2.7 est livré avec un **point de contrôle FP8 (float8\_e4m3fn)** sur le dépôt officiel. Cela rend un déploiement sur un seul nœud possible sur **4× H100 80 Go** ou **2× H200 141 Go** — pas besoin de racks H200 octets ou de racks 16 GPU. Si vous faisiez tourner [GLM-5.1](/guides/guides_v2-fr/modeles-de-langage/glm-5-1.md) et que vous voulez un deuxième modèle open-weight dans votre pile d'agents avec un profil de biais différent, c'est celui à associer.

### Spécifications clés

| Propriété                       | Valeur                                                                                                                                          |
| ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| Paramètres totaux               | 229B (MoE, 256 experts)                                                                                                                         |
| Experts par jeton               | 8 sur 256                                                                                                                                       |
| Paramètres actifs               | **Non publié officiellement** — voir la fiche du modèle. La famille M2 a historiquement \~10B actifs ; vérifiez avant de le citer publiquement. |
| Taille cachée / Couches         | 3,072 / 62                                                                                                                                      |
| Attention                       | 48 têtes, 8 KV (GQA)                                                                                                                            |
| Fenêtre de contexte             | 204 800 jetons (200K)                                                                                                                           |
| Types de tenseurs               | F32, BF16, F8\_E4M3                                                                                                                             |
| MTP                             | Prédiction multi-jetons activée (3 modules MTP)                                                                                                 |
| Licence                         | **Licence MiniMax personnalisée — non commerciale par défaut**                                                                                  |
| Date de sortie                  | 9 avril 2026                                                                                                                                    |
| Téléchargements HF (3 semaines) | \~496 k                                                                                                                                         |
| Échantillonnage recommandé      | `temperature=1.0`, `top_p=0.95`, `top_k=40`                                                                                                     |
| Outils principaux               | vLLM, SGLang, Transformers, KTransformers, MLX-LM                                                                                               |

### Pourquoi MiniMax M2.7 ?

* **Poids ouverts à 229B** — le plus grand modèle de codage "réel" à poids ouverts qui tient encore sur un seul nœud 4×H100 en FP8
* **Pensée entrelacée** — `<think>` les blocs survivent d'un tour d'appel d'outil à l'autre, ce qui est réellement utile pour les agents de type SWE
* **Accent sur le codage multilingue** — MiniMax met en avant de solides performances en Rust, Go, Java, Kotlin, Swift et TypeScript, pas seulement en Python
* **Signal d'adoption** — 496 k téléchargements en trois semaines est l'adoption communautaire la plus forte de toute version open-weight d'avril 2026 que nous suivons
* **Prise en charge MTP** — le décodage spéculatif via les modules Multi-Token Prediction est intégré, ce qui se traduit par un débit réel sur H100/H200
* **Solution de repli hébergée** — si votre charge de travail dépasse un seul nœud, le point de terminaison hébergé de MiniMax existe ; vous n'avez pas à choisir au stade de l'architecture

***

## Exigences

{% hint style="warning" %}
**Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai.** Les plus grosses machines répertoriées aujourd’hui sont 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est proposée en bare metal sur demande. Consultez [bare metal](https://clore.ai/bare-metal) sur demande. Consultez [Tarifs et disponibilité des GPU](/guides/guides_v2-fr/premiers-pas/pricing.md) avant de dimensionner un déploiement.
{% endhint %}

{% hint style="warning" %}
**229B, c'est toujours 229B.** Les poids BF16 font \~460 Go. Le point de contrôle FP8 en fait environ la moitié — \~230 Go — ce qui rend possible un déploiement sur un seul nœud. Les quantifications INT4 de la communauté le font descendre sous \~120 Go, mais elles ne sont pas officiellement prises en charge.
{% endhint %}

| Composant   | Loisir (INT4 GGUF, déchargement)                | Recommandé (FP8 sur un seul nœud)   | BF16 complet                   |
| ----------- | ----------------------------------------------- | ----------------------------------- | ------------------------------ |
| VRAM GPU    | GPU 24–48 Go + déchargement vers 128 Go+ de RAM | 4× H100 80 Go **ou** 2× H200 141 Go | 8× H100 80 Go / 4× H200 141 Go |
| VRAM totale | \~48 Go GPU + déchargement                      | 320 Go / 282 Go                     | 640 Go / 564 Go                |
| RAM         | 128 Go                                          | 256GB                               | 512GB                          |
| Disque      | 200 Go NVMe                                     | 400 Go NVMe                         | 600 Go NVMe                    |
| CUDA        | 12.8+                                           | 12.8+                               | 12.8+                          |

**Choix Clore.ai :** Le point de contrôle FP8 sur **2× H200** est la cible de déploiement la plus propre — répartitions tensor-parallel minimales, moins de sauts NCCL, et les calculs pour le contexte 200K fonctionnent tout simplement. **4× H100** est l'alternative moins chère si le stock H200 est serré.

***

## Option A — Ollama / GGUF (quantifié)

{% hint style="warning" %}
**Uniquement des quantifications communautaires.** MiniMax ne publie pas de poids GGUF officiels pour M2.7. Les builds communautaires Q4/Q5 apparaissent généralement 1 à 2 semaines après la sortie — recherchez [huggingface.co/models?search=minimax-m2.7+gguf](https://huggingface.co/models?search=minimax-m2.7+gguf) et vérifiez l'uploader. La qualité varie pour les quantifs MoE en dessous de Q4.
{% endhint %}

```bash
# Une fois qu'une version communautaire Q4_K_M est disponible (vérifiez d'abord sur HuggingFace)
docker exec ollama ollama pull minimax-m2.7:q4_K_M
docker exec ollama ollama run minimax-m2.7:q4_K_M

# Ou avec llama.cpp directement sur un GGUF téléchargé
docker run --gpus all -it --rm -p 8080:8080 \
  -v $(pwd)/models:/models \
  ghcr.io/ggerganov/llama.cpp:server-cuda \
  -m /models/minimax-m2.7-q4_k_m.gguf \\
  --n-gpu-layers 80 --ctx-size 32768 \\
  --temp 1.0 --top-p 0.95 --top-k 40 \\
  --port 8080 --host 0.0.0.0
```

Réservé à un usage de loisir. Pour de vraies charges de travail, utilisez vLLM ou SGLang sur le point de contrôle FP8.

***

## Option B — vLLM (API de production, recommandé)

vLLM est la cible de service de premier plan. Le point de contrôle FP8 officiel est celui à télécharger — même qualité que BF16 pour environ la moitié de la VRAM.

### docker-compose.yml — 4× H100 80 Go

```yaml
version: "3.8"
services:
  vllm:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - hf_cache:/root/.cache/huggingface
    command: >
      --model MiniMaxAI/MiniMax-M2.7
      --quantization fp8
      --tensor-parallel-size 4
      --max-model-len 65536
      --gpu-memory-utilization 0.88
      --enable-auto-tool-choice
      --tool-call-parser hermes
      --served-model-name minimax-m2.7
      --trust-remote-code
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    shm_size: "16gb"

volumes:
  hf_cache:
```

### docker-compose.yml — 2× H200 141 Go

Réduisez `--tensor-parallel-size` à 2 et augmentez `--max-model-len` pour utiliser la marge :

```yaml
    command: >
      --model MiniMaxAI/MiniMax-M2.7
      --quantization fp8
      --tensor-parallel-size 2
      --max-model-len 131072
      --gpu-memory-utilization 0.90
      --enable-auto-tool-choice
      --tool-call-parser hermes
      --enable-chunked-prefill
      --served-model-name minimax-m2.7
      --trust-remote-code
```

### Test rapide

```bash
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "minimax-m2.7",
    "messages": [
      {"role": "system", "content": "Vous êtes un ingénieur senior. Utilisez la pensée entrelacée lorsque vous raisonnez à travers des appels d'outils."},
      {"role": "user", "content": "Auditez ce gestionnaire async Rust pour la sécurité d'annulation tokio : ..."}
    ],
    "max_tokens": 4096,
    "temperature": 1.0,
    "top_p": 0.95
  }'
```

{% hint style="info" %}
**N'abaissez pas `temperature` en dessous de 1.0.** L'échantillonnage recommandé par MiniMax est `T=1.0, top_p=0.95, top_k=40`. Le décodage gourmand casse silencieusement `<think>` l'entrelacement sur les appels d'outils multi-tours.
{% endhint %}

***

## Option C — SGLang

Le planificateur MoE de SGLang est compétitif avec vLLM sur Hopper et gagne souvent sur les complétions de codage à long contexte grâce au décodage spéculatif EAGLE qui se combine avec les modules MTP de M2.7.

```bash
docker pull lmsysorg/sglang:latest

python3 -m sglang.launch_server \
  --model-path MiniMaxAI/MiniMax-M2.7 \\
  --quantization fp8 \
  --tp-size 4 \\
  --mem-fraction-static 0.88 \\
  --context-length 65536 \\
  --enable-mixed-chunk \\
  --speculative-algorithm EAGLE \\
  --speculative-num-steps 3 \\
  --speculative-eagle-topk 1 \\
  --speculative-num-draft-tokens 4 \\
  --served-model-name minimax-m2.7 \\
  --trust-remote-code
```

Attendez-vous à un gain de débit d'environ 1,5 à 2× par rapport à vLLM vanilla sur de longues traces d'agent. Réduisez `--tp-size` à 2 sur H200.

***

## Recommandations GPU Clore.ai

| Configuration                                | VRAM           | Performances attendues                                      | Coût Clore.ai                                 |
| -------------------------------------------- | -------------- | ----------------------------------------------------------- | --------------------------------------------- |
| 1× RTX 4090 24 Go + déchargement vers la RAM | 24 Go + 128 Go | INT4 de loisir, \~5–10 tok/s                                | 0,14–0,42 $/h                                 |
| 4× A100 80 Go                                | 320 Go         | BF16 découpé, \~15–25 tok/s                                 | [bare metal](https://clore.ai/bare-metal)     |
| **4× H100 80 Go (FP8)**                      | **320 Go**     | **FP8 de production, \~40–60 tok/s**                        | **\~4,16 $/h**                                |
| **2× H200 141 Go (FP8)**                     | **282 Go**     | **FP8 de production, \~50–70 tok/s, contexte complet 200K** | [**bare metal**](https://clore.ai/bare-metal) |
| 8× H100 80GB                                 | 640 Go         | BF16 complet, \~80+ tok/s                                   | \~8,32 $/h                                    |

{% hint style="success" %}
**Meilleur rapport qualité-prix :** 2× H200 avec le point de contrôle FP8. Même classe de débit que 4× H100 avec moitié moins de sauts tensor-parallel, souvent moins cher par jour sur la place de marché, et vous gardez suffisamment de marge VRAM pour le contexte complet 200K.
{% endhint %}

Louez les machines ici :

* [**H200 en bare metal**](https://clore.ai/bare-metal) — recommandé pour le déploiement FP8 2× H200
* [**Louez des GPU H100**](https://clore.ai/rent-h100.html) — pour le déploiement FP8 4× H100
* [**A100 80 Go en bare metal**](https://clore.ai/bare-metal) — solution de repli BF16 multi-GPU
* [**Louer une RTX 4090**](https://clore.ai/rent-4090.html) — uniquement pour un usage de loisir INT4
* [**Place de marché**](https://clore.ai/marketplace) — inventaire complet, enchères à la demande et au comptant

***

## Cas d’usage

* **Agents SWE multilingues** — Rust, Go, Java, Kotlin, Swift et TypeScript bénéficient d'un traitement de premier ordre, pas seulement Python/JS
* **Boucles d'appels d'outils à long horizon** — la pensée entrelacée maintient la trace de raisonnement vivante sur des centaines de `tool_use` allers-retours
* **Audits de bases de code** — le contexte 200K permet de faire tenir un service de taille moyenne et ses tests dans un seul prompt
* **Pipelines de refactorisation** — correction soutenue sur de nombreuses modifications de fichiers grâce aux modules MTP
* **Orchestration d'agents d'agents** — associez M2.7 comme planificateur à un modèle plus petit (Qwen3.5, GLM-4.7-Flash) comme exécutant
* **Alternative auto-hébergée à Claude Sonnet/Opus** pour la recherche en codage non commerciale — mais **lisez d'abord la licence**

***

## Benchmarks

{% hint style="warning" %}
**Déclaré par le fournisseur — vérifiez indépendamment.** Les chiffres ci-dessous proviennent des notes de version de MiniMax du 9 avril 2026. Les reproductions indépendantes continuent d'arriver.
{% endhint %}

| Benchmark        | MiniMax M2.7 | Claude Sonnet 4.5 (réf. fournisseur) | Claude Opus 4.6 (réf. fournisseur) | GPT-5.3-Codex |
| ---------------- | ------------ | ------------------------------------ | ---------------------------------- | ------------- |
| SWE-Pro          | **56.22%**   | \~55%                                | \~57.3%                            | 56.2%         |
| VIBE-Pro         | **55.6%**    | —                                    | \~57%                              | —             |
| Terminal Bench 2 | **57.0%**    | —                                    | —                                  | —             |
| GDPval-AA (ELO)  | **1495**     | —                                    | —                                  | —             |

Le cadrage de MiniMax : M2.7 égalise ou dépasse Claude Sonnet 4.5 sur la suite de codage agentique qui compte pour eux, et se situe à quelques points de Claude Opus 4.6 sur SWE-Pro / VIBE-Pro. Considérez cela comme un signal directionnel, pas comme un classement arrêté — l'écart avec les modèles fermés de pointe se réduit à chaque version.

***

## Famille MiniMax M2

| Version  | Publié          | Orientation architecturale                             | Recommandé pour                                             |
| -------- | --------------- | ------------------------------------------------------ | ----------------------------------------------------------- |
| M2       | Oct 2025        | Première version MoE 229B, codage ajusté par RL        | Référence / historique                                      |
| M2.1     | Déc 2025        | **Pensée entrelacée** introduit                        | Première version qui mérite d'être exécutée pour les agents |
| M2.5     | Fév 2026        | Post-entraînement RL auto-évolutif, contexte plus long | Bon modèle de codage si l'espace disque est limité          |
| **M2.7** | **9 avr. 2026** | **Codage multilingue affiné, MTP, FP8 officiel**       | **Choix par défaut — utilisez ceci**                        |

Si vous repartez de zéro, sautez les versions antérieures et passez directement à M2.7. Les différences architecturales se cumulent et l'ergonomie FP8 est sensiblement meilleure.

***

## Dépannage

| Problème                                | Solution                                                                                                                                         |
| --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| `OutOfMemoryError` en charge FP8        | Nécessite \~230 Go de VRAM. Utilisez 4× H100 80 Go ou 2× H200 141 Go. Réduisez `--max-model-len` à 32768 d'abord.                                |
| Téléchargement HuggingFace lent         | `huggingface-cli download MiniMaxAI/MiniMax-M2.7 --local-dir ./weights --resume-download`. Attendez-vous à \~230 Go FP8 / \~460 Go BF16.         |
| Appels d'outils ignorés silencieusement | Définissez `--enable-auto-tool-choice --tool-call-parser hermes` dans vLLM. M2.7 utilise des balises d'outils de style Hermes.                   |
| `<think>` blocs vides ou corrompus      | L'échantillonnage doit être `temperature=1.0, top_p=0.95, top_k=40`. Le décodage gourmand casse Interleaved Thinking.                            |
| Erreurs MTP / incompatibilité de forme  | Mettez vLLM à jour vers la dernière version stable ; la prise en charge MTP est arrivée tard et les anciennes builds n'incluent pas les modules. |
| OOM du contexte 200K sur H100           | Utilisez `--enable-chunked-prefill` et commencez à `--max-model-len 65536`. Le contexte complet 200K nécessite en pratique un H200.              |
| Confusion sur la licence                | Par défaut = non commercial. Envoyez un e-mail à `api@minimax.io` avec pour objet « Licensing M2.7 » avant tout usage payant du produit.         |

***

## Étapes suivantes

* **Sœur audio :** [MiniMax Speech](/guides/guides_v2-fr/audio-et-voix/minimax-speech.md) — même fournisseur, génération audio/voix
* **Alternative à licence ouverte :** [GLM-5.1](/guides/guides_v2-fr/modeles-de-langage/glm-5-1.md) — 744B / 40B actifs, licence MIT, top SWE-Bench Pro
* **Alternative à très grand contexte :** [DeepSeek V4](/guides/guides_v2-fr/modeles-de-langage/deepseek-v4.md) — contexte 1M, multimodal
* **Option agentique moins chère :** [GLM-4.7 Flash](/guides/guides_v2-fr/modeles-de-langage/glm-47-flash.md) — tient sur un seul H100, MIT
* **Place de marché Clore.ai :** [clore.ai/marketplace](https://clore.ai/marketplace) — H100/H200/A100 sur le marché spot

### Liens

* [MiniMax M2.7 sur HuggingFace](https://huggingface.co/MiniMaxAI/MiniMax-M2.7)
* [Licence MiniMax M2.7](https://huggingface.co/MiniMaxAI/MiniMax-M2.7/blob/main/LICENSE) — à lire avant usage commercial
* [Plateforme MiniMax](https://www.minimax.io)
* [documentation vLLM](https://docs.vllm.ai)
* [dépôt SGLang](https://github.com/sgl-project/sglang)
* [KTransformers](https://github.com/kvcache-ai/ktransformers)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/minimax-m27.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
