gfp-mcp 0.1.0__py3-none-any.whl → 0.2.4__py3-none-any.whl

mcp_standalone/server.py

@@ -13,11 +13,17 @@ from typing import Any
 
 from mcp.server import Server
 from mcp.server.stdio import stdio_server
-from mcp.types import TextContent, Tool
+from mcp.types import (
+    Resource,
+    TextContent,
+    Tool,
+)
 
 from .client import FastAPIClient
 from .config import MCPConfig
 from .mappings import get_mapping, transform_request, transform_response
+from .registry import get_registry_path
+from .resources import get_all_resources, get_resource_content
 from .tools import get_all_tools
 
 __all__ = ["create_server", "run_server", "main"]
@@ -34,10 +40,8 @@ def create_server(api_url: str | None = None) -> Server:
     Returns:
         Configured MCP Server instance
     """
-    # Create server instance
     server = Server("gdsfactoryplus")
 
-    # Create HTTP client for FastAPI backend
     client = FastAPIClient(api_url)
 
     @server.list_tools()
@@ -51,6 +55,40 @@ def create_server(api_url: str | None = None) -> Server:
         logger.info("Listing %d tools", len(tools))
         return tools
 
+    @server.list_resources()
+    async def list_resources() -> list[Resource]:
+        """List all available MCP resources.
+
+        Returns:
+            List of resource definitions
+        """
+        resources = get_all_resources()
+        logger.info("Listing %d resources", len(resources))
+        return resources
+
+    @server.read_resource()
+    async def read_resource(uri: str) -> str:
+        """Read a specific resource by URI.
+
+        Args:
+            uri: Resource URI
+
+        Returns:
+            Resource content as string
+
+        Raises:
+            ValueError: If resource URI is not found
+        """
+        logger.info("Resource requested: %s", uri)
+
+        content = get_resource_content(uri)
+        if content is None:
+            error_msg = f"Unknown resource URI: {uri}"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+        return content
+
     @server.call_tool()
     async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:  # noqa: PLR0911
         """Call an MCP tool.
@@ -65,7 +103,6 @@ def create_server(api_url: str | None = None) -> Server:
         logger.info("Tool called: %s", name)
         logger.debug("Arguments: %s", arguments)
 
-        # Handle special tools that don't require HTTP requests
         if name == "list_projects":
             try:
                 projects = client.list_projects()
@@ -97,7 +134,6 @@ def create_server(api_url: str | None = None) -> Server:
                 logger.exception(error_msg)
                 return [TextContent(type="text", text=json.dumps({"error": error_msg}))]
 
-        # Get the endpoint mapping
         mapping = get_mapping(name)
         if mapping is None:
             error_msg = f"Unknown tool: {name}"
@@ -105,21 +141,17 @@ def create_server(api_url: str | None = None) -> Server:
             return [TextContent(type="text", text=json.dumps({"error": error_msg}))]
 
         try:
-            # Extract project parameter (optional)
             project = arguments.get("project")
 
-            # Transform MCP arguments to HTTP request parameters
             transformed = transform_request(name, arguments)
             logger.debug("Transformed request: %s", transformed)
 
-            # Extract request parameters
             method = mapping.method
             path = transformed.get("path", mapping.path)
             params = transformed.get("params")
             json_data = transformed.get("json_data")
             data = transformed.get("data")
 
-            # Make HTTP request to FastAPI backend (with optional project routing)
             response = await client.request(
                 method=method,
                 path=path,
@@ -129,11 +161,9 @@ def create_server(api_url: str | None = None) -> Server:
                 project=project,
             )
 
-            # Transform response to MCP format
             result = transform_response(name, response)
             logger.debug("Tool result: %s", result)
 
-            # Return as text content
             return [
                 TextContent(
                     type="text",
@@ -151,19 +181,51 @@ def create_server(api_url: str | None = None) -> Server:
                 )
             ]
 
