gfp-mcp 0.1.0__py3-none-any.whl

mcp_standalone/config.py

@@ -0,0 +1,54 @@
+"""Configuration management for MCP standalone server."""
+
+from __future__ import annotations
+
+import os
+from typing import Final
+
+__all__ = ["MCPConfig"]
+
+
+class MCPConfig:
+    """Configuration for MCP standalone server.
+
+    Manages environment variables and default settings for the MCP server
+    that proxies requests to the FastAPI backend.
+    """
+
+    # FastAPI base URL (default: http://localhost:8787)
+    API_URL: Final[str] = os.getenv("GFP_API_URL", "http://localhost:8787")
+
+    # Timeout for tool calls in seconds (default: 300 = 5 minutes)
+    TIMEOUT: Final[int] = int(os.getenv("GFP_MCP_TIMEOUT", "300"))
+
+    # Enable debug logging
+    DEBUG: Final[bool] = os.getenv("GFP_MCP_DEBUG", "false").lower() in (
+        "true",
+        "1",
+        "yes",
+    )
+
+    # Retry configuration
+    MAX_RETRIES: Final[int] = 3
+    RETRY_BACKOFF: Final[float] = 0.5  # Initial backoff in seconds
+
+    @classmethod
+    def get_api_url(cls, override: str | None = None) -> str:
+        """Get the FastAPI base URL.
+
+        Args:
+            override: Optional URL to override the environment variable
+
+        Returns:
+            The API base URL
+        """
+        return override or cls.API_URL
+
+    @classmethod
+    def get_timeout(cls) -> int:
+        """Get the timeout for tool calls.
+
+        Returns:
+            Timeout in seconds
+        """
+        return cls.TIMEOUT

mcp_standalone/mappings.py

