luma-mcp 1.2.2 → 1.2.4

package/minimax_coding_plan_mcp-0.0.2/minimax_mcp/__main__.py

@@ -1,99 +0,0 @@
-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_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)

package/minimax_coding_plan_mcp-0.0.2/minimax_mcp/client.py

@@ -1,104 +0,0 @@
-"""Minimax API client base class."""
-
-import requests
-import urllib3
-from typing import Any, Dict
-from minimax_mcp.exceptions import MinimaxAuthError, MinimaxRequestError
-
-# Disable SSL warnings for China region API
-urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
-
-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:
-            # Disable SSL verification for api.minimaxi.com (China region)
-            # This is a workaround for SSL certificate verification issues
-            if 'verify' not in kwargs and 'minimaxi.com' in self.api_host:
-                kwargs['verify'] = False
-            
-            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) 

package/minimax_coding_plan_mcp-0.0.2/minimax_mcp/const.py

@@ -1,4 +0,0 @@
-# ENV variables
-ENV_MINIMAX_API_KEY = "MINIMAX_API_KEY"
-ENV_MINIMAX_API_HOST = "MINIMAX_API_HOST"
-ENV_FASTMCP_LOG_LEVEL = "FASTMCP_LOG_LEVEL"

package/minimax_coding_plan_mcp-0.0.2/minimax_mcp/exceptions.py

@@ -1,24 +0,0 @@
-"""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

package/minimax_coding_plan_mcp-0.0.2/minimax_mcp/server.py

@@ -1,169 +0,0 @@
-"""
-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)
-api_host = os.getenv(ENV_MINIMAX_API_HOST)
-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="""
-    
-    Web Search API, works like Google Search.
-    
-    Args:
-        query (str): The search query string. Use 3-5 keywords. Add the current date for time-sensitive queries, e.g. `latest iPhone 2025`
-        
-    Search Strategy:
-        - If no valid results found, try changing search keywords
-        
-    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 web_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="""
-    
-    A powerful LLM that can analyze and understand image content from files or URLs, follow your instruction.
-    Use this tool to understand images by LLM.
-    Only support jpeg, png, webp formats. Other formats like pdf/gif/psd/svg and so on are not supported.
-        
-    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, WebP
-        
-    Returns:
-        Text content with the image analysis result.
-    """
-)
-def understand_image(
-    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()

package/minimax_coding_plan_mcp-0.0.2/minimax_mcp/utils.py

@@ -1,101 +0,0 @@
-import os
-import base64
-import requests
-from minimax_mcp.const import *
-from minimax_mcp.exceptions import MinimaxMcpError, MinimaxRequestError
-
-
-def strip_at_prefix(path: str) -> str:
-    """
-    Remove @ prefix from Claude Code file references.
-    
-    Claude Code uses @ as a syntax sugar for workspace files.
-    For example: @test-minimax-image/image.png -> test-minimax-image/image.png
-    
-    Args:
-        path (str): The file path that may have @ prefix
-        
-    Returns:
-        str: Path without @ prefix
-    """
-    if path.startswith('@'):
-        return path[1:]
-    return path
-
-
-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
-    """
-    # Remove @ prefix if present (Claude Code syntax)
-    image_url = strip_at_prefix(image_url)
-    
-    # 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 '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('.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)}")
-
-

package/minimax_coding_plan_mcp-0.0.2/pyproject.toml

@@ -1,59 +0,0 @@
-[project]
-name = "minimax-coding-plan-mcp"
-version = "0.0.2"
-description = "Specialized MiniMax Model Context Protocol (MCP) server designed for coding-plan users"
-authors = [
-    { name = "Roy Wu", email = "zhengyu@minimax.chat" },
-]
-readme = "README.md"
-license = { file = "LICENSE" }
-classifiers = [
-    "Development Status :: 4 - Beta",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
-]
-keywords = [
-    "minimax",
-    "mcp",
-    "web_search",
-    "understand-image",
-]
-requires-python = ">=3.10"
-dependencies = [
-    "mcp[cli]>=1.6.0",
-    "fastapi>=0.109.2",
-    "uvicorn>=0.27.1",
-    "python-dotenv>=1.0.1",
-    "pydantic>=2.6.1",
-    "httpx>=0.28.1",
-    "fuzzywuzzy>=0.18.0",
-    "python-Levenshtein>=0.25.0",
-    "sounddevice>=0.5.1",
-    "soundfile>=0.13.1",
-    "requests>=2.31.0",
-]
-
-[project.scripts]
-minimax-coding-plan-mcp = "minimax_mcp.server:main"
-
-[project.optional-dependencies]
-dev = [
-    "pre-commit>=3.6.2",
-    "ruff>=0.3.0",
-    "fastmcp>=0.4.1",
-    "pytest>=8.0.0",
-    "pytest-cov>=4.1.0",
-    "twine>=6.1.0",
-    "build>=1.0.3",
-]
-
-[build-system]
-requires = ["setuptools>=45", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[tool.pytest.ini_options]
-testpaths = ["tests"]
-python_files = ["test_*.py"]
-addopts = "-v --cov=minimax_mcp --cov-report=term-missing"

package/minimax_coding_plan_mcp-0.0.2/setup.cfg

@@ -1,4 +0,0 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-

package/minimax_coding_plan_mcp-0.0.2/setup.py

@@ -1,6 +0,0 @@
-from setuptools import setup, find_packages
-
-setup(
-    packages=find_packages(),
-    include_package_data=True,
-)