# MiniMax M2.7 (229B MoE para código)

{% hint style="info" %}
**Estado (abril de 2026):** MiniMax M2.7 se publicó en HuggingFace el **9 de abril de 2026** por MiniMaxAI y alcanzó **496 mil descargas en tres semanas** — por adopción, el mayor lanzamiento de pesos abiertos de nuestra actualización de abril. Los pesos están en [huggingface.co/MiniMaxAI/MiniMax-M2.7](https://huggingface.co/MiniMaxAI/MiniMax-M2.7) bajo una **licencia personalizada de MiniMax** (`licencia: otra`). Es **no** Apache/MIT — lee [la LICENCIA](https://huggingface.co/MiniMaxAI/MiniMax-M2.7/blob/main/LICENSE) antes de cualquier despliegue comercial.
{% endhint %}

{% hint style="warning" %}
**Corrección:** Las revisiones anteriores de nuestro índice de modelos listaban M2.7 como un modelo propietario solo por API. Eso era incorrecto al 9 de abril de 2026: los pesos son públicos. Esta guía reemplaza ese listado.
{% endhint %}

MiniMax M2.7 es un **modelo Mixture-of-Experts de 229 mil millones de parámetros** (256 expertos, 8 activos por token) y la última entrada de la familia M2 de MiniMax, una línea construida alrededor de **autoevolución / posentrenamiento impulsado por RL** y **codificación agéntica** cargas de trabajo. La versión 2.7 es el equivalente público y autohospedable del agente de codificación alojado de MiniMax y MiniMax la posiciona como competitiva con Claude Sonnet 4.5 en benchmarks agénticos, acercándose al territorio de Claude Opus 4.6 en algunos de ellos.

El detalle arquitectónico interesante es **Pensamiento Intercalado** (introducido en M2.1 y refinado a través de 2.5/2.7): el modelo alterna `<think>` bloques de razonamiento con generación normal a lo largo de llamadas a herramientas de múltiples turnos, de modo que la cadena de pensamiento sobrevive a través de los ida y vuelta de llamadas a funciones en lugar de descartarse en cada turno. Eso es lo que lo hace interesante para agentes de largo horizonte: el rastro de razonamiento no se reinicia cada vez que llegas a un `tool_use` límite.

Para los usuarios de Clore.ai, la noticia práctica es que M2.7 se entrega con un **checkpoint FP8 (float8\_e4m3fn)** en el repositorio oficial. Eso pone un despliegue en un solo nodo al alcance en **4× H100 80GB** o **2× H200 141GB** — no se requieren octetos H200 ni racks de 16 GPU. Si has estado ejecutando [GLM-5.1](/guides/guides_v2-es/modelos-de-lenguaje/glm-5-1.md) y quieres un segundo modelo de pesos abiertos en tu pila de agentes con un perfil de sesgo diferente, este es el que debes emparejar.

### Especificaciones clave

| Propiedad                   | Valor                                                                                                                                             |
| --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| Parámetros totales          | 229B (MoE, 256 expertos)                                                                                                                          |
| Expertos por token          | 8 de 256                                                                                                                                          |
| Parámetros activos          | **No publicado oficialmente** — consulta la tarjeta del modelo. La familia M2 históricamente \~10B activos; verifica antes de citar públicamente. |
| Tamaño oculto / Capas       | 3,072 / 62                                                                                                                                        |
| Atención                    | 48 cabezas, 8 KV (GQA)                                                                                                                            |
| Ventana de contexto         | 204.800 tokens (200K)                                                                                                                             |
| Tipos de tensor             | F32, BF16, F8\_E4M3                                                                                                                               |
| MTP                         | Predicción de múltiples tokens habilitada (3 módulos MTP)                                                                                         |
| Licencia                    | **MiniMax personalizada — no comercial por defecto**                                                                                              |
| Fecha de lanzamiento        | 9 de abril de 2026                                                                                                                                |
| Descargas en HF (3 semanas) | \~496 mil                                                                                                                                         |
| Muestreo recomendado        | `temperatura=1.0`, `top_p=0.95`, `top_k=40`                                                                                                       |
| Herramientas principales    | vLLM, SGLang, Transformers, KTransformers, MLX-LM                                                                                                 |

### ¿Por qué MiniMax M2.7?

* **Pesos abiertos de 229B** — el mayor modelo de codificación de pesos abiertos "real" que aún cabe en un solo nodo 4×H100 en FP8
* **Pensamiento Intercalado** — `<think>` los bloques sobreviven a través de los turnos de llamadas a herramientas, lo cual es genuinamente útil para agentes estilo SWE
* **Enfoque en codificación multilingüe** — MiniMax promociona un fuerte rendimiento en Rust, Go, Java, Kotlin, Swift y TypeScript, no solo en Python
* **Señal de adopción** — 496 mil descargas en tres semanas es la adopción comunitaria más fuerte de cualquier lanzamiento de pesos abiertos de abril de 2026 que hayamos rastreado
* **Soporte MTP** — la decodificación especulativa mediante módulos de Predicción de Múltiples Tokens viene integrada, lo que se traduce en rendimiento real en H100/H200
* **Alternativa alojada** — si tu carga de trabajo supera un solo nodo, el endpoint alojado de MiniMax existe; no tienes que decidirlo en la arquitectura

***

## Requisitos

{% hint style="warning" %}
**229B sigue siendo 229B.** Los pesos BF16 son \~460GB. El checkpoint FP8 es aproximadamente la mitad: \~230GB, que es lo que hace viable el despliegue en un solo nodo. Los quants comunitarios INT4 lo reducen a menos de \~120GB, pero no están oficialmente soportados.
{% endhint %}

| Componente  | Hobby (INT4 GGUF, offload)                | Recomendado (FP8 de un solo nodo) | BF16 completo                |
| ----------- | ----------------------------------------- | --------------------------------- | ---------------------------- |
| VRAM de GPU | GPU de 24–48GB + offload de RAM de 128GB+ | 4× H100 80GB **o** 2× H200 141GB  | 8× H100 80GB / 4× H200 141GB |
| VRAM total  | \~48GB GPU + offload                      | 320GB / 282GB                     | 640GB / 564GB                |
| RAM         | 128GB                                     | 256GB                             | 512GB                        |
| Disco       | 200GB NVMe                                | 400GB NVMe                        | 600GB NVMe                   |
| CUDA        | 12.0+                                     | 12.4+                             | 12.4+                        |

**Elección de Clore.ai:** El checkpoint FP8 en **2× H200** es el objetivo de despliegue más limpio: divisiones tensor-parallel mínimas, menos saltos NCCL y las matemáticas para contexto de 200K simplemente funcionan. **4× H100** es la alternativa más barata si el stock de H200 es limitado.

***

## Opción A — Ollama / GGUF (Cuantizado)

{% hint style="warning" %}
**Solo quants de la comunidad.** MiniMax no publica pesos GGUF oficiales para M2.7. Las compilaciones comunitarias Q4/Q5 suelen aparecer 1–2 semanas después del lanzamiento — busca [huggingface.co/models?search=minimax-m2.7+gguf](https://huggingface.co/models?search=minimax-m2.7+gguf) y verifica el uploader. La calidad varía en quants MoE por debajo de Q4.
{% endhint %}

```bash
# Una vez que llegue una compilación comunitaria Q4_K_M (comprueba HuggingFace primero)
docker exec ollama ollama pull minimax-m2.7:q4_K_M
docker exec ollama ollama run minimax-m2.7:q4_K_M

# O con llama.cpp directamente sobre un GGUF descargado
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
```

Solo para uso hobby. Para cargas de trabajo reales usa vLLM o SGLang contra el checkpoint FP8.

***

## Opción B — vLLM (API de producción, recomendado)

vLLM es el objetivo de servicio de primera clase. El checkpoint FP8 oficial es el que debes obtener: misma calidad que BF16 con aproximadamente la mitad de la VRAM.

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

```yaml
version: "3.8"
servicios:
  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 141GB

Reduce `--tensor-parallel-size` a 2 y aumenta `--max-model-len` para usar el margen:

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

### Prueba rápida

```bash
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "minimax-m2.7",
    "messages": [
      {"role": "system", "content": "Eres un ingeniero sénior. Usa Pensamiento Intercalado al razonar a través de llamadas a herramientas."},
      {"role": "user", "content": "Audita este manejador async de Rust para la seguridad de cancelación en tokio: ..."}
    ],
    "max_tokens": 4096,
    "temperature": 1.0,
    "top_p": 0.95
  }'
```

{% hint style="info" %}
**No bajes `temperature` por debajo de 1.0.** El muestreo recomendado por MiniMax es `T=1.0, top_p=0.95, top_k=40`. La decodificación codiciosa rompe silenciosamente el `<think>` intercalado en llamadas a herramientas de múltiples turnos.
{% endhint %}

***

## Opción C — SGLang

El programador MoE de SGLang es competitivo con vLLM en Hopper y a menudo gana en completaciones de codificación de contexto largo gracias a la decodificación especulativa EAGLE apilada con los módulos 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
```

Espera una mejora de rendimiento de \~1.5–2× sobre vLLM estándar en trazas largas de agentes. Reduce `--tp-size` a 2 en H200.

***

## Recomendaciones de GPU de Clore.ai

| Configuración                     | VRAM         | Rendimiento esperado                                         | Costo en Clore.ai |
| --------------------------------- | ------------ | ------------------------------------------------------------ | ----------------- |
| 1× RTX 4090 24GB + offload de RAM | 24GB + 128GB | Hobby INT4, \~5–10 tok/s                                     | \~$1–2/día        |
| 4× A100 80GB                      | 320GB        | BF16 fragmentado, \~15–25 tok/s                              | \~$15–22/día      |
| **4× H100 80GB (FP8)**            | **320GB**    | **Producción FP8, \~40–60 tok/s**                            | **\~$20–28/día**  |
| **2× H200 141GB (FP8)**           | **282GB**    | **Producción FP8, \~50–70 tok/s, contexto completo de 200K** | **\~$18–26/día**  |
| 8× H100 80GB                      | 640GB        | BF16 completo, \~80+ tok/s                                   | \~$40–55/día      |

{% hint style="success" %}
**Mejor valor:** 2× H200 con el checkpoint FP8. Misma clase de rendimiento que 4× H100 con la mitad de los saltos tensor-parallel; a menudo más barato por día en el mercado, y mantienes suficiente margen de VRAM para el contexto completo de 200K.
{% endhint %}

Renta las máquinas aquí:

* [**Rentar GPUs H200**](https://clore.ai/rent-h200.html) — recomendado para el despliegue FP8 de 2× H200
* [**Rentar GPUs H100**](https://clore.ai/rent-h100.html) — para el despliegue FP8 de 4× H100
* [**Rentar A100 80GB**](https://clore.ai/rent-a100-80gb.html) — alternativa BF16 multigPU
* [**Rentar RTX 4090**](https://clore.ai/rent-4090.html) — solo uso hobby INT4
* [**Mercado**](https://clore.ai/marketplace) — inventario completo, en demanda y subasta spot

***

## Casos de uso

* **Agentes SWE multilingües** — Rust, Go, Java, Kotlin, Swift y TypeScript reciben tratamiento de primera clase, no solo Python/JS
* **Bucles de llamadas a herramientas de largo horizonte** — Pensamiento Intercalado mantiene vivo el rastro de razonamiento a través de cientos de `tool_use` ida y vuelta
* **Auditorías de bases de código** — el contexto de 200K cabe un servicio de tamaño medio junto con sus pruebas en un solo prompt
* **Pipelines de refactorización** — corrección sostenida a través de muchas ediciones de archivos gracias a los módulos MTP
* **Orquestación agente-de-agentes** — usa M2.7 como planificador junto con un modelo más pequeño (Qwen3.5, GLM-4.7-Flash) como trabajador
* **Alternativa autohospedada a Claude Sonnet/Opus** para investigación de codificación no comercial — pero **lee primero la licencia**

***

## Benchmarks

{% hint style="warning" %}
**Reclamados por el proveedor — verifica de forma independiente.** Las cifras a continuación provienen de las notas de lanzamiento de MiniMax del 9 de abril de 2026. Aún están llegando reproducciones independientes.
{% endhint %}

| Benchmark        | MiniMax M2.7 | Claude Sonnet 4.5 (ref. del proveedor) | Claude Opus 4.6 (ref. del proveedor) | 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**     | —                                      | —                                    | —             |

La formulación de MiniMax: M2.7 iguala o supera a Claude Sonnet 4.5 en la suite de codificación agéntica que les importa, y queda a pocos puntos de Claude Opus 4.6 en SWE-Pro / VIBE-Pro. Tómalo como una señal direccional, no como una clasificación cerrada: la brecha con los modelos cerrados de frontera se reduce en cada lanzamiento.

***

## Familia MiniMax M2

| Versión  | Lanzamiento    | Enfoque arquitectónico                                        | Recomendado para                                       |
| -------- | -------------- | ------------------------------------------------------------- | ------------------------------------------------------ |
| M2       | oct 2025       | Lanzamiento inicial de MoE 229B, codificación ajustada por RL | Referencia / histórico                                 |
| M2.1     | dic 2025       | **Pensamiento Intercalado** introdujo                         | Primera versión que vale la pena ejecutar para agentes |
| M2.5     | feb 2026       | Posentrenamiento RL autoevolutivo, contexto más largo         | Modelo de codificación sólido si el disco es limitado  |
| **M2.7** | **9 abr 2026** | **Codificación multilingüe refinada, MTP, FP8 oficial**       | **Opción predeterminada — usa esta**                   |

Si empiezas desde cero, omite las versiones anteriores y ve directamente a M2.7. Las diferencias arquitectónicas se acumulan y la ergonomía de FP8 es notablemente mejor.

***

## Solución de problemas

| Problema                                              | Solución                                                                                                                                     |
| ----------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError` en la carga FP8                    | Se necesitan \~230GB de VRAM. Usa 4× H100 80GB o 2× H200 141GB. Baja `--max-model-len` a 32768 primero.                                      |
| Descarga lenta de HuggingFace                         | `huggingface-cli download MiniMaxAI/MiniMax-M2.7 --local-dir ./weights --resume-download`. Espera \~230GB FP8 / \~460GB BF16.                |
| Las llamadas a herramientas se omiten silenciosamente | Configura `--enable-auto-tool-choice --tool-call-parser hermes` en vLLM. M2.7 usa etiquetas de herramientas estilo Hermes.                   |
| `<think>` bloques vacíos o corruptos                  | El muestreo debe ser `temperature=1.0, top_p=0.95, top_k=40`. La decodificación codiciosa rompe Pensamiento Intercalado.                     |
| Errores MTP / desajuste de formas                     | Actualiza vLLM a la versión estable más reciente; el soporte MTP llegó tarde y las compilaciones antiguas no incluyen los módulos.           |
| OOM de contexto de 200K en H100                       | Usa `--enable-chunked-prefill` y empieza en `--max-model-len 65536`. El contexto completo de 200K requiere de forma realista H200.           |
| Confusión de licencia                                 | Predeterminado = no comercial. Envía un correo a `api@minimax.io` con asunto "M2.7 licensing" antes de cualquier uso en un producto de pago. |

***

## Siguientes pasos

* **Pariente de audio:** [MiniMax Speech](/guides/guides_v2-es/audio-y-voz/minimax-speech.md) — mismo proveedor, generación de audio/voz
* **Alternativa con licencia abierta:** [GLM-5.1](/guides/guides_v2-es/modelos-de-lenguaje/glm-5-1.md) — 744B / 40B activos, licencia MIT, top SWE-Bench Pro
* **Alternativa de contexto masivo:** [DeepSeek V4](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-v4.md) — 1M de contexto, multimodal
* **Opción agéntica más barata:** [GLM-4.7 Flash](/guides/guides_v2-es/modelos-de-lenguaje/glm-47-flash.md) — cabe en un solo H100, MIT
* **Mercado de Clore.ai:** [clore.ai/marketplace](https://clore.ai/marketplace) — H100/H200/A100 del mercado spot

### Enlaces

* [MiniMax M2.7 en HuggingFace](https://huggingface.co/MiniMaxAI/MiniMax-M2.7)
* [LICENCIA de MiniMax M2.7](https://huggingface.co/MiniMaxAI/MiniMax-M2.7/blob/main/LICENSE) — leer antes de uso comercial
* [Plataforma MiniMax](https://www.minimax.io)
* [documentación de vLLM](https://docs.vllm.ai)
* [repositorio de SGLang](https://github.com/sgl-project/sglang)
* [KTransformers](https://github.com/kvcache-ai/ktransformers)


---

# Agent Instructions: 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:

```
GET https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/minimax-m27.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.
