Guide · Agent skill
How to use the DeepChem molecular property prediction agent skill
Updated · written with AI from the project's own documentation and checked against our catalogue data
The DeepChem skill lets an AI agent build molecular property prediction workflows with DeepChem, the open-source chemistry machine learning library. It covers SMILES featurization, MoleculeNet benchmarks, scaffold or grouped holdouts, and explicitly configured pretrained encoder transfer. This guide explains what the skill does, how to install it, how to ask for work with plain requests, and what it needs to run.
DeepChem Molecular Property PredictionK-Dense-AI/scientific-agent-skills · MIT Download the skill Quick start
- 1Check your Python and RDKit setup. Confirm you have Python 3.11 available and plan an isolated environment for DeepChem, separate from any project with a conflicting Python requirement.
- 2Install the DeepChem stack. Create the environment with uv and install the pinned DeepChem, Torch, Transformers and torch-geometric packages shown in the installation section.
- 3Place the skill folder. Unzip the downloaded ZIP into ~/.claude/skills/ for personal use or into .claude/skills/ in your project, or upload the ZIP under Settings → Capabilities → Skills in the Claude apps.
- 4Ask for a property prediction task. Describe the task in plain language, naming your SMILES data, the endpoint such as solubility or toxicity, and how the model will be used.
- 5Run a bundled script. Use predict_solubility.py with your CSV, SMILES column and target column, or the graph and transfer scripts for other model types.
- 6Review the validation report. Check per-task support, the holdout strategy, metrics in original units and the baseline comparison before drawing any conclusion.
What does the DeepChem skill make the agent do?
Once installed, the agent follows a structured DeepChem workflow for chemical property prediction, such as solubility, toxicity or ADMET-style endpoints, starting from SMILES molecular strings. It checks that the data is usable before modelling: it parses structures, keeps a record of rejected rows, and audits duplicate structures and repeated measurements before splitting.
The skill tells the agent to choose a representation that matches each model type, for example explicit fingerprints for a fingerprint baseline or a graph featurizer for graph models. It also asks for a numeric baseline first, uses scaffold, temporal or grouped holdouts so test molecules differ from training ones, keeps missing labels masked, and reports metrics in original units.
- Parses SMILES and audits failures, duplicates and repeated measurements
- Matches featurizers to model types, such as CircularFingerprint for fingerprint baselines and MolGraphConvFeaturizer for Torch GCN or GAT
- Uses scaffold or grouped holdouts and checks scaffold overlap and per-task class support
- Keeps unmeasured labels masked rather than treating them as negatives
- Reports metrics in original units and warns when results are not evidence of real-world performance
How do you install the DeepChem skill?
Download the skill ZIP from this page and unzip it. For a personal install, place the skill folder in ~/.claude/skills/. For a single project, place it in the project's .claude/skills/ folder. Alternatively, in the Claude apps, open Settings → Capabilities → Skills and upload the ZIP.
The skill also needs a working Python environment for DeepChem itself. The skill recommends an isolated Python 3.11 environment, kept separate from any repository whose Python requirement conflicts. The tested core stack can be set up with uv using the commands below.
- Personal install: ~/.claude/skills/
- Project install: .claude/skills/ inside your project
- Claude apps: Settings → Capabilities → Skills, then upload the ZIP
uv venv --python 3.11 .venv-deepchem
uv pip install --python .venv-deepchem/bin/python 'deepchem==2.8.0' 'torch==2.14.1' 'transformers==5.18.0' 'torch-geometric==2.8.0.post1'How do you trigger the skill with natural requests?
You do not need special syntax. Describe the chemistry task in plain language and mention SMILES, solubility, toxicity, ADMET, MoleculeNet or DeepChem. The skill is written for molecular property prediction, so requests that involve those topics are the ones it is meant to handle. Requests about non-chemistry tabular data fall outside its scope.
Be specific about the question you want answered. Saying where the model will be used, such as screening new compounds, helps the agent pick a holdout strategy that matches the deployment question.
- Build a baseline solubility model from my CSV of SMILES and logS values, with a scaffold split.
- Train a toxicity classifier on BBBP and report AUC per task.
- Predict solubility for these SMILES: CCO and c1ccccc1 using a fingerprint model.
- Set up a graph neural network for ADMET-style endpoints and tell me what features it needs.
- Check my molecular dataset for duplicate structures and invalid SMILES before splitting.
What do the bundled scripts do and how do you run them?
The main executable example is predict_solubility.py. With a custom CSV and query SMILES, it validates complete continuous targets, creates 2048-bit fingerprints, performs a scaffold split, fits training-target normalization, trains a Torch MultitaskRegressor, and prints original-unit metrics and predictions. Run it from the skill directory using the Python interpreter of your DeepChem environment.
The script prints results only. It does not save split IDs, rejected-row tables or a prediction file, so you need to save provenance and outputs yourself if you are doing research. It also does not run the random-forest reference baseline or the hyperparameter search template. Graph and transfer scripts are available for other model types.
- predict_solubility.py: fingerprint-based regression with a scaffold split
- graph_neural_network.py: model-specific graph features, for example --model dmpnn
- transfer_learning.py: Hugging Face transfer with a single complete task, for example --model chemberta
python scripts/predict_solubility.py --epochs 50
python scripts/predict_solubility.py --data measured.csv --smiles-col smiles --target-col logS --predict CCO c1ccccc1
python scripts/graph_neural_network.py --model dmpnn --dataset bbbp --epochs 20
python scripts/transfer_learning.py --model chemberta --dataset bbbp --epochs 10What does the skill need to run?
You need Python 3.11, the RDKit chemistry toolkit, and DeepChem. Torch and Transformers are needed for the Torch and Hugging Face paths. Graph models additionally need torch-geometric, and the GCN, GAT, AttentiveFP and Torch MPNN paths also need DGL and DGL-LifeSci. The skill notes that GPU and DGL-based backends were not verified in its review, so treat those paths as unconfirmed on your machine.
Network access is needed for package installation and for downloading MoleculeNet datasets or model weights. The CPU stack is the tested route; for GPU training, install the correct framework build from its official instructions.
- Python 3.11 and RDKit
- DeepChem, Torch and Transformers for the core paths
- torch-geometric for graph models
- DGL and DGL-LifeSci for GCN, GAT, AttentiveFP and Torch MPNN
- Network access for installs and dataset or model downloads
What are the safety notes for scripts and network use?
This skill runs scripts and uses the network. The scripts read data you provide or download benchmark datasets, and the skill's allowed tools include Read, Write, Edit and Bash. Read the script and the command before running it, and only run it on data you trust.
The CSV guard rejects duplicate headers, non-finite labels, invalid SMILES and rows lost during featurization, so bad input stops loading. Pretrained weights are not loaded just by naming a model ID. The MoLFormer and GROVER recipes require explicit repository revisions or local checkpoints, as described in the skill's workflow reference.
- Review scripts before running them, because the skill runs them with Bash access
- Expect network downloads for packages, MoleculeNet datasets and model weights
- A model ID or model directory is not itself a loaded pretrained model
- Successful fitting is not evidence of prospective performance
What tips help you get reliable results?
Use the baseline first and compare more complex models against it. Keep the split strategy aligned with the question you are answering, and inspect per-task support before trusting an AUC, since AUC needs both observed classes. Fit any preprocessing on training data only, and convert predictions back to original units before reporting them.
Do not use a trained model alone for regulatory, clinical or safety decisions. The skill is designed for baseline models and careful validation, not for turnkey prediction apps.
- Start with a fingerprint baseline and compare against it
- Use scaffold or grouped splits, not random splits, for held-out estimates
- Check class support per task before reading AUC
- Record the solubility conditions (pH, temperature, salt form) because they can change the outcome
- Save split IDs and predictions yourself when you need an audit trail
What people use it for
- Building a baseline solubility regression model from a custom CSV of SMILES and measured logS values
- Benchmarking a toxicity or blood-brain barrier classifier on a MoleculeNet dataset with a scaffold split
- Screening a short list of query SMILES with a fitted fingerprint model and recording predictions in original units
- Auditing a chemistry dataset for invalid SMILES, duplicate structures and missing labels before modelling
Frequently asked questions
Is the DeepChem agent skill free to use?
The skill is published under the MIT licence, as stated on this page. DeepChem and its dependencies are separate open-source packages, and you should check their own licences before use.
What do I need installed before using the DeepChem skill?
You need Python 3.11, RDKit, and the DeepChem stack listed in the installation section. Graph models also need torch-geometric, and GCN, GAT, AttentiveFP and Torch MPNN also need DGL and DGL-LifeSci, which were not verified in the skill's review.
How do I install the DeepChem skill in Claude?
Download the ZIP from this page and unzip it into ~/.claude/skills/ for personal use or into .claude/skills/ in a project. In the Claude apps, you can instead upload the ZIP under Settings → Capabilities → Skills.
Does DeepChem work on a GPU?
The skill's tested stack was CPU-based. For GPU training, install the correct framework build following its official platform instructions, and expect that to need checking on your own machine.
How does the skill compare with using DeepChem directly or other chemistry ML tools?
The skill adds a structured workflow on top of DeepChem, including split strategy, masking and validation guidance. If you only need a quick accuracy number or a turnkey app, it is not built for that, and you may prefer a simpler tool.
Why does the skill say a trained model is not enough for real decisions?
The skill states that successful fitting is not prospective scientific evidence. Predictions on benchmark or retrospective data do not show how a model will perform on new compounds or in regulatory, clinical or safety settings.
New agent skills, repos and AI tools — every week
The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.
Our verdict
Choose this skill if you are a chemistry or cheminformatics researcher, or a data scientist learning MoleculeNet and molecular featurization, and you want careful validation rather than a quick accuracy figure. Pick something else if you need a turnkey app, do not have Python 3.11 and RDKit set up, want GPU or graph-model backends confirmed, or are working on non-chemistry tabular data.
Download the skill