hanzo-mcp 0.6.12__py3-none-any.whl → 0.7.0__py3-none-any.whl

hanzo_mcp/config/settings.py

@@ -1,4 +1,4 @@
-"""Settings management for Hanzo MCP.
+"""Settings management for Hanzo AI.
 
 Handles loading and saving configuration from multiple sources:
 1. Default settings
@@ -59,6 +59,7 @@ class AgentConfig:
     enabled: bool = False
     model: Optional[str] = None
     api_key: Optional[str] = None
+    hanzo_api_key: Optional[str] = None  # HANZO_API_KEY support
     base_url: Optional[str] = None
     max_tokens: Optional[int] = None
     max_iterations: int = 10
@@ -70,7 +71,7 @@ class ServerConfig:
     """Configuration for the MCP server."""
     name: str = "hanzo-mcp"
     host: str = "127.0.0.1"
-    port: int = 3000
+    port: int = 8888
     transport: str = "stdio"  # stdio or sse
     log_level: str = "INFO"
     command_timeout: float = 120.0
@@ -78,7 +79,7 @@ class ServerConfig:
 
 @dataclass
 class HanzoMCPSettings:
-    """Complete configuration for Hanzo MCP."""
+    """Complete configuration for Hanzo AI."""
     # Server settings
     server: ServerConfig = field(default_factory=ServerConfig)
     
@@ -106,6 +107,9 @@ class HanzoMCPSettings:
     projects: Dict[str, ProjectConfig] = field(default_factory=dict)
     current_project: Optional[str] = None
     
+    # Mode configuration
+    active_mode: Optional[str] = None
+    
     def __post_init__(self):
         """Initialize default tool states if not specified."""
         if not self.enabled_tools:
@@ -250,7 +254,7 @@ class HanzoMCPSettings:
 
 
 def get_config_dir() -> Path:
-    """Get the configuration directory for Hanzo MCP."""
+    """Get the configuration directory for Hanzo AI."""
     if os.name == "nt":  # Windows
         config_dir = Path(os.environ.get("APPDATA", "")) / "hanzo"
     else:  # Unix/macOS
@@ -341,6 +345,59 @@ def detect_project_from_path(file_path: str) -> Optional[Dict[str, str]]:
     return None
 
 
