domains / science / medchem-compound-filtering / medchem

medchem

Skill card

combined

The K-Dense copy is the most technically precise and verified (pinned versions, DataFrame return types, Lilly native build requirements, and specific API distinctions like catalog_filter vs alert_filter). The other three copies (Vibe-Skills, aipoch, OpenClaw) are near-identical to each other and provide a broader, higher-level overview including Lilly Demerits, Chemical Groups, Complexity, and Constraints modules that the K-Dense copy truncates or omits in detail. They disagree on result formats (DataFrames vs dictionaries) and installation specifics (pinned vs latest). Combining is necessary to capture the verified low-level API details from K-Dense and the comprehensive module coverage from the others.

Repositories

Other copies

Combined skill

# Medchem

## Overview
Medchem is a Python library for molecular filtering and prioritization in drug discovery. Apply drug-likeness rules, structural alerts, complexity metrics, and property constraints to triage compound libraries. Filters are context-specific guidelines; combine with domain expertise.

## Installation
Requires Python 3.11+.
```bash
uv pip install "medchem==2.1.1" "datamol==0.13.0" "rdkit==2026.3.6"
```
Optional Lilly demerits require native tools (C++ compiler, make, zlib, Ruby):
```bash
medchem install-lilly
```

## Core Capabilities

### 1. Medicinal Chemistry Rules
Apply drug-likeness rules via `medchem.rules`.

**Single rule:**
```python
import medchem as mc
smiles = "CC(=O)OC1=CC=CC=C1C(=O)O"
mc.rules.basic_rules.rule_of_five(smiles)  # True
```

**Multiple rules (returns DataFrame):**
```python
import datamol as dm
mols = [dm.to_mol(s) for s in smiles_list]
rfilter = mc.rules.RuleFilters(rule_list=["rule_of_five", "rule_of_cns", "rule_of_leadlike_soft"])
df = rfilter(mols=mols, n_jobs=-1, progress=True)
passing = df[df["pass_all"]]
```

### 2. Structural Alert Filters
Detect problematic patterns with `medchem.structural`. Returns DataFrames with `pass_filter`, `status`, `reasons`.

**Common Alerts:**
```python
alert_filter = mc.structural.CommonAlertsFilters(alerts_set=["BMS", "Dundee", "Glaxo"])
df = alert_filter(mols=mol_list, n_jobs=-1)
clean = df[df["pass_filter"]]
```

**NIBR Filters:**
```python
nibr_filter = mc.structural.NIBRFilters()
df = nibr_filter(mols=mol_list, n_jobs=-1)
# Reject if severity >= 10: df["pass_filter"] & (df["severity"] < 10)
```

**Lilly Demerits:**
```python
lilly = mc.structural.LillyDemeritsFilters()
results = lilly(mols=mol_list, n_jobs=-1)
# Reject if demerits > 100
```

### 3. Named Catalogs (PAINS, Brenk, etc.)
Use `medchem.catalogs` for RDKit FilterCatalog instances.
```python
passes = mc.functional.catalog_filter(mols=mol_list, catalogs=["pains"], n_jobs=-1)
```
Note: `catalog_filter` rejects string names `nibr` and `bredt`; use dedicated functional filters for those.

### 4. Chemical Groups Detection
Identify functional groups using `medchem.groups`.
```python
group = mc.groups.ChemicalGroup(groups=["hinge_binders", "michael_acceptors"])
has_matches = group.has_match(mol_list)
```

### 5. Molecular Complexity
Calculate complexity metrics using `medchem.complexity`.
```python
complex_filter = mc.complexity.ComplexityFilter(max_complexity=500)
results = complex_filter(mols=mol_list, n_jobs=-1)
```

### 6. Constraints Filtering
Apply property-based constraints using `medchem.constraints`.
```python
constraints = mc.constraints.Constraints(
    mw_range=(200, 500),
    logp_range=(-2, 5),
    tpsa_max=140,
    rotatable_bonds_max=10
)
results = constraints(mols=mol_list, n_jobs=-1)
```

### 7. Medchem Query Language
Combine heterogeneous criteria (rules + alerts + numeric thresholds) into a single expression for complex filtering.

## Best Practices
- Prevalidate inputs; reject missing/empty structures before filtering.
- Use `keep_props=True` in RuleFilters to include computed descriptors (mw, clogp, tpsa).
- Start broad (Ro5/Veber), then tighten (CNS/lead-like) as project constraints become clearer.
- Use `n_jobs=-1` for parallelization on large libraries.