napistu 0.2.4.dev5__py3-none-any.whl → 0.2.5.dev2__py3-none-any.whl

napistu/mcp/__main__.py

@@ -1,15 +1,21 @@
+# src/napistu/mcp/__main__.py
 """
-MCP (Model Context Protocol) Server for Napistu.
+MCP (Model Context Protocol) Server CLI for Napistu.
 """
 
 import asyncio
-import logging
 import click
 import click_logging
+import logging
 
 import napistu
-from napistu.mcp.profiles import get_profile, ServerProfile
-from napistu.mcp.server import create_server
+from napistu.mcp.server import start_mcp_server
+from napistu.mcp.client import (
+    check_server_health,
+    print_health_status,
+    list_server_resources,
+    read_server_resource,
+)
 
 logger = logging.getLogger(napistu.__name__)
 click_logging.basic_config(logger)
@@ -29,152 +35,171 @@ def server():
 
 @server.command(name="start")
 @click.option(
-    "--profile",
-    type=click.Choice(["local", "remote", "full"]),
-    default="remote",
-    help="Predefined configuration profile",
+    "--profile", type=click.Choice(["local", "remote", "full"]), default="remote"
 )
-@click.option("--server-name", type=str, help="Name of the MCP server")
+@click.option("--host", type=str, default="127.0.0.1")
+@click.option("--port", type=int, default=8765)
+@click.option("--server-name", type=str)
 @click_logging.simple_verbosity_option(logger)
-def start_server(profile, server_name):
+def start_server(profile, host, port, server_name):
     """Start an MCP server with the specified profile."""
-    # Collect configuration
-    config = {}
-    if server_name:
-        config["server_name"] = server_name
-
-    # Get profile with overrides
-    server_profile = get_profile(profile, **config)
-
-    # Create and start the server
-    logger.info(f"Starting Napistu MCP Server with {profile} profile...")
-    server = create_server(server_profile)
-    asyncio.run(server.start())
+    start_mcp_server(profile, host, port, server_name)
 
 
 @server.command(name="local")
-@click.option(
-    "--server-name", type=str, default="napistu-local", help="Name of the MCP server"
-)
+@click.option("--server-name", type=str, default="napistu-local")
 @click_logging.simple_verbosity_option(logger)
 def start_local(server_name):
     """Start a local MCP server optimized for function execution."""
-    # Get profile with overrides
-    server_profile = get_profile("local", server_name=server_name)
+    start_mcp_server("local", "127.0.0.1", 8765, server_name)
 
-    # Create and start the server
-    logger.info("Starting Napistu local MCP Server...")
-    server = create_server(server_profile)
-    asyncio.run(server.start())
 
-
-@server.command(name="remote")
-@click.option(
-    "--server-name", type=str, default="napistu-docs", help="Name of the MCP server"
-)
-@click.option("--codebase-path", type=str, help="Path to the Napistu codebase")
-@click.option(
-    "--docs-paths",
-    type=str,
-    help="Comma-separated list of paths to documentation files",
-)
-@click.option("--tutorials-path", type=str, help="Path to the tutorials directory")
+@server.command(name="full")
+@click.option("--server-name", type=str, default="napistu-full")
 @click_logging.simple_verbosity_option(logger)
-def start_remote(server_name, tutorials_path):
-    """Start a remote MCP server for documentation and codebase exploration."""
-    # Collect configuration
-    config = {"server_name": server_name}
-    if tutorials_path:
-        config["tutorials_path"] = tutorials_path
+def start_full(server_name):
+    """Start a full MCP server with all components enabled (local debugging)."""
+    start_mcp_server("full", "127.0.0.1", 8765, server_name)
 
-    # Get profile with overrides
-    server_profile = get_profile("remote", **config)
 
-    # Create and start the server
-    logger.info("Starting Napistu remote MCP Server...")
-    server = create_server(server_profile)
-    asyncio.run(server.start())
+@cli.command()
+@click.option("--url", default="http://127.0.0.1:8765", help="Server URL")
+@click_logging.simple_verbosity_option(logger)
+def health(url):
+    """Quick health check of MCP server."""
 
+    async def run_health_check():
+        print("🏥 Napistu MCP Server Health Check")
+        print("=" * 40)
+        print(f"Server URL: {url}")
+        print()
 
-@click.group()
-def component():
-    """Enable or disable specific MCP server components."""
-    pass
-
+        health = await check_server_health(server_url=url)
+        print_health_status(health)
 
