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

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

rowan_mcp/functions/molecule_lookup.py

@@ -1,446 +1,57 @@
-"""
-Advanced molecule lookup using PubChemPy + SQLite Cache + RDKit validation.
-"""
+from urllib.request import urlopen
+from urllib.parse import quote
 
-import sqlite3
-import logging
-from datetime import datetime, timedelta
-from typing import Optional, Tuple
-import os
 
-# Set up logging
-logger = logging.getLogger(__name__)
-
-# Import dependencies with fallbacks
-try:
-    import pubchempy as pcp
-    PUBCHEMPY_AVAILABLE = True
-except ImportError:
-    logger.warning("pubchempy not available - install with: pip install pubchempy")
-    PUBCHEMPY_AVAILABLE = False
-
-try:
-    from rdkit import Chem
-    from rdkit.Chem import Descriptors
-    RDKIT_AVAILABLE = True
-except ImportError:
-    logger.warning("rdkit not available - install with: pip install rdkit")
-    RDKIT_AVAILABLE = False
-
-class MoleculeLookup:
-    """Molecule lookup with PubChem API, SQLite caching, and RDKit validation."""
-    
-    def __init__(self, cache_db: str = 'molecule_cache.db', cache_expiry_days: int = 30):
-        """Initialize the molecule lookup system."""
-        self.cache_expiry_days = cache_expiry_days
-        
-        # Create cache database
-        cache_path = os.path.join(os.path.dirname(__file__), cache_db)
-        self.conn = sqlite3.connect(cache_path, check_same_thread=False)
-        
-        # Create tables if they don't exist
-        self.conn.execute('''
-            CREATE TABLE IF NOT EXISTS molecules (
-                identifier TEXT PRIMARY KEY,
-                smiles TEXT,
-                canonical_smiles TEXT,
-                name TEXT,
-                iupac_name TEXT,
-                formula TEXT,
-                molecular_weight REAL,
-                cid INTEGER,
-                retrieved_at TIMESTAMP,
-                source TEXT
-            )
-        ''')
-        
-        self.conn.execute('''
-            CREATE TABLE IF NOT EXISTS lookup_stats (
-                date TEXT PRIMARY KEY,
-                cache_hits INTEGER DEFAULT 0,
-                api_calls INTEGER DEFAULT 0,
-                failed_lookups INTEGER DEFAULT 0
-            )
-        ''')
-        
-        self.conn.commit()
-        logger.info("Molecule lookup cache initialized")
-    
-    def validate_smiles(self, smiles: str) -> Optional[str]:
-        """Validate and canonicalize SMILES using RDKit."""
-        if not RDKIT_AVAILABLE:
-            logger.warning("RDKit not available - returning SMILES as-is")
-            return smiles
-        
-        try:
-            mol = Chem.MolFromSmiles(smiles)
-            if mol is not None:
-                canonical = Chem.MolToSmiles(mol, canonical=True)
-                logger.debug(f"SMILES validated: {smiles} -> {canonical}")
-                return canonical
-        except Exception as e:
-            logger.warning(f"SMILES validation failed for {smiles}: {e}")
-        
-        return None
-    
-    def get_molecular_properties(self, smiles: str) -> dict:
-        """Calculate molecular properties using RDKit."""
-        if not RDKIT_AVAILABLE:
-            return {}
-        
-        try:
-            mol = Chem.MolFromSmiles(smiles)
-            if mol is not None:
-                return {
-                    'molecular_weight': round(Descriptors.MolWt(mol), 2),
-                    'logp': round(Descriptors.MolLogP(mol), 2),
-                    'hbd': Descriptors.NumHDonors(mol),
-                    'hba': Descriptors.NumHAcceptors(mol),
-                    'rotatable_bonds': Descriptors.NumRotatableBonds(mol),
-                    'aromatic_rings': Descriptors.NumAromaticRings(mol)
-                }
-        except Exception as e:
-            logger.warning(f"Property calculation failed for {smiles}: {e}")
-        
-        return {}
-    
-    def _is_cache_valid(self, retrieved_at: str) -> bool:
-        """Check if cache entry is still valid."""
-        try:
-            cache_time = datetime.fromisoformat(retrieved_at)
-            expiry_time = datetime.now() - timedelta(days=self.cache_expiry_days)
-            return cache_time > expiry_time
-        except:
-            return False
-    
-    def _update_stats(self, stat_type: str):
-        """Update lookup statistics."""
-        today = datetime.now().date().isoformat()
-        
-        # Insert or update today's stats
-        self.conn.execute(f'''
-            INSERT OR IGNORE INTO lookup_stats (date, {stat_type}) VALUES (?, 1)
-        ''', (today,))
-        
-        self.conn.execute(f'''
-            UPDATE lookup_stats SET {stat_type} = {stat_type} + 1 WHERE date = ?
-        ''', (today,))
-        
-        self.conn.commit()
-    
-    def get_smiles(self, identifier: str) -> Tuple[Optional[str], str, dict]:
-        """Get canonical SMILES for a molecule identifier."""
-        identifier = identifier.strip()
-        identifier_lower = identifier.lower()
-        
-        # 1. Check cache first
-        cursor = self.conn.execute('''
-            SELECT smiles, canonical_smiles, name, iupac_name, formula, 
-                   molecular_weight, cid, retrieved_at, source 
-            FROM molecules WHERE identifier = ?
-        ''', (identifier_lower,))
-        
-        result = cursor.fetchone()
-        if result:
-            retrieved_at = result[7]
-            if self._is_cache_valid(retrieved_at):
-                self._update_stats('cache_hits')
-                logger.info(f"Cache hit for: {identifier}")
-                
-                metadata = {
-                    'name': result[2],
-                    'iupac_name': result[3],
-                    'formula': result[4],
-                    'molecular_weight': result[5],
-                    'cid': result[6],
-                    'source': result[8],
-                    'cached': True
-                }
-                
-                return result[1], result[8], metadata  # Return canonical_smiles
-        
-        # 2. Check if input is already a valid SMILES
-        validated_smiles = self.validate_smiles(identifier)
-        if validated_smiles and validated_smiles != identifier:
-            logger.info(f"Input was valid SMILES, canonicalized: {identifier} -> {validated_smiles}")
-            
-            # Cache the result
-            metadata = {'source': 'input_smiles', 'cached': False}
-            properties = self.get_molecular_properties(validated_smiles)
-            metadata.update(properties)
-            
-            self._cache_result(identifier_lower, identifier, validated_smiles, 
-                             "User Input SMILES", "", "", 
-                             properties.get('molecular_weight'), None, 'input_smiles')
-            
-            return validated_smiles, 'input_smiles', metadata
-        
-        # 3. Fetch from PubChem using PubChemPy
-        if not PUBCHEMPY_AVAILABLE:
-            logger.error("PubChemPy not available for API lookup")
-            self._update_stats('failed_lookups')
-            return None, 'error', {'error': 'PubChemPy not available'}
-        
-        try:
-            self._update_stats('api_calls')
-            logger.info(f"PubChem API lookup for: {identifier}")
-            
-            # Try name lookup first
-            compounds = pcp.get_compounds(identifier, 'name')
-            
-            # If name lookup fails, try as SMILES/InChI
-            if not compounds:
-                compounds = pcp.get_compounds(identifier, 'smiles')
-            
-            if compounds:
-                compound = compounds[0]
-                
-                # Validate the SMILES from PubChem
-                pubchem_smiles = compound.canonical_smiles
-                validated_smiles = self.validate_smiles(pubchem_smiles)
-                
-                if validated_smiles:
-                    # Get additional properties
-                    properties = self.get_molecular_properties(validated_smiles)
-                    
-                    # Cache the successful result
-                    self._cache_result(
-                        identifier_lower,
-                        pubchem_smiles,
-                        validated_smiles,
-                        getattr(compound, 'iupac_name', '') or identifier,
-                        getattr(compound, 'iupac_name', ''),
-                        getattr(compound, 'molecular_formula', ''),
-                        properties.get('molecular_weight') or getattr(compound, 'molecular_weight', None),
-                        getattr(compound, 'cid', None),
-                        'pubchem'
-                    )
-                    
-                    metadata = {
-                        'name': identifier,
-                        'iupac_name': getattr(compound, 'iupac_name', ''),
-                        'formula': getattr(compound, 'molecular_formula', ''),
-                        'molecular_weight': properties.get('molecular_weight') or getattr(compound, 'molecular_weight', None),
-                        'cid': getattr(compound, 'cid', None),
-                        'source': 'pubchem',
-                        'cached': False
-                    }
-                    metadata.update(properties)
-                    
-                    logger.info(f"PubChem lookup successful: {identifier} -> {validated_smiles}")
-                    return validated_smiles, 'pubchem', metadata
-        
-        except Exception as e:
-            logger.error(f"PubChem lookup failed for {identifier}: {e}")
-            self._update_stats('failed_lookups')
-            return None, 'error', {'error': str(e)}
-        
-        # 4. No results found
-        logger.warning(f"No results found for: {identifier}")
-        self._update_stats('failed_lookups')
-        return None, 'not_found', {'error': 'No results found'}
+def CIRconvert(ids):
+    """
+    Convert molecule name/identifier to SMILES using Chemical Identifier Resolver.
     
-    def _cache_result(self, identifier: str, original_smiles: str, canonical_smiles: str,
-                     name: str, iupac_name: str, formula: str, 
-                     molecular_weight: Optional[float], cid: Optional[int], source: str):
-        """Cache a successful lookup result."""
-        try:
-            self.conn.execute('''
-                INSERT OR REPLACE INTO molecules 
-                (identifier, smiles, canonical_smiles, name, iupac_name, formula, 
-                 molecular_weight, cid, retrieved_at, source)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            ''', (identifier, original_smiles, canonical_smiles, name, iupac_name,
-                  formula, molecular_weight, cid, datetime.now().isoformat(), source))
-            
-            self.conn.commit()
-            logger.debug(f"Cached result for: {identifier}")
-        except Exception as e:
-            logger.error(f"Failed to cache result: {e}")
+    Args:
+        ids (str): Molecule name or identifier (e.g., 'Aspirin', '3-Methylheptane', CAS numbers)
     
-    def get_cache_stats(self) -> dict:
-        """Get cache usage statistics."""
-        cursor = self.conn.execute('''
-            SELECT COUNT(*) as total_entries,
-                   COUNT(CASE WHEN source = 'pubchem' THEN 1 END) as pubchem_entries,
-                   COUNT(CASE WHEN source = 'input_smiles' THEN 1 END) as smiles_entries
-            FROM molecules
-        ''')
-        
-        cache_stats = cursor.fetchone()
-        
-        cursor = self.conn.execute('''
-            SELECT SUM(cache_hits) as total_hits,
-                   SUM(api_calls) as total_calls,
-                   SUM(failed_lookups) as total_failures
-            FROM lookup_stats
-        ''')
-        
-        usage_stats = cursor.fetchone()
-        
-        return {
-            'total_cached_molecules': cache_stats[0] or 0,
-            'pubchem_entries': cache_stats[1] or 0,
-            'smiles_entries': cache_stats[2] or 0,
-            'total_cache_hits': usage_stats[0] or 0,
-            'total_api_calls': usage_stats[1] or 0,
-            'total_failures': usage_stats[2] or 0
-        }
-
-# Global instance
-_lookup_instance = None
+    Returns:
+        str: SMILES string if found, 'Did not work' if failed
+    """
+    try:
+        url = 'http://cactus.nci.nih.gov/chemical/structure/' + quote(ids) + '/smiles'
+        ans = urlopen(url).read().decode('utf8')
+        return ans
+    except:
+        return 'Did not work'
 
