rc-foundry 0.1.1__tar.gz → 0.1.2__tar.gz

rc_foundry-0.1.2/.git

@@ -0,0 +1 @@
+gitdir: /home/ncorley/projects/modelhub/modelhub.git/worktrees/modelworks

{rc_foundry-0.1.1 → rc_foundry-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rc-foundry
-Version: 0.1.1
+Version: 0.1.2
 Summary: Shared utilities and training infrastructure for biomolecular structure prediction models.
 Author-email: Institute for Protein Design <contact@ipd.uw.edu>
 License: BSD 3-Clause License
@@ -95,8 +95,6 @@ Description-Content-Type: text/markdown
 
 Foundry provides tooling and infrastructure for using and training all classes of models for protein design, including design (RFD3), inverse folding (ProteinMPNN) and protein folding (RF3).
 
-All models within Foundry rely on [AtomWorks](https://github.com/RosettaCommons/atomworks) - a unified framework for manipulating and processing biomolecular structures - for both training and inference. 
-
 ## Getting Started
 ### Quickstart guide
 **Installation**
@@ -109,14 +107,14 @@ pip install rc-foundry[all]
 ```
 foundry install all --checkpoint_dir <path/to/ckpt/dir>
 ```
-This will download all the models supported (including multiple checkpoints of RF3) but as a beginner you can start with:
+This will download all the models supported (including multiple checkpoints of rf3) but as a beginner you can start with:
 ```
 foundry install rfd3 ligandmpnn rf3 --checkpoint_dir  <path/to/ckpt/dir>
 ```
 
 >*See `examples/all.ipynb` for how to run each model in a notebook.*
 
-### RFdiffusion3 (RFD3)
+### RFdiffusion3
 
 [RFdiffusion3](https://www.biorxiv.org/content/10.1101/2025.09.18.676967v2) is an all-atom generative model capable of designing protein structures under complex constraints. 
 
@@ -131,8 +129,7 @@ foundry install rfd3 ligandmpnn rf3 --checkpoint_dir  <path/to/ckpt/dir>
 
 > *See [models/mpnn/README.md](models/mpnn/README.md) for complete documentation.*
 
-
-### RosettaFold3 (RF3)
+### RosettaFold3
 
 [RF3](https://doi.org/10.1101/2025.08.14.670328) is a structure prediction neural network that narrows the gap between closed-source AF-3 and open-source alternatives.
 

{rc_foundry-0.1.1 → rc_foundry-0.1.2}/README.md

@@ -2,8 +2,6 @@
 
 Foundry provides tooling and infrastructure for using and training all classes of models for protein design, including design (RFD3), inverse folding (ProteinMPNN) and protein folding (RF3).
 
-All models within Foundry rely on [AtomWorks](https://github.com/RosettaCommons/atomworks) - a unified framework for manipulating and processing biomolecular structures - for both training and inference. 
-
 ## Getting Started
 ### Quickstart guide
 **Installation**
@@ -16,14 +14,14 @@ pip install rc-foundry[all]
 ```
 foundry install all --checkpoint_dir <path/to/ckpt/dir>
 ```
-This will download all the models supported (including multiple checkpoints of RF3) but as a beginner you can start with:
+This will download all the models supported (including multiple checkpoints of rf3) but as a beginner you can start with:
 ```
 foundry install rfd3 ligandmpnn rf3 --checkpoint_dir  <path/to/ckpt/dir>
 ```
 
 >*See `examples/all.ipynb` for how to run each model in a notebook.*
 
-### RFdiffusion3 (RFD3)
+### RFdiffusion3
 
 [RFdiffusion3](https://www.biorxiv.org/content/10.1101/2025.09.18.676967v2) is an all-atom generative model capable of designing protein structures under complex constraints. 
 
@@ -38,8 +36,7 @@ foundry install rfd3 ligandmpnn rf3 --checkpoint_dir  <path/to/ckpt/dir>
 
 > *See [models/mpnn/README.md](models/mpnn/README.md) for complete documentation.*
 
-
-### RosettaFold3 (RF3)
+### RosettaFold3
 
 [RF3](https://doi.org/10.1101/2025.08.14.670328) is a structure prediction neural network that narrows the gap between closed-source AF-3 and open-source alternatives.
 

rc_foundry-0.1.1/models/rfd3/docs/na_binder_design.json → rc_foundry-0.1.2/docs/releases/rfd3/examples/na_tutorial.json

@@ -1,10 +1,26 @@
-{
-    "dsDNA_basic": { 
+{   
+    "dsDNA_basic": {
         "input": "./input_pdbs/1bna.pdb",
         "contig": "A1-10,/0,B15-24,/0,120-130",
         "length": "140-150",
         "ori_token": [24,20,10]
     },
+    "dsDNA_complex": {
+        "input": "./input_pdbs/2r5z.pdb",
+        "contig": "C5-18,/0,D24-37,/0,40-50,A146-154,80-90",
+        "length": "147-167",
+        "unindex": "/0,/0,B251-B255",
+        "select_fixed_atoms": {
+            "C9-14":"ALL",
+            "D28-33":"ALL",
+            "C5-8,C15-18": "",
+            "D24-27,D34-37": ""
+        },
+        "ori_token":[25,35,20],
+        "select_hbond_acceptor": {"C16":"N7,O6", "D31-32":"N7", "D28-30":"OP1,OP2,O3',O5'"},
+        "select_hbond_donor": {"D31-32":"N6"}
+
+    },    
     "ssDNA_basic": {
         "input": "./input_pdbs/5o4d.pdb",
         "contig": "A1-23,/0,120-130",
@@ -22,21 +38,5 @@
         "contig": "A1-15,/0,120-130",
         "length": "135-145",
         "ori_token": [15,2,-4]
-    },
-    "dsDNA_complex": {
-        "input": "./input_pdbs/2r5z.pdb",
-        "contig": "C5-18,/0,D24-37,/0,40-50,A146-154,80-90",
-        "length": "147-167",
-        "unindex": "/0,/0,B251-B255",
-        "select_fixed_atoms": {
-            "C9-14":"ALL",
-            "D28-33":"ALL",
-            "C5-8,C15-18": "",
-            "D24-27,D34-37": ""
-        },
-        "ori_token":[25,35,20],
-        "select_hbond_acceptor": {"C16":"N7,O6", "D31-32":"N7", "D28-30":"OP1,OP2,O3',O5'"},
-        "select_hbond_donor": {"D31-32":"N6"}
-
     }
 }

{rc_foundry-0.1.1/models/rfd3/docs → rc_foundry-0.1.2/docs/releases/rfd3/examples}/run_inf_tutorial.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 
-foundry=../../../
+foundry=../../../../
 
 export PYTHONPATH="$foundry/src:$foundry/models/rfd3/src/"
 
@@ -8,7 +8,7 @@ export PYTHONPATH="$foundry/src:$foundry/models/rfd3/src/"
 outdir=./na_tutorial_outputs/
 rm $outdir/*
 ckpt_path=rfd3_foundry_2025_12_01.ckpt
-uv run python $foundry/models/rfd3/src/rfd3/run_inference.py ckpt_path=$ckpt_path out_dir=$outdir inputs=./na_binder_design.json n_batches=2 diffusion_batch_size=3 cleanup_virtual_atoms=True
+uv run python $foundry/models/rfd3/src/rfd3/run_inference.py ckpt_path=$ckpt_path out_dir=$outdir inputs=./na_tutorial.json n_batches=2 diffusion_batch_size=3 cleanup_virtual_atoms=True
 
 #some cleanup
 rm *.hb2

rc_foundry-0.1.2/examples/all_colab.ipynb

@@ -0,0 +1,462 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "colab-header"
+   },
+   "source": "# Example: End-To-End *De Novo* Protein Design Pipeline\n\n## Overview\n\nThis notebook demonstrates an end-to-end protein design workflow using three deep learning networks from the Institute for Protein Design:\n\n| Step | Model | Purpose |\n|------|-------|---------|\n| 1. **Backbone Generation** | RFD3 | Generate novel protein backbones via diffusion |\n| 2. **Sequence Design** | MPNN | Design amino acid sequences for the generated backbone |\n| 3. **Structure Validation** | RF3 | Predict the structure from designed sequence to validate designability |\n\nAll models are unified through [Foundry](https://github.com/RosettaCommons/foundry) and [AtomWorks](https://github.com/RosettaCommons/atomworks), relying on Biotite `AtomArray` objects for both inference and training.\n\n### Pipeline Flow\n```\nRFD3 (backbone) → MPNN (sequence) → RF3 (validation) → RMSD comparison\n```\n\n---"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "setup-instructions"
+   },
+   "source": [
+    "## ⚠️ Setup Instructions\n",
+    "\n",
+    "1. **Enable GPU**: Go to `Runtime` → `Change runtime type` → Select **T4 GPU** (or A100 for faster inference)\n",
+    "2. **Run the installation cell below** (takes ~3-5 minutes)\n",
+    "3. **Restart runtime** when prompted after installation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "install-deps"
+   },
+   "outputs": [],
+   "source": "# Install uv and create a clean environment\n!pip install uv -q\n!uv venv venv --python 3.12\n\n# Install rc-foundry\n!uv pip install rc-foundry[all] --python venv/bin/python\n\n# Add venv to path so imports work\nimport sys\nsys.path.insert(0, 'venv/lib/python3.12/site-packages')\n\n# Download model checkpoints\n!venv/bin/foundry install rfd3 ligandmpnn rf3"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "verify-gpu"
+   },
+   "outputs": [],
+   "source": [
+    "# Verify GPU is available\n",
+    "import torch\n",
+    "print(f\"PyTorch version: {torch.__version__}\")\n",
+    "print(f\"CUDA available: {torch.cuda.is_available()}\")\n",
+    "if torch.cuda.is_available():\n",
+    "    print(f\"GPU: {torch.cuda.get_device_name(0)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "819e8193"
+   },
+   "outputs": [],
+   "source": [
+    "# Shared utilities for visualization (from AtomWorks)\n",
+    "from atomworks.io.utils.visualize import view"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "a7tw5gds8p"
+   },
+   "source": [
+    "---\n",
+    "\n",
+    "## Section 1: Backbone Generation with RFD3\n",
+    "\n",
+    "RFdiffusion3 (RFD3) generates *de novo* all-atom proteins that meet specific conditioning requirements.\n",
+    "\n",
+    "**Parameters Used** *(many more are available for more complex protein design tasks)*:\n",
+    "- `length`: Target protein length in residues\n",
+    "- `diffusion_batch_size`: Number of structures to generate per batch\n",
+    "- `n_batches`: Number of batches to run\n",
+    "\n",
+    "**Outputs:** Dictionary of `RFD3Output` objects."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "d16cb95b-3f4c-4167-952b-278bdb561bf7"
+   },
+   "outputs": [],
+   "source": [
+    "from lightning.fabric import seed_everything\n",
+    "from rfd3.engine import RFD3InferenceConfig, RFD3InferenceEngine\n",
+    "\n",
+    "# Set seed for reproducibility\n",
+    "seed_everything(0)\n",
+    "\n",
+    "# Configure RFD3 inference\n",
+    "config = RFD3InferenceConfig(\n",
+    "    specification={\n",
+    "        'length': 15,  # Generate 80-residue proteins\n",
+    "    },\n",
+    "    diffusion_batch_size=2,  # Generate 2 structures per batch\n",
+    ")\n",
+    "\n",
+    "# Initialize engine and run generation\n",
+    "model = RFD3InferenceEngine(**config)\n",
+    "outputs = model.run(\n",
+    "    inputs=None,      # None for unconditional generation\n",
+    "    out_dir=None,     # None to return in memory (no file output)\n",
+    "    n_batches=1,      # Generate 1 batch\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "86adad90"
+   },
+   "outputs": [],
+   "source": [
+    "# View generated example IDs (one key per generated structure)\n",
+    "outputs.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "35253ef3-2ce1-4dca-958a-63b359b70d73"
+   },
+   "outputs": [],
+   "source": [
+    "# Inspect RFD3 outputs and extract the generated backbone\n",
+    "for idx, data in outputs.items():\n",
+    "    print(f\"Batch {idx}: {len(data)} structure(s)\")\n",
+    "    print(f\"  Output type: {type(data[0]).__name__}\")\n",
+    "    print(f\"  AtomArray: {data[0].atom_array}\")\n",
+    "\n",
+    "# Extract the first generated backbone for downstream use\n",
+    "first_key = next(iter(outputs.keys()))\n",
+    "atom_array = outputs[first_key][0].atom_array\n",
+    "\n",
+    "# Visualize the generated backbone\n",
+    "view(atom_array)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "1cziwe2nb26h"
+   },
+   "source": [
+    "---\n",
+    "\n",
+    "## Section 2: Sequence Design with MPNN\n",
+    "\n",
+    "Protein and Ligand MPNN (Message Passing Neural Network) designs amino acid sequences that will fold into a target backbone structure.\n",
+    "\n",
+    "**Model Options:**\n",
+    "- `protein_mpnn`: Original ProteinMPNN for protein-only design\n",
+    "- `ligand_mpnn`: Extended model supporting ligand-aware design\n",
+    "\n",
+    "**Key Parameters:**\n",
+    "- `batch_size`: Number of sequences to generate per structure\n",
+    "- `remove_waters`: Whether to exclude water molecules from context"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "d07ae413"
+   },
+   "outputs": [],
+   "source": [
+    "from mpnn.inference_engines.mpnn import MPNNInferenceEngine\n",
+    "\n",
+    "# Configure MPNN inference engine\n",
+    "# See mpnn.utils.inference.MPNN_GLOBAL_INFERENCE_DEFAULTS for all options\n",
+    "engine_config = {\n",
+    "    \"model_type\": \"ligand_mpnn\",  # or \"protein_mpnn\" for vanilla ProteinMPNN\n",
+    "    \"is_legacy_weights\": True,    # Required for now for ligand_mpnn and protein_mpnn\n",
+    "    \"out_directory\": None,        # Return results in memory\n",
+    "    \"write_structures\": False,\n",
+    "    \"write_fasta\": False,\n",
+    "}\n",
+    "\n",
+    "# Configure per-input inference options\n",
+    "# See mpnn.utils.inference.MPNN_PER_INPUT_INFERENCE_DEFAULTS for all options\n",
+    "input_configs = [\n",
+    "    {\n",
+    "        \"batch_size\": 10,         # Generate 10 sequences per structure\n",
+    "        \"remove_waters\": True,\n",
+    "    }\n",
+    "]\n",
+    "\n",
+    "# Run sequence design on the RFD3-generated backbone\n",
+    "model = MPNNInferenceEngine(**engine_config)\n",
+    "mpnn_outputs = model.run(input_dicts=input_configs, atom_arrays=[atom_array])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "75f5e558-3323-4094-9cce-c5a19b54f4cf"
+   },
+   "outputs": [],
+   "source": [
+    "from biotite.structure import get_residue_starts\n",
+    "from biotite.sequence import ProteinSequence\n",
+    "\n",
+    "# Extract and display the designed sequences\n",
+    "print(f\"Generated {len(mpnn_outputs)} designed sequences:\\n\")\n",
+    "\n",
+    "for i, item in enumerate(mpnn_outputs):\n",
+    "    res_starts = get_residue_starts(item.atom_array)\n",
+    "    # Convert 3-letter codes to 1-letter using Biotite\n",
+    "    seq_1letter = ''.join(\n",
+    "        ProteinSequence.convert_letter_3to1(res_name)\n",
+    "        for res_name in item.atom_array.res_name[res_starts]\n",
+    "    )\n",
+    "    print(f\"Sequence {i+1}: {seq_1letter}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "te84j9ce9rn"
+   },
+   "source": [
+    "---\n",
+    "\n",
+    "## Section 3: Structure Prediction with RF3\n",
+    "\n",
+    "RF3 (RoseTTAFold 3) predicts protein structures from sequences. By re-folding the MPNN-designed sequence, we can validate whether the design is likely to adopt the intended backbone structure.\n",
+    "\n",
+    "**Outputs:** `RF3Output` objects containing:\n",
+    "- `atom_array`: Predicted structure as Biotite AtomArray\n",
+    "- `summary_confidences`: Overall confidence metrics (pLDDT, PAE, pTM, etc.)\n",
+    "- `confidences`: Per-atom/residue confidence scores\n",
+    "\n",
+    "**Confidence Metrics:**\n",
+    "| Metric | Description |\n",
+    "|--------|-------------|\n",
+    "| pLDDT | Per-residue confidence (0-1, higher is better) |\n",
+    "| PAE | Predicted Aligned Error (lower is better) |\n",
+    "| pTM | Predicted TM-score |\n",
+    "| ranking_score | Overall model quality score |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "d85eda46-4dca-4e92-8946-73b69a5536e3"
+   },
+   "outputs": [],
+   "source": [
+    "from rf3.inference_engines.rf3 import RF3InferenceEngine\n",
+    "from rf3.utils.inference import InferenceInput\n",
+    "\n",
+    "\n",
+    "# Initialize RF3 inference engine\n",
+    "inference_engine = RF3InferenceEngine(ckpt_path='rf3_preprint_921', verbose=False)\n",
+    "\n",
+    "# Create input from the MPNN-designed structure (first design)\n",
+    "# This re-folds the sequence to validate it adopts the intended structure\n",
+    "input_structure = InferenceInput.from_atom_array(atom_array, example_id=\"example_protein\")\n",
+    "rf3_outputs = inference_engine.run(inputs=input_structure)\n",
+    "\n",
+    "# Outputs: dict mapping example_id -> list[RF3Output] (multiple models per input)\n",
+    "print(f\"Output keys: {rf3_outputs.keys()}\")\n",
+    "print(f\"Number of models for 'example_protein': {len(rf3_outputs['example_protein'])}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "f7113c03"
+   },
+   "outputs": [],
+   "source": [
+    "# Extract the top-ranked prediction\n",
+    "rf3_output = rf3_outputs[\"example_protein\"][0]\n",
+    "\n",
+    "# Inspect RF3Output structure\n",
+    "print(f\"RF3Output contains:\")\n",
+    "print(f\"  - atom_array: {len(rf3_output.atom_array)} atoms\")\n",
+    "print(f\"  - summary_confidences: {list(rf3_output.summary_confidences.keys())}\")\n",
+    "print(f\"  - confidences: {list(rf3_output.confidences.keys()) if rf3_output.confidences else None}\")\n",
+    "\n",
+    "# Visualize the predicted structure\n",
+    "view(rf3_output.atom_array)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "6mqnovlrygo"
+   },
+   "outputs": [],
+   "source": [
+    "# Summary confidences: overall model quality metrics\n",
+    "summary = rf3_output.summary_confidences\n",
+    "\n",
+    "print(\"=== Summary Confidences ===\")\n",
+    "print(f\"  Overall pLDDT:    {summary['overall_plddt']:.3f}\")\n",
+    "print(f\"  Overall PAE:      {summary['overall_pae']:.2f} A\")\n",
+    "print(f\"  Overall PDE:      {summary['overall_pde']:.3f}\")\n",
+    "print(f\"  pTM:              {summary['ptm']:.3f}\")\n",
+    "print(f\"  ipTM:             {summary.get('iptm', 'N/A (single chain)')}\")\n",
+    "print(f\"  Ranking score:    {summary['ranking_score']:.3f}\")\n",
+    "print(f\"  Has clash:        {summary['has_clash']}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "g5gupirgy6"
+   },
+   "outputs": [],
+   "source": [
+    "# Detailed per-atom/residue confidences\n",
+    "conf = rf3_output.confidences\n",
+    "\n",
+    "print(\"=== Per-Atom/Residue Confidences ===\")\n",
+    "print(f\"  atom_plddts:      {len(conf['atom_plddts'])} values (one per atom)\")\n",
+    "print(f\"  atom_chain_ids:   {len(conf['atom_chain_ids'])} values\")\n",
+    "print(f\"  token_chain_ids:  {len(conf['token_chain_ids'])} values (one per residue)\")\n",
+    "print(f\"  token_res_ids:    {len(conf['token_res_ids'])} values\")\n",
+    "print(f\"  PAE matrix:       {len(conf['pae'])}x{len(conf['pae'][0])}\")\n",
+    "\n",
+    "# Preview first 10 atom pLDDT scores\n",
+    "import numpy as np\n",
+    "print(f\"\\nFirst 10 atom pLDDTs: {np.round(conf['atom_plddts'][:10], 2).tolist()}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "0epbqi91bv3n"
+   },
+   "source": [
+    "---\n",
+    "\n",
+    "## Section 4: Validation and Export\n",
+    "\n",
+    "The final step compares the RF3-predicted structure against the original RFD3-generated backbone. A low backbone RMSD indicates the designed sequence is likely to fold into the intended structure (high designability)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "238a0241"
+   },
+   "outputs": [],
+   "source": [
+    "from biotite.structure import rmsd, superimpose\n",
+    "from atomworks.constants import PROTEIN_BACKBONE_ATOM_NAMES\n",
+    "import numpy as np\n",
+    "\n",
+    "# Get structures for comparison\n",
+    "aa_generated = atom_array              # Original RFD3 backbone (from Section 1)\n",
+    "aa_refolded = rf3_output.atom_array    # RF3-predicted structure\n",
+    "\n",
+    "# Filter to backbone atoms (N, CA, C, O)\n",
+    "bb_generated = aa_generated[np.isin(aa_generated.atom_name, PROTEIN_BACKBONE_ATOM_NAMES)]\n",
+    "bb_refolded = aa_refolded[np.isin(aa_refolded.atom_name, PROTEIN_BACKBONE_ATOM_NAMES)]\n",
+    "\n",
+    "# Superimpose structures and calculate RMSD\n",
+    "bb_refolded_fitted, _ = superimpose(bb_generated, bb_refolded)\n",
+    "rmsd_value = rmsd(bb_generated, bb_refolded_fitted)\n",
+    "\n",
+    "print(f\"Backbone RMSD: {rmsd_value:.2f} A\")\n",
+    "print(f\"\\nInterpretation: {'Excellent' if rmsd_value < 1.0 else 'Good' if rmsd_value < 2.0 else 'Moderate'} designability\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "9070ead8"
+   },
+   "outputs": [],
+   "source": [
+    "from atomworks.io.utils.io_utils import to_cif_file\n",
+    "\n",
+    "# Export structures to CIF format for visualization in PyMOL/ChimeraX\n",
+    "to_cif_file(aa_generated, \"generated.cif\")\n",
+    "to_cif_file(aa_refolded, \"refolded.cif\")\n",
+    "\n",
+    "print(\"Exported structures:\")\n",
+    "print(\"  - generated.cif: Original RFD3 backbone\")\n",
+    "print(\"  - refolded.cif:  RF3-predicted structure\")\n",
+    "print(\"\\nDownload these files from the Files panel on the left (folder icon)\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "6fc67730"
+   },
+   "source": [
+    "### Superimposed Result\n",
+    "\n",
+    "The image below shows the generated backbone (RFD3) superimposed with the re-folded structure (RF3). Close alignment indicates successful design.\n",
+    "\n",
+    "![Superimposed Protein](https://raw.githubusercontent.com/RosettaCommons/modelworks/main/docs/_static/superimposed_80_residue_protein.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "optional-gdrive"
+   },
+   "source": [
+    "---\n",
+    "\n",
+    "## (Optional) Save to Google Drive\n",
+    "\n",
+    "Mount Google Drive to save outputs permanently:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "mount-gdrive"
+   },
+   "outputs": [],
+   "source": [
+    "# Uncomment to mount Google Drive and save outputs\n",
+    "# from google.colab import drive\n",
+    "# drive.mount('/content/drive')\n",
+    "\n",
+    "# # Save to Drive\n",
+    "# to_cif_file(aa_generated, \"/content/drive/MyDrive/generated.cif\")\n",
+    "# to_cif_file(aa_refolded, \"/content/drive/MyDrive/refolded.cif\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "gpuType": "T4",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

rc_foundry-0.1.2/models/mpnn/README.md

@@ -0,0 +1,29 @@
+# ProteinMPNN and LigandMPNN
+
+> [!WARNING]
+> **Benchmarking**: Please use the old repositories of ProteinMPNN and LigandMPNN for model benchmarking/comparison until the API and public weights stabilize. We are in the process of validating that the re-implementation (both the retrained version and the old weight loading option) is as performant as the original models.
+
+> [!IMPORTANT]
+> **Issues**: Please provide feedback on any issues you encounter with the ProteinMPNN/LigandMPNN re-implementation. We are particularly interested in discrepancies between the original models and this re-implementation, issues with performance when loading the original weights from the old repositories, problems with inference hyperparameters/conditioning, and input/output bugs.
+
+> [!IMPORTANT]
+> **API Instability**: We are currently finalizing some cleanup work on the inference API and training code. Please expect the API (including input formats and outputs) to stabilize in the upcoming weeks. Thank you for your patience!
+
+> [!IMPORTANT]
+> **Training Code and New Weights**: We are working to release the dataframes used for retrianing the ProteinMPNN and LigandMPNN re-implementations. Also, we are finalizing the retraining runs and will release weights retrained within this repository shortly.
+
+ProteinMPNN enables protein sequence design given a fixed backbone structure of a protein. LigandMPNN extends this functionality to enable fixed-backbone sequence design of proteins in the context of ligands (i.e. small molecules, ions, DNA/RNA, etc.). This module represents a re-implementation of the original ProteinMPNN and LigandMPNN models within the modelforge/atomworks framework.
+
+For more information on the original models, please see:
+- [Robust deep learning–based protein sequence design using ProteinMPNN](https://doi.org/10.1126/science.add2187) | [ProteinMPNN Original Github](https://github.com/dauparas/ProteinMPNN)
+- [Atomic context-conditioned protein sequence design using LigandMPNN](https://doi.org/10.1038/s41592-025-02626-1) | [LigandMPNN Original Github](https://github.com/dauparas/LigandMPNN)
+
+This guide provides instructions on preparing inputs and running inference for ProteinMPNN/LigandMPNN, as well as training these models.
+
+## Inference
+
+> [!IMPORTANT] 
+> When using weights from the original ProteinMPNN/LigandMPNN repositories, please ensure to set `is_legacy_weights` to `True` when running inference.
+
+### Notes on Programmatic (Scripted) Inference
+- Currently, 'mpnn_bias' and 'mpnn_pair_bias' annotations cannot be saved to CIF files due to shape limitations. As a result, these annotations must be recreated (either directly with annotation on the atom array or via the input config dictionary) when reloading designed structures from CIF files.