Complexa Evaluate Pdbs

NVIDIAOfficialPublished by NVIDIA

Skill
Workflow
Science and research
Apache-2.0
Medium risk
Has scripts

From the author

Agent runbook for evaluating an existing PDB directory through the separately installed first-party Proteina-Complexa CLI. Use to refold or score designs, compute interface pAE, i_pLDDT, scRMSD, motif RMSD, or designability, run complexa analysis, or assess third-party BindCraft, AlphaProteo, or RFdiffusion outputs. SKILL.md selects and invokes the evaluation configuration; bundled executables only inspect local readiness and write a run manifest.

— the description by NVIDIA

AutoGineer summary

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

The complexa-evaluate-pdbs skill provides a structured workflow to evaluate directories of pre-existing PDB files. It utilizes the Proteina-Complexa CLI to perform refolding and metric computation, including interface pAE, i_pLDDT, scRMSD, and designability scores. The skill supports various design types such as protein binders, ligand binders, and AME (motif-ligand) designs, allowing users to assess outputs from third-party tools like BindCraft, AlphaProteo, or RFdiffusion. It handles the full evaluation pipeline from pre-flight environment checks to final manifest generation.

What it does

Refolds PDB files using backends like AF2, RF3, ESMFold, or Boltz2.
Computes interface metrics including i_pAE, i_pTM, pLDDT, and scRMSD.
Assesses monomer and codesignability through ProteinMPNN-based redesign.
Calculates motif-specific metrics such as motif RMSD and sequence recovery.
Aggregates results into CSV summaries with pass-rate analysis based on defined thresholds.
Generates a run manifest to track configurations, git SHAs, and output paths for reproducibility.

When to use it

When you need to evaluate a directory of pre-existing PDB designs.
When assessing the quality of third-party protein binder or ligand binder outputs.
When performing motif-aware evaluation for enzyme or AME designs.
When you need to generate standardized pass-rate reports for a set of protein structures.

Advantages

Automates the complex evaluation-to-analysis pipeline for protein designs.
Supports multiple folding backends and design types within a unified configuration framework.
Provides standardized metrics and success thresholds for consistent result interpretation.
Includes pre-flight checks to ensure hardware and environment readiness before execution.

Usage examples

“Evaluate my protein binder PDBs in /data/designs using AF2.”: The agent runs the pre-flight check, then executes the complexa analysis command with the protein_binder configuration and colabdesign backend.
“Score these ligand binder designs in /data/ligands.”: The agent identifies the ligand_binder type, configures the RF3 folding backend, and runs the evaluation and analysis steps.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/nvidia/complexa-evaluate-pdbs/download

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

mkdir -p .agents/skills && unzip complexa-evaluate-pdbs.zip -d .agents/skills

Documentation by NVIDIA

Complexa Evaluate-PDBs Skill

Score a directory of pre-existing PDB files against the same metrics Proteina-Complexa uses internally. Wraps complexa analysis <evaluate_config> ++sample_storage_path=<dir>: the CLI runs the evaluate step (refold + interface metrics + monomer metrics) and then the analyze step (success thresholds, diversity, pass-rate CSVs). Do not run complexa generate here — the inputs already exist.

What this skill enables

Re-fold a directory of designed PDBs with AF2 (colabdesign), RF3 (rf3_latest), ESMFold (esmfold), or Boltz2 (boltz2_default).
Compute binder interface metrics: i_pAE, min_ipAE, i_pTM, pLDDT, binder/complex scRMSD.
Compute monomer designability (ProteinMPNN-redesigned scRMSD) and codesignability (original sequence refold scRMSD).
For motif inputs: motif RMSD (CA + all-atom), motif-region designability/codesignability, sequence recovery.
Aggregate into per-PDB CSVs plus pass-rate summaries using the default thresholds for the result_type.

Step 1: Pre-flight

Always check GPU / disk / tool binaries before launching a refold job. RF3 and ColabDesign-AF2 are large.

bash scripts/preflight.sh

Surface from preflight.json:

