# AlphaFold Multimer Sequence Preparation: Step-by-Step Guide

By the end of this guide you will be able to take two or more protein sequences, decide exactly which residues belong in each chain, build a correctly formatted multi-chain FASTA file, submit it to ColabFold or the AlphaFold Server, and judge whether the resulting complex model deserves your trust. You need a Unix-style shell, curl, Python 3, and either a local ColabFold installation with a GPU or a web browser for the AlphaFold Server. No prior scripting beyond basic file handling is required.

Sequence preparation is the least glamorous and most consequential stage of any AlphaFold tutorial on complex prediction. The prediction engine cannot fix a wrong construct. If you hand it a fragment that starts in the middle of a helix, or a chain with the wrong isoform, you get a confident-looking model of a protein that does not exist.

## What Sequence Preparation Means for AlphaFold Multimer

AlphaFold Multimer is the multi-chain extension of AlphaFold 2. It predicts the structure of protein complexes, meaning the conformations of individual chains and their relative orientations, from the amino acid sequences of each chain. Later versions of AlphaFold 3 extended this to [nucleic acids](/blog/guides/nucleic-acids) and small molecules, and independent platforms such as RoseTTAFold2NA and Chai-1 now cover similar territory [1].

Sequence preparation covers four decisions:

1. **Which residues go into each chain.** Full-length canonical sequence, a trimmed construct, a mature processed form, or an isoform.
2. **How many copies of each chain.** A heterodimer has two entries. A homotrimer needs three identical entries so the modeler knows the stoichiometry.
3. **What goes in the FASTA header.** The accession in the header is what the MSA machinery uses to find and pair homologous sequences, so a wrong header silently degrades the [multiple sequence alignment](/blog/guides/multiple-sequence-alignment) (MSA), the set of evolutionarily related sequences used to infer constraints.
4. **What format the file is in.** One FASTA entry per chain, headers on their own lines, sequences in single-letter amino acid code with no stops, spaces, or numbering.

Each of these decisions feeds directly into model accuracy. A systematic comparison of sequence-to-structure methods for antibody-antigen complexes found that AlphaFold Multimer was the strongest of six methods tested, yet absolute performance still left considerable room for improvement, and lower-quality Multimer models carried measurable structural biases [2]. Careful inputs do not guarantee a good complex model, but careless inputs reliably produce a bad one.

## Step-by-Step: Preparing Your Sequences

This walkthrough models the oxygen-carrying hemoglobin subunits alpha and beta as a heterodimer. The same workflow applies to any protein-protein complex. Every command is reproducible in a plain terminal.

### Step 1. Decide chain definitions before you touch a keyboard

For each chain, answer three questions.

**Full-length or construct?** Start from the canonical UniProt sequence. Trim only when you have a specific reason, such as a well-characterized soluble domain, and record the residue numbers you kept. Trimming is not neutral. The way the ipTM metric is formulated in AlphaFold 2 and 3 means that trimming full-length constructs to interacting domains changes ipTM even when the predicted interface itself is unchanged, and the direction of the change depends on how much disordered or accessory sequence each partner carries [3]. There is no single universally correct construct. There is only a construct you can defend and report.

**Does the biology include regions a naive domain boundary would miss?** Domain boundaries taken from annotations can be wrong in specific, consequential ways. In the mycolactone polyketide synthase acyl carrier proteins, constructs built on prior domain definitions produced one fragment that folded and another that failed to fold, until secondary-structure prediction revealed a previously undetected N-terminal helix, H0, that belongs to the domain and stabilizes it [4]. Before trimming, run a secondary-structure or disorder prediction and check that your chain endpoints sit in loops rather than inside helices or sheets.

**Does the interface depend on sequence length?** Sequence-level details can flip the predicted assembly. In histidine kinases, AlphaFold models correctly recover whether the dimer phosphorylates in cis or in trans, and the switch between mechanisms is determined by the lengths of the helices flanking the DHp loop, where very small sequence changes cause a mechanism switch [5]. If your construct boundaries cut near a region implicated in oligomerization, model both the full-length and trimmed versions and compare.

### Step 2. Fetch canonical sequences from UniProt

Use the UniProt REST API. Human hemoglobin alpha is P69905 and beta is P68827.

```bash
curl -s "https://rest.uniprot.org/uniprotkb/P69905.fasta" -o alpha.fasta
curl -s "https://rest.uniprotkb/uniprotkb/P68827.fasta" -o beta.fasta
```