-@component.command(name="list")
-def list_components():
-    """List available MCP server components."""
-    click.echo("Available MCP server components:")
-    click.echo("  - documentation: Documentation components")
-    click.echo("  - codebase: Codebase exploration components")
-    click.echo("  - execution: Function execution components")
-    click.echo("  - tutorials: Tutorial components")
+    asyncio.run(run_health_check())
 
 
-@component.command(name="custom")
-@click.option(
-    "--enable-documentation/--disable-documentation",
-    default=None,
-    help="Enable/disable documentation components",
-)
-@click.option(
-    "--enable-codebase/--disable-codebase",
-    default=None,
-    help="Enable/disable codebase exploration components",
-)
-@click.option(
-    "--enable-execution/--disable-execution",
-    default=None,
-    help="Enable/disable function execution components",
-)
-@click.option(
-    "--enable-tutorials/--disable-tutorials",
-    default=None,
-    help="Enable/disable tutorial components",
-)
-@click.option(
-    "--server-name", type=str, default="napistu-custom", help="Name of the MCP server"
-)
-@click.option("--codebase-path", type=str, help="Path to the Napistu codebase")
+@cli.command()
+@click.option("--url", default="http://127.0.0.1:8765", help="Server URL")
+@click_logging.simple_verbosity_option(logger)
+def resources(url):
+    """List all available resources on the MCP server."""
+
+    async def run_list_resources():
+        print("📋 Napistu MCP Server Resources")
+        print("=" * 40)
+        print(f"Server URL: {url}")
+        print()
+
+        resources = await list_server_resources(server_url=url)
+
+        if resources:
+            print(f"Found {len(resources)} resources:")
+            for resource in resources:
+                print(f"  📄 {resource.uri}")
+                if resource.name != resource.uri:
+                    print(f"      Name: {resource.name}")
+                if hasattr(resource, "description") and resource.description:
+                    print(f"      Description: {resource.description}")
+                print()
+        else:
+            print("❌ Could not retrieve resources")
+
+    asyncio.run(run_list_resources())
+
+
+@cli.command()
+@click.argument("resource_uri")
+@click.option("--url", default="http://127.0.0.1:8765", help="Server URL")
 @click.option(
-    "--docs-paths",
-    type=str,
-    help="Comma-separated list of paths to documentation files",
+    "--output", type=click.File("w"), default="-", help="Output file (default: stdout)"
 )
-@click.option("--tutorials-path", type=str, help="Path to the tutorials directory")
 @click_logging.simple_verbosity_option(logger)
-def custom_server(
-    enable_documentation,
-    enable_codebase,
-    enable_execution,
-    enable_tutorials,
-    server_name,
-):
-    """Start an MCP server with custom component configuration."""
-    # Collect configuration
-    config = {"server_name": server_name}
-    if enable_documentation is not None:
-        config["enable_documentation"] = enable_documentation
-    if enable_codebase is not None:
-        config["enable_codebase"] = enable_codebase
-    if enable_execution is not None:
-        config["enable_execution"] = enable_execution
-    if enable_tutorials is not None:
-        config["enable_tutorials"] = enable_tutorials
-
-    # Create a custom profile
-    server_profile = ServerProfile(**config)
-
-    # Create and start the server
-    logger.info("Starting Napistu custom MCP Server...")
-    server = create_server(server_profile)
-    asyncio.run(server.start())
-
-
-# Add command groups to the CLI
+def read(resource_uri, url, output):
+    """Read a specific resource from the MCP server."""
+
+    async def run_read_resource():
+        print(
+            f"📖 Reading Resource: {resource_uri}",
+            file=output if output.name != "<stdout>" else None,
+        )
+        print(f"Server URL: {url}", file=output if output.name != "<stdout>" else None)
+        print("=" * 50, file=output if output.name != "<stdout>" else None)
+
+        content = await read_server_resource(resource_uri, server_url=url)
+
+        if content:
+            print(content, file=output)
+        else:
+            print(
+                "❌ Could not read resource",
+                file=output if output.name != "<stdout>" else None,
+            )
+
+    asyncio.run(run_read_resource())
+
+
+@cli.command()
+@click.option("--local-url", default="http://127.0.0.1:8765", help="Local server URL")
+@click.option("--remote-url", required=True, help="Remote server URL")
+@click_logging.simple_verbosity_option(logger)
+def compare(local_url, remote_url):
+    """Compare health between local and remote servers."""
+
+    async def run_comparison():
+        print("🔍 Local vs Remote Server Comparison")
+        print("=" * 50)
+
+        print(f"\n📍 Local Server: {local_url}")
+        local_health = await check_server_health(server_url=local_url)
+        print_health_status(local_health)
+
+        print(f"\n🌐 Remote Server: {remote_url}")
+        remote_health = await check_server_health(server_url=remote_url)
+        print_health_status(remote_health)
+
+        # Compare results
+        print("\n📊 Comparison Summary:")
+        if local_health and remote_health:
+            local_components = local_health.get("components", {})
+            remote_components = remote_health.get("components", {})
+
+            all_components = set(local_components.keys()) | set(
+                remote_components.keys()
+            )
+
+            for component in sorted(all_components):
+                local_status = local_components.get(component, {}).get(
+                    "status", "missing"
+                )
+                remote_status = remote_components.get(component, {}).get(
+                    "status", "missing"
+                )
+
+                if local_status == remote_status == "healthy":
+                    icon = "✅"
+                elif local_status != remote_status:
+                    icon = "⚠️ "
+                else:
+                    icon = "❌"
+
+                print(
+                    f"  {icon} {component}: Local={local_status}, Remote={remote_status}"
+                )
+        else:
+            print("  ❌ Cannot compare - one or both servers unreachable")
+
+    asyncio.run(run_comparison())
+
+
+# Add commands to the CLI
 cli.add_command(server)
