rdkit

Par mkurman · zorai

Boîte à outils cheminformatique pour un contrôle moléculaire précis. Parsing SMILES/SDF, descripteurs (MW, LogP, TPSA), fingerprints, recherche de sous-structures, génération 2D/3D, similarité, réactions. Pour les workflows standard avec une interface plus simple, utilisez datamol (wrapper autour de RDKit). Utilisez rdkit pour un contrôle avancé, une sanitisation personnalisée et des algorithmes spécialisés.

npx skills add https://github.com/mkurman/zorai --skill rdkit

Boîte à outils de cheminformatique RDKit

Aperçu

RDKit est une bibliothèque cheminformatique complète fournissant des API Python pour l'analyse et la manipulation moléculaire. Cette compétence fournit des conseils pour la lecture/écriture de structures moléculaires, le calcul de descripteurs, la génération d'empreintes digitales, la recherche de sous-structures, les réactions chimiques, la génération de coordonnées 2D/3D et la visualisation moléculaire. Utilisez cette compétence pour les tâches de découverte de médicaments, de chimie computationnelle et de recherche en cheminformatique.

Capacités principales

1. E/S et création moléculaires

Lecture de molécules :

Lisez les structures moléculaires à partir de divers formats :

from rdkit import Chem

# À partir de chaînes SMILES
mol = Chem.MolFromSmiles('Cc1ccccc1')  # Retourne l'objet Mol ou None

# À partir de fichiers MOL
mol = Chem.MolFromMolFile('path/to/file.mol')

# À partir de blocs MOL (données chaîne)
mol = Chem.MolFromMolBlock(mol_block_string)

# À partir d'InChI
mol = Chem.MolFromInchi('InChI=1S/C6H6/c1-2-4-6-5-3-1/h1-6H')

Écriture de molécules :

Convertissez les molécules en représentations textuelles :

# En SMILES canonique
smiles = Chem.MolToSmiles(mol)

# En bloc MOL
mol_block = Chem.MolToMolBlock(mol)

# En InChI
inchi = Chem.MolToInchi(mol)

Traitement par lot :

Pour traiter plusieurs molécules, utilisez les objets Supplier/Writer :

# Lire les fichiers SDF
suppl = Chem.SDMolSupplier('molecules.sdf')
for mol in suppl:
    if mol is not None:  # Vérifier les erreurs d'analyse
        # Traiter la molécule
        pass

# Lire les fichiers SMILES
suppl = Chem.SmilesMolSupplier('molecules.smi', titleLine=False)

# Pour les fichiers volumineux ou les données compressées
with gzip.open('molecules.sdf.gz') as f:
    suppl = Chem.ForwardSDMolSupplier(f)
    for mol in suppl:
        # Traiter la molécule
        pass

# Traitement multithreadé pour les ensembles de données volumineux
suppl = Chem.MultithreadedSDMolSupplier('molecules.sdf')

# Écrire les molécules en SDF
writer = Chem.SDWriter('output.sdf')
for mol in molecules:
    writer.write(mol)
writer.close()

Notes importantes :

  • Toutes les fonctions MolFrom* retournent None en cas d'échec avec des messages d'erreur
  • Vérifiez toujours None avant de traiter les molécules
  • Les molécules sont automatiquement assainies à l'importation (valide la valence, perçoit l'aromaticité)

2. Assainissement et validation moléculaires

RDKit assainit automatiquement les molécules lors de l'analyse, en exécutant 13 étapes incluant la vérification de la valence, la perception de l'aromaticité et l'assignation de chiralité.

Contrôle de l'assainissement :

# Désactiver l'assainissement automatique
mol = Chem.MolFromSmiles('C1=CC=CC=C1', sanitize=False)

# Assainissement manuel
Chem.SanitizeMol(mol)

# Détecter les problèmes avant l'assainissement
problems = Chem.DetectChemistryProblems(mol)
for problem in problems:
    print(problem.GetType(), problem.Message())

# Assainissement partiel (ignorer des étapes spécifiques)
from rdkit.Chem import rdMolStandardize
Chem.SanitizeMol(mol, sanitizeOps=Chem.SANITIZE_ALL ^ Chem.SANITIZE_PROPERTIES)

Problèmes d'assainissement courants :

  • Les atomes avec une valence explicite dépassant le maximum autorisé lèveront des exceptions
  • Les anneaux aromatiques invalides causeront des erreurs de kekulisation
  • Les électrons radicaux peuvent ne pas être correctement assignés sans spécification explicite

