> 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-es/modelos-de-lenguaje/minimax-m27.md).

# 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 [el archivo LICENSE](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 enumeraban M2.7 como un modelo propietario solo de API. Eso era incorrecto al 9 de abril de 2026: los pesos son públicos. Esta guía reemplaza esa entrada.
{% 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 **posentrenamiento autoevolutivo / impulsado por RL** y **codificación agéntica** cargas de trabajo. La versión 2.7 es la contraparte pública y autoalojable 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 en 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, por lo que la cadena de pensamiento sobrevive entre idas y vueltas 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 alcanzas un `tool_use` límite.

Para los usuarios de Clore.ai, la noticia práctica es que M2.7 se ofrece con un **checkpoint FP8 (float8\_e4m3fn)** en el repositorio oficial. Eso hace que un despliegue en un solo nodo sea alcanzable en **4× H100 80GB** o **2× H200 141 GB** — no se necesitan 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 combinar con él.

### Especificaciones clave

| Propiedad                   | Valor                                                                                                                                     |
| --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
| Parámetros totales          | 229B (MoE, 256 expertos)                                                                                                                  |
| Expertos por token          | 8 de 256                                                                                                                                  |
| Parámetros activos          | **No publicado oficialmente** — ver ficha del modelo. La familia M2 históricamente \~10B activos; verifica antes de citarlo 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 personalizado — no comercial por defecto**                                                                                      |
| Fecha de lanzamiento        | 9 de abril de 2026                                                                                                                        |
| Descargas en HF (3 semanas) | \~496 mil                                                                                                                                 |
| Muestreo recomendado        | `temperature=1.0`, `top_p=0.95`, `top_k=40`                                                                                               |
| Herramientas principales    | vLLM, SGLang, Transformers, KTransformers, MLX-LM                                                                                         |

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

* **Pesos abiertos a 229B** — el mayor modelo de codificación de pesos abiertos "real" que todavía cabe en un solo nodo 4×H100 en FP8
* **Pensamiento Intercalado** — `<think>` los bloques sobreviven entre turnos de llamadas a herramientas, lo cual es realmente útil para agentes de estilo SWE
* **Enfoque de codificación multilingüe** — MiniMax promociona un rendimiento sólido 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 acogida comunitaria más fuerte de cualquier lanzamiento de pesos abiertos de abril de 2026 que hayamos seguido
* **Compatibilidad con MTP** — la decodificación especulativa mediante módulos Multi-Token Prediction está integrada, lo que se traduce en rendimiento real en H100/H200
* **Alternativa alojada** — si tu carga de trabajo supera un solo nodo, existe el endpoint alojado de MiniMax; no tienes que decidirlo en la arquitectura

***

## Requisitos

{% hint style="warning" %}
**Los equipos multinodo de clase 80GB no aparecen listados en el marketplace de Clore.ai.** Los equipos más grandes listados hoy son 4× RTX PRO 6000 Blackwell (96GB cada una, 380GB en total) y 8–11× RTX 5090 (32GB cada una). La capacidad A100 / H200 / B200 se vende como [bare metal](https://clore.ai/bare-metal) bajo pedido. Consulta [Precios y disponibilidad de GPU](/guides/guides_v2-es/primeros-pasos/pricing.md) antes de dimensionar un despliegue.
{% endhint %}

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

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

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

***

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

{% hint style="warning" %}
**Solo cuantizados 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 cargador. La calidad varía en cuantizaciones MoE por debajo de Q4.
{% endhint %}

```bash
# Una vez que aparezca una compilación comunitaria Q4_K_M (comprueba primero HuggingFace)
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 aficionado. 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 usar: la misma calidad que BF16 con aproximadamente la mitad de la VRAM.

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

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

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 senior. Usa Pensamiento Intercalado al razonar entre llamadas a herramientas."},
      {"role": "user", "content": "Audita este manejador asíncrono en Rust para la seguridad ante cancelaciones de 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 greedy rompe silenciosamente la `<think>` intercalación en llamadas a herramientas de múltiples turnos.
{% endhint %}

***

## Opción C — SGLang

El programador MoE de SGLang compite con vLLM en Hopper y a menudo gana en completions de codificación de contexto largo gracias a que la decodificación especulativa EAGLE se apila 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 de agente largas. Reduce `--tp-size` a 2 en H200.

***

## Recomendaciones de GPU para Clore.ai

| Configuración                              | VRAM           | Rendimiento esperado                                            | Coste de Clore.ai                             |
| ------------------------------------------ | -------------- | --------------------------------------------------------------- | --------------------------------------------- |
| 1× RTX 4090 24 GB + descarga parcial a RAM | 24 GB + 128 GB | INT4 aficionado, \~5–10 tok/s                                   | $0.14–0.42/h                                  |
| 4× A100 80 GB                              | 320GB          | BF16 fragmentado, \~15–25 tok/s                                 | [bare metal](https://clore.ai/bare-metal)     |
| **4× H100 80 GB (FP8)**                    | **320GB**      | **FP8 en producción, \~40–60 tok/s**                            | **\~4,16 $/h**                                |
| **2× H200 141 GB (FP8)**                   | **282 GB**     | **FP8 en producción, \~50–70 tok/s, contexto completo de 200K** | [**bare metal**](https://clore.ai/bare-metal) |
| 8× H100 80GB                               | 640GB          | BF16 completo, \~80+ tok/s                                      | \~8,32 $/h                                    |

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

Alquila las máquinas aquí:

* [**H200 como bare metal**](https://clore.ai/bare-metal) — recomendado para el despliegue FP8 de 2× H200
* [**Alquilar GPU H100**](https://clore.ai/rent-h100.html) — para el despliegue FP8 de 4× H100
* [**A100 80 GB como bare metal**](https://clore.ai/bare-metal) — alternativa BF16 multi-GPU
* [**Alquilar RTX 4090**](https://clore.ai/rent-4090.html) — solo para uso aficionado INT4
* [**Marketplace**](https://clore.ai/marketplace) — inventario completo, bajo demanda y pujas 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** — el Pensamiento Intercalado mantiene vivo el rastro de razonamiento a través de cientos de `tool_use` idas y vueltas
* **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
* **Canalizaciones de refactorización** — corrección sostenida a través de muchas ediciones de archivos mediante los módulos MTP
* **Orquestación de 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 autoalojada a Claude Sonnet/Opus** para investigación de codificación no comercial — pero **lee primero la licencia**

***

## Pruebas comparativas

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

| Benchmark        | MiniMax M2.7 | Claude Sonnet 4.5 (referencia del proveedor) | Claude Opus 4.6 (referencia 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 229B MoE, codificación ajustada con RL | Referencia / histórico                                         |
| M2.1     | Dic 2025       | **Pensamiento Intercalado** introducido                       | La versión más temprana que vale la pena ejecutar para agentes |
| M2.5     | Feb 2026       | Posentrenamiento RL autoevolutivo, contexto más largo         | Buen modelo de codificación si tienes poco espacio en disco    |
| **M2.7** | **9 abr 2026** | **Codificación multilingüe refinada, MTP, FP8 oficial**       | **Elección por defecto — usa esta**                            |

Si empiezas desde cero, salta 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                  | Necesita \~230 GB de VRAM. Usa 4× H100 80 GB o 2× H200 141 GB. Reduce `--max-model-len` a 32768 primero.                                     |
| Descarga lenta de HuggingFace                       | `huggingface-cli download MiniMaxAI/MiniMax-M2.7 --local-dir ./weights --resume-download`. Espera \~230 GB FP8 / \~460 GB BF16.              |
| Llamadas a herramientas descartadas silenciosamente | Establece `--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 greedy rompe el Pensamiento Intercalado.                     |
| Errores de MTP / discrepancia de formas             | Actualiza vLLM a la última versión estable; el soporte MTP llegó tarde y las compilaciones antiguas no incluyen los módulos.                 |
| OOM de contexto 200K en H100                        | Usa `--enable-chunked-prefill` y empieza en `--max-model-len 65536`. El 200K completo en realidad requiere H200.                             |
| Confusión de licencia                               | Por defecto = no comercial. Envía un correo a `api@minimax.io` con el asunto "M2.7 licensing" antes de cualquier uso en un producto de pago. |

***

## Siguientes pasos

* **Hermano 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
* **Marketplace 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 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-es/modelos-de-lenguaje/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.