-cli.add_command(component)
+cli.add_command(health)
+cli.add_command(resources)
+cli.add_command(read)
+cli.add_command(compare)
+
 
 if __name__ == "__main__":
     cli()

napistu/mcp/client.py

@@ -0,0 +1,207 @@
+# src/napistu/mcp/client.py
+"""
+MCP client for testing and interacting with Napistu MCP servers.
+"""
+
+import json
+import logging
+from typing import Optional, Dict, Any, Mapping
+
+from fastmcp import Client
+
+logger = logging.getLogger(__name__)
+
+
+async def check_server_health(
+    server_url: str = "http://127.0.0.1:8765",
+) -> Optional[Dict[str, Any]]:
+    """
+    Health check using FastMCP client.
+
+    Parameters
+    ----------
+    server_url : str, optional
+        Server URL for HTTP transport. Defaults to 'http://127.0.0.1:8765'.
+
+    Returns
+    -------
+    Optional[Dict[str, Any]]
+        Dictionary containing health status information if successful, None if failed.
+        The dictionary contains:
+            - status : str
+                Overall server status ('healthy', 'degraded', or 'unhealthy')
+            - timestamp : str
+                ISO format timestamp of the health check
+            - version : str
+                Version of the Napistu package
+            - components : Dict[str, Dict[str, str]]
+                Status of each component ('healthy', 'inactive', or 'unavailable')
+    """
+
+    try:
+        # FastMCP streamable-http requires the /mcp path
+        mcp_url = server_url.rstrip("/") + "/mcp"
+        logger.info(f"Connecting to MCP server at: {mcp_url}")
+
+        client = Client(mcp_url)
+
+        async with client:
+            logger.info("✅ FastMCP client connected")
+
+            # List all available resources
+            resources = await client.list_resources()
+            logger.info(f"Found {len(resources)} resources")
+
+            # Find health resource
+            health_resource = None
+            for resource in resources:
+                uri_str = str(resource.uri).lower()
+                if "health" in uri_str:
+                    health_resource = resource
+                    logger.info(f"Found health resource: {resource.uri}")
+                    break
+
+            if not health_resource:
+                logger.error("No health resource found")
+                logger.info(f"Available resources: {[str(r.uri) for r in resources]}")
+                return None
+
+            # Read the health resource
+            logger.info(f"Reading health resource: {health_resource.uri}")
+            result = await client.read_resource(str(health_resource.uri))
+
+            if result and len(result) > 0 and hasattr(result[0], "text"):
+                try:
+                    health_data = json.loads(result[0].text)
+                    logger.info("✅ Health check successful")
+                    return health_data
+                except json.JSONDecodeError as e:
+                    logger.error(f"Failed to parse health JSON: {e}")
+                    logger.error(f"Raw response: {result[0].text}")
+                    return None
+            else:
+                logger.error(f"No valid response from health resource: {result}")
+                return None
+
+    except Exception as e:
+        logger.error(f"Health check failed: {str(e)}")
+        if hasattr(e, "__traceback__"):
+            import traceback
+
+            logger.error("Traceback:\n" + "".join(traceback.format_tb(e.__traceback__)))
+        return None
+
+
+def print_health_status(health: Optional[Mapping[str, Any]]) -> None:
+    """
+    Pretty print health status information.
+
+    Parameters
+    ----------
+    health : Optional[Mapping[str, Any]]
+        Health status dictionary from check_server_health, or None if health check failed.
+        Expected to contain:
+            - status : str
+                Overall server status
+            - components : Dict[str, Dict[str, str]]
+                Status of each component
+            - timestamp : str, optional
+                ISO format timestamp
+            - version : str, optional
+                Package version
+
+    Returns
+    -------
+    None
+        Prints health status information to stdout.
+    """
+    if not health:
+        print("❌ Could not get health status")
+        print("Check the logs above for detailed error information")
+        return
+
+    status = health.get("status", "unknown")
+    print(f"\nServer Status: {status}")
+
+    components = health.get("components", {})
+    if components:
+        print("\nComponents:")
+        for name, comp_status in components.items():
+            icon = "✅" if comp_status.get("status") == "healthy" else "❌"
+            print(f"  {icon} {name}: {comp_status.get('status', 'unknown')}")
+
+    # Show additional info if available
+    if "timestamp" in health:
+        print(f"\nTimestamp: {health['timestamp']}")
+    if "version" in health:
+        print(f"Version: {health['version']}")
+
+
+async def list_server_resources(
+    server_url: str = "http://127.0.0.1:8765",
+) -> Optional[list]:
+    """
+    List all available resources on the MCP server.
+
+    Parameters
+    ----------
+    server_url : str, optional
+        Server URL for HTTP transport. Defaults to 'http://127.0.0.1:8765'.
+
+    Returns
+    -------
+    Optional[list]
+        List of available resources, or None if failed.
+    """
+    try:
+        mcp_url = server_url.rstrip("/") + "/mcp"
+        logger.info(f"Listing resources from: {mcp_url}")
+
+        client = Client(mcp_url)
+
+        async with client:
+            resources = await client.list_resources()
+            logger.info(f"Found {len(resources)} resources")
+            return resources
+
+    except Exception as e:
+        logger.error(f"Failed to list resources: {str(e)}")
+        return None
+
+
+async def read_server_resource(
+    resource_uri: str, server_url: str = "http://127.0.0.1:8765"
+) -> Optional[str]:
+    """
+    Read a specific resource from the MCP server.
+
+    Parameters
+    ----------
+    resource_uri : str
+        URI of the resource to read (e.g., 'napistu://health')
+    server_url : str, optional
+        Server URL for HTTP transport. Defaults to 'http://127.0.0.1:8765'.
+
+    Returns
+    -------
+    Optional[str]
+        Resource content as text, or None if failed.
+    """
+    try:
+        mcp_url = server_url.rstrip("/") + "/mcp"
+        logger.info(f"Reading resource {resource_uri} from: {mcp_url}")
+
+        client = Client(mcp_url)
+
+        async with client:
+            result = await client.read_resource(resource_uri)
+
+            if result and len(result) > 0 and hasattr(result[0], "text"):
+                return result[0].text
+            else:
+                logger.error(f"No content found for resource: {resource_uri}")
+                return None
+
+    except Exception as e:
+        logger.error(f"Failed to read resource {resource_uri}: {str(e)}")
+        return None

