mseep-rmcp 0.3.3__py3-none-any.whl

rmcp/core/schemas.py

@@ -0,0 +1,156 @@
+"""
+JSON Schema validation helpers.
+
+Provides utilities for:
+- Schema validation with proper MCP error codes (-32602)
+- Common schema patterns for statistical tools
+- Type conversion helpers
+"""
+
+from typing import Any, Dict, List, Optional, Union
+import json
+import jsonschema
+from jsonschema import validate, ValidationError as JsonSchemaValidationError
+
+
+class SchemaError(Exception):
+    """Schema validation error with MCP error code."""
+    
+    def __init__(self, message: str, field: Optional[str] = None):
+        super().__init__(message)
+        self.field = field
+        self.code = -32602  # JSON-RPC invalid params error
+
+
+def validate_schema(data: Any, schema: Dict[str, Any], context: str = "") -> None:
+    """
+    Validate data against JSON schema.
+    
+    Raises SchemaError with MCP-compatible error code on failure.
+    """
+    try:
+        validate(instance=data, schema=schema)
+    except JsonSchemaValidationError as e:
+        field_path = ".".join(str(p) for p in e.absolute_path)
+        error_context = f" in {context}" if context else ""
+        field_info = f" (field: {field_path})" if field_path else ""
+        
+        raise SchemaError(
+            f"Schema validation failed{error_context}: {e.message}{field_info}",
+            field=field_path
+        ) from e
+    except Exception as e:
+        raise SchemaError(f"Schema validation error: {str(e)}") from e
+
+
+# Common schema patterns for statistical tools
+
+def table_schema(required_columns: Optional[List[str]] = None) -> Dict[str, Any]:
+    """Schema for tabular data (dict with column arrays)."""
+    schema = {
+        "type": "object",
+        "properties": {},
+        "additionalProperties": {
+            "type": "array",
+            "items": {"type": ["number", "string", "null"]}
+        }
+    }
+    
+    if required_columns:
+        schema["required"] = required_columns
+        for col in required_columns:
+            schema["properties"][col] = {
+                "type": "array",
+                "items": {"type": ["number", "string", "null"]}
+            }
+    
+    return schema
+
+
+def formula_schema() -> Dict[str, Any]:
+    """Schema for R formula strings."""
+    return {
+        "type": "string",
+        "pattern": r"^[^~]+~[^~]+$",
+        "description": "R formula (e.g., 'y ~ x1 + x2')"
+    }
+
+
+def numeric_array_schema(min_length: int = 1) -> Dict[str, Any]:
+    """Schema for numeric arrays."""
+    return {
+        "type": "array",
+        "items": {"type": "number"},
+        "minItems": min_length
+    }
+
+
+def positive_number_schema() -> Dict[str, Any]:
+    """Schema for positive numbers."""
+    return {
+        "type": "number",
+        "minimum": 0,
+        "exclusiveMinimum": True
+    }
+
+
+def confidence_level_schema() -> Dict[str, Any]:
+    """Schema for confidence levels (0-1)."""
+    return {
+        "type": "number",
+        "minimum": 0,
+        "maximum": 1,
+        "exclusiveMinimum": True,
+        "exclusiveMaximum": True
+    }
+
+
+def choice_schema(choices: List[str]) -> Dict[str, Any]:
+    """Schema for enumerated choices."""
+    return {
+        "type": "string",
+        "enum": choices
+    }
+
+
+# Tool result schemas
+
+def statistical_result_schema() -> Dict[str, Any]:
+    """Base schema for statistical analysis results."""
+    return {
+        "type": "object",
+        "properties": {
+            "success": {"type": "boolean"},
+            "message": {"type": "string"},
+            "data": {"type": "object"},
+            "metadata": {
+                "type": "object",
+                "properties": {
+                    "method": {"type": "string"},
+                    "n_obs": {"type": "integer", "minimum": 0},
+                    "timestamp": {"type": "string", "format": "date-time"}
+                }
+            }
+        },
+        "required": ["success"]
+    }
+
+
+def error_result_schema() -> Dict[str, Any]:
+    """Schema for error results."""
+    return {
+        "type": "object", 
+        "properties": {
+            "success": {"const": False},
+            "error": {
+                "type": "object",
+                "properties": {
+                    "type": {"type": "string"},
+                    "message": {"type": "string"},
+                    "details": {"type": "object"}
+                },
+                "required": ["type", "message"]
+            }
+        },
+        "required": ["success", "error"]
+    }