3. Analyse et propriétés moléculaires

Accès à la structure moléculaire :

# Itérer les atomes et les liaisons
for atom in mol.GetAtoms():
    print(atom.GetSymbol(), atom.GetIdx(), atom.GetDegree())

for bond in mol.GetBonds():
    print(bond.GetBeginAtomIdx(), bond.GetEndAtomIdx(), bond.GetBondType())

# Informations sur les anneaux
ring_info = mol.GetRingInfo()
ring_info.NumRings()
ring_info.AtomRings()  # Retourne les tuples d'indices d'atomes

# Vérifier si l'atome est dans un anneau
atom = mol.GetAtomWithIdx(0)
atom.IsInRing()
atom.IsInRingSize(6)  # Vérifier les anneaux de 6 membres

# Trouver le plus petit ensemble des plus petits anneaux (SSSR)
from rdkit.Chem import GetSymmSSSR
rings = GetSymmSSSR(mol)

Stéréochimie :

# Trouver les centres chiraux
from rdkit.Chem import FindMolChiralCenters
chiral_centers = FindMolChiralCenters(mol, includeUnassigned=True)
# Retourne une liste de tuples (atom_idx, chirality)

# Assigner la stéréochimie à partir des coordonnées 3D
from rdkit.Chem import AssignStereochemistryFrom3D
AssignStereochemistryFrom3D(mol)

# Vérifier la stéréochimie des liaisons
bond = mol.GetBondWithIdx(0)
stereo = bond.GetStereo()  # STEREONONE, STEREOZ, STEREOE, etc.

Analyse des fragments :

# Obtenir les fragments déconnectés
frags = Chem.GetMolFrags(mol, asMols=True)

# Fragmenter sur des liaisons spécifiques
from rdkit.Chem import FragmentOnBonds
frag_mol = FragmentOnBonds(mol, [bond_idx1, bond_idx2])

# Compter les systèmes d'anneaux
from rdkit.Chem.Scaffolds import MurckoScaffold
scaffold = MurckoScaffold.GetScaffoldForMol(mol)

4. Descripteurs et propriétés moléculaires

Descripteurs de base :

from rdkit.Chem import Descriptors

# Poids moléculaire
mw = Descriptors.MolWt(mol)
exact_mw = Descriptors.ExactMolWt(mol)

# LogP (lipophilicité)
logp = Descriptors.MolLogP(mol)

# Surface polaire topologique
tpsa = Descriptors.TPSA(mol)

# Nombre de donneurs/accepteurs de liaison hydrogène
hbd = Descriptors.NumHDonors(mol)
hba = Descriptors.NumHAcceptors(mol)

# Nombre de liaisons rotables
rot_bonds = Descriptors.NumRotatableBonds(mol)

# Nombre d'anneaux aromatiques
aromatic_rings = Descriptors.NumAromaticRings(mol)

Calcul de descripteurs par lot :

# Calculer tous les descripteurs à la fois
all_descriptors = Descriptors.CalcMolDescriptors(mol)
# Retourne un dictionnaire : {'MolWt': 180.16, 'MolLogP': 1.23, ...}

# Obtenir la liste des noms de descripteurs disponibles
descriptor_names = [desc[0] for desc in Descriptors._descList]

Règle des cinq de Lipinski :

# Vérifier la ressemblance avec un médicament
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. Empreintes digitales et similarité moléculaire

Types d'empreintes digitales :

from rdkit.Chem import rdFingerprintGenerator
from rdkit.Chem import MACCSkeys

# Empreinte digitale topologique RDKit
rdk_gen = rdFingerprintGenerator.GetRDKitFPGenerator(minPath=1, maxPath=7, fpSize=2048)
fp = rdk_gen.GetFingerprint(mol)

# Empreintes digitales Morgan (empreintes digitales circulaires, similaires à ECFP)
# API moderne utilisant rdFingerprintGenerator
morgan_gen = rdFingerprintGenerator.GetMorganGenerator(radius=2, fpSize=2048)
fp = morgan_gen.GetFingerprint(mol)
# Empreinte digitale basée sur les comptages
fp_count = morgan_gen.GetCountFingerprint(mol)

# Clés MACCS (clé structurale de 166 bits)
fp = MACCSkeys.GenMACCSKeys(mol)