gpu.available and gpu.vram_gb — colabdesign/RF3 need ≥40 GB; ESMFold tolerates ≥24 GB.
env.missing_required — must include the keys for the chosen folding backend:
- colabdesign → AF2_DIR
- rf3_latest → RF3_CKPT_PATH, RF3_EXEC_PATH
- esmfold → ESMFold weights resolvable
tools.{foldseek,mmseqs} — required by aggregation.compute_diversity / compute_mmseqs_diversity (both default true).

If any required key is missing, route the user to the complexa-setup skill.

Step 2: Identify the design type

Like complexa design, evaluation has one default flow (protein binder) and two extensions (ligand binder, AME). The evaluate config you pass to complexa analysis decides everything else (which metrics, which refolder defaults, which thresholds the analyze step applies).

Default — protein binder

complexa analysis configs/evaluate_from_pdb_dir.yaml \
    ++sample_storage_path=/abs/path/to/pdbs \
    ++dataset.task_name=02_PDL1 \
    ++result_type=protein_binder \
    ++metric.binder_folding_method=colabdesign \
    ++metric.inverse_folding_model=soluble_mpnn \
    ++run_name=eval_pdl1_af2

Use this when the user's PDBs are protein-binder designs (multi-chain, binder is the last chain) or third-party outputs from BindCraft / AlphaProteo / RFdiffusion. Pulls thresholds for protein_binder (i_pAE * 31 ≤ 7.0, pLDDT ≥ 0.9, scRMSD_ca < 1.5 Å).

Extensions — pick the matching config

Design type	Use the protein-binder default?	Evaluate config	Analyze config	`result_type`	Default backend
Protein binder	Yes (default)	`configs/evaluate_from_pdb_dir.yaml`	`configs/analyze.yaml`	`protein_binder`	`colabdesign` (AF2)
Ligand binder (binder + small-molecule)	Same evaluate config, swap 3 overrides	`configs/evaluate_from_pdb_dir.yaml`	`configs/analyze.yaml`	`ligand_binder`	`rf3_latest`
AME / motif + ligand (enzyme outputs)	No — needs motif-aware config	`configs/evaluate_ame_from_pdb_dir.yaml`	`configs/analyze_motif_binder.yaml`	`motif_ligand_binder`	`rf3_latest`
Motif protein binder (standalone)	No — no `_from_pdb_dir` variant	`configs/evaluate_motif_binder.yaml` + `++input_mode=pdb_dir`	`configs/analyze_motif_binder.yaml`	`motif_protein_binder`	`colabdesign` / `rf3_latest`

Extending to ligand binder (same evaluate config as default, three override swaps):

complexa analysis configs/evaluate_from_pdb_dir.yaml \
    ++sample_storage_path=/abs/path/to/pdbs \
    ++dataset.task_name=39_7V11_LIGAND \
    ++result_type=ligand_binder \
    ++metric.binder_folding_method=rf3_latest \
    ++metric.inverse_folding_model=ligand_mpnn \
    ++run_name=eval_v11_rf3

Extending to AME (different config; ligand auto-completion gotcha — see Step 4):

complexa analysis configs/evaluate_ame_from_pdb_dir.yaml \
    ++sample_storage_path=/abs/path/to/pdbs \
    ++dataset.task_name=M0096_1chm \
    ++run_name=eval_ame_chm

See references/eval_configs.md for the full matrix (every result_type, every threshold default, every supported folding backend, motif-protein-binder variant).

Step 3: Gather inputs (AskUserQuestion)

Ask in one batched AskUserQuestion:

pdb_dir — absolute path to the directory of PDBs to evaluate.
Design type — protein binder / ligand binder / AME (motif + ligand).
Folding backend — colabdesign (AF2, protein binders), rf3_latest (ligand / AME), boltz2_default (alternative).
Target / task name — must match a key in configs/targets/targets_dict.yaml, configs/targets/ligand_targets_dict.yaml, or configs/design_tasks/ame_dict_v2.yaml. Required for binder + AME evaluation (needed to identify the target reference and, for AME, the motif contigs).
AME-only: confirm ligand residue name is already renamed to L:0 in every PDB (see Troubleshooting). If not, do that rename first.

Step 4: Run evaluate → analyze