napistu/mcp/health.py

@@ -0,0 +1,247 @@
+# src/napistu/mcp/health.py
+"""
+Health check endpoint for the MCP server when deployed to Cloud Run.
+"""
+
+import logging
+from typing import Dict, Any, TypeVar
+from datetime import datetime
+from fastmcp import FastMCP
+
+logger = logging.getLogger(__name__)
+
+# Type variable for the FastMCP decorator return type
+T = TypeVar("T")
+
+# Global cache for component health status
+_health_cache = {"status": "initializing", "components": {}, "last_check": None}
+
+
+def register_components(mcp: FastMCP) -> None:
+    """
+    Register health check components with the MCP server.
+
+    Parameters
+    ----------
+    mcp : FastMCP
+        FastMCP server instance to register the health endpoint with.
+    """
+
+    @mcp.resource("napistu://health")
+    async def health_check() -> Dict[str, Any]:
+        """
+        Health check endpoint for deployment monitoring.
+        Returns current cached health status.
+        """
+        return _health_cache
+
+    @mcp.tool("napistu://health/check")
+    async def check_current_health() -> Dict[str, Any]:
+        """
+        Tool to actively check current component health.
+        This performs real-time checks and updates the cached status.
+        """
+        global _health_cache
+        try:
+            health_status = {
+                "status": "healthy",
+                "timestamp": datetime.utcnow().isoformat(),
+                "version": _get_version(),
+                "components": await _check_components(),
+            }
+
+            # Check if any components failed
+            failed_components = [
+                name
+                for name, status in health_status["components"].items()
+                if status["status"] == "unavailable"
+            ]
+
+            if failed_components:
+                health_status["status"] = "degraded"
+                health_status["failed_components"] = failed_components
+
+            # Update the global cache with latest status
+            health_status["last_check"] = datetime.utcnow().isoformat()
+            _health_cache.update(health_status)
+            logger.info(f"Updated health cache - Status: {health_status['status']}")
+
+            return health_status
+
+        except Exception as e:
+            logger.error(f"Health check failed: {e}")
+            error_status = {
+                "status": "unhealthy",
+                "error": str(e),
+                "timestamp": datetime.utcnow().isoformat(),
+                "last_check": datetime.utcnow().isoformat(),
+            }
+            # Update cache even on error
+            _health_cache.update(error_status)
+            return error_status
+
+
+async def initialize_components() -> bool:
+    """
+    Initialize health check components.
+    Performs initial health check and caches the result.
+
+    Returns
+    -------
+    bool
+        True if initialization is successful
+    """
+    global _health_cache
+
+    logger.info("Initializing health check components...")
+
+    try:
+        # Check initial component health
+        component_status = await _check_components()
+
+        # Update cache
+        _health_cache.update(
+            {
+                "status": "healthy",
+                "components": component_status,
+                "timestamp": datetime.utcnow().isoformat(),
+                "version": _get_version(),
+                "last_check": datetime.utcnow().isoformat(),
+            }
+        )
+
+        # Check for failed components
+        failed_components = [
+            name
+            for name, status in component_status.items()
+            if status["status"] == "unavailable"
+        ]
+
+        if failed_components:
+            _health_cache["status"] = "degraded"
+            _health_cache["failed_components"] = failed_components
+
+        logger.info(f"Health check initialization complete: {_health_cache['status']}")
+        return True
+
+    except Exception as e:
+        logger.error(f"Health check initialization failed: {e}")
+        _health_cache["status"] = "unhealthy"
+        _health_cache["error"] = str(e)
+        return False
+
+
+def _check_component_health(
+    component_name: str, module_name: str, cache_attr: str
+) -> Dict[str, str]:
+    """
+    Check the health of a single MCP component by verifying its cache is initialized and contains data.
+
+    Parameters
+    ----------
+    component_name : str
+        Name of the component (for importing)
+    module_name : str
+        Full module path for importing
+    cache_attr : str
+        Name of the cache/context attribute to check
+
+    Returns
+    -------
+    Dict[str, str]
+        Dictionary containing component health status:
+            - status : str
+                One of: 'healthy', 'inactive', or 'unavailable'
+            - error : str, optional
+                Error message if status is 'unavailable'
+    """
+    try:
+        module = __import__(module_name, fromlist=[component_name])
+        cache = getattr(module, cache_attr, None)
+        logger.info(
+            f"Checking {component_name} health - Cache exists: {cache is not None}"
+        )
+
+        # Component specific checks for actual data
+        if cache:
+            if component_name == "documentation":
+                # Check if any documentation section has content
+                has_data = any(bool(section) for section in cache.values())
+                logger.info(f"Documentation sections: {list(cache.keys())}")
+            elif component_name == "codebase":
+                # Check if any codebase section has content
+                has_data = any(bool(section) for section in cache.values())
+                logger.info(f"Codebase sections: {list(cache.keys())}")
+            elif component_name == "tutorials":
+                # Check if tutorials section has content
+                has_data = bool(cache.get("tutorials", {}))
+                logger.info(f"Tutorials cache: {bool(cache.get('tutorials', {}))}")
+            elif component_name == "execution":
+                # Check if session context has more than just napistu module
+                has_data = len(cache) > 0
+                logger.info(f"Execution context: {list(cache.keys())}")
+            else:
+                has_data = bool(cache)
+
+            if has_data:
+                logger.info(f"{component_name} is healthy")
+                return {"status": "healthy"}
+
+        logger.info(f"{component_name} is inactive")
+        return {"status": "inactive"}
+    except Exception as e:
+        logger.error(f"{component_name} check failed: {str(e)}")
+        return {"status": "unavailable", "error": str(e)}
+
+
+async def _check_components() -> Dict[str, Dict[str, Any]]:
+    """
+    Check the health of individual MCP components by verifying their caches.
+
+    Returns
+    -------
+    Dict[str, Dict[str, Any]]
+        Dictionary mapping component names to their health status:
+            - {component_name} : Dict[str, str]
+                Health status for each component, containing:
+                    - status : str
+                        One of: 'healthy', 'inactive', or 'unavailable'
+                    - error : str, optional
+                        Error message if status is 'unavailable'
+    """
+    # Define component configurations - cache vars that indicate initialization
+    component_configs = {
+        "documentation": ("napistu.mcp.documentation", "_docs_cache"),
+        "codebase": ("napistu.mcp.codebase", "_codebase_cache"),
+        "tutorials": ("napistu.mcp.tutorials", "_tutorial_cache"),
+        "execution": ("napistu.mcp.execution", "_session_context"),
+    }
+
+    logger.info("Starting component health checks...")
+    logger.info(f"Checking components: {list(component_configs.keys())}")
+
+    # Check each component's cache
+    results = {
+        name: _check_component_health(name, module_path, cache_attr)
+        for name, (module_path, cache_attr) in component_configs.items()
+    }
+
+    logger.info(f"Health check results: {results}")
+    return results
+
+
+def _get_version() -> str:
+    """
+    Get the Napistu version.
+
+    Returns
+    -------
+    str
+        Version string of the Napistu package, or 'unknown' if not available.
+    """
+    try:
+        import napistu
+
+        return getattr(napistu, "__version__", "unknown")
+    except ImportError:
+        return "unknown"

