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

rowan_mcp/__init__.py

@@ -5,7 +5,7 @@ This package provides MCP (Model Context Protocol) server functionality
 for integrating with Rowan's computational chemistry platform.
 """
 
-__version__ = "1.0.0"
+__version__ = "1.0.2"
 __author__ = "Kat Yenko"
 __description__ = "MCP server for Rowan computational chemistry platform"
 

rowan_mcp/__main__.py

@@ -2,13 +2,11 @@
 Main entry point for Rowan MCP Server when run as a module.
 
 Usage:
-    python -m src                # STDIO mode (default)
-    python -m src --stdio        # STDIO mode  
-    python -m src --http         # HTTP mode
-    python -m src --help         # Show help
+    python -m rowan_mcp          # HTTP/SSE mode
+    python -m rowan_mcp --help   # Show help
 """
 
 if __name__ == "__main__":
-    # All modes now handled by the unified server
+    # HTTP transport only
     from .server import main
     main() 

rowan_mcp/functions/admet.py

@@ -16,11 +16,6 @@ except ImportError:
 # Setup logging
 logger = logging.getLogger(__name__)
 
-# Setup API key
-api_key = os.getenv("ROWAN_API_KEY")
-if rowan and api_key:
-    rowan.api_key = api_key
-
 
 def log_rowan_api_call(workflow_type: str, **kwargs):
     """Log Rowan API calls with detailed parameters."""

rowan_mcp/functions/bde.py

@@ -10,14 +10,7 @@ from typing import Optional, List, Union
 import logging
 logger = logging.getLogger(__name__)
 
-# Configure rowan API key
-if not hasattr(rowan, 'api_key') or not rowan.api_key:
-    api_key = os.getenv("ROWAN_API_KEY")
-    if api_key:
-        rowan.api_key = api_key
-        logger.info("🔑 Rowan API key configured")
-    else:
-        logger.error("No ROWAN_API_KEY found in environment")
+
 
 def log_rowan_api_call(workflow_type: str, **kwargs):
     """Log Rowan API calls and let Rowan handle its own errors."""

rowan_mcp/functions/conformers.py

@@ -15,10 +15,7 @@ except ImportError:
 # Setup logging
 logger = logging.getLogger(__name__)
 
-# Setup API key
-api_key = os.getenv("ROWAN_API_KEY")
-if rowan and api_key:
-    rowan.api_key = api_key
+
 
 def log_rowan_api_call(workflow_type: str, **kwargs):
     """Log Rowan API calls and let Rowan handle its own errors."""

rowan_mcp/functions/descriptors.py

@@ -15,10 +15,7 @@ except ImportError:
 # Setup logging
 logger = logging.getLogger(__name__)
 
-# Setup API key
-api_key = os.getenv("ROWAN_API_KEY")
-if rowan and api_key:
-    rowan.api_key = api_key
+
 
 def log_rowan_api_call(workflow_type: str, **kwargs):
     """Log Rowan API calls with detailed parameters."""

rowan_mcp/functions/docking.py