The second command above contains a deliberate typo trap. The correct form is:

```bash
curl -s "https://rest.uniprot.org/uniprotkb/P68827.fasta" -o beta.fasta
```

Inspect the results:

```bash
cat alpha.fasta
```

Expected output:

```
>sp|P69905|HBA_HUMAN Hemoglobin subunit alpha OS=Homo sapiens OX=9606 GN=HBA1 PE=1 SV=2
VLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKK
VADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVH
ASLDKFLASVSTVLTSKYR
```

Note that this entry is 142 residues and lacks an initiator methionine, because it is the mature processed protein. Many UniProt entries differ from the mature biological form by a [signal peptide](/knowledge/molecular-biology/signal-peptide), propeptide, or initiator Met. Read the sequence annotation lines on the UniProt entry before deciding which form matches the complex you are studying.

### Step 3. Assemble the multi-chain FASTA

For ColabFold, each chain gets one entry. The first field of the header, before the first pipe character, should be the UniProt accession so ColabFold can find and pair MSAs. The last field is the chain identifier you choose.

Create `complex.fasta`:

```
>P69905|A
VLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR
>P68827|B
VHLTPEEKSAVTALWGKVNVDEVGGEALGRLLVVYPWTQRFFESFGDLSTPDAVMGNPKVKAHGKKVLGAFSDGLAHLDNLKGTFATLSELHCDKLHVDPENFRLLGNVLVCVLAHHFGKEFTPPVQAAYQKVVAGVANALAHKYH
```

Total input length for this heterodimer is 142 plus 147, which equals 289 residues. This number matters because the public AlphaFold Server applies overall length limits to submitted complexes, so adding up your residue counts before submission tells you whether the job fits or whether you need to trim to the interacting regions.

### Step 4. Validate the FASTA

Count residues per chain:

```bash
awk '/^>/{if(n)print name,n; name=$0; n=0; next}{n+=length($0)}END{print name,n}' complex.fasta
```

Expected output:

```
>P69905|A 142
>P68827|B 147
```

Check for characters outside the standard 20 amino acids. The letter X is tolerated by the pipeline but degrades the MSA, and asterisks from stop codons cause hard failures:

```bash
grep -v "^>" complex.fasta | grep -vE "^[ACDEFGHIKLMNPQRSTVWY]+$"
```

If this command prints nothing, every residue is a standard amino acid. If it prints lines, inspect them for `*`, `X`, `U` (selenocysteine), spaces, or digits from copied sequence-numbering. Replace `U` with `C` if the selenocysteine is not central to your question, and investigate any `X` stretches, which usually mean low-complexity or unresolved regions.

Finally, confirm that identical chains that are meant to be identical are byte-for-byte identical, and that chains that merely look similar are genuinely different sequences. A diff of two chain files that should be identical is cheaper than a wasted GPU run.

### Step 5. Set homomer copy number

![Worked calculation showing hemoglobin alpha at 142 residues and beta at 147 residues, giving 289 for the heterodimer and 578 for the heterotetramer.](/article-images/illustrations/alphafold-multimer-sequence-preparation-tetramer-residues.webp)

For a homomer, repeat the identical entry once per copy. For a hemoglobin-like heterotetramer of two alpha and two beta chains, the FASTA holds four entries:

```
>P69905|A
VLSPADKTN...
>P68827|B
VHLTPEEK...
>P69905|C
VLSPADKTN...
>P68827|D
VHLTPEEK...
```

The full tetramer is 2 times 142 plus 2 times 147, which equals 578 residues. ColabFold detects identical sequences and models them as multiple copies of the same chain, so the repeats carry the stoichiometry. Getting copy number wrong is one of the most common failures in alphafold multimer sequence preparation, because a homodimer modeled as a monomer can still return a high intra-chain score while telling you nothing about the interface.

### Step 6. Think about MSA depth and redundancy

The MSA is the evidence base for the whole prediction. Two practical concerns are depth and redundancy.

Deep, diverse MSAs improve single-chain fold accuracy, and for heteromers, paired MSAs that link homologous positions across chains improve interface accuracy. For well-studied model organisms, the default databases usually suffice. For proteins with sparse homologs, expect weak models and consider whether the complex is even predictable from sequence alone.

