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

rowan_mcp/functions_v2/submit_macropka_workflow.py

@@ -0,0 +1,99 @@
+"""
+Rowan v2 API: MacropKa Workflow
+Calculate macroscopic pKa values across a pH range.
+"""
+
+from typing import Annotated
+import rowan
+
+def submit_macropka_workflow(
+    initial_smiles: Annotated[str, "SMILES string of the molecule for macropKa calculation"],
+    min_pH: Annotated[int, "Minimum pH value for the calculation range"] = 0,
+    max_pH: Annotated[int, "Maximum pH value for the calculation range"] = 14,
+    min_charge: Annotated[int, "Minimum molecular charge to consider"] = -2,
+    max_charge: Annotated[int, "Maximum molecular charge to consider"] = 2,
+    compute_solvation_energy: Annotated[bool, "Whether to compute solvation energy corrections"] = True,
+    name: Annotated[str, "Workflow name for identification and tracking"] = "Macropka Workflow",
+    folder_uuid: Annotated[str, "UUID of folder to organize this workflow. Empty string uses default folder"] = "",
+    max_credits: Annotated[int, "Maximum credits to spend on this calculation. 0 for no limit"] = 0
+):
+    """Submit a MacropKa workflow using Rowan v2 API.
+    
+    Args:
+        initial_smiles: SMILES string of the molecule for macropKa calculation
+        min_pH: Minimum pH value for the calculation range
+        max_pH: Maximum pH value for the calculation range
+        min_charge: Minimum molecular charge to consider
+        max_charge: Maximum molecular charge to consider
+        compute_solvation_energy: Whether to compute solvation energy for each species
+        name: Workflow name for identification and tracking
+        folder_uuid: UUID of folder to organize this workflow. Empty string uses default folder.
+        max_credits: Maximum credits to spend on this calculation. 0 for no limit.
+    
+    Calculates macroscopic pKa values across a pH range, determining the
+    protonation states and their populations at different pH values.
+    
+    The workflow will:
+    1. Identify all ionizable sites in the molecule
+    2. Calculate microscopic pKa values for each site
+    3. Determine macroscopic pKa values and species populations
+    4. Optionally compute solvation energies
+    
+    Returns:
+        Workflow object representing the submitted workflow
+        
+    Examples:
+        # Simple molecule macropKa
+        result = submit_macropka_workflow(
+            initial_smiles="CC(=O)O",  # Acetic acid
+            min_pH=0,
+            max_pH=14
+        )
+        
+        # Complex molecule with custom charge range
+        result = submit_macropka_workflow(
+            initial_smiles="CC(C)CC(C(=O)O)N",  # Leucine
+            min_pH=0,
+            max_pH=14,
+            min_charge=-3,
+            max_charge=3,
+            compute_solvation_energy=True
+        )
+    """
+    
+    try:
+        # Build workflow_data
+        workflow_data = {
+            "min_pH": min_pH,
+            "max_pH": max_pH,
+            "min_charge": min_charge,
+            "max_charge": max_charge,
+            "compute_solvation_energy": compute_solvation_energy,
+        }
+        
+        # Build the API request
+        data = {
+            "name": name,
+            "folder_uuid": folder_uuid,
+            "workflow_type": "macropka",
+            "workflow_data": workflow_data,
+            "initial_smiles": initial_smiles,
+            "max_credits": max_credits,
+        }
+        
+        # Submit to API using rowan module
+        return rowan.submit_macropka_workflow(
+            initial_smiles=initial_smiles,
+            min_pH=min_pH,
+            max_pH=max_pH,
+            min_charge=min_charge,
+            max_charge=max_charge,
+            compute_solvation_energy=compute_solvation_energy,
+            name=name,
+            folder_uuid=folder_uuid if folder_uuid else None,
+            max_credits=max_credits if max_credits > 0 else None
+        )
+            
+    except Exception as e:
+        # Re-raise the exception so MCP can handle it
+        raise e

rowan_mcp/functions_v2/submit_pka_workflow.py

