mcp-proxy-adapter 2.1.16__py3-none-any.whl → 3.0.0__py3-none-any.whl

mcp_proxy_adapter/config.py

@@ -0,0 +1,186 @@
+"""
+Module for microservice configuration management.
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+class Config:
+    """
+    Configuration management class for the microservice.
+    Allows loading settings from configuration file and environment variables.
+    """
+
+    def __init__(self, config_path: Optional[str] = None):
+        """
+        Initialize configuration.
+
+        Args:
+            config_path: Path to configuration file. If not specified, "./config.json" is used.
+        """
+        self.config_path = config_path or "./config.json"
+        self.config_data: Dict[str, Any] = {}
+        self.load_config()
+
+    def load_config(self) -> None:
+        """
+        Load configuration from file and environment variables.
+        """
+        # Set default config values
+        self.config_data = {
+            "server": {
+                "host": "0.0.0.0",
+                "port": 8000,
+                "debug": False,
+                "log_level": "INFO"
+            },
+            "logging": {
+                "level": "INFO",
+                "file": None
+            }
+        }
+        
+        # Try to load configuration from file
+        if os.path.exists(self.config_path):
+            try:
+                with open(self.config_path, 'r', encoding='utf-8') as f:
+                    file_config = json.load(f)
+                    self._update_nested_dict(self.config_data, file_config)
+            except Exception as e:
+                print(f"Error loading config from {self.config_path}: {e}")
+        
+        # Load configuration from environment variables
+        self._load_env_variables()
+
+    def load_from_file(self, config_path: str) -> None:
+        """
+        Load configuration from the specified file.
+
+        Args:
+            config_path: Path to configuration file.
+        """
+        self.config_path = config_path
+        self.load_config()
+
+    def _load_env_variables(self) -> None:
+        """
+        Load configuration from environment variables.
+        Environment variables should be in format SERVICE_SECTION_KEY=value.
+        For example, SERVICE_SERVER_PORT=8080.
+        """
+        prefix = "SERVICE_"
+        for key, value in os.environ.items():
+            if key.startswith(prefix):
+                parts = key[len(prefix):].lower().split("_", 1)
+                if len(parts) == 2:
+                    section, param = parts
+                    if section not in self.config_data:
+                        self.config_data[section] = {}
+                    self.config_data[section][param] = self._convert_env_value(value)
+
+    def _convert_env_value(self, value: str) -> Any:
+        """
+        Convert environment variable value to appropriate type.
+
+        Args:
+            value: Value as string
+
+        Returns:
+            Converted value
+        """
+        # Try to convert to appropriate type
+        if value.lower() == "true":
+            return True
+        elif value.lower() == "false":
+            return False
+        elif value.isdigit():
+            return int(value)
+        else:
+            try:
+                return float(value)
+            except ValueError:
+                return value
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """
+        Get configuration value for key.
+
+        Args:
+            key: Configuration key in format "section.param"
+            default: Default value if key not found
+
+        Returns:
+            Configuration value
+        """
+        parts = key.split(".")
+        
+        # Get value from config
+        value = self.config_data
+        for part in parts:
+            if not isinstance(value, dict) or part not in value:
+                return default
+            value = value[part]
+            
+        return value
+
+    def set(self, key: str, value: Any) -> None:
+        """
+        Set configuration value for key.
+
+        Args:
+            key: Configuration key in format "section.param"
+            value: Configuration value
+        """
+        parts = key.split(".")
+        if len(parts) == 1:
+            self.config_data[key] = value
+        else:
+            section = parts[0]
+            param = ".".join(parts[1:])
+            
+            if section not in self.config_data:
+                self.config_data[section] = {}
+                
+            current = self.config_data[section]
+            for part in parts[1:-1]:
+                if part not in current:
+                    current[part] = {}
+                current = current[part]
+                
+            current[parts[-1]] = value
+
+    def save(self, path: Optional[str] = None) -> None:
+        """
+        Save configuration to file.
+
+        Args:
+            path: Path to configuration file. If not specified, self.config_path is used.
+        """
+        save_path = path or self.config_path
+        with open(save_path, 'w', encoding='utf-8') as f:
+            json.dump(self.config_data, f, indent=2)
+
+    def _update_nested_dict(self, d: Dict, u: Dict) -> Dict:
+        """
+        Update nested dictionary recursively.
+
+        Args:
+            d: Dictionary to update
+            u: Dictionary with new values
+
+        Returns:
+            Updated dictionary
+        """
+        for k, v in u.items():
+            if isinstance(v, dict) and k in d and isinstance(d[k], dict):
+                self._update_nested_dict(d[k], v)
+            else:
+                d[k] = v
+        return d
+
+
+# Singleton instance
+config = Config()

mcp_proxy_adapter/custom_openapi.py

@@ -0,0 +1,125 @@
+"""
+Custom OpenAPI schema generator for MCP Microservice compatible with MCP-Proxy.
+"""
+import json
+from copy import deepcopy
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set, Type
+
+from fastapi import FastAPI
+from fastapi.openapi.utils import get_openapi
+
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.core.logging import logger
+
+
+class CustomOpenAPIGenerator:
+    """
+    Custom OpenAPI schema generator for compatibility with MCP-Proxy.
+    
+    This generator creates an OpenAPI schema that matches the format expected by MCP-Proxy,
+    enabling dynamic command loading and proper tool representation in AI models.
+    """
+    
+    def __init__(self):
+        """Initialize the generator."""
+        self.base_schema_path = Path(__file__).parent / "schemas" / "openapi_schema.json"
+        self.base_schema = self._load_base_schema()
+        
+    def _load_base_schema(self) -> Dict[str, Any]:
+        """
+        Load the base OpenAPI schema from file.
+        
+        Returns:
+            Dict containing the base OpenAPI schema.
+        """
+        with open(self.base_schema_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    
+    def _add_commands_to_schema(self, schema: Dict[str, Any]) -> None:
+        """
+        Add all registered commands to the OpenAPI schema.
+        
+        Args:
+            schema: The OpenAPI schema to update.
+        """
+        # Get all commands from the registry
+        commands = registry.get_all_commands()
+        
+        # Add command names to the CommandRequest enum
+        schema["components"]["schemas"]["CommandRequest"]["properties"]["command"]["enum"] = [
+            cmd for cmd in commands.keys()
+        ]
+        
+        # Add command parameters to oneOf
+        params_refs = []
+        
+        for name, cmd_class in commands.items():
+            # Create schema for command parameters
+            param_schema_name = f"{name.capitalize()}Params"
+            schema["components"]["schemas"][param_schema_name] = self._create_params_schema(cmd_class)
+            
+            # Add to oneOf
+            params_refs.append({"$ref": f"#/components/schemas/{param_schema_name}"})
+        
+        # Add null option for commands without parameters
+        params_refs.append({"type": "null"})
+        
+        # Set oneOf for params
+        schema["components"]["schemas"]["CommandRequest"]["properties"]["params"]["oneOf"] = params_refs
+    
+    def _create_params_schema(self, cmd_class: Type[Command]) -> Dict[str, Any]:
+        """
+        Create a schema for command parameters.
+        
+        Args:
+            cmd_class: The command class.
+            
+        Returns:
+            Dict containing the parameter schema.
+        """
+        # Get command schema
+        cmd_schema = cmd_class.get_schema()
+        
+        # Add title and description
+        cmd_schema["title"] = f"Parameters for {cmd_class.name}"
+        cmd_schema["description"] = f"Parameters for the {cmd_class.name} command"
+        
+        return cmd_schema
+        
+    def generate(self) -> Dict[str, Any]:
+        """
+        Generate the complete OpenAPI schema compatible with MCP-Proxy.
+        
+        Returns:
+            Dict containing the complete OpenAPI schema.
+        """
+        # Deep copy the base schema to avoid modifying it
+        schema = deepcopy(self.base_schema)
+        
+        # Add commands to schema
+        self._add_commands_to_schema(schema)
+        
+        logger.info(f"Generated OpenAPI schema with {len(registry.get_all_commands())} commands")
+        
+        return schema
+
+
+def custom_openapi(app: FastAPI) -> Dict[str, Any]:
+    """
+    Create a custom OpenAPI schema for the FastAPI application.
+    
+    Args:
+        app: The FastAPI application.
+        
+    Returns:
+        Dict containing the custom OpenAPI schema.
+    """
+    generator = CustomOpenAPIGenerator()
+    openapi_schema = generator.generate()
+    
+    # Cache the schema
+    app.openapi_schema = openapi_schema
+    
+    return openapi_schema 

mcp_proxy_adapter/framework.py

@@ -0,0 +1,109 @@
+"""
+Framework module for creating microservices.
+"""
+
+import os
+import uvicorn
+from typing import Any, Callable, Dict, List, Optional, Type, Union
+
+from fastapi import FastAPI
+
+from mcp_proxy_adapter.api.app import create_app
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.config import config
+from mcp_proxy_adapter.core.logging import logger, setup_logging
+
+
+class MicroService:
+    """
+    Main class for creating and managing microservices.
+    """
+    
+    def __init__(
+        self, 
+        title: str = "MicroService",
+        description: str = "JSON-RPC microservice",
+        version: str = "1.0.0",
+        config_path: Optional[str] = None,
+        log_level: str = "INFO",
+    ):
+        """
+        Initialize microservice.
+        
+        Args:
+            title: Service title (displayed in docs)
+            description: Service description (displayed in docs)
+            version: Service version
+            config_path: Path to configuration file
+            log_level: Logging level
+        """
+        # Set configuration
+        if config_path and os.path.exists(config_path):
+            config.load_from_file(config_path)
+            
+        # Set logging
+        setup_logging(log_level)
+        
+        # Create FastAPI app
+        self.app = create_app()
+        self.app.title = title
+        self.app.description = description
+        self.app.version = version
+        
+        logger.info(f"MicroService '{title}' v{version} initialized")
+    
+    def register_command(self, command_class: Type[Command]) -> None:
+        """
+        Register command in the service.
+        
+        Args:
+            command_class: Command class to register
+        """
+        registry.register(command_class)
+        logger.info(f"Command '{command_class.name if hasattr(command_class, 'name') else command_class.__name__}' registered")
+    
+    def discover_commands(self, package_path: str) -> None:
+        """
+        Automatically discover and register commands in package.
+        
+        Args:
+            package_path: Path to package with commands
+        """
+        registry.discover_commands(package_path)
+        logger.info(f"Commands discovered in package '{package_path}'")
+    
+    def run(
+        self,
+        host: str = "0.0.0.0",
+        port: int = 8000,
+        reload: bool = False,
+        workers: int = 1,
+    ) -> None:
+        """
+        Run microservice.
+        
+        Args:
+            host: Host to bind server
+            port: Port to bind server
+            reload: Enable auto-reload on code changes
+            workers: Number of worker processes
+        """
+        logger.info(f"Starting microservice on {host}:{port}")
+        uvicorn.run(
+            self.app,
+            host=host,
+            port=port,
+            reload=reload,
+            workers=workers,
+            log_level=config.get("logging.level", "info").lower()
+        )
+    
+    def get_app(self) -> FastAPI:
+        """
+        Get FastAPI application instance.
+        
+        Returns:
+            FastAPI application
+        """
+        return self.app