Redundancy matters when you build custom MSAs or pick representative sequences from a large family. Sequence clustering tools such as MMseqs2 and CD-HIT collapse redundant sequences into representative groups, and practical walkthroughs of these tools emphasize that clustering at a sensible identity threshold, commonly in the range of 50 to 90 percent depending on the application, prevents a single close relative from dominating the alignment [6]. If you are choosing which paralog or ortholog to model, clustering your candidate set first keeps the comparison fair.

## Running the Job: ColabFold, Local AlphaFold, and the AlphaFold Server

![Decision path asking whether the complex has DNA, RNA or ligands, then whether you need control over models and seeds, ending at a run route.](/article-images/illustrations/alphafold-multimer-sequence-preparation-which-run-route.webp)

You have three realistic routes.

**ColabFold** wraps AlphaFold 2 and the Multimer models in an accessible package, either through the hosted Colab notebook or a local `colabfold_batch` installation. For the pip installation described in the ColabFold documentation, run:

```bash
pip install "colabfold[alphafold-minus-jax]"
```

This installs the batch tool but not the genetic databases. Local runs need the MSA and parameter databases downloaded and a CUDA-capable GPU. Follow the database setup in the ColabFold documentation before your first production run.

Submit the complex:

```bash
colabfold_batch --model-type alphafold2_multimer_v3 --num-models 5 --num-recycle 3 complex.fasta out/
```

Expected console output ends with a ranked list, and the output directory contains files like:

```
out/complex_unrelaxed_rank_001_alphafold2_multimer_v3_model_1_seed_000.pdb
out/complex_relaxed_rank_001_alphafold2_multimer_v3_model_1_seed_000.pdb
out/complex_scores_rank_001_alphafold2_multimer_v3_model_1_seed_000.json
out/complex_paes_rank_001_alphafold2_multimer_v3_model_1_seed_000.png
```

The table below summarizes the options that matter most for complex prediction.

| Option | What it controls | Practical choice |
|, - |, - |, - |
| `-model-type` | Which network weights run | `alphafold2_multimer_v3` for the current Multimer model |
| `-num-models` | Number of model predictions | 5, the standard set used in benchmarking |
| `-num-recycle` | Recycling iterations per model | 3, the recommended default for Multimer |
| `-num-ensemble` | Number of MSA and template ensembles | 1 for speed, higher for final runs |
| `-msa-mode` | MSA construction method | Default MMseqs2 search unless you supply custom alignments |
| `-random-seed` | Random seed for reproducibility | Fix it when comparing variants across constructs |

**The AlphaFold Server** is the hosted web service from Google DeepMind for AlphaFold 3. You enter chains as text, specify copy counts, and can include nucleic acids, ions, and ligands alongside proteins. The server applies length limits to submissions, so the residue arithmetic from Step 4 tells you in advance whether a large complex will fit. The server is a sensible first pass, especially for complexes with DNA or ligands, but it gives less control over model count and seeds than a local run.

**Independent platforms** are worth knowing about rather than treating as afterthoughts. In a systematic study of competence protein ComP bound to DNA uptake sequences, researchers modeled the same protein-DNA systems with AlphaFold 3, RoseTTAFold2NA, and Chai-1, and found six distinct binding modes of which two were robustly reproduced across platforms and across ComP orthologs [1]. When a modeled contact survives three independent networks, your confidence in it should rise substantially.

## Reading the Output: ipTM, pLDDT, and PAE

Three numbers govern interpretation. Define each before use.

**pLDDT**, per-residue predicted local distance difference test, is a per-residue confidence score from 0 to 100, reported in the B-factor column of PDB output and as banded colors in viewers. It reflects local backbone accuracy.

**PAE**, predicted aligned error, is a matrix of expected positional errors between residue pairs. In complexes, the off-diagonal blocks between different chains encode interface confidence. A dark cross-chain block means the two chains are positioned relative to each other with confidence.

**ipTM**, interface predicted TM-score, summarizes cross-chain alignment quality into a single number from 0 to 1. AlphaFold Multimer ranks models with a weighted metric dominated by ipTM, so the top-ranked model is usually the best-interface model.

Extract the scores:

```bash
python3 - <<EOF
import json, glob
for f in sorted(glob.glob("out/*_scores_rank_*.json")):
    d = json.load(open(f))
    print(f.split("/")[-1], "ipTM", round(d["iptm"], 3), "pTM", round(d["ptm"], 3))
EOF
```

Example output:

```
complex_scores_rank_001_alphafold2_multimer_v3_model_1_seed_000.json ipTM 0.87 pTM 0.91
complex_scores_rank_002_alphafold2_multimer_v3_model_2_seed_000.json ipTM 0.84 pTM 0.90
```

Now the caveats, each of which changes how you act.

**ipTM is construct-dependent in a non-intuitive way.** Because ipTM scores whole chains mathematically, adding long disordered or irrelevant regions to one chain can raise its ipTM, while trimming those same regions can lower it, even though the modeled interface is unchanged. When both partners carry large disordered or accessory regions, the distortion runs in the opposite direction [3]. The practical consequence is that ipTM values are only comparable across runs with identical construct definitions. When you compare a wild-type and a mutant complex, use the same boundaries for both.

**pLDDT flags trouble but does not localize it well.** In a homology-controlled benchmark of AlphaFold Database models against experimental structures, residues below pLDDT 70 had roughly 3.7-fold enriched contact error compared with residues above 70, but pLDDT was only a weak discriminator of contact errors overall, with an area under the curve of 0.672, and low-pLDDT regions captured under half of all contact errors [7]. Treat low pLDDT as a prompt to inspect the PAE matrix, not as a list of residues to delete.

**Termini deserve special scrutiny.** In a broad AlphaFold 3 benchmark across viral, bacterial, and plant proteins, minor misfolding of N- and C-terminal segments was common, and it often did not affect the biological interpretation of the folded core [8]. Before interpreting a chain-terminus contact in a complex model, check whether that contact is an artifact of dangling terminal segments, visible as high PAE radiating from the terminus.

**Interface confidence is not interaction proof.** For antibody-antigen complexes, even the best-performing method in a six-method comparison, AlphaFold Multimer, produced a meaningful fraction of poor models, and the poor models showed systematic structural biases [2]. A high ipTM on an antibody-antigen pair is encouraging evidence, not a validated epitope.

## Practical Tips for Better Complexes

These alphafold multimer sequence preparation tips compress the experience of published Multimer studies into working habits.

**Check the AlphaFold Database before computing.** Individual full-length chains are already predicted for most cataloged proteins. The AlphaFoldDB Structure Extractor is a web server and API that bulk-downloads predicted structures from the AlphaFold Database using NCBI Taxonomy IDs, RefSeq accessions, locus tags, and UniProt or AlphaFold accessions, with output in PDB, mmCIF, bCIF, and PAE JSON formats plus an ID-mapping file [9]. Pulling the existing monomer models of both partners takes minutes and tells you which regions are expected to fold, which is exactly the information you need to justify construct boundaries.

**Use AFDB-scale search to place your protein in structural context.** Structural similarity searches across the AlphaFold Database, such as transitive-closure workflows built on DaliLite and Foldseek, can reveal that a chain in your complex has a distant structural relative with a known interaction mode [10]. A known interaction in a structural homolog is strong prior evidence for the interface you are modeling.

**Combine AlphaFold with classical sequence analysis.** Studies that extract real biological conclusions from AlphaFold models almost always pair the structures with sequence and genome-context analysis. The PolB2 mutasome work combined AlphaFold models with protein sequence analysis and genome context to characterize a heteropentameric complex featuring high modeling confidence, including an unexpected RadA-like oligomerization motif in the interaction surface [11]. A multimer model plus a conservation alignment of the interface is far more convincing than either alone.

**Model alternatives, not just your hypothesis.** In the histidine kinase study, AlphaFold models recovered both cis and trans dimerization mechanisms, and the mechanism traced to helix length differences that small sequence changes could flip [5]. If a few residues near the interface could plausibly vary, run both variants. If two oligomeric states are discussed in the literature, run both stoichiometries.

**Report your inputs.** A complex model is only reproducible if the reader knows the exact UniProt accessions, residue ranges, copy numbers, model type, and seed. Put these in your methods section as a line, not in a screenshot.

## Common Mistakes and Limitations

This section covers the alphafold multimer sequence preparation common mistakes that account for most failed or misleading complex runs.

1. **Trimming constructs arbitrarily.** Removing residues changes ipTM without changing the interface, in either direction depending on where the disorder sits [3]. Trim for a stated biological reason, verify boundaries against secondary structure [4], and never compare ipTM values across differently trimmed constructs.

2. **Using the wrong sequence form.** Precursor with signal peptide, mature chain, isoform, and species ortholog are four different inputs. Modeling the precursor when your experiment used the mature protein produces a model of something nobody measured. Always read the UniProt processing annotations.