@@ -0,0 +1,72 @@
+"""
+Rowan v2 API: pKa Workflow
+Predict acid dissociation constants for ionizable groups in molecules.
+"""
+
+from typing import List, Dict, Any, Annotated
+import rowan
+import json
+import stjames
+
+def submit_pka_workflow(
+    initial_molecule: Annotated[str, "SMILES string of the molecule to calculate pKa"],
+    pka_range: Annotated[List[float], "pKa range [min, max] to search (e.g., [2, 12])"] = [2, 12],
+    deprotonate_elements: Annotated[str, "Comma-separated elements for deprotonation (e.g., 'N,O,S'). Empty for auto-detect"] = "",
+    protonate_elements: Annotated[str, "Comma-separated elements for protonation (e.g., 'N,O'). Empty for auto-detect"] = "",
+    mode: Annotated[str, "Calculation mode: 'rapid', 'careful', or 'meticulous'"] = "careful",
+    name: Annotated[str, "Workflow name for identification and tracking"] = "pKa Workflow",
+    folder_uuid: Annotated[str, "UUID of folder to organize this workflow. Empty string uses default folder"] = "",
+    max_credits: Annotated[int, "Maximum credits to spend on this calculation. 0 for no limit"] = 0
+):
+    """Submit a pKa prediction workflow using Rowan v2 API.
+    
+    Args:
+        initial_molecule: The molecule to calculate the pKa of. SMILES string.
+        pka_range: pKa range [min, max] to search, e.g., [2, 12]
+        deprotonate_elements: Atomic numbers to consider for deprotonation, e.g., "[7, 8, 16]" for N, O, S. Empty string uses defaults.
+        protonate_elements: Atomic numbers to consider for protonation, e.g., "[7, 8]" for N, O. Empty string uses defaults.
+        mode: Calculation mode: 'rapid' (fast), 'careful' (balanced), or 'meticulous' (thorough)
+        name: Workflow name for identification and tracking
+        folder_uuid: UUID of folder to organize this workflow. Empty string uses default folder.
+        max_credits: Maximum credits to spend on this calculation. 0 for no limit.
+    
+    Returns:
+        Workflow object representing the submitted workflow
+        
+    Examples:
+        # Phenol pKa
+        result = submit_pka_workflow(
+            initial_molecule="Oc1ccccc1",
+            name="pKa phenol",
+            deprotonate_elements="[8]"  # Only consider oxygen
+        )
+    """
+    
+    # Handle JSON string inputs for element lists
+    parsed_deprotonate_elements = None
+    if deprotonate_elements:
+        try:
+            parsed_deprotonate_elements = json.loads(deprotonate_elements)
+        except json.JSONDecodeError:
+            pass  # Keep as None if not valid JSON
+            
+    parsed_protonate_elements = None
+    if protonate_elements:
+        try:
+            parsed_protonate_elements = json.loads(protonate_elements)
+        except json.JSONDecodeError:
+            pass  # Keep as None if not valid JSON
+
+    # Convert List[float] to Tuple[float, float] for Rowan SDK compatibility
+    pka_range_tuple = tuple(pka_range) if len(pka_range) == 2 else (pka_range[0], pka_range[1] if len(pka_range) > 1 else pka_range[0])
+    
+    return rowan.submit_pka_workflow(
+        initial_molecule=stjames.Molecule.from_smiles(initial_molecule),
+        pka_range=pka_range_tuple,
+        deprotonate_elements=parsed_deprotonate_elements,
+        protonate_elements=parsed_protonate_elements,
+        mode=mode,
+        name=name,
+        folder_uuid=folder_uuid if folder_uuid else None,
+        max_credits=max_credits if max_credits > 0 else None
+    )

rowan_mcp/functions_v2/submit_protein_cofolding_workflow.py

