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

{mcp_standalone → gfp_mcp}/__init__.py

@@ -1,22 +1,22 @@
-"""MCP Standalone Server for GDSFactory+.
+"""GDSFactory+ MCP Server.
 
 This package provides a Model Context Protocol (MCP) server that exposes
 GDSFactory+ operations as tools for AI assistants. The server uses STDIO
 transport and proxies requests to the FastAPI backend.
 
 Architecture:
-- Standalone MCP server (this package)
+- Tool handlers in gfp_mcp/tools/ with co-located definitions and transformers
 - STDIO transport for universal compatibility
-- HTTP proxy to FastAPI backend
+- HTTP proxy to FastAPI backend via client.py
+- Multi-project routing via server registry
 - Zero changes to existing FastAPI server
-- No database conflicts (only FastAPI touches SQLite)
 
 Usage:
-    from gdsfactoryplus.mcp_standalone import main
+    from gfp_mcp import main
     main()
 
 Or via CLI:
-    gfp mcp-serve
+    gfp-mcp-serve
 """
 
 from __future__ import annotations
@@ -25,18 +25,20 @@ 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
+from .tools import get_all_tools, get_handler, get_tool_by_name
 
 __all__ = [
+    "__version__",
     "FastAPIClient",
     "MCPConfig",
     "create_server",
     "main",
     "run_server",
     "get_all_tools",
+    "get_handler",
     "get_tool_by_name",
     "get_all_resources",
     "get_resource_content",
 ]
 
-__version__ = "0.2.1"
+__version__ = "0.3.2"

{mcp_standalone → gfp_mcp}/client.py

@@ -43,6 +43,21 @@ class FastAPIClient:
         self._client: httpx.AsyncClient | None = None
         self._registry = ServerRegistry()
 
+    def _has_available_servers(self) -> bool:
+        """Check if any servers are available in the registry."""
+        return len(self._registry.list_servers()) > 0
+
+    def _get_default_server_url(self) -> str | None:
+        """Get the first available server URL from registry if no base_url configured."""
+        if self.base_url:
+            return self.base_url
+
+        servers = self._registry.list_servers()
+        if servers:
+            return f"http://localhost:{servers[0].port}"
+
+        return None
+
     async def __aenter__(self) -> Self:
         """Enter async context."""
         await self.start()
@@ -55,12 +70,17 @@ class FastAPIClient:
     async def start(self) -> None:
         """Start the HTTP client with connection pooling."""
         if self._client is None:
+            base_url = self.base_url or "http://localhost"
+
             self._client = httpx.AsyncClient(
-                base_url=self.base_url,
+                base_url=base_url,
                 timeout=httpx.Timeout(self.timeout),
                 limits=httpx.Limits(max_keepalive_connections=5, max_connections=10),
             )
-            logger.debug("HTTP client started with base URL: %s", self.base_url)
+            logger.debug(
+                "HTTP client started with base URL: %s (resolved per-request if needed)",
+                self.base_url or "from registry",
+            )
 
     async def close(self) -> None:
         """Close the HTTP client."""
@@ -79,22 +99,46 @@ class FastAPIClient:
             Base URL for the request
 
         Raises:
-            ValueError: If project not found in registry
+            ValueError: If base URL cannot be resolved
         """
-        # If no project specified, use default base_url
-        if project is None:
+        if project is not None:
+            server_info = self._registry.get_server_by_project(project)
+            if server_info is None:
+                available = self._registry.list_servers()
+                if available:
+                    project_list = ", ".join([s.project_name for s in available[:3]])
+                    if len(available) > 3:
+                        project_list += f", ... and {len(available) - 3} more"
+                    msg = (
+                        f"Project '{project}' not found in registry. "
+                        f"Available projects: {project_list}. "
+                        "Use list_projects tool to see all running servers."
+                    )
+                else:
+                    msg = (
+                        f"Project '{project}' not found. No GDSFactory+ servers are running. "
+                        "Please open a GDSFactory+ project in VSCode with the extension installed."
+                    )
+                raise ValueError(msg)
+
+            return f"http://localhost:{server_info.port}"
+
+        if self.base_url:
             return self.base_url
 
