Enhancement/mcp apps

.vscode/settings.json

@@ -1,4 +1,3 @@
 {
-    "python-envs.defaultEnvManager": "ms-python.python:system",
-    "python-envs.pythonProjects": []
+    "python-envs.defaultEnvManager": "ms-python.python:system"
 }

docs/explanation/display-system.md

@@ -6,7 +6,7 @@ The Display Server is a component of the HoloViz MCP that enables AI assistants
 
 The Display System uses a decoupled architecture:
 
-1. **MCP Server** (your main process): Hosts the `show` tool, connects via HTTP
+1. **MCP Server** (your main process): Hosts the `show` and `show_pyodide` tools
 2. **Display Server** (independent process): Executes Python code and serves web pages
 3. **Browser** (user interface): Displays visualizations and management interfaces
 
@@ -22,7 +22,14 @@ When you use the `show` tool:
 3. Display Server stores the snippet in SQLite database
 4. Display Server executes the code and captures output
 5. MCP server returns URL to view visualization
-6. User accesses visualization via URL in browser
+6. User accesses visualization via URL in browser (or via in-chat MCP App UI when supported)
+
+When you use the `show_pyodide` tool:
+
+1. AI sends code to the MCP server via the tool
+2. MCP server returns a payload for an MCP App resource
+3. The host renders the app in a sandboxed iframe
+4. panel-live runs the code in a browser/Pyodide runtime
 
 This decoupled architecture means:
 
@@ -38,7 +45,7 @@ The `show` MCP tool is the primary interface for creating visualizations. It acc
 - **app** (required): Python code to execute
 - **name** (optional): Human-readable title for the visualization
 - **description** (optional): Explanation of what the code does
-- **method** (optional): Execution method - "jupyter" (default) or "panel"
+- **method** (optional): Execution method - "jupyter" (default), "panel", or "pyodide"
 
 The tool returns a response containing:
 
@@ -48,6 +55,17 @@ The tool returns a response containing:
 
 The workflow is designed to be simple: send code, get URL, view in browser.
 
+## The `show_pyodide` Tool
+
+The `show_pyodide` MCP tool is a browser-runtime path intended for panel-live/Pyodide rendering.
+It does not depend on display-server code execution.
+
+It accepts:
+
+- **code** (required): Python code to run in panel-live
+- **name** (optional): Human-readable title for the app
+- **description** (optional): Explanation of what the code does
+
 ## Why an Independent Server?
 
 Running visualizations in an independent server process provides several key benefits:
@@ -81,7 +99,7 @@ A **snippet** is a stored code sample with metadata. Each snippet has:
 - Detected packages and Panel extensions
 - Execution method and timestamp
 
-The Display System supports two execution methods:
+The Display System supports three execution methods:
 
 ### Jupyter Method (Default)
 
@@ -101,6 +119,11 @@ Executes code that explicitly calls `.servable()` on Panel components. This meth
 - Multiple objects can be served
 - Best for complex, interactive applications
 
+### Pyodide Method
+
+Stores snippets with browser-runtime intent and skips Panel-extension inference.
+This method is intended for `show_pyodide` and panel-live flows.
+
 The method is automatically inferred from the code or can be specified explicitly.
 
 ## Database and URL Management

docs/explanation/tools.md

@@ -140,6 +140,33 @@ Tools for accessing HoloViews documentation.
 
 Tools for searching and accessing HoloViz documentation.
 
+### show
+
+**Purpose**: Execute visualization code via the display server and return a view URL (with MCP App rendering in capable hosts).
+
+**Parameters**:
+- `code` (string): Python code to execute
+- `name` (string, optional): Visualization name
+- `description` (string, optional): Visualization description
+- `method` (string, optional): `jupyter` (default), `panel`, or `pyodide`
+
+**Use Case**: Standard display-server backed visualization flow with URL fallback behavior.
+
+**Returns**: Success/error message containing a view URL.
+
+### show_pyodide
+
+**Purpose**: Return an MCP App payload for panel-live/Pyodide browser execution.
+
+**Parameters**:
+- `code` (string): Python code to run in the browser runtime
+- `name` (string, optional): App title
+- `description` (string, optional): App description
+
+**Use Case**: Browser-only runtime path where server-side execution should be avoided.
+
+**Returns**: JSON text payload consumed by the linked MCP App resource.
+
 ### search
 
 **Purpose**: Search HoloViz documentation using semantic similarity.

src/holoviz_mcp/config/loader.py

