rowan-mcp 0.1.0__py3-none-any.whl

rowan_mcp/functions/workflow_management.py

@@ -0,0 +1,422 @@
+"""
+Rowan workflow management functions for MCP tool integration.
+"""
+
+from typing import Optional, Dict, Any, Union, List, Literal
+import rowan
+
+def safe_get_attr(obj, attr: str, default=None):
+    """Safely get an attribute from an object, returning default if it doesn't exist."""
+    try:
+        return getattr(obj, attr, default)
+    except (AttributeError, TypeError):
+        return default
+
+def rowan_workflow_management(
+    action: Literal['create', 'retrieve', 'update', 'stop', 'status', 'is_finished', 'delete', 'list'],
+    workflow_uuid: Optional[str] = None,
+    name: Optional[str] = None,
+    workflow_type: Optional[str] = None,
+    initial_molecule: Optional[str] = None,
+    parent_uuid: Optional[str] = None,
+    notes: Optional[str] = None,
+    starred: Optional[bool] = None,
+    public: Optional[bool] = None,
+    email_when_complete: Optional[bool] = None,
+    workflow_data: Optional[Dict[str, Any]] = None,
+    name_contains: Optional[str] = None,
+    object_status: Optional[int] = None,
+    object_type: Optional[str] = None,
+    page: int = 0,
+    size: int = 50
+) -> str:
+    """Unified workflow management tool for all workflow operations. Available actions: create, retrieve, update, stop, status, is_finished, delete, list.
+    
+    **Available Actions:**
+    - **create**: Create a new workflow (requires: name, workflow_type, initial_molecule)
+    - **retrieve**: retrieve workflow details (requires: workflow_uuid)
+    - **update**: Update workflow properties (requires: workflow_uuid, optional: name, parent_uuid, notes, starred, public, email_when_complete)
+    - **stop**: Stop a running workflow (requires: workflow_uuid)
+    - **status**: Check workflow status (requires: workflow_uuid)
+    - **is_finished**: Check if workflow is finished (requires: workflow_uuid)
+    - **delete**: Delete a workflow (requires: workflow_uuid)
+    - **list**: List workflows with filters (optional: name_contains, parent_uuid, starred, public, object_status, object_type, page, size)
+    
+    Args:
+        action: Action to perform - must be one of: 'create', 'retrieve', 'update', 'stop', 'status', 'is_finished', 'delete', 'list'
+        workflow_uuid: UUID of the workflow (required for retrieve, update, stop, status, is_finished, delete)
+        name: Workflow name (required for create, optional for update)
+        workflow_type: Type of workflow (required for create)
+        initial_molecule: Initial molecule SMILES (required for create)
+        parent_uuid: Parent folder UUID (optional for create/update)
+        notes: Workflow notes (optional for create/update)
+        starred: Star the workflow (optional for create/update)
+        public: Make workflow public (optional for create/update)
+        email_when_complete: Email when complete (optional for create/update)
+        workflow_data: Additional workflow data (optional for create)
+        name_contains: Filter by name containing text (optional for list)
+        object_status: Filter by status (0=queued, 1=running, 2=completed, 3=failed, 4=stopped, optional for list)
+        object_type: Filter by workflow type (optional for list)
+        page: Page number for pagination (default: 1, for list)
+        size: Results per page (default: 50, for list)
+    
+    Returns:
+        Results of the workflow operation
+    """
+    
+    action = action.lower()
+    
+    try:
+        if action == "create":
+            if not all([name, workflow_type, initial_molecule]):
+                return " Error: 'name', 'workflow_type', and 'initial_molecule' are required for creating a workflow"
+            
+            # Validate workflow type
+            VALID_WORKFLOWS = {
+                "admet", "basic_calculation", "conformer_search", "descriptors", 
+                "docking", "electronic_properties", "fukui", 
+                "irc", "molecular_dynamics", "multistage_opt", "pka", "redox_potential", 
+                "scan", "solubility", "spin_states", "tautomers"
+            }
+            
+            if workflow_type not in VALID_WORKFLOWS:
+                error_msg = f" Invalid workflow_type '{workflow_type}'.\n\n"
+                error_msg += " **Available Rowan Workflow Types:**\n"
+                error_msg += f"{', '.join(sorted(VALID_WORKFLOWS))}"
+                return error_msg
+            
+            workflow = rowan.Workflow.create(
+                name=name,
+                workflow_type=workflow_type,
+                initial_molecule=initial_molecule,
+                parent_uuid=parent_uuid,
+                notes=notes or "",
+                starred=starred or False,
+                public=public or False,
+                email_when_complete=email_when_complete or False,
+                workflow_data=workflow_data or {}
+            )
+            
+            formatted = f" Workflow '{name}' created successfully!\n\n"
+            formatted += f" UUID: {safe_get_attr(workflow, 'uuid', 'N/A')}\n"
+            formatted += f" Type: {workflow_type}\n"
+            formatted += f" Status: {safe_get_attr(workflow, 'object_status', 'Unknown')}\n"
+            formatted += f" Created: {safe_get_attr(workflow, 'created_at', 'N/A')}\n"
+            return formatted
+            
+        elif action == "retrieve":
+            if not workflow_uuid:
+                return " Error: 'workflow_uuid' is required for retrieving a workflow"
+            
+            try:
+                workflow = rowan.Workflow.retrieve(uuid=workflow_uuid)
+            except Exception as e:
+                return f" Error retrieving workflow: {str(e)}"
+            
+            # Handle workflow as dictionary (which is what Rowan API returns)
+            def safe_get_dict_value(data, key, default='N/A'):
+                """Safely get a value from a dictionary."""
+                if isinstance(data, dict):
+                    return data.get(key, default)
+                return safe_get_attr(data, key, default)
+            
+            # Get status and interpret it
+            status = safe_get_dict_value(workflow, 'object_status', 'Unknown')
+            status_names = {
+                0: "Queued",
+                1: "Running", 
+                2: "Completed",
+                3: "Failed",
+                4: "Stopped",
+                5: "Awaiting Queue"
+            }
+            status_name = status_names.get(status, f"Unknown ({status})")
+            
+            formatted = f" Workflow Details:\n\n"
+            formatted += f" Name: {safe_get_dict_value(workflow, 'name', 'N/A')}\n"
+            formatted += f" UUID: {safe_get_dict_value(workflow, 'uuid', 'N/A')}\n"
+            formatted += f" Type: {safe_get_dict_value(workflow, 'object_type', 'N/A')}\n"
+            formatted += f" Status: {status_name} ({status})\n"
+            formatted += f" Parent: {safe_get_dict_value(workflow, 'parent_uuid', 'Root')}\n"
+            formatted += f" Starred: {'Yes' if safe_get_dict_value(workflow, 'starred', False) else 'No'}\n"
+            formatted += f" Public: {'Yes' if safe_get_dict_value(workflow, 'public', False) else 'No'}\n"
+            formatted += f" Created: {safe_get_dict_value(workflow, 'created_at', 'N/A')}\n"
+            formatted += f" Elapsed: {safe_get_dict_value(workflow, 'elapsed', 0):.2f}s\n"
+            formatted += f" Credits: {safe_get_dict_value(workflow, 'credits_charged', 0)}\n"
+            formatted += f" Notes: {safe_get_dict_value(workflow, 'notes', 'None')}\n\n"
+            
+            # If workflow is completed (status 2), extract and show results
+            if status == 2:
+                formatted += f" **Workflow Completed Successfully!**\n\n"
+                
+                # Show basic completion details
+                credits_charged = safe_get_dict_value(workflow, 'credits_charged', 0)
+                elapsed_time = safe_get_dict_value(workflow, 'elapsed', 0)
+                if credits_charged or elapsed_time:
+                    formatted += f" Workflow used {credits_charged} credits and ran for {elapsed_time:.2f}s\n\n"
+                
+                # Debug: Show all available keys in the workflow dictionary
+                if isinstance(workflow, dict):
+                    workflow_keys = list(workflow.keys())
+                    formatted += f" **Debug - Available Workflow Keys:**\n"
+                    formatted += f" {', '.join(workflow_keys)}\n\n"
+                else:
+                    # Fallback for object-based workflows
+                    workflow_attrs = []
+                    for attr in dir(workflow):
+                        if not attr.startswith('_'):
+                            try:
+                                value = getattr(workflow, attr)
+                                if not callable(value):
+                                    workflow_attrs.append(attr)
+                            except:
+                                pass
+                    formatted += f" **Debug - Available Workflow Attributes:**\n"
+                    formatted += f" {', '.join(workflow_attrs)}\n\n"
+                
+                # Extract actual results from object_data
+                object_data = safe_get_dict_value(workflow, 'object_data', {})
+                workflow_type = safe_get_dict_value(workflow, 'object_type', '')
+                
+                formatted += f" **Results Analysis:**\n"
+                formatted += f" Workflow Type: {workflow_type}\n"
+                formatted += f" Object Data Present: {'Yes' if object_data else 'No'}\n"
+                
+                if object_data:
+                    formatted += f" Object Data Keys: {list(object_data.keys()) if isinstance(object_data, dict) else 'Not a dictionary'}\n\n"
+                    formatted += extract_workflow_results(workflow_type, object_data)
+                else:
+                    formatted += f" **No results data found in workflow object_data**\n"
+                    formatted += f" This could mean:\n"
+                    formatted += f" • The workflow completed but didn't generate data\n"
+                    formatted += f" • The results are stored in a different attribute\n"
+                    formatted += f" • There was an issue with the workflow execution\n"
+            
+            elif status == 1:  # Running
+                formatted += f" **Workflow is currently running...**\n"
+                formatted += f" Check back later or use `rowan_workflow_management(action='status', workflow_uuid='{workflow_uuid}')` for updates\n"
+            elif status == 0:  # Queued
+                formatted += f" **Workflow is queued and waiting to start**\n"
+                formatted += f" Use `rowan_workflow_management(action='status', workflow_uuid='{workflow_uuid}')` to check progress\n"
+            elif status == 3:  # Failed
+                formatted += f" **Workflow failed**\n"
+                formatted += f" Check the workflow details in the Rowan web interface for error messages\n"
+            elif status == 4:  # Stopped
+                formatted += f" **Workflow was stopped**\n"
+            
+            return formatted
+            
+        elif action == "update":
+            if not workflow_uuid:
+                return " Error: 'workflow_uuid' is required for updating a workflow"
+            
+            # Build update parameters according to Rowan API docs
+            update_params = {'uuid': workflow_uuid}
+            updates_made = []
+            
+            if name is not None:
+                update_params['name'] = name
+                updates_made.append(f"name: {name}")
+            if parent_uuid is not None:
+                update_params['parent_uuid'] = parent_uuid
+                updates_made.append(f"parent_uuid: {parent_uuid}")
+            if notes is not None:
+                update_params['notes'] = notes
+                updates_made.append(f"notes: {notes}")
+            if starred is not None:
+                update_params['starred'] = starred
+                updates_made.append(f"starred: {starred}")
+            if public is not None:
+                update_params['public'] = public
+                updates_made.append(f"public: {public}")
+            if email_when_complete is not None:
+                update_params['email_when_complete'] = email_when_complete
+                updates_made.append(f"email_when_complete: {email_when_complete}")
+            
+            if len(update_params) == 1:  # Only UUID provided
+                return " Error: At least one field must be provided for updating (name, parent_uuid, notes, starred, public, email_when_complete)"
+            
+            # Call Rowan API with correct parameter structure
+            workflow = rowan.Workflow.update(**update_params)
+            
+            # Format response using the returned workflow object
+            formatted = f" Workflow updated successfully!\n\n"
+            formatted += f" UUID: {safe_get_attr(workflow, 'uuid', workflow_uuid)}\n"
+            formatted += f" Name: {safe_get_attr(workflow, 'name', 'N/A')}\n"
+            formatted += f" Type: {safe_get_attr(workflow, 'object_type', 'N/A')}\n"
+            formatted += f" Parent: {safe_get_attr(workflow, 'parent_uuid', 'Root')}\n"
+            formatted += f" Starred: {'Yes' if safe_get_attr(workflow, 'starred', False) else 'No'}\n"
+            formatted += f" Public: {'Yes' if safe_get_attr(workflow, 'public', False) else 'No'}\n"
+            formatted += f" Email on Complete: {'Yes' if safe_get_attr(workflow, 'email_when_complete', False) else 'No'}\n"
+            formatted += f" Notes: {safe_get_attr(workflow, 'notes', 'None')}\n\n"
+            
+            formatted += f" **Updates Applied:**\n"
+            for update in updates_made:
+                formatted += f"• {update}\n"
+            
+            return formatted
+            
+        elif action in ["stop", "status", "is_finished"]:
+            if not workflow_uuid:
+                return f" Error: 'workflow_uuid' is required for {action} action"
+            
+            if action == "stop":
+                result = rowan.Workflow.stop(uuid=workflow_uuid)
+                return f" Workflow stop request submitted. Result: {result}"
+            elif action == "status":
+                workflow = rowan.Workflow.retrieve(uuid=workflow_uuid)
+                
+                # Handle workflow as dictionary
+                def safe_get_dict_value(data, key, default='N/A'):
+                    if isinstance(data, dict):
+                        return data.get(key, default)
+                    return safe_get_attr(data, key, default)
+                
+                status = safe_get_dict_value(workflow, 'object_status', 'Unknown')
+                status_names = {
+                    0: "Queued",
+                    1: "Running", 
+                    2: "Completed",
+                    3: "Failed",
+                    4: "Stopped",
+                    5: "Awaiting Queue"
+                }
+                status_name = status_names.get(status, f"Unknown ({status})")
+                
+                formatted = f" **Workflow Status**: {status_name} ({status})\n"
+                formatted += f" UUID: {workflow_uuid}\n"
+                formatted += f" Name: {safe_get_dict_value(workflow, 'name', 'N/A')}\n"
+                formatted += f" Elapsed: {safe_get_dict_value(workflow, 'elapsed', 0):.2f}s\n"
+                
+                if status == 2:
+                    formatted += f" **Completed successfully!** Use 'retrieve' action to get results.\n"
+                elif status == 1:
+                    formatted += f" **Currently running...** Check back later for results.\n"
+                elif status == 0:
+                    formatted += f" **Queued and waiting to start**\n"
+                elif status == 3:
+                    formatted += f" **Failed** - Check workflow details for error information.\n"
+                elif status == 4:
+                    formatted += f" **Stopped**\n"
+                    
+                return formatted
+            elif action == "is_finished":
+                workflow = rowan.Workflow.retrieve(uuid=workflow_uuid)
+                
+                # Handle workflow as dictionary
+                def safe_get_dict_value(data, key, default='N/A'):
+                    if isinstance(data, dict):
+                        return data.get(key, default)
+                    return safe_get_attr(data, key, default)
+                
+                status = safe_get_dict_value(workflow, 'object_status', 'Unknown')
+                is_finished = status in [2, 3, 4]  # Completed, Failed, or Stopped
+                
+                formatted = f" **Workflow Finished Check**\n"
+                formatted += f" UUID: {workflow_uuid}\n"
+                formatted += f" Status: {status}\n"
+                formatted += f" Finished: {'Yes' if is_finished else 'No'}\n"
+                
+                if is_finished:
+                    if status == 2:
+                        formatted += f" Use 'retrieve' action to get results\n"
+                    elif status == 3:
+                        formatted += f" Workflow failed - check details for error info\n"
+                    elif status == 4:
+                        formatted += f" Workflow was stopped\n"
+                else:
+                    formatted += f" Workflow is still {['queued', 'running'][status] if status in [0, 1] else 'in progress'}\n"
+                    
+                return formatted
+                
+        elif action == "delete":
+            if not workflow_uuid:
+                return " Error: 'workflow_uuid' is required for deleting a workflow"
+            
+            result = rowan.Workflow.delete(uuid=workflow_uuid)
+            return f" Workflow deletion request submitted. Result: {result}"
+            
+        elif action == "list":
+            # Build filters
+            filters = {
+                'page': page,
+                'size': min(size * 5, 250)  # Get more workflows to sort properly, cap at 250
+            }
+            
+            if name_contains:
+                filters['name_contains'] = name_contains
+            if parent_uuid:
+                filters['parent_uuid'] = parent_uuid
+            if starred is not None:
+                filters['starred'] = starred
+            if public is not None:
+                filters['public'] = public
+            if object_status is not None:
+                filters['object_status'] = object_status
+            if object_type:
+                filters['object_type'] = object_type
+            
+            workflows = rowan.Workflow.list(**filters)
+            
+            # Sort workflows by created_at in descending order (most recent first)
+            if 'workflows' in workflows and workflows['workflows']:
+                from datetime import datetime
+                
+                def parse_date(date_str):
+                    try:
+                        return datetime.fromisoformat(date_str.replace('Z', '+00:00'))
+                    except:
+                        return datetime.min
+                
+                sorted_workflows = sorted(
+                    workflows['workflows'], 
+                    key=lambda w: parse_date(w.get('created_at', '')),
+                    reverse=True
+                )
+                
+                # Remove object_logfile from each workflow and return only the requested number
+                cleaned_workflows = []
+                for workflow in sorted_workflows[:size]:
+                    cleaned_workflow = {k: v for k, v in workflow.items() if k != 'object_logfile'}
+                    cleaned_workflows.append(cleaned_workflow)
+                
+                workflows['workflows'] = cleaned_workflows
+            
+            return workflows
+            
+        else:
+            return f" Error: Unknown action '{action}'. Available actions: create, retrieve, update, stop, status, is_finished, delete, list"
+            
+    except Exception as e:
+        return f" Error in workflow management: {str(e)}"
+
+def extract_workflow_results(workflow_type: str, object_data: Dict[str, Any]) -> str:
+    """Extract and format workflow results - simple raw data display."""
+    
+    formatted = f" **{workflow_type.replace('_', ' ').title()} Results:**\n\n"
+    
+    import json
+    try:
+        # Pretty print the object_data as JSON
+        formatted += f"```json\n{json.dumps(object_data, indent=2, default=str)}\n```\n"
+    except Exception as e:
+        # Fallback if JSON serialization fails
+        formatted += f"Raw object_data:\n{str(object_data)}\n"
+        formatted += f"(JSON serialization failed: {e})\n"
+    
+    return formatted
+
+def test_rowan_workflow_management():
+    """Test the workflow management function."""
+    try:
+        # Test list action
+        result = rowan_workflow_management("list", size=5)
+        print(" Workflow management test successful!")
+        print(f"Sample result: {result[:200]}...")
+        return True
+    except Exception as e:
+        print(f" Workflow management test failed: {e}")
+        return False
+
+if __name__ == "__main__":
+    test_rowan_workflow_management() 

rowan_mcp/server.py

@@ -0,0 +1,169 @@
+"""
+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
+
+try:
+    from dotenv import load_dotenv
+    load_dotenv()  # Load .env file if available
+except ImportError:
+    pass  # dotenv not required, but helpful if available
+
+# 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:
+    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()
+
+if __name__ == "__main__":
+    main()