-        # Look up project in registry
-        server_info = self._registry.get_server_by_project(project)
-        if server_info is None:
-            msg = (
-                f"Project '{project}' not found in registry. "
-                "Make sure the server is running for this project."
+        default_url = self._get_default_server_url()
+        if default_url:
+            logger.info(
+                "No project specified, using first available server: %s", default_url
             )
-            raise ValueError(msg)
+            return default_url
 
-        return f"http://localhost:{server_info.port}"
+        msg = (
+            "No project specified and no GDSFactory+ servers are running. "
+            "Either: (1) Start a server by opening a GDSFactory+ project in VSCode, "
+            "(2) Specify a project parameter, or (3) Set GFP_API_URL environment variable."
+        )
+        raise ValueError(msg)
 
     async def request(
         self,
@@ -125,7 +169,6 @@ class FastAPIClient:
         if self._client is None:
             await self.start()
 
-        # Resolve the base URL for this request
         base_url = self._resolve_base_url(project)
 
         last_error = None
@@ -143,7 +186,6 @@ class FastAPIClient:
                     base_url,
                 )
 
-                # Build full URL with the resolved base URL
                 full_url = f"{base_url}{path}"
 
                 response = await self._client.request(  # type: ignore[union-attr]
@@ -155,7 +197,6 @@ class FastAPIClient:
                 )
                 response.raise_for_status()
 
-                # Try to parse JSON, fall back to text
                 try:
                     return response.json()
                 except (ValueError, TypeError):
@@ -165,19 +206,16 @@ class FastAPIClient:
                 last_error = e
                 logger.warning("Request failed (attempt %d): %s", attempt + 1, e)
 
-                # Don't retry on client errors (4xx)
                 if (
                     isinstance(e, httpx.HTTPStatusError)
                     and 400 <= e.response.status_code < 500
                 ):
                     raise
 
-                # Exponential backoff for retries
                 if attempt < MCPConfig.MAX_RETRIES - 1:
                     await asyncio.sleep(backoff)
                     backoff *= 2
 
-        # All retries failed
         logger.error("All %d attempts failed", MCPConfig.MAX_RETRIES)
         raise last_error  # type: ignore[misc]
 
@@ -256,17 +294,3 @@ class FastAPIClient:
             }
             for server in servers
         ]
-
-    async def get_project_info(self, project: str) -> dict[str, Any]:
-        """Get detailed information about a specific project.
-
-        Args:
-            project: Project name or path
-
-        Returns:
-            Project information from the server's /info endpoint
-
-        Raises:
-            ValueError: If project not found
-        """
-        return await self.request("GET", "/info", project=project)

gfp_mcp/config.py