@@ -102,7 +102,7 @@ def _filter_known_fields(self, config_dict: dict[str, Any]) -> dict[str, Any]:
         This prevents validation errors when loading user config files that might
         contain extra fields.
         """
-        known_fields = {"server", "docs", "resources", "prompts", "user_dir", "default_dir", "repos_dir"}
+        known_fields = {"server", "docs", "resources", "prompts", "display", "user_dir", "default_dir", "repos_dir"}
         return {k: v for k, v in config_dict.items() if k in known_fields}
 
     def _get_default_config(self) -> dict[str, Any]:
@@ -123,6 +123,14 @@ def _get_default_config(self) -> dict[str, Any]:
             },
             "resources": {"search_paths": []},
             "prompts": {"search_paths": []},
+            "display": {
+                "enabled": True,
+                "mode": "subprocess",
+                "port": 5005,
+                "host": "localhost",
+                "max_restarts": 3,
+                "health_check_interval": 60,
+            },
         }
 
     def _load_yaml_file(self, file_path: Path) -> dict[str, Any]:
@@ -272,6 +280,12 @@ def create_default_user_config(self) -> None:
             },
             "resources": {"search_paths": []},
             "prompts": {"search_paths": []},
+            "display": {
+                "enabled": True,
+                "mode": "subprocess",
+                "port": 5005,
+                "host": "localhost",
+            },
         }
 
         with open(config_file, "w", encoding="utf-8") as f:

src/holoviz_mcp/core/inspect.py

@@ -19,15 +19,74 @@
 import asyncio
 import atexit
 import logging
+import os
 from asyncio import sleep
 from dataclasses import dataclass
 from dataclasses import field
 from datetime import datetime
 from pathlib import Path
+from urllib.parse import urlparse
 from uuid import uuid4
 
 logger = logging.getLogger(__name__)
 
+
+def _internalize_url(url: str) -> str:
+    """Convert an externalized proxy/Codespaces URL back to a localhost URL.
+
+    panel-live-server (and other tools) rewrite localhost URLs to externally
+    reachable addresses so the *user* can open them in a browser.  When the
+    *inspect* tool uses Playwright on the same machine it should talk directly
+    to localhost — no round-trip through the internet, no auth required.
+
+    Supported patterns
+    ------------------
+    GitHub Codespaces
+        ``https://<name>-<port>.app.github.dev<path>``
+        → ``http://localhost:<port><path>``
+
+    Jupyter server proxy
+        ``<JUPYTER_SERVER_PROXY_URL>/<port><path>``
+        → ``http://localhost:<port><path>``
+
+    All other URLs are returned unchanged.
+    """
+    if not url:
+        return url
+
+    parsed = urlparse(url)
+    hostname = (parsed.hostname or "").lower()
+
+    # ── GitHub Codespaces ────────────────────────────────────────────────────
+    codespace_name = os.getenv("CODESPACE_NAME", "")
+    forwarding_domain = os.getenv("GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN", "app.github.dev")
+    if codespace_name and hostname.endswith(f".{forwarding_domain}"):
+        # hostname: "<codespace_name>-<port>.<forwarding_domain>"
+        inner = hostname[: -len(f".{forwarding_domain}")]  # strip domain suffix
+        # port is always the last hyphen-separated segment
+        try:
+            port = int(inner.rsplit("-", 1)[-1])
+        except ValueError:
+            return url
+        path = parsed.path or "/"
+        query = f"?{parsed.query}" if parsed.query else ""
+        return f"http://localhost:{port}{path}{query}"
+
+    # ── Jupyter server proxy ─────────────────────────────────────────────────
+    proxy_base = os.getenv("JUPYTER_SERVER_PROXY_URL", "").rstrip("/")
+    if proxy_base and url.startswith(proxy_base):
+        remainder = url[len(proxy_base) :].lstrip("/")  # e.g. "5077/view?id=abc"
+        parts = remainder.split("/", 1)
+        try:
+            port = int(parts[0])
+        except ValueError:
+            return url
+        rest = "/" + parts[1] if len(parts) > 1 else "/"
+        return f"http://localhost:{port}{rest}"
+
+    return url
+
+
 # Known browser/framework noise patterns to filter from console logs.
 # These are infrastructure messages, not application errors.
 _NOISE_PATTERNS: list[str] = [
@@ -180,6 +239,8 @@ async def inspect_app(
     if not screenshot and not console_logs:
         raise ValueError("At least one of 'screenshot' or 'console_logs' must be True.")
 
+    url = _internalize_url(url)
+
     manager = _get_playwright_manager()
     browser = await manager.get_browser()
     page = await browser.new_page(

src/holoviz_mcp/display_mcp/database.py

@@ -40,7 +40,7 @@ class Snippet(BaseModel):
     name: str = Field(default="", description="User-provided name")
     description: str = Field(default="", description="Short description of the app")
     readme: str = Field(default="", description="Longer documentation describing the app")
-    method: Literal["jupyter", "panel"] = Field(..., description="Execution method")
+    method: Literal["jupyter", "panel", "pyodide"] = Field(..., description="Execution method")
     created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
     updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
     status: Literal["pending", "success", "error"] = Field(default="pending")
@@ -437,7 +437,7 @@ def create_visualization(
         name: str = "",
         description: str = "",
         readme: str = "",
-        method: Literal["jupyter", "panel"] = "jupyter",
+        method: Literal["jupyter", "panel", "pyodide"] = "jupyter",
     ) -> Snippet:
         """Create a visualization request.
 