@@ -0,0 +1,286 @@
+"""Mappings from MCP tools to FastAPI endpoints.
+
+This module defines how MCP tool arguments are transformed into HTTP
+requests to the FastAPI backend, and how responses are transformed back.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+__all__ = [
+    "TOOL_MAPPINGS",
+    "get_mapping",
+    "transform_request",
+    "transform_response",
+]
+
+
+class EndpointMapping:
+    """Configuration for mapping an MCP tool to a FastAPI endpoint."""
+
+    def __init__(
+        self,
+        method: str,
+        path: str,
+        request_transformer: Callable[[dict[str, Any]], dict[str, Any]] | None = None,
+        response_transformer: Callable[[Any], Any] | None = None,
+    ) -> None:
+        """Initialize endpoint mapping.
+
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            path: API endpoint path
+            request_transformer: Optional function to transform MCP args to
+                HTTP params
+            response_transformer: Optional function to transform HTTP response
+                to MCP format
+        """
+        self.method = method
+        self.path = path
+        self.request_transformer = request_transformer or (lambda x: x)
+        self.response_transformer = response_transformer or (lambda x: x)
+
+
+def _build_cell_request(args: dict[str, Any]) -> dict[str, Any]:
+    """Transform build_cell MCP args to FastAPI params.
+
+    Args:
+        args: MCP tool arguments
+
+    Returns:
+        Dict with 'params' key for query parameters
+    """
+    return {
+        "params": {
+            "name": args["name"],
+            "with_metadata": args.get("with_metadata", True),
+            "register": args.get("register", True),
+        }
+    }
+
+
+def _build_cells_request(args: dict[str, Any]) -> dict[str, Any]:
+    """Transform build_cells MCP args to FastAPI params.
+
+    Args:
+        args: MCP tool arguments
+
+    Returns:
+        Dict with 'params' key for query parameters and 'json_data' for body
+    """
+    return {
+        "params": {
+            "with_metadata": args.get("with_metadata", True),
+            "register": args.get("register", True),
+        },
+        "json_data": args["names"],
+    }
+
+
+def _list_cells_response(response: Any) -> dict[str, Any]:
+    """Transform list_cells response to MCP format.
+
+    Args:
+        response: FastAPI response (list of cell names)
+
+    Returns:
+        Formatted response with cell names
+    """
+    if isinstance(response, list):
+        return {"cells": response, "count": len(response)}
+    return response
+
+
+def _get_cell_info_request(args: dict[str, Any]) -> dict[str, Any]:
+    """Transform get_cell_info MCP args to FastAPI params.
+
+    Args:
+        args: MCP tool arguments
+
+    Returns:
+        Dict with 'params' key for query parameters
+    """
+    return {"params": {"name": args["name"]}}
+
+
+def _download_gds_request(args: dict[str, Any]) -> dict[str, Any]:
+    """Transform download_gds MCP args to FastAPI path.
+
+    Args:
+        args: MCP tool arguments
+
+    Returns:
+        Dict with modified 'path' for the endpoint
+    """
+    path = args["path"]
+    # The path template in FastAPI is /api/download/{path:path}.gds
+    # We need to construct the full path
+    return {"path": f"/api/download/{path}.gds"}
+
+
+def _download_gds_response(response: Any) -> dict[str, Any]:
+    """Transform download_gds response to MCP format.
+
+    Args:
+        response: FastAPI response (file path or error)
+
+    Returns:
+        Formatted response with file path
+    """
+    # If response is a string (text), it's likely the file content or path
+    if isinstance(response, str):
+        return {"status": "success", "message": response}
+    return response
+
+
+def _check_drc_request(args: dict[str, Any]) -> dict[str, Any]:
+    """Transform check_drc 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 "pdk" in args and args["pdk"]:
+        json_data["pdk"] = args["pdk"]
+    if "process" in args and args["process"]:
+        json_data["process"] = args["process"]
+    if "timeout" in args and args["timeout"]:
+        json_data["timeout"] = args["timeout"]
+    if "host" in args and args["host"]:
+        json_data["host"] = args["host"]
+
+    return {"json_data": json_data}
+
+
+def _check_connectivity_request(args: dict[str, Any]) -> dict[str, Any]:
+    """Transform check_connectivity MCP args to FastAPI params.
+
+    Args:
+        args: MCP tool arguments
+
+    Returns:
+        Dict with 'json_data' key for request body
+    """
+    return {"json_data": {"path": args["path"]}}
+
+
+def _check_lvs_request(args: dict[str, Any]) -> dict[str, Any]:
+    """Transform check_lvs MCP args to FastAPI params.
+
+    Args:
+        args: MCP tool arguments
+
+    Returns:
+        Dict with 'json_data' key for request body
+    """
+    return {
+        "json_data": {
+            "cell": args["cell"],
+            "netpath": args["netpath"],
+            "cellargs": args.get("cellargs", ""),
+        }
+    }
+
+
+# Tool name -> Endpoint mapping
+TOOL_MAPPINGS: dict[str, EndpointMapping] = {
+    # Phase 1: Core Building Tools
+    "build_cell": EndpointMapping(
+        method="GET",
+        path="/api/build-cell",
+        request_transformer=_build_cell_request,
+    ),
+    "build_cells": EndpointMapping(
+        method="POST",
+        path="/api/build-cells",
+        request_transformer=_build_cells_request,
+    ),
+    "list_cells": EndpointMapping(
+        method="GET",
+        path="/api/cells",
+        response_transformer=_list_cells_response,
+    ),
+    "get_cell_info": EndpointMapping(
+        method="GET",
+        path="/api/cell-info",
+        request_transformer=_get_cell_info_request,
+    ),
+    "download_gds": EndpointMapping(
+        method="GET",
+        path="/api/download/{path}.gds",
+        request_transformer=_download_gds_request,
+        response_transformer=_download_gds_response,
+    ),
+    # Phase 2: Verification Tools
+    "check_drc": EndpointMapping(
+        method="POST",
+        path="/api/check-drc",
+        request_transformer=_check_drc_request,
+    ),
+    "check_connectivity": EndpointMapping(
+        method="POST",
+        path="/api/check-connectivity",
+        request_transformer=_check_connectivity_request,
+    ),
+    "check_lvs": EndpointMapping(
+        method="POST",
+        path="/api/check-lvs",
+        request_transformer=_check_lvs_request,
+    ),
+}
+
+
+def get_mapping(tool_name: str) -> EndpointMapping | None:
+    """Get the endpoint mapping for a tool.
+
+    Args:
+        tool_name: Name of the MCP tool
+
+    Returns:
+        EndpointMapping or None if not found
+    """
+    return TOOL_MAPPINGS.get(tool_name)
+
+
+def transform_request(
+    tool_name: str,
+    args: dict[str, Any],
+) -> dict[str, Any]:
+    """Transform MCP tool arguments to HTTP request parameters.
+
+    Args:
+        tool_name: Name of the MCP tool
+        args: Tool arguments from MCP
+
+    Returns:
+        Dict containing HTTP request parameters (params, json_data, path, etc.)
+    """
+    mapping = get_mapping(tool_name)
+    if mapping is None:
+        return {}
+
+    return mapping.request_transformer(args)
+
+
+def transform_response(tool_name: str, response: Any) -> Any:
+    """Transform HTTP response to MCP format.
+
+    Args:
+        tool_name: Name of the MCP tool
+        response: HTTP response from FastAPI
+
+    Returns:
+        Transformed response for MCP
+    """
+    mapping = get_mapping(tool_name)
+    if mapping is None:
+        return response
+
+    return mapping.response_transformer(response)

mcp_standalone/registry.py