@@ -0,0 +1,88 @@
+"""
+Rowan v2 API: Protein Cofolding Workflow
+Simulate protein-protein interactions and cofolding.
+"""
+
+from typing import List, Annotated
+import rowan
+import stjames
+import json
+
+
+def submit_protein_cofolding_workflow(
+    initial_protein_sequences: Annotated[str, "JSON string list of protein sequences for cofolding (e.g., '[\"MKLLV...\", \"MAHQR...\"]')"],
+    initial_smiles_list: Annotated[str, "JSON string list of SMILES for ligands to include in cofolding (e.g., '[\"CCO\", \"CC(=O)O\"]'). Empty for protein-only"] = "",
+    ligand_binding_affinity_index: Annotated[str, "JSON string mapping ligand indices to protein binding sites. Empty for automatic detection"] = "",
+    use_msa_server: Annotated[bool, "Whether to use multiple sequence alignment server for better structure prediction"] = True,
+    use_potentials: Annotated[bool, "Whether to include additional potentials in the calculation"] = False,
+    name: Annotated[str, "Workflow name for identification and tracking"] = "Cofolding Workflow",
+    model: Annotated[str, "Structure prediction model to use (e.g., 'boltz_2', 'alphafold3')"] = "boltz_2",
+    folder_uuid: Annotated[str, "UUID of folder to organize this workflow. Empty string uses default folder"] = "",
+    max_credits: Annotated[int, "Maximum credits to spend on this calculation. 0 for no limit"] = 0
+):
+    """Submits a protein cofolding workflow to the API.
+    
+    Args:
+        initial_protein_sequences: JSON string list of protein sequences (amino acid strings) to cofold
+        initial_smiles_list: JSON string list of ligand SMILES strings to include in cofolding. Empty string for protein-only
+        ligand_binding_affinity_index: Index of ligand in initial_smiles_list for binding affinity calculation (e.g., "0"). Empty string skips affinity
+        use_msa_server: Whether to use MSA (Multiple Sequence Alignment) server for improved accuracy
+        use_potentials: Whether to use statistical potentials in the calculation
+        name: Workflow name for identification and tracking
+        model: Cofolding model to use (e.g., 'boltz_2', 'alphafold3')
+        folder_uuid: UUID of folder to organize this workflow. Empty string uses default folder.
+        max_credits: Maximum credits to spend on this calculation. 0 for no limit.
+    
+    Returns:
+        Workflow object representing the submitted workflow
+        
+    Example:
+        # Protein-ligand cofolding with CDK2 kinase (from test)
+        result = submit_protein_cofolding_workflow(
+            initial_protein_sequences='["MENFQKVEKIGEGTYGVVYKARNKLTGEVVALKKIRLDTETEGVPSTAIREISLLKELNHPNIVKLLDVIHTENKLYLVFEFLHQDLKKFMDASALTGIPLPLIKSYLFQLLQGLAFCHSHRVLHRDLKPQNLLINTEGAIKLADFGLARAFGVPVRTYTHEVVTLWYRAPEILLGCKYYSTAVDIWSLGCIFAEMVTRRALFPGDSEIDQLFRIFRTLGTPDEVVWPGVTSMPDYKPSFPKWARQDFSKVVPPLDEDGRSLLSQMLHYDPNKRISAKAALAHPFFQDVTKPVPHLRL"]',
+            initial_smiles_list='["CCC(C)(C)NC1=NCC2(CCC(=O)C2C)N1"]',
+            ligand_binding_affinity_index="0",
+            name="Cofolding CDK2 with ligand"
+        )
+    """
+    # Parse initial_protein_sequences (always a string in simplified version)
+    try:
+        initial_protein_sequences = json.loads(initial_protein_sequences)
+    except (json.JSONDecodeError, ValueError):
+        # Try to parse as comma-separated
+        if ',' in initial_protein_sequences:
+            initial_protein_sequences = [s.strip() for s in initial_protein_sequences.split(',') if s.strip()]
+        else:
+            initial_protein_sequences = [initial_protein_sequences.strip()]
+    
+    # Parse initial_smiles_list if provided
+    parsed_initial_smiles_list = None
+    if initial_smiles_list:
+        try:
+            parsed_initial_smiles_list = json.loads(initial_smiles_list)
+        except (json.JSONDecodeError, ValueError):
+            # Try to parse as comma-separated
+            if ',' in initial_smiles_list:
+                parsed_initial_smiles_list = [s.strip() for s in initial_smiles_list.split(',') if s.strip()]
+            else:
+                parsed_initial_smiles_list = [initial_smiles_list.strip()]
+    
+    # Parse ligand_binding_affinity_index if provided
+    parsed_ligand_index = None
+    if ligand_binding_affinity_index:
+        try:
+            parsed_ligand_index = int(ligand_binding_affinity_index)
+        except (ValueError, TypeError):
+            raise ValueError(f"Invalid ligand_binding_affinity_index: '{ligand_binding_affinity_index}' must be an integer")
+    
+    return rowan.submit_protein_cofolding_workflow(
+        initial_protein_sequences=initial_protein_sequences,
+        initial_smiles_list=parsed_initial_smiles_list,
+        ligand_binding_affinity_index=parsed_ligand_index,
+        use_msa_server=use_msa_server,
+        use_potentials=use_potentials,
+        name=name,
+        model=model,
+        folder_uuid=folder_uuid if folder_uuid else None,
+        max_credits=max_credits if max_credits > 0 else None
+    )