-def get_lookup_instance():
-    """Get or create the global MoleculeLookup instance."""
-    global _lookup_instance
-    if _lookup_instance is None:
-        _lookup_instance = MoleculeLookup()
-    return _lookup_instance
 
-def rowan_molecule_lookup(molecule_name: str, show_properties: bool = False) -> str:
-    """Advanced molecule lookup with PubChem API, SQLite caching, and RDKit validation.
-    
-    Features:
-    - PubChemPy integration for reliable API access
-    - SQLite caching for faster repeated lookups
-    - RDKit validation and canonicalization
-    - Comprehensive molecular properties
-    - Usage statistics and cache management
+def rowan_molecule_lookup(molecule_name: str) -> str:
+    """
+    Convert a molecule name to SMILES using Chemical Identifier Resolver.
     
     Args:
-        molecule_name: Name of the molecule (e.g., "aspirin", "taxol", "remdesivir")
-        show_properties: Include molecular properties in output
+        molecule_name (str): Name of the molecule (e.g., 'aspirin', 'benzene')
     
     Returns:
-        Comprehensive molecule information with canonical SMILES
+        str: SMILES notation, or error message if not found
     """
+    smiles = CIRconvert(molecule_name)
     
-    if not molecule_name.strip():
-        lookup = get_lookup_instance()
-        stats = lookup.get_cache_stats()
-        
-        formatted = "**Advanced Molecule SMILES Lookup**\n\n"
-        formatted += "**Features:**\n"
-        formatted += "• PubChemPy integration - Official PubChem API access\n"
-        formatted += "• SQLite caching - Faster repeated lookups\n"
-        formatted += "• RDKit validation - Canonical SMILES standardization\n"
-        formatted += "• Molecular properties - MW, LogP, H-bond donors/acceptors\n\n"
-        
-        formatted += "**Usage Examples:**\n"
-        formatted += "• rowan_molecule_lookup('aspirin') - Look up pharmaceuticals\n"
-        formatted += "• rowan_molecule_lookup('taxol') - Complex natural products\n"
-        formatted += "• rowan_molecule_lookup('remdesivir') - Modern drugs\n"
-        formatted += "• rowan_molecule_lookup('SMILES_STRING') - Validate existing SMILES\n\n"
-        
-        formatted += "**Cache Statistics:**\n"
-        formatted += f"• Cached molecules: {stats['total_cached_molecules']}\n"
-        formatted += f"• Cache hits: {stats['total_cache_hits']}\n"
-        formatted += f"• API calls made: {stats['total_api_calls']}\n"
-        formatted += f"• Failed lookups: {stats['total_failures']}\n\n"
-        
-        formatted += "**Dependencies Status:**\n"
-        formatted += f"• PubChemPy: {'✓ Available' if PUBCHEMPY_AVAILABLE else '✗ Missing (pip install pubchempy)'}\n"
-        formatted += f"• RDKit: {'✓ Available' if RDKIT_AVAILABLE else '✗ Missing (pip install rdkit)'}\n"
-        
-        return formatted
+    if smiles == 'Did not work':
+        return f"{molecule_name}: Not found"
+    else:
+        return smiles.strip()  # Remove any trailing newlines
+
+
+def batch_convert(identifiers):
+    """
+    Convert multiple molecule identifiers to SMILES.
     
