Update autodE/mcp_output/mcp_plugin/mcp_service.py

autodE/mcp_output/mcp_plugin/mcp_service.py

@@ -1,148 +1,423 @@
+import os
+import sys
+
+# Add the local source directory to sys.path
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+if source_path not in sys.path:
+    sys.path.insert(0, source_path)
+
 from fastmcp import FastMCP
 
+# Check if autodE is available
+try:
+    import autode as ade
+    from autode import Atom, Molecule, Reactant, Product, Reaction, Config
+    from autode import Species
+    AUTODE_AVAILABLE = True
+except ImportError:
+    AUTODE_AVAILABLE = False
+
 # Create the FastMCP service application
 mcp = FastMCP("autode_service")
 
-@mcp.tool(name="optimize_geometry", description="Optimize the geometry of a molecule")
-def optimize_geometry(molecule: dict) -> dict:
+# ============================================================================
+# Molecule and Species Creation Tools
+# ============================================================================
+
+@mcp.tool()
+def create_molecule_from_smiles(smiles: str, name: str = "molecule") -> dict:
     """
-    Optimize the geometry of a molecule using autode.
+    Create a molecule from a SMILES string.
 
     Parameters:
-    - molecule: A dictionary representing the molecule.
+    - smiles: SMILES string representation (e.g., 'CCO' for ethanol)
+    - name: Name for the molecule (default 'molecule')
 
     Returns:
-    - dict: Optimized geometry and energy.
+    - dict: Molecule information including atoms count and charge
     """
+    if not AUTODE_AVAILABLE:
+        return {"success": False, "error": "autodE not installed. Requires: rdkit, numpy, networkx, and more"}
+    
     try:
-        from autode.species.molecule import Molecule
-        from autode.opt.optimisers import BFGS
-        
-        mol = Molecule(**molecule)
-        mol.optimise(method=BFGS())
-        
+        mol = Molecule(smiles=smiles, name=name)
         return {
             "success": True,
-            "optimized_geometry": mol.coordinates,
-            "energy": mol.energy
+            "name": mol.name,
+            "smiles": smiles,
+            "n_atoms": mol.n_atoms,
+            "charge": mol.charge,
+            "mult": mol.mult,
+            "formula": str(mol.formula) if hasattr(mol, 'formula') else None
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
-@mcp.tool(name="calculate_reaction_energy", description="Calculate the reaction energy for a given reaction")
-def calculate_reaction_energy(reactants: list, products: list) -> dict:
+
+@mcp.tool()
+def get_atom_properties(element: str) -> dict:
     """
-    Calculate the reaction energy for a given reaction.
+    Get properties of an atom given its element symbol.
 
     Parameters:
-    - reactants: A list of reactant molecules.
-    - products: A list of product molecules.
+    - element: Chemical symbol (e.g., 'H', 'C', 'O', 'N')
 
     Returns:
-    - dict: Reaction energy.
+    - dict: Atom properties including mass and atomic number
     """
+    if not AUTODE_AVAILABLE:
+        return {"success": False, "error": "autodE not installed"}
+    
     try:
-        from autode.reactions.reaction import Reaction
-        from autode.species.molecule import Molecule
-        
-        reactant_mols = [Molecule(**r) for r in reactants]
-        product_mols = [Molecule(**p) for p in products]
-        
-        reaction = Reaction(*reactant_mols, *product_mols)
-        reaction.calculate_reaction_energy()
-        
+        atom = Atom(element)
         return {
             "success": True,
-            "reaction_energy": reaction.reaction_energy
+            "element": element,
+            "atomic_number": atom.atomic_number,
+            "atomic_mass": atom.mass,
+            "atomic_symbol": atom.label
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
-@mcp.tool(name="generate_conformers", description="Generate conformers for a molecule")
-def generate_conformers(molecule: dict) -> dict:
+
+# ============================================================================
+# Reaction Setup Tools
+# ============================================================================
+
+@mcp.tool()
+def create_reaction_from_smiles(reactant_smiles: str, product_smiles: str, 
+                                name: str = "reaction", solvent_name: str = None) -> dict:
     """
-    Generate conformers for a molecule.
+    Create a reaction from reactant and product SMILES strings.
 
     Parameters:
-    - molecule: A dictionary representing the molecule.
+    - reactant_smiles: SMILES of reactant(s), separate multiple with '.'
+    - product_smiles: SMILES of product(s), separate multiple with '.'
+    - name: Name for the reaction (default 'reaction')
+    - solvent_name: Solvent name if needed (optional)
 
     Returns:
-    - dict: Generated conformers.
+    - dict: Reaction information
     """
+    if not AUTODE_AVAILABLE:
+        return {"success": False, "error": "autodE not installed"}
+    
     try:
-        from autode.conformers.conformers import Conformers
-        from autode.species.molecule import Molecule
-        
-        mol = Molecule(**molecule)
-        conformers = Conformers.generate(mol)
+        # Create reaction using simplified notation
+        reaction_smiles = f"{reactant_smiles}>>{product_smiles}"
+        rxn = Reaction(reaction_smiles, name=name, solvent_name=solvent_name)
         
         return {
             "success": True,
-            "conformers": [conf.coordinates for conf in conformers]
+            "name": rxn.name,
+            "reaction_smiles": reaction_smiles,
+            "n_reactants": len(rxn.reacs),
+            "n_products": len(rxn.prods),
+            "solvent": solvent_name
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# ============================================================================
+# Configuration Tools
+# ============================================================================
+
+@mcp.tool()
+def get_config_info() -> dict:
+    """
+    Get current autodE configuration settings.
+
+    Returns:
+    - dict: Configuration parameters
+    """
+    if not AUTODE_AVAILABLE:
+        return {"success": False, "error": "autodE not installed"}
+    
+    try:
+        return {
+            "success": True,
+            "n_cores": Config.n_cores,
+            "max_core": Config.max_core,
+            "hcode": Config.hcode,
+            "lcode": Config.lcode,
+            "ts_guess_methods": Config.ts_guess_methods if hasattr(Config, 'ts_guess_methods') else None,
+            "num_conformers": Config.num_conformers if hasattr(Config, 'num_conformers') else None
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
-@mcp.tool(name="locate_transition_state", description="Locate the transition state for a reaction")
-def locate_transition_state(reactants: list, products: list) -> dict:
+
+@mcp.tool()
+def set_n_cores(n_cores: int) -> dict:
     """
-    Locate the transition state for a reaction.
+    Set the number of CPU cores to use for calculations.
 
     Parameters:
-    - reactants: A list of reactant molecules.
-    - products: A list of product molecules.
+    - n_cores: Number of cores (positive integer)
 
     Returns:
-    - dict: Transition state geometry and energy.
+    - dict: Updated configuration
     """
+    if not AUTODE_AVAILABLE:
+        return {"success": False, "error": "autodE not installed"}
+    
     try:
-        from autode.transition_states.transition_state import TransitionState
-        from autode.species.molecule import Molecule
+        if n_cores < 1:
+            return {"success": False, "error": "n_cores must be at least 1"}
         
-        reactant_mols = [Molecule(**r) for r in reactants]
-        product_mols = [Molecule(**p) for p in products]
-        
-        ts = TransitionState(reactants=reactant_mols, products=product_mols)
-        ts.locate()
+        Config.n_cores = n_cores
+        return {
+            "success": True,
+            "n_cores": Config.n_cores,
+            "message": f"Set to use {n_cores} cores"
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def list_available_methods() -> dict:
+    """
+    List available computational chemistry methods/codes.
+
+    Returns:
+    - dict: Available high-level and low-level methods
+    """
+    if not AUTODE_AVAILABLE:
+        return {"success": False, "error": "autodE not installed"}
+    
+    try:
+        # Common methods autodE supports
+        available_methods = {
+            "high_level": [
+                "orca",
+                "g09", "g16",  # Gaussian
+                "qchem",
+                "nwchem",
+                "psi4"
+            ],
+            "low_level": [
+                "xtb",
+                "mopac",
+                "orca"
+            ],
+            "description": {
+                "orca": "ORCA - general purpose quantum chemistry",
+                "g09/g16": "Gaussian - widely used QM package",
+                "xtb": "GFN-xTB - fast semi-empirical method",
+                "mopac": "MOPAC - semi-empirical methods",
+                "qchem": "Q-Chem",
+                "psi4": "Psi4 - open-source QM",
+                "nwchem": "NWChem"
+            }
+        }
         
         return {
             "success": True,
-            "ts_geometry": ts.coordinates,
-            "ts_energy": ts.energy
+            "methods": available_methods,
+            "current_hcode": Config.hcode,
+            "current_lcode": Config.lcode
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
-@mcp.tool(name="calculate_hessian", description="Calculate the Hessian matrix for a molecule")
-def calculate_hessian(molecule: dict) -> dict:
+
+# ============================================================================
+# Information and Utility Tools
+# ============================================================================
+
+@mcp.tool()
+def get_reaction_example() -> dict:
+    """
+    Get an example of setting up and running a reaction calculation.
+
+    Returns:
+    - dict: Example code for Diels-Alder reaction
+    """
+    if not AUTODE_AVAILABLE:
+        return {"success": False, "error": "autodE not installed"}
+    
+    example_code = """
+import autode as ade
+
+# Configure
+ade.Config.n_cores = 4
+
+# Create reaction from SMILES (Diels-Alder)
+rxn = ade.Reaction('C=CC=C.C=C>>C1=CCCCC1', name='diels_alder')
+
+# Calculate reaction profile (requires QM software installed)
+# rxn.calculate_reaction_profile()
+
+# Access results
+# print(f"Reactants: {rxn.reacs}")
+# print(f"Products: {rxn.prods}")
+# print(f"Transition state: {rxn.ts}")
+"""
+    
+    return {
+        "success": True,
+        "description": "Diels-Alder cycloaddition example",
+        "reaction": "Butadiene + Ethylene -> Cyclohexene",
+        "code": example_code,
+        "note": "Requires external QM software (ORCA, Gaussian, etc.) to be installed"
+    }
+
+
+@mcp.tool()
+def get_sn2_example() -> dict:
     """
-    Calculate the Hessian matrix for a molecule.
+    Get an example of an SN2 reaction setup.
+
+    Returns:
+    - dict: Example code for SN2 reaction
+    """
+    if not AUTODE_AVAILABLE:
+        return {"success": False, "error": "autodE not installed"}
+    
+    example_code = """
+import autode as ade
+
+# SN2 reaction: Cl- + CH3Br -> CH3Cl + Br-
+rxn = ade.Reaction('[Cl-].CBr>>[Br-].CCl', name='sn2')
+
+# Calculate reaction profile
+# rxn.calculate_reaction_profile()
+
+# Access energies
+# delta_e = rxn.delta('energy')
+# delta_h = rxn.delta('enthalpy')
+# delta_g = rxn.delta('free_energy')
+"""
+    
+    return {
+        "success": True,
+        "description": "SN2 nucleophilic substitution example",
+        "reaction": "Cl- + CH3Br -> CH3Cl + Br-",
+        "code": example_code
+    }
+
+
+@mcp.tool()
+def get_molecule_from_xyz(xyz_string: str, name: str = "molecule", 
+                          charge: int = 0, mult: int = 1) -> dict:
+    """
+    Create a molecule from XYZ coordinate string.
 
     Parameters:
-    - molecule: A dictionary representing the molecule.
+    - xyz_string: XYZ format coordinates (element x y z per line)
+    - name: Molecule name (default 'molecule')
+    - charge: Molecular charge (default 0)
+    - mult: Spin multiplicity (default 1)
 
     Returns:
-    - dict: Hessian matrix.
+    - dict: Molecule information
     """
+    if not AUTODE_AVAILABLE:
+        return {"success": False, "error": "autodE not installed"}
+    
     try:
-        from autode.hessians.hessians import Hessian
-        from autode.species.molecule import Molecule
+        # Parse XYZ string
+        lines = xyz_string.strip().split('\n')
+        atoms = []
+        
+        for line in lines:
+            parts = line.split()
+            if len(parts) >= 4:
+                element = parts[0]
+                x, y, z = float(parts[1]), float(parts[2]), float(parts[3])
+                atoms.append(Atom(element, x=x, y=y, z=z))
         
-        mol = Molecule(**molecule)
-        hessian = Hessian(mol)
+        mol = Molecule(name=name, charge=charge, mult=mult, atoms=atoms)
         
         return {
             "success": True,
-            "hessian_matrix": hessian.matrix
+            "name": mol.name,
+            "n_atoms": mol.n_atoms,
+            "charge": mol.charge,
+            "mult": mol.mult
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
+
+@mcp.tool()
+def list_supported_solvents() -> dict:
+    """
+    List commonly supported solvent names.
+
+    Returns:
+    - dict: Available solvent names
+    """
+    if not AUTODE_AVAILABLE:
+        return {"success": False, "error": "autodE not installed"}
+    
+    solvents = [
+        "water", "h2o",
+        "methanol", "meoh",
+        "ethanol", "etoh",
+        "acetone",
+        "acetonitrile", "mecn",
+        "dmso",
+        "dmf",
+        "thf",
+        "dichloromethane", "dcm",
+        "chloroform", "chcl3",
+        "benzene",
+        "toluene",
+        "hexane",
+        "diethyl ether", "ether"
+    ]
+    
+    return {
+        "success": True,
+        "solvents": solvents,
+        "note": "Solvent availability depends on the QM method used"
+    }
+
+
+@mcp.tool()
+def get_autode_info() -> dict:
+    """
+    Get autodE version and installation information.
+
+    Returns:
+    - dict: Version and capabilities
+    """
+    if not AUTODE_AVAILABLE:
+        return {
+            "success": False,
+            "available": False,
+            "message": "autodE not installed. Requires: pip install autode rdkit numpy networkx scipy matplotlib"
+        }
+    
+    try:
+        return {
+            "success": True,
+            "available": True,
+            "version": ade.__version__,
+            "description": "Automated reaction profile generation for organic and organometallic reactions",
+            "capabilities": [
+                "Automated transition state search",
+                "Reaction profile calculation",
+                "Conformer generation",
+                "NEB calculations",
+                "Multistep reactions"
+            ],
+            "github": "https://github.com/duartegroup/autodE",
+            "docs": "https://duartegroup.github.io/autodE/"
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
 def create_app() -> FastMCP:
     """
     Create and return the FastMCP application instance.
 
     Returns:
-    - FastMCP: The FastMCP application instance.
+    - FastMCP: The FastMCP service instance.
     """
     return mcp