rowan-mcp 1.0.2__py3-none-any.whl → 2.0.1__py3-none-any.whl

rowan_mcp/functions_v2/workflow_management_v2.py

@@ -0,0 +1,382 @@
+"""
+Rowan v2 API: Workflow Management Tools
+MCP tools for interacting with Workflow objects returned by v2 API submission functions.
+"""
+
+from typing import Dict, Any, List, Annotated
+import rowan
+
+
+def workflow_get_status(
+    workflow_uuid: Annotated[str, "UUID of the workflow to check status"]
+) -> Dict[str, Any]:
+    """Get the current status of a workflow.
+    
+    Args:
+        workflow_uuid: UUID of the workflow to check status
+    
+    Returns:
+        Dictionary with status information
+    """
+    workflow = rowan.retrieve_workflow(workflow_uuid)
+    status = workflow.get_status()
+    
+    return {
+        "uuid": workflow_uuid,
+        "status": status,
+        "name": workflow.name,
+        "is_finished": workflow.is_finished()
+    }
+
+
+def workflow_wait_for_result(
+    workflow_uuid: Annotated[str, "UUID of the workflow to wait for completion"],
+    poll_interval: Annotated[int, "Seconds between status checks while waiting"] = 5
+) -> Dict[str, Any]:
+    """Wait for a workflow to complete and return the result.
+    
+    Args:
+        workflow_uuid: UUID of the workflow to wait for completion
+        poll_interval: Seconds between status checks while waiting
+    
+    Essential for chaining dependent workflows where subsequent calculations 
+    require results from previous ones. Blocks execution until the workflow 
+    completes, then returns the full results.
+    
+    Common use cases:
+    - Conformer search → Redox potential for each conformer
+    - Optimization → Frequency calculation on optimized geometry
+    - Multiple sequential optimizations with different methods
+    - Any workflow chain where results feed into next calculation
+    
+    Example workflow chain:
+        1. Submit conformer search
+        2. Wait for conformer search to complete (using this function)
+        3. Extract conformer geometries from results
+        4. Submit new workflows using those geometries
+    
+    Returns:
+        Dictionary containing the completed workflow data including results
+        needed for dependent workflows (e.g., conformer_uuids, optimized
+        geometries, calculation_uuids)
+    """
+    workflow = rowan.retrieve_workflow(workflow_uuid)
+    
+    # Use the built-in wait_for_result method
+    workflow.wait_for_result(poll_interval=poll_interval)
+    
+    # Return complete workflow data
+    return {
+        "uuid": workflow.uuid,
+        "status": workflow.status,
+        "name": workflow.name,
+        "created_at": workflow.created_at,
+        "updated_at": workflow.updated_at,
+        "completed_at": workflow.completed_at,
+        "parent_uuid": workflow.parent_uuid,
+        "workflow_type": workflow.workflow_type,
+        "data": workflow.data,
+        "credits_charged": workflow.credits_charged,
+        "elapsed": workflow.elapsed
+    }
+
+
+def workflow_stop(
+    workflow_uuid: Annotated[str, "UUID of the running workflow to stop"]
+) -> Dict[str, str]:
+    """Stop a running workflow.
+    
+    Args:
+        workflow_uuid: UUID of the running workflow to stop
+    
+    Returns:
+        Dictionary with confirmation message
+    """
+    workflow = rowan.retrieve_workflow(workflow_uuid)
+    workflow.stop()
+    
+    return {
+        "message": f"Workflow {workflow_uuid} stop request submitted",
+        "uuid": workflow_uuid
+    }
+
+
+def workflow_delete(
+    workflow_uuid: Annotated[str, "UUID of the workflow to permanently delete"]
+) -> Dict[str, str]:
+    """Delete a workflow.
+    
+    Args:
+        workflow_uuid: UUID of the workflow to permanently delete
+    
+    This permanently removes the workflow and its results from the database.
+    
+    Returns:
+        Dictionary with confirmation message
+    """
+    workflow = rowan.retrieve_workflow(workflow_uuid)
+    workflow.delete()
+    
+    return {
+        "message": f"Workflow {workflow_uuid} deleted successfully",
+        "uuid": workflow_uuid
+    }
+
+
+def workflow_fetch_latest(
+    workflow_uuid: Annotated[str, "UUID of the workflow to fetch latest data"],
+    in_place: Annotated[bool, "Whether to update the workflow object in place"] = False
+) -> Dict[str, Any]:
+    """Fetch the latest workflow data from the database.
+    
+    Args:
+        workflow_uuid: UUID of the workflow to fetch latest data
+        in_place: Whether to update the workflow object in place
+    
+    Updates the workflow object with the most recent status and results.
+    
+    Returns:
+        Dictionary containing the updated workflow data including status and results
+    """
+    workflow = rowan.retrieve_workflow(workflow_uuid)
+    
+    # Fetch latest updates
+    workflow.fetch_latest(in_place=in_place)
+    
+    # Return workflow data as dict
+    return {
+        "uuid": workflow.uuid,
+        "status": workflow.status,
+        "name": workflow.name,
+        "created_at": workflow.created_at,
+        "updated_at": workflow.updated_at,
+        "started_at": workflow.started_at,
+        "completed_at": workflow.completed_at,
+        "parent_uuid": workflow.parent_uuid,
+        "workflow_type": workflow.workflow_type,
+        "data": workflow.data,
+        "notes": workflow.notes,
+        "starred": workflow.starred,
+        "public": workflow.public,
+        "credits_charged": workflow.credits_charged,
+        "elapsed": workflow.elapsed
+    }
+
+
+def retrieve_workflow(
+    uuid: Annotated[str, "UUID of the workflow to retrieve"]
+) -> Dict[str, Any]:
+    """Retrieve a workflow from the API.
+    
+    Args:
+        uuid: UUID of the workflow to retrieve
+    
+    Returns:
+        Dictionary containing the complete workflow data
+        
+    Raises:
+        HTTPError: If the API request fails
+    """
+    workflow = rowan.retrieve_workflow(uuid)
+    
+    # Convert workflow object to dict
+    return {
+        "uuid": workflow.uuid,
+        "status": workflow.status,
+        "name": workflow.name,
+        "created_at": workflow.created_at,
+        "updated_at": workflow.updated_at,
+        "started_at": workflow.started_at,
+        "completed_at": workflow.completed_at,
+        "parent_uuid": workflow.parent_uuid,
+        "workflow_type": workflow.workflow_type,
+        "data": workflow.data,
+        "notes": workflow.notes,
+        "starred": workflow.starred,
+        "public": workflow.public,
+        "email_when_complete": workflow.email_when_complete,
+        "max_credits": workflow.max_credits,
+        "elapsed": workflow.elapsed,
+        "credits_charged": workflow.credits_charged
+    }
+
+
+def list_workflows(
+    parent_uuid: Annotated[str, "UUID of parent folder to filter by. Empty string for all folders"] = "",
+    name_contains: Annotated[str, "Substring to search for in workflow names. Empty string for all names"] = "",
+    public: Annotated[str, "Filter by public status ('true'/'false'). Empty string for both"] = "",
+    starred: Annotated[str, "Filter by starred status ('true'/'false'). Empty string for both"] = "",
+    status: Annotated[str, "Filter by workflow status code. Empty string for all statuses"] = "",
+    workflow_type: Annotated[str, "Filter by workflow type (e.g., 'conformer_search', 'pka'). Empty string for all types"] = "",
+    page: Annotated[int, "Page number for pagination (0-indexed)"] = 0,
+    size: Annotated[int, "Number of workflows per page"] = 10
+):
+    """List workflows subject to the specified criteria.
+    
+    Args:
+        parent_uuid: UUID of parent folder to filter by. Empty string for all folders
+        name_contains: Substring to search for in workflow names. Empty string for all names
+        public: Filter by public status ("true"/"false"). Empty string for both
+        starred: Filter by starred status ("true"/"false"). Empty string for both
+        status: Filter by workflow status code. Empty string for all statuses
+        workflow_type: Filter by workflow type (e.g., 'conformer_search', 'pka'). Empty string for all types
+        page: Page number for pagination (0-indexed)
+        size: Number of workflows per page
+    
+    Returns:
+        List of workflow dictionaries that match the search criteria
+        
+    Raises:
+        HTTPError: If the request to the API fails
+    """
+    # Use direct API call to avoid Workflow validation issues
+    with rowan.api_client() as client:
+        params = {
+            "page": page,
+            "size": size
+        }
+        
+        # Add non-empty filters
+        if parent_uuid:
+            params["parent_uuid"] = parent_uuid
+        if name_contains:
+            params["name_contains"] = name_contains
+        if public:
+            params["public"] = public.lower() == "true"
+        if starred:
+            params["starred"] = starred.lower() == "true"
+        if status:
+            params["object_status"] = int(status)
+        if workflow_type:
+            params["object_type"] = workflow_type
+        
+        response = client.get("/workflow", params=params)
+        response.raise_for_status()
+        
+        data = response.json()
+        # Extract workflows from the paginated response
+        return data.get("workflows", [])
+
+
+def retrieve_calculation_molecules(
+    uuid: Annotated[str, "UUID of the calculation to retrieve molecules from"]
+) -> List[Dict[str, Any]]:
+    """Retrieve a list of molecules from a calculation.
+    
+    Args:
+        uuid: UUID of the calculation to retrieve molecules from
+    
+    Returns:
+        List of dictionaries representing the molecules in the calculation
+        
+    Raises:
+        HTTPError: If the API request fails
+    """
+    molecules = rowan.retrieve_calculation_molecules(uuid)
+    
+    # Convert molecules to list of dicts
+    result = []
+    for mol in molecules:
+        mol_dict = {
+            "smiles": mol.get("smiles"),
+            "name": mol.get("name"),
+            "charge": mol.get("charge"),
+            "multiplicity": mol.get("multiplicity"),
+            "energy": mol.get("energy"),
+            "coordinates": mol.get("coordinates"),
+            "properties": mol.get("properties", {})
+        }
+        # Remove None values
+        mol_dict = {k: v for k, v in mol_dict.items() if v is not None}
+        result.append(mol_dict)
+    
+    return result
+
+
+def workflow_update(
+    workflow_uuid: Annotated[str, "UUID of the workflow to update"],
+    name: Annotated[str, "New name for the workflow. Empty string to keep current name"] = "",
+    notes: Annotated[str, "New notes/description for the workflow. Empty string to keep current notes"] = "",
+    starred: Annotated[str, "Set starred status ('true'/'false'). Empty string to keep current status"] = "",
+    public: Annotated[str, "Set public visibility ('true'/'false'). Empty string to keep current status"] = ""
+) -> Dict[str, Any]:
+    """Update workflow details.
+    
+    Args:
+        workflow_uuid: UUID of the workflow to update
+        name: New name for the workflow. Empty string to keep current name
+        notes: New notes/description for the workflow. Empty string to keep current notes
+        starred: Set starred status ("true"/"false"). Empty string to keep current status
+        public: Set public visibility ("true"/"false"). Empty string to keep current status
+    
+    Returns:
+        Dictionary with updated workflow information
+    """
+    workflow = rowan.retrieve_workflow(workflow_uuid)
+    
+    # Parse string boolean inputs
+    parsed_starred = None
+    if starred:
+        parsed_starred = starred.lower() == "true"
+    
+    parsed_public = None
+    if public:
+        parsed_public = public.lower() == "true"
+    
+    # Update the workflow
+    workflow.update(
+        name=name if name else None,
+        notes=notes if notes else None,
+        starred=parsed_starred,
+        public=parsed_public
+    )
+    
+    return {
+        "uuid": workflow.uuid,
+        "name": workflow.name,
+        "notes": workflow.notes,
+        "starred": workflow.starred,
+        "public": workflow.public,
+        "message": "Workflow updated successfully"
+    }
+
+
+def workflow_is_finished(
+    workflow_uuid: Annotated[str, "UUID of the workflow to check completion status"]
+) -> Dict[str, Any]:
+    """Check if a workflow is finished.
+    
+    Args:
+        workflow_uuid: UUID of the workflow to check completion status
+    
+    Returns:
+        Dictionary with workflow completion status
+    """
+    workflow = rowan.retrieve_workflow(workflow_uuid)
+    
+    return {
+        "uuid": workflow_uuid,
+        "is_finished": workflow.is_finished(),
+        "status": workflow.status,
+        "name": workflow.name
+    }
+
+
+def workflow_delete_data(
+    workflow_uuid: Annotated[str, "UUID of the workflow whose data to delete (keeps workflow record)"]
+) -> Dict[str, str]:
+    """Delete workflow data while keeping the workflow record.
+    
+    Args:
+        workflow_uuid: UUID of the workflow whose data to delete (keeps workflow record)
+    
+    Returns:
+        Dictionary with confirmation message
+    """
+    workflow = rowan.retrieve_workflow(workflow_uuid)
+    workflow.delete_data()
+    
+    return {
+        "message": f"Data for workflow {workflow_uuid} deleted successfully",
+        "uuid": workflow_uuid
+    }