Prefer complexa analysis (the evaluate→analyze chain) — it reuses the same config for both steps and writes a single log dir.

# Protein binder PDB dir, AF2 refold
complexa analysis configs/evaluate_from_pdb_dir.yaml \
  ++sample_storage_path=/abs/path/to/pdbs \
  ++dataset.task_name=02_PDL1 \
  ++metric.binder_folding_method=colabdesign \
  ++metric.inverse_folding_model=soluble_mpnn \
  ++result_type=protein_binder \
  ++run_name=eval_pdl1_af2

For ligand binders flip binder_folding_method=rf3_latest, inverse_folding_model=ligand_mpnn, result_type=ligand_binder. For AME use configs/evaluate_ame_from_pdb_dir.yaml — see references/eval_configs.md for full worked examples.

If you need to inspect output between stages, run them separately. The configs above are shared between evaluate and analyze:

complexa evaluate configs/evaluate_from_pdb_dir.yaml ++sample_storage_path=/abs/path/to/pdbs ++run_name=eval_pdl1_af2
complexa analyze  configs/evaluate_from_pdb_dir.yaml ++run_name=eval_pdl1_af2

Dry-run first if the user is unsure (no GPU work happens; the planned file walk + invocation prints):

complexa analysis configs/evaluate_from_pdb_dir.yaml ++sample_storage_path=/abs/path/to/pdbs ++dryrun=true

Direct module invocation (debug fallback)

complexa evaluate / analyze are subprocess wrappers around the Hydra modules with logging + parallel job splitting bolted on. To attach a debugger or run under a profiler, invoke the module directly:

python -m proteinfoundation.evaluate \
    --config-path "$(realpath configs)" \
    --config-name evaluate_from_pdb_dir \
    ++sample_storage_path=/abs/path/to/pdbs \
    ++dataset.task_name=02_PDL1 \
    ++metric.binder_folding_method=colabdesign \
    ++run_name=eval_debug

For normal one-shot runs prefer complexa analysis — you get the shared log dir and a single replayable invocation, instead of having to thread the same overrides through two python -m calls.

Step 5: Parse results

Output lands under ./evaluation_results/${run_name}/:

Per-PDB metrics CSV — *_results_*.csv (one row per input PDB × sequence_types).
Pass-rate summaries — written by the analyze step (e.g. res_designability.csv, res_filter_ligand_pass_*.csv, success_criteria_*.json).
Diversity output — FoldSeek/MMseqs2 cluster files when aggregation.compute_diversity=true (default).

Summarize to the user:

Per-PDB row count and number of successful designs vs total.
Default-threshold pass rate by result_type (e.g. for protein_binder: i_pAE*31 <= 7.0 AND pLDDT >= 0.9 AND scRMSD_ca < 1.5).
Top 5 designs by primary metric (i_pAE for protein, min_ipAE for ligand, motif_rmsd_pred_all for motif binders).

Step 6: Emit manifest

Capture the resolved invocation + outputs for replay.

python3 scripts/write_manifest.py \
  --output-dir ./evaluation_results/${run_name} \
  --command "complexa analysis configs/evaluate_from_pdb_dir.yaml ++sample_storage_path=<dir> ++dataset.task_name=<task> ++metric.binder_folding_method=<backend> ++run_name=<run>" \
  --skill complexa-evaluate-pdbs \
  --out ./eval_manifest.json

The manifest pins: resolved config, git SHA, ckpt SHA-256s, the result CSV paths, and the user-stated result_type for replay.

Most common overrides

