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

gfp_mcp-0.2.1.dist-info/METADATA

@@ -0,0 +1,210 @@
+Metadata-Version: 2.4
+Name: gfp-mcp
+Version: 0.2.1
+Summary: Model Context Protocol (MCP) server for GDSFactory+ photonic IC design
+Author: GDSFactory+ Team
+License: MIT
+Project-URL: Homepage, https://github.com/doplaydo/gfp-mcp
+Project-URL: Repository, https://github.com/doplaydo/gfp-mcp
+Project-URL: Documentation, https://github.com/doplaydo/gfp-mcp#readme
+Project-URL: Changelog, https://github.com/doplaydo/gfp-mcp/blob/main/CHANGELOG.md
+Project-URL: Issue Tracker, https://github.com/doplaydo/gfp-mcp/issues
+Keywords: mcp,gdsfactory,photonics,ic-design,eda,model-context-protocol,photonic-ic,gds
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=1.7.1
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: typing-extensions>=4.0.0; python_version < "3.11"
+Requires-Dist: psutil>=5.9.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Dynamic: license-file
+
+# GDSFactory+ MCP Server
+
+[![PyPI version](https://img.shields.io/pypi/v/gfp-mcp.svg)](https://pypi.org/project/gfp-mcp/)
+[![Python versions](https://img.shields.io/pypi/pyversions/gfp-mcp.svg)](https://pypi.org/project/gfp-mcp/)
+[![Tests](https://github.com/doplaydo/gfp-mcp/workflows/Tests/badge.svg)](https://github.com/doplaydo/gfp-mcp/actions)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Model Context Protocol (MCP) server for GDSFactory+ that enables AI assistants like Claude to design and build photonic integrated circuits.
+
+## What is this?
+
+This MCP server connects AI assistants to [GDSFactory+](https://gdsfactory.com), allowing you to design photonic ICs through natural language. Build components, run verification checks, and manage multiple projects directly from Claude Code or Claude Desktop.
+
+## Quick Start
+
+### 1. Install Prerequisites
+
+- Python 3.10 or higher
+- VSCode with the [GDSFactory+ extension](https://marketplace.visualstudio.com/items?itemName=gdsfactory.gdsfactoryplus) installed
+
+### 2. Install the MCP Server
+
+```bash
+pip install gfp-mcp
+```
+
+Or with uv:
+
+```bash
+uvx --from gfp-mcp gfp-mcp-serve
+```
+
+### 3. Connect to Your AI Assistant
+
+<details>
+<summary><strong>Claude Code</strong></summary>
+
+Add to `.claude/settings.json`:
+
+```json
+{
+    "mcpServers": {
+        "gdsfactoryplus": {
+            "command": "gfp-mcp-serve",
+            "args": [],
+            "env": {
+                "GFP_API_URL": "http://localhost:8787"
+            }
+        }
+    }
+}
+```
+
+Or use the CLI:
+
+```bash
+claude mcp add gdsfactoryplus -- gfp-mcp-serve
+```
+
+</details>
+
+<details>
+<summary><strong>Claude Desktop</strong></summary>
+
+Add to your config file:
+
+**macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+
+**Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+
+**Linux**: `~/.config/Claude/claude_desktop_config.json`
+
+```json
+{
+    "mcpServers": {
+        "gdsfactoryplus": {
+            "command": "gfp-mcp-serve",
+            "args": []
+        }
+    }
+}
+```
+
+Restart Claude Desktop after adding the configuration.
+
+</details>
+
+<details>
+<summary><strong>Cursor</strong></summary>
+
+Coming soon. Follow the MCP integration instructions for Cursor when available.
+
+</details>
+
+### 4. Start Designing
+
+The MCP server automatically discovers running GDSFactory+ servers via the registry (`~/.gdsfactory/server-registry.json`). On startup, it will log all discovered projects.
+
+Try these commands with your AI assistant:
+
+- "List all available photonic components"
+- "Build an MZI interferometer"
+- "Show me details about the directional coupler"
+- "Build multiple components: mzi, coupler, and bend_euler"
+- "List all my GDSFactory+ projects"
+
+## Available Tools
+
+- **build_cell** - Build a single GDS cell by name
+- **build_cells** - Build multiple GDS cells in batch
+- **list_cells** - List all available photonic components
+- **get_cell_info** - Get detailed component metadata
+- **download_gds** - Download built GDS files
+- **list_projects** - List all running GDSFactory+ server instances
+- **get_project_info** - Get detailed information about a specific project
+- **check_drc** - Run Design Rule Check verification
+- **check_connectivity** - Run connectivity verification
+- **check_lvs** - Run Layout vs. Schematic verification
+
+## Multi-Project Support
+
+The MCP server automatically discovers all running GDSFactory+ projects via the server registry (`~/.gdsfactory/server-registry.json`). The registry is the source of truth for available servers. Use the `list_projects` tool to see all running projects, then specify the project name when building components:
+
+```
+User: "List all my GDSFactory+ projects"
+Claude: [Uses list_projects tool to show all running servers]
+
+User: "Build the mzi component in my_photonics_project"
+Claude: [Routes request to the correct project]
+```
+
+## Troubleshooting
+
+<details>
+<summary><strong>Server not appearing in Claude</strong></summary>
+
+1. Verify installation: `gfp-mcp-serve --help`
+2. Check Claude Code logs: `claude --debug`
+3. Restart Claude Desktop/Code
+4. Ensure the GDSFactory+ VSCode extension is active and a project is open
+
+</details>
+
+<details>
+<summary><strong>Connection refused errors</strong></summary>
+
+The MCP server uses the registry (`~/.gdsfactory/server-registry.json`) to discover running servers.
+
+1. Use the `list_projects` tool in Claude to check available servers
+2. If no servers are found, ensure the GDSFactory+ VSCode extension is running with an active project:
+   - Open VSCode with the GDSFactory+ extension installed
+   - Open a GDSFactory+ project folder
+   - The extension automatically starts the server and registers it
+3. Check the MCP startup logs for discovered servers
+4. Verify the registry is accessible at `~/.gdsfactory/server-registry.json`
+5. For backward compatibility, you can set a specific server URL:
+
+```bash
+export GFP_API_URL="http://localhost:YOUR_PORT"
+```
+
+</details>
+
+<details>
+<summary><strong>Tool execution timeout</strong></summary>
+
+Increase the timeout for long-running operations:
+
+```bash
+export GFP_MCP_TIMEOUT=600  # 10 minutes
+```
+
+</details>

gfp_mcp-0.2.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+gfp_mcp-0.2.1.dist-info/licenses/LICENSE,sha256=ixSuHdKKXzNJw_eTgAxHzaCNIds8k48hytA_eJgA8gQ,225
+mcp_standalone/__init__.py,sha256=B6JB7U_vEMARO87RzNDesfSZdGgD1U-RC2GkL2ijOCA,1069
+mcp_standalone/client.py,sha256=vS_mw3frp5dQr2s_uFbPH-cF4k98rOJFGZLIz1FOU7A,8371
+mcp_standalone/config.py,sha256=1B00PLrKOz96c62lkhIgrraF-HWZ015uoPZ7okCcuKk,1525
+mcp_standalone/mappings.py,sha256=2J2DEZzXTdmi6VmrtCeI1cg-2T7tYHkytRGrZJ62zog,10583
+mcp_standalone/registry.py,sha256=1E61UalVot8HUS3cALjM7ejYB0qR6tI5QbQSZZeQe7Y,6401
+mcp_standalone/resources.py,sha256=iMkYIyTxLWwWE0NLxprLabGFYbPnUaIbgwwtbvZ2av0,3606
+mcp_standalone/server.py,sha256=jDCns5Cgb5JZahbx8pjCCDqryT-RiLCOFD5FIpgr3OA,9149
+mcp_standalone/tools.py,sha256=totbebwVzqOej1TjmY6lOZ7raSPFIwGWmWfOFVN3IyE,18734
+gfp_mcp-0.2.1.dist-info/METADATA,sha256=16kFH1_7TvI11tZnuXXrdTyQ6os5s7I5E7mTvSdRfVA,6858
+gfp_mcp-0.2.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+gfp_mcp-0.2.1.dist-info/entry_points.txt,sha256=mgyus9dsB_8mjgnztuHNPqzPi-7HcPg1iYzfM5NMIjk,61
+gfp_mcp-0.2.1.dist-info/top_level.txt,sha256=g2hRJHoDDPNtrNdXR70T7FR9Ev6DTRJiGW7ZvlvnXMc,15
+gfp_mcp-0.2.1.dist-info/RECORD,,

{gfp_mcp-0.1.0.dist-info → gfp_mcp-0.2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

gfp_mcp-0.2.1.dist-info/licenses/LICENSE

@@ -0,0 +1,4 @@
+PROPRIETARY AND CONFIDENTIAL
+THIS SOFTWARE IS THE SOLE PROPERTY AND COPYRIGHT (c) 2025 OF DOPLAYDO INC.
+USE OR REPRODUCTION IN PART OR AS A WHOLE WITHOUT THE WRITTEN AGREEMENT OF DOPLAYDO IS PROHIBITED.
+NOTICE VERSION: 0.0.2

mcp_standalone/__init__.py

@@ -23,6 +23,7 @@ from __future__ import annotations
 
 from .client import FastAPIClient
 from .config import MCPConfig
+from .resources import get_all_resources, get_resource_content
 from .server import create_server, main, run_server
 from .tools import get_all_tools, get_tool_by_name
 
@@ -34,6 +35,8 @@ __all__ = [
     "run_server",
     "get_all_tools",
     "get_tool_by_name",
+    "get_all_resources",
+    "get_resource_content",
 ]
 
-__version__ = "0.1.0"
+__version__ = "0.2.1"

mcp_standalone/client.py

@@ -218,6 +218,10 @@ class FastAPIClient:
     async def health_check(self, project: str | None = None) -> bool:
         """Check if the FastAPI server is reachable.
 
+        .. deprecated::
+            This method is deprecated and no longer called during MCP startup.
+            Use list_projects() for server discovery instead.
+
         Args:
             project: Optional project name to check specific server
 

mcp_standalone/config.py

@@ -16,6 +16,8 @@ class MCPConfig:
     """
 
     # FastAPI base URL (default: http://localhost:8787)
+    # This default is primarily for backward compatibility.
+    # The MCP server automatically discovers running servers via the registry.
     API_URL: Final[str] = os.getenv("GFP_API_URL", "http://localhost:8787")
 
     # Timeout for tool calls in seconds (default: 300 = 5 minutes)

mcp_standalone/mappings.py

@@ -189,6 +189,81 @@ def _check_lvs_request(args: dict[str, Any]) -> dict[str, Any]:
     }
 
 
+def _simulate_component_request(args: dict[str, Any]) -> dict[str, Any]:
+    """Transform simulate_component MCP args to FastAPI params.
+
+    Args:
+        args: MCP tool arguments
+
+    Returns:
+        Dict with 'params' key for query parameters
+    """
+    return {"params": {"name": args["name"]}}
+
+
+def _get_port_center_request(args: dict[str, Any]) -> dict[str, Any]:
+    """Transform get_port_center MCP args to FastAPI params.
+
+    Args:
+        args: MCP tool arguments
+
+    Returns:
+        Dict with 'params' key for query parameters
+    """
+    return {
+        "params": {
+            "netlist": args["netlist"],
+            "instance": args["instance"],
+            "port": args["port"],
+        }
+    }
+
+
+def _generate_bbox_request(args: dict[str, Any]) -> dict[str, Any]:
+    """Transform generate_bbox MCP args to FastAPI params.
+
+    Args:
+        args: MCP tool arguments
+
+    Returns:
+        Dict with 'json_data' key for request body
+    """
+    json_data: dict[str, Any] = {"path": args["path"]}
+
+    # Add optional parameters if provided
+    if "outpath" in args and args["outpath"]:
+        json_data["outpath"] = args["outpath"]
+    if "layers_to_keep" in args and args["layers_to_keep"]:
+        json_data["layers_to_keep"] = args["layers_to_keep"]
+    if "bbox_layer" in args and args["bbox_layer"]:
+        json_data["bbox_layer"] = args["bbox_layer"]
+    if "ignore_ports" in args:
+        json_data["ignore_ports"] = args["ignore_ports"]
+
+    return {"json_data": json_data}
+
+
+def _freeze_cell_request(args: dict[str, Any]) -> dict[str, Any]:
+    """Transform freeze_cell MCP args to FastAPI params.
+
+    Args:
+        args: MCP tool arguments
+
+    Returns:
+        Dict with 'path' and 'json_data' for the request
+    """
+    cell_name = args["cell_name"]
+    kwargs = args.get("kwargs", {})
+
+    # The freeze endpoint expects a JSON string in the body.
+    # httpx with json= will JSON-encode the dict and send it as the body,
+    # which FastAPI's Body() will read as a string.
+    return {
+        "path": f"/freeze/{cell_name}",
+        "json_data": kwargs,  # httpx will JSON-encode this to a string
+    }
+
+
 # Tool name -> Endpoint mapping
 TOOL_MAPPINGS: dict[str, EndpointMapping] = {
     # Phase 1: Core Building Tools
@@ -234,6 +309,31 @@ TOOL_MAPPINGS: dict[str, EndpointMapping] = {
         path="/api/check-lvs",
         request_transformer=_check_lvs_request,
     ),
+    # Phase 4: Simulation & Advanced Tools
+    "simulate_component": EndpointMapping(
+        method="GET",
+        path="/api/simulate",
+        request_transformer=_simulate_component_request,
+    ),
+    "get_port_center": EndpointMapping(
+        method="GET",
+        path="/api/port-center",
+        request_transformer=_get_port_center_request,
+    ),
+    "generate_bbox": EndpointMapping(
+        method="POST",
+        path="/api/bbox",
+        request_transformer=_generate_bbox_request,
+    ),
+    "freeze_cell": EndpointMapping(
+        method="POST",
+        path="/freeze/{cell_name}",
+        request_transformer=_freeze_cell_request,
+    ),
+    "get_pdk_info": EndpointMapping(
+        method="GET",
+        path="/info",
+    ),
 }
 
 

mcp_standalone/resources.py

@@ -0,0 +1,141 @@
+"""MCP resource definitions for GDSFactory+.
+
+This module defines the MCP resources that are exposed to AI assistants.
+Resources provide read-only access to documentation and instruction content.
+"""
+
+from __future__ import annotations
+
+from mcp.types import Resource
+
+__all__ = [
+    "RESOURCES",
+    "get_all_resources",
+    "get_resource_content",
+]
+
+
+# Define available resources
+RESOURCES: list[Resource] = [
+    Resource(
+        uri="instructions://build_custom_cell",
+        name="Build Custom Cell Instructions",
+        description=(
+            "Comprehensive instructions for building custom photonic cells "
+            "in GDSFactory+. Covers component creation, file organization, "
+            "PDK integration, and best practices."
+        ),
+        mimeType="text/markdown",
+    ),
+]
+
+
+# Resource content
+RESOURCE_CONTENT = {
+    "instructions://build_custom_cell": """---
+Workflow: Creating Custom Components in GDSFactory+ Projects
+
+Overview
+
+When users request custom photonic components, keep user-defined components separate from PDK-defined
+objects to maintain clean project organization.
+
+Step-by-Step Process
+
+1. File Organization
+
+- DO NOT add custom components to cells.py - this file is reserved for PDK-defined objects
+- CREATE or use custom_components.py in the package directory (e.g., myph18da/custom_components.py)
+- This keeps custom user components separate from the PDK
+
+2. Component Creation
+
+\"\"\"Custom user-defined components.\"\"\"
+
+import gdsfactory as gf
+from ph18da.cells import <relevant_pdk_functions>  # Use PDK functions when available
+
+__all__ = ["custom_component_name"]
+
+@gf.cell
+def custom_component_name(
+    param1: float = default_value,
+    param2: float = default_value,
+) -> gf.Component:
+    \"\"\"Component description.
+
+    Args:
+        param1: Description
+        param2: Description
+
+    Returns:
+        Component description
+    \"\"\"
+    # Implementation using PDK functions
+    c = pdk_function(parameters...)
+    return c
+
+3. Key Implementation Guidelines
+
+- Use @gf.cell decorator for all components
+- Prefer using existing PDK functions (e.g., mzi_swg) over internal functions (e.g., _mzi)
+- Import from ph18da.cells for PDK-specific components
+- Use standard PDK component names (e.g., "c_mmi_2x2_swg", "wg_straight_swg", "wg_arc_swg")
+- Keep component parameters clear and well-documented
+
+4. Register the Component
+
+Update the package __init__.py to import and expose the custom component:
+from myph18da.custom_components import custom_component_name
+
+5. Build the Component
+
+Use the MCP build tool:
+mcp__gdsfactoryplus__build_cell(
+    name="custom_component_name",
+    project="project-name"
+)
+
+6. Verification
+
+- Check build status with get_cell_info
+- Verify GDS file exists in build/gds/ directory
+- Ensure status is "SUCCESS"
+
+Troubleshooting
+
+If build fails with import errors:
+- Use PDK public functions instead of internal _functions
+- Check that imports are from the correct PDK modules
+
+If component not found:
+- Ensure it's imported in __init__.py
+- Rebuild the component after changes
+
+If parameter errors occur:
+- Check PDK component compatibility
+- Verify parameter names match PDK expectations
+---
+""",
+}
+
+
+def get_all_resources() -> list[Resource]:
+    """Get all available MCP resources.
+
+    Returns:
+        List of all resource definitions
+    """
+    return RESOURCES
+
+
+def get_resource_content(uri: str) -> str | None:
+    """Get resource content by URI.
+
+    Args:
+        uri: Resource URI
+
+    Returns:
+        Resource content string or None if not found
+    """
+    return RESOURCE_CONTENT.get(uri)

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"]
@@ -51,6 +57,41 @@ 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)
+
+        # Get resource content
+        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.
@@ -157,6 +198,35 @@ def create_server(api_url: str | None = None) -> Server:
     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. Start a server with: "
+                "gfp serve --port 8787"
+            )
+            logger.info("Registry location: %s", get_registry_path())
+    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.
 
@@ -182,12 +252,8 @@ async def run_server(api_url: str | None = None) -> None:
         # 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."
-            )
+        # Discover available servers
+        _log_server_discovery(client)
 
         # Run server with STDIO transport
         async with stdio_server() as (read_stream, write_stream):

mcp_standalone/tools.py

@@ -58,7 +58,7 @@ PROJECT_PARAM_SCHEMA = {
         "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). "
+            "server. If not provided, routes to the default server. "
             "Use list_projects to see available projects."
         ),
     },
@@ -331,8 +331,170 @@ 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] = []
+# Phase 4: Simulation & Advanced Tools
+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] = [

gfp_mcp-0.1.0.dist-info/METADATA

@@ -1,360 +0,0 @@
-Metadata-Version: 2.4
-Name: gfp-mcp
-Version: 0.1.0
-Summary: Model Context Protocol (MCP) server for GDSFactory+ photonic IC design
-Author: GDSFactory+ Team
-License: MIT
-Project-URL: Homepage, https://github.com/doplaydo/gfp-mcp
-Project-URL: Repository, https://github.com/doplaydo/gfp-mcp
-Project-URL: Documentation, https://github.com/doplaydo/gfp-mcp#readme
-Project-URL: Changelog, https://github.com/doplaydo/gfp-mcp/blob/main/CHANGELOG.md
-Project-URL: Issue Tracker, https://github.com/doplaydo/gfp-mcp/issues
-Keywords: mcp,gdsfactory,photonics,ic-design,eda,model-context-protocol,photonic-ic,gds
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Science/Research
-Classifier: Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: mcp>=1.7.1
-Requires-Dist: httpx>=0.25.0
-Requires-Dist: typing-extensions>=4.0.0; python_version < "3.11"
-Requires-Dist: psutil>=5.9.0
-Provides-Extra: dev
-Requires-Dist: pytest>=7.0.0; extra == "dev"
-Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
-Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
-Requires-Dist: ruff>=0.1.0; extra == "dev"
-
-# GDSFactory+ MCP Server
-
-[![PyPI version](https://img.shields.io/pypi/v/gfp-mcp.svg)](https://pypi.org/project/gfp-mcp/)
-[![Python versions](https://img.shields.io/pypi/pyversions/gfp-mcp.svg)](https://pypi.org/project/gfp-mcp/)
-[![Tests](https://github.com/doplaydo/gfp-mcp/workflows/Tests/badge.svg)](https://github.com/doplaydo/gfp-mcp/actions)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
-Model Context Protocol (MCP) server for GDSFactory+ that exposes photonic IC design operations as tools for AI assistants like Claude Code and Claude Desktop.
-
-## Overview
-
-This project implements a standalone MCP server that bridges AI assistants with GDSFactory+ photonic IC design capabilities. The server acts as a lightweight proxy that exposes GDSFactory+ operations through standardized MCP tools while maintaining zero modifications to the existing FastAPI backend.
-
-## Features
-
-### Phase 1: Core Building Tools (Complete)
-
-- **build_cell** - Build a single GDS cell by name
-- **build_cells** - Build multiple GDS cells in batch
-- **list_cells** - List all available photonic components
-- **get_cell_info** - Get detailed component metadata
-- **download_gds** - Download built GDS files
-- **list_projects** - List all running GDSFactory+ server instances
-- **get_project_info** - Get detailed information about a specific project
-
-### Multi-Project Support
-
-The MCP server integrates with the GDSFactory+ server registry to support working with multiple projects simultaneously. The registry is stored at `~/.gdsfactory/server-registry.json` and is automatically managed by GDSFactory+ servers.
-
-#### How It Works
-
-1. When you start a GDSFactory+ server with `gfp serve`, it registers itself in the shared registry
-2. The MCP server reads from this registry to discover available projects
-3. Tools accept an optional `project` parameter to route requests to specific servers
-4. The MCP server automatically resolves project names to the correct port
-
-#### Example Usage
-
-```
-User: "List all running GDSFactory+ projects"
-Claude: [Uses list_projects tool to show all registered servers]
-
-User: "Build the mzi component in the my_photonics_project"
-Claude: [Uses build_cell tool with project="my_photonics_project"]
-```
-
-**Note**: The MCP has read-only access to the registry. Only GDSFactory+ servers can register/unregister themselves.
-
-### Architecture
-
-```
-AI Assistant (Claude) <-> MCP Server (STDIO) <-> HTTP Client <-> FastAPI Server
-```
-
-**Key Benefits:**
-- Universal MCP client compatibility via STDIO transport
-- Zero modifications to existing FastAPI server
-- Clean separation of concerns
-- No database conflicts (only FastAPI touches SQLite)
-- Scalable architecture ready for 20+ tools
-
-## Installation
-
-### From PyPI (Recommended)
-
-Install the package from PyPI:
-
-```bash
-pip install gfp-mcp
-```
-
-Or with uv:
-
-```bash
-uv pip install gfp-mcp
-```
-
-### From Source (Development)
-
-For development or if you want the latest unreleased changes:
-
-```bash
-git clone https://github.com/doplaydo/gfp-mcp.git
-cd gfp-mcp
-pip install -e ".[dev]"
-```
-
-### Prerequisites
-
-- Python 3.10 or higher
-- GDSFactory+ with FastAPI server running
-
-### Verify Installation
-
-```bash
-gfp-mcp-serve --help
-```
-
-## Quick Start
-
-### 1. Start the FastAPI Server
-
-In one terminal:
-
-```bash
-gfp serve --port 8787
-```
-
-### 2. Configure Your AI Assistant
-
-#### Claude Code
-
-Add to `.claude/settings.json`:
-
-```json
-{
-    "mcpServers": {
-        "gdsfactoryplus": {
-            "command": "gfp-mcp-serve",
-            "args": [],
-            "env": {
-                "GFP_API_URL": "http://localhost:8787"
-            }
-        }
-    }
-}
-```
-
-Or use the command line:
-
-```bash
-claude mcp add gdsfactoryplus -- gfp-mcp-serve
-```
-
-#### Claude Desktop
-
-Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS):
-
-```json
-{
-    "mcpServers": {
-        "gdsfactoryplus": {
-            "command": "gfp-mcp-serve",
-            "args": []
-        }
-    }
-}
-```
-
-For Windows: `%APPDATA%\Claude\claude_desktop_config.json`
-
-For Linux: `~/.config/Claude/claude_desktop_config.json`
-
-### 3. Use the Tools
-
-Ask your AI assistant to:
-
-- "List all available photonic components"
-- "Build the mzi component"
-- "Show me details about the coupler component"
-- "Build multiple components: mzi, coupler, and bend_euler"
-
-## Environment Variables
-
-Configure the MCP server using environment variables:
-
-```bash
-# FastAPI server URL (default: http://localhost:8787)
-export GFP_API_URL="http://localhost:8787"
-
-# Request timeout in seconds (default: 300)
-export GFP_MCP_TIMEOUT=300
-
-# Enable debug logging (default: false)
-export GFP_MCP_DEBUG=true
-```
-
-## Project Structure
-
-```
-gfp-mcp/
-├── mcp_standalone/          # MCP server implementation
-│   ├── __init__.py         # Package exports
-│   ├── config.py           # Configuration management
-│   ├── client.py           # HTTP client for FastAPI
-│   ├── registry.py         # Server registry (multi-project support)
-│   ├── tools.py            # MCP tool definitions
-│   ├── mappings.py         # Tool → Endpoint mappings
-│   ├── server.py           # MCP server core
-│   └── README.md           # Detailed documentation
-├── tests/                  # Test suite
-│   ├── test_mcp_tools.py
-│   ├── test_mcp_mappings.py
-│   ├── test_mcp_integration.py
-│   └── test_registry.py
-├── mcp_serve.py            # CLI entry point
-├── MCP_QUICKSTART.md       # Quick start guide
-├── MCP_IMPLEMENTATION_STATUS.md  # Implementation details
-└── README.md               # This file
-```
-
-## Testing
-
-Run the test suite:
-
-```bash
-# Run all MCP tests
-pytest tests/test_mcp_*.py -v
-
-# Run with coverage
-pytest tests/test_mcp_*.py --cov=mcp_standalone --cov-report=term-missing
-
-# Run specific test file
-pytest tests/test_mcp_tools.py -v
-```
-
-All tests are passing (46/46 tests):
-- Tool definitions: 15 tests
-- Endpoint mappings: 13 tests
-- Integration & client: 9 tests
-- Registry integration: 9 tests
-
-## Example Workflows
-
-### Build and Verify a Component
-
-```
-User: "List all available photonic components"
-Claude: [Uses list_cells tool]
-
-User: "Build the mzi component"
-Claude: [Uses build_cell tool with name="mzi"]
-
-User: "Show me the details of the mzi component"
-Claude: [Uses get_cell_info tool with name="mzi"]
-```
-
-### Batch Build Multiple Components
-
-```
-User: "Build the following components: mzi, coupler, and bend_euler"
-Claude: [Uses build_cells tool with names=["mzi", "coupler", "bend_euler"]]
-```
-
-## Troubleshooting
-
-### Error: "Connection refused to localhost:8787"
-
-**Cause**: FastAPI server is not running
-
-**Solution**: Start the FastAPI server:
-
-```bash
-gfp serve --port 8787
-```
-
-### Error: "MCP server not responding"
-
-**Cause**: STDIO transport issue or MCP client misconfiguration
-
-**Solution**:
-1. Check Claude Code/Desktop logs with `claude --debug`
-2. Restart the MCP server
-3. Verify the configuration in settings.json
-
-### Error: "Tool execution timeout"
-
-**Cause**: Long-running operation exceeded timeout
-
-**Solution**: Increase the timeout:
-
-```bash
-export GFP_MCP_TIMEOUT=600  # 10 minutes
-gfp mcp-serve
-```
-
-## Roadmap
-
-### Future Phases
-
-- **Phase 2**: Verification tools (DRC, LVS)
-- **Phase 3**: SPICE workflow tools
-- **Phase 4**: Simulation & advanced tools
-- **Phase 5**: Comprehensive testing & documentation
-
-## Documentation
-
-- [Quick Start Guide](MCP_QUICKSTART.md) - Step-by-step setup instructions
-- [Implementation Status](MCP_IMPLEMENTATION_STATUS.md) - Detailed implementation notes
-- [MCP Standalone README](mcp_standalone/README.md) - Architecture details
-- [Contributing Guide](CONTRIBUTING.md) - Development and release guidelines
-- [Changelog](CHANGELOG.md) - Version history and release notes
-
-## Contributing
-
-Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for detailed guidelines on:
-
-- Development setup
-- Running tests and code quality checks
-- Making changes and submitting PRs
-- Release process (for maintainers)
-
-Quick checklist:
-
-1. All tests pass: `pytest tests/test_mcp_*.py -v`
-2. Code quality: `ruff check . && ruff format --check .`
-3. Documentation is updated
-4. Changes are backward compatible
-
-## License
-
-See the main GDSFactory+ project for license information.
-
-## Support
-
-For issues or questions:
-
-1. Check the [Quick Start Guide](MCP_QUICKSTART.md) troubleshooting section
-2. Review the [Implementation Status](MCP_IMPLEMENTATION_STATUS.md) document
-3. Enable debug mode with `GFP_MCP_DEBUG=true` and check server logs
-4. Open an issue on GitHub
-
-## Acknowledgments
-
-Built on the Model Context Protocol by Anthropic, enabling seamless AI assistant integration with photonic IC design workflows.

gfp_mcp-0.1.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-mcp_standalone/__init__.py,sha256=7PhYozHyiRK_oFui0RkF5GJWxA2OZoWVcU_-ESfHIR4,953
-mcp_standalone/client.py,sha256=gUs9m2M27OP-GYmJ9fkojyxv212ETVJFqp0v2uN8Q2c,8205
-mcp_standalone/config.py,sha256=zr2LnI_wNEcMWrnB_WLscR-skkXjE33ZPBtK08XjaX0,1386
-mcp_standalone/mappings.py,sha256=jXEHwSrSYNDuVeMRM2dsSUsr38CzrHBLoe6exkJhqvc,7695
-mcp_standalone/registry.py,sha256=1E61UalVot8HUS3cALjM7ejYB0qR6tI5QbQSZZeQe7Y,6401
-mcp_standalone/server.py,sha256=Celd9j0KY1Fl_Qw09b9Px03vGhtaTUac2ozlYdGJ23A,7100
-mcp_standalone/tools.py,sha256=__j9N396-cJj9CKi6EAdP5_J-xESrbRZG35KNzdszXM,12349
-gfp_mcp-0.1.0.dist-info/METADATA,sha256=dVk1r3JfmlEY3RcqVSDqMLYm2fPAqwYjM4cTUD6sVQE,10442
-gfp_mcp-0.1.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-gfp_mcp-0.1.0.dist-info/entry_points.txt,sha256=mgyus9dsB_8mjgnztuHNPqzPi-7HcPg1iYzfM5NMIjk,61
-gfp_mcp-0.1.0.dist-info/top_level.txt,sha256=g2hRJHoDDPNtrNdXR70T7FR9Ev6DTRJiGW7ZvlvnXMc,15
-gfp_mcp-0.1.0.dist-info/RECORD,,