@@ -455,7 +455,7 @@ def create_visualization(
         readme : str, optional
             Longer documentation describing the app
         method : str, optional
-            Execution method: "jupyter" or "panel"
+            Execution method: "jupyter", "panel", or "pyodide"
 
         Returns
         -------
@@ -477,6 +477,11 @@ def create_visualization(
         if ".show(" in app:
             raise ValueError("`.show()` calls are not supported in this environment")
 
+        supported_methods = {"jupyter", "panel", "pyodide"}
+        if method not in supported_methods:
+            supported_text = ", ".join(sorted(supported_methods))
+            raise ValueError(f"Unsupported execution method '{method}'. Supported methods: {supported_text}")
+
         # Validate syntax
         ast.parse(app)  # Raises SyntaxError if invalid
 

src/holoviz_mcp/display_mcp/endpoints.py

@@ -13,11 +13,39 @@
 
 from tornado.web import RequestHandler
 
+from holoviz_mcp.config.loader import get_config
 from holoviz_mcp.display_mcp.database import get_db
 
 logger = logging.getLogger(__name__)
 
 
+def _get_external_base_url(request_host: str) -> str | None:
+    """Get external base URL for links returned to clients.
+
+    Priority order:
+    1. Jupyter server proxy URL
+    2. GitHub Codespaces forwarded URL
+    3. None (caller should fall back to request URL)
+    """
+    jupyter_base = os.getenv("JUPYTER_SERVER_PROXY_URL")
+    if not jupyter_base:
+        try:
+            jupyter_base = get_config().server.jupyter_server_proxy_url
+        except Exception:
+            jupyter_base = ""
+
+    if jupyter_base:
+        port = request_host.split(":")[-1]
+        return f"{jupyter_base.rstrip('/')}/{port}"
+
+    if codespace_name := os.getenv("CODESPACE_NAME"):
+        port = request_host.split(":")[-1]
+        forwarding_domain = os.getenv("GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN", "app.github.dev")
+        return f"https://{codespace_name}-{port}.{forwarding_domain}"
+
+    return None
+
+
 class SnippetEndpoint(RequestHandler):
     """Tornado RequestHandler for /api/snippet endpoint."""
 
@@ -44,9 +72,7 @@ def post(self):
                 method=method,
             )
 
-            if jupyter_base := os.getenv("JUPYTER_SERVER_PROXY_URL"):
-                port = self.request.host.split(":")[-1]
-                base_url = f"{jupyter_base.rstrip('/')}/{port}"
+            if base_url := _get_external_base_url(self.request.host):
                 url = f"{base_url}/view?id={snippet.id}"
             else:
                 full_url = self.request.full_url()

src/holoviz_mcp/display_mcp/pages/view_page.py

@@ -117,10 +117,21 @@ def _execute_code(snippet: Snippet) -> pn.viewable.Viewable | None:
     """
     module_name = f"holoviz_snippet_{snippet.id.replace('-', '_')}"
 
+    # We need to reset the material design
+    app: str = (
+        """\
+import panel as pn
+
+pn.config.design = None
+
+"""
+        + snippet.app
+    )
+
     if snippet.method == "jupyter":
         # Extract last expression
         try:
-            statements, last_expr = extract_last_expression(snippet.app)
+            statements, last_expr = extract_last_expression(app)
         except ValueError as e:
             raise ValueError(f"Failed to parse code: {e}") from e
 
@@ -150,7 +161,7 @@ def _execute_code(snippet: Snippet) -> pn.viewable.Viewable | None:
     else:  # panel method
         # Execute code that should call .servable()
         execute_in_module(
-            snippet.app,
+            app,
             module_name=module_name,
             cleanup=True,  # Can cleanup immediately
         )