AutoGineer
Generated banner for Nvmolkit Usage
Generated logo for Nvmolkit Usage

Nvmolkit Usage

NVIDIAOfficialCreated by Kevin Boyd (@scal444)Distributed by NVIDIA

  • Skill
  • Tool integration
  • Software development
  • Apache-2.0
  • Medium risk
Download ZIP

From the author

Use when writing or debugging nvMolKit Python code for GPU-accelerated RDKit fingerprints, similarity, conformers, clustering, and molecular searches.
— the description by Kevin Boyd (@scal444)

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

nvMolKit provides a Python API for high-throughput molecular operations by leveraging NVIDIA GPUs. It mirrors RDKit's API structure while enabling parallel processing of large batches of molecules. The library is designed for scenarios where throughput is prioritized over per-molecule latency, such as fingerprinting large libraries, bulk conformer embedding, or pairwise similarity calculations. It integrates with PyTorch for GPU-resident data handling, allowing for efficient chaining of operations without host-side round-trips.

What it does

  • Generates Morgan fingerprints in parallel on GPU.
  • Performs bulk Tanimoto and cosine similarity calculations.
  • Executes ETKDG conformer embedding and MMFF/UFF forcefield optimizations.
  • Calculates pairwise conformer RMSD and Torsion Fingerprint Deviation (TFD).
  • Provides GPU-accelerated Butina clustering and substructure searching.
  • Supports custom geometric constraints and forcefield configurations.

When to use it

  • When processing large batches of molecules (thousands or more).
  • When the same operation is repeated identically across a large dataset.
  • When you need to chain multiple molecular operations while keeping data on the GPU.
  • When optimizing for total wall-clock time across a batch.

Advantages

  • Significant throughput improvements for batch-oriented cheminformatics tasks.
  • Seamless integration with PyTorch for zero-copy GPU data exchange.
  • Supports asynchronous execution and custom CUDA stream control.
  • Provides flexible hardware tuning and autotuning capabilities.

Usage examples

“How do I calculate Morgan fingerprints for a list of SMILES strings using nvMolKit?”
The agent provides code to initialize a MorganFingerprintGenerator, process the list of RDKit Mol objects, and retrieve the results as a GPU-resident torch tensor.
“Can I perform MMFF94 minimization on a batch of conformers?”
The agent demonstrates using MMFFOptimizeMoleculesConfs to update conformer coordinates in-place on the GPU, returning optimized energies.
“How do I run a substructure search on a large library?”
The agent explains how to use the substructure module, including configuring batch sizes and worker threads for optimal GPU performance.
“How can I chain ETKDG embedding and similarity scoring without moving data to the CPU?”
The agent shows how to use CoordinateOutput.DEVICE to keep conformer coordinates on the GPU and pass them directly into downstream similarity or clustering functions.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/nvidia/nvmolkit-usage/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip nvmolkit-usage.zip -d .agents/skills

Documentation by Kevin Boyd (@scal444)

nvMolKit usage

Purpose

GPU-accelerated, batched implementations of common RDKit operations. APIs mirror RDKit where possible but are batch-oriented: they take lists of rdkit.Chem.Mol (or lists of fingerprints) and process them in parallel on one or more GPUs. nvMolKit links against RDKit at build time; inputs and outputs are real RDKit Mol objects.

This skill covers the installed Python API. Building nvMolKit from source is out of scope.

Where nvMolKit does well

Reach for nvMolKit when:

  • The workload is a large batch of molecules processed together (typically thousands or more).

  • The metric is throughput / total wall time across the batch, not per-molecule latency.

  • The same operation is repeated identically across the batch (fingerprinting a library, embedding/minimizing many conformers, bulk pairwise similarity), so the GPU stays saturated.