rowan_mcp/functions_v2/submit_redox_potential_workflow.py

@@ -0,0 +1,55 @@
+"""
+Rowan v2 API: Redox Potential Workflow
+Calculate reduction and oxidation potentials for molecules.
+"""
+
+from typing import Annotated
+import rowan
+import stjames
+
+
+def submit_redox_potential_workflow(
+    initial_molecule: Annotated[str, "SMILES string for redox potential calculation"],
+    reduction: Annotated[bool, "Whether to calculate reduction potential (gaining electron)"] = False,
+    oxidization: Annotated[bool, "Whether to calculate oxidation potential (losing electron)"] = True,
+    mode: Annotated[str, "Calculation mode: 'rapid' (fast), 'careful' (balanced), or 'meticulous' (thorough)"] = "rapid",
+    name: Annotated[str, "Workflow name for identification and tracking"] = "Redox Potential Workflow",
+    folder_uuid: Annotated[str, "UUID of folder to organize this workflow. Empty string uses default folder"] = "",
+    max_credits: Annotated[int, "Maximum credits to spend on this calculation. 0 for no limit"] = 0
+):
+    """Submit a redox potential calculation workflow using Rowan v2 API.
+    
+    Args:
+        initial_molecule: SMILES string for redox potential calculation
+        reduction: Whether to calculate reduction potential (gaining electron)
+        oxidization: Whether to calculate oxidation potential (losing electron)
+        mode: Calculation mode: 'rapid' (fast), 'careful' (balanced), or 'meticulous' (thorough)
+        name: Workflow name for identification and tracking
+        folder_uuid: UUID of folder to organize this workflow. Empty string uses default folder.
+        max_credits: Maximum credits to spend on this calculation. 0 for no limit.
+    
+    Calculates reduction and/or oxidation potentials for a molecule using
+    quantum chemistry methods.
+    
+    Returns:
+        Workflow object representing the submitted workflow
+        
+    Example:
+        # Simple redox potential from SMILES
+        result = submit_redox_potential_workflow(
+            initial_molecule="Cc1ccccc1",  # Toluene
+            reduction=True,
+            oxidization=True,
+            name="Toluene Redox Potential"
+        )
+    """
+    
+    return rowan.submit_redox_potential_workflow(
+        initial_molecule=stjames.Molecule.from_smiles(initial_molecule),
+        reduction=reduction,
+        oxidization=oxidization,
+        mode=mode,
+        name=name,
+        folder_uuid=folder_uuid if folder_uuid else None,
+        max_credits=max_credits if max_credits > 0 else None
+    )

rowan_mcp/functions_v2/submit_scan_workflow.py

