Skip to main content
Docs

Search guides and API endpoints, for example “Idempotency-Key” or “submit job”.

    Tools · Computational Biology

    MM-GBSA Rescoring

    Rescore docked or predicted protein–ligand complexes with an implicit-solvent MM-GBSA binding energy, and rank the poses.

    Updated October 1, 2026

    On this page

    Prices, workflows, and method papersOpen in the app

    MM-GBSA Rescoring gives each protein–ligand pose a physics-based binding energy, to re-rank docking hits with a different method from the docking score itself (and from GNINA's neural-network score). It runs OpenMM on a CPU by default, or a T4 GPU.

    How it works

    For each complex it builds the system (protein force field amber14 by default, or amber99sbildn; the ligand with OpenFF Sage), optionally minimizes it briefly in implicit solvent (GBSA, OBC2 model), and computes

    ΔG ≈ E(complex) − E(receptor) − E(ligand)

    in kcal/mol: an end-point estimate, with no sampling and no entropy term. More negative means stronger predicted binding. Use it to rank similar ligands against the same target; the absolute values are not binding free energies.

    Inputs

    Either:

    • a prepared receptor PDB (protein) and docked poses (pose or poses: SDF, PDBQT, or PDB), for example from AutoDock Vina, or
    • complete complexes (complex or complexes: PDB or mmCIF), for example from Boltz-2.

    Options: max_poses (up to 50), minimize (default on) and min_steps (default 100, up to 500; 0 scores the poses as they are).

    Outputs

    • scores.csv: each pose ranked by ΔG, with its energy components.
    • The poses reordered by score, for the next step.
    • summary.json: settings and counts.

    In a workflow, the score is available both as mm_gbsa_kcal_mol and as binding_affinity_kcal_mol, so filter steps can rank on it like a docking score.

    Not covered

    Free-energy perturbation, explicit-solvent sampling before scoring (run OpenMM MD for that), and Poisson–Boltzmann (MM-PBSA).

    Run it from the API

    Submit with Submit a job and the job_type below. Price it first with Estimate job reservation cost: submitting reserves that amount from your wallet, and the charge settles at the actual runtime.

    MM-GBSA Rescoring mm-gbsa

    Job type
    mm-gbsa
    Hardware
    cpu (default)t4
    Typical runtime
    30 min on CPU

    Payload

    Payload fields
    FieldTypeDescription
    proteinfile_object

    Prepared receptor PDB. Required with poses; omit in complexes mode.

    posefile_object

    Single docked pose (SDF, PDBQT, or PDB).

    posesfile_object | file_object[]

    Docked poses (SDF/PDBQT/PDB). XOR with complexes.

    complexfile_object

    Single protein–ligand complex (PDB or CIF).

    complexesfile_object | file_object[]

    Structure ensemble of complexes (PDB/CIF). XOR with protein+poses.

    max_posesinteger

    Default: 50Limits: ≥ 1, ≤ 50

    minimizeboolean

    False (or min_steps 0) is single-point GBSA with no minimization.

    Default: true

    min_stepsinteger

    Default: 100Limits: ≥ 0, ≤ 500

    force_fieldstring

    Default: "amber14"One of: "amber14", "amber99sbildn"

    solvent_modelstring

    Default: "implicit_obc2"One of: "implicit_obc2"

    File fields take {"name": "x.pdb", "content_b64": "…"} or a stored artifact, {"$artifact": {"id": "art-…", "port": "…"}}. Files are up to 25 MiB each.

    Example

    from cognichem_client import CogniChem

client = CogniChem.from_env()  # reads COGNICHEM_API_KEY
payload = {
    "protein": {
        "name": "protein.pdb",
        "content_b64": "<file contents, base64>",
    },
    "poses": {"name": "ligand.sdf", "content_b64": "<file contents, base64>"},
    "max_poses": 50,
    "minimize": True,
    "min_steps": 100,
    "force_field": "amber14",
    "solvent_model": "implicit_obc2",
}

estimate = client.jobs.estimate(job_type="mm-gbsa", payload=payload, resource="cpu")
print(f"Reserves ${estimate.cost:.2f}")

job = client.jobs.submit(
    job_name="my-mm-gbsa-run",
    job_type="mm-gbsa",
    payload=payload,
    resource="cpu",
)
status = client.jobs.wait(job.process_id)
if status.status == "completed":
    client.jobs.result(job.process_id, save_path=".")

    Sample data from the job catalog; long values are shortened here. Each job_name must be unique among your jobs.

    Workflow inputs

    • Structures (list) · optionalPDB, CIF
    • Docked poses (list) · optionalSDF, PDBQT, PDB
    • Protein structure · optionalPDB

    Workflow outputs

    • ArchiveZIP
    • Docked posesSDF
    • TableCSV