rowan_mcp/server.py

@@ -1,169 +1,134 @@
 """
 Rowan MCP Server Implementation using FastMCP
-
-This module implements the Model Context Protocol server for Rowan's
-computational chemistry platform using the FastMCP framework.
-Supports both STDIO and HTTP transports.
 """
 
 import os
 import sys
-import time
-import traceback
-from typing import Any, Dict, List, Optional, Literal, Union
-from enum import Enum
-
 from fastmcp import FastMCP
-from pydantic import BaseModel, Field
-from stjames import Molecule
-
-# Import functions from functions module
-from .functions.scan import rowan_scan as scan_function
-from .functions.scan_analyzer import rowan_scan_analyzer as scan_analyzer_function
-from .functions.admet import rowan_admet as admet_function
-
-from .functions.multistage_opt import rowan_multistage_opt as multistage_opt_function
-from .functions.descriptors import rowan_descriptors as descriptors_function
-from .functions.tautomers import rowan_tautomers as tautomers_function
-
-from .functions.redox_potential import rowan_redox_potential as redox_potential_function
-from .functions.conformers import rowan_conformers as conformers_function
-from .functions.electronic_properties import rowan_electronic_properties as electronic_properties_function
-from .functions.fukui import rowan_fukui as fukui_function
-from .functions.spin_states import rowan_spin_states as spin_states_function
-from .functions.solubility import rowan_solubility as solubility_function
-from .functions.molecular_dynamics import rowan_molecular_dynamics as molecular_dynamics_function
-from .functions.irc import rowan_irc as irc_function
-from .functions.docking import rowan_docking as docking_function, rowan_docking_pdb_id as docking_pdb_id_function
-from .functions.docking_enhanced import rowan_docking_enhanced as docking_enhanced_function
-from .functions.workflow_management import rowan_workflow_management as workflow_management_function
-# from .functions.calculation_retrieve import rowan_calculation_retrieve as calculation_retrieve_function
-from .functions.pka import rowan_pka as pka_function
-from .functions.macropka import rowan_macropka as macropka_function
-from .functions.hydrogen_bond_basicity import rowan_hydrogen_bond_basicity as hydrogen_bond_basicity_function
-from .functions.bde import rowan_bde as bde_function
-from .functions.folder_management import rowan_folder_management as folder_management_function
-from .functions.system_management import rowan_system_management as system_management_function
-
-# Import molecule lookup from functions
-from .functions.molecule_lookup import rowan_molecule_lookup as molecule_lookup_function
 