+def _load_from_env() -> Dict[str, Any]:
+    """Load configuration from environment variables."""
+    config = {}
+    
+    # Check for agent API keys
+    has_api_keys = False
+    
+    # HANZO_API_KEY
+    if hanzo_key := os.environ.get("HANZO_API_KEY"):
+        config.setdefault("agent", {})["hanzo_api_key"] = hanzo_key
+        config["agent"]["enabled"] = True
+        has_api_keys = True
+    
+    # Check for other API keys
+    api_key_env_vars = [
+        ("OPENAI_API_KEY", "openai"),
+        ("ANTHROPIC_API_KEY", "anthropic"), 
+        ("GOOGLE_API_KEY", "google"),
+        ("GROQ_API_KEY", "groq"),
+        ("TOGETHER_API_KEY", "together"),
+        ("MISTRAL_API_KEY", "mistral"),
+        ("PERPLEXITY_API_KEY", "perplexity"),
+    ]
+    
+    for env_var, provider in api_key_env_vars:
+        if os.environ.get(env_var):
+            has_api_keys = True
+            break
+    
+    # Auto-enable agent and consensus tools if API keys present
+    if has_api_keys:
+        config.setdefault("enabled_tools", {})
+        config["enabled_tools"]["agent"] = True
+        config["enabled_tools"]["consensus"] = True
+        config.setdefault("agent", {})["enabled"] = True
+    
+    # Check for MODE/PERSONALITY/HANZO_MODE
+    if mode := os.environ.get("HANZO_MODE") or os.environ.get("PERSONALITY") or os.environ.get("MODE"):
+        config["active_mode"] = mode
+    
+    # Check for other environment overrides
+    if project_dir := os.environ.get("HANZO_PROJECT_DIR"):
+        config["project_dir"] = project_dir
+    
+    if log_level := os.environ.get("HANZO_LOG_LEVEL"):
+        config.setdefault("server", {})["log_level"] = log_level
+    
+    if allowed_paths := os.environ.get("HANZO_ALLOWED_PATHS"):
+        config["allowed_paths"] = allowed_paths.split(":")
+    
+    return config
+
+
 def load_settings(
     project_dir: Optional[str] = None,
     config_overrides: Optional[Dict[str, Any]] = None
@@ -349,9 +406,10 @@ def load_settings(
     
     Priority (highest to lowest):
     1. config_overrides (usually from CLI)
-    2. Project-specific config file
-    3. Global config file
-    4. Defaults
+    2. Environment variables
+    3. Project-specific config file
+    4. Global config file
+    5. Defaults
     """
     # Start with defaults
     settings = HanzoMCPSettings()
@@ -380,6 +438,11 @@ def load_settings(
             logger = logging.getLogger(__name__)
             logger.warning(f"Failed to load project config: {e}")
     
+    # Apply environment variables
+    env_config = _load_from_env()
+    if env_config:
+        settings = _merge_config(settings, env_config)
+    
     # Apply CLI overrides
     if config_overrides:
         settings = _merge_config(settings, config_overrides)

hanzo_mcp/config/tool_config.py

@@ -1,4 +1,4 @@
-"""Tool configuration definitions for Hanzo MCP."""
+"""Tool configuration definitions for Hanzo AI."""
 
 from enum import Enum
 from typing import Dict, List, Optional
@@ -6,7 +6,7 @@ from dataclasses import dataclass
 
 
 class ToolCategory(str, Enum):
-    """Categories of tools available in Hanzo MCP."""
+    """Categories of tools available in Hanzo AI."""
     FILESYSTEM = "filesystem"
     SHELL = "shell"
     JUPYTER = "jupyter"
@@ -71,11 +71,11 @@ TOOL_REGISTRY: Dict[str, ToolConfig] = {
         description="Fast content search using ripgrep or fallback Python implementation",
         cli_flag="--disable-grep"
     ),
-    "grep_ast": ToolConfig(
-        name="grep_ast", 
+    "ast": ToolConfig(
+        name="ast", 
         category=ToolCategory.FILESYSTEM,
         description="Search source code with AST context using tree-sitter",
-        cli_flag="--disable-grep-ast"
+        cli_flag="--disable-ast"
     ),
     "content_replace": ToolConfig(
         name="content_replace",
@@ -120,7 +120,7 @@ TOOL_REGISTRY: Dict[str, ToolConfig] = {
         cli_flag="--disable-todo-write"
     ),
     
-    # Agent Tools (1)
+    # Agent Tools (3)
     "dispatch_agent": ToolConfig(
         name="dispatch_agent",
         category=ToolCategory.AGENT,
@@ -128,6 +128,20 @@ TOOL_REGISTRY: Dict[str, ToolConfig] = {
         description="Delegate tasks to sub-agents for concurrent/specialized processing",
         cli_flag="--enable-dispatch-agent"
     ),
+    "swarm": ToolConfig(
+        name="swarm",
+        category=ToolCategory.AGENT,
+        enabled=False,  # Disabled by default
+        description="Execute multiple agent tasks in parallel across different files",
+        cli_flag="--enable-swarm"
+    ),
+    "hierarchical_swarm": ToolConfig(
+        name="hierarchical_swarm",
+        category=ToolCategory.AGENT,
+        enabled=False,  # Disabled by default
+        description="Execute hierarchical agent swarms with Claude Code integration",
+        cli_flag="--enable-hierarchical-swarm"
+    ),
     
     # Common Tools (3)
     "think": ToolConfig(

hanzo_mcp/dev_server.py

@@ -1,4 +1,4 @@
-"""Development server with hot reload for Hanzo MCP."""
+"""Development server with hot reload for Hanzo AI."""
 
 import asyncio
 import logging
@@ -159,7 +159,7 @@ class DevServer:
         self.running = True
         
         logger = logging.getLogger(__name__)
-        logger.info(f"\n🚀 Starting Hanzo MCP in development mode...")
+        logger.info(f"\n🚀 Starting Hanzo AI in development mode...")
         logger.info(f"🔧 Hot reload enabled - watching for file changes")
         logger.info(f"📁 Project: {self.project_dir or 'current directory'}")
         logger.info(f"🌐 Transport: {transport}\n")
@@ -194,7 +194,7 @@ def run_dev_server():
     """Entry point for development server."""
     import argparse
     
-    parser = argparse.ArgumentParser(description="Run Hanzo MCP in development mode with hot reload")
+    parser = argparse.ArgumentParser(description="Run Hanzo AI in development mode with hot reload")
     parser.add_argument(
         "--name",
         type=str,

hanzo_mcp/prompts/project_system.py

@@ -30,7 +30,7 @@ Recent commits:
 </project_info>
 
 <available_tools>
-Hanzo MCP provides 65+ tools organized by category. Key tools include:
+Hanzo AI provides 65+ tools organized by category. Key tools include:
 
 # File Operations
 - read, write, edit, multi_edit: File manipulation

hanzo_mcp/server.py

@@ -16,6 +16,9 @@ except ImportError:
     # Fallback for older MCP versions
     from mcp.server import FastMCP
 
+# Import our enhanced server
+from hanzo_mcp.server_enhanced import EnhancedFastMCP
+
 from hanzo_mcp.prompts import register_all_prompts
 from hanzo_mcp.tools import register_all_tools
 
@@ -45,11 +48,11 @@ class HanzoMCPServer:
         disable_write_tools: bool = False,
         disable_search_tools: bool = False,
         host: str = "127.0.0.1",
-        port: int = 3000,
+        port: int = 8888,
         enabled_tools: dict[str, bool] | None = None,
         disabled_tools: list[str] | None = None,
     ):
-        """Initialize the Hanzo MCP server.
+        """Initialize the Hanzo AI server.
 
         Args:
             name: The name of the server
@@ -72,7 +75,8 @@ class HanzoMCPServer:
             enabled_tools: Dictionary of individual tool enable states (default: None)
             disabled_tools: List of tool names to disable (default: None)
         """
-        self.mcp = mcp_instance if mcp_instance is not None else FastMCP(name)
+        # Use enhanced server for automatic context normalization
+        self.mcp = mcp_instance if mcp_instance is not None else EnhancedFastMCP(name)
 
         # Initialize permissions and command executor
         self.permission_manager = PermissionManager()
@@ -222,3 +226,36 @@ class HanzoMCPServer:
         # Run the server
         transport_type = cast(Literal["stdio", "sse"], transport)
         self.mcp.run(transport=transport_type)
+
+
+def create_server(
+    name: str = "hanzo-mcp",
+    allowed_paths: list[str] | None = None,
+    enable_all_tools: bool = False,
+    **kwargs
+) -> HanzoMCPServer:
+    """Create a Hanzo MCP server instance.
+    
+    Args:
+        name: Server name
+        allowed_paths: List of allowed file paths
+        enable_all_tools: Enable all tools including agent tools
+        **kwargs: Additional server configuration
+        
+    Returns:
+        HanzoMCPServer instance
+    """
+    if enable_all_tools:
+        kwargs['enable_agent_tool'] = True
+        
+    return HanzoMCPServer(
+        name=name,
+        allowed_paths=allowed_paths,
+        **kwargs
+    )
+
+
+def main():
+    """Main entry point for the server."""
+    from hanzo_mcp.cli import main as cli_main
+    cli_main()

hanzo_mcp/server_enhanced.py

@@ -0,0 +1,69 @@
+"""Enhanced MCP server with automatic context normalization.
+
+This module provides an enhanced FastMCP server that automatically
+applies context normalization to all registered tools.
+"""
+
+from typing import Any, Callable
+from functools import wraps
+
+from mcp.server import FastMCP
+
+from hanzo_mcp.tools.common.decorators import with_context_normalization
+
+
+class EnhancedFastMCP(FastMCP):
+    """Enhanced FastMCP server with automatic context normalization.
+    
+    This server automatically wraps all tool registrations with context
+    normalization, ensuring that tools work properly when called externally
+    with serialized context parameters.
+    """
+    
+    def tool(
+        self,
+        name: str | None = None,
+        description: str | None = None
+    ) -> Callable:
+        """Enhanced tool decorator that includes automatic context normalization.
+        
+        Args:
+            name: Tool name (defaults to function name)
+            description: Tool description
+            
+        Returns:
+            Decorator function that registers the tool with context normalization
+        """
+        # Get the original decorator from parent class
+        original_decorator = super().tool(
+            name=name,
+            description=description
+        )
+        
+        # Create our enhanced decorator
+        def enhanced_decorator(func: Callable) -> Callable:
+            # Apply context normalization first
+            # Check if function has ctx parameter
+            import inspect
+            sig = inspect.signature(func)
+            if 'ctx' in sig.parameters:
+                normalized_func = with_context_normalization(func)
+            else:
+                normalized_func = func
+            
+            # Then apply the original decorator
+            return original_decorator(normalized_func)
+        
+        return enhanced_decorator
+
+
+def create_enhanced_server(name: str = "hanzo") -> EnhancedFastMCP:
+    """Create an enhanced MCP server with automatic context normalization.
+    
+    Args:
+        name: Server name
+        
+    Returns:
+        Enhanced FastMCP server instance
+    """
+    return EnhancedFastMCP(name)

hanzo_mcp/tools/__init__.py

@@ -1,7 +1,7 @@
-"""Tools package for Hanzo MCP.
+"""Tools package for Hanzo AI.
 
-This package contains all the tools for the Hanzo MCP server.
-It provides a unified interface for registering all tools with an MCP server.
+This package contains all the tools for the Hanzo AI server.
+It provides a interface for registering all tools with an MCP server.
 
 This includes a "think" tool implementation based on Anthropic's research showing
 improved performance for complex tool-based interactions when Claude has a dedicated
@@ -12,7 +12,7 @@ to delegate tasks to sub-agents for concurrent execution and specialized process
 from mcp.server import FastMCP
 
 from hanzo_mcp.tools.agent import register_agent_tools
-from hanzo_mcp.tools.common import register_batch_tool, register_thinking_tool
+from hanzo_mcp.tools.common import register_batch_tool, register_thinking_tool, register_critic_tool
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.common.tool_enable import ToolEnableTool
@@ -25,11 +25,28 @@ from hanzo_mcp.tools.shell import register_shell_tools
 from hanzo_mcp.tools.todo import register_todo_tools
 from hanzo_mcp.tools.vector import register_vector_tools
 from hanzo_mcp.tools.database import register_database_tools, DatabaseManager
-from hanzo_mcp.tools.mcp import UnifiedMCPTool, McpAddTool, McpRemoveTool, McpStatsTool
+
+# Try to import memory tools, but don't fail if hanzo-memory is not installed
+try:
+    from hanzo_mcp.tools.memory import register_memory_tools
+    MEMORY_TOOLS_AVAILABLE = True
+except ImportError:
+    MEMORY_TOOLS_AVAILABLE = False
+    register_memory_tools = None
+from hanzo_mcp.tools.mcp import MCPTool, McpAddTool, McpRemoveTool, McpStatsTool
 from hanzo_mcp.tools.editor import NeovimEditTool, NeovimCommandTool, NeovimSessionTool
-from hanzo_mcp.tools.llm import UnifiedLLMTool, LLMTool, ConsensusTool, LLMManageTool, create_provider_tools
-from hanzo_mcp.tools.config.palette_tool import palette_tool
-from hanzo_mcp.tools.common.palette_loader import PaletteLoader
+from hanzo_mcp.tools.llm import LLMTool, LLMTool, ConsensusTool, LLMManageTool, create_provider_tools
+from hanzo_mcp.tools.config.mode_tool import mode_tool
+from hanzo_mcp.tools.common.mode_loader import ModeLoader
+from hanzo_mcp.tools.common.mode import activate_mode_from_env
+from hanzo_mcp.tools.common.plugin_loader import load_user_plugins
+
+# Try to import LSP tool
+try:
+    from hanzo_mcp.tools.lsp import LSPTool, create_lsp_tool
+    LSP_TOOL_AVAILABLE = True
+except ImportError:
+    LSP_TOOL_AVAILABLE = False
 
 
 def register_all_tools(
@@ -46,8 +63,8 @@ def register_all_tools(
     disable_search_tools: bool = False,
     enabled_tools: dict[str, bool] | None = None,
     vector_config: dict | None = None,
-    use_palette: bool = True,
-    force_palette: str | None = None,
+    use_mode: bool = True,
+    force_mode: str | None = None,
 ) -> None:
     """Register all Hanzo tools with the MCP server.
 
@@ -65,20 +82,36 @@ def register_all_tools(
         disable_search_tools: Whether to disable search tools (default: False)
         enabled_tools: Dictionary of individual tool enable/disable states (default: None)
         vector_config: Vector store configuration (default: None)
-        use_palette: Whether to use palette system for tool configuration (default: True)
-        force_palette: Force a specific palette to be active (default: None)
+        use_mode: Whether to use mode system for tool configuration (default: True)
+        force_mode: Force a specific mode to be active (default: None)
     """
     # Dictionary to store all registered tools
     all_tools: dict[str, BaseTool] = {}
     
-    # Apply palette configuration if enabled
-    if use_palette:
-        tool_config = PaletteLoader.get_enabled_tools_from_palette(
+    # Load user plugins early
+    try:
+        plugins = load_user_plugins()
+        import logging
+        logger = logging.getLogger(__name__)
+        if plugins:
+            logger.info(f"Loaded {len(plugins)} user plugin tools: {', '.join(plugins.keys())}")
+    except Exception as e:
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.warning(f"Failed to load user plugins: {e}")
+        plugins = {}
+    
+    # Apply mode configuration if enabled
+    if use_mode:
+        # First check for mode activation from environment
+        activate_mode_from_env()
+        
+        tool_config = ModeLoader.get_enabled_tools_from_mode(
             base_enabled_tools=enabled_tools,
-            force_palette=force_palette
+            force_mode=force_mode
         )
-        # Apply palette environment variables
-        PaletteLoader.apply_palette_environment()
+        # Apply mode environment variables
+        ModeLoader.apply_environment_from_mode()
     else:
         # Use individual tool configuration if provided, otherwise fall back to category-level flags
         tool_config = enabled_tools or {}
@@ -97,15 +130,18 @@ def register_all_tools(
         "multi_edit": is_tool_enabled("multi_edit", not disable_write_tools),
         "directory_tree": is_tool_enabled("directory_tree", True),
         "grep": is_tool_enabled("grep", not disable_search_tools),
-        "grep_ast": is_tool_enabled("grep_ast", not disable_search_tools),
+        "symbols": is_tool_enabled("symbols", not disable_search_tools),
         "git_search": is_tool_enabled("git_search", not disable_search_tools),
         "content_replace": is_tool_enabled("content_replace", not disable_write_tools),
         "batch_search": is_tool_enabled("batch_search", not disable_search_tools),
         "find_files": is_tool_enabled("find_files", True),
-        "unified_search": is_tool_enabled("unified_search", not disable_search_tools),
+        "rules": is_tool_enabled("rules", True),
+        "search": is_tool_enabled("search", not disable_search_tools),
+        "unified_search": is_tool_enabled("unified_search", True),  # Primary search tool
+        "find": is_tool_enabled("find", True),  # Fast file finder
     }
     
-    # Vector tools setup (needed for unified search)
+    # Vector tools setup (needed for search)
     project_manager = None
     vector_enabled = {
         "vector_index": is_tool_enabled("vector_index", False),
@@ -113,7 +149,7 @@ def register_all_tools(
     }
     
     # Create project manager if vector tools, batch_search, or unified_search are enabled
-    if any(vector_enabled.values()) or filesystem_enabled.get("batch_search", False) or filesystem_enabled.get("unified_search", False):
+    if any(vector_enabled.values()) or filesystem_enabled.get("batch_search", False) or filesystem_enabled.get("search", False):
         if vector_config:
             from hanzo_mcp.tools.vector.project_manager import ProjectVectorManager
             search_paths = [str(path) for path in permission_manager.allowed_paths]
@@ -155,8 +191,10 @@ def register_all_tools(
             all_tools[tool.name] = tool
 
     # Register agent tools if enabled
-    agent_enabled = enable_agent_tool or is_tool_enabled("dispatch_agent", False)
-    if agent_enabled:
+    agent_enabled = enable_agent_tool or is_tool_enabled("agent", False) or is_tool_enabled("dispatch_agent", False)
+    swarm_enabled = is_tool_enabled("swarm", False)
+    
+    if agent_enabled or swarm_enabled:
         agent_tools = register_agent_tools(
             mcp_server,
             permission_manager,
@@ -167,17 +205,27 @@ def register_all_tools(
             agent_max_iterations=agent_max_iterations,
             agent_max_tool_uses=agent_max_tool_uses,
         )
+        # Filter based on what's enabled
         for tool in agent_tools:
-            all_tools[tool.name] = tool
+            if tool.name == "agent" and agent_enabled:
+                all_tools[tool.name] = tool
+            elif tool.name == "swarm" and swarm_enabled:
+                all_tools[tool.name] = tool
+            elif tool.name in ["claude", "codex", "gemini", "grok", "code_auth"]:
+                # CLI tools and auth are always included when agent tools are enabled
+                all_tools[tool.name] = tool
 
     # Register todo tools if enabled
     todo_enabled = {
+        "todo": is_tool_enabled("todo", True),
+        # Backward compatibility - if old names are used, enable the unified tool
         "todo_read": is_tool_enabled("todo_read", True),
         "todo_write": is_tool_enabled("todo_write", True),
     }
     
+    # Enable unified todo if any of the todo tools are enabled
     if any(todo_enabled.values()):
-        todo_tools = register_todo_tools(mcp_server, enabled_tools=todo_enabled)
+        todo_tools = register_todo_tools(mcp_server, enabled_tools={"todo": True})
         for tool in todo_tools:
             all_tools[tool.name] = tool
 
@@ -186,6 +234,12 @@ def register_all_tools(
         thinking_tool = register_thinking_tool(mcp_server)
         for tool in thinking_tool:
             all_tools[tool.name] = tool
+    
+    # Register critic tool if enabled
+    if is_tool_enabled("critic", True):
+        critic_tools = register_critic_tool(mcp_server)
+        for tool in critic_tools:
+            all_tools[tool.name] = tool
 
     # Register vector tools if enabled (reuse project_manager if available)
     if any(vector_enabled.values()) and project_manager:
@@ -230,7 +284,7 @@ def register_all_tools(
     
     # Register unified MCP tool if enabled
     if is_tool_enabled("mcp", True):
-        tool = UnifiedMCPTool()
+        tool = MCPTool()
         tool.register(mcp_server)
         all_tools[tool.name] = tool
     
@@ -275,9 +329,9 @@ def register_all_tools(
     stats_tool.register(mcp_server)
     all_tools[stats_tool.name] = stats_tool
     
-    # Palette tool (always enabled for managing tool sets)
-    palette_tool.register(mcp_server)
-    all_tools[palette_tool.name] = palette_tool
+    # Mode tool (always enabled for managing tool sets)
+    mode_tool.register(mcp_server)
+    all_tools[mode_tool.name] = mode_tool
     
     # Register editor tools if enabled
     editor_enabled = {
@@ -303,11 +357,18 @@ def register_all_tools(
     
     # Register unified LLM tool if enabled
     if is_tool_enabled("llm", True):
-        tool = UnifiedLLMTool()
+        tool = LLMTool()
         if tool.available_providers:  # Only register if API keys found
             tool.register(mcp_server)
             all_tools[tool.name] = tool
     
+    # Register consensus tool if enabled (enabled by default)
+    if is_tool_enabled("consensus", True):
+        tool = ConsensusTool()
+        if tool.llm_tool.available_providers:
+            tool.register(mcp_server)
+            all_tools[tool.name] = tool
+
     # Register legacy LLM tools if explicitly enabled (disabled by default)
     legacy_llm_enabled = {
         "llm_legacy": is_tool_enabled("llm_legacy", False),
@@ -339,3 +400,51 @@ def register_all_tools(
             if is_tool_enabled(tool.name, False):
                 tool.register(mcp_server)
                 all_tools[tool.name] = tool
+    
+    # Register memory tools if enabled
+    memory_enabled = {
+        "recall_memories": is_tool_enabled("recall_memories", True),
+        "create_memories": is_tool_enabled("create_memories", True),
+        "update_memories": is_tool_enabled("update_memories", True),
+        "delete_memories": is_tool_enabled("delete_memories", True),
+        "manage_memories": is_tool_enabled("manage_memories", True),
+        "recall_facts": is_tool_enabled("recall_facts", True),
+        "store_facts": is_tool_enabled("store_facts", True),
+        "summarize_to_memory": is_tool_enabled("summarize_to_memory", True),
+        "manage_knowledge_bases": is_tool_enabled("manage_knowledge_bases", True),
+    }
+    
+    if any(memory_enabled.values()) and MEMORY_TOOLS_AVAILABLE:
+        try:
+            memory_tools = register_memory_tools(
+                mcp_server,
+                permission_manager,
+                user_id="default",
+                project_id="default"
+            )
+            # Filter based on enabled state
+            for tool in memory_tools:
+                if memory_enabled.get(tool.name, True):
+                    all_tools[tool.name] = tool
+        except Exception as e:
+            logger.warning(f"Failed to register memory tools: {e}")
+    
+    # Register LSP tool if enabled
+    if is_tool_enabled("lsp", True) and LSP_TOOL_AVAILABLE:
+        try:
+            tool = create_lsp_tool()
+            tool.register(mcp_server)
+            all_tools[tool.name] = tool
+        except Exception as e:
+            logger.warning(f"Failed to register LSP tool: {e}")
+    
+    # Register user plugins last (so they can override built-in tools)
+    for plugin_name, plugin in plugins.items():
+        if is_tool_enabled(plugin_name, True):
+            try:
+                tool = plugin.tool_class()
+                tool.register(mcp_server)
+                all_tools[tool.name] = tool
+                logger.info(f"Registered plugin tool: {plugin_name}")
+            except Exception as e:
+                logger.error(f"Failed to register plugin tool {plugin_name}: {e}")