3. **Confusing pLDDT with interface quality.** pLDDT is per-residue and local. A complex can have beautiful per-chain pLDDT and a garbage interface. Interface questions are answered by cross-chain PAE blocks and ipTM.

4. **Over-reading low pLDDT as a defect list.** Low pLDDT regions carry elevated but imperfectly predicted contact error, and they capture under half of all contact errors in a controlled benchmark [7]. Deleting every low-confidence region is not a quality upgrade, it is a different question.

5. **Ignoring terminal artifacts.** N- and C-terminal misfolding is a recurring failure mode in benchmarking [8]. An interface contact reported by a dangling terminus is a hypothesis to test, not a result.

6. **Wrong copy number.** Homomers need repeated identical entries. Heteromers need every distinct chain. Modeling a hemoglobin tetramer as an alpha-beta dimer is not an approximation, it is a different complex.

7. **Treating a confident model as experimental truth.** Cross-validation across AlphaFold 3, RoseTTAFold2NA, and Chai-1 in the ComP study showed that of six candidate binding modes, only two were robustly reproduced across platforms [1]. Single-platform, single-seed models of novel interfaces should be labeled as hypotheses.

8. **Expecting a complete biological mechanism from one model.** The most credible published uses of AlphaFold Multimer combine structural models with sequence analysis, genome context, and experimental anchors [11], [5]. A model is one line of evidence.

9. **Skipping redundancy control when selecting sequences.** If your study models many members of a protein family, clustering the family first keeps representatives non-redundant and comparisons interpretable [6].

10. **Ignoring what the field can and cannot do.** A six-method comparison of antibody-antigen prediction found that even the leading method left considerable room for improvement, with lower-quality models carrying detectable structural biases [2]. Plan experimental validation for any interface that matters.

## Frequently Asked Questions

### Do I need the full-length UniProt sequence for every chain?

No. Use the full canonical sequence as your default, but trim when you are studying defined interacting domains, when the complex exceeds server length limits, or when disordered tails are known to be irrelevant. Record the residue ranges you kept, and compare ipTM only between runs that use identical boundaries.

### How many copies of a chain do I enter for a homotrimer?

Three identical FASTA entries with the same accession in the header. The repeated entries tell the modeler the stoichiometry. Modeling one copy as a monomer gives you the fold but no interface information.

### What ipTM value indicates a reliable complex model?

There is no universal cutoff that separates true from false interactions. Read ipTM as graded evidence, inspect the cross-chain PAE block for the specific interface, and remember that ipTM is sensitive to construct length, so identical boundaries are required for fair comparisons.

### Why did my ipTM drop after I trimmed my constructs?

The ipTM formula scores whole chains, so removing disordered or accessory residues can lower ipTM even when the predicted interface is unchanged, and the effect can reverse depending on which partner carries the disorder. This is a known property of the metric, not evidence that your trimming damaged the model.

### Should I use ColabFold or the AlphaFold Server?

Use the AlphaFold Server for quick first passes and for complexes involving DNA, RNA, or ligands, and use local ColabFold when you need control over model count, seeds, MSA options, and reproducible batch runs. Many projects use both, the server to scout and ColabFold to compare constructs systematically.

### Can AlphaFold Multimer model DNA, RNA, or small molecules?

The AlphaFold 2 Multimer models are protein-only. AlphaFold 3 and independent tools such as RoseTTAFold2NA and Chai-1 extend prediction to nucleic acids and ligands, and comparative studies recommend running more than one platform when the interface matters.

### Should signal peptides be included in the sequence?

Generally no for secreted or membrane-processed proteins, because the mature chain is the biological unit and the signal peptide is cleaved. Include it only if the signal peptide itself is part of your question, and say so explicitly in your methods.

### How can I check whether my protein's structure is already predicted?