@@ -0,0 +1,210 @@
+"""Read-only server registry for MCP that works with gdsfactoryplus registry.
+
+This module provides read-only access to the gdsfactoryplus server registry,
+allowing the MCP to discover and connect to running GDSFactory+ server instances.
+The registry file is managed by gdsfactoryplus and located at:
+~/.gdsfactory/server-registry.json
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+try:
+    import psutil
+
+    HAS_PSUTIL = True
+except ImportError:
+    HAS_PSUTIL = False
+
+__all__ = ["ServerRegistry", "ServerInfo", "get_registry_path"]
+
+
+def get_registry_path() -> Path:
+    """Get the path to the server registry file.
+
+    Returns:
+        Path to ~/.gdsfactory/server-registry.json
+    """
+    gdsfactory_dir = Path.home() / ".gdsfactory"
+    gdsfactory_dir.mkdir(parents=True, exist_ok=True)
+    return gdsfactory_dir / "server-registry.json"
+
+
+class ServerInfo:
+    """Information about a running GDSFactory+ server.
+
+    This class is compatible with gdsfactoryplus.registry.ServerInfo
+    but doesn't require the full gdsfactoryplus package.
+    """
+
+    def __init__(
+        self,
+        port: int,
+        pid: int,
+        project_path: str,
+        project_name: str,
+        pdk: str | None = None,
+        started_at: str | None = None,
+        last_heartbeat: str | None = None,
+    ) -> None:
+        """Initialize server info.
+
+        Args:
+            port: HTTP server port
+            pid: Process ID
+            project_path: Absolute path to project directory
+            project_name: Human-readable project name
+            pdk: PDK name (optional)
+            started_at: ISO timestamp when server started
+            last_heartbeat: ISO timestamp of last heartbeat
+        """
+        self.port = port
+        self.pid = pid
+        self.project_path = project_path
+        self.project_name = project_name
+        self.pdk = pdk
+        self.started_at = started_at
+        self.last_heartbeat = last_heartbeat
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "port": self.port,
+            "pid": self.pid,
+            "project_path": self.project_path,
+            "project_name": self.project_name,
+            "pdk": self.pdk,
+            "started_at": self.started_at,
+            "last_heartbeat": self.last_heartbeat,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> ServerInfo:
+        """Create from dictionary."""
+        return cls(
+            port=data["port"],
+            pid=data["pid"],
+            project_path=data["project_path"],
+            project_name=data["project_name"],
+            pdk=data.get("pdk"),
+            started_at=data.get("started_at"),
+            last_heartbeat=data.get("last_heartbeat"),
+        )
+
+    def is_alive(self) -> bool:
+        """Check if the server process is still running.
+
+        Returns:
+            True if process exists, False otherwise
+            If psutil is not available, always returns True
+        """
+        if not HAS_PSUTIL:
+            # Without psutil, assume the process is alive
+            # The registry cleanup is handled by gdsfactoryplus
+            return True
+
+        try:
+            process = psutil.Process(self.pid)
+            return process.is_running()
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            return False
+
+
+class ServerRegistry:
+    """Read-only registry for discovering active GDSFactory+ servers.
+
+    This registry reads from the same file as gdsfactoryplus.registry.ServerRegistry
+    (~/.gdsfactory/server-registry.json) but provides only read access.
+
+    The registry file is managed by the GDSFactory+ servers themselves.
+    This MCP implementation only reads from it to discover running servers.
+    """
+
+    def __init__(self, registry_path: Path | None = None) -> None:
+        """Initialize registry with read-only access.
+
+        Args:
+            registry_path: Optional custom path to registry file
+        """
+        self.registry_path = registry_path or get_registry_path()
+
+    def _read_registry(self) -> dict[str, Any]:
+        """Read the registry file.
+
+        Returns:
+            Registry data as dictionary
+        """
+        if not self.registry_path.exists():
+            return {"servers": {}}
+
+        try:
+            with self.registry_path.open() as f:
+                return json.load(f)
+        except (FileNotFoundError, json.JSONDecodeError):
+            return {"servers": {}}
+
+    def get_server(self, port: int) -> ServerInfo | None:
+        """Get server info by port.
+
+        Args:
+            port: Port number
+
+        Returns:
+            ServerInfo if found and alive, None otherwise
+        """
+        data = self._read_registry()
+        port_key = str(port)
+
+        if port_key not in data["servers"]:
+            return None
+
+        server_info = ServerInfo.from_dict(data["servers"][port_key])
+
+        # Check if process is still alive (if psutil is available)
+        if HAS_PSUTIL and not server_info.is_alive():
+            return None
+
+        return server_info
+
+    def get_server_by_project(self, project: str) -> ServerInfo | None:
+        """Get server info by project name or path.
+
+        Args:
+            project: Project name or path
+
+        Returns:
+            Server info if found and alive, None otherwise
+        """
+        for server in self.list_servers():
+            if project in {
+                server.project_name,
+                server.project_path,
+                Path(server.project_path).name,
+            }:
+                return server
+        return None
+
+    def list_servers(self, *, include_dead: bool = False) -> list[ServerInfo]:
+        """List all registered servers.
+
+        Args:
+            include_dead: Include servers with dead processes (default: False)
+                         Only effective if psutil is available
+
+        Returns:
+            List of ServerInfo objects
+        """
+        data = self._read_registry()
+        servers = []
+
+        for server_data in data["servers"].values():
+            server_info = ServerInfo.from_dict(server_data)
+
+            # Include all servers if psutil is not available or include_dead is True
+            if not HAS_PSUTIL or include_dead or server_info.is_alive():
+                servers.append(server_info)
+
+        return servers