Override	Effect
`++sample_storage_path=<dir>`	The directory of PDBs to evaluate (required).
`++dataset.task_name=<name>`	Target / AME task name (binders, AME). Resolves target PDB + contigs.
`++metric.binder_folding_method=<backend>`	`colabdesign` / `rf3_latest` / `boltz2_default`.
`++metric.inverse_folding_model=<model>`	`protein_mpnn` / `soluble_mpnn` / `ligand_mpnn`.
`++metric.sequence_types=[self,mpnn,mpnn_fixed]`	Which sequence flavors to refold.
`++metric.num_redesign_seqs=N`	ProteinMPNN/LigandMPNN redesign count.
`++metric.compute_pre_refolding_metrics=true`	Add bioinformatics/TMOL/HBPLUS metrics on the input structures.
`++metric.keep_folding_outputs=true`	Save the refolded PDBs (large, but useful for inspection).
`++result_type=<type>`	Override default thresholds: `protein_binder` / `ligand_binder` / `motif_protein_binder` / `motif_ligand_binder`.
`++aggregation.success_thresholds.<…>`	Tighten or loosen specific thresholds (see `references/eval_configs.md`).
`++eval_njobs=N`	Parallel GPUs for the evaluate step.
`++dryrun=true`	Plan without running any folding.
`++file_limit=N`	Cap input PDBs (handy for first-pass smoke tests).

Hardware

GPU: ≥1 CUDA GPU. AF2 (colabdesign) and RF3 (rf3_latest) need ≥40 GB VRAM (A100/H100/L40S). ESMFold runs on ≥24 GB. Multi-GPU via ++eval_njobs=N.
CPU/disk: 24 CPUs default (ncpus_: 24). Each refolded PDB + intermediate output is ~1–5 MB; keep_folding_outputs=true can balloon to tens of GB for thousands of inputs.
See references/hardware.md for per-backend wall-clock and VRAM tables.

Troubleshooting

Error: Config file not found — paths are relative to the repo root; cd to the repo before invoking complexa analysis.
compute_motif_binder_metrics=True but result_type=protein_binder — result_type and the underlying compute_*_metrics must agree. Use configs/evaluate_ame_from_pdb_dir.yaml for AME inputs rather than mutating evaluate_from_pdb_dir.yaml.
RF3 shape errors on AME PDBs — RF3 tries to auto-complete the ligand atoms from CCD. Rename the ligand residue to L:0 in every input PDB before evaluation; see the snippet in README.md (atom_array.res_name[ligand_mask] = "L:0").
Diversity step fails (foldseek not found) — FOLDSEEK_EXEC not on PATH. Either fix .env (preferred) or disable: ++aggregation.compute_diversity=false ++aggregation.compute_mmseqs_diversity=false.
All pass-rates are 0% — check the binder_folding_method matches the target type (RF3 for ligand, AF2 for protein) and that ++dataset.task_name resolves to the correct reference PDB (complexa target show <name> to verify).

Reference

Full evaluate/analyze config matrix, every supported result_type, per-threshold defaults, and three worked examples (protein binder / ligand binder / AME): see references/eval_configs.md.

Files

ATTRIBUTION.mdAdded by AutoGineer885 B
BENCHMARK.md7.7 KiB
LICENSELicence file added by AutoGineer11.2 KiB
SKILL.md12.7 KiB
config/skillspector-baseline.yml1.2 KiB
evals/evals.json5.0 KiB
evals/trigger_evals.json1.4 KiB
references/CONFIGURATION_GUIDE.md34.7 KiB
references/EVALUATION_METRICS.md55.9 KiB
references/INFERENCE.md14.9 KiB
references/SEARCH_METADATA.md7.7 KiB
references/SWEEP.md10.6 KiB
references/eval_configs.md12.4 KiB
references/hardware.md4.8 KiB
scripts/preflight.shScript8.4 KiB
scripts/write_manifest.pyScript9.6 KiB
skill-card.md5.3 KiB
skill.oms.sig7.0 KiB

references/INFERENCE.md

Inference and Search Guide

How to run protein design with Proteina-Complexa: local execution, SLURM cluster deployment, custom targets, and troubleshooting.

Documentation Map
Tuning YAML configs? See Configuration Guide.
Understanding metrics? See Evaluation Guide.
Parameter sweeps? See Sweep System.
Search metadata? See Search Metadata.

Pipeline Overview
Design Pipeline Types
Configuration Architecture
Running Locally
SLURM Cluster Execution
Defining Custom Targets
Troubleshooting
Examples

Pipeline Overview

All design pipelines share the same four-stage structure:

