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

rowan_mcp/__init__.py

@@ -6,7 +6,7 @@ for integrating with Rowan's computational chemistry platform.
 """
 
 __version__ = "1.0.0"
-__author__ = "Rowan MCP Team"
+__author__ = "Kat Yenko"
 __description__ = "MCP server for Rowan computational chemistry platform"
 
 from .server import main

rowan_mcp/functions/conformers.py

@@ -42,8 +42,8 @@ def rowan_conformers(
     folder_uuid: Optional[str] = None,
     blocking: bool = True,
     ping_interval: int = 5
-) -> str:
-    """Generate and optimize molecular conformers using Rowan's conformer_search workflow.
+):
+    """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
@@ -65,7 +65,7 @@ def rowan_conformers(
             f"Invalid mode '{mode}'. Valid modes are: {', '.join(valid_modes)}"
         )
     
-    result = log_rowan_api_call(
+    return log_rowan_api_call(
         workflow_type="conformer_search",
         name=name,
         molecule=molecule,
@@ -75,61 +75,6 @@ def rowan_conformers(
         blocking=blocking,
         ping_interval=ping_interval
     )
-    
-    # Format results based on whether we waited or not
-    if blocking:
-        # We waited for completion - format actual results
-        status = result.get('status', result.get('object_status', 'Unknown'))
-        
-        if status == 2:  # Completed successfully
-            formatted = f" Conformer search for '{name}' completed successfully!\n\n"
-        elif status == 3:  # Failed
-            formatted = f" Conformer search for '{name}' failed!\n\n"
-        else:
-            formatted = f" Conformer search for '{name}' finished with status {status}\n\n"
-            
-        formatted += f" Molecule: {molecule}\n"
-        formatted += f" Job UUID: {result.get('uuid', 'N/A')}\n"
-        formatted += f" Status: {status}\n"
-        formatted += f" Mode: {mode.upper()}\n"
-        formatted += f" Max Conformers: {max_conformers}\n"
-        
-        # Try to extract actual results
-        if isinstance(result, dict) and 'object_data' in result and result['object_data']:
-            data = result['object_data']
-            
-            # Count conformers found
-            if 'conformers' in data:
-                conformer_count = len(data['conformers']) if isinstance(data['conformers'], list) else data.get('num_conformers', 'Unknown')
-                formatted += f" Generated Conformers: {conformer_count}\n"
-            
-            # Energy information
-            if 'energies' in data and isinstance(data['energies'], list) and data['energies']:
-                energies = data['energies']
-                min_energy = min(energies)
-                max_energy = max(energies)
-                energy_range = max_energy - min_energy
-                formatted += f" Energy Range: {min_energy:.3f} to {max_energy:.3f} kcal/mol (Δ={energy_range:.3f})\n"
-                formatted += f" Lowest Energy Conformer: {min_energy:.3f} kcal/mol\n"
-            
-            # Additional properties if available
-            if 'properties' in data:
-                props = data['properties']
-                formatted += f" Properties calculated: {', '.join(props.keys())}\n"
-        
-        # Basic guidance
-        if status == 2:
-            formatted += f"\n Use rowan_workflow_management(action='retrieve', workflow_uuid='{result.get('uuid')}') for detailed data\n"
-    else:
-        # Non-blocking mode - just submission confirmation
-        formatted = f" Conformer search for '{name}' submitted!\n\n"
-        formatted += f" Molecule: {molecule}\n"
-        formatted += f" Job UUID: {result.get('uuid', 'N/A')}\n"
-        formatted += f" Status: {result.get('status', 'Submitted')}\n"
-        formatted += f" Mode: {mode.upper()}\n"
-        formatted += f" Max Conformers: {max_conformers}\n"
-    
-    return formatted
 
 if __name__ == "__main__":
     pass 

rowan_mcp/functions/electronic_properties.py

@@ -186,68 +186,10 @@ def rowan_electronic_properties(
             **electronic_params
         )
         
-        # Enhanced result formatting for electronic properties
-        if blocking:
-            status = result.get('status', result.get('object_status', 'Unknown'))
-            
-            if status == 2:  # Completed successfully
-                formatted = f"Electronic properties calculation for '{name}' completed successfully!\n\n"
-            elif status == 3:  # Failed
-                formatted = f"Electronic properties calculation for '{name}' failed!\n\n"
-            else:
-                formatted = f"Electronic properties calculation for '{name}' submitted!\n\n"
-            
-            formatted += f"Molecule: {molecule}\n"
-            formatted += f"Canonical SMILES: {canonical_smiles}\n"
-            formatted += f"Job UUID: {result.get('uuid', 'N/A')}\n"
-            formatted += f"Status: {status}\n\n"
-            
-            formatted += f"Molecule Lookup: Advanced PubChemPy + SQLite + RDKit system\n\n"
-            formatted += f"Calculation Settings:\n"
-            formatted += f"• Method: {method.upper()}\n"
-            formatted += f"• Basis Set: {basis_set}\n"
-            formatted += f"• Engine: {engine.upper()}\n"
-            formatted += f"• Charge: {charge}, Multiplicity: {multiplicity}\n\n"
-            
-            formatted += f"Property Calculations:\n"
-            formatted += f"• Density Cube: {'Enabled' if compute_density_cube else 'Disabled'}\n"
-            formatted += f"• ESP Cube: {'Enabled' if compute_electrostatic_potential_cube else 'Disabled'}\n"
-            formatted += f"• Occupied MOs: {compute_num_occupied_orbitals}\n"
-            formatted += f"• Virtual MOs: {compute_num_virtual_orbitals}\n\n"
-            
-            if status == 2:
-                formatted += f"Additional Analysis:\n"
-                formatted += f"• Use rowan_calculation_retrieve('{result.get('uuid')}') for full calculation details\n"
-                formatted += f"• Use rowan_workflow_management(action='retrieve', workflow_uuid='{result.get('uuid')}') for workflow metadata\n"
-                
-            elif status == 3:
-                formatted += f"Troubleshooting:\n"
-                formatted += f"• Try simpler method/basis: method='hf', basis_set='sto-3g'\n"
-                formatted += f"• Check molecular charge and multiplicity\n"
-                formatted += f"• Disable cube generation for faster calculations\n"
-                formatted += f"• Use rowan_workflow_management(action='retrieve', workflow_uuid='{result.get('uuid')}') for error details\n"
-            else:
-                formatted += f"Next Steps:\n"
-                formatted += f"• Monitor status with rowan_workflow_management(action='retrieve', workflow_uuid='{result.get('uuid')}')\n"
-                formatted += f"• Electronic properties calculations may take several minutes\n"
-            
-            return formatted
-        else:
-            return str(result)
+        return result
             
     except Exception as e:
-        error_msg = f"Electronic properties calculation failed: {str(e)}\n\n"
-        error_msg += f"Molecule: {molecule}\n"
-        error_msg += f"Canonical SMILES: {canonical_smiles}\n"
-        error_msg += f"Settings: {method}/{basis_set}/{engine}\n\n"
-        error_msg += f"Molecule Lookup: Advanced PubChemPy + SQLite + RDKit system\n\n"
-        error_msg += f"Common Issues:\n"
-        error_msg += f"• Invalid method/basis set combination\n"
-        error_msg += f"• Incorrect charge/multiplicity for molecule\n"
-        error_msg += f"• Engine compatibility issues\n"
-        error_msg += f"• Molecule not found in PubChem database\n"
-        error_msg += f"• Try with default parameters first\n"
-        return error_msg
+        return f"Electronic properties calculation failed: {str(e)}"
 
 def test_electronic_properties():
     """Test the electronic properties function with advanced molecule lookup."""

rowan_mcp/functions/fukui.py

@@ -54,53 +54,33 @@ def log_rowan_api_call(workflow_type: str, **kwargs):
         raise e
 
 def lookup_molecule_smiles(molecule_name: str) -> str:
-    """Look up canonical SMILES for common molecule names."""
-    # Common molecule SMILES database
-    MOLECULE_SMILES = {
-        # Aromatics
-        "phenol": "Oc1ccccc1",
-        "benzene": "c1ccccc1", 
-        "toluene": "Cc1ccccc1",
-        "aniline": "Nc1ccccc1",
-        "benzoic acid": "O=C(O)c1ccccc1",
-        "salicylic acid": "O=C(O)c1ccccc1O",
-        "aspirin": "CC(=O)Oc1ccccc1C(=O)O",
+    """Look up canonical SMILES using the advanced molecule_lookup system.
+    
+    Uses PubChemPy + SQLite caching + RDKit validation for scalable molecule lookup.
+    """
+    try:
+        # Import the advanced molecule lookup system
+        from .molecule_lookup import get_lookup_instance
         
-        # Solvents
-        "water": "O",
-        "acetone": "CC(=O)C",
-        "dmso": "CS(=O)C",
-        "dmf": "CN(C)C=O",
-        "thf": "C1CCOC1",
-        "dioxane": "C1COCCO1",
-        "chloroform": "ClC(Cl)Cl",
-        "dichloromethane": "ClCCl",
+        lookup = get_lookup_instance()
+        smiles, source, metadata = lookup.get_smiles(molecule_name)
         
-        # Others
-        "glucose": "OC[C@H]1OC(O)[C@H](O)[C@@H](O)[C@@H]1O",
-        "ethylene": "C=C",
-        "acetylene": "C#C",
-        "formaldehyde": "C=O",
-        "ammonia": "N",
-        "hydrogen peroxide": "OO",
-        "carbon dioxide": "O=C=O",
-    }
-    
-    # Normalize the input (lowercase, strip whitespace)
-    normalized_name = molecule_name.lower().strip()
-    
-    # Direct lookup
-    if normalized_name in MOLECULE_SMILES:
-        return MOLECULE_SMILES[normalized_name]
-    
-    # Try partial matches for common variations
-    for name, smiles in MOLECULE_SMILES.items():
-        if normalized_name in name or name in normalized_name:
-            logger.info(f"SMILES Lookup (partial match): '{molecule_name}' → '{name}' → '{smiles}'")
+        if smiles:
+            logger.info(f"Molecule lookup successful: '{molecule_name}' → '{smiles}' (source: {source})")
             return smiles
-    
-    # If no match found, return the original input (assume it's already SMILES)
-    return molecule_name
+        else:
+            logger.warning(f"Molecule lookup failed for '{molecule_name}': {metadata.get('error', 'Unknown error')}")
+            # Return original input as fallback (might be valid SMILES)
+            return molecule_name
+            
+    except ImportError as e:
+        logger.error(f"Could not import molecule_lookup: {e}")
+        # Fallback: return original input
+        return molecule_name
+    except Exception as e:
+        logger.error(f"Molecule lookup error for '{molecule_name}': {e}")
+        # Fallback: return original input
+        return molecule_name
 
 def rowan_fukui(
     name: str,
@@ -135,9 +115,12 @@ def rowan_fukui(
     - Per-atom reactivity indices for site-specific analysis
     - Global reactivity descriptors
     
+    **Molecule Lookup**: Uses advanced PubChemPy + SQLite caching + RDKit validation system
+    for robust molecule identification and SMILES canonicalization.
+    
     Args:
         name: Name for the calculation
-        molecule: Molecule SMILES string or common name (e.g., "phenol", "benzene")
+        molecule: Molecule name (e.g., "aspirin", "taxol") or SMILES string
         optimize: Whether to optimize geometry before Fukui calculation (default: True)
         opt_method: Method for optimization (default: None, uses engine default)
         opt_basis_set: Basis set for optimization (default: None, uses engine default)
@@ -212,135 +195,16 @@ def rowan_fukui(
     if fukui_engine:
         fukui_params["fukui_engine"] = fukui_engine.lower()
     
-    result = log_rowan_api_call(
-        workflow_type="fukui",
-        **fukui_params
-    )
-    
-    if blocking:
-        status = result.get('status', result.get('object_status', 'Unknown'))
-        
-        if status == 2:  # Completed successfully
-            formatted = f"Fukui analysis for '{name}' completed successfully!\n\n"
-        elif status == 3:  # Failed
-            formatted = f"Fukui analysis for '{name}' failed!\n\n"
-        else:
-            formatted = f"Fukui analysis for '{name}' finished with status {status}\n\n"
-            
-        formatted += f"Molecule: {molecule}\n"
-        formatted += f"SMILES: {canonical_smiles}\n"
-        formatted += f"Job UUID: {result.get('uuid', 'N/A')}\n"
-        formatted += f"Status: {status}\n"
-        
-        # Computational settings summary
-        formatted += f"\nComputational Settings:\n"
-        formatted += f"   Optimization: {'Enabled' if optimize else 'Disabled'}\n"
-        if optimize:
-            opt_method_display = opt_settings.get('method', 'default') if opt_settings else 'default'
-            formatted += f"   Opt Method: {opt_method_display.upper()}\n"
-            if opt_engine:
-                formatted += f"   Opt Engine: {opt_engine.upper()}\n"
-        formatted += f"   Fukui Method: {fukui_method.upper()}\n"
-        if fukui_engine:
-            formatted += f"   Fukui Engine: {fukui_engine.upper()}\n"
-        formatted += f"   Charge: {charge}, Multiplicity: {multiplicity}\n"
+    try:
+        result = log_rowan_api_call(
+            workflow_type="fukui",
+            **fukui_params
+        )
         
-        # Try to extract Fukui results
-        if isinstance(result, dict) and 'object_data' in result and result['object_data']:
-            data = result['object_data']
-            
-            # Global electrophilicity index
-            if 'global_electrophilicity_index' in data and data['global_electrophilicity_index'] is not None:
-                gei = data['global_electrophilicity_index']
-                formatted += f"\nGlobal Electrophilicity Index: {gei:.4f}\n"
-                if gei > 1.5:
-                    formatted += f"   → Strong electrophile (highly reactive towards nucleophiles)\n"
-                elif gei > 0.8:
-                    formatted += f"   → Moderate electrophile\n"
-                else:
-                    formatted += f"   → Weak electrophile\n"
+        return result
             
-            # Fukui indices per atom
-            fukui_available = []
-            if 'fukui_positive' in data and data['fukui_positive']:
-                fukui_available.append("f(+)")
-            if 'fukui_negative' in data and data['fukui_negative']:
-                fukui_available.append("f(-)")
-            if 'fukui_zero' in data and data['fukui_zero']:
-                fukui_available.append("f(0)")
-                
-            if fukui_available:
-                formatted += f"\nFukui Indices Available: {', '.join(fukui_available)}\n"
-                
-                # Analyze most reactive sites
-                formatted += f"\nMost Reactive Sites:\n"
-                
-                # f(+) - electrophilic attack sites
-                if 'fukui_positive' in data and data['fukui_positive']:
-                    f_plus = data['fukui_positive']
-                    if isinstance(f_plus, list) and len(f_plus) > 0:
-                        # Find top 3 sites
-                        indexed_values = [(i+1, val) for i, val in enumerate(f_plus) if val is not None]
-                        top_f_plus = sorted(indexed_values, key=lambda x: x[1], reverse=True)[:3]
-                        formatted += f"   f(+) Top Sites (electrophilic attack): "
-                        formatted += f"{', '.join([f'Atom {atom}({val:.3f})' for atom, val in top_f_plus])}\n"
-                
-                # f(-) - nucleophilic attack sites  
-                if 'fukui_negative' in data and data['fukui_negative']:
-                    f_minus = data['fukui_negative']
-                    if isinstance(f_minus, list) and len(f_minus) > 0:
-                        indexed_values = [(i+1, val) for i, val in enumerate(f_minus) if val is not None]
-                        top_f_minus = sorted(indexed_values, key=lambda x: x[1], reverse=True)[:3]
-                        formatted += f"   f(-) Top Sites (nucleophilic attack): "
-                        formatted += f"{', '.join([f'Atom {atom}({val:.3f})' for atom, val in top_f_minus])}\n"
-                
-                # f(0) - radical attack sites
-                if 'fukui_zero' in data and data['fukui_zero']:
-                    f_zero = data['fukui_zero']
-                    if isinstance(f_zero, list) and len(f_zero) > 0:
-                        indexed_values = [(i+1, val) for i, val in enumerate(f_zero) if val is not None]
-                        top_f_zero = sorted(indexed_values, key=lambda x: x[1], reverse=True)[:3]
-                        formatted += f"   f(0) Top Sites (radical attack): "
-                        formatted += f"{', '.join([f'Atom {atom}({val:.3f})' for atom, val in top_f_zero])}\n"
-        
-        # Status-specific guidance
-        formatted += f"\nNext Steps:\n"
-        if status == 2:  # Completed
-            formatted += f"• Use rowan_workflow_management(action='retrieve', workflow_uuid='{result.get('uuid')}') for full per-atom data\n"
-            formatted += f"• Higher Fukui values indicate more reactive sites\n"
-            formatted += f"• f(+) predicts where nucleophiles will attack\n"
-            formatted += f"• f(-) predicts where electrophiles will attack\n"
-            formatted += f"• f(0) predicts radical reaction sites\n"
-        elif status == 3:  # Failed
-            formatted += f"• Use rowan_workflow_management(action='retrieve', workflow_uuid='{result.get('uuid')}') for error details\n"
-            formatted += f"• Troubleshooting:\n"
-            formatted += f"  - Try disabling optimization: optimize=False\n"
-            formatted += f"  - Use faster Fukui method: fukui_method='gfn1_xtb'\n"
-            formatted += f"  - Check if molecule SMILES is valid\n"
-            formatted += f"  - Verify charge and multiplicity are correct\n"
-        elif status in [0, 1, 5]:  # Running
-            formatted += f"• Check progress: rowan_workflow_management(action='status', workflow_uuid='{result.get('uuid')}')\n"
-            if optimize:
-                formatted += f"• Two-step process: optimization → Fukui calculation\n"
-            formatted += f"• Fukui analysis may take 5-20 minutes depending on method and molecule size\n"
-        elif status == 4:  # Stopped
-            formatted += f"• Check why stopped: rowan_workflow_management(action='retrieve', workflow_uuid='{result.get('uuid')}')\n"
-            formatted += f"• You can restart with same or modified parameters\n"
-        else:  # Unknown
-            formatted += f"• Check status: rowan_workflow_management(action='status', workflow_uuid='{result.get('uuid')}')\n"
-        
-        return formatted
-    else:
-        formatted = f"Fukui analysis for '{name}' submitted!\n\n"
-        formatted += f"Molecule: {molecule}\n"
-        formatted += f"SMILES: {canonical_smiles}\n"
-        formatted += f"Job UUID: {result.get('uuid', 'N/A')}\n"
-        formatted += f"Status: {result.get('status', 'Submitted')}\n"
-        formatted += f"Optimization: {'Enabled' if optimize else 'Disabled'}\n"
-        formatted += f"Fukui Method: {fukui_method.upper()}\n"
-        formatted += f"Charge: {charge}, Multiplicity: {multiplicity}\n"
-        formatted += f"\nUse rowan_workflow_management tools to check progress and retrieve results\n"
-        return formatted
+    except Exception as e:
+        return f"Fukui analysis failed: {str(e)}"
 
 def test_fukui():
     """Test the fukui function."""

rowan_mcp/functions/macropka.py

@@ -1,7 +1,6 @@
 """MacropKa workflow function for MCP server."""
 
 import os
-import json
 import logging
 from typing import Optional, Union, List
 
@@ -61,11 +60,11 @@ def rowan_macropka(
     try:
         # Validate pH range
         if min_pH >= max_pH:
-            return json.dumps({"error": "min_pH must be less than max_pH"})
+            return "Error: min_pH must be less than max_pH"
         
         # Validate charge range  
         if min_charge >= max_charge:
-            return json.dumps({"error": "min_charge must be less than max_charge"})
+            return "Error: min_charge must be less than max_charge"
             
         # Log the API call
         log_rowan_api_call(
@@ -102,85 +101,11 @@ def rowan_macropka(
             compute_solvation_energy=compute_solvation_energy
         )
         
-        if blocking:
-            # Format completed results
-            status = result.get("status", "unknown")
-            uuid = result.get("uuid", "unknown")
-            
-            if status == "success":
-                object_data = result.get("object_data", {})
-                
-                # Extract key results
-                microstates = object_data.get("microstates", [])
-                pka_values = object_data.get("pKa_values", [])
-                isoelectric_point = object_data.get("isoelectric_point")
-                solvation_energy = object_data.get("solvation_energy")
-                kpuu_probability = object_data.get("kpuu_probability")
-                microstate_weights_by_pH = object_data.get("microstate_weights_by_pH", [])
-                logD_by_pH = object_data.get("logD_by_pH", [])
-                aqueous_solubility_by_pH = object_data.get("aqueous_solubility_by_pH", [])
-                
-                formatted = f"✅ MacropKa calculation completed successfully!\n"
-                formatted += f"🔖 Workflow UUID: {uuid}\n"
-                formatted += f"📋 Status: {status}\n\n"
-                
-                # Format pKa values
-                if pka_values:
-                    formatted += "📊 pKa Values:\n"
-                    for pka in pka_values:
-                        formatted += f"   • {pka.get('initial_charge', 'N/A')} → {pka.get('final_charge', 'N/A')}: pKa = {pka.get('pKa', 'N/A')}\n"
-                    formatted += "\n"
-                
-                # Format microstates
-                if microstates:
-                    formatted += f"🔬 Microstates ({len(microstates)} found):\n"
-                    for i, microstate in enumerate(microstates[:5]):  # Show first 5
-                        formatted += f"   {i+1}. Charge: {microstate.get('charge', 'N/A')}, Energy: {microstate.get('energy', 'N/A')} kcal/mol\n"
-                    if len(microstates) > 5:
-                        formatted += f"   ... and {len(microstates) - 5} more\n"
-                    formatted += "\n"
-                
-                # Add other properties
-                if isoelectric_point is not None:
-                    formatted += f"⚡ Isoelectric Point: pH {isoelectric_point}\n"
-                
-                if solvation_energy is not None:
-                    formatted += f"💧 Solvation Energy: {solvation_energy} kcal/mol\n"
-                    
-                if kpuu_probability is not None:
-                    formatted += f"🧠 Kpuu Probability (≥0.3): {kpuu_probability:.2%}\n"
-                
-                # Show pH-dependent properties if available
-                if logD_by_pH:
-                    formatted += f"\n📈 logD values available for {len(logD_by_pH)} pH points\n"
-                    
-                if aqueous_solubility_by_pH:
-                    formatted += f"💧 Aqueous solubility values available for {len(aqueous_solubility_by_pH)} pH points\n"
-                    
-                if microstate_weights_by_pH:
-                    formatted += f"⚖️  Microstate weights available for {len(microstate_weights_by_pH)} pH points\n"
-                
-                return formatted
-            else:
-                # Handle failed calculation
-                return f"❌ MacropKa calculation failed\n🔖 UUID: {uuid}\n📋 Status: {status}\n💬 Check workflow details for more information"
-        else:
-            # Non-blocking mode - return submission confirmation
-            uuid = result.get("uuid", "unknown")
-            formatted = f"📋 MacropKa calculation submitted!\n"
-            formatted += f"🔖 Workflow UUID: {uuid}\n"
-            formatted += f"⏳ Status: Running...\n"
-            formatted += f"💡 Use rowan_workflow_management to check status\n"
-            formatted += f"\nCalculation parameters:\n"
-            formatted += f"   • pH range: {min_pH} - {max_pH}\n"
-            formatted += f"   • Charge range: {min_charge} to {max_charge}\n"
-            formatted += f"   • Compute solvation energy: {compute_solvation_energy}\n"
-            formatted += f"   • Compute aqueous solubility: {compute_aqueous_solubility}\n"
-            return formatted
+        return result
             
     except Exception as e:
         logger.error(f"Error in rowan_macropka: {str(e)}")
-        return json.dumps({"error": str(e)})
+        return f"MacropKa calculation failed: {str(e)}"
 
 
 # Test function