MiniMax M2: cos’è, quanto costa e come usarlo

MiniMax M2 è un modello di intelligenza artificiale open-weight (licenza MIT) con architettura Mixture-of-Experts: 230 miliardi di parametri totali, 10 miliardi attivi per token. Nasce per scrivere codice e usare strumenti (terminale, browser, interprete Python) in autonomia. Supporta contesti fino a 200.000 token, è rapido ed economico, e si integra sia via API sia in locale. Se costruisci agenti o assistenti per sviluppatori, è una scelta solida per POC e produzione.

Indice dei contenuti

Cos’è MiniMax M2

Tipo: LLM con pesi pubblici (licenza MIT).
Architettura: MoE “sparsa” → grande capacità totale, ma attiva solo una piccola parte per token (meno latenza e costi).
Focus: coding multi-file, cicli edit → run → fix → test, agenti con tool-calling (terminal, browser, Python/MCP).
Contesto: fino a ~200K token (dipende dal serving scelto).
Interleaved thinking: il modello inserisce un blocco di ragionamento <think>…</think> che deve rimanere nella cronologia. Se lo togli, peggiorano pianificazione e coerenza.

Quando conviene (e quando no)

Usalo se:

vuoi agenti multi-step che orchestrano shell + browser + Python/MCP;
ti serve un assistente dev end-to-end (fino all’apertura della PR);
lavori con contesti lunghi (log, manuali, trascrizioni, lunghi thread tecnici).

Valuta alternative se:

il carico è ragionamento matematico puro (competizioni/olimpiadi);
policy/stack impediscono di salvare <think> tra i turni.

Ti sta piacendo?

Ricevi una guida pratica ogni settimana. AI, tool e automazioni.

Quanto costa davvero (e cosa misurare)

Indicazioni tipiche API: ~$0,30/M token input, ~$1,20/M token output.
Conta il costo per task (quanto paghi per chiudere il lavoro), non il prezzo “al milione” preso da solo.

Esempio: 120.000 token in + 80.000 token out

IN: 120.000 × 0,30 / 1.000.000 = $0,036
OUT: 80.000 × 1,20 / 1.000.000 = $0,096
Totale task: $0,132

Consigli

Metti un cap agli output token.
Logga token IN/OUT di tutte le chiamate.
Conta i retry (step rifatti: test falliti, tool-error, piano rivisto).

Riferimenti API: https://platform.minimax.io/docs/guides/pricing#text

4) Provarlo subito con Ollama Cloud

Prova lampo da terminale, nessun peso da scaricare.

Comando

ollama run minimax-m2:cloud

Note

Gira in cloud (non locale).
Contesto ~200K.
Script rapido:

echo "Spiegami come risolvere l'errore X" | ollama run minimax-m2:cloud

Pagina modello: https://ollama.com/library/minimax-m2

Pro: parti in 30 secondi.
Contro: meno controllo su latenza/rete; non è un endpoint API “universale”.

Integrarlo via API con OpenRouter (per ora free)

Endpoint compatibile OpenAI, perfetto per app, bot, IDE, n8n.

Python

from openai import OpenAI

client = OpenAI(
  base_url="https://openrouter.ai/api/v1",
  api_key="<OPENROUTER_API_KEY>",
)

res = client.chat.completions.create(
  model="minimax/minimax-m2:free",
  messages=[
    {"role":"system","content":"Sei un assistente per coding e tool-use."},
    {"role":"user","content":"Scrivi un test che riproduce il bug #123 e proponi la patch."}
  ],
  temperature=1.0,
  top_p=0.95
)
print(res.choices[0].message.content)

Curl

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model":"minimax/minimax-m2:free",
    "messages":[
      {"role":"system","content":"Assistant per coding/agent."},
      {"role":"user","content":"Genera un piano passo-passo per correggere il test fallito e preparare la PR."}
    ],
    "temperature":1.0,
    "top_p":0.95
  }'

Pagina modello: https://openrouter.ai/minimax/minimax-m2:free

Parametri consigliati: temperature 1.0, top_p 0.95, top_k 40 (A/B con 20).
Cruciale: non filtrare <think> quando invii la cronologia del turno successivo.

Pro: integrazione veloce; al momento gratis; throughput/latency buoni.
Contro: la gratuità può cambiare → prevedi fallback a versione paid o self-host.

Eseguirlo in casa (self-host): vLLM e SGLan

Pesi e doc

Hugging Face: https://huggingface.co/MiniMaxAI/MiniMax-M2
GitHub (guide): https://github.com/MiniMax-AI/MiniMax-M2
News: https://www.minimax.io/news/minimax-m2

vLLM (server OpenAI-compatible)

Indicativamente 40–80 GB VRAM a seconda di dtype/quantizzazione/parallelismi.

pip install "vllm>=0.6.0.dev0"

python -m vllm.entrypoints.openai.api_server \
  --model MiniMaxAI/MiniMax-M2 \
  --dtype auto \
  --gpu-memory-utilization 0.9 \
  --max-model-len 200000 \
  --trust-remote-code

Ottimizzazioni: PagedAttention (default), batching dinamico, KV-cache, FP8/INT8 (quando stabile), tensor/pipeline parallel, speculative decoding (se disponibile).

SGLang (molto reattivo per agenti)

pip install "sglang>=0.3.0"

sglang serve \
  --model MiniMaxAI/MiniMax-M2 \
  --context-length 200000 \
  --trust-remote-code

