agentsclimarketplace

Analyze

Skill pregHosh/Solitarius-mcp/skills/analyze

Evaluate and characterize a set of generated SMILES across multiple quality dimensions (physicochemical, druglikeness, scaffold diversity, structural alerts, similarity to reference). Use after sampling or RL to assess molecule quality.From its SKILL.md

Install
npx -y skills add pregHosh/Solitarius-mcp --skill analyze

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

  • 1 stars1 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

SKILL.md

7.9 KB, as published. Nobody here has run it

REINVENT4 Molecule Analysis

Evaluate generated molecules using Python/RDKit/pandas directly. No MCP server needed — requires RDKit, pandas, and optionally umap-learn.

Workflow

1. Resolve paths

readlink -f <relative_path>

2. Identify inputs

  • smiles_file (required): sampling CSV or .smi file. Use $0 if provided. SMILES column auto-detected from CSV headers (first column containing "smiles", case-insensitive).
  • ref_smiles_file (optional): reference / known-active SMILES for novelty and similarity. Use $1 if provided.
  • output_dir: default <stem>_analysis/ next to the input file.

3. Load molecules

import pandas as pd
from rdkit import Chem
from pathlib import Path

path = Path("/absolute/path/to/sampling.csv")

if path.suffix == ".csv":
    df = pd.read_csv(path)
    smi_col = next((c for c in df.columns if "smiles" in c.lower()), df.columns[0])
    raw_smiles = df[smi_col].dropna().astype(str).tolist()
else:
    raw_smiles = [l.split()[0] for l in path.read_text().splitlines() if l.strip()]

mols, valid_smiles = [], []
for smi in raw_smiles:
    mol = Chem.MolFromSmiles(smi)
    if mol:
        mols.append(mol)
        valid_smiles.append(Chem.MolToSmiles(mol))

print(f"Total: {len(raw_smiles)}, Valid: {len(mols)} ({100*len(mols)/max(len(raw_smiles),1):.1f}%)")

4. Physicochemical properties

from rdkit.Chem import Descriptors, rdMolDescriptors
import numpy as np

props = []
for mol in mols:
    props.append({
        "mw":      Descriptors.MolWt(mol),
        "logp":    Descriptors.MolLogP(mol),
        "tpsa":    Descriptors.TPSA(mol),
        "hbd":     rdMolDescriptors.CalcNumHBD(mol),
        "hba":     rdMolDescriptors.CalcNumHBA(mol),
        "rotbonds":rdMolDescriptors.CalcNumRotatableBonds(mol),
        "rings":   rdMolDescriptors.CalcNumRings(mol),
    })

df_props = pd.DataFrame(props)
print(df_props.describe().round(2))

5. Druglikeness

from rdkit.Chem import QED

qeds = [QED.qed(mol) for mol in mols]

# Lipinski RO5
def lipinski(mol):
    return (Descriptors.MolWt(mol) <= 500 and Descriptors.MolLogP(mol) <= 5 and
            rdMolDescriptors.CalcNumHBD(mol) <= 5 and rdMolDescriptors.CalcNumHBA(mol) <= 10)

ro5_pass = sum(1 for mol in mols if lipinski(mol))
print(f"QED — mean: {np.mean(qeds):.3f}, median: {np.median(qeds):.3f}")
print(f"Lipinski RO5 pass: {ro5_pass}/{len(mols)} ({100*ro5_pass/max(len(mols),1):.1f}%)")

6. Synthetic accessibility and structural alerts

# SAScore (requires sascorer from rdkit-contrib or SA_Score.py)
try:
    from rdkit.Chem import RDConfig
    import os, sys
    sa_path = os.path.join(RDConfig.RDContribDir, "SA_Score")
    if sa_path not in sys.path:
        sys.path.append(sa_path)
    import sascorer
    sa_scores = [sascorer.calculateScore(mol) for mol in mols]
    print(f"SAScore — mean: {np.mean(sa_scores):.2f} (1=easy, 10=hard to synthesize)")
    hard_synth = sum(1 for s in sa_scores if s > 6)
    print(f"Hard to synthesize (SA>6): {hard_synth}/{len(mols)} ({100*hard_synth/max(len(mols),1):.1f}%)")
except Exception as e:
    print(f"SAScore not available: {e}")

# Structural alerts: PAINS and Brenk
from rdkit.Chem.FilterCatalog import FilterCatalog, FilterCatalogParams

pains_params = FilterCatalogParams()
pains_params.AddCatalog(FilterCatalogParams.FilterCatalogs.PAINS)
pains_cat = FilterCatalog(pains_params)

brenk_params = FilterCatalogParams()
brenk_params.AddCatalog(FilterCatalogParams.FilterCatalogs.BRENK)
brenk_cat = FilterCatalog(brenk_params)

