minimax-coding-plan-mcp 0.0.1__py3-none-any.whl

minimax_coding_plan_mcp-0.0.1.dist-info/METADATA

@@ -0,0 +1,202 @@
+Metadata-Version: 2.4
+Name: minimax-coding-plan-mcp
+Version: 0.0.1
+Summary: Specialized MiniMax Model Context Protocol (MCP) server designed for coding-plan users
+Author-email: Roy Wu <zhengyu@minimax.chat>
+License: MIT License
+        
+        Copyright 2025 MiniMax AI.
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Keywords: minimax,mcp,coding-plan-search,coding-plan-vlm
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp[cli]>=1.6.0
+Requires-Dist: fastapi>=0.109.2
+Requires-Dist: uvicorn>=0.27.1
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: pydantic>=2.6.1
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: fuzzywuzzy>=0.18.0
+Requires-Dist: python-Levenshtein>=0.25.0
+Requires-Dist: sounddevice>=0.5.1
+Requires-Dist: soundfile>=0.13.1
+Requires-Dist: requests>=2.31.0
+Provides-Extra: dev
+Requires-Dist: pre-commit>=3.6.2; extra == "dev"
+Requires-Dist: ruff>=0.3.0; extra == "dev"
+Requires-Dist: fastmcp>=0.4.1; extra == "dev"
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: twine>=6.1.0; extra == "dev"
+Requires-Dist: build>=1.0.3; extra == "dev"
+Dynamic: license-file
+
+![export](https://github.com/MiniMax-AI/MiniMax-01/raw/main/figures/MiniMaxLogo-Light.png)
+
+<div align="center" style="line-height: 1;">
+  <a href="https://www.minimax.io" target="_blank" style="margin: 2px; color: var(--fgColor-default);">
+    <img alt="Homepage" src="https://img.shields.io/badge/_Homepage-MiniMax-FF4040?style=flat-square&labelColor=2C3E50&logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgNDkwLjE2IDQxMS43Ij48ZGVmcz48c3R5bGU+LmNscy0xe2ZpbGw6I2ZmZjt9PC9zdHlsZT48L2RlZnM+PHBhdGggY2xhc3M9ImNscy0xIiBkPSJNMjMzLjQ1LDQwLjgxYTE3LjU1LDE3LjU1LDAsMSwwLTM1LjEsMFYzMzEuNTZhNDAuODIsNDAuODIsMCwwLDEtODEuNjMsMFYxNDVhMTcuNTUsMTcuNTUsMCwxLDAtMzUuMDksMHY3OS4wNmE0MC44Miw0MC44MiwwLDAsMS04MS42MywwVjE5NS40MmExMS42MywxMS42MywwLDAsMSwyMy4yNiwwdjI4LjY2YTE3LjU1LDE3LjU1LDAsMCwwLDM1LjEsMFYxNDVBNDAuODIsNDAuODIsMCwwLDEsMTQwLDE0NVYzMzEuNTZhMTcuNTUsMTcuNTUsMCwwLDAsMzUuMSwwVjIxNy41aDBWNDAuODFhNDAuODEsNDAuODEsMCwxLDEsODEuNjIsMFYyODEuNTZhMTEuNjMsMTEuNjMsMCwxLDEtMjMuMjYsMFptMjE1LjksNjMuNEE0MC44Niw0MC44NiwwLDAsMCw0MDguNTMsMTQ1VjMwMC44NWExNy41NSwxNy41NSwwLDAsMS0zNS4wOSwwdi0yNjBhNDAuODIsNDAuODIsMCwwLDAtODEuNjMsMFYzNzAuODlhMTcuNTUsMTcuNTUsMCwwLDEtMzUuMSwwVjMzMGExMS42MywxMS42MywwLDEsMC0yMy4yNiwwdjQwLjg2YTQwLjgxLDQwLjgxLDAsMCwwLDgxLjYyLDBWNDAuODFhMTcuNTUsMTcuNTUsMCwwLDEsMzUuMSwwdjI2MGE0MC44Miw0MC44MiwwLDAsMCw4MS42MywwVjE0NWExNy41NSwxNy41NSwwLDEsMSwzNS4xLDBWMjgxLjU2YTExLjYzLDExLjYzLDAsMCwwLDIzLjI2LDBWMTQ1QTQwLjg1LDQwLjg1LDAsMCwwLDQ0OS4zNSwxMDQuMjFaIi8+PC9zdmc+&logoWidth=20" style="display: inline-block; vertical-align: middle;"/>
+  </a>
+  <a href="https://arxiv.org/abs/2501.08313" target="_blank" style="margin: 2px;">
+    <img alt="Paper" src="https://img.shields.io/badge/📖_Paper-MiniMax--01-FF4040?style=flat-square&labelColor=2C3E50" style="display: inline-block; vertical-align: middle;"/>
+  </a>
+   <a href="https://chat.minimax.io/" target="_blank" style="margin: 2px;">
+    <img alt="Chat" src="https://img.shields.io/badge/_MiniMax_Chat-FF4040?style=flat-square&labelColor=2C3E50&logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgNDkwLjE2IDQxMS43Ij48ZGVmcz48c3R5bGU+LmNscy0xe2ZpbGw6I2ZmZjt9PC9zdHlsZT48L2RlZnM+PHBhdGggY2xhc3M9ImNscy0xIiBkPSJNMjMzLjQ1LDQwLjgxYTE3LjU1LDE3LjU1LDAsMSwwLTM1LjEsMFYzMzEuNTZhNDAuODIsNDAuODIsMCwwLDEtODEuNjMsMFYxNDVhMTcuNTUsMTcuNTUsMCwxLDAtMzUuMDksMHY3OS4wNmE0MC44Miw0MC44MiwwLDAsMS04MS42MywwVjE5NS40MmExMS42MywxMS42MywwLDAsMSwyMy4yNiwwdjI4LjY2YTE3LjU1LDE3LjU1LDAsMCwwLDM1LjEsMFYxNDVBNDAuODIsNDAuODIsMCwwLDEsMTQwLDE0NVYzMzEuNTZhMTcuNTUsMTcuNTUsMCwwLDAsMzUuMSwwVjIxNy41aDBWNDAuODFhNDAuODEsNDAuODEsMCwxLDEsODEuNjIsMFYyODEuNTZhMTEuNjMsMTEuNjMsMCwxLDEtMjMuMjYsMFptMjE1LjksNjMuNEE0MC44Niw0MC44NiwwLDAsMCw0MDguNTMsMTQ1VjMwMC44NWExNy41NSwxNy41NSwwLDAsMS0zNS4wOSwwdi0yNjBhNDAuODIsNDAuODIsMCwwLDAtODEuNjMsMFYzNzAuODlhMTcuNTUsMTcuNTUsMCwwLDEtMzUuMSwwVjMzMGExMS42MywxMS42MywwLDEsMC0yMy4yNiwwdjQwLjg2YTQwLjgxLDQwLjgxLDAsMCwwLDgxLjYyLDBWNDAuODFhMTcuNTUsMTcuNTUsMCwwLDEsMzUuMSwwdjI2MGE0MC44Miw0MC44MiwwLDAsMCw4MS42MywwVjE0NWExNy41NSwxNy41NSwwLDEsMSwzNS4xLDBWMjgxLjU2YTExLjYzLDExLjYzLDAsMCwwLDIzLjI2LDBWMTQ1QTQwLjg1LDQwLjg1LDAsMCwwLDQ0OS4zNSwxMDQuMjFaIi8+PC9zdmc+&logoWidth=20" style="display: inline-block; vertical-align: middle;"/>
+  </a>
+  <a href="https://www.minimax.io/platform" style="margin: 2px;">
+    <img alt="API" src="https://img.shields.io/badge/⚡_API-Platform-FF4040?style=flat-square&labelColor=2C3E50" style="display: inline-block; vertical-align: middle;"/>
+  </a>  
+</div>
+<div align="center" style="line-height: 1;">
+  <a href="https://huggingface.co/MiniMaxAI" target="_blank" style="margin: 2px;">
+    <img alt="Hugging Face" src="https://img.shields.io/badge/🤗_Hugging_Face-MiniMax-FF4040?style=flat-square&labelColor=2C3E50" style="display: inline-block; vertical-align: middle;"/>
+  </a>
+  <a href="https://github.com/MiniMax-AI/MiniMax-AI.github.io/blob/main/images/wechat-qrcode.jpeg" target="_blank" style="margin: 2px;">
+    <img alt="WeChat" src="https://img.shields.io/badge/_WeChat-MiniMax-FF4040?style=flat-square&labelColor=2C3E50" style="display: inline-block; vertical-align: middle;"/>
+  </a>
+  <a href="https://www.modelscope.cn/organization/MiniMax" target="_blank" style="margin: 2px;">
+    <img alt="ModelScope" src="https://img.shields.io/badge/_ModelScope-MiniMax-FF4040?style=flat-square&labelColor=2C3E50" style="display: inline-block; vertical-align: middle;"/>
+  </a>
+</div>
+<div align="center" style="line-height: 1;">
+   <a href="https://github.com/MiniMax-AI/MiniMax-MCP/blob/main/LICENSE" style="margin: 2px;">
+    <img alt="Code License" src="https://img.shields.io/badge/_Code_License-MIT-FF4040?style=flat-square&labelColor=2C3E50" style="display: inline-block; vertical-align: middle;"/>
+  </a>
+</div>
+
+<p align="center">
+  Specialized MiniMax Model Context Protocol (MCP) server designed for <b>coding-plan</b> users, featuring AI-powered search and vision analysis APIs optimized for code development workflows. Unlike the standard <a href="https://github.com/MiniMax-AI/MiniMax-MCP">MiniMax-MCP</a>, this version provides coding-specific tools (for examples: <code>coding_plan_search</code> and <code>coding_plan_vlm</code>) that integrate seamlessly with MCP clients like <a href="https://www.anthropic.com/claude">Claude Desktop</a>, <a href="https://www.cursor.so">Cursor</a>, <a href="https://codeium.com/windsurf">Windsurf</a>, <a href="https://github.com/openai/openai-agents-python">OpenAI Agents</a> and others to enhance your coding experience.
+</p>
+
+## Documentation
+- [中文文档](README-CN.md)
+
+
+## Quickstart with MCP Client
+1. Get your API key from [MiniMax](https://www.minimax.io/platform/user-center/basic-information/interface-key). 
+2. Install `uv` (Python package manager), install with `curl -LsSf https://astral.sh/uv/install.sh | sh` or see the `uv` [repo](https://github.com/astral-sh/uv) for additional install methods.
+3. **Important**: The API host and key vary by region and must match; otherwise, you'll encounter an `Invalid API key` error.
+
+|Region| Global  | Mainland  |
+|:--|:-----|:-----|
+|MINIMAX_API_KEY| go get from [MiniMax Global](https://www.minimax.io/platform/user-center/basic-information/interface-key) | go get from [MiniMax](https://platform.minimaxi.com/user-center/basic-information/interface-key) |
+|MINIMAX_API_HOST| https://api.minimax.io | https://api.minimaxi.com |
+
+
+### Claude Desktop
+Go to `Claude > Settings > Developer > Edit Config > claude_desktop_config.json` to include the following:
+
+```
+{
+  "mcpServers": {
+    "MiniMax": {
+      "command": "uvx",
+      "args": [
+        "minimax-coding-plan-mcp",
+        "-y"
+      ],
+      "env": {
+        "MINIMAX_API_KEY": "insert-your-api-key-here",
+        "MINIMAX_MCP_BASE_PATH": "local-output-dir-path, such as /User/xxx/Desktop",
+        "MINIMAX_API_HOST": "api host, https://api.minimax.io | https://api.minimaxi.com",
+        "MINIMAX_API_RESOURCE_MODE": "optional, [url|local], url is default, audio/image/video are downloaded locally or provided in URL format"
+      }
+    }
+  }
+}
+
+```
+⚠️ Warning: The API key needs to match the host. If an error "API Error: invalid api key" occurs, please check your api host:
+- Global Host：`https://api.minimax.io`
+- Mainland Host：`https://api.minimaxi.com`
+
+If you're using Windows, you will have to enable "Developer Mode" in Claude Desktop to use the MCP server. Click "Help" in the hamburger menu in the top left and select "Enable Developer Mode".
+
+
+### Cursor
+Go to `Cursor -> Preferences -> Cursor Settings -> MCP -> Add new global MCP Server` to add above config.
+
+That's it. Your MCP client can now interact with MiniMax through these tools:
+
+## Transport
+We support two transport types: stdio and sse.
+| stdio  | SSE  |
+|:-----|:-----|
+| Run locally | Can be deployed locally or in the cloud |
+| Communication through `stdout` | Communication through `network` |
+| Input: Supports processing `local files` or valid `URL` resources | Input: When deployed in the cloud, it is recommended to use `URL` for input |
+
+## Available Tools
+| tool  | description  |
+|-|-|
+|`coding_plan_search`|Performs web searches and returns organic search results along with related search queries|
+|`coding_plan_vlm`|Analyzes images with AI based on text prompts, extracts information and answers questions about images|
+
+## Release Notes
+
+### November 20, 2025
+
+#### 🆕 What's New
+- **Web Search**: New `coding_plan_search` tool - perform web searches and get organic results with related search queries
+- **Vision Language Model**: New `coding_plan_vlm` tool - analyze images using AI based on text prompts
+
+#### 📈 Features
+- `coding_plan_search` - Search the web and get structured results including titles, links, snippets, and related searches
+- `coding_plan_vlm` - Analyze images from URLs or local files, supporting JPEG, PNG, GIF, and WebP formats
+
+## FAQ
+### 1. invalid api key
+Please ensure your API key and API host are regionally aligned
+|Region| Global  | Mainland  |
+|:--|:-----|:-----|
+|MINIMAX_API_KEY| go get from [MiniMax Global](https://www.minimax.io/platform/user-center/basic-information/interface-key) | go get from [MiniMax](https://platform.minimaxi.com/user-center/basic-information/interface-key) |
+|MINIMAX_API_HOST| https://api.minimax.io | https://api.minimaxi.com |
+
+### 2. spawn uvx ENOENT
+Please confirm its absolute path by running this command in your terminal:
+```sh
+which uvx
+```
+Once you obtain the absolute path (e.g., /usr/local/bin/uvx), update your configuration to use that path (e.g., "command": "/usr/local/bin/uvx"). 
+
+
+
+## Example usage
+
+⚠️ Warning: Using these tools may incur costs.
+
+### 1. Web Search
+Use the `coding_plan_search` tool to search for information on the web:
+
+<img src="https://cdn.hailuoai.video/moss/prod/2025-11-20-15/user/multi_chat_file/99ff15e3-e5d6-48e2-8216-38c6abf03c71.image/png" style="display: 
+inline-block; vertical-align: middle; "/>
+
+### 2. Image Analysis
+Use the `coding_plan_vlm` tool to analyze images with AI:
+
+<img src="https://cdn.hailuoai.video/moss/prod/2025-11-20-15/user/multi_chat_file/1f8174a2-68d5-4576-b886-86933eab5280.image/png" style="display: 
+inline-block; vertical-align: middle; "/>

minimax_coding_plan_mcp-0.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+minimax_coding_plan_mcp-0.0.1.dist-info/licenses/LICENSE,sha256=qROMAfPCJkGsj4_i8-x13gtKBJT_gejaQ7PMIJGTWsM,1064
+minimax_mcp/__init__.py,sha256=CKIi_HLF6Kg0jwf_Mq4H50_YqbadAzELljOlfvBoFAI,69
+minimax_mcp/__main__.py,sha256=t-bxkqivbV-ri9pZADozQS2eUpjq5_cWTJXuG-vclmQ,3021
+minimax_mcp/client.py,sha256=CNQRaiDoplLOueK29YsefN_kZLFLr_BZd-CLSwW2a-M,3675
+minimax_mcp/const.py,sha256=mPzsI7CgHw9uaxJ4egkRAhmYaF8yCPmEBWaBepGE5KU,830
+minimax_mcp/exceptions.py,sha256=f02y8FAKo7WS9jqhQD1_hFkPHWFX4-j5nEvZ_rBmFCU,547
+minimax_mcp/server.py,sha256=wXW_4XEThyrqthKyLDQSCqpyvb33zd-LBrKbiw5raXE,5484
+minimax_mcp/utils.py,sha256=YndfmVoeFyIHmyPcMe2uQke0C-r17eq288_2wRb3PUs,8504
+minimax_coding_plan_mcp-0.0.1.dist-info/METADATA,sha256=NaxK9rYdwg2Eoy2dqGI6lsjsfywuLS48Zl-aQycJ0JY,12902
+minimax_coding_plan_mcp-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+minimax_coding_plan_mcp-0.0.1.dist-info/entry_points.txt,sha256=nBQn7kfqXxlmJCWcPmnLA9nyy-wGLUuI0p4daZ6_OHg,68
+minimax_coding_plan_mcp-0.0.1.dist-info/top_level.txt,sha256=PQ7pnbym7cuF8XXvQ-yLu2czj9EDuAhkTbbwtoeEKsA,12
+minimax_coding_plan_mcp-0.0.1.dist-info/RECORD,,

minimax_coding_plan_mcp-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

minimax_coding_plan_mcp-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+minimax-coding-plan-mcp = minimax_mcp.server:main

minimax_coding_plan_mcp-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright 2025 MiniMax AI.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

minimax_coding_plan_mcp-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+minimax_mcp

minimax_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""Minimax Coding Plan MCP Server package."""
+
+__version__ = "0.0.1"

minimax_mcp/__main__.py

@@ -0,0 +1,100 @@
+import os
+import json
+from pathlib import Path
+import sys
+from dotenv import load_dotenv
+import argparse
+
+load_dotenv()
+
+
+def get_claude_config_path() -> Path | None:
+    """Get the Claude config directory based on platform."""
+    if sys.platform == "win32":
+        path = Path(Path.home(), "AppData", "Roaming", "Claude")
+    elif sys.platform == "darwin":
+        path = Path(Path.home(), "Library", "Application Support", "Claude")
+    elif sys.platform.startswith("linux"):
+        path = Path(
+            os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config"), "Claude"
+        )
+    else:
+        return None
+
+    if path.exists():
+        return path
+    return None
+
+
+def get_python_path():
+    return sys.executable
+
+
+def generate_config(api_key: str | None = None):
+    module_dir = Path(__file__).resolve().parent
+    server_path = module_dir / "server.py"
+    python_path = get_python_path()
+
+    final_api_key = api_key or os.environ.get("MINIMAX_API_KEY")
+    if not final_api_key:
+        print("Error: Minimax API key is required.")
+        print("Please either:")
+        print("  1. Pass the API key using --api-key argument, or")
+        print("  2. Set the MINIMAX_API_KEY environment variable, or")
+        print("  3. Add MINIMAX_API_KEY to your .env file")
+        sys.exit(1)
+
+    config = {
+        "mcpServers": {
+            "Minimax": {
+                "command": "uvx",
+                "args": [
+                    "minimax-coding-plan-mcp",
+                ],
+
+                "env": {
+                    "MINIMAX_API_KEY": final_api_key,
+                    "MINIMAX_MCP_BASE_PATH": "",
+                    "MINIMAX_API_HOST": "https://api.minimax.chat",
+                },
+            }
+        }
+    }
+
+    return config
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--print",
+        action="store_true",
+        help="Print config to screen instead of writing to file",
+    )
+    parser.add_argument(
+        "--api-key",
+        help="Minimax API key (alternatively, set MINIMAX_API_KEY environment variable)",
+    )
+    parser.add_argument(
+        "--config-path",
+        type=Path,
+        help="Custom path to Claude config directory",
+    )
+    args = parser.parse_args()
+
+    config = generate_config(args.api_key)
+
+    if args.print:
+        print(json.dumps(config, indent=2))
+    else:
+        claude_path = args.config_path if args.config_path else get_claude_config_path()
+        if claude_path is None:
+            print(
+                "Could not find Claude config path automatically. Please specify it using --config-path argument. The argument should be an absolute path of the claude_desktop_config.json file."
+            )
+            sys.exit(1)
+
+        claude_path.mkdir(parents=True, exist_ok=True)
+        print("Writing config to", claude_path / "claude_desktop_config.json")
+        with open(claude_path / "claude_desktop_config.json", "w") as f:
+            json.dump(config, f, indent=2)

minimax_mcp/client.py

@@ -0,0 +1,95 @@
+"""Minimax API client base class."""
+
+import requests
+from typing import Any, Dict
+from minimax_mcp.exceptions import MinimaxAuthError, MinimaxRequestError
+
+class MinimaxAPIClient:
+    """Base client for making requests to Minimax API."""
+    
+    def __init__(self, api_key: str, api_host: str):
+        """Initialize the API client.
+        
+        Args:
+            api_key: The API key for authentication
+            api_host: The API host URL
+        """
+        self.api_key = api_key
+        self.api_host = api_host
+        self.session = requests.Session()
+        self.session.headers.update({
+            'Authorization': f'Bearer {api_key}',
+            'MM-API-Source': 'Minimax-MCP'
+        })
+
+    def _make_request(
+        self, 
+        method: str, 
+        endpoint: str, 
+        **kwargs
+    ) -> Dict[str, Any]:
+        """Make an HTTP request to the Minimax API.
+        
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            endpoint: API endpoint path
+            **kwargs: Additional arguments to pass to requests
+            
+        Returns:
+            API response data as dictionary
+            
+        Raises:
+            MinimaxAuthError: If authentication fails
+            MinimaxRequestError: If the request fails
+        """
+        url = f"{self.api_host}{endpoint}"
+        
+        # Set Content-Type based on whether files are being uploaded
+        files = kwargs.get('files')
+        if not files:
+            self.session.headers['Content-Type'] = 'application/json'
+        else:
+            # Remove Content-Type header for multipart/form-data
+            # requests library will set it automatically with the correct boundary
+            self.session.headers.pop('Content-Type', None)
+        
+        try:
+            response = self.session.request(method, url, **kwargs)
+            
+            # Check for other HTTP errors
+            response.raise_for_status()
+            
+            data = response.json()
+            
+            # Check API-specific error codes
+            base_resp = data.get("base_resp", {})
+            if base_resp.get("status_code") != 0:
+                match base_resp.get("status_code"):
+                    case 1004:
+                        raise MinimaxAuthError(
+                            f"API Error: {base_resp.get('status_msg')}, please check your API key and API host."
+                            f"Trace-Id: {response.headers.get('Trace-Id')}"
+                        )
+                    case 2038:
+                        raise MinimaxRequestError(
+                            f"API Error: {base_resp.get('status_msg')}, should complete real-name verification on the open-platform(https://platform.minimaxi.com/user-center/basic-information)."
+                            f"Trace-Id: {response.headers.get('Trace-Id')}"
+                        )
+                    case _:
+                        raise MinimaxRequestError(
+                            f"API Error: {base_resp.get('status_code')}-{base_resp.get('status_msg')} "
+                            f"Trace-Id: {response.headers.get('Trace-Id')}"
+                        )
+                
+            return data
+            
+        except requests.exceptions.RequestException as e:
+            raise MinimaxRequestError(f"Request failed: {str(e)}")
+            
+    def get(self, endpoint: str, **kwargs) -> Dict[str, Any]:
+        """Make a GET request."""
+        return self._make_request("GET", endpoint, **kwargs)
+        
+    def post(self, endpoint: str, **kwargs) -> Dict[str, Any]:
+        """Make a POST request."""
+        return self._make_request("POST", endpoint, **kwargs) 

minimax_mcp/const.py

@@ -0,0 +1,30 @@
+# speech model default values
+DEFAULT_VOICE_ID = "female-shaonv"
+DEFAULT_SPEECH_MODEL = "speech-02-hd"
+DEFAULT_MUSIC_MODEL = "music-1.5"
+DEFAULT_SPEED = 1.0
+DEFAULT_VOLUME = 1.0
+DEFAULT_PITCH = 0
+DEFAULT_EMOTION = "happy"
+DEFAULT_SAMPLE_RATE = 32000
+DEFAULT_BITRATE = 128000
+DEFAULT_CHANNEL = 1
+DEFAULT_FORMAT = "mp3"
+DEFAULT_LANGUAGE_BOOST = "auto"
+
+# video model default values
+DEFAULT_T2V_MODEL = "T2V-01"
+
+# image model default values
+DEFAULT_T2I_MODEL = "image-01"
+
+# ENV variables
+ENV_MINIMAX_API_KEY = "MINIMAX_API_KEY"
+ENV_MINIMAX_API_HOST = "MINIMAX_API_HOST"
+ENV_MINIMAX_MCP_BASE_PATH = "MINIMAX_MCP_BASE_PATH"
+ENV_RESOURCE_MODE = "MINIMAX_API_RESOURCE_MODE"
+
+RESOURCE_MODE_LOCAL = "local" # save resource to local file system
+RESOURCE_MODE_URL = "url" # provide resource url
+
+ENV_FASTMCP_LOG_LEVEL = "FASTMCP_LOG_LEVEL"

minimax_mcp/exceptions.py

@@ -0,0 +1,24 @@
+"""Custom exceptions for Minimax MCP."""
+
+class MinimaxAPIError(Exception):
+    """Base exception for Minimax API errors."""
+    pass
+
+class MinimaxAuthError(MinimaxAPIError):
+    """Authentication related errors."""
+    pass
+
+class MinimaxRequestError(MinimaxAPIError):
+    """Request related errors."""
+    pass
+
+class MinimaxTimeoutError(MinimaxAPIError):
+    """Timeout related errors."""
+    pass
+
+class MinimaxValidationError(MinimaxAPIError):
+    """Validation related errors."""
+    pass 
+
+class MinimaxMcpError(MinimaxAPIError):
+    pass

minimax_mcp/server.py

@@ -0,0 +1,170 @@
+"""
+MiniMax Coding Plan MCP Server
+
+⚠️ IMPORTANT: This server connects to Minimax API endpoints which may involve costs.
+Any tool that makes an API call is clearly marked with a cost warning. Please follow these guidelines:
+
+1. Only use these tools when users specifically ask for them
+2. For audio generation tools, be mindful that text length affects the cost
+3. Voice cloning features are charged upon first use after cloning
+
+Note: Tools without cost warnings are free to use as they only read existing data.
+"""
+
+import os
+import json
+from dotenv import load_dotenv
+from mcp.server.fastmcp import FastMCP
+from mcp.types import TextContent
+from minimax_mcp.utils import (
+    process_image_url,
+)
+
+from minimax_mcp.const import *
+from minimax_mcp.exceptions import MinimaxAPIError, MinimaxRequestError
+from minimax_mcp.client import MinimaxAPIClient
+
+load_dotenv()
+api_key = os.getenv(ENV_MINIMAX_API_KEY)
+base_path = os.getenv(ENV_MINIMAX_MCP_BASE_PATH) or "~/Desktop"
+api_host = os.getenv(ENV_MINIMAX_API_HOST)
+resource_mode = os.getenv(ENV_RESOURCE_MODE) or RESOURCE_MODE_URL
+fastmcp_log_level = os.getenv(ENV_FASTMCP_LOG_LEVEL) or "WARNING"
+
+if not api_key:
+    raise ValueError("MINIMAX_API_KEY environment variable is required")
+if not api_host:
+    raise ValueError("MINIMAX_API_HOST environment variable is required")
+
+mcp = FastMCP("Minimax",log_level=fastmcp_log_level)
+api_client = MinimaxAPIClient(api_key, api_host)
+
+@mcp.tool(
+    description="""Search for information using a search query.
+    
+    This tool performs web searches and returns organic search results along with related search queries.
+    
+    COST WARNING: This tool makes an API call to Minimax which may incur costs. Only use when explicitly requested by the user.
+
+    Args:
+        query (str): The search query string.
+        
+    Returns:
+        Text content with search results in JSON format. The response structure is:
+        {
+            "organic": [
+                {
+                    "title": "string - The title of the search result",
+                    "link": "string - The URL link to the result",
+                    "snippet": "string - A brief description or excerpt",
+                    "date": "string - The date of the result"
+                }
+            ],
+            "related_searches": [
+                {
+                    "query": "string - A related search query suggestion"
+                }
+            ],
+            "base_resp": {
+                "status_code": "int - Response status code",
+                "status_msg": "string - Response status message"
+            }
+        }
+    """
+)
+def coding_plan_search(
+    query: str,
+) -> TextContent:
+    try:
+        if not query:
+            raise MinimaxRequestError("Query is required")
+        
+        # Build request payload
+        payload = {
+            "q": query
+        }
+        
+        # Call search API
+        response_data = api_client.post("/v1/coding_plan/search", json=payload)
+        
+        # Return JSON dump of response data
+        return TextContent(
+            type="text",
+            text=json.dumps(response_data, ensure_ascii=False, indent=2)
+        )
+        
+    except MinimaxAPIError as e:
+        return TextContent(
+            type="text",
+            text=f"Failed to perform search: {str(e)}"
+        )
+
+
+@mcp.tool(
+    description="""Analyze an image with AI based on your text prompt.
+    
+    This tool analyzes images and answers questions or extracts information based on your prompt.
+    
+    COST WARNING: This tool makes an API call to Minimax which may incur costs. Only use when explicitly requested by the user.
+    
+    Args:
+        prompt (str): The text prompt describing what you want to analyze or extract from the image.
+        image_source (str): The source location of the image to analyze.
+            Accepts:
+            - HTTP/HTTPS URL: "https://example.com/image.jpg"
+            - Local file path: "/path/to/image.png"
+            Supported formats: JPEG, PNG, GIF, WebP
+        
+    Returns:
+        Text content with the VLM analysis result containing the content field.
+    """
+)
+def coding_plan_vlm(
+    prompt: str,
+    image_source: str,
+) -> TextContent:
+    try:
+        if not prompt:
+            raise MinimaxRequestError("Prompt is required")
+        if not image_source:
+            raise MinimaxRequestError("Image source is required")
+        
+        # Process image_source: convert HTTP URL or local file to base64, or pass through existing base64
+        processed_image_url = process_image_url(image_source)
+        
+        # Build request payload
+        payload = {
+            "prompt": prompt,
+            "image_url": processed_image_url
+        }
+        
+        # Call VLM API
+        response_data = api_client.post("/v1/coding_plan/vlm", json=payload)
+        
+        # Extract content from response
+        content = response_data.get("content", "")
+        
+        if not content:
+            raise MinimaxRequestError("No content returned from VLM API")
+        
+        # Return the content
+        return TextContent(
+            type="text",
+            text=content
+        )
+        
+    except MinimaxAPIError as e:
+        return TextContent(
+            type="text",
+            text=f"Failed to perform VLM analysis: {str(e)}"
+        )
+
+
+def main():
+    print("Starting Minimax MCP server")
+    """Run the Minimax MCP server"""
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

minimax_mcp/utils.py

@@ -0,0 +1,251 @@
+import os
+from pathlib import Path
+from datetime import datetime
+from fuzzywuzzy import fuzz
+import shutil
+import subprocess
+import base64
+import requests
+from typing import Iterator, Union
+from minimax_mcp.const import *
+from minimax_mcp.exceptions import MinimaxMcpError, MinimaxRequestError
+
+
+def is_file_writeable(path: Path) -> bool:
+    if path.exists():
+        return os.access(path, os.W_OK)
+    parent_dir = path.parent
+    return os.access(parent_dir, os.W_OK)
+
+
+def build_output_file(
+    tool: str, text: str, output_path: Path, extension: str, full_id: bool = False
+) -> Path:
+    id = text if full_id else text[:10]
+
+    output_file_name = f"{tool}_{id.replace(' ', '_')}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.{extension}"
+    return output_path / output_file_name
+
+
+def build_output_path(
+    output_directory: str | None, base_path: str | None = None, is_test: bool = False
+) -> Path:
+    # Set default base_path to desktop if not provided
+    if base_path is None:
+        base_path = str(Path.home() / "Desktop")
+    
+    # Handle output path based on output_directory
+    if output_directory is None:
+        output_path = Path(os.path.expanduser(base_path))
+    elif not os.path.isabs(os.path.expanduser(output_directory)):
+        output_path = Path(os.path.expanduser(base_path)) / Path(output_directory)
+    else:
+        output_path = Path(os.path.expanduser(output_directory))
+
+    # Safety checks and directory creation
+    if is_test:
+        return output_path
+    if not is_file_writeable(output_path):
+        raise MinimaxMcpError(f"Directory ({output_path}) is not writeable")
+    output_path.mkdir(parents=True, exist_ok=True)
+    return output_path
+
+
+def find_similar_filenames(
+    target_file: str, directory: Path, threshold: int = 70
+) -> list[tuple[str, int]]:
+    """
+    Find files with names similar to the target file using fuzzy matching.
+
+    Args:
+        target_file (str): The reference filename to compare against
+        directory (str): Directory to search in (defaults to current directory)
+        threshold (int): Similarity threshold (0 to 100, where 100 is identical)
+
+    Returns:
+        list: List of similar filenames with their similarity scores
+    """
+    target_filename = os.path.basename(target_file)
+    similar_files = []
+    for root, _, files in os.walk(directory):
+        for filename in files:
+            if (
+                filename == target_filename
+                and os.path.join(root, filename) == target_file
+            ):
+                continue
+            similarity = fuzz.token_sort_ratio(target_filename, filename)
+
+            if similarity >= threshold:
+                file_path = Path(root) / filename
+                similar_files.append((file_path, similarity))
+
+    similar_files.sort(key=lambda x: x[1], reverse=True)
+
+    return similar_files
+
+
+def try_find_similar_files(
+    filename: str, directory: Path, take_n: int = 5
+) -> list[Path]:
+    similar_files = find_similar_filenames(filename, directory)
+    if not similar_files:
+        return []
+
+    filtered_files = []
+
+    for path, _ in similar_files[:take_n]:
+        if check_audio_file(path):
+            filtered_files.append(path)
+
+    return filtered_files
+
+
+def check_audio_file(path: Path) -> bool:
+    audio_extensions = {
+        ".wav",
+        ".mp3",
+        ".m4a",
+        ".aac",
+        ".ogg",
+        ".flac",
+        ".mp4",
+        ".avi",
+        ".mov",
+        ".wmv",
+    }
+    return path.suffix.lower() in audio_extensions
+
+
+def process_input_file(file_path: str, audio_content_check: bool = True) -> Path:
+    if not os.path.isabs(file_path) and not os.environ.get(ENV_MINIMAX_MCP_BASE_PATH):
+        raise MinimaxMcpError(
+            "File path must be an absolute path if MINIMAX_MCP_BASE_PATH is not set"
+        )
+    path = Path(file_path)
+    if not path.exists() and path.parent.exists():
+        parent_directory = path.parent
+        similar_files = try_find_similar_files(path.name, parent_directory)
+        similar_files_formatted = ",".join([str(file) for file in similar_files])
+        if similar_files:
+            raise MinimaxMcpError(
+                f"File ({path}) does not exist. Did you mean any of these files: {similar_files_formatted}?"
+            )
+        raise MinimaxMcpError(f"File ({path}) does not exist")
+    elif not path.exists():
+        raise MinimaxMcpError(f"File ({path}) does not exist")
+    elif not path.is_file():
+        raise MinimaxMcpError(f"File ({path}) is not a file")
+
+    if audio_content_check and not check_audio_file(path):
+        raise MinimaxMcpError(f"File ({path}) is not an audio or video file")
+    return path
+
+
+def is_installed(lib_name: str) -> bool:
+    return shutil.which(lib_name) is not None
+
+
+def play(
+    audio: Union[bytes, Iterator[bytes]]
+) -> None:
+    if isinstance(audio, Iterator):
+        audio = b"".join(audio)
+
+    if not is_installed("ffplay"):
+        message = (
+            "ffplay from ffmpeg not found, necessary to play audio. "
+            "mac: install it with 'brew install ffmpeg'. "
+            "linux or windows: install it from https://ffmpeg.org/"
+        )
+        raise ValueError(message)
+    
+    args = ["ffplay", "-autoexit", "-", "-nodisp"]
+    proc = subprocess.Popen(
+        args=args,
+        stdout=subprocess.PIPE,
+        stdin=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    out, err = proc.communicate(input=audio)
+
+    proc.poll()
+
+
+def process_image_url(image_url: str) -> str:
+    """
+    Process image URL and convert to base64 data URL format.
+    
+    This function handles three types of image inputs:
+    1. HTTP/HTTPS URLs: Downloads the image and converts to base64
+    2. Base64 data URLs: Passes through as-is
+    3. Local file paths: Reads the file and converts to base64
+    
+    Args:
+        image_url (str): The image URL, data URL, or local file path
+        
+    Returns:
+        str: Base64 data URL in format "data:image/{format};base64,{data}"
+        
+    Raises:
+        MinimaxRequestError: If image cannot be downloaded, read, or processed
+    """
+    # If already in base64 data URL format, pass through
+    if image_url.startswith("data:"):
+        return image_url
+    
+    # Handle HTTP/HTTPS URLs
+    if image_url.startswith(("http://", "https://")):
+        try:
+            image_response = requests.get(image_url)
+            image_response.raise_for_status()
+            image_data = image_response.content
+            
+            # Detect image format from content-type header
+            content_type = image_response.headers.get('content-type', '').lower()
+            if 'jpeg' in content_type or 'jpg' in content_type:
+                image_format = 'jpeg'
+            elif 'png' in content_type:
+                image_format = 'png'
+            elif 'gif' in content_type:
+                image_format = 'gif'
+            elif 'webp' in content_type:
+                image_format = 'webp'
+            else:
+                # Default to jpeg if cannot detect
+                image_format = 'jpeg'
+            
+            # Convert to base64 data URL
+            base64_data = base64.b64encode(image_data).decode('utf-8')
+            return f"data:image/{image_format};base64,{base64_data}"
+            
+        except requests.RequestException as e:
+            raise MinimaxRequestError(f"Failed to download image from URL: {str(e)}")
+    
+    # Handle local file paths
+    else:
+        if not os.path.exists(image_url):
+            raise MinimaxRequestError(f"Local image file does not exist: {image_url}")
+        
+        try:
+            with open(image_url, "rb") as f:
+                image_data = f.read()
+                
+                # Detect image format from file extension
+                image_format = 'jpeg'  # Default
+                if image_url.lower().endswith('.png'):
+                    image_format = 'png'
+                elif image_url.lower().endswith('.gif'):
+                    image_format = 'gif'
+                elif image_url.lower().endswith('.webp'):
+                    image_format = 'webp'
+                elif image_url.lower().endswith(('.jpg', '.jpeg')):
+                    image_format = 'jpeg'
+                
+                base64_data = base64.b64encode(image_data).decode('utf-8')
+                return f"data:image/{image_format};base64,{base64_data}"
+                
+        except IOError as e:
+            raise MinimaxRequestError(f"Failed to read local image file: {str(e)}")
+
+