Tip: abilita chunk prefill per contesti lunghi e logga la tool-latency (plan → act → verify) per trovare i colli di bottiglia.

Provalo ora con DeepSite (gratis su Hugging Face)

Vuoi “giocarci” senza installare nulla e generare codice/front-end al volo?
Usa DeepSite – Vibe Coding: https://huggingface.co/spaces/enzostvs/deepsite

Come fare (2 minuti):

Apri lo Space e clicca su Start Vibe Coding (se serve, wake up).
In Customize Settings, scegli MiniMax M2 come modello (provider auto).
Scrivi cosa vuoi creare (es. “Landing page responsive con hero, pricing e CTA”).
Premi Run: DeepSite genera il progetto e puoi modificare/rigenerare sezioni.
Esporta i file o copia il codice nel tuo IDE.

Perché è utile: è il modo più semplice e gratuito per testare MiniMax-M2 su un flusso di coding reale (UI/HTML/CSS/JS) prima di integrarlo nelle tue pipeline.

Esempio pratico: “correggi un bug e apri una PR”

System (una volta sola)

Sei un agente di sviluppo. Strategia: pianifica → agisci → verifica.
Strumenti: terminale, interprete Python, browser. Log sintetici.
Limiti: massimo 100 comandi; apri PR solo se i test sono verdi.

User

Repo: <URL>
Obiettivo: riprodurre il bug #123, scrivere un test, applicare la patch, rieseguire i test.
Consegna: diff, breve spiegazione tecnica, link alla PR.

Loop tipico

Pianifica (nel <think>).
Esegui i test.
Leggi gli errori.
Applica la patch.
Ritesta.
Commit + PR se tutto verde.

Non rimuovere <think> dalla cronologia: serve a mantenere il piano.

Problemi comuni e soluzioni

Calano le performance dopo pochi turni → quasi sempre hai rimosso <think>. Conservalo (puoi nasconderlo in UI, ma salvalo lato server).
Latenza alta con molte tool-call → riduci verbosità tra gli step, abilita batching/speculative, preferisci SGLang per hop frequenti.
Token OUT elevati → metti hard-cap agli output, chiedi riassunti periodici dei log, taglia history superflue.
Errori su matematica/logic “dura” → usa tool Python per i calcoli e, quando serve, 2–3 tentativi con selezione del migliore.

Valutare le prestazioni (metriche chiare)

Tieni sempre queste 4 metriche:

Tempo totale: minuti dall’inizio alla fine del task.
Token IN/OUT: somma dei token di tutte le chiamate del task.
Retry: step rifatti (test falliti, tool error, piano rivisto).
€ per task:

costo_task = (token_in_tot * prezzo_in/M + token_out_tot * prezzo_out/M) / 1.000.000

Esempio tabella (SWE-bench: 3 issue)

Task	Esito	Minuti	Token IN	Token OUT	Retry	Costo
123	Pass	18,4	121.000	84.000	2	0,13
77	Fail	22,9	160.000	112.000	4	0,23
9	Pass	14,6	98.000	62.000	1	0,10

Medie rapide: pass-rate, tempo medio, costo medio.
Sono i numeri che aiutano davvero a decidere (CTO/CFO).

Grafico a barre con i punteggi di MiniMax-M2 confrontati con DeepSeek-V3.2, GLM-4.6, Kimi K2 0905, Gemini 2.5 Pro, Claude Sonnet 4.5 e GPT-5 (thinking) su SWE-bench, Multi-SWE-Bench, Terminal-Bench, ArtifactsBench, τ²-Bench, GAIA, BrowseComp e FinSearchComp-global. — Confronto sintetico delle prestazioni su suite pratiche di coding e tool-use.

Sicurezza, governance, cost control

Tool policy: allow-list dei domini, sandbox Python, limiti shell.
Audit: salva plan/act/verify e citazioni web.
Segreti/PII: non farli comparire nel <think>; usa un vault.
Budget: alert su token OUT e limiti per job.
Privacy: dati sensibili? Meglio self-host.

Domande frequenti (FAQ)

È migliore dei modelli proprietari top?
Su tool-use e coding è competitivo; sul ragionamento matematico puro in genere no. Decidi con il costo per task.

Devo davvero conservare <think>?
Sì: MiniMax-M2 è progettato per interleaved thinking. Se lo togli, degradano pianificazione e coerenza.

Supporta MCP e strumenti esterni?
Sì: terminale, browser, Python sono first-class; MCP è uno scenario naturale.

Quanta GPU serve on-prem?
Dipende da dtype/quantizzazione. Con FP8/INT8 e parallelismi puoi ridurre la VRAM, ma verifica sempre la latenza tail rispetto ai tuoi SLO.

Risorse ufficiali (link diretti)

OpenRouter (free, endpoint OpenAI-compatible): https://openrouter.ai/minimax/minimax-m2:free
News/Annuncio MiniMax-M2: https://www.minimax.io/news/minimax-m2
Ollama Cloud – pagina modello: https://ollama.com/library/minimax-m2
Hugging Face – pesi: https://huggingface.co/MiniMaxAI/MiniMax-M2
Repository GitHub (guide, tool, doc): https://github.com/MiniMax-AI/MiniMax-M2

Nuovo su Google

Aggiungi francescogruner.it come fonte preferita

Se leggi spesso i miei articoli su AI, automazione e tecnologia, ora puoi dire a Google che vuoi vedere più spesso i contenuti di francescogruner.it tra le notizie.