Rowan is a cloud-native molecular modeling and medicinal-chemistry workflow platform with a Python API. Use for pKa and macropKa prediction, conformer and tautomer ensembles, docking and analogue docking, protein-ligand cofolding, MSA generation, molecular dynamics, permeability, descriptor workflows, and related small-molecule or protein modeling tasks. Ideal for programmatic batch screening, multi-step chemistry pipelines, and workflows that would otherwise require maintaining local HPC/GPU infrastructure.
Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Um comando direto ignora o prompt de revisão. Verifique a origem antes de executá-lo.
Instruções da origem · Visualização somente leitura
name
rowan
description
Rowan is a cloud-native molecular modeling and medicinal-chemistry workflow platform with a Python API. Use for pKa and macropKa prediction, conformer and tautomer ensembles, docking and analogue docking, protein-ligand cofolding, MSA generation, molecular dynamics, permeability, descriptor workflows, and related small-molecule or protein modeling tasks. Ideal for programmatic batch screening, multi-step chemistry pipelines, and workflows that would otherwise require maintaining local HPC/GPU infrastructure.
license
Proprietary (API key required)
allowed-tools
Read Write Edit Bash
compatibility
Requires Python 3.12+ and a ROWAN_API_KEY. Rowan is a commercial hosted service — compute is metered and billed, so a large batch has a real cost. No local GPU or HPC needed.
metadata
{"version":"1.5","skill-author":"Rowan Science","trigger-keywords":"pKa prediction, molecular docking, conformer search, chemistry workflow, drug discovery, SMILES, protein structure, batch molecular modeling, cloud chemistry","openclaw":{"primaryEnv":"ROWAN_API_KEY","envVars":[{"name":"ROWAN_API_KEY","required":true,"description":"Rowan computational chemistry API key."}]}}
Rowan: Cloud-Native Molecular-Modeling and Drug-Design Workflows
Overview
Rowan is a cloud-native workflow platform for molecular simulation, medicinal chemistry, and structure-based design. Its Python API exposes a unified interface for small-molecule modeling, property prediction, docking, molecular dynamics, and AI structure workflows.
Use Rowan when you want to run medicinal-chemistry or molecular-design workflows programmatically without maintaining local HPC infrastructure, GPU provisioning, or a collection of separate modeling tools. Rowan handles all infrastructure, result management, and computation scaling.
When to use Rowan
Rowan is a good fit for:
Quantum chemistry, semiempirical methods, or neural network potentials
Batch medicinal-chemistry campaigns where you need consistent, scalable infrastructure
Rowan is not the right fit for:
Simple molecular I/O (use RDKit directly)
Post-HF ab initio quantum chemistry or relativistic calculations
Quick start
uv pip install rowan-python
import rowan
rowan.api_key = "your_api_key_here"# or set ROWAN_API_KEY env var# Submit a descriptors workflow — completes in under a minute
wf = rowan.submit_descriptors_workflow("CC(=O)Oc1ccccc1C(=O)O", name="aspirin")
result = wf.result()
print(result.descriptors['MW']) # 180.16print(result.descriptors['SLogP']) # 1.19print(result.descriptors['TPSA']) # 59.44
If that prints without error, you're set up correctly.
Installation
uv pip install rowan-python
# or: uv pip install rowan-python
User and webhook management
Authentication
Set an API key via environment variable (recommended):
export ROWAN_API_KEY="your_api_key_here"
Or set directly in Python:
import rowan
rowan.api_key = "your_api_key_here"
Verify authentication:
import rowan
user = rowan.whoami() # Returns user info if authenticatedprint(f"User: {user.email}")
print(f"Credits available: {user.credits_available_string}")
Molecule input formats
Rowan accepts molecules in the following formats:
SMILES (preferred): "CCO", "c1ccccc1O"
SMARTS patterns (for some workflows): subset of SMARTS for substructure matching
InChI (if supported in your API version): "InChI=1S/C2H6O/c1-2-3/h3H,2H2,1H3"
The API will validate input and raise a rowan.ValidationError if a molecule cannot be parsed. Always use canonicalized SMILES for reproducibility.
Tip: Use RDKit to validate SMILES before submission:
from rdkit import Chem
smiles = "CCO"
mol = Chem.MolFromSmiles(smiles)
if mol isNone:
raise ValueError(f"Invalid SMILES: {smiles}")
Core usage pattern
Most Rowan tasks follow the same three-step pattern:
Submit a workflow
Wait for completion (with optional streaming)
Retrieve typed results with convenience properties
import rowan
# 1. Submit — use the specific workflow function (not the generic submit_workflow)
workflow = rowan.submit_descriptors_workflow(
"CC(=O)Oc1ccccc1C(=O)O",
name="aspirin descriptors",
)
# 2. & 3. Wait and retrieve
result = workflow.result() # Blocks until done (default: wait=True, poll_interval=5)print(result.data) # Raw dictprint(result.descriptors['MW']) # 180.16 — use result.descriptors dict, not result.molecular_weight
For long-running workflows, use streaming:
for partial in workflow.stream_result(poll_interval=5):
print(f"Progress: {partial.complete}%")
print(partial.data)
result() vs. stream_result()
Pattern
Use When
Duration
result()
You can wait for the full result
<5 min typical
stream_result()
You want progress feedback or need early partial results
>5 min, or interactive use
Guideline: Use result() for descriptors, pKa. Use stream_result() for conformer search, docking, cofolding.
Working with results
Rowan's API includes typed workflow result objects with convenience properties.
For nontrivial campaigns, use projects and folders to keep work organized.
Projects
import rowan
# Create a project
project = rowan.create_project(name="CDK2 lead optimization")
rowan.set_project("CDK2 lead optimization")
# All subsequent workflows go into this project
wf = rowan.submit_descriptors_workflow("CCO", name="test compound")
# Retrieve later
project = rowan.retrieve_project("CDK2 lead optimization")
workflows = rowan.list_workflows(project=project, size=50)
Folders
# Create a hierarchical folder structure
folder = rowan.create_folder(name="docking/batch_1/screening")
wf = rowan.submit_docking_workflow(
# ... docking params ...
folder=folder,
name="compound_001",
)
# List workflows in a folder
results = rowan.list_workflows(folder=folder)
Workflow decision trees
pKa vs. MacropKa
Use microscopic pKa when:
You need the pKa of a single ionizable group
You're interested in acid–base transitions and protonation thermodynamics
The molecule has one or two ionizable sites
Speed is critical (faster, fewer credits)
Use macropKa when:
You need pH-dependent behavior across a physiologically relevant range (e.g., 0–14)
You want aggregated charge and protonation-state populations across pH
The molecule has multiple ionizable groups with coupled protonation
You need downstream properties like aqueous solubility at different pH
Example decision:
Phenol (pKa ~10): Use microscopic pKa
Amine (pKa ~9–10): Use microscopic pKa
Multi-ionizable drug (N, O, acidic group): Use macropKa
ADME assessment across GI pH: Use macropKa
Conformer search vs. tautomer search
Use conformer search when:
A single tautomeric form is known
You need a diverse 3D ensemble for docking, MD, or SAR analysis
Rotatable bonds dominate the chemical space
Use tautomer search when:
Tautomeric equilibrium is uncertain (e.g., heterocycles, keto–enol systems)
You need to model all relevant protonation isomers
Downstream calculations (docking, pKa) depend on tautomeric form
# From local PDB file
protein = rowan.upload_protein(
name="egfr_kinase_domain",
file_path="egfr_kinase.pdb",
)
# From PDB database
protein_from_pdb = rowan.create_protein_from_pdb_id(
name="CDK2 (1M17)",
code="1M17",
)
# Retrieve previously uploaded protein
protein = rowan.retrieve_protein("protein-uuid")
# List all proteins
my_proteins = rowan.list_proteins()
Protein preparation guidance
File format: PDB, mmCIF (Rowan auto-detects)
Water molecules: Rowan usually keeps relevant water; remove bulk water beforehand if desired
Heteroatoms: Cofactors, ions, and bound ligands are usually preserved; remove unwanted heteroatoms before upload
Multi-chain proteins: Fully supported
Resolution: Works with NMR structures, homology models, and cryo-EM; quality matters for downstream predictions
Validation: Rowan validates PDB syntax; severely malformed files may be rejected
Workflow catalog
Nine common workflow categories — descriptors, microscopic pKa, MacropKa, conformer
search, tautomer search, docking, analogue docking, MSA generation, and protein-ligand
cofolding — each with submission code and result shapes, plus the complete list of every
supported workflow type (core modeling, structure-based design, advanced computational
chemistry, reaction chemistry, advanced properties, binding free energy, and sequence and
structural biology) are in
references/workflow_catalog.md.
Batch submission, webhooks, and asynchronous work
Batch submit/poll/retrieve, the non-blocking fire-and-check pattern, webhook setup,
secret creation and rotation, payload and signature verification (with a FastAPI
handler), and webhook best practices are in
references/batch_and_webhooks.md.
A full lead-optimization campaign — project setup, tautomers, pKa across an analogue
series, result collection, and a docking follow-up — is in
references/end_to_end_example.md.
Use webhooks for long-running campaigns (>50 workflows) or asynchronous pipelines
Use streaming for interactive feedback on large conformer/docking searches
Summary
Use Rowan when your workflow requires cloud execution for molecular-design tasks, especially when you want one unified API and consistent result handling across small-molecule modeling, proteins, docking, ADME prediction, and ML structure generation.
Rowan is a molecular-design workflow platform, not just a remote chemistry engine. It handles infrastructure scaling, result persistence, and multi-step pipeline orchestration so you can focus on science.
Composing with the rest of the bundle
rdkit / datamol → before: standardise and desalt. You are paying per molecule, so do not
spend credits computing pKa for a counterion.
medchem → before: triage first. Filtering after the cloud run is money already spent.
free-energy-perturbation → alongside: Rowan removes the local-GPU requirement for FEP-scale
work; the network-design and cycle-closure discipline in that skill still applies to the results.
autodock-vina / diffdock → instead, when local: Rowan's docking is the same class of
question without infrastructure. Choose on cost and scale, not on quality.
pkpd-translation → after: predicted permeability and pKa feed dose projection.
tamarind → alongside: overlapping hosted-compute coverage, stronger on protein and structure
tools where Rowan is stronger on small-molecule quantum and ADME workflows.