n_pains = sum(1 for mol in mols if pains_cat.HasMatch(mol))
n_brenk = sum(1 for mol in mols if brenk_cat.HasMatch(mol))
print(f"PAINS alerts:  {n_pains}/{len(mols)} ({100*n_pains/max(len(mols),1):.1f}%)")
print(f"Brenk alerts:  {n_brenk}/{len(mols)} ({100*n_brenk/max(len(mols),1):.1f}%)")

7. Scaffold diversity

from rdkit.Chem.Scaffolds import MurckoScaffold

scaffolds = set()
for mol in mols:
    try:
        scaffolds.add(Chem.MolToSmiles(MurckoScaffold.GetScaffoldForMol(mol)))
    except Exception:
        pass

print(f"Unique Murcko scaffolds: {len(scaffolds)}/{len(mols)} ({100*len(scaffolds)/max(len(mols),1):.1f}%)")

8. Internal diversity

from rdkit.Chem import DataStructs
from rdkit.Chem import rdMolDescriptors as rdmd
import random

fps = [rdmd.GetMorganFingerprintAsBitVect(mol, 2, 2048) for mol in mols]

# Sample up to 1000 pairs for speed
sample = random.sample(fps, min(len(fps), 200))
sims = []
for i in range(len(sample)):
    for j in range(i+1, len(sample)):
        sims.append(DataStructs.TanimotoSimilarity(sample[i], sample[j]))

diversity = 1 - np.mean(sims) if sims else 0.0
print(f"Internal diversity (1 - mean Tanimoto): {diversity:.3f}")

9. Similarity and novelty vs reference (if ref provided)

ref_path = Path("/absolute/path/to/reference.smi")
ref_smiles = [l.split()[0] for l in ref_path.read_text().splitlines() if l.strip()]
ref_mols = [Chem.MolFromSmiles(s) for s in ref_smiles if Chem.MolFromSmiles(s)]
ref_fps = [rdmd.GetMorganFingerprintAsBitVect(m, 2, 2048) for m in ref_mols]
ref_canon = set(Chem.MolToSmiles(m) for m in ref_mols)

nn_sims = []
for fp in fps:
    sims = DataStructs.BulkTanimotoSimilarity(fp, ref_fps)
    nn_sims.append(max(sims) if sims else 0.0)

novelty = sum(1 for s in valid_smiles if s not in ref_canon) / max(len(valid_smiles), 1)
print(f"Mean NN Tanimoto to reference: {np.mean(nn_sims):.3f}")
print(f"Novelty (not in reference): {100*novelty:.1f}%")

10. Generate plots

import matplotlib.pyplot as plt
from pathlib import Path

out_dir = Path("/absolute/workdir_analysis")
out_dir.mkdir(exist_ok=True)

# Physicochemical distributions
fig, axes = plt.subplots(2, 4, figsize=(16, 8))
for ax, col in zip(axes.flat, ["mw", "logp", "tpsa", "hbd", "hba", "rotbonds", "rings"]):
    ax.hist(df_props[col].dropna(), bins=30, edgecolor="k", alpha=0.7)
    ax.set_title(col.upper())
plt.tight_layout()
fig.savefig(out_dir / "physicochemical_dist.png", dpi=150)
plt.close(fig)
print(f"Saved: {out_dir}/physicochemical_dist.png")

# UMAP (requires umap-learn)
try:
    import umap
    import numpy as np
    mat = np.array([list(fp.ToBitString()) for fp in fps], dtype=float)
    emb = umap.UMAP(n_components=2, random_state=42).fit_transform(mat)
    fig, ax = plt.subplots(figsize=(8, 6))
    ax.scatter(emb[:,0], emb[:,1], s=5, alpha=0.5, label="generated")
    ax.set_title("ECFP4 UMAP")
    fig.savefig(out_dir / "umap_projection.png", dpi=150)
    plt.close(fig)
    print(f"Saved: {out_dir}/umap_projection.png")
except ImportError:
    print("umap-learn not installed — skipping UMAP (pip install umap-learn)")

11. Report results and flag issues

Always report:

  • Validity rate, unique molecule count
  • MW / LogP / TPSA / QED means
  • Lipinski RO5 pass rate
  • SAScore mean (if available) and hard-to-synthesize rate
  • PAINS and Brenk alert rates
  • Scaffold diversity %
  • Internal diversity score

If reference provided: mean NN Tanimoto, novelty %.

Flag actionable issues:

  • Validity < 90% → check sampling config or SMILES source
  • Lipinski pass < 70% → consider adding MW/LogP/HBD/HBA components to RL
  • Scaffold diversity < 20% → tighten RL diversity filter
  • Internal diversity < 0.5 → mode collapse risk
  • Mean NN Tanimoto > 0.7 with low novelty → model may need more TL diversity
  • SAScore mean > 5 → add SAScore reverse_sigmoid component to RL scoring
  • PAINS rate > 20% → add custom_alerts filter to RL config

Example

/analyze reinvent_runs/sampling_20240412/sampling.csv data/known_actives.smi
/analyze reinvent_runs/sampling_20240412/sampling.csv

Keep looking

Skills are one crate of 608,475. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.