rmcp/core/server.py

@@ -0,0 +1,261 @@
+"""
+MCP Server shell with lifecycle hooks.
+
+This module provides the main server class that:
+- Initializes the MCP app using official SDK
+- Manages lifespan hooks (startup/shutdown) 
+- Composes transports at the edge
+- Centralizes registry management
+
+Following the principle: "A single shell centralizes initialization and teardown."
+"""
+
+import asyncio
+import logging
+from typing import Any, Dict, Optional, Callable, Awaitable, List
+from pathlib import Path
+import sys
+
+# Official MCP SDK imports (to be added when SDK is available)
+# from mcp import Server, initialize_server
+# from mcp.types import Request, Response, Notification
+
+from .context import Context, LifespanState, RequestState
+from ..registries.tools import ToolsRegistry  
+from ..registries.resources import ResourcesRegistry
+from ..registries.prompts import PromptsRegistry
+from ..security.vfs import VFS
+
+logger = logging.getLogger(__name__)
+
+
+class MCPServer:
+    """
+    Main MCP server shell that manages lifecycle and registries.
+    
+    Centralizes:
+    - Lifespan management (startup/shutdown)
+    - Registry composition (tools/resources/prompts)
+    - Security policy enforcement
+    - Transport-agnostic request handling
+    """
+    
+    def __init__(
+        self,
+        name: str = "RMCP MCP Server",
+        version: str = "0.3.2",
+        description: str = "R-based statistical analysis MCP server",
+    ):
+        self.name = name
+        self.version = version
+        self.description = description
+        
+        # Lifespan state
+        self.lifespan_state = LifespanState()
+        
+        # Registries
+        self.tools = ToolsRegistry()
+        self.resources = ResourcesRegistry()
+        self.prompts = PromptsRegistry()
+        
+        # Security
+        self.vfs: Optional[VFS] = None
+        
+        # Callbacks
+        self._startup_callbacks: List[Callable[[], Awaitable[None]]] = []
+        self._shutdown_callbacks: List[Callable[[], Awaitable[None]]] = []
+        
+        # Request tracking for cancellation
+        self._active_requests: Dict[str, RequestState] = {}
+    
+    def configure(
+        self,
+        allowed_paths: Optional[List[str]] = None,
+        cache_root: Optional[str] = None,
+        read_only: bool = True,
+        **settings: Any,
+    ) -> "MCPServer":
+        """Configure server settings."""
+        
+        if allowed_paths:
+            self.lifespan_state.allowed_paths = [Path(p) for p in allowed_paths]
+        
+        if cache_root:
+            cache_path = Path(cache_root)
+            cache_path.mkdir(parents=True, exist_ok=True)
+            self.lifespan_state.cache_root = cache_path
+        
+        self.lifespan_state.read_only = read_only
+        self.lifespan_state.settings.update(settings)
+        
+        # Initialize VFS
+        self.vfs = VFS(
+            allowed_roots=self.lifespan_state.allowed_paths,
+            read_only=read_only
+        )
+        
+        return self
+    
+    def on_startup(self, func: Callable[[], Awaitable[None]]) -> Callable[[], Awaitable[None]]:
+        """Register startup callback."""
+        self._startup_callbacks.append(func)
+        return func
+    
+    def on_shutdown(self, func: Callable[[], Awaitable[None]]) -> Callable[[], Awaitable[None]]:
+        """Register shutdown callback.""" 
+        self._shutdown_callbacks.append(func)
+        return func
+    
+    async def startup(self) -> None:
+        """Run startup callbacks."""
+        logger.info(f"Starting {self.name} v{self.version}")
+        
+        for callback in self._startup_callbacks:
+            await callback()
+        
+        logger.info("Server startup complete")
+    
+    async def shutdown(self) -> None:
+        """Run shutdown callbacks."""
+        logger.info("Shutting down server")
+        
+        # Cancel active requests
+        for request in self._active_requests.values():
+            request.cancel()
+        
+        # Run shutdown callbacks
+        for callback in self._shutdown_callbacks:
+            try:
+                await callback()
+            except Exception as e:
+                logger.error(f"Error in shutdown callback: {e}")
+        
+        logger.info("Server shutdown complete")
+    
+    def create_context(
+        self,
+        request_id: str,
+        method: str,
+        progress_token: Optional[str] = None,
+    ) -> Context:
+        """Create request context."""
+        
+        async def progress_callback(message: str, current: int, total: int) -> None:
+            # TODO: Send MCP progress notification
+            logger.info(f"Progress {request_id}: {message} ({current}/{total})")
+        
+        async def log_callback(level: str, message: str, data: Dict[str, Any]) -> None:
+            # TODO: Send MCP log notification  
+            log_level = getattr(logging, level.upper(), logging.INFO)
+            logger.log(log_level, f"{request_id}: {message} {data}")
+        
+        context = Context.create(
+            request_id=request_id,
+            method=method,
+            lifespan_state=self.lifespan_state,
+            progress_token=progress_token,
+            progress_callback=progress_callback,
+            log_callback=log_callback,
+        )
+        
+        # Track request for cancellation
+        self._active_requests[request_id] = context.request
+        
+        return context
+    
+    def finish_request(self, request_id: str) -> None:
+        """Clean up request tracking."""
+        self._active_requests.pop(request_id, None)
+    
+    async def cancel_request(self, request_id: str) -> None:
+        """Cancel active request."""
+        if request_id in self._active_requests:
+            self._active_requests[request_id].cancel()
+            logger.info(f"Cancelled request {request_id}")
+    
+    async def handle_request(self, request: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """
+        Handle incoming MCP request.
+        
+        This is the main dispatch point that routes requests to appropriate handlers.
+        Returns None for notifications (no response expected).
+        """
+        method = request.get("method")
+        request_id = request.get("id")
+        params = request.get("params", {})
+        
+        # Handle notifications (no response expected)
+        if request_id is None:
+            await self._handle_notification(method, params)
+            return None
+        
+        try:
+            context = self.create_context(request_id, method)
+            
+            # Route to appropriate handler
+            if method == "tools/list":
+                result = await self.tools.list_tools(context)
+            elif method == "tools/call":
+                tool_name = params.get("name")
+                arguments = params.get("arguments", {})
+                result = await self.tools.call_tool(context, tool_name, arguments)
+            elif method == "resources/list":
+                result = await self.resources.list_resources(context)
+            elif method == "resources/read":
+                uri = params.get("uri")
+                result = await self.resources.read_resource(context, uri)
+            elif method == "prompts/list":
+                result = await self.prompts.list_prompts(context)
+            elif method == "prompts/get":
+                name = params.get("name")
+                arguments = params.get("arguments", {})
+                result = await self.prompts.get_prompt(context, name, arguments)
+            else:
+                raise ValueError(f"Unknown method: {method}")
+            
+            return {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "result": result
+            }
+        
+        except Exception as e:
+            logger.error(f"Error handling request {request_id}: {e}")
+            return {
+                "jsonrpc": "2.0", 
+                "id": request_id,
+                "error": {
+                    "code": -32603,  # Internal error
+                    "message": str(e)
+                }
+            }
+        
+        finally:
+            if request_id:
+                self.finish_request(request_id)
+    
+    async def _handle_notification(self, method: str, params: Dict[str, Any]) -> None:
+        """Handle notification messages (no response expected)."""
+        logger.info(f"Received notification: {method}")
+        
+        if method == "notifications/cancelled":
+            # Handle cancellation notification
+            request_id = params.get("requestId")
+            if request_id:
+                await self.cancel_request(request_id)
+        
+        elif method == "notifications/initialized":
+            # MCP initialization complete
+            logger.info("MCP client initialization complete")
+        
+        else:
+            logger.warning(f"Unknown notification method: {method}")
+
+
+def create_server(
+    name: str = "RMCP MCP Server",
+    version: str = "0.3.2", 
+    description: str = "R-based statistical analysis MCP server",
+) -> MCPServer:
+    """Create and return a new MCP server instance."""
+    return MCPServer(name=name, version=version, description=description)

rmcp/r_assets/__init__.py

@@ -0,0 +1,8 @@
+"""
+R integration assets.
+
+Contains R scripts and assets needed for:
+- Package installation
+- R environment setup
+- Statistical computation resources  
+"""

rmcp/r_integration.py

@@ -0,0 +1,112 @@
+"""
+Clean R integration for statistical analysis.
+
+Extracted working R execution functionality without dependencies.
+"""
+
+import os
+import json
+import tempfile
+import subprocess
+import logging
+from typing import Dict, Any
+
+logger = logging.getLogger(__name__)
+
+
+class RExecutionError(Exception):
+    """Exception raised when R script execution fails."""
+    
+    def __init__(self, message: str, stdout: str = "", stderr: str = "", returncode: int = None):
+        super().__init__(message)
+        self.stdout = stdout
+        self.stderr = stderr  
+        self.returncode = returncode
+
+
+def execute_r_script(script: str, args: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Execute an R script with the given arguments and return the results.
+    
+    Args:
+        script: R script code to execute
+        args: Dictionary of arguments to pass to the R script
+        
+    Returns:
+        Dictionary containing the results from R script execution
+        
+    Raises:
+        RExecutionError: If R script execution fails
+        FileNotFoundError: If R is not installed or not in PATH
+        json.JSONDecodeError: If R script returns invalid JSON
+    """
+    with tempfile.NamedTemporaryFile(suffix='.R', delete=False, mode='w') as script_file, \
+         tempfile.NamedTemporaryFile(suffix='.json', delete=False, mode='w') as args_file, \
+         tempfile.NamedTemporaryFile(suffix='.json', delete=False) as result_file:
+        
+        script_path = script_file.name
+        args_path = args_file.name
+        result_path = result_file.name
+        
+        try:
+            # Write arguments to JSON file
+            json.dump(args, args_file, default=str)
+            args_file.flush()
+            
+            # Create complete R script
+            full_script = f'''
+# Load required libraries
+library(jsonlite)
+
+# Load arguments
+args <- fromJSON("{args_path}")
+
+# User script
+{script}
+
+# Write result
+write_json(result, "{result_path}", auto_unbox = TRUE)
+'''
+            
+            script_file.write(full_script)
+            script_file.flush()
+            
+            logger.debug(f"Executing R script with args: {args}")
+            
+            # Execute R script
+            process = subprocess.run(
+                ['R', '--slave', '--no-restore', '--file=' + script_path],
+                capture_output=True,
+                text=True,
+                timeout=120
+            )
+            
+            if process.returncode != 0:
+                error_msg = f"R script failed with return code {process.returncode}"
+                logger.error(f"{error_msg}\\nStderr: {process.stderr}")
+                raise RExecutionError(
+                    error_msg,
+                    stdout=process.stdout,
+                    stderr=process.stderr,
+                    returncode=process.returncode
+                )
+            
+            # Read results
+            try:
+                with open(result_path, 'r') as f:
+                    result = json.load(f)
+                logger.debug(f"R script executed successfully, result: {result}")
+                return result
+            except FileNotFoundError:
+                raise RExecutionError("R script did not produce output file")
+            except json.JSONDecodeError as e:
+                raise RExecutionError(f"R script produced invalid JSON: {e}")
+        
+        finally:
+            # Cleanup temporary files
+            for temp_path in [script_path, args_path, result_path]:
+                try:
+                    os.unlink(temp_path)
+                    logger.debug(f"Cleaned up temporary file: {temp_path}")
+                except OSError:
+                    pass

rmcp/registries/__init__.py

@@ -0,0 +1,26 @@
+"""
+Registry system for MCP server capabilities.
+
+The registry pattern provides clean separation between:
+- Protocol concerns (MCP message handling)  
+- Registry concerns (capability discovery and dispatch)
+- Domain concerns (actual tool/resource/prompt logic)
+
+This enables:
+- Independent testing of domain logic
+- Clean capability declaration
+- Type-safe interfaces
+"""
+
+from .tools import ToolsRegistry, tool
+from .resources import ResourcesRegistry, resource  
+from .prompts import PromptsRegistry, prompt
+
+__all__ = [
+    "ToolsRegistry",
+    "ResourcesRegistry", 
+    "PromptsRegistry",
+    "tool",
+    "resource",
+    "prompt",
+]