Search the AlphaFold Database, which holds predicted structures for large fractions of cataloged proteins. Bulk retrieval tools accept UniProt, RefSeq, taxonomy, and locus-tag identifiers and return PDB, mmCIF, or PAE files, which is faster than predicting monomers yourself and gives you a reference fold before you model the complex.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Do I need the full-length UniProt sequence for every chain?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "No. Use the full canonical sequence as your default, but trim when you are studying defined interacting domains, when the complex exceeds server length limits, or when disordered tails are known to be irrelevant. Record the residue ranges you kept, and compare ipTM only between runs that use identical boundaries."
      }
    },
    {
      "@type": "Question",
      "name": "How many copies of a chain do I enter for a homotrimer?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Three identical FASTA entries with the same accession in the header. The repeated entries tell the modeler the stoichiometry. Modeling one copy as a monomer gives you the fold but no interface information."
      }
    },
    {
      "@type": "Question",
      "name": "What ipTM value indicates a reliable complex model?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "There is no universal cutoff that separates true from false interactions. Read ipTM as graded evidence, inspect the cross-chain PAE block for the specific interface, and remember that ipTM is sensitive to construct length, so identical boundaries are required for fair comparisons."
      }
    },
    {
      "@type": "Question",
      "name": "Why did my ipTM drop after I trimmed my constructs?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "The ipTM formula scores whole chains, so removing disordered or accessory residues can lower ipTM even when the predicted interface is unchanged, and the effect can reverse depending on which partner carries the disorder. This is a known property of the metric, not evidence that your trimming damaged the model."
      }
    },
    {
      "@type": "Question",
      "name": "Should I use ColabFold or the AlphaFold Server?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Use the AlphaFold Server for quick first passes and for complexes involving DNA, RNA, or ligands, and use local ColabFold when you need control over model count, seeds, MSA options, and reproducible batch runs. Many projects use both, the server to scout and ColabFold to compare constructs systematically."
      }
    },
    {
      "@type": "Question",
      "name": "Can AlphaFold Multimer model DNA, RNA, or small molecules?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "The AlphaFold 2 Multimer models are protein-only. AlphaFold 3 and independent tools such as RoseTTAFold2NA and Chai-1 extend prediction to nucleic acids and ligands, and comparative studies recommend running more than one platform when the interface matters."
      }
    },
    {
      "@type": "Question",
      "name": "Should signal peptides be included in the sequence?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Generally no for secreted or membrane-processed proteins, because the mature chain is the biological unit and the signal peptide is cleaved. Include it only if the signal peptide itself is part of your question, and say so explicitly in your methods."
      }
    },
    {
      "@type": "Question",
      "name": "How can I check whether my protein's structure is already predicted?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Search the AlphaFold Database, which holds predicted structures for large fractions of cataloged proteins. Bulk retrieval tools accept UniProt, RefSeq, taxonomy, and locus-tag identifiers and return PDB, mmCIF, or PAE files, which is faster than predicting monomers yourself and gives you a reference fold before you model the complex."
      }
    }
  ]
}
</script>

## Sources

1. [Two different and robustly modeled DNA binding modes of Competence Protein ComP - systematic modeling with AlphaFold 3, RoseTTAFold2NA, Chai-1 and re-docking in HADDOCK](https://pubmed.ncbi.nlm.nih.gov/40338866/)
2. [A comparison of antibody-antigen complex sequence-to-structure prediction methods and their systematic biases](https://pubmed.ncbi.nlm.nih.gov/39167052/)
3. [Rēs ipSAE loquunt: What’s wrong with AlphaFold’s ipTM score and how to fix it](https://pubmed.ncbi.nlm.nih.gov/39990437/)
4. [Modular type I polyketide synthase acyl carrier protein domains share a common N-terminally extended fold](https://pubmed.ncbi.nlm.nih.gov/30787330/)
5. [Phosphorylation Mechanism Switching in Histidine Kinases Is a Tool for Fast Protein Evolution: Insights From AlphaFold Models](https://pubmed.ncbi.nlm.nih.gov/38884545/)
6. [How to cluster protein sequences: tools, tips and commands](https://doi.org/10.15406/MOJPB.2017.05.00174)
7. [Where Does AlphaFold Make Contact Errors? A Homology-Controlled Characterization of pLDDT, Contact Error, and the Limits of Contact Refinement](https://doi.org/10.1142/s0219720026500150)
8. [Benchmarking Google DeepMind’s AlphaFold 3 Performance for Protein 3D-Structure Prediction](https://doi.org/10.26565/2220-637x-2024-43-01)
9. [AlphaFold Database Structure Extractor: a web server and API to download AlphaFold structures using common protein accessions](https://pubmed.ncbi.nlm.nih.gov/41291409/)
10. [3-D substructure search by transitive closure in AlphaFold database](https://pubmed.ncbi.nlm.nih.gov/40400345/)
11. [Common themes in architecture and interactions of prokaryotic PolB2 and Pol V mutasomes inferred from in silico studies](https://pubmed.ncbi.nlm.nih.gov/39906160/)