Stage	Module	Config Section	Description
1. Generate	`proteinfoundation.generate`	`generation.*`	Sample structures using flow matching + reward scoring
2. Filter	`proteinfoundation.filter`	`generation.filter.*`	Filter samples by reward scores
3. Evaluate	`proteinfoundation.evaluate`	`metric.*`	Redesign sequences and validate with structure prediction
4. Analyze	`proteinfoundation.analyze`	`aggregation.*`	Aggregate metrics, compute success rates, diversity

Design Pipeline Types

There are three main design pipelines, each targeting a different design task:

Protein Binder Pipeline

Design protein binders for target proteins. Uses AF2 as the primary reward model and ColabDesign (AF2) or RF3 for evaluation refolding.

complexa design configs/search_binder_local_pipeline.yaml \
    ++run_name=my_binder ++generation.task_name=02_PDL1

Aspect	Setting
Model	Protein model (`complexa.ckpt`)
Generation reward	AF2 folding (TMOL, bioinformatics optional)
Inverse folding	SolubleMPNN
Evaluation folding	ColabDesign (default), RF3
Evaluation type	`protein_type: binder`, `result_type: protein_binder`
Analysis modes	`[binder, monomer]`

Ligand Binder Pipeline

Design proteins that bind small-molecule ligands. Uses RF3 for both reward and evaluation since it can handle protein-ligand complexes.

complexa design configs/search_ligand_binder_local_pipeline.yaml \
    ++run_name=my_ligand_binder ++generation.task_name=39_7V11_LIGAND

Aspect	Setting
Model	Ligand model with LoRA (`complexa_ligand.ckpt`)
Generation reward	RF3 folding
Inverse folding	LigandMPNN
Evaluation folding	RF3
Evaluation type	`protein_type: binder`, `result_type: ligand_binder`
Analysis modes	`[binder, monomer]`

AME Pipeline (Motif + Ligand Binder)

Scaffold functional motifs with ligand context. Combines motif features (atom-spec mode) and ligand features. Uses RF3 for reward and evaluation.

complexa design configs/search_ame_local_pipeline.yaml \
    ++run_name=my_ame ++generation.task_name=M0096_1chm

Aspect	Setting
Model	AME model with LoRA (`complexa_ame.ckpt`)
Generation reward	RF3 folding
Inverse folding	LigandMPNN
Evaluation folding	RF3
Evaluation type	`protein_type: motif_binder`, `result_type: motif_ligand_binder`
Analysis modes	`[motif_binder, binder, monomer]`
Extra metrics	Motif RMSD, motif sequence recovery, ligand clash detection

Motif Binder Evaluation (Standalone)

Each base binder type (protein, ligand) has a motif counterpart that adds motif preservation metrics on top of the standard binder evaluation. The AME pipeline automatically uses motif_ligand_binder, but you can also run motif binder evaluation standalone on outputs from any binder pipeline:

# Motif protein binder evaluation (on outputs from protein binder pipeline)
complexa evaluate configs/evaluate_motif_binder.yaml \
    ++dataset.task_name=MY_MOTIF_TASK \
    ++metric.binder_folding_method=colabdesign \
    ++metric.inverse_folding_model=soluble_mpnn

# Analysis (set result_type to match)
complexa analyze configs/analyze_motif_binder.yaml \
    ++result_type=motif_protein_binder

Variant	`result_type`	Binder thresholds	Motif thresholds
Motif Protein Binder	`motif_protein_binder`	i_pAE*31 <= 7.0, pLDDT >= 0.8, scRMSD_ca < 2.0	motif_rmsd < 2.0, seq_recovery >= 1.0
Motif Ligand Binder	`motif_ligand_binder`	scRMSD_bb3 <= 2.0	motif_rmsd <= 1.5, seq_recovery >= 1.0, no ligand clashes

Configuration Architecture

The pipeline uses a modular config system. Each top-level pipeline config composes stage-specific sub-configs via Hydra defaults:

configs/search_binder_local_pipeline.yaml
├── pipeline/binder/binder_generate.yaml    → generation.*
├── pipeline/binder/binder_evaluate.yaml    → metric.*
└── pipeline/binder/binder_analyze.yaml     → aggregation.*

