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

mcp_standalone/mappings.py

@@ -6,6 +6,7 @@ requests to the FastAPI backend, and how responses are transformed back.
 
 from __future__ import annotations
 
+import xml.etree.ElementTree as ET
 from collections.abc import Callable
 from typing import Any
 
@@ -43,24 +44,6 @@ class EndpointMapping:
         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.
 
@@ -105,58 +88,272 @@ def _get_cell_info_request(args: dict[str, Any]) -> dict[str, Any]:
     return {"params": {"name": args["name"]}}
 
 
-def _download_gds_request(args: dict[str, Any]) -> dict[str, Any]:
-    """Transform download_gds MCP args to FastAPI path.
+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 modified 'path' for the endpoint
+        Dict with 'json_data' key for request body
     """
-    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"}
+    json_data: dict[str, Any] = {"path": args["path"]}
+
+    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 _download_gds_response(response: Any) -> dict[str, Any]:
-    """Transform download_gds response to MCP format.
+def _check_drc_response(response: Any) -> dict[str, Any]:
+    """Transform check_drc response to LLM-friendly format.
+
+    Parses KLayout RDB XML and extracts actionable violation summary
+    without polygon coordinates or verbose metadata. Computes simplified
+    location data (bounding box, centroid, size) from polygon coordinates
+    to reduce token usage by ~82% while preserving all violation details.
 
     Args:
-        response: FastAPI response (file path or error)
+        response: FastAPI response (XML string or dict with 'content' key)
 
     Returns:
-        Formatted response with file path
+        Structured summary with all violations including location data,
+        or error dict if parsing fails
     """
-    # 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
+    try:
+        if isinstance(response, dict) and "content" in response:
+            xml_str = response["content"]
+        elif isinstance(response, str):
+            xml_str = response
+        else:
+            return {
+                "error": f"Unexpected response type: {type(response).__name__}",
+                "suggestion": "Expected XML string or dict with 'content' key",
+            }
+    except Exception as e:
+        return {
+            "error": f"Failed to extract XML from response: {e}",
+            "response_preview": str(response)[:500],
+        }
 
+    try:
+        root = ET.fromstring(xml_str)
+    except ET.ParseError as e:
+        return {
+            "error": f"Failed to parse DRC XML: {e}",
+            "raw_preview": xml_str[:500],
+            "suggestion": "Check if DRC server returned valid XML",
+        }
+
+    categories_map = {}
+    for category in root.findall(".//categories/category"):
+        name_elem = category.find("name")
+        desc_elem = category.find("description")
+        if name_elem is not None and name_elem.text:
+            categories_map[name_elem.text] = (
+                desc_elem.text
+                if desc_elem is not None and desc_elem.text
+                else name_elem.text
+            )
+
+    cells = []
+    for cell in root.findall(".//cells/cell"):
+        name_elem = cell.find("name")
+        if name_elem is not None and name_elem.text:
+            cells.append(name_elem.text)
+
+    violations = []
+    violation_counts: dict[str, int] = {}
+
+    for item in root.findall(".//items/item"):
+        category_elem = item.find("category")
+        cell_elem = item.find("cell")
+        comment_elem = item.find("comment")
+        values_elem = item.find("values")
+
+        if category_elem is None or category_elem.text is None:
+            continue
+
+        category = category_elem.text
+        cell = cell_elem.text if cell_elem is not None and cell_elem.text else "unknown"
+        description = (
+            comment_elem.text
+            if comment_elem is not None and comment_elem.text
+            else categories_map.get(category, category)
+        )
+
+        location = _parse_polygon_location(values_elem)
+
+        violation = {
+            "category": category,
+            "cell": cell,
+            "description": description,
+        }
+
+        if location is not None:
+            violation["location"] = location
+        elif values_elem is not None:
+            violation["location_warning"] = "Could not parse coordinates"
+
+        violations.append(violation)
+
+        violation_counts[category] = violation_counts.get(category, 0) + 1
+
+    total_violations = len(violations)
+    status = "PASSED" if total_violations == 0 else "FAILED"
+
+    summary = {
+        "total_violations": total_violations,
+        "total_categories": len(violation_counts),
+        "cells_checked": cells,
+        "status": status,
+    }
+
+    if total_violations == 0:
+        summary["message"] = "No DRC violations found"
+
+    violations_by_category = [
+        {
+            "category": cat,
+            "description": categories_map.get(cat, cat),
+            "count": count,
+        }
+        for cat, count in sorted(
+            violation_counts.items(),
+            key=lambda x: x[1],
+            reverse=True,
+        )
+    ]
+
+    recommendations = _generate_drc_recommendations(
+        total_violations,
+        violations_by_category,
+        cells,
+    )
+
+    return {
+        "summary": summary,
+        "violations_by_category": violations_by_category,
+        "violations": violations,
+        "recommendations": recommendations,
+    }
 
-def _check_drc_request(args: dict[str, Any]) -> dict[str, Any]:
-    """Transform check_drc MCP args to FastAPI params.
+
+def _parse_polygon_location(values_elem: ET.Element | None) -> dict[str, Any] | None:
+    """Parse polygon coordinates and compute location data.
 
     Args:
-        args: MCP tool arguments
+        values_elem: XML element containing polygon coordinates
 
     Returns:
-        Dict with 'json_data' key for request body
+        Dict with bbox, centroid, and size, or None if parsing fails
     """