-try:
-    import rowan
-except ImportError:
-    rowan = None
+
+# Import v2 API functions
+from .functions_v2.submit_basic_calculation_workflow import submit_basic_calculation_workflow
+from .functions_v2.submit_conformer_search_workflow import submit_conformer_search_workflow
+from .functions_v2.submit_solubility_workflow import submit_solubility_workflow
+from .functions_v2.submit_pka_workflow import submit_pka_workflow
+from .functions_v2.submit_redox_potential_workflow import submit_redox_potential_workflow
+from .functions_v2.submit_fukui_workflow import submit_fukui_workflow
+from .functions_v2.submit_tautomer_search_workflow import submit_tautomer_search_workflow
+from .functions_v2.submit_descriptors_workflow import submit_descriptors_workflow
+from .functions_v2.submit_scan_workflow import submit_scan_workflow
+from .functions_v2.submit_irc_workflow import submit_irc_workflow
+from .functions_v2.submit_protein_cofolding_workflow import submit_protein_cofolding_workflow
+from .functions_v2.submit_docking_workflow import submit_docking_workflow
+from .functions_v2.submit_macropka_workflow import submit_macropka_workflow
+
+# Import molecule lookup functions
+from .functions_v2.molecule_lookup import (
+    molecule_lookup,
+    batch_molecule_lookup,
+    validate_smiles
+)
+
+# Import workflow management functions
+from .functions_v2.workflow_management_v2 import (
+    workflow_fetch_latest,
+    workflow_wait_for_result,
+    workflow_get_status,
+    workflow_stop,
+    workflow_delete,
+    retrieve_workflow,
+    retrieve_calculation_molecules,
+    list_workflows,
+    workflow_update,
+    workflow_is_finished,
+    workflow_delete_data
+)
+
+# Import protein management functions
+from .functions_v2.protein_management import (
+    create_protein_from_pdb_id,
+    retrieve_protein,
+    list_proteins,
+    upload_protein,
+    delete_protein,
+    sanitize_protein
+)
 
 try:
     from dotenv import load_dotenv