@@ -0,0 +1,161 @@
+"""Configuration management for MCP standalone server."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Final
+
+try:
+    import tomllib  # Python 3.11+
+except ImportError:
+    import tomli as tomllib  # type: ignore[import-not-found]
+
+__all__ = ["MCPConfig", "get_gfp_api_key", "set_gfp_api_key"]
+
+
+class MCPConfig:
+    """Configuration for MCP standalone server.
+
+    Manages environment variables and default settings for the MCP server
+    that proxies requests to the FastAPI backend.
+    """
+
+    API_URL: Final[str | None] = os.getenv("GFP_API_URL")
+
+    TIMEOUT: Final[int] = int(os.getenv("GFP_MCP_TIMEOUT", "300"))
+
+    DEBUG: Final[bool] = os.getenv("GFP_MCP_DEBUG", "false").lower() in (
+        "true",
+        "1",
+        "yes",
+    )
+
+    REGISTRY_API_URL: Final[str] = "https://registry.gdsfactory.com"
+
+    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 | None:
+        """Get the FastAPI base URL.
+
+        Args:
+            override: Optional URL to override the environment variable
+
+        Returns:
+            The API base URL or None if not configured
+        """
+        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
+
+
+def _read_api_key_from_toml(file_path: Path) -> str | None:
+    """Read the API key from a TOML configuration file.
+
+    Args:
+        file_path: Path to the TOML file.
+
+    Returns:
+        The API key string, or None if not found or file doesn't exist.
+    """
+    if not file_path.exists():
+        return None
+
+    try:
+        with open(file_path, "rb") as f:
+            config = tomllib.load(f)
+
+        return (
+            config.get("tool", {}).get("gdsfactoryplus", {}).get("api", {}).get("key")
+        )
+    except Exception:
+        return None
+
+
+def get_gfp_api_key() -> str | None:
+    """Retrieve the GFP API key from environment variables or config files.
+
+    Checks sources in priority order:
+    1. GFP_API_KEY environment variable
+    2. ~/.gdsfactory/gdsfactoryplus.toml
+    3. ./pyproject.toml
+
+    Returns:
+        The API key string, or None if not found.
+    """
+    # 1. Check environment variable (highest priority)
+    api_key = os.environ.get("GFP_API_KEY")
+    if api_key:
+        return api_key
+
+    # 2. Check global config file: ~/.gdsfactory/gdsfactoryplus.toml
+    global_config_path = Path.home() / ".gdsfactory" / "gdsfactoryplus.toml"
+    api_key = _read_api_key_from_toml(global_config_path)
+    if api_key:
+        return api_key
+
+    # 3. Check local project config: ./pyproject.toml
+    local_config_path = Path.cwd() / "pyproject.toml"
+    api_key = _read_api_key_from_toml(local_config_path)
+    if api_key:
+        return api_key
+
+    return None
+
+
+def set_gfp_api_key(api_key: str) -> None:
+    """Save the GFP API key to the global config file.
+
+    Writes to: ~/.gdsfactory/gdsfactoryplus.toml
+
+    Args:
+        api_key: The API key to save.
+
+    Raises:
+        ValueError: If api_key is empty or None.
+    """
+    if not api_key:
+        raise ValueError("API key is required")
+
+    config_dir = Path.home() / ".gdsfactory"
+    config_path = config_dir / "gdsfactoryplus.toml"
+
+    # Create directory if it doesn't exist
+    config_dir.mkdir(parents=True, exist_ok=True)
+
+    # Load existing config or create new one
+    config: dict = {}
+    if config_path.exists():
+        with open(config_path, "rb") as f:
+            config = tomllib.load(f)
+
+    # Set the API key in the nested structure
+    if "tool" not in config:
+        config["tool"] = {}
+    if "gdsfactoryplus" not in config["tool"]:
+        config["tool"]["gdsfactoryplus"] = {}
+    if "api" not in config["tool"]["gdsfactoryplus"]:
+        config["tool"]["gdsfactoryplus"]["api"] = {}
+
+    config["tool"]["gdsfactoryplus"]["api"]["key"] = api_key
+
+    # Write back to file using tomli_w if available, otherwise manual formatting
+    try:
+        import tomli_w
+
+        with open(config_path, "wb") as f:
+            tomli_w.dump(config, f)
+    except ImportError:
+        # Fallback: write TOML manually for this simple structure
+        with open(config_path, "w") as f:
+            f.write("[tool.gdsfactoryplus.api]\n")
+            f.write(f'key = "{api_key}"\n')

{mcp_standalone → gfp_mcp}/registry.py

@@ -102,8 +102,6 @@ class ServerInfo:
             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:
@@ -163,7 +161,6 @@ class ServerRegistry:
 
         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
 
@@ -203,7 +200,6 @@ class ServerRegistry:
         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)
 

gfp_mcp/render.py

@@ -0,0 +1,139 @@
+"""GDS rendering utilities for MCP server.
+
+This module provides utilities for rendering GDS files to PNG images,
+enabling automatic image return when building cells.
+"""
+
+from __future__ import annotations
+
+import base64
+import logging
+from pathlib import Path
+
+from mcp.types import ImageContent
+
+from .registry import ServerRegistry
+from .utils import wait_for_gds_file
+
+__all__ = ["render_gds_to_png", "render_built_cells", "HAS_KLAYOUT"]
+
+logger = logging.getLogger(__name__)
+
+try:
+    import klayout.db as db
+    import klayout.lay as lay
+
+    HAS_KLAYOUT = True
+except ImportError:
+    HAS_KLAYOUT = False
+    db = None  # type: ignore[assignment]
+    lay = None  # type: ignore[assignment]
+
+
+def render_gds_to_png(
+    gds_path: Path,
+    width: int = 800,
+    height: int = 600,
+) -> bytes | None:
+    """Render GDS file to PNG image using klayout.
+
+    Args:
+        gds_path: Path to the GDS file to render
+        width: Image width in pixels (default: 800)
+        height: Image height in pixels (default: 600)
+
+    Returns:
+        PNG image as bytes, or None if klayout is not available or rendering fails
+    """
+    if not HAS_KLAYOUT:
+        logger.debug("klayout not available, skipping GDS rendering")
+        return None
+
+    if not gds_path.exists():
+        logger.warning("GDS file not found for rendering: %s", gds_path)
+        return None
+
+    try:
+        layout = db.Layout()
+        layout.read(str(gds_path))
+
+        layout_view = lay.LayoutView()
+        layout_view.load_layout(str(gds_path), True)
+
+        layout_view.max_hier()
+
+        layout_view.zoom_fit()
+
+        pixel_buffer = layout_view.get_pixels(width, height)
+
+        png_bytes = pixel_buffer.to_png_data()
+
+        logger.debug("Rendered GDS to PNG: %s (%dx%d)", gds_path, width, height)
+        return png_bytes
+
+    except Exception as e:
+        logger.warning("Failed to render GDS to PNG: %s - %s", gds_path, e)
+        return None
+
+
+async def render_built_cells(
+    cell_names: list[str],
+    project: str | None,
+) -> list[ImageContent]:
+    """Render built GDS cells to PNG images.
+
+    Args:
+        cell_names: List of cell names to render
+        project: Optional project name for routing
+
+    Returns:
+        List of ImageContent for successfully rendered cells
+    """
+    images: list[ImageContent] = []
+
+    if not cell_names:
+        return images
+
+    if not HAS_KLAYOUT:
+        logger.debug("klayout not available, skipping cell rendering")
+        return images
+
+    registry = ServerRegistry()
+    server_info = None
+
+    if project:
+        server_info = registry.get_server_by_project(project)
+    if not server_info:
+        servers = registry.list_servers()
+        if servers:
+            server_info = servers[0]
+
+    if not server_info:
+        logger.debug(
+            "No server found in registry, cannot determine project path for GDS rendering"
+        )
+        return images
+
+    project_path = Path(server_info.project_path)
+    gds_dir = project_path / "build" / "gds"
+
+    for cell_name in cell_names:
+        gds_path = gds_dir / f"{cell_name}.gds"
+
+        if await wait_for_gds_file(gds_path):
+            png_bytes = render_gds_to_png(gds_path)
+            if png_bytes:
+                images.append(
+                    ImageContent(
+                        type="image",
+                        data=base64.b64encode(png_bytes).decode("utf-8"),
+                        mimeType="image/png",
+                    )
+                )
+                logger.info("Added PNG image for cell: %s", cell_name)
+            else:
+                logger.debug("Failed to render GDS to PNG for cell: %s", cell_name)
+        else:
+            logger.debug("GDS file not found within timeout for cell: %s", cell_name)
+
+    return images

{mcp_standalone → gfp_mcp}/resources.py

@@ -15,7 +15,6 @@ __all__ = [
 ]
 
 
-# Define available resources
 RESOURCES: list[Resource] = [
     Resource(
         uri="instructions://build_custom_cell",
@@ -30,7 +29,6 @@ RESOURCES: list[Resource] = [
 ]
 
 
-# Resource content
 RESOURCE_CONTENT = {
     "instructions://build_custom_cell": """---
 Workflow: Creating Custom Components in GDSFactory+ Projects
@@ -71,7 +69,6 @@ def custom_component_name(
     Returns:
         Component description
     \"\"\"
-    # Implementation using PDK functions
     c = pdk_function(parameters...)
     return c