@@ -0,0 +1,82 @@
+"""
+Rowan v2 API: Scan Workflow
+Perform potential energy surface scans along molecular coordinates.
+"""
+
+from typing import Dict, Any, Annotated
+import rowan
+import stjames
+import json
+
+def submit_scan_workflow(
+    initial_molecule: Annotated[str, "SMILES string to scan"],
+    scan_settings: Annotated[str, "JSON string of scan parameters: '{\"type\": \"dihedral\"/\"bond\"/\"angle\", \"atoms\": [1-indexed], \"start\": value, \"stop\": value, \"num\": points}'"] = "",
+    calculation_engine: Annotated[str, "Computational engine: 'omol25', 'xtb', 'psi4'"] = "omol25",
+    calculation_method: Annotated[str, "Computational method (e.g., 'uma_m_omol', 'gfn2-xtb', 'b3lyp-d3bj')"] = "uma_m_omol",
+    wavefront_propagation: Annotated[bool, "Whether to use wavefront propagation for scan"] = True,
+    name: Annotated[str, "Workflow name for identification and tracking"] = "Scan Workflow",
+    folder_uuid: Annotated[str, "UUID of folder to organize this workflow. Empty string uses default folder"] = "",
+    max_credits: Annotated[int, "Maximum credits to spend on this calculation. 0 for no limit"] = 0
+):
+    """Submit a potential energy surface scan workflow using Rowan v2 API.
+    
+    Args:
+        initial_molecule: SMILES string to scan
+        scan_settings: JSON string of scan parameters: '{"type": "dihedral"/"bond"/"angle", "atoms": [1-indexed], "start": value, "stop": value, "num": points}'
+        calculation_engine: Computational engine: 'omol25', 'xtb', or 'psi4'
+        calculation_method: Calculation method (depends on engine): 'uma_m_omol', 'gfn2_xtb', 'r2scan_3c'
+        wavefront_propagation: Use previous scan point geometries as starting points for faster convergence
+        name: Workflow name for identification and tracking
+        folder_uuid: UUID of folder to organize this workflow. Empty string uses default folder.
+        max_credits: Maximum credits to spend on this calculation. 0 for no limit.
+    
+    Performs systematic scans along specified molecular coordinates (bonds, angles,
+    or dihedrals) to map the potential energy surface.
+    
+    Returns:
+        Workflow object representing the submitted workflow
+        
+    Example:
+        # Water angle scan
+        result = submit_scan_workflow(
+            initial_molecule="O",  # Water SMILES
+            name="Water Angle scan",
+            scan_settings='{"type": "angle", "atoms": [2, 1, 3], "start": 100, "stop": 110, "num": 5}',
+            calculation_method="GFN2-xTB",
+            calculation_engine="xtb"
+        )
+    """
+    # Parse scan_settings if provided
+    parsed_scan_settings = None
+    if scan_settings:
+        try:
+            parsed_scan_settings = json.loads(scan_settings)
+        except (json.JSONDecodeError, ValueError) as e:
+            raise ValueError(f"Invalid scan_settings format: {e}")
+    
+    # Validate and convert scan_settings
+    if parsed_scan_settings is not None:
+        # Convert step to num if step is provided instead of num
+        if 'step' in parsed_scan_settings and 'num' not in parsed_scan_settings:
+            start = parsed_scan_settings.get('start', 0)
+            stop = parsed_scan_settings.get('stop', 360)
+            step = parsed_scan_settings['step']
+            parsed_scan_settings['num'] = int((stop - start) / step) + 1
+            del parsed_scan_settings['step']  # Remove step as API doesn't accept it
+        
+        # Validate required fields
+        required_fields = ['type', 'atoms', 'start', 'stop', 'num']
+        missing_fields = [field for field in required_fields if field not in parsed_scan_settings]
+        if missing_fields:
+            raise ValueError(f"Missing required fields in scan_settings: {missing_fields}")
+    
+    return rowan.submit_scan_workflow(
+        initial_molecule=stjames.Molecule.from_smiles(initial_molecule),
+        scan_settings=parsed_scan_settings,
+        calculation_engine=calculation_engine,
+        calculation_method=calculation_method,
+        wavefront_propagation=wavefront_propagation,
+        name=name,
+        folder_uuid=folder_uuid if folder_uuid else None,
+        max_credits=max_credits if max_credits > 0 else None
+    )

rowan_mcp/functions_v2/submit_solubility_workflow.py