-    load_dotenv()  # Load .env file if available
+    load_dotenv()
 except ImportError:
-    pass  # dotenv not required, but helpful if available
+    pass
 
 # Initialize FastMCP server
 mcp = FastMCP("Rowan MCP Server")
 
-# Register imported functions as MCP tools
-rowan_scan = mcp.tool()(scan_function)
-rowan_scan_analyzer = mcp.tool()(scan_analyzer_function)
-rowan_admet = mcp.tool()(admet_function)
-
-rowan_multistage_opt = mcp.tool()(multistage_opt_function)
-rowan_descriptors = mcp.tool()(descriptors_function)
-rowan_tautomers = mcp.tool()(tautomers_function)
-
-rowan_redox_potential = mcp.tool()(redox_potential_function)
-rowan_conformers = mcp.tool()(conformers_function)
-rowan_electronic_properties = mcp.tool()(electronic_properties_function)
-rowan_fukui = mcp.tool()(fukui_function)
-rowan_spin_states = mcp.tool()(spin_states_function)
-rowan_solubility = mcp.tool()(solubility_function)
-rowan_molecular_dynamics = mcp.tool()(molecular_dynamics_function)
-rowan_irc = mcp.tool()(irc_function)
-rowan_docking = mcp.tool()(docking_function)
-rowan_docking_pdb_id = mcp.tool()(docking_pdb_id_function)
-rowan_docking_enhanced = mcp.tool()(docking_enhanced_function)
-rowan_workflow_management = mcp.tool()(workflow_management_function)
-# rowan_calculation_retrieve = mcp.tool()(calculation_retrieve_function)
-rowan_molecule_lookup = mcp.tool()(molecule_lookup_function)
-rowan_pka = mcp.tool()(pka_function)
-rowan_macropka = mcp.tool()(macropka_function)
-rowan_hydrogen_bond_basicity = mcp.tool()(hydrogen_bond_basicity_function)
-rowan_bde = mcp.tool()(bde_function)
-rowan_folder_management = mcp.tool()(folder_management_function)
-rowan_system_management = mcp.tool()(system_management_function)
-
-# Setup API key
-api_key = os.getenv("ROWAN_API_KEY")
-if not api_key:
+# Register v2 API tools
+mcp.tool()(submit_basic_calculation_workflow)
+mcp.tool()(submit_conformer_search_workflow)
+mcp.tool()(submit_solubility_workflow)
+mcp.tool()(submit_pka_workflow)
+mcp.tool()(submit_redox_potential_workflow)
+mcp.tool()(submit_fukui_workflow)
+mcp.tool()(submit_tautomer_search_workflow)
+mcp.tool()(submit_descriptors_workflow)
+mcp.tool()(submit_scan_workflow)
+mcp.tool()(submit_irc_workflow)
+mcp.tool()(submit_protein_cofolding_workflow)
+mcp.tool()(submit_docking_workflow)
+mcp.tool()(submit_macropka_workflow)
+
+# Register molecule lookup tools
+mcp.tool()(molecule_lookup)
+mcp.tool()(batch_molecule_lookup)
+mcp.tool()(validate_smiles)
+
+# Register workflow management tools
+mcp.tool()(workflow_fetch_latest)
+mcp.tool()(workflow_wait_for_result)
+mcp.tool()(workflow_get_status)
+mcp.tool()(workflow_stop)
+mcp.tool()(workflow_delete)
+mcp.tool()(retrieve_workflow)
+mcp.tool()(retrieve_calculation_molecules)
+mcp.tool()(list_workflows)
+mcp.tool()(workflow_update)
+mcp.tool()(workflow_is_finished)
+mcp.tool()(workflow_delete_data)
+
+# Register protein management tools
+mcp.tool()(create_protein_from_pdb_id)
+mcp.tool()(retrieve_protein)
+mcp.tool()(list_proteins)
+mcp.tool()(upload_protein)
+mcp.tool()(delete_protein)
+mcp.tool()(sanitize_protein)
+
+# Validate required configuration
+if not os.getenv("ROWAN_API_KEY"):
     raise ValueError(
         "ROWAN_API_KEY environment variable is required. "
         "Get your API key from https://labs.rowansci.com"
     )
 