-    lookup = get_lookup_instance()
-    smiles, source, metadata = lookup.get_smiles(molecule_name)
+    Args:
+        identifiers (list): List of molecule names/identifiers
     
-    if source == 'error':
-        formatted = f"**Lookup Error for '{molecule_name}'**\n\n"
-        formatted += f"**Error:** {metadata.get('error', 'Unknown error')}\n\n"
-        formatted += "**Troubleshooting:**\n"
-        formatted += "• Check internet connection for PubChem access\n"
-        formatted += "• Verify molecule name spelling\n"
-        formatted += "• Try alternative names or systematic names\n"
-        return formatted
+    Returns:
+        dict: Dictionary mapping identifiers to SMILES
+    """
+    results = {}
     
-    elif source == 'not_found':
-        formatted = f"**No results found for '{molecule_name}'**\n\n"
-        formatted += "**Searched in:**\n"
-        formatted += "• PubChem database (via PubChemPy)\n"
-        formatted += "• Local SQLite cache\n\n"
-        formatted += "**Suggestions:**\n"
-        formatted += "• Check spelling of molecule name\n"
-        formatted += "• Try alternative names (e.g., 'acetaminophen' vs 'paracetamol')\n"
-        formatted += "• Try systematic IUPAC name\n"
-        formatted += "• Try CAS registry number\n"
-        formatted += "• If you have a SMILES string, it will be validated automatically\n"
-        return formatted
+    for ids in identifiers:
+        results[ids] = CIRconvert(ids)
     
-    else:
-        source_names = {
-            'pubchem': 'PubChem Database (via PubChemPy)',
-            'input_smiles': 'Input SMILES Validation (RDKit)',
-            'cache': 'Local Cache'
-        }
-        
-        formatted = f"**SMILES lookup successful!** {'(Cached)' if metadata.get('cached') else ''}\n\n"
-        formatted += f"**Molecule:** {molecule_name}\n"
-        formatted += f"**Canonical SMILES:** {smiles}\n"
-        formatted += f"**Source:** {source_names.get(source, source)}\n\n"
-        
-        # Add molecular information if available
-        if metadata.get('name') and metadata['name'] != molecule_name:
-            formatted += f"**Common Name:** {metadata['name']}\n"
-        
-        if metadata.get('iupac_name'):
-            formatted += f"**IUPAC Name:** {metadata['iupac_name']}\n"
-        
-        if metadata.get('formula'):
-            formatted += f"**Formula:** {metadata['formula']}\n"
-        
-        if metadata.get('cid'):
-            formatted += f"**PubChem CID:** {metadata['cid']}\n"
-        
-        # Add molecular properties if requested or available
-        if show_properties or any(key in metadata for key in ['molecular_weight', 'logp', 'hbd', 'hba']):
-            formatted += "\n**Molecular Properties:**\n"
-            
-            if metadata.get('molecular_weight'):
-                formatted += f"• Molecular Weight: {metadata['molecular_weight']:.2f} g/mol\n"
-            
-            if metadata.get('logp') is not None:
-                formatted += f"• LogP: {metadata['logp']:.2f}\n"
-            
-            if metadata.get('hbd') is not None:
-                formatted += f"• H-bond Donors: {metadata['hbd']}\n"
-            
-            if metadata.get('hba') is not None:
-                formatted += f"• H-bond Acceptors: {metadata['hba']}\n"
-            
-            if metadata.get('rotatable_bonds') is not None:
-                formatted += f"• Rotatable Bonds: {metadata['rotatable_bonds']}\n"
-            
-            if metadata.get('aromatic_rings') is not None:
-                formatted += f"• Aromatic Rings: {metadata['aromatic_rings']}\n"
-        
-        formatted += f"\n**Usage:** Use '{smiles}' in Rowan calculations for consistent results\n"
-        
-        return formatted
-
-def test_rowan_molecule_lookup():
-    """Test the advanced molecule lookup function."""
-    try:
-        print("Testing advanced molecule lookup...")
-        
-        # Test common molecule
-        print("1. Testing phenol...")
-        result1 = rowan_molecule_lookup("phenol")
-        print("✓ Phenol lookup successful")
-        
-        # Test cache stats
-        print("2. Testing cache statistics...")
-        result2 = rowan_molecule_lookup("")
-        print("✓ Cache statistics successful")
-        
-        print("Advanced molecule lookup test successful!")
-        return True
-    except Exception as e:
-        print(f"Advanced molecule lookup test failed: {e}")
-        return False
-
-if __name__ == "__main__":
-    test_rowan_molecule_lookup() 
+    return results 
 

{rowan_mcp-1.0.0.dist-info → rowan_mcp-1.0.1.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: rowan-mcp
-Version: 1.0.0
+Version: 1.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 <katherineyenko@example.com>
+Author-email: Katherine Yenko <katherineayenko@gmail.com>
 License: MIT
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Science/Research
@@ -32,7 +32,7 @@ Description-Content-Type: text/markdown
 
 # Rowan MCP Server
 
-This project wraps an MCP (Model Context Protocol) around Rowan's tools, making it easy for users to submit complex quantum chemistry calculations in natural everyday language. 
+This project wraps an MCP (Model Context Protocol) around Rowan's tools, making it easy for users to design molecuels and run simulations in natural everyday language. 
 
 ---
 
@@ -52,36 +52,17 @@ That's it - no command line setup needed!
 
 ## **Package Installation**
 
-### **Using uv (recommended):**
-```bash
-# Install the package
-uv add rowan-mcp
-```
-
-### **Using pip:**
-```bash
-# Install the package
-pip install rowan-mcp
-
-# Or in a virtual environment
-python -m venv venv
-source venv/bin/activate  # On Windows: venv\Scripts\activate
-pip install rowan-mcp
-```
-
-### **Get API Key & Configure**
+### **Option 1: Auto-Install (No manual installation needed!)**
 
-1. **Get your API key**: Visit [labs.rowansci.com](https://labs.rowansci.com) → Create account → Generate API key
+Just add this to your MCP configuration and it will automatically install and run:
 
-2. **Configure your MCP client** (e.g., Claude Code, VSCode, Cursor, etc.):
-
-**With uv:**
+**Using uvx (simplest):**
 ```json
 {
   "mcpServers": {
     "rowan": {
-      "command": "uv",
-      "args": ["run", "rowan-mcp"],
+      "command": "uvx",
+      "args": ["--from", "rowan-mcp", "rowan-mcp"],
       "env": {
         "ROWAN_API_KEY": "your_api_key_here"
       }
@@ -90,12 +71,13 @@ pip install rowan-mcp
 }
 ```
 
-**With pip/system Python:**
+**Using uv run (alternative):**
 ```json
 {
   "mcpServers": {
     "rowan": {
-      "command": "rowan-mcp",
+      "command": "uv",
+      "args": ["run", "--with", "rowan-mcp", "-m", "rowan_mcp"],
       "env": {
         "ROWAN_API_KEY": "your_api_key_here"
       }
@@ -104,30 +86,26 @@ pip install rowan-mcp
 }
 ```
 
-### **Start Using**
-Ask your AI: *"Calculate the pKa of aspirin"* or *"Optimize the geometry of caffeine"*
+### **Option 2: Manual Installation**
 
----
-
-## **Development Installation**
+If you prefer to install the package first:
 
-**For developers or contributors:**
+**Using uv:**
+```bash
+uv add rowan-mcp
+```
 
-### **1. Clone and Setup**
+**Using pip:**
 ```bash
-git clone https://github.com/k-yenko/rowan-mcp.git
-cd rowan-mcp
-uv sync
+pip install rowan-mcp
 ```
 
-### **2. Configure for Development**
+Then use this configuration:
 ```json
 {
   "mcpServers": {
     "rowan": {
-      "command": "uv",
-      "args": ["run", "python", "-m", "rowan_mcp"],
-      "cwd": "/path/to/rowan-mcp",
+      "command": "rowan-mcp",
       "env": {
         "ROWAN_API_KEY": "your_api_key_here"
       }
@@ -136,7 +114,13 @@ uv sync
 }
 ```
 
-*Replace `/path/to/rowan-mcp` with your actual clone path. Find it with `pwd` in the project directory.*
+### **Get API Key**
+
+Visit [labs.rowansci.com](https://labs.rowansci.com) → Create account → Generate API key
+
+### **Start Using**
+
+Ask your AI: *"Calculate the pKa of aspirin"* or *"Optimize the geometry of caffeine"*
 
 ---
 
@@ -155,7 +139,6 @@ Ask the LLM to:
 - **Rowan API key** (free at [labs.rowansci.com](https://labs.rowansci.com))
 - **MCP-compatible client** (Claude Desktop, etc.)
 
-
 **Development commands** (if you cloned the repo):
 ```bash
 # Run from source
@@ -164,7 +147,7 @@ uv run python -m rowan_mcp --http
 
 ---
 
-## Available Tools
+## **Available Tools**
 
 ### Chemistry Calculations
 - `rowan_basic_calculation` - Energy, optimization, frequencies
@@ -183,7 +166,6 @@ uv run python -m rowan_mcp --http
 ### Drug Discovery
 - `rowan_admet` - ADME-Tox properties
 
-
 ### Reactivity Analysis  
 - `rowan_fukui` - Reactivity sites
 - `rowan_spin_states` - Spin multiplicities
@@ -192,13 +174,13 @@ uv run python -m rowan_mcp --http
 - `rowan_folder_create/list/update/delete` - Organize calculations
 - `rowan_workflow_create/list/status/stop` - Manage workflows
 
-## Requirements
+## **Requirements**
 
 - Python 3.10+
 - Rowan API key
 - MCP-compatible AI assistant (Claude Desktop, etc.)
 
-## Getting Help
+## **Getting Help**
 
 - **Documentation**: [docs.rowansci.com](https://docs.rowansci.com/)
 - or ping me! 
@@ -218,7 +200,7 @@ uv run python -m rowan_mcp --http
 - [ ] Multistage optimization sometimes shows unexpected imaginary frequencies
 - [ ] Some calculations show as finished in logs but not in Rowan UI
 
-## Citation
+## **Citation**
 
 If you use this MCP tool in your research, please cite the underlying Rowan platform:
 

{rowan_mcp-1.0.0.dist-info → rowan_mcp-1.0.1.dist-info}/RECORD

@@ -4,20 +4,19 @@ rowan_mcp/server.py,sha256=47MsJchxzqRVd4mFQXR81wYXBX8B8fFUkl7wDYB5uMs,7702
 rowan_mcp/functions/admet.py,sha256=m_RD7OJ8GDocEInHw4zOmk4tBf2mWBGTL3LVt-vo_mU,2438
 rowan_mcp/functions/bde.py,sha256=x6Wmnqzy3zRDvSM_AlxSm_0ksg9lI2zV1PiBzXjU_sU,3634
 rowan_mcp/functions/calculation_retrieve.py,sha256=jL28RKvZX3QUeZ_qDlBfLdGG_Lsk6LyA1xjsHvPM-mg,3376
-rowan_mcp/functions/conformers.py,sha256=tzMMeZ44Vw5ZmD9wZtGxyFlwoeu1izr6wdAFNwwwGKA,5171
+rowan_mcp/functions/conformers.py,sha256=2Bjim0v5xajWykVwRU9YPwtNyqIo6n2wiLDgR2_5wE8,2552
 rowan_mcp/functions/descriptors.py,sha256=HJXsMZmgx-PdqfSe39D0BcMxzRYmR38gt98fXIMc69w,2747
 rowan_mcp/functions/docking.py,sha256=J-bcgig_68x07eCpVPG1ZJKdUFsPVeDuvhoeM9Y9V9I,13954
 rowan_mcp/functions/docking_enhanced.py,sha256=lwviIWg_26VW8VlITIlHd-Lbw8E25tnvNrLfzK6fLJs,5528
-rowan_mcp/functions/electronic_properties.py,sha256=qJpn-iEXTsk_wVcHYVq-7TLK7_T3JP-z7viHxg2L434,11741
+rowan_mcp/functions/electronic_properties.py,sha256=hBpUz0lP5ImRS8U8Cqd04tl_vzyoUSl3eP1sHKvG7Yg,8154
 rowan_mcp/functions/folder_management.py,sha256=qPZ6cjC2AFxr1BhXpRsJk2AZAF7GV5ojy6oJDQjYKbw,4874
-rowan_mcp/functions/fukui.py,sha256=HvR8qC_eBJ2ojGhf50DIGVr9luowMvfPnU8txyfCVaQ,15339
+rowan_mcp/functions/fukui.py,sha256=7uz0kQ-Bt9_m4YXto4BlEJFbAknusnwZlfl67tWrwmg,7750
 rowan_mcp/functions/hydrogen_bond_basicity.py,sha256=xH7czHEF_stKnQoh-F93b8G8936DCTYjkf6nTa7kmKo,3081
 rowan_mcp/functions/irc.py,sha256=ulMfkpVTXoQDwFVzAJRcEbyZpFxM2LucO7Mq-XkgNTs,4096
-rowan_mcp/functions/macropka.py,sha256=CreAYpGKpJ9pQBgpEHXnN3kCH33qbm08Xa7jKhPkMic,8219
+rowan_mcp/functions/macropka.py,sha256=ze0D8R5-1-FLfOLXNe06I-BUAUKF9CHeWuTYw30sT1s,3985
 rowan_mcp/functions/molecular_converter.py,sha256=j9YeCnaHZahwkhG2EZNPu5VVmGy2sqIHPB_qf1ojoec,17349
 rowan_mcp/functions/molecular_dynamics.py,sha256=yzA03LeFv8K59Cg1SAnavWwmodl4_KW667pRHJQTXNw,6990
-rowan_mcp/functions/molecule_cache.db,sha256=Fq1LLzSFPy4f7MrZPLhMhU3yA_gE10YQUPLhIQcfHQU,28672
-rowan_mcp/functions/molecule_lookup.py,sha256=I0infAB-9zN6LNCEyEQNDvLvlQ5L5nOrVJGWF6jLD9s,18466
+rowan_mcp/functions/molecule_lookup.py,sha256=Ff3ARljNbLlGgSinREl6OFxoJ-HVXtbXPxy-r_6CMKs,1467
 rowan_mcp/functions/multistage_opt.py,sha256=lWwgXZgpXnWsjgonkA1toks4t01Cdxo822xmT2EOssM,6185
 rowan_mcp/functions/pdb_handler.py,sha256=EnhRqxStnke5kiSnDaWOzcJT8fAHW6VVIhTaH6ODkWE,6241
 rowan_mcp/functions/pka.py,sha256=EFGIFtq2HrtNzcU5-3-ncgmpiwIGnOE-vROjr_eC1Nk,5014
@@ -29,7 +28,7 @@ rowan_mcp/functions/spin_states.py,sha256=NG7uJjTi_Fx-E4Qr7RzjNhfFmKlHfIGMD0Uhyo
 rowan_mcp/functions/system_management.py,sha256=UwdKD46FNEJh1zEPpvFW7-JBD6g8x-xSbmH7lrcubx0,20089
 rowan_mcp/functions/tautomers.py,sha256=oXFUpMgCVtXy2JnyCb8G04vYj_anJj4WThD26ZGOsZ0,2694
 rowan_mcp/functions/workflow_management.py,sha256=EqXRqj0EuJz7h2igqOHBpq23Qyo-KT9geWp39URacxw,21130
-rowan_mcp-1.0.0.dist-info/METADATA,sha256=wqqheHW12cXQmu4Ocp-j551vbx1oJ72P5kB85Q65q8g,6628
-rowan_mcp-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-rowan_mcp-1.0.0.dist-info/entry_points.txt,sha256=QkmK3GHkTNA6gqyTIFrl2V2eVBm-VBdRAlDNsvi4Rl0,52
-rowan_mcp-1.0.0.dist-info/RECORD,,
+rowan_mcp-1.0.1.dist-info/METADATA,sha256=LMlceF8ZjrMjgaJdx7sxCEskrF7E2jMBQsnCyOVFZl0,6262
+rowan_mcp-1.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+rowan_mcp-1.0.1.dist-info/entry_points.txt,sha256=QkmK3GHkTNA6gqyTIFrl2V2eVBm-VBdRAlDNsvi4Rl0,52
+rowan_mcp-1.0.1.dist-info/RECORD,,