@@ -0,0 +1,157 @@
+"""
+Rowan v2 API: Solubility Workflow
+Predict molecular solubility in various solvents at different temperatures.
+"""
+
+from typing import List, Annotated
+import rowan
+import json
+
+
+def submit_solubility_workflow(
+    initial_smiles: Annotated[str, "SMILES string of the molecule for solubility prediction"],
+    solvents: Annotated[str, "JSON string list of solvents as SMILES or names (e.g., '[\"water\", \"ethanol\", \"CCO\"]'). Empty string uses defaults"] = "",
+    temperatures: Annotated[str, "JSON string list of temperatures in Kelvin (e.g., '[298.15, 310.15]'). Empty string uses default range"] = "",
+    name: Annotated[str, "Workflow name for identification and tracking"] = "Solubility Workflow",
+    folder_uuid: Annotated[str, "UUID of folder to organize this workflow. Empty string uses default folder"] = "",
+    max_credits: Annotated[int, "Maximum credits to spend on this calculation. 0 for no limit"] = 0
+):
+    """Submit a solubility prediction workflow using Rowan v2 API.
+    
+    Args:
+        initial_smiles: SMILES string of the molecule for solubility prediction
+        solvents: JSON string list of solvents as SMILES or names (e.g., '["water", "ethanol", "CCO"]'). Empty string uses defaults
+        temperatures: JSON string list of temperatures in Kelvin (e.g., '[298.15, 310.15]'). Empty string uses default range
+        name: Workflow name for identification and tracking
+        folder_uuid: UUID of folder to organize this workflow. Empty string uses default folder.
+        max_credits: Maximum credits to spend on this calculation. 0 for no limit.
+    
+    Predicts solubility (log S) of a molecule in multiple solvents at various temperatures
+    using machine learning models.
+    
+    Returns:
+        Workflow object representing the submitted workflow
+        
+    Example:
+        # Basic solubility prediction
+        result = submit_solubility_workflow(
+            initial_smiles="CC(=O)Nc1ccc(O)cc1",
+            solvents='["water", "ethanol"]',
+            temperatures='[298.15, 310.15]'
+        )
+        
+        # With SMILES solvents
+        result = submit_solubility_workflow(
+            initial_smiles="CC(=O)O",
+            solvents='["O", "CCO", "CCCCCC"]',
+            temperatures='[273.15, 298.15, 323.15]'
+        )
+    """
+    
+    # Parse solvents parameter - handle string input
+    parsed_solvents = None
+    if solvents:
+        # Handle various string formats
+        solvents = solvents.strip()
+        if solvents.startswith('[') and solvents.endswith(']'):
+            # JSON array format like '["water", "ethanol"]'
+            try:
+                parsed_solvents = json.loads(solvents)
+            except (json.JSONDecodeError, ValueError):
+                # Failed to parse as JSON, try as comma-separated
+                solvents = solvents.strip('[]').replace('"', '').replace("'", "")
+                parsed_solvents = [s.strip() for s in solvents.split(',') if s.strip()]
+        elif ',' in solvents:
+            # Comma-separated format like 'water, ethanol'
+            parsed_solvents = [s.strip() for s in solvents.split(',') if s.strip()]
+        else:
+            # Single solvent as string like 'water'
+            parsed_solvents = [solvents]
+        
+        # Convert solvent names to SMILES if needed
+        solvent_name_to_smiles = {
+            'water': 'O',
+            'ethanol': 'CCO',
+            'dmso': 'CS(=O)C',
+            'acetone': 'CC(=O)C',
+            'methanol': 'CO',
+            'chloroform': 'C(Cl)(Cl)Cl',
+            'dichloromethane': 'C(Cl)Cl',
+            'toluene': 'Cc1ccccc1',
+            'benzene': 'c1ccccc1',
+            'hexane': 'CCCCCC',
+            'ether': 'CCOCC',
+            'diethyl ether': 'CCOCC',
+            'thf': 'C1CCOC1',
+            'tetrahydrofuran': 'C1CCOC1',
+            'dioxane': 'C1COCCO1',
+            'acetonitrile': 'CC#N',
+            'pyridine': 'c1ccncc1'
+        }
+        
+        converted_solvents = []
+        for solvent in parsed_solvents:
+            solvent_lower = solvent.lower().strip()
+            if solvent_lower in solvent_name_to_smiles:
+                converted_solvents.append(solvent_name_to_smiles[solvent_lower])
+            else:
+                # Assume it's already a SMILES string or use as-is
+                converted_solvents.append(solvent)
+        parsed_solvents = converted_solvents
+        
+        # Validate the final solvent SMILES to catch issues early
+        try:
+            from rdkit import Chem
+            for i, solvent_smiles in enumerate(parsed_solvents):
+                mol = Chem.MolFromSmiles(solvent_smiles)
+                if mol is None:
+                    raise ValueError(f"Invalid solvent SMILES: '{solvent_smiles}' at position {i}")
+        except ImportError:
+            # RDKit not available for validation, proceed anyway
+            pass
+    
+    # Parse temperatures parameter - handle string input
+    parsed_temperatures = None
+    if temperatures:
+        # Handle various string formats
+        temperatures = temperatures.strip()
+        if temperatures.startswith('[') and temperatures.endswith(']'):
+            # JSON array format like '[298.15, 310.15]'
+            try:
+                parsed_temperatures = json.loads(temperatures)
+            except (json.JSONDecodeError, ValueError):
+                # Failed to parse as JSON, try as comma-separated
+                temperatures = temperatures.strip('[]').replace('"', '').replace("'", "")
+                parsed_temperatures = [float(t.strip()) for t in temperatures.split(',') if t.strip()]
+        elif ',' in temperatures:
+            # Comma-separated format like '298.15, 310.15'
+            parsed_temperatures = [float(t.strip()) for t in temperatures.split(',') if t.strip()]
+        else:
+            # Single temperature as string like '298.15'
+            parsed_temperatures = [float(temperatures)]
+    
+    # Validate the main SMILES string early to catch issues
+    try:
+        from rdkit import Chem
+        mol = Chem.MolFromSmiles(initial_smiles)
+        if mol is None:
+            raise ValueError(f"Invalid initial SMILES: '{initial_smiles}'")
+    except ImportError:
+        # RDKit not available for validation, proceed anyway
+        pass
+    
+    try:
+        result = rowan.submit_solubility_workflow(
+            initial_smiles=initial_smiles,
+            solvents=parsed_solvents,
+            temperatures=parsed_temperatures,
+            name=name,
+            folder_uuid=folder_uuid if folder_uuid else None,
+            max_credits=max_credits if max_credits > 0 else None
+        )
+        
+        return result
+        
+    except Exception as e:
+        # Re-raise the exception so MCP can handle it
+        raise