Requirements

  • An NVIDIA GPU with compute capability 7.0 (V100) or higher

  • A CUDA driver compatible with CUDA 12.6+.

  • A working torch install with CUDA support (nvMolKit returns GPU tensors via torch's CUDA array interface).

When helping with installation, make the user choose a PyTorch CUDA backend that the host driver supports before installing nvMolKit. nvMolKit's PyPI wheels are built with CUDA Toolkit 12.9 and depend on CUDA 12 runtime packages, but pip/uv can still select a CUDA 13 PyTorch wheel unless the install command says otherwise.

  • Conda: prefer conda-forge pytorch-gpu; pin cuda-version=12.6 or another CUDA version supported by the driver.

  • pip: send the user to the PyTorch install selector or previous-versions page to install torch for a CUDA 12.x backend before installing nvMolKit.

  • uv: install nvMolKit with an explicit backend, e.g. uv pip install --torch-backend=cu128 nvmolkit.

Inputs

  • Required: choose an operation and supply molecules or fingerprints from the user's code or molecular dataset. Parse SMILES with RDKit and reject failed parses (None).

  • Molecular operations use RDKit Mol objects. Add hydrogens for ETKDG; minimization and conformer comparisons need existing conformers.

  • Fingerprint similarity takes packed AsyncGpuResult, torch tensors, or NumPy arrays: one molecule per row, with int32 or uint32 words.

  • Optional: take conformer counts, fingerprint settings, cutoffs, output modes, and hardware options from the user's requested workflow; otherwise use the documented API defaults.

Limitations

  • CUDA is required; there is no CPU fallback. Use RDKit directly when CPU execution is needed.

  • Plain RDKit is usually preferable for single-molecule work or operations that cannot be batched.

  • ETKDG does not support custom bounds matrices, custom CPCI, coordinate maps, or separate-fragment embedding.

  • Substructure search does not support chirality-aware matching, enhanced stereochemistry, or other advanced RDKit SubstructMatchParameters options.

Instructions

  1. Run the smoke test below before writing nvMolKit code.

  2. Choose an API from the entry-point table and apply its input requirements.

  3. Handle its result as described below; synchronize asynchronous GPU results before host reads.

Verify the install before writing real code
import nvmolkit
import torch
from rdkit import Chem
from nvmolkit.fingerprints import MorganFingerprintGenerator

print("nvmolkit:", nvmolkit.__version__)
print("cuda available:", torch.cuda.is_available())
print("device count:", torch.cuda.device_count())

mols = [Chem.MolFromSmiles(smi) for smi in ["CCO", "c1ccccc1", "CC(=O)O"]]
fpgen = MorganFingerprintGenerator(radius=2, fpSize=1024)
result = fpgen.GetFingerprints(mols)
torch.cuda.synchronize()
fps = result.torch()
print("fps shape:", tuple(fps.shape), "dtype:", fps.dtype)
# Expected: shape (3, 32), dtype torch.int32  (1024 bits packed into 32 int32s per row)

If this fails, point the user at the installation guide rather than guessing.

Entry points

TaskModulePrimary entry point
Morgan fingerprintsnvmolkit.fingerprintsMorganFingerprintGenerator(radius, fpSize).GetFingerprints(mols)
Bulk Tanimoto / cosine similaritynvmolkit.similaritycrossTanimotoSimilarity(...), crossCosineSimilarity(...), plus *MemoryConstrained variants for results too large to fit in GPU memory
ETKDG conformer embeddingnvmolkit.embedMoleculesEmbedMolecules(molecules, params, confsPerMolecule, ...)
MMFF94 optimization (one-shot)nvmolkit.mmffOptimizationMMFFOptimizeMoleculesConfs(molecules, ..., minimizerKind=..., fireOptions=...)
UFF optimization (one-shot)nvmolkit.uffOptimizationUFFOptimizeMoleculesConfs(molecules, ..., minimizerKind=..., fireOptions=...)
Forcefield with custom options + constraintsnvmolkit.batchedForcefieldMMFFBatchedForcefield(mols, properties=..., nonBondedThreshold=..., ignoreInterfragInteractions=..., hardwareOptions=...), UFFBatchedForcefield(mols, vdwThreshold=..., ...). Per-molecule view ff[i] exposes add_distance_constraint, add_position_constraint, add_angle_constraint, add_torsion_constraint. Methods: .compute_energy(), .compute_gradients(), .minimize(maxIters, forceTol, minimizerKind=..., fireOptions=...)
Pairwise conformer RMSDnvmolkit.conformerRmsdGetConformerRMSMatrix(mol), GetConformerRMSMatrixBatch(mols)
Torsion Fingerprint Deviation (TFD)nvmolkit.tfdGetTFDMatrix(mol), GetTFDMatrices(mols)
Butina clusteringnvmolkit.clusteringbutina(distance_matrix, cutoff) (precomputed matrix), fused_butina(fingerprints, cutoff) (memory-efficient, on-the-fly); both support explicit RDKit and device output modes
Substructure searchnvmolkit.substructurehasSubstructMatch, countSubstructMatches, getSubstructMatches
Maximum common substructurenvmolkit.mcsfindMCS(mols, ...) for all pairs, explicit pairs, or two paired molecule lists
Hardware tuning (batch size, GPU IDs)nvmolkit.typesHardwareOptions(...) passed to ETKDG / MMFF / UFF
Optional autotuningnvmolkit.autotunetune_embed_molecules, tune_mmff_optimize, tune_uff_optimize, tune_batched_forcefield, tune_substructure, tune_mcs. Requires the optuna package

Result types and execution model

Two return shapes carry GPU-resident output, depending on what the operation produces.

AsyncGpuResult

Used by operations that return a single flat tensor (fingerprints, similarity matrices, RMSD/TFD vectors, Butina inputs). Key behaviors:

  • Asynchronous. The kernel may not have completed when the call returns.

  • result.torch() returns a zero-copy torch.Tensor on the GPU. Caller is responsible for synchronizing before reading values on the host.

  • result.numpy() synchronizes and returns a CPU numpy array.

  • Exposes __cuda_array_interface__, so it can be passed directly into other nvMolKit functions (e.g. fingerprints → similarity) with no host round-trip.

CUDA stream control

A subset of the AsyncGpuResult-returning APIs accept an optional stream: torch.cuda.Stream | None = None argument so callers can submit nvMolKit work to a non-default stream and overlap it with their own kernels. When omitted, the call uses the current torch stream.

APIs that take a stream argument:

  • MorganFingerprintGenerator.GetFingerprints

  • crossTanimotoSimilarity, crossCosineSimilarity, and their *MemoryConstrained variants

  • butina, fused_butina

  • GetConformerRMSMatrix, GetConformerRMSMatrixBatch

Other APIs (ETKDG, MMFF/UFF optimization, TFD, substructure search, MCS) are synchronous to the caller — no stream plumbing needed.

Typical pattern:

import torch
from rdkit import Chem
from nvmolkit.fingerprints import MorganFingerprintGenerator
from nvmolkit.similarity import crossTanimotoSimilarity

stream = torch.cuda.Stream()
fpgen = MorganFingerprintGenerator(radius=2, fpSize=1024)
mols = [Chem.MolFromSmiles(smi) for smi in ["CCO", "c1ccccc1", "CC(=O)O"]]

with torch.cuda.stream(stream):
    fps = fpgen.GetFingerprints(mols, stream=stream)
    sim = crossTanimotoSimilarity(fps, stream=stream)
stream.synchronize()
print(sim.torch())
Device3DResult

Used by ETKDG embedding and MMFF/UFF optimization (one-shot and BatchedForcefield) when called with output=CoordinateOutput.DEVICE. The GPU-resident equivalent of writing conformers back to Mol objects. Fields:

  • values: AsyncGpuResult of shape (total_atoms, 3) float64. Concatenated conformer coordinates in CSR-style layout.

  • atom_starts, mol_indices, conf_indices: AsyncGpuResult int32 buffers describing the layout (values[atom_starts[i]:atom_starts[i+1]] is conformer i's atoms).

  • energies, converged: AsyncGpuResult buffers populated only for MMFF/UFF minimization (not for plain ETKDG).

  • gpu_id: device the buffers live on. The targetGpu argument on each API picks this; targetGpu=-1 uses the default consolidation device.

  • .per_molecule() returns nested list[list[torch.Tensor]] of per-conformer views; .dense(pad_value=nan) materializes a padded (n_mols, max_confs, max_atoms, 3) tensor.

The default mode (CoordinateOutput.RDKIT_CONFORMERS) still writes optimized coordinates back into each Mol and returns Python lists of energies/convergence flags. Reach for CoordinateOutput.DEVICE when chaining downstream GPU work (e.g. ETKDG → MMFF → similarity scoring) without host round-trips.

MCSBatchResult

findMCS is synchronous and returns an MCSBatchResult backed by CPU NumPy arrays. Results are always flat: result[k] (or result.get_result(k)) materializes the result at pair position k, not generally the result for molecule k. Use result.pairs[k] to identify that pair. In all_pairs mode these are the generated pairs over mols; in pairs mode they exactly preserve the supplied pair sequence; in paired_lists mode item k compares mols[k] with mols_b[k], while result.pairs[k] uses the combined-table indices (k, len(mols) + k). Each MCSResult has pair, num_atoms, num_bonds, canceled, atom_mapping, and bond_mapping; the two columns of each mapping index the first and second molecule of that result pair, respectively.

Configuration

For ETKDG, forcefield, substructure, or MCS tuning, read the advanced configuration reference. It lists configuration fields, defaults, GPU selection, and autotuning APIs.

Examples

Morgan fingerprints + bulk Tanimoto similarity
import torch
from rdkit import Chem
from nvmolkit.fingerprints import MorganFingerprintGenerator
from nvmolkit.similarity import crossTanimotoSimilarity

smiles = ["CCO", "CCN", "c1ccccc1", "CC(=O)O", "CCOCC"]
mols = [Chem.MolFromSmiles(smi) for smi in smiles]

fpgen = MorganFingerprintGenerator(radius=2, fpSize=1024)
fps = fpgen.GetFingerprints(mols)

sim = crossTanimotoSimilarity(fps)
torch.cuda.synchronize()
print(sim.torch())

Inputs are list[Mol]. Output of GetFingerprints is an AsyncGpuResult wrapping an (n_mols, fpSize / 32) int32 tensor of packed bits. Pass it straight into crossTanimotoSimilarity for an (n, n) similarity matrix; pass two fingerprint sets for an (n, m) cross-matrix. For sets too large to materialize on the GPU, use crossTanimotoSimilarityMemoryConstrained (chunked compute, returns numpy on CPU).

ETKDG conformer embedding
from rdkit.Chem import AddHs, MolFromSmiles
from rdkit.Chem.rdDistGeom import ETKDGv3
from nvmolkit.embedMolecules import EmbedMolecules

mols = [AddHs(MolFromSmiles(smi)) for smi in ["C1CCCCC1", "C1CCCCC2CCCCC12", "COO"]]
params = ETKDGv3()

EmbedMolecules(mols, params, confsPerMolecule=10, maxIterations=-1)

for mol in mols:
    print(mol.GetNumConformers())

Inputs are sanitized list[Mol] with hydrogens added (AddHs). Conformers are added in-place; see Limitations for unsupported embedding options.

MMFF94 minimization of a batch of conformers
from rdkit.Chem import AddHs, MolFromSmiles
from rdkit.Chem.rdDistGeom import ETKDGv3
from nvmolkit.embedMolecules import EmbedMolecules
from nvmolkit.mmffOptimization import MMFFOptimizeMoleculesConfs

mols = [AddHs(MolFromSmiles(smi)) for smi in ["CCO", "CCN", "c1ccccc1"]]
params = ETKDGv3()
EmbedMolecules(mols, params, confsPerMolecule=5)

energies = MMFFOptimizeMoleculesConfs(mols, maxIters=500)
for mol, mol_energies in zip(mols, energies):
    print(mol.GetNumConformers(), mol_energies)

Inputs are list[Mol] with conformers already populated (typically by ETKDG, RDKit's EmbedMultipleConfs, or a prior nvMolKit call). Coordinates are updated in place; the return is list[list[float]] of optimized energies aligned with the input molecule order and conformer index. UFF is identical in shape: swap in from nvmolkit.uffOptimization import UFFOptimizeMoleculesConfs.

BFGS is the default minimizer. To use FIRE, pass minimizerKind="FIRE"; optionally customize it with a nvmolkit.types.FireOptions instance through fireOptions=. The one-shot MMFF and UFF functions and both batched-forcefield .minimize() methods accept the same selector.

If any input molecule is None or lacks MMFF/UFF atom types, the call raises ValueError. The exception's args[1] is a dict with keys "none" and "no_params" listing the offending indices - useful for filtering a noisy input set.

Conformer RMSD and Butina clustering
import torch
from rdkit import Chem
from rdkit.Chem.rdDistGeom import EmbedMultipleConfs
from nvmolkit.clustering import ButinaOutputMode, butina
from nvmolkit.conformerRmsd import GetConformerRMSMatrixBatch

mols = [Chem.AddHs(Chem.MolFromSmiles(smi)) for smi in ["CCCCCC", "c1ccccc1"]]
for mol in mols:
    EmbedMultipleConfs(mol, numConfs=10)

# Remove hydrogens after embedding for heavy-atom RMSD.
heavy_mols = [Chem.RemoveHs(mol) for mol in mols]

# Default RMSD output is RDKit-compatible condensed lower-triangle form.
condensed = GetConformerRMSMatrixBatch(heavy_mols)

# Butina expects a square distance matrix, so request square GPU tensors.
square = GetConformerRMSMatrixBatch(heavy_mols, output_format="square")
results = [
    butina(distance_matrix, cutoff=0.5, output=ButinaOutputMode.DEVICE)
    for distance_matrix in square
]

torch.cuda.synchronize()
for result in results:
    print(result.cluster_ids.torch().cpu().tolist())

Both Butina functions return GPU-resident results by default:

  • The default, output=ButinaOutputMode.DEVICE, returns cluster IDs, centroids, and sizes.

  • output=ButinaOutputMode.RDKIT returns RDKit cluster tuples on the host. The first element of each cluster is its centroid.

The device output fields are AsyncGpuResult objects. Use .torch() to access their CUDA tensors without a host copy or .numpy() to synchronize and copy a field to the host.

GetConformerRMSMatrix(mol) and GetConformerRMSMatrixBatch(mols) default to output_format="condensed", returning AsyncGpuResult objects that wrap RDKit-style flat vectors of length N * (N - 1) // 2. Use output_format="square" when chaining into butina() or any other API that expects an N x N distance matrix. Both forms live on the GPU; call .numpy() on condensed results or synchronize before moving square tensors to the CPU.

Atom-Atom Path similarity and directed sphere exclusion clustering

Atom-Atom Path (AAP) similarity with directed sphere exclusion (DISE) clustering provides device and RDKit-style output modes:

from rdkit import Chem
from nvmolkit.clustering import DISEOutputMode, aap_dise

molecules = [Chem.MolFromSmiles(smiles) for smiles in ["CCCC", "CCCO", "CCOC"]]
device_result = aap_dise(molecules)
rdkit_clusters = aap_dise(molecules, output=DISEOutputMode.RDKIT)

device_result has cluster_ids, centroids, and cluster_sizes fields; cluster IDs are zero-based and contiguous. DISEOutputMode.RDKIT describes the centroid-first RDKit cluster representation, not an RDKit implementation of the AAP+DISE algorithm. The current DISE control loop synchronizes before returning either mode; DEVICE describes the stable schema and where the result resides, not asynchronous execution of the overall call.

Maximum common substructure search
from rdkit import Chem
from nvmolkit.mcs import findMCS

mols = [Chem.MolFromSmiles(smi) for smi in ["CCO", "CCN", "c1ccccc1O"]]
result = findMCS(mols, mode="pairs", pairs=[(0, 1), (0, 2)])

for pair_idx, pair in enumerate(result.pairs):
    item = result[pair_idx]
    print(pair, item.num_atoms, item.num_bonds, item.atom_mapping)

The default mode="all_pairs" generates the upper triangle including the diagonal. mode="pairs" preserves an explicit pair list exactly, including duplicates and reversed pairs. mode="paired_lists" zips mols with an equally sized mols_b. Timeouts are per pair; inspect item.canceled because a timed-out result can contain the best partial MCS found.

Matching options include atom_compare, bond_compare, valence/formal-charge matching, and atom/bond ring-only matching. Unsupported RDKit fMCS options raise instead of silently changing semantics. For repeated representative explicit-pair workloads, nvmolkit.autotune.tune_mcs returns a TuneResult. Its best_config is the tuned MCSConfig to pass to findMCS(..., config=result.best_config).

Custom forcefield options + constraints (BatchedForcefield)

For per-molecule forcefield settings, geometric constraints, or separate energy and gradient calls, read the advanced forcefield recipe.

Troubleshooting

SymptomLikely causeAction
torch.cuda.is_available() is falseGPU access, driver compatibility, or the torch CUDA build is missingCheck the GPU and driver, then follow the installation guidance above to select a compatible torch build.
RuntimeError: invalid device ordinalA requested gpuIds entry is not visibleUse device indices below torch.cuda.device_count() or the API's documented GPU defaults.
An RDKit option is rejectedThe option is unsupported by that nvMolKit APIUse supported options only if they preserve the requested behavior; otherwise use RDKit for that operation.

Going deeper

Files

LICENSE

Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.


                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

   1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

   END OF TERMS AND CONDITIONS

   APPENDIX: How to apply the Apache License to your work.

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

   Copyright [yyyy] [name of copyright owner]

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Python

Security

What our scanner noticed· Medium risk

  • Large base64-encoded blobs
  • Instructions that use the network

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Kevin Boyd (@scal444)
Publisher
NVIDIA (Official)
Distributed by
NVIDIA
Source
NVIDIA/skills · skills/bionemo-nvmolkit-usage · commit fce3cca
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE-APACHE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Kevin Boyd (@scal444) or NVIDIA.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download nvmolkit-usage.zip