# Empreintes digitales de paires d'atomes
ap_gen = rdFingerprintGenerator.GetAtomPairGenerator()
fp = ap_gen.GetFingerprint(mol)

# Empreintes digitales de torsions topologiques
tt_gen = rdFingerprintGenerator.GetTopologicalTorsionGenerator()
fp = tt_gen.GetFingerprint(mol)

# Empreintes digitales Avalon (si disponible)
from rdkit.Avalon import pyAvalonTools
fp = pyAvalonTools.GetAvalonFP(mol)

Calcul de similarité :

from rdkit import DataStructs
from rdkit.Chem import rdFingerprintGenerator

# Générer les empreintes digitales en utilisant le générateur
mfpgen = rdFingerprintGenerator.GetMorganGenerator(radius=2, fpSize=2048)
fp1 = mfpgen.GetFingerprint(mol1)
fp2 = mfpgen.GetFingerprint(mol2)

# Calculer la similarité Tanimoto
similarity = DataStructs.TanimotoSimilarity(fp1, fp2)

# Calculer la similarité pour plusieurs molécules
fps = [mfpgen.GetFingerprint(m) for m in [mol2, mol3, mol4]]
similarities = DataStructs.BulkTanimotoSimilarity(fp1, fps)

# Autres métriques de similarité
dice = DataStructs.DiceSimilarity(fp1, fp2)
cosine = DataStructs.CosineSimilarity(fp1, fp2)

Clustering et diversité :

# Clustering Butina basé sur la similarité des empreintes digitales
from rdkit.ML.Cluster import Butina

# Calculer la matrice de distances
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 avec un seuil de distance
clusters = Butina.ClusterData(dists, len(fps), distThresh=0.3, isDistData=True)

6. Recherche de sous-structures et SMARTS

Correspondance de sous-structures de base :

# Définir la requête à l'aide de SMARTS
query = Chem.MolFromSmarts('[#6]1:[#6]:[#6]:[#6]:[#6]:[#6]:1')  # Anneau benzène

# Vérifier si la molécule contient une sous-structure
has_match = mol.HasSubstructMatch(query)

# Obtenir tous les correspondances (retourne un tuple de tuples avec les indices d'atomes)
matches = mol.GetSubstructMatches(query)

# Obtenir seulement la première correspondance
match = mol.GetSubstructMatch(query)

Motifs SMARTS courants :

# Alcools primaires
primary_alcohol = Chem.MolFromSmarts('[CH2][OH1]')

# Acides carboxyliques
carboxylic_acid = Chem.MolFromSmarts('C(=O)[OH]')

# Amides
amide = Chem.MolFromSmarts('C(=O)N')

# Hétérocycles aromatiques
aromatic_n = Chem.MolFromSmarts('[nR]')  # Azote aromatique dans un anneau

# Macrocycles (anneaux > 12 atomes)
macrocycle = Chem.MolFromSmarts('[r{12-}]')

Règles de correspondance :

  • Les propriétés non spécifiées dans la requête correspondent à n'importe quelle valeur dans la cible
  • Les hydrogènes sont ignorés sauf s'ils sont explicitement spécifiés
  • Un atome de requête chargé ne correspondra pas à un atome cible non chargé
  • Un atome de requête aromatique ne correspondra pas à un atome cible aliphatique (à moins que la requête soit générique)

7. Réactions chimiques

SMARTS de réaction :

from rdkit.Chem import AllChem

# Définir la réaction à l'aide de SMARTS : réactifs >> produits
rxn = AllChem.ReactionFromSmarts('[C:1]=[O:2]>>[C:1][O:2]')  # Réduction de la cétone

# Appliquer la réaction aux molécules
reactants = (mol1,)
products = rxn.RunReactants(reactants)

# Les produits forment un tuple de tuples (un tuple par ensemble de produits)
for product_set in products:
    for product in product_set:
        # Assainir le produit
        Chem.SanitizeMol(product)

Caractéristiques de la réaction :

  • L'assignation d'atomes préserve les atomes spécifiques entre les réactifs et les produits
  • Les atomes fictifs dans les produits sont remplacés par les atomes réactifs correspondants
  • Les liaisons « Any » héritent de l'ordre des liaisons des réactifs
  • La chiralité est préservée sauf si elle est explicitement modifiée

