Update autodE/mcp_output/mcp_plugin/mcp_service.py

autodE/mcp_output/mcp_plugin/mcp_service.py

@@ -1,423 +1,148 @@
-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")
 
-# ============================================================================
-# Molecule and Species Creation Tools
-# ============================================================================
-
-@mcp.tool()
-def create_molecule_from_smiles(smiles: str, name: str = "molecule") -> dict:
+@mcp.tool(name="optimize_geometry", description="Optimize the geometry of a molecule")
+def optimize_geometry(molecule: dict) -> dict:
     """
-    Create a molecule from a SMILES string.
+    Optimize the geometry of a molecule using autode.
 
     Parameters:
-    - smiles: SMILES string representation (e.g., 'CCO' for ethanol)
-    - name: Name for the molecule (default 'molecule')
+    - molecule: A dictionary representing the molecule.
 
     Returns:
-    - dict: Molecule information including atoms count and charge
+    - dict: Optimized geometry and energy.
     """
-    if not AUTODE_AVAILABLE:
-        return {"success": False, "error": "autodE not installed. Requires: rdkit, numpy, networkx, and more"}
-    
     try:
-        mol = Molecule(smiles=smiles, name=name)
-        return {
-            "success": True,
-            "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()
-def get_atom_properties(element: str) -> dict:
-    """
-    Get properties of an atom given its element symbol.
-
-    Parameters:
-    - element: Chemical symbol (e.g., 'H', 'C', 'O', 'N')
-
-    Returns:
-    - dict: Atom properties including mass and atomic number
-    """
-    if not AUTODE_AVAILABLE:
-        return {"success": False, "error": "autodE not installed"}
-    
-    try:
-        atom = Atom(element)
+        from autode.species.molecule import Molecule
+        from autode.opt.optimisers import BFGS
+        
+        mol = Molecule(**molecule)
+        mol.optimise(method=BFGS())
+        
         return {
             "success": True,
-            "element": element,
-            "atomic_number": atom.atomic_number,
-            "atomic_mass": atom.mass,
-            "atomic_symbol": atom.label
+            "optimized_geometry": mol.coordinates,
+            "energy": mol.energy
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
-
-# ============================================================================
-# Reaction Setup Tools
-# ============================================================================
-
-@mcp.tool()
-def create_reaction_from_smiles(reactant_smiles: str, product_smiles: str, 
-                                name: str = "reaction", solvent_name: str = None) -> dict:
+@mcp.tool(name="calculate_reaction_energy", description="Calculate the reaction energy for a given reaction")
+def calculate_reaction_energy(reactants: list, products: list) -> dict:
     """
-    Create a reaction from reactant and product SMILES strings.
+    Calculate the reaction energy for a given reaction.
 
     Parameters:
-    - 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)
+    - reactants: A list of reactant molecules.
+    - products: A list of product molecules.
 
     Returns:
-    - dict: Reaction information
+    - dict: Reaction energy.
     """
-    if not AUTODE_AVAILABLE:
-        return {"success": False, "error": "autodE not installed"}
-    
     try:
-        # Create reaction using simplified notation
-        reaction_smiles = f"{reactant_smiles}>>{product_smiles}"
-        rxn = Reaction(reaction_smiles, name=name, solvent_name=solvent_name)
+        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()
         
         return {
             "success": True,
-            "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
+            "reaction_energy": reaction.reaction_energy
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
-
-@mcp.tool()
-def set_n_cores(n_cores: int) -> dict:
+@mcp.tool(name="generate_conformers", description="Generate conformers for a molecule")
+def generate_conformers(molecule: dict) -> dict:
     """
-    Set the number of CPU cores to use for calculations.
+    Generate conformers for a molecule.
 
     Parameters:
-    - n_cores: Number of cores (positive integer)
+    - molecule: A dictionary representing the molecule.
 
     Returns:
-    - dict: Updated configuration
+    - dict: Generated conformers.
     """
-    if not AUTODE_AVAILABLE:
-        return {"success": False, "error": "autodE not installed"}
-    
     try:
-        if n_cores < 1:
-            return {"success": False, "error": "n_cores must be at least 1"}
+        from autode.conformers.conformers import Conformers
+        from autode.species.molecule import Molecule
         
-        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"
-            }
-        }
+        mol = Molecule(**molecule)
+        conformers = Conformers.generate(mol)
         
         return {
             "success": True,
-            "methods": available_methods,
-            "current_hcode": Config.hcode,
-            "current_lcode": Config.lcode
+            "conformers": [conf.coordinates for conf in conformers]
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
-
-# ============================================================================
-# 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:
+@mcp.tool(name="locate_transition_state", description="Locate the transition state for a reaction")
+def locate_transition_state(reactants: list, products: list) -> dict:
     """
-    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.
+    Locate the transition state for a reaction.
 
     Parameters:
-    - 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)
+    - reactants: A list of reactant molecules.
+    - products: A list of product molecules.
 
     Returns:
-    - dict: Molecule information
+    - dict: Transition state geometry and energy.
     """
-    if not AUTODE_AVAILABLE:
-        return {"success": False, "error": "autodE not installed"}
-    
     try:
-        # Parse XYZ string
-        lines = xyz_string.strip().split('\n')
-        atoms = []
+        from autode.transition_states.transition_state import TransitionState
+        from autode.species.molecule import Molecule
         
-        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))
+        reactant_mols = [Molecule(**r) for r in reactants]
+        product_mols = [Molecule(**p) for p in products]
         
-        mol = Molecule(name=name, charge=charge, mult=mult, atoms=atoms)
+        ts = TransitionState(reactants=reactant_mols, products=product_mols)
+        ts.locate()
         
         return {
             "success": True,
-            "name": mol.name,
-            "n_atoms": mol.n_atoms,
-            "charge": mol.charge,
-            "mult": mol.mult
+            "ts_geometry": ts.coordinates,
+            "ts_energy": ts.energy
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
-
-@mcp.tool()
-def list_supported_solvents() -> dict:
+@mcp.tool(name="calculate_hessian", description="Calculate the Hessian matrix for a molecule")
+def calculate_hessian(molecule: dict) -> dict:
     """
-    List commonly supported solvent names.
+    Calculate the Hessian matrix for a molecule.
 
-    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.
+    Parameters:
+    - molecule: A dictionary representing the molecule.
 
     Returns:
-    - dict: Version and capabilities
+    - dict: Hessian matrix.
     """
-    if not AUTODE_AVAILABLE:
-        return {
-            "success": False,
-            "available": False,
-            "message": "autodE not installed. Requires: pip install autode rdkit numpy networkx scipy matplotlib"
-        }
-    
     try:
+        from autode.hessians.hessians import Hessian
+        from autode.species.molecule import Molecule
+        
+        mol = Molecule(**molecule)
+        hessian = Hessian(mol)
+        
         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/"
+            "hessian_matrix": hessian.matrix
         }
     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 service instance.
+    - FastMCP: The FastMCP application instance.
     """
     return mcp