rowan-mcp 2.0.0__tar.gz → 2.0.1__tar.gz

{rowan_mcp-2.0.0 → rowan_mcp-2.0.1}/.gitignore

@@ -17,3 +17,5 @@ CLAUDE.md
 # Personal compatibility notes
 GEMINI_MCP_COMPATIBILITY.md
 MCP_CHATGPT_GEMINI_COMPATIBILITY_ANALYSIS.md
+ROWAN_MCP_TEST_QUERIES.md
+ROWAN_MCP_TOOLS.md

{rowan_mcp-2.0.0 → rowan_mcp-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rowan-mcp
-Version: 2.0.0
+Version: 2.0.1
 Summary: Model Context Protocol server for Rowan computational chemistry platform
 Project-URL: Homepage, https://github.com/k-yenko/rowan-mcp
 Author-email: Katherine Yenko <katherineayenko@gmail.com>
@@ -130,7 +130,7 @@ Ask the LLM to:
 
 ## **System Requirements**
 
-- **Python 3.10+** (Python 3.11+ recommended)
+- **Python 3.11+** 
 - **Package manager**: [uv](https://docs.astral.sh/uv/) (recommended) or pip
 - **Rowan API key** (free at [labs.rowansci.com](https://labs.rowansci.com))
 - **MCP-compatible client** (Claude Desktop, etc.)
@@ -173,7 +173,7 @@ uv run python -m rowan_mcp
 
 ## **Requirements**
 
-- Python 3.10+
+- Python 3.11+
 - Rowan API key
 - MCP-compatible AI assistant (Claude Desktop, etc.)
 
@@ -184,21 +184,6 @@ uv run python -m rowan_mcp
 
 ---
 
-## **Todo**
-
-- [X] Remove unnecessary AI spaghetti formatting
-- [X] Remove no longer necessary API config lines
-- [ ] Some complex conformer searches hang on "running"
-- [X] Edit MCP one-liner context
-- [ ] Transition state finding and IRC
-- [X] `rowan_scan` - Potential energy surfaces
-- [ ] `rowan_docking` - Protein-ligand docking
-- [X] add in h-bond, BDE and macroscopic pka, logD, BBB
-- [ ] Folder listing API bug (returns 500 error) - Rowan side?
-- [ ] Multistage optimization sometimes shows unexpected imaginary frequencies
-- [X] Some calculations show as finished in logs but not in Rowan UI
-- [ ] Can you hook up Rowan's visual capabilites? 
-
 ## **Citation**
 
 If you use this MCP tool in your research, please cite the underlying Rowan platform:

{rowan_mcp-2.0.0 → rowan_mcp-2.0.1}/README.md

@@ -97,7 +97,7 @@ Ask the LLM to:
 
 ## **System Requirements**
 
-- **Python 3.10+** (Python 3.11+ recommended)
+- **Python 3.11+** 
 - **Package manager**: [uv](https://docs.astral.sh/uv/) (recommended) or pip
 - **Rowan API key** (free at [labs.rowansci.com](https://labs.rowansci.com))
 - **MCP-compatible client** (Claude Desktop, etc.)
@@ -140,7 +140,7 @@ uv run python -m rowan_mcp
 
 ## **Requirements**
 
-- Python 3.10+
+- Python 3.11+
 - Rowan API key
 - MCP-compatible AI assistant (Claude Desktop, etc.)
 
@@ -151,21 +151,6 @@ uv run python -m rowan_mcp
 
 ---
 
-## **Todo**
-
-- [X] Remove unnecessary AI spaghetti formatting
-- [X] Remove no longer necessary API config lines
-- [ ] Some complex conformer searches hang on "running"
-- [X] Edit MCP one-liner context
-- [ ] Transition state finding and IRC
-- [X] `rowan_scan` - Potential energy surfaces
-- [ ] `rowan_docking` - Protein-ligand docking
-- [X] add in h-bond, BDE and macroscopic pka, logD, BBB
-- [ ] Folder listing API bug (returns 500 error) - Rowan side?
-- [ ] Multistage optimization sometimes shows unexpected imaginary frequencies
-- [X] Some calculations show as finished in logs but not in Rowan UI
-- [ ] Can you hook up Rowan's visual capabilites? 
-
 ## **Citation**
 
 If you use this MCP tool in your research, please cite the underlying Rowan platform:

{rowan_mcp-2.0.0 → rowan_mcp-2.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rowan-mcp"
-version = "2.0.0"
+version = "2.0.1"
 description = "Model Context Protocol server for Rowan computational chemistry platform"
 authors = [
     {name = "Katherine Yenko", email = "katherineayenko@gmail.com"}
@@ -50,6 +50,16 @@ rowan-mcp = "rowan_mcp.server:main"
 [tool.hatch.build.targets.wheel]
 packages = ["rowan_mcp"]
 
+[tool.hatch.build.targets.sdist]
+exclude = [
+  "rowan-dxt/",
+  "dxt/", 
+  "*.log",
+  "test_*.py",
+  ".venv/",
+  "*.dxt"
+]
+
 [tool.black]
 line-length = 88
 target-version = ['py38']

rowan_mcp-2.0.1/rowan_mcp/functions/admet.py

@@ -0,0 +1,89 @@
+"""
+Rowan ADMET properties function for drug discovery.
+"""
+
+import os
+import logging
+import time
+import traceback
+from typing import Optional
+
+try:
+    import rowan
+except ImportError:
+    rowan = None
+
+# Setup logging
+logger = logging.getLogger(__name__)
+
+
+def log_rowan_api_call(workflow_type: str, **kwargs):
+    """Log Rowan API calls with detailed parameters."""
+    
+    try:
+        start_time = time.time()
+        result = rowan.compute(workflow_type=workflow_type, **kwargs)
+        api_time = time.time() - start_time
+
+        return result
+        
+    except Exception as e:
+        api_time = time.time() - start_time
+
+        raise e
+
+
+def rowan_admet(
+    name: str,
+    molecule: str,
+    folder_uuid: Optional[str] = None,
+    blocking: bool = True,
+    ping_interval: int = 5
+) -> str:
+    """Predict ADME-Tox properties for drug discovery.
+    
+    ADMET (Absorption, Distribution, Metabolism, Excretion, Toxicity) properties are crucial
+    for drug development. This workflow predicts drug-like properties including:
+    - Bioavailability and permeability
+    - Metabolic stability and clearance
+    - Toxicity indicators and safety profiles
+    - Drug-likeness metrics
+    
+    Use this for: Drug discovery, pharmaceutical development, toxicity screening
+    
+    Args:
+        name: Name for the calculation
+        molecule: Molecule SMILES string
+        folder_uuid: Optional folder UUID for organization
+        blocking: Whether to wait for completion (default: True)
+        ping_interval: Check status interval in seconds (default: 5)
+    
+    Returns:
+        ADMET prediction results
+    """
+    result = log_rowan_api_call(
+        workflow_type="admet",
+        name=name,
+        molecule=molecule,
+        folder_uuid=folder_uuid,
+        blocking=blocking,
+        ping_interval=ping_interval
+    )
+    return str(result)
+
+
+def test_rowan_admet():
+    """Test the rowan_admet function."""
+    try:
+        # Test with a simple molecule (non-blocking to avoid long wait)
+        result = rowan_admet("test_admet", "CCO", blocking=False)
+        print("ADMET test successful!")
+        print(f"Result length: {len(result)} characters")
+        return True
+    except Exception as e:
+        print(f"ADMET test failed: {e}")
+        return False
+
+
+if __name__ == "__main__":
+    test_rowan_admet() 

rowan_mcp-2.0.1/rowan_mcp/functions/bde.py

@@ -0,0 +1,106 @@
+"""
+Calculate bond dissociation energy (BDE) for molecules to determine bond strength - useful for reaction prediction, stability analysis, or understanding molecular fragmentation. Modes: reckless/rapid/careful/meticulous. Input: molecule (SMILES), optional atoms to break.
+"""
+
+import os
+import rowan
+from typing import Optional, List, Union
+
+# Set up logging
+import logging
+logger = logging.getLogger(__name__)
+
+
+
+def log_rowan_api_call(workflow_type: str, **kwargs):
+    """Log Rowan API calls and let Rowan handle its own errors."""
+    
+    # Simple logging for calculations
+    logger.info(f" Starting {workflow_type.replace('_', ' ')}...")
+    
+    # Let Rowan handle everything - no custom error handling
+    return rowan.compute(workflow_type=workflow_type, **kwargs)
+
+def rowan_bde(
+    name: str,
+    molecule: str,
+    mode: str = "rapid",
+    atoms: Optional[List[int]] = None,
+    optimize_fragments: Optional[bool] = None,
+    all_CH: bool = False,
+    all_CX: bool = False,
+    folder_uuid: Optional[str] = None,
+    blocking: bool = True,
+    ping_interval: int = 5
+) -> str:
+    """Calculate bond dissociation energy (BDE) for molecules.
+    
+    Args:
+        name: Name for the calculation
+        molecule: Molecule SMILES string
+        mode: Calculation mode - reckless/rapid/careful/meticulous (default: rapid)
+        atoms: Specific atoms to dissociate (1-indexed)
+        optimize_fragments: Whether to optimize fragments (default depends on mode)
+        all_CH: Dissociate all C-H bonds (default: False)
+        all_CX: Dissociate all C-X bonds where X is halogen (default: False)
+        folder_uuid: UUID of folder to organize calculation in
+        blocking: Whether to wait for completion (default: True)
+        ping_interval: How often to check status in seconds (default: 5)
+    
+    Returns:
+        Bond dissociation energy calculation results
+    """
+    try:
+        # Build kwargs for API call
+        kwargs = {
+            "workflow_type": "bde",
+            "name": name,
+            "molecule": molecule,
+            "mode": mode.lower(),
+            "folder_uuid": folder_uuid,
+            "blocking": blocking,
+            "ping_interval": ping_interval
+        }
+        
+        # Add optional parameters only if specified
+        if atoms is not None:
+            kwargs["atoms"] = atoms
+        if optimize_fragments is not None:
+            kwargs["optimize_fragments"] = optimize_fragments
+        if all_CH:
+            kwargs["all_CH"] = all_CH
+        if all_CX:
+            kwargs["all_CX"] = all_CX
+        
+        result = log_rowan_api_call(**kwargs)
+        
+        return str(result)
+        
+    except Exception as e:
+        error_response = {
+            "error": f"BDE calculation failed: {str(e)}",
+            "name": name,
+            "molecule": molecule
+        }
+        return str(error_response)
+
+
+def test_rowan_bde():
+    """Test the rowan_bde function."""
+    try:
+        # Test with ethane C-C bond
+        result = rowan_bde(
+            name="test_ethane_CC",
+            molecule="CC",
+            mode="rapid"
+        )
+        print("✅ BDE test successful!")
+        print(f"Result: {result}")
+        return True
+    except Exception as e:
+        print(f"BDE test failed: {e}")
+        return False
+
+
+if __name__ == "__main__":
+    test_rowan_bde()

rowan_mcp-2.0.1/rowan_mcp/functions/calculation_retrieve.py

@@ -0,0 +1,89 @@
+"""
+Rowan calculation retrieval functions for MCP tool integration.
+"""
+
+from typing import Optional, Dict, Any
+import rowan
+
+def rowan_calculation_retrieve(calculation_uuid: str) -> str:
+    """Retrieve details of a specific calculation.
+    
+    Args:
+        calculation_uuid: UUID of the calculation to retrieve
+    
+    Returns:
+        Calculation details
+    """
+    
+    try:
+        calculation = rowan.Calculation.retrieve(uuid=calculation_uuid)
+        return format_calculation_details(calculation, calculation_uuid)
+                
+    except Exception as e:
+        return f" Error retrieving calculation: {str(e)}"
+
+# Fallback error handling removed - keeping function simple and focused
+
+def format_calculation_details(calculation: Dict[str, Any], calculation_uuid: str) -> str:
+    """Format calculation details for display."""
+    
+    formatted = f"⚙ **Calculation Details:**\n\n"
+    formatted += f" Name: {calculation.get('name', 'N/A')}\n"
+    formatted += f"UUID: {calculation_uuid}\n"
+    formatted += f" Status: {calculation.get('status', 'Unknown')}\n"
+    formatted += f" Elapsed: {calculation.get('elapsed', 0):.3f}s\n"
+    
+    # Settings information
+    settings = calculation.get('settings', {})
+    if settings:
+        formatted += f"\n⚙ **Settings:**\n"
+        formatted += f"   Method: {settings.get('method', 'N/A')}\n"
+        if settings.get('basis_set'):
+            formatted += f"   Basis Set: {settings.get('basis_set')}\n"
+        if settings.get('tasks'):
+            formatted += f"   Tasks: {', '.join(settings.get('tasks', []))}\n"
+    
+    # Molecule information
+    molecules = calculation.get('molecules', [])
+    if molecules:
+        formatted += f"\n **Molecules:** {len(molecules)} structure(s)\n"
+        if len(molecules) > 0 and isinstance(molecules[0], dict):
+            first_mol = molecules[0]
+            if 'smiles' in first_mol:
+                formatted += f"   Primary SMILES: {first_mol['smiles']}\n"
+    
+    # Results/output data
+    if 'output' in calculation:
+        output = calculation['output']
+        formatted += f"\n **Results Available:**\n"
+        if isinstance(output, dict):
+            for key, value in list(output.items())[:5]:  # Show first 5 items
+                if isinstance(value, (int, float)):
+                    formatted += f"   {key}: {value:.4f}\n"
+                elif isinstance(value, str) and len(value) < 50:
+                    formatted += f"   {key}: {value}\n"
+                elif isinstance(value, list) and len(value) < 10:
+                    formatted += f"   {key}: {value}\n"
+                else:
+                    formatted += f"   {key}: <complex data>\n"
+        else:
+            formatted += f"   Raw output: {str(output)[:200]}...\n"
+    
+    return formatted
+
+# Specialized object data formatting removed - keeping function simple
+
+def test_rowan_calculation_retrieve():
+    """Test the calculation retrieve function."""
+    try:
+        # Test with a dummy UUID to see error handling
+        result = rowan_calculation_retrieve("test-uuid-123")
+        print(" Calculation retrieve test successful!")
+        print(f"Sample result: {result[:200]}...")
+        return True
+    except Exception as e:
+        print(f" Calculation retrieve test failed: {e}")
+        return False
+
+if __name__ == "__main__":
+    test_rowan_calculation_retrieve() 

rowan_mcp-2.0.1/rowan_mcp/functions/conformers.py

@@ -0,0 +1,77 @@
+"""
+Rowan conformers function for conformational analysis.
+"""
+
+import os
+import logging
+import time
+from typing import Optional
+
+try:
+    import rowan
+except ImportError:
+    rowan = None
+
+# Setup logging
+logger = logging.getLogger(__name__)
+
+
+
+def log_rowan_api_call(workflow_type: str, **kwargs):
+    """Log Rowan API calls and let Rowan handle its own errors."""
+    
+    # Simple logging for long-running calculations
+    if workflow_type in ["multistage_opt", "conformer_search"]:
+        blocking = kwargs.get('blocking', True)
+        if blocking:
+            logger.info(f" Starting {workflow_type.replace('_', ' ')}...")
+        else:
+            logger.info(f" Submitting {workflow_type.replace('_', ' ')} without waiting")
+    
+    # Let Rowan handle everything - no custom error handling
+    return rowan.compute(workflow_type=workflow_type, **kwargs)
+
+def rowan_conformers(
+    name: str,
+    molecule: str,
+    max_conformers: int = 50,
+    mode: str = "rapid",
+    folder_uuid: Optional[str] = None,
+    blocking: bool = True,
+    ping_interval: int = 5
+):
+    """Generate and optimize molecular conformers using Rowan's conformer_search workflow. Valid modes are "reckless", "rapid", "careful", and "meticulous", and default to using SMILES strings for the "molecule" parameter.
+    
+    Args:
+        name: Name for the calculation
+        molecule: Molecule SMILES string or common name
+        max_conformers: Maximum number of conformers to generate (default: 50)
+        mode: Conformer search mode - "reckless", "rapid", "careful", "meticulous" (default: "rapid")
+        folder_uuid: UUID of folder to organize calculation in
+        blocking: Whether to wait for completion (default: True)
+        ping_interval: How often to check status in seconds (default: 5)
+    
+    Returns:
+        Conformer search results (actual results if blocking=True)
+    """
+    
+    # Validate mode parameter
+    valid_modes = ["reckless", "rapid", "careful", "meticulous"]
+    if mode not in valid_modes:
+        raise ValueError(
+            f"Invalid mode '{mode}'. Valid modes are: {', '.join(valid_modes)}"
+        )
+    
+    return log_rowan_api_call(
+        workflow_type="conformer_search",
+        name=name,
+        molecule=molecule,
+        mode=mode,
+        max_conformers=max_conformers,
+        folder_uuid=folder_uuid,
+        blocking=blocking,
+        ping_interval=ping_interval
+    )
+
+if __name__ == "__main__":
+    pass 

rowan_mcp-2.0.1/rowan_mcp/functions/descriptors.py

@@ -0,0 +1,89 @@
+"""
+Rowan molecular descriptors function for QSAR modeling.
+"""
+
+import os
+import logging
+import time
+from typing import Optional
+
+try:
+    import rowan
+except ImportError:
+    rowan = None
+
+# Setup logging
+logger = logging.getLogger(__name__)
+
+
+
+def log_rowan_api_call(workflow_type: str, **kwargs):
+    """Log Rowan API calls with detailed parameters."""
+    
+    try:
+        start_time = time.time()
+        result = rowan.compute(workflow_type=workflow_type, **kwargs)
+        api_time = time.time() - start_time
+        
+        if isinstance(result, dict) and 'uuid' in result:
+            job_status = result.get('status', result.get('object_status', 'Unknown'))
+            status_names = {0: "Queued", 1: "Running", 2: "Completed", 3: "Failed", 4: "Stopped", 5: "Awaiting Queue"}
+            status_text = status_names.get(job_status, f"Unknown ({job_status})")
+        
+        return result
+        
+    except Exception as e:
+        api_time = time.time() - start_time
+        raise e
+
+def rowan_descriptors(
+    name: str,
+    molecule: str,
+    folder_uuid: Optional[str] = None,
+    blocking: bool = True,
+    ping_interval: int = 5
+) -> str:
+    """Calculate molecular descriptors for data science.
+    
+    Generates comprehensive molecular descriptors including:
+    - Topological and geometric descriptors
+    - Electronic and physicochemical properties
+    - Graph-based molecular features
+    - Machine learning ready feature vectors
+    
+    Use this for: QSAR modeling, machine learning, chemical space analysis
+    
+    Args:
+        name: Name for the calculation
+        molecule: Molecule SMILES string
+        folder_uuid: Optional folder UUID for organization
+        blocking: Whether to wait for completion (default: True)
+        ping_interval: Check status interval in seconds (default: 5)
+    
+    Returns:
+        Molecular descriptors results
+    """
+    result = log_rowan_api_call(
+        workflow_type="descriptors",
+        name=name,
+        molecule=molecule,
+        folder_uuid=folder_uuid,
+        blocking=blocking,
+        ping_interval=ping_interval
+    )
+    return str(result)
+
+def test_rowan_descriptors():
+    """Test the rowan_descriptors function."""
+    try:
+        # Test with a simple molecule (non-blocking to avoid long wait)
+        result = rowan_descriptors("test_descriptors", "CCO", blocking=False)
+        print(" Descriptors test successful!")
+        print(f"Result length: {len(result)} characters")
+        return True
+    except Exception as e:
+        print(f" Descriptors test failed: {e}")
+        return False
+
+if __name__ == "__main__":
+    test_rowan_descriptors()