configs/search_ligand_binder_local_pipeline.yaml
├── pipeline/ligand_binder/ligand_binder_generate.yaml    → generation.*
├── pipeline/ligand_binder/ligand_binder_evaluate.yaml    → metric.*
└── pipeline/ligand_binder/ligand_binder_analyze.yaml     → aggregation.*

configs/search_ame_local_pipeline.yaml
├── pipeline/ame/ame_generate.yaml    → generation.*
├── pipeline/ame/ame_evaluate.yaml    → metric.*
└── pipeline/ame/ame_analyze.yaml     → aggregation.*

For the full config structure, pipeline YAML examples, and every configurable parameter, see the Configuration Guide.

Note: You can also run individual modules directly with python -m proteinfoundation.generate, python -m proteinfoundation.evaluate, etc. The complexa CLI wraps these with additional validation and logging.

Running Locally

Quick Start

# Protein binder design
complexa design configs/search_binder_local_pipeline.yaml \
    ++run_name=my_binder ++generation.task_name=02_PDL1

# Ligand binder design
complexa design configs/search_ligand_binder_local_pipeline.yaml \
    ++run_name=my_ligand_binder ++generation.task_name=39_7V11_LIGAND

# AME motif scaffolding
complexa design configs/search_ame_local_pipeline.yaml \
    ++run_name=my_ame ++generation.task_name=M0096_1chm

Validate Before Running

complexa validate design configs/search_binder_local_pipeline.yaml
complexa validate design configs/search_ligand_binder_local_pipeline.yaml
complexa validate design configs/search_ame_local_pipeline.yaml

Individual Stages

complexa generate configs/search_binder_local_pipeline.yaml
complexa filter configs/search_binder_local_pipeline.yaml
complexa evaluate configs/search_binder_local_pipeline.yaml
complexa analyze configs/search_binder_local_pipeline.yaml

The same stage commands work for all pipeline configs -- just substitute the config path.

CLI Options

# Verbose mode (show output instead of logging to file)
complexa design configs/search_binder_local_pipeline.yaml --verbose

# Override any config parameter with ++key=value
complexa design configs/search_binder_local_pipeline.yaml \
    ++generation.args.nsteps=200 \
    ++metric.binder_folding_method=rf3_latest

Common Overrides

# Change target
++generation.task_name=33_TrkA

# Change search algorithm
++generation.search.algorithm=beam-search
++generation.search.beam_search.beam_width=8

# Change sampling steps (fewer = faster, lower quality)
++generation.args.nsteps=200

# Change folding model for evaluation
++metric.binder_folding_method=rf3_latest

# Change reward weights (protein binder -- AF2)
++generation.reward_model.reward_models.af2folding.reward_weights.i_pae=-2.0

# Change reward weights (ligand binder / AME -- RF3)
++generation.reward_model.reward_models.rf3folding.reward_weights.min_ipAE=-2.0

# Change success thresholds for analysis
++aggregation.success_thresholds.i_pAE.threshold=5.0

# Change filter settings
++generation.filter.filter_samples_limit=500
++generation.filter.reward_threshold=0.5

For the full list of configurable parameters, see the Configuration Guide.

Quick Local Test

complexa design configs/search_binder_local_pipeline.yaml \
    ++run_name=quick_test \
    ++generation.task_name=02_PDL1 \
    ++generation.args.nsteps=100 \
    ++generation.dataloader.dataset.nres.nsamples=2

Config	Use case
`search_binder_local_pipeline.yaml`	Protein-protein binder design (local)
`search_ligand_binder_local_pipeline.yaml`	Small-molecule binder design (local)
`search_ame_local_pipeline.yaml`	AME motif scaffolding (local)
`search_binder_pipeline.yaml`	Protein binder design (SLURM cluster)

SLURM Cluster Execution

Setup

Create user configuration:

cp slurm_utils/.user_info_example slurm_utils/.user_info

Edit .user_info with your cluster credentials:

USER="your_username"
REMOTE="cluster.example.com"
ROOT_REMOTE="/path/to/workspace"
ENV_BINDER="complexa"
PYTHON_BINDER="/path/to/python"
MAMBA_EXEC="/path/to/mamba"

Launch Scripts

From local machine (SSH to cluster):

# Single target
bash slurm_utils/launch_protein_binder_search_from_local_conda.sh 02_PDL1