-    # Store client reference for cleanup
     server._http_client = client  # type: ignore[attr-defined]  # noqa: SLF001
 
     return server
 
 
+def _log_server_discovery(client: FastAPIClient) -> None:
+    """Log discovered GDSFactory+ servers at startup."""
+    try:
+        projects = client.list_projects()
+        if projects:
+            logger.info("Discovered %d GDSFactory+ server(s):", len(projects))
+            for project in projects[:3]:  # Show first 3
+                logger.info(
+                    "  - %s (port %d, PDK: %s)",
+                    project["project_name"],
+                    project["port"],
+                    project.get("pdk", "unknown"),
+                )
+            if len(projects) > 3:
+                logger.info("  ... and %d more", len(projects) - 3)
+        else:
+            logger.warning(
+                "No GDSFactory+ servers found. To start a server:\n"
+                "  1. Open VSCode with the GDSFactory+ extension installed\n"
+                "  2. Open a GDSFactory+ project folder\n"
+                "  3. The extension will automatically start and register the server"
+            )
+            logger.info("Registry location: %s", get_registry_path())
+            logger.info(
+                "Alternatively, set GFP_API_URL environment variable to connect to a specific server"
+            )
+    except Exception as e:
+        logger.warning("Could not read server registry: %s", e)
+        logger.info(
+            "If GDSFactory+ is running, ensure registry is accessible at: %s",
+            get_registry_path(),
+        )
+
+
 async def run_server(api_url: str | None = None) -> None:
     """Run the MCP server with STDIO transport.
 
     Args:
         api_url: Optional FastAPI base URL (default from config)
     """
-    # Configure logging
     log_level = logging.DEBUG if MCPConfig.DEBUG else logging.INFO
     logging.basicConfig(
         level=log_level,
@@ -171,25 +233,18 @@ async def run_server(api_url: str | None = None) -> None:
     )
 
     logger.info("Starting GDSFactory+ MCP server")
-    logger.info("FastAPI base URL: %s", MCPConfig.get_api_url(api_url))
+    base_url_info = MCPConfig.get_api_url(api_url) or "registry-based routing"
+    logger.info("Base URL: %s", base_url_info)
     logger.info("Timeout: %ds", MCPConfig.get_timeout())
 
-    # Create server
     server = create_server(api_url)
     client: FastAPIClient = server._http_client  # type: ignore[attr-defined]  # noqa: SLF001
 
     try:
-        # Start HTTP client
         await client.start()
 
-        # Health check
-        healthy = await client.health_check()
-        if not healthy:
-            logger.warning(
-                "FastAPI server health check failed. Server may not be running."
-            )
+        _log_server_discovery(client)
 
