rdkit

name rdkit description Cheminformatics toolkit for fine-grained molecular control. SMILES/SDF parsing, descriptors (MW, LogP, TPSA), fingerprints, substructure search, 2D/3D generation, similarity, reactions. For standard workflows with simpler interface, use datamol (wrapper around RDKit). Use rdkit for advanced control, custom sanitization, specialized algorithms. category chemistry license BSD-3-Clause license metadata {"skill-author":"Synthetic Sciences"} version 1.0.0 author Synthetic Sciences tags ["Cheminformatics","Molecules","SMILES","Fingerprints","Drug Discovery"] dependencies ["rdkit-pypi>=2024.3.1"] RDKit Cheminformatics Toolkit Overview RDKit is a comprehensive cheminformatics library providing Python APIs for molecular analysis and manipulation. This skill provides guidance for reading/writing molecular structures, calculating descriptors, fingerprinting, substructure searching, chemical reactions, 2D/3D coordinate generation, and molecular visualization. Use this skill for drug discovery, computational chemistry, and cheminformatics research tasks. Core Capabilities 1. Molecular I/O and Creation Reading Molecules: Read molecular structures from various formats: from rdkit import Chem # From SMILES strings mol = Chem.MolFromSmiles( 'Cc1ccccc1' ) # Returns Mol object or None # From MOL files mol = Chem.MolFromMolFile( 'path/to/file.mol' ) # From MOL blocks (string data) mol = Chem.MolFromMolBlock(mol_block_string) # From InChI mol = Chem.MolFromInchi( 'InChI=1S/C6H6/c1-2-4-6-5-3-1/h1-6H' ) Writing Molecules: Convert molecules to text representations: # To canonical SMILES smiles = Chem.MolToSmiles(mol) # To MOL block mol_block = Chem.MolToMolBlock(mol) # To InChI inchi = Chem.MolToInchi(mol) Batch Processing: For processing multiple molecules, use Supplier/Writer objects: # Read SDF files suppl = Chem.SDMolSupplier( 'molecules.sdf' ) for mol in suppl: if mol is not None : # Check for parsing errors # Process molecule pass # Read SMILES files suppl = Chem.SmilesMolSupplier( 'molecules.smi' , titleLine= False ) # For large files or compressed data with gzip. open ( 'molecules.sdf.gz' ) as f: suppl = Chem.ForwardSDMolSupplier(f) for mol in suppl: # Process molecule pass # Multithreaded processing for large datasets suppl = Chem.MultithreadedSDMolSupplier( 'molecules.sdf' ) # Write molecules to SDF writer = Chem.SDWriter( 'output.sdf' ) for mol in molecules: writer.write(mol) writer.close() Important Notes: All MolFrom* functions return None on failure with error messages Always check for None before processing molecules Molecules are automatically sanitized on import (validates valence, perceives aromaticity) 2. Molecular Sanitization and Validation RDKit automatically sanitizes molecules during parsing, executing 13 steps including valence checking, aromaticity perception, and chirality assignment. Sanitization Control: # Disable automatic sanitization mol = Chem.MolFromSmiles( 'C1=CC=CC=C1' , sanitize= False ) # Manual sanitization Chem.SanitizeMol(mol) # Detect problems before sanitization problems = Chem.DetectChemistryProblems(mol) for problem in problems: print (problem.GetType(), problem.Message()) # Partial sanitization (skip specific steps) from rdkit.Chem import rdMolStandardize Chem.SanitizeMol(mol, sanitizeOps=Chem.SANITIZE_ALL ^ Chem.SANITIZE_PROPERTIES) Common Sanitization Issues: Atoms with explicit valence exceeding maximum allowed will raise exceptions Invalid aromatic rings will cause kekulization errors Radical electrons may not be properly assigned without explicit specification 3. Molecular Analysis and Properties Accessing Molecular Structure: # Iterate atoms and bonds for atom in mol.GetAtoms(): print (atom.GetSymbol(), atom.GetIdx(), atom.GetDegree()) for bond in mol.GetBonds(): print (bond.GetBeginAtomIdx(), bond.GetEndAtomIdx(), bond.GetBondType()) # Ring information ring_info = mol.GetRingInfo() ring_info.NumRings() ring_info.AtomRings() # Returns tuples of atom indices # Check if atom is in ring atom = mol.GetAtomWithIdx( 0 ) atom.IsInRing() atom.IsInRingSize( 6 ) # Check for 6-membered rings # Find smallest set of smallest rings (SSSR) from rdkit.Chem import GetSymmSSSR rings = GetSymmSSSR(mol) Stereochemistry: # Find chiral centers from rdkit.Chem import FindMolChiralCenters chiral_centers = FindMolChiralCenters(mol, includeUnassigned= True ) # Returns list of (atom_idx, chirality) tuples # Assign stereochemistry from 3D coordinates from rdkit.Chem import AssignStereochemistryFrom3D AssignStereochemistryFrom3D(mol) # Check bond stereochemistry bond = mol.GetBondWithIdx( 0 ) stereo = bond.GetStereo() # STEREONONE, STEREOZ, STEREOE, etc. Fragment Analysis: # Get disconnected fragments frags = Chem.GetMolFrags(mol, asMols= True ) # Fragment on specific bonds from rdkit.Chem import FragmentOnBonds frag_mol = FragmentOnBonds(mol, [bond_idx1, bond_idx2]) # Count ring systems from rdkit.Chem.Scaffolds import MurckoScaffold scaffold = MurckoScaffold.GetScaffoldForMol(mol) 4. Molecular Descriptors and Properties Basic Descriptors: from rdkit.Chem import Descriptors # Molecular weight mw = Descriptors.MolWt(mol) exact_mw = Descriptors.ExactMolWt(mol) # LogP (lipophilicity) logp = Descriptors.MolLogP(mol) # Topological polar surface area tpsa = Descriptors.TPSA(mol) # Number of hydrogen bond donors/acceptors hbd = Descriptors.NumHDonors(mol) hba = Descriptors.NumHAcceptors(mol) # Number of rotatable bonds rot_bonds = Descriptors.NumRotatableBonds(mol) # Number of aromatic rings aromatic_rings = Descriptors.NumAromaticRings(mol) Batch Descriptor Calculation: # Calculate all descriptors at once all_descriptors = Descriptors.CalcMolDescriptors(mol) # Returns dictionary: {'MolWt': 180.16, 'MolLogP': 1.23, ...} # Get list of available descriptor names descriptor_names = [desc[ 0 ] for desc in Descriptors._descList] Lipinski's Rule of Five: # Check drug-likeness mw = Descriptors.MolWt(mol) <= 500 logp = Descriptors.MolLogP(mol) <= 5 hbd = Descriptors.NumHDonors(mol) <= 5 hba = Descriptors.NumHAcceptors(mol) <= 10 is_drug_like = mw and logp and hbd and hba 5. Fingerprints and Molecular Similarity Fingerprint Types: from rdkit.Chem import rdFingerprintGenerator from rdkit.Chem import MACCSkeys # RDKit topological fingerprint rdk_gen = rdFingerprintGenerator.GetRDKitFPGenerator(minPath= 1 , maxPath= 7 , fpSize= 2048 ) fp = rdk_gen.GetFingerprint(mol) # Morgan fingerprints (circular fingerprints, similar to ECFP) # Modern API using rdFingerprintGenerator morgan_gen = rdFingerprintGenerator.GetMorganGenerator(radius= 2 , fpSize= 2048 ) fp = morgan_gen.GetFingerprint(mol) # Count-based fingerprint fp_count = morgan_gen.GetCountFingerprint(mol) # MACCS keys (166-bit structural key) fp = MACCSkeys.GenMACCSKeys(mol) # Atom pair fingerprints ap_gen = rdFingerprintGenerator.GetAtomPairGenerator() fp = ap_gen.GetFingerprint(mol) # Topological torsion fingerprints tt_gen = rdFingerprintGenerator.GetTopologicalTorsionGenerator() fp = tt_gen.GetFingerprint(mol) # Avalon fingerprints (if available) from rdkit.Avalon import pyAvalonTools fp = pyAvalonTools.GetAvalonFP(mol) Similarity Calculation: from rdkit import DataStructs from rdkit.Chem import rdFingerprintGenerator # Generate fingerprints using generator mfpgen = rdFingerprintGenerator.GetMorganGenerator(radius= 2 , fpSize= 2048 ) fp1 = mfpgen.GetFingerprint(mol1) fp2 = mfpgen.GetFingerprint(mol2) # Calculate Tanimoto similarity similarity = DataStructs.TanimotoSimilarity(fp1, fp2) # Calculate similarity for multiple molecules fps = [mfpgen.GetFingerprint(m) for m in [mol2, mol3, mol4]] similarities = DataStructs.BulkTanimotoSimilarity(fp1, fps) # Other similarity metrics dice = DataStructs.DiceSimilarity(fp1, fp2) cosine = DataStructs.CosineSimilarity(fp1, fp2) Clustering and Diversity: # Butina clustering based on fingerprint similarity from rdkit.ML.Cluster import Butina # Calculate distance matrix dists = [] mfpgen = rdFingerprintGenerator.GetMorganGenerator(radius= 2 , fpSize= 2048 ) fps = [mfpgen.GetFingerprint(mol) for mol in mols] for i in range ( len (fps)): sims = DataStructs.BulkTanimotoSimilarity(fps[i], fps[:i]) dists.extend([ 1 -sim for sim in sims]) # Cluster with distance cutoff clusters = Butina.ClusterData(dists, len (fps), distThresh= 0.3 , isDistData= True ) 6. Substructure Searching and SMARTS Basic Substructure Matching: # Define query using SMARTS query = Chem.MolFromSmarts( '[#6]1:[#6]:[#6]:[#6]:[#6]:[#6]:1' ) # Benzene ring # Check if molecule contains substructure has_match = mol.HasSubstructMatch(query) # Get all matches (returns tuple of tuples with atom indices) matches = mol.GetSubstructMatches(query) # Get only first match match = mol.GetSubstructMatch(query) Common SMARTS Patterns: # Primary alcohols primary_alcohol = Chem.MolFromSmarts( '[CH2][OH1]' ) # Carboxylic acids carboxylic_acid = Chem.MolFromSmarts( 'C(=O)[OH]' ) # Amides amide = Chem.MolFromSmarts( 'C(=O)N' ) # Aromatic heterocycles aromatic_n = Chem.MolFromSmarts( '[nR]' ) # Aromatic nitrogen in ring # Macrocycles (rings > 12 atoms) macrocycle = Chem.MolFromSmarts( '[r{12-}]' ) Matching Rules: Unspecified properties in query match any value in target Hydrogens are ignored unless explicitly specified Charged query atom won't match uncharged target atom Aromatic query atom won't match aliphatic target atom (unless query is generic) 7. Chemical Reactions Reaction SMARTS: from rdkit.Chem import AllChem # Define reaction using SMARTS: reactants >> products rxn = AllChem.ReactionFromSmarts( '[C:1]=[O:2]>>[C:1][O:2]' ) # Ketone reduction # Apply reaction to molecules reactants = (mol1,) products = rxn.RunReactants(reactants) # Products is tuple of tuples (one tuple per product set) for product_set in products: for product in product_set: # Sanitize product Chem.SanitizeMol(product) Reaction Features: Atom mapping preserves specific atoms between reactants and products Dummy atoms in products are replaced by corresponding reactant atoms "Any" bonds inherit bond order from reactants Chirality preserved unless explicitly changed Reaction Similarity: # Generate reaction fingerprints fp = AllChem.CreateDifferenceFingerprintForReaction(rxn) # Compare reactions similarity = DataStructs.TanimotoSimilarity(fp1, fp2) 8. 2D and 3D Coordinate Generation 2D Coordinate Generation: from rdkit.Chem import AllChem # Generate 2D coordinates for depiction AllChem.Compute2DCoords(mol) # Align molecule to template structure template = Chem.MolFromSmiles( 'c1ccccc1' ) AllChem.Compute2DCoords(template) AllChem.GenerateDepictionMatching2DStructure(mol, template) 3D Coordinate Generation and Conformers: # Generate single 3D conformer using ETKDG AllChem.EmbedMolecule(mol, randomSeed= 42 ) # Generate multiple conformers conf_ids = AllChem.EmbedMultipleConfs(mol, numConfs= 10 , randomSeed= 42 ) # Optimize geometry with force field AllChem.UFFOptimizeMolecule(mol) # UFF force field AllChem.MMFFOptimizeMolecule(mol) # MMFF94 force field # Optimize all conformers for conf_id in conf_ids: AllChem.MMFFOptimizeMolecule(mol, confId=conf_id) # Calculate RMSD between conformers from rdkit.Chem import AllChem rms = AllChem.GetConformerRMS(mol, conf_id1, conf_id2) # Align molecules AllChem.AlignMol(probe_mol, ref_mol) Constrained Embedding: # Embed with part of molecule constrained to specific coordinates AllChem.ConstrainedEmbed(mol, core_mol) 9. Molecular Visualization Basic Drawing: from rdkit.Chem import Draw # Draw single molecule to PIL image img = Draw.MolToImage(mol, size=( 300 , 300 )) img.save( 'molecule.png' ) # Draw to file directly Draw.MolToFile(mol, 'molecule.png' ) # Draw multiple molecules in grid mols = [mol1, mol2, mol3, mol4] img = Draw.MolsToGridImage(mols, molsPerRow= 2 , subImgSize=( 200 , 200 )) Highlighting Substructures: # Highlight substructure match query = Chem.MolFromSmarts( 'c1ccccc1' ) match = mol.GetSubstructMatch(query) img = Draw.MolToImage(mol, highlightAtoms= match ) # Custom highlight colors highlight_colors = {atom_idx: ( 1 , 0 , 0 ) for atom_idx in match } # Red img = Draw.MolToImage(mol, highlightAtoms= match , highlightAtomColors=highlight_colors) Customizing Visualization: from rdkit.Chem.Draw import rdMolDraw2D # Create drawer with custom options drawer = rdMolDraw2D.MolDraw2DCairo( 300 , 300 ) opts = drawer.drawOptions() # Customize options opts.addAtomIndices = True opts.addStereoAnnotation = True opts.bondLineWidth = 2 # Draw molecule drawer.DrawMolecule(mol) drawer.FinishDrawing() # Save to file with open ( 'molecule.png' , 'wb' ) as f: f.write(drawer.GetDrawingText()) Jupyter Notebook Integration: # Enable inline display in Jupyter from rdkit.Chem.Draw import IPythonConsole # Customize default display IPythonConsole.ipython_useSVG = True # Use SVG instead of PNG IPythonConsole.molSize = ( 300 , 300 ) # Default size # Molecules now display automatically mol # Shows molecule image Visualizing Fingerprint Bits: # Show what molecular features a fingerprint bit represents from rdkit.Chem import Draw # For Morgan fingerprints bit_info = {} fp = AllChem.GetMorganFingerprintAsBitVect(mol, radius= 2 , bitInfo=bit_info) # Draw environment for specific bit img = Draw.DrawMorganBit(mol, bit_id, bit_info) 10. Molecular Modification Adding/Removing Hydrogens: # Add explicit hydrogens mol_h = Chem.AddHs(mol) # Remove explicit hydrogens mol = Chem.RemoveHs(mol_h) Kekulization and Aromaticity: # Convert aromatic bonds to alternating single/double Chem.Kekulize(mol) # Set aromaticity Chem.SetAromaticity(mol) Replacing Substructures: # Replace substructure with another structure query = Chem.MolFromSmarts( 'c1ccccc1' ) # Benzene replacement = Chem.MolFromSmiles( 'C1CCCCC1' ) # Cyclohexane