@@ -192,63 +192,13 @@ def rowan_docking(
         if conformers is not None:
             compute_params["conformers"] = conformers
         
-        # Submit docking calculation
+        # Submit docking calculation and return raw result
         result = rowan.compute(**compute_params)
-        
-        # Format results
-        uuid = result.get('uuid', 'N/A')
-        status = result.get('status', 'unknown')
-        
-        if blocking:
-            # Blocking mode - check if successful
-            if status == "success":
-                formatted = f"✅ Docking calculation '{name}' completed successfully!\n"
-                formatted += f"🔖 Workflow UUID: {uuid}\n"
-                formatted += f"📊 Status: {status}\n\n"
-                
-                # Extract docking results if available
-                object_data = result.get("object_data", {})
-                scores = object_data.get("scores", [])
-                
-                if scores:
-                    formatted += f"🎯 Docking Results: {len(scores)} poses generated\n"
-                    formatted += f"📈 Best docking score: {scores[0] if scores else 'N/A'}\n"
-                    
-                    # Show top poses
-                    formatted += "\nTop poses:\n"
-                    for i, score in enumerate(scores[:5]):
-                        formatted += f"  {i+1}. Score: {score}\n"
-                        
-                    if len(scores) > 5:
-                        formatted += f"  ... and {len(scores) - 5} more poses\n"
-                else:
-                    formatted += "📈 Results: Check workflow details for docking data\n"
-                    
-                return formatted
-            else:
-                # Failed calculation
-                return f"❌ Docking calculation failed\n🔖 UUID: {uuid}\n📋 Status: {status}\n💬 Check workflow details for more information"
-        else:
-            # Non-blocking mode
-            formatted = f"📋 Docking calculation '{name}' submitted!\n"
-            formatted += f"🔖 Workflow UUID: {uuid}\n"
-            formatted += f"⏳ Status: Running...\n"
-            formatted += f"💡 Use rowan_workflow_management to check status\n\n"
-            
-            formatted += f"Docking Details:\n"
-            formatted += f"🧬 Ligand: {initial_molecule}\n"
-            formatted += f"🎯 Target: {target_uuid or target[:50] + '...' if target and len(target) > 50 else target}\n"
-            formatted += f"📍 Pocket: center={pocket[0]}, size={pocket[1]}\n"
-            formatted += f"⚙️  Settings: csearch={do_csearch}, optimize={do_optimization}, refine={do_pose_refinement}\n"
-            
-            if conformers:
-                formatted += f"🔬 Pre-optimized conformers: {len(conformers)}\n"
-                
-            return formatted
+        return result
             
     except Exception as e:
         logger.error(f"Error in rowan_docking: {str(e)}")
-        return f"❌ Docking calculation failed: {str(e)}"
+        return f"Docking calculation failed: {str(e)}"
 
 def rowan_docking_pdb_id(
     name: str,
@@ -297,7 +247,7 @@ def rowan_docking_pdb_id(
         else:
             ligand_param = f"    smiles={smiles},\n"
     
-    return (f"✅ PDB {pdb_id} found in RCSB database!\n\n"
+    return (f"PDB {pdb_id} found in RCSB database!\n\n"
             f"To perform docking with this protein:\n\n"
             f"1. Go to https://labs.rowansci.com\n"
             f"2. Upload the PDB file for {pdb_id}\n"
@@ -329,11 +279,11 @@ def test_rowan_docking():
             pocket=((0.0, 0.0, 0.0), (20.0, 20.0, 20.0)),
             blocking=False
         )
-        print("✅ Docking test result:")
+        print("Docking test result:")
         print(result)
         return True
     except Exception as e:
-        print(f"❌ Docking test failed: {e}")
+        print(f"Docking test failed: {e}")
         return False
 
 if __name__ == "__main__":

rowan_mcp/functions/electronic_properties.py

@@ -22,10 +22,7 @@ except ImportError:
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Setup API key
-api_key = os.getenv("ROWAN_API_KEY")
-if api_key and rowan:
-    rowan.api_key = api_key
+
 
 def log_rowan_api_call(workflow_type: str, **kwargs):
     """Log Rowan API calls with detailed parameters."""

rowan_mcp/functions/folder_management.py

@@ -10,14 +10,7 @@ from typing import Optional
 import logging
 logger = logging.getLogger(__name__)
 
-# Configure rowan API key
-if not hasattr(rowan, 'api_key') or not rowan.api_key:
-    api_key = os.getenv("ROWAN_API_KEY")
-    if api_key:
-        rowan.api_key = api_key
-        logger.info("Rowan API key configured")
-    else:
-        logger.error("No ROWAN_API_KEY found in environment")
+
 
 def rowan_folder_management(
     action: str,

rowan_mcp/functions/fukui.py

@@ -22,10 +22,7 @@ except ImportError:
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Setup API key
-api_key = os.getenv("ROWAN_API_KEY")
-if api_key and rowan:
-    rowan.api_key = api_key
+
 
 def log_rowan_api_call(workflow_type: str, **kwargs):
     """Log Rowan API calls with detailed parameters."""

rowan_mcp/functions/hydrogen_bond_basicity.py

@@ -10,14 +10,7 @@ from typing import Optional
 import logging
 logger = logging.getLogger(__name__)
 
-# Configure rowan API key
-if not hasattr(rowan, 'api_key') or not rowan.api_key:
-    api_key = os.getenv("ROWAN_API_KEY")
-    if api_key:
-        rowan.api_key = api_key
-        logger.info("🔑 Rowan API key configured")
-    else:
-        logger.error("No ROWAN_API_KEY found in environment")
+
 
 def log_rowan_api_call(workflow_type: str, **kwargs):
     """Log Rowan API calls and let Rowan handle its own errors."""

rowan_mcp/functions/multistage_opt.py

@@ -15,10 +15,7 @@ except ImportError:
 # Setup logging
 logger = logging.getLogger(__name__)
 
-# Setup API key
-api_key = os.getenv("ROWAN_API_KEY")
-if rowan and api_key:
-    rowan.api_key = api_key
+
 
 def log_rowan_api_call(workflow_type: str, **kwargs):
     """Log Rowan API calls with detailed parameters."""

rowan_mcp/functions/pka.py

@@ -10,14 +10,7 @@ from typing import Optional
 import logging
 logger = logging.getLogger(__name__)
 
-# Configure rowan API key
-if not hasattr(rowan, 'api_key') or not rowan.api_key:
-    api_key = os.getenv("ROWAN_API_KEY")
-    if api_key:
-        rowan.api_key = api_key
-        logger.info("Rowan API key configured")
-    else:
-        logger.error("No ROWAN_API_KEY found in environment")
+
 
 def log_rowan_api_call(workflow_type: str, **kwargs):
     """Log Rowan API calls and let Rowan handle its own errors."""

rowan_mcp/functions/redox_potential.py

@@ -15,10 +15,7 @@ except ImportError:
 # Setup logging
 logger = logging.getLogger(__name__)
 
-# Setup API key
-api_key = os.getenv("ROWAN_API_KEY")
-if rowan and api_key:
-    rowan.api_key = api_key
+
 
 def lookup_molecule_smiles(molecule_name: str) -> str:
     """Look up canonical SMILES for common molecule names."""
@@ -287,7 +284,7 @@ def rowan_redox_potential(
         formatted += f" Job UUID: {result.get('uuid', 'N/A')}\n"
         formatted += f" Status: {status}\n"
         formatted += f"⚙ Mode: {mode_lower.title()}\n"
-        formatted += f"💧 Solvent: Acetonitrile\n"
+        formatted += f"Solvent: Acetonitrile\n"
         
         # Show which potentials were calculated
         calc_types = []

rowan_mcp/functions/system_management.py

@@ -11,14 +11,7 @@ from typing import Optional
 # Set up logging
 logger = logging.getLogger(__name__)
 
-# Configure rowan API key
-if not hasattr(rowan, 'api_key') or not rowan.api_key:
-    api_key = os.getenv("ROWAN_API_KEY")
-    if api_key:
-        rowan.api_key = api_key
-        logger.info("Rowan API key configured")
-    else:
-        logger.error("No ROWAN_API_KEY found in environment")
+
 
 def rowan_system_management(
     action: str,

rowan_mcp/functions/tautomers.py

@@ -15,10 +15,7 @@ except ImportError:
 # Setup logging
 logger = logging.getLogger(__name__)
 
-# Setup API key
-api_key = os.getenv("ROWAN_API_KEY")
-if rowan and api_key:
-    rowan.api_key = api_key
+
 
 def log_rowan_api_call(workflow_type: str, **kwargs):
     """Log Rowan API calls with detailed parameters."""

rowan_mcp/functions_v2/BENCHMARK.md

@@ -0,0 +1,86 @@
+# Rowan MCP Benchmark Suite
+
+## Overview
+Systematic evaluation of the Rowan MCP server's ability to handle chemistry workflows through natural language queries.
+
+## Evaluation Tiers
+
+### Tier 1: Single Tool Calls
+**Tests**: Basic tool invocation and parameter passing  
+**Characteristics**:
+- Single workflow submission
+- Explicit parameters
+- No dependencies
+- Direct SMILES or common molecule names
+
+**Example Queries**:
+- "Calculate the pKa of phenol"
+- "Optimize water geometry with GFN2-xTB"
+- "Find conformers of ethanol"
+
+### Tier 2: Parameter Interpretation
+**Tests**: Natural language to parameter mapping, molecule name resolution  
+**Characteristics**:
+- Requires interpreting descriptive terms into API parameters
+- Mode selection (rapid/careful/meticulous)
+- Element specification by name vs atomic number
+- Common name to SMILES conversion
+
+**Example Queries**:
+- "Calculate the oxidation potential of caffeine using careful mode"
+- "Find the pKa of aspirin, only considering oxygen atoms"
+- "Dock ibuprofen to CDK2 without optimization"
+
+### Tier 3: Batch Operations
+**Tests**: Multiple independent calculations, result organization  
+**Characteristics**:
+- Multiple molecules or methods
+- Parallel workflow submission
+- Result comparison/aggregation
+- Folder organization
+
+**Example Queries**:
+- "Calculate pKa for phenol, p-nitrophenol, and p-chlorophenol"
+- "Optimize butane with GFN2-xTB, UMA, and R2SCAN-3c methods"
+- "Screen 5 molecules for docking against CDK2"
+
+### Tier 4: Workflow Chaining
+**Tests**: Sequential dependent calculations, data extraction from results  
+**Characteristics**:
+- Output from one workflow feeds into next
+- Requires waiting for completion
+- UUID and result extraction
+- Proper async handling
+
+**Example Queries**:
+- "Find conformers of benzophenone, then calculate redox potential for top 3"
+- "Optimize this transition state, then run IRC from the result"
+- "Calculate pKa, then run conformer search at the predicted pKa value"
+
+### Tier 5: Conditional Logic
+**Tests**: Decision-making based on results, complex multi-step analysis  
+**Characteristics**:
+- Conditional branching based on results
+- Threshold-based decisions
+- Error handling and retries
+- Statistical analysis of results
+
+**Example Queries**:
+- "Screen molecules for docking, only run detailed analysis if score < -8.0"
+- "Calculate conformer energies, identify outliers (>2 kcal/mol from lowest), recalculate outliers with meticulous mode"
+- "Find pKa sites, if any are between 6-8, run pH-dependent calculations at those values"
+
+## Scoring Criteria
+
+### Per Query
+- **Success**: Workflow submitted correctly (1 point)
+- **Parameters**: All parameters correctly mapped (1 point)
+- **Completion**: Workflow completes without error (1 point)
+- **Chaining**: Dependencies handled correctly (1 point, Tier 4-5 only)
+- **Logic**: Conditional logic executed correctly (1 point, Tier 5 only)
+
+### Overall Metrics
+- Success rate per tier
+- Average time to completion
+- Error recovery rate
+- Parameter accuracy rate

rowan_mcp/functions_v2/molecule_lookup.py

@@ -0,0 +1,232 @@
+"""
+Molecule name to SMILES converter using Chemical Identifier Resolver (CIR).
+Enables natural language molecule input for Rowan workflows.
+"""
+
+from typing import List, Dict, Annotated
+from urllib.request import urlopen
+from urllib.parse import quote
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def molecule_lookup(
+    molecule_name: Annotated[str, "Common name, IUPAC name, or CAS number of molecule (e.g., 'aspirin', 'caffeine', '50-78-2')"],
+    fallback_to_input: Annotated[bool, "If lookup fails, return the input string assuming it might be SMILES"] = False
+) -> str:
+    """Convert molecule names to SMILES using Chemical Identifier Resolver (CIR).
+    
+    Args:
+        molecule_name: Common name, IUPAC name, or CAS number of molecule (e.g., 'aspirin', 'caffeine', '50-78-2')
+        fallback_to_input: If lookup fails, return the input string assuming it might be SMILES
+    
+    This tool enables natural language input for molecules by converting common names,
+    IUPAC names, CAS numbers, and other identifiers to SMILES strings that can be
+    used with Rowan workflows.
+    
+    Supported Input Types:
+    - Common names: 'aspirin', 'caffeine', 'benzene', 'glucose'
+    - IUPAC names: '2-acetoxybenzoic acid', '1,3,7-trimethylpurine-2,6-dione'
+    - CAS numbers: '50-78-2' (aspirin), '58-08-2' (caffeine)
+    - InChI strings
+    - Already valid SMILES (will be validated)
+    
+    Returns:
+        SMILES string if successful, error message if not found
+        
+    Examples:
+        # Common drug name
+        result = molecule_lookup("aspirin")
+        # Returns: "CC(=O)Oc1ccccc1C(=O)O"
+        
+        # IUPAC name
+        result = molecule_lookup("2-acetoxybenzoic acid")
+        # Returns: "CC(=O)Oc1ccccc1C(=O)O"
+        
+        # CAS number
+        result = molecule_lookup("50-78-2")
+        # Returns: "CC(=O)Oc1ccccc1C(=O)O"
+        
+        # Complex molecule
+        result = molecule_lookup("paracetamol")
+        # Returns: "CC(=O)Nc1ccc(O)cc1"
+    """
+    try:
+        # Clean input
+        molecule_name = molecule_name.strip()
+        
+        # Check if already SMILES-like (contains typical SMILES characters)
+        smiles_chars = {'=', '#', '(', ')', '[', ']', '@', '+', '-'}
+        if any(char in molecule_name for char in smiles_chars):
+            logger.info(f"Input '{molecule_name}' appears to be SMILES, returning as-is")
+            return molecule_name
+        
+        # Query CIR service
+        logger.info(f"Looking up molecule: {molecule_name}")
+        url = f'http://cactus.nci.nih.gov/chemical/structure/{quote(molecule_name)}/smiles'
+        
+        response = urlopen(url, timeout=10)
+        smiles = response.read().decode('utf8').strip()
+        
+        # CIR may return multiple SMILES for some queries, take the first one
+        if '\n' in smiles:
+            smiles = smiles.split('\n')[0]
+        
+        logger.info(f"Successfully converted '{molecule_name}' to SMILES: {smiles}")
+        return smiles
+        
+    except Exception as e:
+        logger.warning(f"Failed to lookup '{molecule_name}': {e}")
+        
+        if fallback_to_input:
+            logger.info(f"Returning original input as fallback: {molecule_name}")
+            return molecule_name
+        else:
+            return f"Could not find SMILES for '{molecule_name}'. Please check the name or provide a valid SMILES string."
+
+
+def batch_molecule_lookup(
+    molecule_names: Annotated[List[str], "List of molecule names to convert to SMILES"],
+    skip_failures: Annotated[bool, "Skip molecules that fail lookup instead of stopping"] = True
+) -> Dict[str, str]:
+    """Convert multiple molecule names to SMILES in batch.
+    
+    Args:
+        molecule_names: List of molecule names to convert to SMILES
+        skip_failures: Skip molecules that fail lookup instead of stopping
+    
+    Useful for preparing multiple molecules for workflows or screening.
+        
+    Returns:
+        Dictionary mapping input names to SMILES strings (or error messages)
+        
+    Examples:
+        # Drug screening set
+        result = batch_molecule_lookup([
+            "aspirin",
+            "ibuprofen", 
+            "paracetamol",
+            "caffeine"
+        ])
+        # Returns: {
+        #     "aspirin": "CC(=O)Oc1ccccc1C(=O)O",
+        #     "ibuprofen": "CC(C)Cc1ccc(C(C)C(=O)O)cc1",
+        #     "paracetamol": "CC(=O)Nc1ccc(O)cc1",
+        #     "caffeine": "CN1C=NC2=C1C(=O)N(C(=O)N2C)C"
+        # }
+        
+        # Mixed input types
+        result = batch_molecule_lookup([
+            "benzene",           # Common name
+            "50-78-2",          # CAS number
+            "ethanoic acid"     # IUPAC name
+        ])
+    """
+    results = {}
+    
+    for name in molecule_names:
+        try:
+            smiles = molecule_lookup(name, fallback_to_input=False)
+            results[name] = smiles
+        except Exception as e:
+            error_msg = f"Lookup failed: {str(e)}"
+            if skip_failures:
+                logger.warning(f"Skipping {name}: {error_msg}")
+                results[name] = error_msg
+            else:
+                raise ValueError(f"Failed to lookup '{name}': {error_msg}")
+    
+    return results
+
+
+def validate_smiles(
+    smiles: Annotated[str, "SMILES string to validate"]
+) -> Dict[str, any]:
+    """Validate a SMILES string and return basic molecular properties.
+    
+    Args:
+        smiles: SMILES string to validate
+    
+    Uses RDKit to validate SMILES and extract basic properties.
+        
+    Returns:
+        Dictionary with validation status and properties if valid
+        
+    Examples:
+        result = validate_smiles("CC(=O)O")
+        # Returns: {
+        #     "valid": True,
+        #     "canonical_smiles": "CC(=O)O",
+        #     "molecular_formula": "C2H4O2",
+        #     "molecular_weight": 60.05
+        # }
+    """
+    try:
+        from rdkit import Chem
+        from rdkit.Chem import Descriptors
+        
+        mol = Chem.MolFromSmiles(smiles)
+        
+        if mol is None:
+            return {
+                "valid": False,
+                "error": "Invalid SMILES string"
+            }
+        
+        return {
+            "valid": True,
+            "canonical_smiles": Chem.MolToSmiles(mol),
+            "molecular_formula": Chem.rdMolDescriptors.CalcMolFormula(mol),
+            "molecular_weight": round(Descriptors.MolWt(mol), 2),
+            "num_atoms": mol.GetNumAtoms(),
+            "num_bonds": mol.GetNumBonds()
+        }
+        
+    except ImportError:
+        return {
+            "valid": "unknown",
+            "error": "RDKit not available for validation"
+        }
+    except Exception as e:
+        return {
+            "valid": False,
+            "error": str(e)
+        }
+
+
+# Common molecules reference (for documentation)
+COMMON_MOLECULES = {
+    # Drugs
+    "aspirin": "CC(=O)Oc1ccccc1C(=O)O",
+    "paracetamol": "CC(=O)Nc1ccc(O)cc1",
+    "acetaminophen": "CC(=O)Nc1ccc(O)cc1",  # Same as paracetamol
+    "ibuprofen": "CC(C)Cc1ccc(C(C)C(=O)O)cc1",
+    "caffeine": "CN1C=NC2=C1C(=O)N(C(=O)N2C)C",
+    "penicillin": "CC1(C)SC2C(NC(=O)Cc3ccccc3)C(=O)N2C1C(=O)O",
+    
+    # Solvents
+    "water": "O",
+    "ethanol": "CCO",
+    "methanol": "CO",
+    "acetone": "CC(=O)C",
+    "dmso": "CS(=O)C",
+    "chloroform": "C(Cl)(Cl)Cl",
+    "benzene": "c1ccccc1",
+    "toluene": "Cc1ccccc1",
+    
+    # Organic compounds
+    "glucose": "C(C1C(C(C(C(O1)O)O)O)O)O",
+    "acetic acid": "CC(=O)O",
+    "ethanoic acid": "CC(=O)O",  # IUPAC for acetic acid
+    "phenol": "Oc1ccccc1",
+    "aniline": "Nc1ccccc1",
+    "naphthalene": "c1ccc2c(c1)cccc2",
+    
+    # Amino acids
+    "glycine": "C(C(=O)O)N",
+    "alanine": "CC(C(=O)O)N",
+    "valine": "CC(C)C(C(=O)O)N",
+    "leucine": "CC(C)CC(C(=O)O)N",
+    "lysine": "C(CCN)CC(C(=O)O)N",
+}