-if rowan is None:
-    raise ImportError(
-        "rowan-python package is required. Install with: pip install rowan-python"
-    )
-
-rowan.api_key = api_key
 
 def main() -> None:
-    """Main entry point for the MCP server."""
-    try:
-        # Check for transport mode from command line args or environment
-        transport_mode = os.getenv("ROWAN_MCP_TRANSPORT", "stdio").lower()
-        
-        # Allow override from command line
-        if len(sys.argv) > 1:
-            if sys.argv[1] == "--http":
-                transport_mode = "http"
-            elif sys.argv[1] == "--stdio":
-                transport_mode = "stdio"
-            elif sys.argv[1] == "--help":
-                print("Rowan MCP Server")
-                print("Usage:")
-                print("  rowan-mcp                      # Default STDIO transport")
-                print("  rowan-mcp --stdio              # STDIO transport")
-                print("  rowan-mcp --http               # HTTP/SSE transport")
-                print("")
-                print("Development usage:")
-                print("  python -m rowan_mcp            # Default STDIO transport")
-                print("  python -m rowan_mcp --stdio    # STDIO transport")
-                print("  python -m rowan_mcp --http     # HTTP/SSE transport")
-                print("")
-                print("Environment variables:")
-                print("  ROWAN_API_KEY                  # Required: Your Rowan API key")
-                print("  ROWAN_MCP_TRANSPORT            # Optional: 'stdio' or 'http' (default: stdio)")
-                print("  ROWAN_MCP_HOST                 # Optional: HTTP host (default: 127.0.0.1)")
-                print("  ROWAN_MCP_PORT                 # Optional: HTTP port (default: 6276)")
-                print("")
-                print("HTTP/SSE mode endpoint: http://host:port/sse")
-                return
-        
-        if transport_mode == "http":
-            host = os.getenv("ROWAN_MCP_HOST", "127.0.0.1")
-            port = int(os.getenv("ROWAN_MCP_PORT", "6276"))
-            
-            print("🚀 Starting Rowan MCP Server (HTTP/SSE mode)")
-            print(f"📡 Server will be available at: http://{host}:{port}/sse")
-            print(f"🔑 API Key loaded: {'✓' if api_key else '✗'}")
-            print(f"🛠️  Available tools: {len([attr for attr in dir() if attr.startswith('rowan_')])}")
-            print("🔗 Connect your MCP client to this endpoint!")
-            print("\nPress Ctrl+C to stop the server")
-            
-            mcp.run(transport="sse", host=host, port=port)
-        else:
-            print("🚀 Starting Rowan MCP Server (STDIO mode)")
-            print(f"🔑 API Key loaded: {'✓' if api_key else '✗'}")
-            print(f"🛠️  Available tools: {len([attr for attr in dir() if attr.startswith('rowan_')])}")
-            
-            mcp.run()  # Default STDIO transport
-            
-    except KeyboardInterrupt:
-        print("\n👋 Server shutdown requested by user")
-    except Exception as e:
-        print(f"❌ Server error: {e}")
-        traceback.print_exc()
+    """Main entry point for the HTTP MCP server."""
+    if len(sys.argv) > 1 and sys.argv[1] == "--help":
+        print("Rowan MCP Server")
+        print("Usage: rowan-mcp")
+        print("Environment variables:")
+        print("  ROWAN_API_KEY    # Required: Your Rowan API key")
+        print("  ROWAN_MCP_HOST   # Optional: HTTP host (default: 127.0.0.1)")
+        print("  ROWAN_MCP_PORT   # Optional: HTTP port (default: 6276)")
+        return
+    
+    host = os.getenv("ROWAN_MCP_HOST", "127.0.0.1")
+    port = int(os.getenv("ROWAN_MCP_PORT", "6276"))
+    
+    print(f"Starting Rowan MCP Server at http://{host}:{port}/sse")
+    
+    mcp.run(transport="sse", host=host, port=port)
 
 if __name__ == "__main__":
-    main() 
+    main()