Similarité des réactions :

# Générer les empreintes digitales de réaction
fp = AllChem.CreateDifferenceFingerprintForReaction(rxn)

# Comparer les réactions
similarity = DataStructs.TanimotoSimilarity(fp1, fp2)

8. Génération de coordonnées 2D et 3D

Génération de coordonnées 2D :

from rdkit.Chem import AllChem

# Générer des coordonnées 2D pour la représentation
AllChem.Compute2DCoords(mol)

# Aligner la molécule à une structure modèle
template = Chem.MolFromSmiles('c1ccccc1')
AllChem.Compute2DCoords(template)
AllChem.GenerateDepictionMatching2DStructure(mol, template)

Génération de coordonnées 3D et conformères :

# Générer un seul conformère 3D en utilisant ETKDG
AllChem.EmbedMolecule(mol, randomSeed=42)

# Générer plusieurs conformères
conf_ids = AllChem.EmbedMultipleConfs(mol, numConfs=10, randomSeed=42)

# Optimiser la géométrie avec un champ de force
AllChem.UFFOptimizeMolecule(mol)  # Champ de force UFF
AllChem.MMFFOptimizeMolecule(mol)  # Champ de force MMFF94

# Optimiser tous les conformères
for conf_id in conf_ids:
    AllChem.MMFFOptimizeMolecule(mol, confId=conf_id)

# Calculer l'RMSD entre les conformères
from rdkit.Chem import AllChem
rms = AllChem.GetConformerRMS(mol, conf_id1, conf_id2)

# Aligner les molécules
AllChem.AlignMol(probe_mol, ref_mol)

Enrobage contraint :

# Enrober avec une partie de la molécule contrainte à des coordonnées spécifiques
AllChem.ConstrainedEmbed(mol, core_mol)

9. Visualisation moléculaire

Dessin de base :

from rdkit.Chem import Draw

# Dessiner une seule molécule en image PIL
img = Draw.MolToImage(mol, size=(300, 300))
img.save('molecule.png')

# Dessiner directement dans un fichier
Draw.MolToFile(mol, 'molecule.png')

# Dessiner plusieurs molécules en grille
mols = [mol1, mol2, mol3, mol4]
img = Draw.MolsToGridImage(mols, molsPerRow=2, subImgSize=(200, 200))

Surlignage des sous-structures :

# Surligner la correspondance de sous-structure
query = Chem.MolFromSmarts('c1ccccc1')
match = mol.GetSubstructMatch(query)

img = Draw.MolToImage(mol, highlightAtoms=match)

# Couleurs de surligneur personnalisées
highlight_colors = {atom_idx: (1, 0, 0) for atom_idx in match}  # Rouge
img = Draw.MolToImage(mol, highlightAtoms=match,
                      highlightAtomColors=highlight_colors)

Personnalisation de la visualisation :

from rdkit.Chem.Draw import rdMolDraw2D

# Créer un draweur avec des options personnalisées
drawer = rdMolDraw2D.MolDraw2DCairo(300, 300)
opts = drawer.drawOptions()

# Personnaliser les options
opts.addAtomIndices = True
opts.addStereoAnnotation = True
opts.bondLineWidth = 2

# Dessiner la molécule
drawer.DrawMolecule(mol)
drawer.FinishDrawing()

# Sauvegarder dans un fichier
with open('molecule.png', 'wb') as f:
    f.write(drawer.GetDrawingText())

Intégration aux carnets Jupyter :

# Activer l'affichage en ligne dans Jupyter
from rdkit.Chem.Draw import IPythonConsole

# Personnaliser l'affichage par défaut
IPythonConsole.ipython_useSVG = True  # Utiliser SVG au lieu de PNG
IPythonConsole.molSize = (300, 300)   # Taille par défaut

# Les molécules s'affichent désormais automatiquement
mol  # Affiche l'image de la molécule

Visualisation des bits d'empreinte digitale :

# Afficher les caractéristiques moléculaires représentées par un bit d'empreinte digitale
from rdkit.Chem import Draw

# Pour les empreintes digitales Morgan
bit_info = {}
fp = AllChem.GetMorganFingerprintAsBitVect(mol, radius=2, bitInfo=bit_info)

# Dessiner l'environnement pour un bit spécifique
img = Draw.DrawMorganBit(mol, bit_id, bit_info)

10. Modification moléculaire

