claude-mpm 4.3.22__py3-none-any.whl → 4.4.3__py3-none-any.whl

claude_mpm/services/mcp_gateway/core/process_pool.py

@@ -377,8 +377,289 @@ def get_process_pool() -> MCPProcessPool:
     return _pool
 
 
+async def auto_initialize_vector_search():
+    """
+    Auto-initialize mcp-vector-search for the current project.
+
+    WHY: Vector search requires project initialization before it can be used.
+    This function ensures the current project is automatically initialized
+    for vector search when the system starts up.
+
+    DESIGN DECISION:
+    - Automatically install mcp-vector-search if not present
+    - Run in background with timeout to avoid blocking startup
+    - Failures are logged but don't prevent the system from starting
+    """
+    logger = get_logger("vector_search_init")
+
+    try:
+        # Import MCPConfigManager to handle installation
+        from claude_mpm.services.mcp_config_manager import MCPConfigManager
+        config_manager = MCPConfigManager()
+
+        # Check if mcp-vector-search is already installed
+        vector_search_path = config_manager.detect_service_path("mcp-vector-search")
+
+        if vector_search_path:
+            logger.debug(f"mcp-vector-search found at: {vector_search_path}")
+        else:
+            # Not installed - attempt installation
+            logger.info("🔍 mcp-vector-search not found. Installing via pipx...")
+
+            # First check if pipx is available
+            import shutil
+            import subprocess
+
+            if not shutil.which("pipx"):
+                logger.warning("⚠️ pipx not found. Please install pipx to enable automatic mcp-vector-search installation")
+                logger.info("   Install pipx with: python -m pip install --user pipx")
+                return
+
+            try:
+                result = subprocess.run(
+                    ["pipx", "install", "mcp-vector-search"],
+                    capture_output=True,
+                    text=True,
+                    timeout=60  # 1 minute timeout for installation
+                )
+
+                if result.returncode == 0:
+                    logger.info("✅ mcp-vector-search installed successfully")
+                    # Detect the newly installed path
+                    vector_search_path = config_manager.detect_service_path("mcp-vector-search")
+                    if not vector_search_path:
+                        logger.warning("mcp-vector-search installed but command not found in PATH")
+                        return
+
+                    # Update the Claude configuration to include the newly installed service
+                    logger.info("📝 Updating Claude configuration...")
+                    config_success, config_msg = config_manager.ensure_mcp_services_configured()
+                    if config_success:
+                        logger.info(f"✅ {config_msg}")
+                    else:
+                        logger.warning(f"⚠️ Configuration update issue: {config_msg}")
+                else:
+                    logger.warning(f"Failed to install mcp-vector-search: {result.stderr}")
+                    return
+
+            except subprocess.TimeoutExpired:
+                logger.warning("Installation of mcp-vector-search timed out")
+                return
+            except Exception as e:
+                logger.warning(f"Error installing mcp-vector-search: {e}")
+                return
+
+        # At this point, mcp-vector-search should be available
+        # Get the actual command to use
+        import shutil
+        vector_search_cmd = shutil.which("mcp-vector-search")
+        if not vector_search_cmd:
+            # Try pipx installation path as fallback
+            pipx_path = Path.home() / ".local/pipx/venvs/mcp-vector-search/bin/mcp-vector-search"
+            if pipx_path.exists():
+                vector_search_cmd = str(pipx_path)
+            else:
+                logger.debug("mcp-vector-search command not found after installation")
+                return
+
+        # Check if current project is already initialized
+        current_dir = Path.cwd()
+        vector_config = current_dir / ".mcp-vector-search/config.json"
+
+        if vector_config.exists():
+            logger.debug(f"Vector search already initialized for {current_dir}")
+            # Check if index needs rebuilding (corrupted database)
+            chroma_db = current_dir / ".mcp-vector-search/chroma.sqlite3"
+            if chroma_db.exists():
+                # Quick health check - verify database file exists and is accessible
+                try:
+                    # Check if database file exists and has reasonable size
+                    if chroma_db.exists() and chroma_db.stat().st_size > 0:
+                        logger.info("✓ Vector search index is healthy and ready")
+                        return
+                    else:
+                        logger.info("⚠️ Vector search index may be corrupted, rebuilding...")
+                except Exception as e:
+                    logger.debug(f"Vector search health check failed: {e}, will attempt to rebuild")
+
+        # Initialize or reinitialize the project
+        logger.info(f"🎯 Initializing vector search for project: {current_dir}")
+
+        # Initialize the project (this creates the config)
+        # Note: mcp-vector-search operates on the current directory
+        import subprocess
+        proc = subprocess.run(
+            [vector_search_cmd, "init"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+            cwd=str(current_dir)  # Run in the project directory
+        )
+
+        if proc.returncode == 0:
+            logger.info("✅ Vector search initialization completed")
+
+            # Start background indexing (non-blocking)
+            def background_index():
+                try:
+                    logger.info("🔄 Starting project indexing in background...")
+                    index_proc = subprocess.run(
+                        [vector_search_cmd, "index", "main"],
+                        capture_output=True,
+                        text=True,
+                        timeout=300,  # 5 minute timeout for indexing
+                        cwd=str(current_dir)  # Run in the project directory
+                    )
+                    if index_proc.returncode == 0:
+                        logger.info("✅ Project indexing completed successfully")
+                        # Parse output to show statistics if available
+                        if "indexed" in index_proc.stdout.lower():
+                            # Extract and log indexing statistics
+                            lines = index_proc.stdout.strip().split('\n')
+                            for line in lines:
+                                if "indexed" in line.lower() or "files" in line.lower():
+                                    logger.info(f"   {line.strip()}")
+                    else:
+                        logger.warning(f"⚠️ Project indexing failed: {index_proc.stderr}")
+                except subprocess.TimeoutExpired:
+                    logger.warning("⚠️ Project indexing timed out (will continue in background)")
+                except Exception as e:
+                    logger.debug(f"Background indexing error (non-critical): {e}")
+
+            # Run indexing in background thread
+            import threading
+            index_thread = threading.Thread(target=background_index, daemon=True)
+            index_thread.start()
+            logger.info("📚 Background indexing started - vector search will be available shortly")
+
+        else:
+            logger.warning(f"⚠️ Vector search initialization failed: {proc.stderr}")
+
+    except Exception as e:
+        logger.debug(f"Vector search auto-initialization error (non-critical): {e}")
+
+
+async def auto_initialize_kuzu_memory():
+    """
+    Auto-initialize kuzu-memory for persistent knowledge storage.
+
+    WHY: Kuzu-memory provides a graph database for structured memory storage
+    with semantic search capabilities, enabling persistent context across sessions.
+
+    DESIGN DECISION:
+    - Automatically install kuzu-memory if not present via pipx
+    - Initialize database in background to avoid blocking startup
+    - Failures are logged but don't prevent the system from starting
+    """
+    logger = get_logger("kuzu_memory_init")
+
+    try:
+        # Import MCPConfigManager to handle installation
+        from claude_mpm.services.mcp_config_manager import MCPConfigManager
+        config_manager = MCPConfigManager()
+
+        # Check if kuzu-memory is already installed
+        kuzu_memory_path = config_manager.detect_service_path("kuzu-memory")
+
+        if kuzu_memory_path:
+            logger.debug(f"kuzu-memory found at: {kuzu_memory_path}")
+        else:
+            # Not installed - attempt installation
+            logger.info("🧠 kuzu-memory not found. Installing via pipx...")
+
+            # First check if pipx is available
+            import shutil
+            import subprocess
+
+            if not shutil.which("pipx"):
+                logger.warning("⚠️ pipx not found. Please install pipx to enable automatic kuzu-memory installation")
+                logger.info("   Install pipx with: python -m pip install --user pipx")
+                return
+
+            try:
+                result = subprocess.run(
+                    ["pipx", "install", "kuzu-memory"],
+                    capture_output=True,
+                    text=True,
+                    timeout=60  # 1 minute timeout for installation
+                )
+
+                if result.returncode == 0:
+                    logger.info("✅ kuzu-memory installed successfully")
+                    # Detect the newly installed path
+                    kuzu_memory_path = config_manager.detect_service_path("kuzu-memory")
+                    if not kuzu_memory_path:
+                        logger.warning("kuzu-memory installed but command not found in PATH")
+                        return
+
+                    # Update the Claude configuration to include the newly installed service
+                    logger.info("📝 Updating Claude configuration...")
+                    config_success, config_msg = config_manager.ensure_mcp_services_configured()
+                    if config_success:
+                        logger.info(f"✅ {config_msg}")
+                    else:
+                        logger.warning(f"⚠️ Configuration update issue: {config_msg}")
+                else:
+                    logger.warning(f"Failed to install kuzu-memory: {result.stderr}")
+                    return
+
+            except subprocess.TimeoutExpired:
+                logger.warning("Installation of kuzu-memory timed out")
+                return
+            except Exception as e:
+                logger.warning(f"Error installing kuzu-memory: {e}")
+                return
+
+        # At this point, kuzu-memory should be available
+        # Get the actual command to use
+        import shutil
+        kuzu_memory_cmd = shutil.which("kuzu-memory")
+        if not kuzu_memory_cmd:
+            # Try pipx installation path as fallback
+            pipx_path = Path.home() / ".local/pipx/venvs/kuzu-memory/bin/kuzu-memory"
+            if pipx_path.exists():
+                kuzu_memory_cmd = str(pipx_path)
+            else:
+                logger.debug("kuzu-memory command not found after installation")
+                return
+
+        # Initialize kuzu-memory database in current project
+        current_dir = Path.cwd()
+        kuzu_memories_dir = current_dir / "kuzu-memories"
+
+        # Check if database is already initialized
+        if kuzu_memories_dir.exists():
+            logger.debug(f"Kuzu-memory database already initialized at {kuzu_memories_dir}")
+        else:
+            logger.info(f"🎯 Initializing kuzu-memory database for project: {current_dir}")
+
+            # Initialize the database in current project directory
+            import subprocess
+            proc = subprocess.run(
+                [kuzu_memory_cmd, "init"],
+                capture_output=True,
+                text=True,
+                timeout=30,
+                cwd=str(current_dir),
+            )
+
+            if proc.returncode == 0:
+                logger.info("✅ Kuzu-memory database initialized successfully")
+            else:
+                logger.warning(f"⚠️ Kuzu-memory initialization failed: {proc.stderr}")
+
+    except Exception as e:
+        logger.debug(f"Kuzu-memory auto-initialization error (non-critical): {e}")
+
+
 async def pre_warm_mcp_servers():
     """Pre-warm MCP servers from configuration."""
+    # Auto-initialize vector search for current project
+    await auto_initialize_vector_search()
+
+    # Auto-initialize kuzu-memory for persistent knowledge
+    await auto_initialize_kuzu_memory()
+
     pool = get_process_pool()
 
     # Load MCP configurations

claude_mpm/services/mcp_gateway/core/startup_verification.py

@@ -45,7 +45,7 @@ class MCPGatewayStartupVerifier:
             "system_info",  # System diagnostics
             "health_check",  # Health diagnostics
             "document_summarizer",  # File summarizer
-            "ticket",  # Ticket service (unified)
+            # Ticket functionality now provided by mcp-ticketer
         ]
 
     async def verify_and_configure(self) -> Dict[str, Any]:
@@ -210,7 +210,7 @@ class MCPGatewayStartupVerifier:
                 "..tools.document_summarizer",
                 "DocumentSummarizerTool",
             ),
-            "ticket": ("..tools.unified_ticket_tool", "UnifiedTicketTool"),
+            # Ticket functionality now provided by mcp-ticketer
         }
 
         if tool_name not in tool_map:

claude_mpm/services/mcp_gateway/main.py

@@ -107,13 +107,8 @@ try:
 except ImportError:
     DocumentSummarizerTool = None
 
-try:
-    from claude_mpm.services.mcp_gateway.tools.unified_ticket_tool import (
-        UnifiedTicketTool,
-    )
-except ImportError:
-    # Unified ticket tool is optional
-    UnifiedTicketTool = None
+# Ticket tools removed - using mcp-ticketer instead
+UnifiedTicketTool = None
 
 try:
     from claude_mpm.services.mcp_gateway.tools.external_mcp_services import (
@@ -316,12 +311,7 @@ class MCPGatewayOrchestrator:
             except Exception as e:
                 self.logger.warning(f"Could not load document summarizer: {e}")
 
-        # Optional: Unified ticket management tool
-        if UnifiedTicketTool is not None:
-            try:
-                tools.append(UnifiedTicketTool())
-            except Exception as e:
-                self.logger.warning(f"Could not load unified ticket tool: {e}")
+        # Ticket tools removed - mcp-ticketer provides ticket functionality
 
         if not tools:
             self.logger.warning("No tools available to register")

claude_mpm/services/mcp_gateway/server/stdio_server.py

@@ -29,15 +29,8 @@ from mcp.types import TextContent, Tool
 # Import pydantic for model patching
 from claude_mpm.core.logger import get_logger
 
-# Import unified ticket tool if available
-try:
-    from claude_mpm.services.mcp_gateway.tools.unified_ticket_tool import (
-        UnifiedTicketTool,
-    )
-
-    TICKET_TOOLS_AVAILABLE = True
-except ImportError:
-    TICKET_TOOLS_AVAILABLE = False
+# Ticket tools removed - using mcp-ticketer instead
+TICKET_TOOLS_AVAILABLE = False
 
 
 def apply_backward_compatibility_patches():
@@ -629,7 +622,8 @@ class SimpleMCPServer:
 
         try:
             self.logger.info("Initializing unified ticket tool...")
-            self.unified_ticket_tool = UnifiedTicketTool()
+            # Ticket tools removed - using mcp-ticketer instead
+            self.unified_ticket_tool = None
             # If the tool has an async init method, call it
             if hasattr(self.unified_ticket_tool, "initialize"):
                 await self.unified_ticket_tool.initialize()

claude_mpm/services/mcp_gateway/tools/__init__.py

@@ -12,7 +12,14 @@ from .base_adapter import (
     SystemInfoToolAdapter,
 )
 from .document_summarizer import DocumentSummarizerTool
-from .unified_ticket_tool import UnifiedTicketTool
+from .kuzu_memory_service import (
+    KuzuMemoryService,
+    store_memory,
+    recall_memories,
+    search_memories,
+    get_context,
+)
+# Ticket tools removed - using mcp-ticketer instead
 
 __all__ = [
     "BaseToolAdapter",
@@ -20,5 +27,9 @@ __all__ = [
     "DocumentSummarizerTool",
     "EchoToolAdapter",
     "SystemInfoToolAdapter",
-    "UnifiedTicketTool",
+    "KuzuMemoryService",
+    "store_memory",
+    "recall_memories",
+    "search_memories",
+    "get_context",
 ]

claude_mpm/services/mcp_gateway/tools/external_mcp_services.py

@@ -16,10 +16,10 @@ import sys
 from pathlib import Path
 from typing import Any, Dict, List
 
-from claude_mpm.services.mcp_gateway.tools.base_adapter import BaseMCPToolAdapter
+from claude_mpm.services.mcp_gateway.tools.base_adapter import BaseToolAdapter
 
 
-class ExternalMCPService(BaseMCPToolAdapter):
+class ExternalMCPService(BaseToolAdapter):
     """Base class for external MCP service integration."""
 
     def __init__(self, service_name: str, package_name: str):
@@ -30,12 +30,40 @@ class ExternalMCPService(BaseMCPToolAdapter):
             service_name: Name of the service for MCP
             package_name: Python package name to install/run
         """
-        super().__init__()
+        # Import here to avoid circular imports
+        from claude_mpm.services.mcp_gateway.core.interfaces import MCPToolDefinition
+
+        # Create a basic tool definition for the service
+        tool_def = MCPToolDefinition(
+            name=service_name,
+            description=f"External MCP service: {package_name}",
+            input_schema={
+                "type": "object",
+                "properties": {},
+                "required": [],
+            },
+        )
+        super().__init__(tool_def)
         self.service_name = service_name
         self.package_name = package_name
         self.process = None
         self._is_installed = False
 
+    async def invoke(self, invocation):
+        """
+        Invoke method required by BaseToolAdapter interface.
+
+        This base implementation should be overridden by subclasses.
+        """
+        # Import here to avoid circular imports
+        from claude_mpm.services.mcp_gateway.core.interfaces import MCPToolResult
+
+        return MCPToolResult(
+            success=False,
+            error="invoke method not implemented in base ExternalMCPService",
+            execution_time=0.0,
+        )
+
     async def initialize(self) -> bool:
         """Initialize the external service."""
         try:
@@ -43,8 +71,8 @@ class ExternalMCPService(BaseMCPToolAdapter):
             self._is_installed = await self._check_installation()
 
             if not self._is_installed:
-                self.logger.warning(
-                    f"{self.package_name} not installed, attempting installation..."
+                self.logger.debug(
+                    f"{self.package_name} not installed - will attempt automatic installation if needed"
                 )
                 await self._install_package()
                 self._is_installed = await self._check_installation()
@@ -389,6 +417,8 @@ class ExternalMCPServiceManager:
         them as tools in the gateway - they run as separate MCP servers.
         """
         # Create service instances
+        # Note: kuzu-memory is configured via MCPConfigManager and runs as a separate MCP server
+        # It doesn't need to be included here since it's already set up through the MCP config
         services = [MCPVectorSearchService(), MCPBrowserService()]
 
         # Initialize each service
@@ -402,7 +432,7 @@ class ExternalMCPServiceManager:
                             f"Initialized external service: {service.service_name}"
                         )
                 elif self.logger:
-                    self.logger.warning(f"Failed to initialize: {service.service_name}")
+                    self.logger.debug(f"Service not available (optional): {service.service_name}")
             except Exception as e:
                 if self.logger:
                     self.logger.error(f"Error initializing {service.service_name}: {e}")