chore: depend on jupyter-mcp-tools 0.1.2

Author: echarles

jupyter_mcp_server/jupyter_extension/handlers.py

@@ -34,6 +34,9 @@ class MCPSSEHandler(RequestHandler):
     The MCP protocol uses SSE for streaming responses from the server to the client.
     """
 
+    # Cache of jupyter_mcp_tools tool names for routing decisions
+    _jupyter_tool_names = set()
+    
     def check_xsrf_cookie(self):
         """Disable XSRF checking for MCP protocol requests."""
         pass
@@ -111,76 +114,103 @@ async def post(self):
                 logger.info("Listing tools from FastMCP and jupyter_mcp_tools...")
 
                 try:
-                    # Get FastMCP tools
+                    # Get FastMCP tools first
                     tools_list = await mcp.list_tools()
                     logger.info(f"Got {len(tools_list)} tools from FastMCP")
 
-                    # Convert FastMCP tools to MCP protocol format
-                    tools = []
-                    for tool in tools_list:
-                        tools.append({
-                            "name": tool.name,
-                            "description": tool.description,
-                            "inputSchema": tool.inputSchema
-                        })
+                    # Map FastMCP tool names to their jupyter-mcp-tools equivalents
+                    fastmcp_to_jupyter_mapping = {
+                        "insert_execute_code_cell": "notebook_append-execute",
+                        # Add more mappings as needed
+                    }
 
-                    # Get tools from jupyter_mcp_tools extension
+                    # Track jupyter_mcp_tools tool names to check for duplicates
+                    jupyter_tool_names = set()
+                    
+                    # Get tools from jupyter_mcp_tools extension first to identify duplicates
+                    jupyter_tools_data = []
                     try:
                         from jupyter_mcp_tools import get_tools
 
-                        # Get the server's base URL dynamically
-                        # The server is running on the port configured in settings
-                        port = self.settings.get('port', 4040)  # Default to 4040 if not set
-                        base_url = f"http://localhost:{port}"
-                        
-                        # Get token from settings if available
-                        token = self.settings.get('token', None)
+                        # Get the server's base URL dynamically from ServerApp
+                        context = get_server_context()
+                        if context.serverapp is not None:
+                            base_url = context.serverapp.connection_url
+                            token = context.serverapp.token
+                            logger.info(f"Using Jupyter ServerApp connection URL: {base_url}")
+                        else:
+                            # Fallback to hardcoded localhost (should not happen in JUPYTER_SERVER mode)
+                            port = self.settings.get('port', 8888)
+                            base_url = f"http://localhost:{port}"
+                            token = self.settings.get('token', None)
+                            logger.warning(f"ServerApp not available, using fallback: {base_url}")
 
                         logger.info(f"Querying jupyter_mcp_tools at {base_url}")
 
+                        # Get ALL tools from jupyter_mcp_tools (no query filter)
                         jupyter_tools_data = await get_tools(
                             base_url=base_url,
                             token=token,
-                            query="console_create",
+                            query=None,  # Get all tools
                             enabled_only=True,
                             wait_timeout=5  # Short timeout
                         )
 
                         logger.info(f"Got {len(jupyter_tools_data)} tools from jupyter_mcp_tools extension")
 
-                        # Validate that exactly one tool was returned
-                        if len(jupyter_tools_data) != 1:
-                            logger.warning(
-                                f"Expected exactly 1 tool matching 'console_create', "
-                                f"but got {len(jupyter_tools_data)} tools"
-                            )
-                        else:
-                            # Convert jupyter_mcp_tools format to MCP format and add to tools list
-                            for tool_data in jupyter_tools_data:
-                                tool_dict = {
-                                    "name": tool_data.get('id', ''),
-                                    "description": tool_data.get('caption', tool_data.get('label', '')),
-                                }
-                                
-                                # Convert parameters to inputSchema
-                                params = tool_data.get('parameters', {})
-                                if params and isinstance(params, dict):
-                                    tool_dict["inputSchema"] = params
-                                else:
-                                    tool_dict["inputSchema"] = {
-                                        "type": "object",
-                                        "properties": {},
-                                        "description": tool_data.get('usage', '')
-                                    }
-                                
-                                tools.append(tool_dict)
-                            
-                            logger.info(f"Added {len(jupyter_tools_data)} tool(s) from jupyter_mcp_tools")
+                        # Build set of jupyter tool names and cache it for routing decisions
+                        jupyter_tool_names = {tool_data.get('id', '') for tool_data in jupyter_tools_data}
+                        MCPSSEHandler._jupyter_tool_names = jupyter_tool_names
+                        logger.info(f"Cached {len(jupyter_tool_names)} jupyter_mcp_tools names for routing: {jupyter_tool_names}")
 
                     except Exception as jupyter_error:
                         # Log but don't fail - just return FastMCP tools
                         logger.warning(f"Could not fetch tools from jupyter_mcp_tools: {jupyter_error}")
 
+                    # Convert FastMCP tools to MCP protocol format, excluding duplicates
+                    tools = []
+                    for tool in tools_list:
+                        # Check if this FastMCP tool has a jupyter-mcp-tools equivalent
+                        jupyter_equivalent = fastmcp_to_jupyter_mapping.get(tool.name)
+                        
+                        if jupyter_equivalent and jupyter_equivalent in jupyter_tool_names:
+                            logger.info(f"Skipping FastMCP tool '{tool.name}' - equivalent '{jupyter_equivalent}' available from jupyter-mcp-tools")
+                            continue
+                        
+                        tools.append({
+                            "name": tool.name,
+                            "description": tool.description,
+                            "inputSchema": tool.inputSchema
+                        })
+                    
+                    # Now add jupyter_mcp_tools
+                    for tool_data in jupyter_tools_data:
+                        # Only include MCP protocol fields (exclude internal fields like commandId)
+                        tool_dict = {
+                            "name": tool_data.get('id', ''),
+                            "description": tool_data.get('caption', tool_data.get('label', '')),
+                        }
+                        
+                        # Convert parameters to inputSchema
+                        # The parameters field contains the JSON Schema for the tool's arguments
+                        params = tool_data.get('parameters', {})
+                        if params and isinstance(params, dict) and params.get('properties'):
+                            # Tool has parameters - use them as inputSchema
+                            tool_dict["inputSchema"] = params
+                            logger.debug(f"Tool {tool_dict['name']} has parameters: {list(params.get('properties', {}).keys())}")
+                        else:
+                            # Tool has no parameters - use empty schema
+                            tool_dict["inputSchema"] = {
+                                "type": "object",
+                                "properties": {},
+                                "description": tool_data.get('usage', '')
+                            }
+                        
+                        tools.append(tool_dict)
+                    
+                    logger.info(f"Added {len(jupyter_tools_data)} tool(s) from jupyter_mcp_tools")
+
+                    
                     logger.info(f"Returning total of {len(tools)} tools")
 
                     response = {
@@ -210,15 +240,24 @@ async def post(self):
                 logger.info(f"Calling tool: {tool_name}")
 
                 try:
-                    # Check if this is a jupyter_mcp_tools tool (e.g., console_create)
-                    if tool_name == "console_create":
+                    # Check if this is a jupyter_mcp_tools tool
+                    # Use the cached set of jupyter tool names from tools/list
+                    if tool_name in MCPSSEHandler._jupyter_tool_names:
                         # Route to jupyter_mcp_tools extension via HTTP execute endpoint
-                        logger.info(f"Routing {tool_name} to jupyter_mcp_tools extension")
+                        logger.info(f"Routing {tool_name} to jupyter_mcp_tools extension (recognized from cache)")
 
-                        # Get server configuration
-                        port = self.settings.get('port', 4040)
-                        base_url = f"http://localhost:{port}"
-                        token = self.settings.get('token', None)
+                        # Get server configuration from ServerApp
+                        context = get_server_context()
+                        if context.serverapp is not None:
+                            base_url = context.serverapp.connection_url
+                            token = context.serverapp.token
+                            logger.info(f"Using Jupyter ServerApp connection URL: {base_url}")
+                        else:
+                            # Fallback to hardcoded localhost (should not happen in JUPYTER_SERVER mode)
+                            port = self.settings.get('port', 8888)
+                            base_url = f"http://localhost:{port}"
+                            token = self.settings.get('token', None)
+                            logger.warning(f"ServerApp not available, using fallback: {base_url}")
 
                         # Use the MCPToolsClient to execute the tool
                         from jupyter_mcp_tools.client import MCPToolsClient
@@ -259,6 +298,7 @@ async def post(self):
                             }
                     else:
                         # Use FastMCP's call_tool method for regular tools
+                        logger.info(f"Routing {tool_name} to FastMCP (not in jupyter_mcp_tools cache)")
                         result = await mcp.call_tool(tool_name, tool_arguments)
 
                         # Handle tuple results from FastMCP

jupyter_mcp_server/server.py

@@ -869,64 +869,122 @@ async def get_registered_tools():
     context = ServerContext.get_instance()
     mode = context._mode
 
-    # For JUPYTER_SERVER mode, query jupyter-mcp-tools extension
+    # For JUPYTER_SERVER mode, expose BOTH FastMCP tools AND jupyter-mcp-tools
     if mode == ServerMode.JUPYTER_SERVER:
+        all_tools = []
+        jupyter_tool_names = set()
+        
+        # First, get tools from jupyter-mcp-tools extension
         try:
             from jupyter_mcp_tools import get_tools
 
-            # Query for a specific tool as the first implementation
-            # Get the base_url and token from context
-            # For now, use localhost with assumption the extension is running
-            base_url = "http://localhost:8888"  # TODO: Get from context
-            token = None  # TODO: Get from context if available
+            # Get the base_url and token from server context
+            # In JUPYTER_SERVER mode, we should use the actual serverapp URL, not hardcoded localhost
+            if server_context.serverapp is not None:
+                # Use the actual Jupyter server connection URL
+                base_url = server_context.serverapp.connection_url
+                token = server_context.serverapp.token
+                logger.info(f"Using Jupyter ServerApp connection URL: {base_url}")
+            else:
+                # Fallback to configuration (for remote scenarios)
+                config = get_config()
+                base_url = config.runtime_url if config.runtime_url else "http://localhost:8888"
+                token = config.runtime_token
+                logger.info(f"Using config runtime URL: {base_url}")
+            
+            logger.info(f"Querying jupyter-mcp-tools at {base_url}")
 
             tools_data = await get_tools(
                 base_url=base_url,
                 token=token,
-                query="console_create",  # Start with just one tool
+                query=None,  # Get all tools
                 enabled_only=True
             )
 
-            # Validate that exactly one tool was returned
-            if len(tools_data) != 1:
-                raise ValueError(
-                    f"Expected exactly 1 tool matching 'console_create', "
-                    f"but got {len(tools_data)} tools"
-                )
+            logger.info(f"Retrieved {len(tools_data)} tools from jupyter-mcp-tools extension")
 
             # Convert jupyter-mcp-tools format to MCP format
-            tools = []
             for tool_data in tools_data:
+                tool_name = tool_data.get('id', '')
+                jupyter_tool_names.add(tool_name)
+                
+                # Only include MCP protocol fields (exclude internal fields like commandId)
                 tool_dict = {
-                    "name": tool_data.get('id', ''),  # Use command ID as name
+                    "name": tool_name,
                     "description": tool_data.get('caption', tool_data.get('label', '')),
                 }
 
                 # Convert parameters to inputSchema
+                # The parameters field contains the JSON Schema for the tool's arguments
                 params = tool_data.get('parameters', {})
-                if params and isinstance(params, dict):
+                if params and isinstance(params, dict) and params.get('properties'):
+                    # Tool has parameters - use them as inputSchema
                     tool_dict["inputSchema"] = params
-                    if 'properties' in params:
-                        tool_dict["parameters"] = list(params['properties'].keys())
-                    else:
-                        tool_dict["parameters"] = []
+                    tool_dict["parameters"] = list(params['properties'].keys())
+                    logger.debug(f"Tool {tool_dict['name']} has parameters: {tool_dict['parameters']}")
                 else:
+                    # Tool has no parameters - use empty schema
                     tool_dict["parameters"] = []
                     tool_dict["inputSchema"] = {
                         "type": "object",
                         "properties": {},
                         "description": tool_data.get('usage', '')
                     }
 
-                tools.append(tool_dict)
+                all_tools.append(tool_dict)
 
-            logger.info(f"Retrieved {len(tools)} tool(s) from jupyter-mcp-tools extension")
-            return tools
+            logger.info(f"Converted {len(all_tools)} tool(s) from jupyter-mcp-tools with parameter schemas")
 
         except Exception as e:
             logger.error(f"Error querying jupyter-mcp-tools extension: {e}", exc_info=True)
-            # Re-raise the exception since we require exactly 1 tool
-            raise
+            # Continue to add FastMCP tools even if jupyter-mcp-tools fails
+        
+        # Second, add FastMCP tools (excluding duplicates)
+        # Map FastMCP tool names to their jupyter-mcp-tools equivalents
+        fastmcp_to_jupyter_mapping = {
+            "insert_execute_code_cell": "notebook_append-execute",
+            # Add more mappings as needed
+        }
+        
+        try:
+            tools_list = await mcp.list_tools()
+            logger.info(f"Retrieved {len(tools_list)} tools from FastMCP registry")
+            
+            for tool in tools_list:
+                # Check if this FastMCP tool has a jupyter-mcp-tools equivalent
+                jupyter_equivalent = fastmcp_to_jupyter_mapping.get(tool.name)
+                
+                if jupyter_equivalent and jupyter_equivalent in jupyter_tool_names:
+                    logger.info(f"Skipping FastMCP tool '{tool.name}' - equivalent '{jupyter_equivalent}' available from jupyter-mcp-tools")
+                    continue
+                
+                # Add FastMCP tool
+                tool_dict = {
+                    "name": tool.name,
+                    "description": tool.description,
+                }
+                
+                # Extract parameter names from inputSchema
+                if hasattr(tool, 'inputSchema') and tool.inputSchema:
+                    input_schema = tool.inputSchema
+                    if 'properties' in input_schema:
+                        tool_dict["parameters"] = list(input_schema['properties'].keys())
+                    else:
+                        tool_dict["parameters"] = []
+                    
+                    # Include full inputSchema for MCP protocol compatibility
+                    tool_dict["inputSchema"] = input_schema
+                else:
+                    tool_dict["parameters"] = []
+                
+                all_tools.append(tool_dict)
+            
+            logger.info(f"Added {len(all_tools) - len(jupyter_tool_names)} FastMCP tool(s), total: {len(all_tools)}")
+            
+        except Exception as e:
+            logger.error(f"Error retrieving FastMCP tools: {e}", exc_info=True)
+        
+        return all_tools
 
     # For MCP_SERVER mode, use local FastMCP registry
     # Use FastMCP's list_tools method which returns Tool objects

pyproject.toml

@@ -22,7 +22,7 @@ classifiers = [
 ]
 dependencies = [
     "jupyter-kernel-client>=0.7.3",
-    "jupyter-mcp-tools>=0.1.1",
+    "jupyter-mcp-tools>=0.1.2",
     "jupyter-nbmodel-client>=0.14.2",
     "jupyter-server-nbmodel",
     "jupyter-server-api",