Ajouter/Supprimer des hydrogènes :

# Ajouter des hydrogènes explicites
mol_h = Chem.AddHs(mol)

# Supprimer les hydrogènes explicites
mol = Chem.RemoveHs(mol_h)

Kekulisation et aromaticité :

# Convertir les liaisons aromatiques en alternance simple/double
Chem.Kekulize(mol)

# Définir l'aromaticité
Chem.SetAromaticity(mol)

Remplacer les sous-structures :

# Remplacer la sous-structure par une autre structure
query = Chem.MolFromSmarts('c1ccccc1')  # Benzène
replacement = Chem.MolFromSmiles('C1CCCCC1')  # Cyclohexane

new_mol = Chem.ReplaceSubstructs(mol, query, replacement)[0]

Neutraliser les charges :

# Supprimer les charges formelles en ajoutant/supprimant des hydrogènes
from rdkit.Chem.MolStandardize import rdMolStandardize

# Utiliser Uncharger
uncharger = rdMolStandardize.Uncharger()
mol_neutral = uncharger.uncharge(mol)

11. Travail avec les hachages moléculaires et la standardisation

Hachage moléculaire :

from rdkit.Chem import rdMolHash

# Générer le hachage de l'échafaudage Murcko
scaffold_hash = rdMolHash.MolHash(mol, rdMolHash.HashFunction.MurckoScaffold)

# Hachage canonique SMILES
canonical_hash = rdMolHash.MolHash(mol, rdMolHash.HashFunction.CanonicalSmiles)

# Hachage de régioisomère (ignore la stéréochimie)
regio_hash = rdMolHash.MolHash(mol, rdMolHash.HashFunction.Regioisomer)

SMILES randomisées :

# Générer des représentations SMILES aléatoires (pour l'augmentation de données)
from rdkit.Chem import MolToRandomSmilesVect

random_smiles = MolToRandomSmilesVect(mol, numSmiles=10, randomSeed=42)

12. Pharmacophore et caractéristiques 3D

Caractéristiques pharmacophores :

from rdkit.Chem import ChemicalFeatures
from rdkit import RDConfig
import os

# Charger la fabrique de caractéristiques
fdef_path = os.path.join(RDConfig.RDDataDir, 'BaseFeatures.fdef')
factory = ChemicalFeatures.BuildFeatureFactory(fdef_path)

# Obtenir les caractéristiques pharmacophores
features = factory.GetFeaturesForMol(mol)

for feat in features:
    print(feat.GetFamily(), feat.GetType(), feat.GetAtomIds())

Flux de travail courants

Analyse de la ressemblance avec un médicament

from rdkit import Chem
from rdkit.Chem import Descriptors

def analyze_druglikeness(smiles):
    mol = Chem.MolFromSmiles(smiles)
    if mol is None:
        return None

    # Calculer les descripteurs Lipinski
    results = {
        'MW': Descriptors.MolWt(mol),
        'LogP': Descriptors.MolLogP(mol),
        'HBD': Descriptors.NumHDonors(mol),
        'HBA': Descriptors.NumHAcceptors(mol),
        'TPSA': Descriptors.TPSA(mol),
        'RotBonds': Descriptors.NumRotatableBonds(mol)
    }

    # Vérifier la règle des cinq de Lipinski
    results['Lipinski'] = (
        results['MW'] <= 500 and
        results['LogP'] <= 5 and
        results['HBD'] <= 5 and
        results['HBA'] <= 10
    )

    return results

Dépistage de similarité

from rdkit import Chem
from rdkit.Chem import AllChem
from rdkit import DataStructs

def similarity_screen(query_smiles, database_smiles, threshold=0.7):
    query_mol = Chem.MolFromSmiles(query_smiles)
    query_fp = AllChem.GetMorganFingerprintAsBitVect(query_mol, 2)

    hits = []
    for idx, smiles in enumerate(database_smiles):
        mol = Chem.MolFromSmiles(smiles)
        if mol:
            fp = AllChem.GetMorganFingerprintAsBitVect(mol, 2)
            sim = DataStructs.TanimotoSimilarity(query_fp, fp)
            if sim >= threshold:
                hits.append((idx, smiles, sim))

    return sorted(hits, key=lambda x: x[2], reverse=True)

Filtrage par sous-structure

from rdkit import Chem