-    json_data: dict[str, Any] = {"path": args["path"]}
+    if values_elem is None:
+        return None
+
+    value_elem = values_elem.find("value")
+    if value_elem is None or value_elem.text is None:
+        return None
+
+    value_text = value_elem.text
+    if "polygon:" not in value_text:
+        return None
+
+    try:
+        coords_str = value_text.replace("polygon:", "").strip().strip("()")
+        if not coords_str:
+            return None
+
+        pairs = coords_str.split(";")
+        coords = []
+        for pair in pairs:
+            if "," not in pair:
+                continue
+            x_str, y_str = pair.split(",", 1)
+            coords.append((float(x_str), float(y_str)))
+
+        if not coords:
+            return None
+
+        xs = [x for x, y in coords]
+        ys = [y for x, y in coords]
+
+        bbox = {
+            "min_x": round(min(xs), 3),
+            "min_y": round(min(ys), 3),
+            "max_x": round(max(xs), 3),
+            "max_y": round(max(ys), 3),
+        }
 
-    # 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"]
+        centroid = {
+            "x": round(sum(xs) / len(xs), 3),
+            "y": round(sum(ys) / len(ys), 3),
+        }
 
-    return {"json_data": json_data}
+        size = {
+            "width": round(bbox["max_x"] - bbox["min_x"], 3),
+            "height": round(bbox["max_y"] - bbox["min_y"], 3),
+        }
+
+        return {
+            "bbox": bbox,
+            "centroid": centroid,
+            "size": size,
+        }
+
+    except (ValueError, IndexError):
+        return None
+
+
+def _generate_drc_recommendations(
+    total_violations: int,
+    violations_by_category: list[dict[str, Any]],
+    cells: list[str],
+) -> list[str]:
+    """Generate actionable recommendations based on DRC results.
+
+    Args:
+        total_violations: Total number of violations
+        violations_by_category: List of violation categories with counts
+        cells: List of cells checked
+
+    Returns:
+        List of recommendation strings
+    """
+    if total_violations == 0:
+        return ["Design passes all DRC checks"]
+
+    recommendations = []
+
+    if violations_by_category:
+        top_category = violations_by_category[0]
+        if top_category["count"] > 10:
+            recommendations.append(
+                f"Focus on {top_category['category']} violations "
+                f"({top_category['count']:,} occurrences)"
+            )
+        elif top_category["count"] > 1:
+            recommendations.append(
+                f"Check {top_category['category']} rules in {', '.join(cells)}"
+            )
+
+    if len(violations_by_category) > 1:
+        recommendations.append(
+            f"Review {len(violations_by_category)} different DRC rule categories"
+        )
+
+    if total_violations > 100:
+        recommendations.append(
+            "Consider fixing systematic issues first to reduce violation count"
+        )
+
+    return recommendations
 
 
 def _check_connectivity_request(args: dict[str, Any]) -> dict[str, Any]:
@@ -189,14 +386,78 @@ def _check_lvs_request(args: dict[str, Any]) -> dict[str, Any]:
     }
 
 
-# Tool name -> Endpoint mapping
+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"]}
+
+    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", {})
+
+    return {
+        "path": f"/freeze/{cell_name}",
+        "json_data": kwargs,  # httpx will JSON-encode this to a string
+    }
+
+
 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",
@@ -212,17 +473,11 @@ TOOL_MAPPINGS: dict[str, EndpointMapping] = {
         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,
+        response_transformer=_check_drc_response,
     ),
     "check_connectivity": EndpointMapping(
         method="POST",
@@ -234,6 +489,30 @@ TOOL_MAPPINGS: dict[str, EndpointMapping] = {
         path="/api/check-lvs",
         request_transformer=_check_lvs_request,
     ),
+    "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/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)
 

mcp_standalone/resources.py

@@ -0,0 +1,138 @@
+"""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",
+]
+
+
+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 = {
+    "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
+    \"\"\"
+    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)