napistu/mcp/server.py

@@ -1,8 +1,11 @@
+# src/napistu/mcp/server.py
 """
 Core MCP server implementation for Napistu.
 """
 
+import asyncio
 import logging
+import os
 
 from mcp.server import FastMCP
 
@@ -10,8 +13,9 @@ from napistu.mcp import codebase
 from napistu.mcp import documentation
 from napistu.mcp import execution
 from napistu.mcp import tutorials
+from napistu.mcp import health
 
-from napistu.mcp.profiles import ServerProfile
+from napistu.mcp.profiles import ServerProfile, get_profile
 
 logger = logging.getLogger(__name__)
 
@@ -55,6 +59,11 @@ def create_server(profile: ServerProfile, **kwargs) -> FastMCP:
     if config["enable_tutorials"]:
         logger.info("Registering tutorials components")
         tutorials.register_components(mcp)
+
+    # Always register health components
+    health.register_components(mcp)
+    logger.info("Registered health components")
+
     return mcp
 
 
@@ -72,6 +81,7 @@ async def initialize_components(profile: ServerProfile) -> None:
     None
     """
     config = profile.get_config()
+
     if config["enable_documentation"]:
         logger.info("Initializing documentation components")
         await documentation.initialize_components()
@@ -84,3 +94,97 @@ async def initialize_components(profile: ServerProfile) -> None:
     if config["enable_execution"]:
         logger.info("Initializing execution components")
         await execution.initialize_components()
+
+    # Initialize health components last since they monitor the other components
+    logger.info("Initializing health components")
+    await health.initialize_components()
+
+
+def start_mcp_server(
+    profile_name: str = "remote",
+    host: str = "0.0.0.0",
+    port: int = 8080,
+    server_name: str | None = None,
+) -> None:
+    """
+    Start MCP server - main entry point for server startup.
+
+    The server will be started with HTTP transport on the specified host and port.
+    Environment variables can override the default configuration:
+    - MCP_PROFILE: Server profile to use
+    - HOST: Host to bind to
+    - PORT: Port to bind to
+    - MCP_SERVER_NAME: Name of the MCP server
+
+    Parameters
+    ----------
+    profile_name : str, optional
+        Server profile to use ('local', 'remote', 'full'). Defaults to 'remote'.
+    host : str, optional
+        Host address to bind the server to. Defaults to '0.0.0.0'.
+    port : int, optional
+        Port number to listen on. Defaults to 8080.
+    server_name : str | None, optional
+        Custom name for the MCP server. If None, will be generated from profile name.
+        Defaults to None.
+
+    Returns
+    -------
+    None
+        This function runs indefinitely until interrupted.
+
+    Notes
+    -----
+    The server uses HTTP transport (streamable-http) for all connections.
+    Components are initialized asynchronously before the server starts.
+    Health components are always registered and initialized last.
+    """
+    # Set up logging
+    logging.basicConfig(level=logging.INFO)
+    logger = logging.getLogger("napistu")
+
+    # Get configuration from environment variables (for Cloud Run)
+    env_profile = os.getenv("MCP_PROFILE", profile_name)
+    env_host = os.getenv("HOST", host)
+    env_port = int(os.getenv("PORT", port))
+    env_server_name = os.getenv(
+        "MCP_SERVER_NAME", server_name or f"napistu-{env_profile}"
+    )
+
+    logger.info("Starting Napistu MCP Server")
+    logger.info(f"  Profile: {env_profile}")
+    logger.info(f"  Host: {env_host}")
+    logger.info(f"  Port: {env_port}")
+    logger.info(f"  Server Name: {env_server_name}")
+    logger.info("  Transport: streamable-http")
+
+    # Create session context for execution components
+    session_context = {}
+    object_registry = {}
+
+    # Get profile with configuration
+    profile: ServerProfile = get_profile(
+        env_profile,
+        session_context=session_context,
+        object_registry=object_registry,
+        server_name=env_server_name,
+    )
+
+    # Create server
+    mcp = create_server(profile, host=env_host, port=env_port)
+
+    # Initialize components first (separate async call)
+    async def init_components():
+        logger.info("Initializing MCP components...")
+        await initialize_components(profile)
+        logger.info("✅ Component initialization complete")
+
+    # Run initialization
+    asyncio.run(init_components())
+
+    # Debug info
+    logger.info(f"Server settings: {mcp.settings}")
+
+    logger.info("🚀 Starting MCP server...")
+    logger.info(f"Using HTTP transport on http://{env_host}:{env_port}")
+    mcp.run(transport="streamable-http")

{napistu-0.2.4.dev5.dist-info → napistu-0.2.5.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: napistu
-Version: 0.2.4.dev5
+Version: 0.2.5.dev2
 Summary: Connecting high-dimensional data to curated pathways
 Home-page: https://github.com/napistu/napistu-py
 Author: Sean Hackett

{napistu-0.2.4.dev5.dist-info → napistu-0.2.5.dev2.dist-info}/RECORD

@@ -26,15 +26,17 @@ napistu/ingestion/string.py,sha256=tsaHrjppgFbl9NnRcB2DytpoontqrpfQL65zD9HPgEM,1
 napistu/ingestion/trrust.py,sha256=ccjZc_eF3PdxxurnukiEo_e0-aKc_3z22NYbaJBtHdY,9774
 napistu/ingestion/yeast.py,sha256=bwFBNxRq-dLDaddgBL1hpfZj0eQ56nBXyR_9n0NZT9Y,5233
 napistu/mcp/__init__.py,sha256=gDkP4J4vAjgq96_760lXKDURPUpQxVIxaRO9XzYrqdA,1970
-napistu/mcp/__main__.py,sha256=LzCbgk07XXk0R3JSzcxI2gSX3hZ9a389qt8xujPJR7E,5335
+napistu/mcp/__main__.py,sha256=UcxLERiTFp7H8OvA5bQ1KhCnmOQKp1DsQ4oYr5WFVw0,6410
+napistu/mcp/client.py,sha256=nTMKgEG-yEGM0bS54LXK85jVtlJvDXOniWsQbnj4FOI,6616
 napistu/mcp/codebase.py,sha256=H32R5vRJqsLpClURIUpemTO8F_YnFW1RDdaeEbYWotk,5674
 napistu/mcp/codebase_utils.py,sha256=r1nbDmGzq-NaH9cT11jC53mEjszQpwQ0uZUJkMHvgVs,10567
 napistu/mcp/constants.py,sha256=s0anHxVre6i6JYFQimB_ppRLDdqiCxbMHNVEYvf6O0U,2852
 napistu/mcp/documentation.py,sha256=L99GF5ilhq7CpzYkRy2BeOzKVQnolK_S9wqf8ChZY2Y,5216
 napistu/mcp/documentation_utils.py,sha256=JH3BfVk2dpSLUvnC77iaeTIRknOBpNMBQ2qhquUhuJM,7099
 napistu/mcp/execution.py,sha256=cYhLzIvihtLjG4J195FZuCM8uVihtgW-R6J4zuPAY5s,12422
+napistu/mcp/health.py,sha256=l6Y8houdip7IOtYZ_pPJrFAFfynN6PntVJwdkcoQKmg,8249
 napistu/mcp/profiles.py,sha256=Nbr1e-n7muJMcY0HxuEJQePUQWPM2koQ9roVLEZa7Pg,2027
-napistu/mcp/server.py,sha256=Igl4SL3KIuWyByBahHz1K3TQ2Zk1rLbszofHULoHPWs,2649
+napistu/mcp/server.py,sha256=R-8BrBccT-bpc3OoKk1TY9wBZek4EUyE_5VDHCAou9c,6010
 napistu/mcp/tutorials.py,sha256=QMX32aWaqRqj4vIc_PVDdT_t55ZBpw4xOWnfQyewZMk,3395
 napistu/mcp/tutorials_utils.py,sha256=6_s6FP2i8Na6VaKVzLDnSnA5JQVgyd3ZHEIz8HSHtzU,6599
 napistu/mcp/utils.py,sha256=WB4c6s8aPZLgi_Wvhhq0DE8Cnz2QGff0V8hrF1feVRg,1296
@@ -57,7 +59,7 @@ napistu/rpy2/callr.py,sha256=76ICWj7Jso-qrYLNfiV-DgPyrMTdRXz_EhyGOD9CbFM,4301
 napistu/rpy2/constants.py,sha256=JpJqsxImZis8fFFfePXYdbkhUZhXDZoHSHVf92w1h8U,2619
 napistu/rpy2/netcontextr.py,sha256=fZKd3NXXu5nfB-z0UW6wedxBkZA8dJ4uB1uOD9wI_eg,16523
 napistu/rpy2/rids.py,sha256=lKyOujjdosuN-Oc54uCQI1nKchTx4zXPwgFbG7QX7d8,24153
-napistu-0.2.4.dev5.dist-info/licenses/LICENSE,sha256=kW8wVT__JWoHjl2BbbJDAZInWa9AxzJeR_uv6-i5x1g,1063
+napistu-0.2.5.dev2.dist-info/licenses/LICENSE,sha256=kW8wVT__JWoHjl2BbbJDAZInWa9AxzJeR_uv6-i5x1g,1063
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/conftest.py,sha256=Xj5PWhedsR7HELbJfBY5XXzv_BAHbFMc1K2n6Nrbrno,2595
 tests/test_consensus.py,sha256=3dJvvPsPG7bHbw_FY4Pm647N_Gt_Ud9157OKYfPCUd4,9502
@@ -88,8 +90,8 @@ tests/test_uncompartmentalize.py,sha256=nAk5kfAVLU9a2VWe2x2HYVcKqj-EnwmwddERIPRa
 tests/test_utils.py,sha256=B9frW_ugWtGWsM-q7Lw7pnfE9a_d6LZTow9BrWU9UDw,17939
 tests/utils.py,sha256=SoWQ_5roJteFGcMaOeEiQ5ucwq3Z2Fa3AAs9iXHTsJY,749
 tests/test_data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-napistu-0.2.4.dev5.dist-info/METADATA,sha256=09rdIg_WphTdSr584QI52OE7HiB-P9LLNsTsdP5JaMA,3202
-napistu-0.2.4.dev5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-napistu-0.2.4.dev5.dist-info/entry_points.txt,sha256=_QnaPOvJNA3IltxmZgWIiBoen-L1bPYX18YQfC7oJgQ,41
-napistu-0.2.4.dev5.dist-info/top_level.txt,sha256=Gpvk0a_PjrtqhYcQ9IDr3zR5LqpZ-uIHidQMIpjlvhY,14
-napistu-0.2.4.dev5.dist-info/RECORD,,
+napistu-0.2.5.dev2.dist-info/METADATA,sha256=v4bFzaxkUVXkyLwn5UDJYIdBf1d2e7tVNw0TO68xXeU,3202
+napistu-0.2.5.dev2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+napistu-0.2.5.dev2.dist-info/entry_points.txt,sha256=_QnaPOvJNA3IltxmZgWIiBoen-L1bPYX18YQfC7oJgQ,41
+napistu-0.2.5.dev2.dist-info/top_level.txt,sha256=Gpvk0a_PjrtqhYcQ9IDr3zR5LqpZ-uIHidQMIpjlvhY,14
+napistu-0.2.5.dev2.dist-info/RECORD,,