def filter_by_substructure(smiles_list, pattern_smarts):
    query = Chem.MolFromSmarts(pattern_smarts)

    hits = []
    for smiles in smiles_list:
        mol = Chem.MolFromSmiles(smiles)
        if mol and mol.HasSubstructMatch(query):
            hits.append(smiles)

    return hits

Bonnes pratiques

Gestion des erreurs

Vérifiez toujours None lors de l'analyse des molécules :

mol = Chem.MolFromSmiles(smiles)
if mol is None:
    print(f"Erreur d'analyse : {smiles}")
    continue

Optimisation des performances

Utiliser les formats binaires pour le stockage :

import pickle

# Sérialiser les molécules pour un chargement rapide
with open('molecules.pkl', 'wb') as f:
    pickle.dump(mols, f)

# Charger les molécules sérialisées (beaucoup plus rapide que réanalyser)
with open('molecules.pkl', 'rb') as f:
    mols = pickle.load(f)

Utiliser les opérations en masse :

# Calculer les empreintes digitales pour toutes les molécules à la fois
fps = [AllChem.GetMorganFingerprintAsBitVect(mol, 2) for mol in mols]

# Utiliser les calculs de similarité en masse
similarities = DataStructs.BulkTanimotoSimilarity(fps[0], fps[1:])

Sécurité des threads

Les opérations RDKit sont généralement thread-safe pour :

  • E/S moléculaire (SMILES, blocs mol)
  • Génération de coordonnées
  • Empreintes digitales et descripteurs
  • Recherche de sous-structures
  • Réactions
  • Dessin

Non thread-safe : MolSuppliers lorsqu'on y accède simultanément.

Gestion de la mémoire

Pour les ensembles de données volumineux :

# Utiliser ForwardSDMolSupplier pour éviter de charger le fichier entier
with open('large.sdf') as f:
    suppl = Chem.ForwardSDMolSupplier(f)
    for mol in suppl:
        # Traiter une molécule à la fois
        pass

# Utiliser MultithreadedSDMolSupplier pour le traitement parallèle
suppl = Chem.MultithreadedSDMolSupplier('large.sdf', numWriterThreads=4)

Pièges courants

  1. Oublier de vérifier None : Validez toujours les molécules après l'analyse
  2. Échecs d'assainissement : Utilisez DetectChemistryProblems() pour déboguer
  3. Hydrogènes manquants : Utilisez AddHs() lors du calcul de propriétés qui dépendent de l'hydrogène
  4. 2D vs 3D : Générez les coordonnées appropriées avant la visualisation ou l'analyse 3D
  5. Règles de correspondance SMARTS : Souvenez-vous que les propriétés non spécifiées correspondent à n'importe quoi
  6. Sécurité des threads avec MolSuppliers : Ne partagez pas les objets suppliers entre les threads

Ressources

references/

Cette compétence comprend une documentation de référence API détaillée :

  • api_reference.md - Listing complet des modules, fonctions et classes RDKit organisés par fonctionnalité
  • descriptors_reference.md - Liste complète des descripteurs moléculaires disponibles avec descriptions
  • smarts_patterns.md - Motifs SMARTS courants pour les groupes fonctionnels et les caractéristiques structurales

Chargez ces références lorsque vous avez besoin de détails API spécifiques, d'informations sur les paramètres ou d'exemples de motifs.

scripts/

Exemples de scripts pour les flux de travail RDKit courants :

  • molecular_properties.py - Calculer des propriétés moléculaires et des descripteurs complets
  • similarity_search.py - Effectuer un dépistage de similarité basé sur les empreintes digitales
  • substructure_filter.py - Filtrer les molécules par motifs de sous-structure

Ces scripts peuvent être exécutés directement ou utilisés comme modèles pour les flux de travail personnalisés.

Skills similaires

datamol
mkurman / zorai

Manipuler des molécules chimiques avec RDKit via une interface Python simplifiée.

309
rowan
mkurman / zorai

Modéliser des molécules et orchestrer des workflows de chimie médicinale dans le cloud.

309
torchdrug
mkurman / zorai

Appliquer des GNN et modèles pré-entraînés à la découverte de molécules et protéines.

309
chembl-database
mkurman / zorai

Interroger la base ChEMBL pour récupérer données moléculaires, cibles et bioactivités.

309
claude-api
anthropics / skills

Construire des applications LLM avec Claude via le SDK officiel adapté au langage.

146 952