-        # Run server with STDIO transport
         async with stdio_server() as (read_stream, write_stream):
             logger.info("MCP server ready (STDIO transport)")
             await server.run(
@@ -204,7 +259,6 @@ async def run_server(api_url: str | None = None) -> None:
         logger.exception("MCP server error")
         raise
     finally:
-        # Cleanup
         await client.close()
         logger.info("MCP server stopped")
 

mcp_standalone/tools.py

@@ -15,7 +15,6 @@ __all__ = [
 ]
 
 
-# Project discovery tools (for multi-project support)
 PROJECT_TOOLS: list[Tool] = [
     Tool(
         name="list_projects",
@@ -52,14 +51,13 @@ PROJECT_TOOLS: list[Tool] = [
     ),
 ]
 
-# Standard optional project parameter for all tools
 PROJECT_PARAM_SCHEMA = {
     "project": {
         "type": "string",
         "description": (
             "Optional project name or path to route this request to a specific "
-            "server. If not provided, uses the default server (port 8787). "
-            "Use list_projects to see available projects."
+            "server. If not provided, uses the first available server from the registry "
+            "or GFP_API_URL if set. Use list_projects to see available projects."
         ),
     },
 }
@@ -80,48 +78,13 @@ def _add_project_param(schema: dict) -> dict:
     return schema
 
 
-# Phase 1: Core Building Tools (5 tools)
 CORE_TOOLS: list[Tool] = [
-    Tool(
-        name="build_cell",
-        description=(
-            "Build a single GDS cell by name. This creates the physical layout "
-            "file (.gds) for a photonic component. The build happens in the "
-            "background and the GDS file will be saved to the project build "
-            "directory."
-        ),
-        inputSchema=_add_project_param(
-            {
-                "type": "object",
-                "properties": {
-                    "name": {
-                        "type": "string",
-                        "description": "Name of the cell/component to build",
-                    },
-                    "with_metadata": {
-                        "type": "boolean",
-                        "description": (
-                            "Include metadata in the GDS file (default: true)"
-                        ),
-                        "default": True,
-                    },
-                    "register": {
-                        "type": "boolean",
-                        "description": (
-                            "Re-register the cell in the KLayout cache (default: true)"
-                        ),
-                        "default": True,
-                    },
-                },
-                "required": ["name"],
-            }
-        ),
-    ),
     Tool(
         name="build_cells",
         description=(
-            "Build multiple GDS cells by name in one operation. This is more "
-            "efficient than building cells one at a time. All cells are built "
+            "Build one or more GDS cells by name. This creates the physical layout "
+            "files (.gds) for photonic components. Pass a list of cell names to build. "
+            "For a single cell, pass a list with one element. All cells are built "
             "in the background and saved to the project build directory."
         ),
         inputSchema=_add_project_param(
@@ -131,7 +94,7 @@ CORE_TOOLS: list[Tool] = [
                     "names": {
                         "type": "array",
                         "items": {"type": "string"},
-                        "description": "List of cell/component names to build",
+                        "description": "List of cell/component names to build (can be a single-item list)",
                     },
                     "with_metadata": {
                         "type": "boolean",
@@ -186,32 +149,8 @@ CORE_TOOLS: list[Tool] = [
             }
         ),
     ),
-    Tool(
-        name="download_gds",
-        description=(
-            "Download a GDS file from the project build directory. Returns the "
-            "file path to the downloaded GDS file. The file must have been "
-            "previously built using build_cell or build_cells."
-        ),
-        inputSchema=_add_project_param(
-            {
-                "type": "object",
-                "properties": {
-                    "path": {
-                        "type": "string",
-                        "description": (
-                            "Relative path to the GDS file (without .gds extension). "
-                            "For example, 'mzi' or 'components/coupler'"
-                        ),
-                    },
-                },
-                "required": ["path"],
-            }
-        ),
-    ),
 ]
 
-# Phase 2: Verification Tools
 VERIFICATION_TOOLS: list[Tool] = [
     Tool(
         name="check_drc",
@@ -328,13 +267,172 @@ VERIFICATION_TOOLS: list[Tool] = [
     ),
 ]
 
-# Phase 3: SPICE Workflow Tools (to be implemented)
 SPICE_TOOLS: list[Tool] = []
 
-# Phase 4: Simulation & Advanced Tools (to be implemented)
-ADVANCED_TOOLS: list[Tool] = []
+ADVANCED_TOOLS: list[Tool] = [
+    Tool(
+        name="simulate_component",
+        description=(
+            "Run a SAX circuit simulation on a photonic component by name. "
+            "This simulates the optical behavior of the component using its "
+            "SAX model. Returns S-parameters showing how light propagates "
+            "through the component's ports. Use this to analyze component "
+            "performance before fabrication."
+        ),
+        inputSchema=_add_project_param(
+            {
+                "type": "object",
+                "properties": {
+                    "name": {
+                        "type": "string",
+                        "description": (
+                            "Name of the component/cell to simulate. The component "
+                            "must have a SAX model defined."
+                        ),
+                    },
+                },
+                "required": ["name"],
+            }
+        ),
+    ),
+    Tool(
+        name="get_port_center",
+        description=(
+            "Get the center coordinates (x, y) of a specific port in a component "
+            "instance. This is useful for positioning components, routing waveguides, "
+            "or analyzing layout geometry. Returns the physical coordinates in "
+            "microns."
+        ),
+        inputSchema=_add_project_param(
+            {
+                "type": "object",
+                "properties": {
+                    "netlist": {
+                        "type": "string",
+                        "description": (
+                            "Name of the component/netlist containing the instance"
+                        ),
+                    },
+                    "instance": {
+                        "type": "string",
+                        "description": "Name of the instance within the netlist",
+                    },
+                    "port": {
+                        "type": "string",
+                        "description": "Name of the port to get coordinates for",
+                    },
+                },
+                "required": ["netlist", "instance", "port"],
+            }
+        ),
+    ),
+    Tool(
+        name="generate_bbox",
+        description=(
+            "Generate a bounding box GDS file from an input GDS. This creates "
+            "a simplified version of the layout with only a bounding box on "
+            "specified layers. Useful for creating abstract views, floorplanning, "
+            "or hierarchical design. Can optionally preserve specific layers and "
+            "ports."
+        ),
+        inputSchema=_add_project_param(
+            {
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "type": "string",
+                        "description": (
+                            "Path to the input GDS file. Can be absolute or relative "
+                            "to the project directory."
+                        ),
+                    },
+                    "outpath": {
+                        "type": "string",
+                        "description": (
+                            "Output path for the bounding box GDS. If not specified, "
+                            "uses the input filename with '-bbox' suffix."
+                        ),
+                        "default": "",
+                    },
+                    "layers_to_keep": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": (
+                            "List of layer names to preserve in the output. "
+                            "Other layers will be replaced by the bounding box."
+                        ),
+                        "default": [],
+                    },
+                    "bbox_layer": {
+                        "type": "array",
+                        "items": {"type": "integer"},
+                        "description": (
+                            "Layer (as [layer, datatype]) to use for the bounding box. "
+                            "Default is [99, 0]."
+                        ),
+                        "default": [99, 0],
+                    },
+                    "ignore_ports": {
+                        "type": "boolean",
+                        "description": (
+                            "If true, do not include ports in the output. "
+                            "Default is false."
+                        ),
+                        "default": False,
+                    },
+                },
+                "required": ["path"],
+            }
+        ),
+    ),
+    Tool(
+        name="freeze_cell",
+        description=(
+            "Freeze a parametric Python cell as a static schematic netlist. "
+            "This converts a gdsfactory component with specific parameters into "
+            "a fixed netlist representation in YAML format. Useful for creating "
+            "versioned snapshots of parametric designs or preparing components "
+            "for simulation workflows."
+        ),
+        inputSchema=_add_project_param(
+            {
+                "type": "object",
+                "properties": {
+                    "cell_name": {
+                        "type": "string",
+                        "description": "Name of the cell/component to freeze",
+                    },
+                    "kwargs": {
+                        "type": "object",
+                        "description": (
+                            "Optional keyword arguments to pass to the component "
+                            "factory. Use this to specify parameter values when "
+                            "freezing the cell. Default is empty (use default params)."
+                        ),
+                        "default": {},
+                    },
+                },
+                "required": ["cell_name"],
+            }
+        ),
+    ),
+    Tool(
+        name="get_pdk_info",
+        description=(
+            "Get information about the current PDK (Process Design Kit) in use. "
+            "Returns metadata including PDK name, project name, project path, "
+            "server port, and version. Use this to verify which PDK is active "
+            "and get project configuration details."
+        ),
+        inputSchema=_add_project_param(
+            {
+                "type": "object",
+                "properties": {},
+            }
+        ),
+    ),
+]
 
-# All tools (Phase 1 + Project tools)
 TOOLS: list[Tool] = [
     *PROJECT_TOOLS,  # Project discovery tools (always available)
     *CORE_TOOLS,