> ## Documentation Index
> Fetch the complete documentation index at: https://proto.evodesign.org/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# RFdiffusion3 + MPNN Binder Design
> De novo binder design: RFdiffusion3 backbones + ProteinMPNN/LigandMPNN sequences
**License:** This generator can use multiple tools, each under its own license. See the **Tools Used** tab and each tool's page for license details.
This generator is open source. Any third-party models, product names, or trademarks referenced are the property of their respective owners, and Proto is not affiliated with them.
De-novo protein binder generator chaining RFdiffusion3 and an inverse-folding model.
For each `sample()` call the generator diffuses binder backbones docked to a fixed
target (RFdiffusion3), then designs each backbone's binder-chain sequence with the
selected inverse-folding model (`proteinmpnn` or `ligandmpnn`) while keeping the
target chains fixed as structural context. With `ligandmpnn` the binder conditions on
the target's ligand/nucleotide/metal atoms, so the target may be a protein, DNA, or RNA
chain (with ligand/metal cofactors as context). The designed binder sequence is written
to `proposal.sequence` and the RFdiffusion3 target+binder complex to
`proposal.structure` (its binder chain carries RFdiffusion3's co-designed sequence, so
downstream structure-prediction constraints should re-fold `proposal.sequence`).
The binder length is the assigned segment's length. The generator fills a length-only
segment, so its category is `"mutation"` despite being a de-novo designer (same
convention as `RandomProteinGenerator`).
## API Reference
Configuration object for RFdiffusionMPNNBinderGenerator.
Top-level fields describe *what* binder to design (the target, its chains, the
epitope hotspots, and which inverse-folding model designs the sequence); the
per-tool knobs live in nested `rfdiffusion3_config` and an inverse-folding config
(`proteinmpnn_config` or `ligandmpnn_config`), matching how constraints nest
tool configs (e.g. `esmfold_config`). Only the config matching `inverse_folding`
is used; it defaults to its tool default when omitted. The binder length is taken
from the assigned segment's length, not from this config.
The generator injects the fields it owns at sample time and respects everything else:
on `rfdiffusion3_config` it sets `n_batches` (to produce enough backbones for the
proposal count) and `seed`; on the inverse-folding config it sets `seed` and reads
`num_sequences_per_structure` as the number of sequences designed per backbone.
Target to bind (file path, PDB/CIF content, or Structure); may include DNA/RNA/ligand chains.
Target chain IDs kept fixed; the binder is emitted after these chains.
Target hotspot residues as '\\' (e.g. \['A37', 'A39']).
Sequence-design model: 'proteinmpnn' (protein only) or 'ligandmpnn' (ligand/DNA/RNA/metal-aware).
Options: `proteinmpnn`, `ligandmpnn`
Advanced RFdiffusion3 backbone-generation configuration.
Advanced ProteinMPNN settings; used when inverse\_folding='proteinmpnn'.
Advanced LigandMPNN settings; used when inverse\_folding='ligandmpnn'.
## Usage
Build a two-segment binder program: a length-only `binder` (designed) plus a fixed
`target` segment derived from the same structure, so a scoring constraint can fold
the complex via `inputs=[binder, target]`. The generator is assigned only to the
binder; the target reaches it through config. See
`examples/scripts/binder_design_rfdiffusion_mpnn.py` for the full program.
```python python icon="python" theme={null}
>>> from proto_tools import Structure
>>> from proto_language.core import Construct, Segment
>>> from proto_language.generator import (
... RFdiffusionMPNNBinderGenerator,
... RFdiffusionMPNNBinderGeneratorConfig,
... )
>>> target_structure = Structure.from_file("target.pdb")
>>> target_seq = target_structure.get_chain_sequence("A", remove_non_standard=True)
>>> binder = Segment(length=80, sequence_type="protein", label="binder")
>>> target = Segment(sequence=target_seq, sequence_type="protein", label="target")
>>> construct = Construct([binder, target]) # target is fixed: no generator
>>> gen = RFdiffusionMPNNBinderGenerator(
... RFdiffusionMPNNBinderGeneratorConfig(
... target_structure=target_structure, target_chains=["A"], hotspots=["A37"]
... )
... )
>>> gen.assign(binder) # generator touches only the binder
>>> gen.sample() # fills num_proposals binders; a constraint scores [binder, target]
```
## Metadata
| Property | Value |
| ------------------------ | -------------------------------- |
| Key | `rfdiffusion-mpnn-binder` |
| Class | `RFdiffusionMPNNBinderGenerator` |
| Category | `mutation` |
| Input Type | `starting_sequence` |
| Uses GPU | `True` |
| Supported Sequence Types | `protein` |
| Allows Empty Start | `True` |
evo-design/proto-language/proto\_language/generator/rfdiffusion\_mpnn\_binder\_generator.py
dguo8412