# Single target with run number
bash slurm_utils/launch_protein_binder_search_from_local_conda.sh 02_PDL1 2

# All targets from config
bash slurm_utils/launch_protein_binder_search_from_local_conda.sh

# Multiple targets via loop
bash slurm_utils/launch_protein_binder_search_target_loop_conda.sh

Directly on cluster:

./slurm_utils/launch_protein_binder_search_from_slurm_conda.sh 02_PDL1
./slurm_utils/launch_protein_binder_search_from_slurm_conda.sh  # all targets

What the Launcher Does

Config generation -- Creates per-run configs in configs/inference_configs/ and configs/eval_configs/
Code sync -- Rsyncs code to cluster (local launcher only)
Job submission -- Submits SLURM array jobs for each stage
Monitoring -- Waits for each stage to complete before proceeding
Result download -- Downloads results locally (local launcher only)

Job Parallelism

Use gen_njobs and eval_njobs to parallelize across samples:

complexa evaluate configs/search_binder_pipeline.yaml \
    ++eval_njobs=20 \
    ++job_id=$SLURM_ARRAY_TASK_ID

Set eval_njobs to match gen_njobs so each eval job processes one generation job's outputs.

Defining Custom Targets

Protein Targets

Add entries to configs/targets/targets_dict.yaml:

target_dict_cfg:
  my_target:
    source: my_targets           # Subfolder in $DATA_PATH/target_data/
    target_filename: my_protein  # PDB filename (without .pdb)
    target_input: A1-150         # Chain and residue range
    hotspot_residues: [A45, A67, A89]
    binder_length: [60, 120]     # [min, max] binder length
    pdb_id: 1abc                 # Optional: PDB ID reference

Then run:

complexa design configs/search_binder_local_pipeline.yaml \
    ++generation.task_name=my_target

Ligand Targets

Add entries to configs/targets/ligand_targets_dict.yaml with additional fields:

target_dict_cfg:
  my_ligand_target:
    source: my_targets
    target_filename: my_complex
    target_input: A1-200
    binder_length: [60, 120]
    pdb_id: 2xyz
    res_name: LIG               # Ligand residue name in PDB
    ligand_only: false           # Whether the target is ligand-only
    SMILES: "CCO"               # SMILES string for the ligand
    use_bonds_from_file: true    # Use bond topology from PDB

Target Input Format

The target_input field specifies which residues to use:

A1-150 -- Chain A, residues 1-150
A1-100,B1-50 -- Multiple chains/ranges
A -- Entire chain A

Hotspot Residues

Interface residues the binder should contact:

hotspot_residues: [A45, A67, A89, A102]

Troubleshooting

Import Errors

Set PYTHONPATH if running without installation:

export PYTHONPATH=/path/to/project/src:/path/to/project/community_models:$PYTHONPATH

Missing Model Weights

complexa download --status

Config Validation Failures

complexa validate design configs/search_binder_local_pipeline.yaml --verbose

RF3 Environment Variables

RF3 requires RF3_CKPT_PATH and RF3_EXEC_PATH to be set. Add them to your .env or export them:

export RF3_CKPT_PATH=/path/to/rf3_latest.pt
export RF3_EXEC_PATH=/path/to/rf3

SLURM Job Failures

ls slurm_run_outputs/inf/   # Generation logs
ls slurm_run_outputs/eval/  # Evaluation logs

Memory Issues

Reduce batch size or parallelization:

++generation.dataloader.batch_size=8
++gen_njobs=1
++eval_njobs=1

Examples

Production Beam Search (Protein Binder)

complexa design configs/search_binder_local_pipeline.yaml \
    ++run_name=pdl1_beam_v1 \
    ++generation.task_name=02_PDL1 \
    ++generation.search.algorithm=beam-search \
    ++generation.search.beam_search.beam_width=8 \
    ++generation.search.beam_search.n_branch=4

Multiple Targets on SLURM

# Launch all targets defined in config
bash slurm_utils/launch_protein_binder_search_target_loop_conda.sh

# Or specific targets
for target in 02_PDL1 33_TrkA 24_SpCas9; do
    bash slurm_utils/launch_protein_binder_search_from_local_conda.sh $target