rowan_mcp/functions_v2/submit_tautomer_search_workflow.py

@@ -0,0 +1,51 @@
+"""
+Rowan v2 API: Tautomer Search Workflow
+Search for tautomeric forms of molecules.
+"""
+
+from typing import Annotated
+import rowan
+import stjames
+
+def submit_tautomer_search_workflow(
+    initial_molecule: Annotated[str, "SMILES string to search for tautomers"],
+    mode: Annotated[str, "Search mode: 'rapid' (fast), 'careful' (balanced), or 'meticulous' (thorough)"] = "careful",
+    name: Annotated[str, "Workflow name for identification and tracking"] = "Tautomer Search Workflow",
+    folder_uuid: Annotated[str, "UUID of folder to organize this workflow. Empty string uses default folder"] = "",
+    max_credits: Annotated[int, "Maximum credits to spend on this calculation. 0 for no limit"] = 0
+):
+    """Submit a tautomer search workflow using Rowan v2 API.
+    
+    Args:
+        initial_molecule: SMILES string to search for tautomers
+        mode: Search mode: 'rapid' (fast), 'careful' (balanced), or 'meticulous' (thorough)
+        name: Workflow name for identification and tracking
+        folder_uuid: UUID of folder to organize this workflow. Empty string uses default folder.
+        max_credits: Maximum credits to spend on this calculation. 0 for no limit.
+    
+    Searches for different tautomeric forms of a molecule and evaluates their
+    relative stabilities. Tautomers are structural isomers that readily interconvert.
+    
+    Returns:
+        Workflow object representing the submitted workflow
+        
+    Example:
+        # Basic tautomer search
+        result = submit_tautomer_search_workflow(
+            initial_molecule="CC(=O)CC(=O)C"
+        )
+        
+        # Meticulous search for complex molecule
+        result = submit_tautomer_search_workflow(
+            initial_molecule="c1ccc2c(c1)ncc(=O)[nH]2",
+            mode="meticulous"
+        )
+    """
+    
+    return rowan.submit_tautomer_search_workflow(
+        initial_molecule=stjames.Molecule.from_smiles(initial_molecule),
+        mode=mode,
+        name=name,
+        folder_uuid=folder_uuid if folder_uuid else None,
+        max_credits=max_credits if max_credits > 0 else None
+    )