MiniMax-MCP: the official MCP server for MiniMax speech, image and video APIs

What MiniMax-MCP actually adds to an MCP client

An MCP client such as Claude Desktop can call tools, but it cannot synthesize speech, clone a voice or render a video on its own. MiniMax-MCP fills that gap by registering MiniMax's hosted generation APIs as MCP tools. The README describes it as the "Official MiniMax Model Context Protocol (MCP) server" and lists the client targets it was written for: Claude Desktop, Cursor, Windsurf, OpenAI Agents and others. The topics on the repository cover text-to-speech, voice cloning, text-to-image, image-to-video and text-to-video, so the intended audience is developers building agent workflows that need media output rather than text output. The server itself does not generate anything. It is a protocol adapter: it receives a tool call from the client, translates it into an HTTP request against a MiniMax endpoint, and returns the result. That distinction matters for anyone evaluating cost and latency, because both are determined by the remote API, not by this package.

How the server is structured and where requests go

The repository layout shows a single Python package, minimax_mcp/, alongside tests/, scripts/ and a pyproject.toml that declares the console entry point minimax-mcp = "minimax_mcp.server:main". Dependencies point at the shape of the server: mcp[cli] for the protocol layer, fastapi and uvicorn for an HTTP surface, httpx and requests for outbound calls, pydantic for request models, python-dotenv for configuration, and sounddevice plus soundfile for local audio handling. The README's configuration table shows that the API host and key vary by region and must match, with https://api.minimax.io for the global platform and https://api.minimaxi.com for the mainland platform. The .env.example file lists MINIMAX_API_KEY, an optional MINIMAX_MCP_BASE_PATH for output files, MINIMAX_API_HOST, and an optional MINIMAX_API_RESOURCE_MODE whose comment says the accepted values are url and local, with url as the default. That last setting is the one worth thinking about before you start: in url mode the client receives a link to the generated asset, and in local mode the asset is written to the base path instead.

Installing MiniMax-MCP and running a first call

The README's quickstart has three steps: get an API key from the MiniMax platform, install uv, and make sure your host and key come from the same region. The uv install command given in the README is a shell one liner.

curl -LsSf https://astral.sh/uv/install.sh | sh

For Claude Desktop the README points to Claude > Settings > Developer > Edit Config > claude_desktop_config.json and shows a server entry that runs the package through uvx. Reproduce it with your own key rather than the placeholder.

{
  "mcpServers": {
    "MiniMax": {
      "command": "uvx",
      "args": ["minimax-mcp", "-y"],
      "env": {
        "MINIMAX_API_KEY": "insert-your-api-key-here",
        "MINIMAX_API_HOST": "https://api.minimax.io"
      }
    }
  }
}

After restarting the client, the MiniMax tools should appear in the tool list and a speech or image request should return either a URL or a local file depending on MINIMAX_API_RESOURCE_MODE. If instead you get an Invalid API key error, the README's stated cause is a region mismatch between key and host, so check which of the two hosts issued your key. There is also a mcp_server_config_demo.json in the repository root that the README does not explain in the excerpt available, so treat it as a starting point to read rather than a documented template. The package also declares a minimax-mcp console script, which means an installed environment can start the server directly, though the README's client examples go through uvx.

The region split is the first thing that breaks

The README marks the host and key pairing as Important, and the wording is blunt: if they do not match you get an Invalid API key error. This is a common failure mode because the two platforms are separate sites with separate key pages, and a key copied from one will look structurally valid on the other. The .env.example file is itself a small trap here: it sets MINIMAX_API_HOST to https://api.minimax.chat, which is neither of the two hosts in the README's configuration table. A user who copies .env.example without reading the table can end up pointed at a host the README does not document. The safe move is to ignore the example host value and take the host from the table that matches the key page you used. Beyond that, the whole server is a dependency on a remote paid service. If MiniMax's API is unreachable, rate limited, or your account has no credit, the MCP tools fail, and no part of this repository gives you a fallback. There is also no rollback or retry behaviour described in the README, so error handling is whatever the MCP client surfaces.

Where a local model or a plain SDK fits better

The obvious alternative for anyone who wants generation without a hosted dependency is a local model stack, for example a text to speech engine or an image model running on your own hardware. The difference is not a matter of quality but of where the work happens: MiniMax-MCP sends every request to api.minimax.io or api.minimaxi.com and returns a URL or a downloaded file, while a local stack keeps the audio or image on your machine and costs GPU time instead of API credit. If your constraint is data residency or offline operation, MiniMax-MCP is the wrong tool, and no configuration flag in .env.example changes that. The second alternative is calling the MiniMax HTTP API directly from your own code. The README itself points at the MiniMax CLI (mmx-cli) as recommended for the latest models and extra features including text, vision and search, and there is a separate MiniMax-MCP-JS implementation for JavaScript. Choosing the MCP server over a direct SDK only pays off when you specifically want the tools to appear inside an MCP client rather than in your own process.

Licence, maintenance and what a version bump costs you

The code is MIT licensed, and pyproject.toml carries the OSI Approved :: MIT License classifier, so the usual MIT terms apply to the server code itself. That says nothing about the MiniMax API, which is a separate commercial service governed by the platform's own terms; the licence on this repository does not grant you API access or usage rights to generated media. On maintenance, the repository is not archived and the last push was on 2026-08-20. The declared version is 0.0.19 and the classifier reads Development Status :: 4 - Beta, so expect the interface to move. Upgrading is mostly a matter of the pinned dependency ranges in pyproject.toml, which require Python 3.10 or newer and constrain mcp[cli] to >=2.0.0,<3. Because the client examples run the package through uvx, a client will typically pull the newest published version on start, which means an upstream change can land in your setup without you changing anything locally. If you need reproducibility, pin the version in the args list rather than relying on uvx resolving the latest release. There is no changelog or release notes in the repository listing, so the diff between versions is not documented here.

Editorial conclusion

Adopt MiniMax-MCP if you already have a MiniMax platform account and want speech, voice cloning, image and video generation reachable as MCP tools inside Claude Desktop, Cursor, Windsurf or OpenAI Agents, and you are comfortable running Python 3.10 or newer through uvx. Do not adopt it if you need offline generation, an on premise model, or a self hosted service with no external API dependency, because every tool call goes to a MiniMax host. Before wiring it into a client, verify three things: that your MINIMAX_API_KEY and MINIMAX_API_HOST come from the same region, that you know which output mode you want for MINIMAX_API_RESOURCE_MODE, and that the .env.example host value matches the host your key was issued for. The repository was last pushed on 2026-08-20 and is not archived, but pyproject.toml still classifies it as Development Status 4 - Beta.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. MiniMax-AI/MiniMax-MCP on GitHub
4. Project website
5. README