done

High-Quality Protein Binder Campaign

complexa design configs/search_binder_local_pipeline.yaml \
    ++run_name=high_quality_campaign \
    ++generation.search.algorithm=beam-search \
    ++generation.search.beam_search.beam_width=8 \
    ++metric.binder_folding_method=rf3_latest \
    ++metric.num_redesign_seqs=16

To also enable TMOL rewards during generation, uncomment the tmol sub-model in binder_generate.yaml or add it via CLI:

++generation.reward_model.reward_models.tmol._target_=proteinfoundation.rewards.tmol_reward.TmolRewardModel \
++generation.reward_model.reward_models.tmol.enable_hbond=true \
++generation.reward_model.weights.tmol=0.5

Custom Success Criteria

# Protein binder with stricter thresholds
complexa analyze configs/search_binder_local_pipeline.yaml \
    ++aggregation.success_thresholds.i_pAE.threshold=5.0 \
    ++aggregation.success_thresholds.scRMSD.threshold=1.0

# AME motif binder with custom thresholds
complexa analyze configs/search_ame_local_pipeline.yaml \
    ++aggregation.motif_binder_success_thresholds.motif_rmsd_pred.threshold=1.0 \
    ++aggregation.motif_binder_success_thresholds.motif_seq_recovery.threshold=0.8

Custom Filter Settings

complexa filter configs/search_binder_local_pipeline.yaml \
    ++generation.filter.filter_samples_limit=200 \
    ++generation.filter.reward_threshold=0.3

Requirements and compatibility

Written for: Claude Code

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: Declares allowed tools, Names Claude Code tools, Needs Python

The author says: complexa CLI installed (pip install -e .); CUDA GPU; AF2_DIR (colabdesign) or RF3_CKPT_PATH+RF3_EXEC_PATH (rf3_latest); ESMFold weights for monomer paths

Security

What our scanner noticed· Medium risk

Large base64-encoded blobs
Instructions that use the network
Scripts that your agent may run

This skill includes scripts that your agent may run. Read them before you use it.

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

Published by

NVIDIA

Publisher

NVIDIA (Official)

Source

NVIDIA/skills · skills/bionemo-complexa-evaluate-pdbs · commit fce3cca

Licence

Apache License 2.0 (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE-APACHE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-08

AutoGineer is not affiliated with or endorsed by NVIDIA.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download complexa-evaluate-pdbs.zip

From the author

AutoGineer summary

What it does

When to use it

Advantages

Usage examples

Install

Documentation by NVIDIA

Complexa Evaluate-PDBs Skill

What this skill enables

Step 1: Pre-flight

Step 2: Identify the design type

Default — protein binder

Extensions — pick the matching config

Step 3: Gather inputs (AskUserQuestion)

Step 4: Run evaluate → analyze

Direct module invocation (debug fallback)

Step 5: Parse results

Step 6: Emit manifest

Most common overrides

Hardware

Troubleshooting

Reference

Files

references/INFERENCE.md

Inference and Search Guide

Table of Contents

Pipeline Overview

Design Pipeline Types

Protein Binder Pipeline

Ligand Binder Pipeline

AME Pipeline (Motif + Ligand Binder)

Motif Binder Evaluation (Standalone)

Configuration Architecture

Running Locally

Quick Start

Validate Before Running

Individual Stages

CLI Options

Common Overrides

Quick Local Test

SLURM Cluster Execution

Setup

Launch Scripts

What the Launcher Does

Job Parallelism

Defining Custom Targets

Protein Targets

Ligand Targets

Target Input Format

Hotspot Residues

Troubleshooting

Import Errors

Missing Model Weights

Config Validation Failures

RF3 Environment Variables

SLURM Job Failures

Memory Issues

Examples

Production Beam Search (Protein Binder)

Multiple Targets on SLURM

High-Quality Protein Binder Campaign

Custom Success Criteria

Custom Filter Settings

Requirements and compatibility

Security

Attribution and licence

Related skills

Astropy

Pymatgen

Opentrons Integration

Relion

Qutip

Simpy

Download ZIP