Bio Structural Biology Modern Structure Prediction

Modern Structure Prediction

Predict protein structures using state-of-the-art machine learning models. This covers cloud APIs, local installations, and interpretation of results.

Model Comparison

*ColabFold can predict complexes with AlphaFold-Multimer.

ESMFold (Fastest Single-Chain)

Via ESM Atlas API

import requests

def predict_esmfold(sequence):
    '''Predict structure using ESMFold API'''
    url = 'https://api.esmatlas.com/foldSequence/v1/pdb/'
    response = requests.post(url, data=sequence, timeout=300)
    if response.status_code == 200:
        return response.text
    raise Exception(f'ESMFold failed: {response.status_code}')

sequence = 'MVLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHFDLSH'
pdb_text = predict_esmfold(sequence)
with open('predicted.pdb', 'w') as f:
    f.write(pdb_text)

Local ESMFold

import torch
import esm

def predict_esmfold_local(sequence, device='cuda'):
    '''Run ESMFold locally (requires ~16GB GPU memory)'''
    model = esm.pretrained.esmfold_v1()
    model = model.eval().to(device)

    with torch.no_grad():
        output = model.infer_pdb(sequence)
    return output

# Extract pLDDT from ESMFold output
def extract_esmfold_plddt(pdb_text):
    plddt = {}
    for line in pdb_text.split('\n'):
        if line.startswith('ATOM') and line[12:16].strip() == 'CA':
            resnum = int(line[22:26])
            bfactor = float(line[60:66])
            plddt[resnum] = bfactor
    return plddt

AlphaFold3 (Server)

AlphaFold3 predictions via the server at alphafoldserver.com.

Prepare Input JSON

import json

def create_af3_input(sequences, job_name='prediction'):
    '''Create AlphaFold3 server input JSON'''
    entities = []
    for i, seq in enumerate(sequences):
        entities.append({
            'type': 'protein',
            'sequence': seq,
            'count': 1
        })

    job = {
        'name': job_name,
        'modelSeeds': [1],
        'sequences': entities
    }
    return json.dumps(job, indent=2)

# Single protein
input_json = create_af3_input(['MVLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHFDLSH'])

# Protein complex
input_json = create_af3_input([
    'MVLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHFDLSH',
    'MGHFTEEDKATITSLWGKVNVEDAGGETLGRLLVVYPWTQRFFDSFGNLSS'
])

Process AF3 Results

import json
from Bio.PDB import PDBParser
import numpy as np

def analyze_af3_result(result_dir):
    '''Analyze AlphaFold3 prediction results'''
    # Load summary
    with open(f'{result_dir}/summary_confidences.json') as f:
        summary = json.load(f)

    # Extract confidence metrics
    iptm = summary.get('iptm', None)  # Interface pTM (complexes)
    ptm = summary.get('ptm', None)    # Predicted TM-score
    ranking = summary.get('ranking_score', None)

    print(f'pTM: {ptm:.3f}' if ptm else 'pTM: N/A')
    print(f'ipTM: {iptm:.3f}' if iptm else 'ipTM: N/A')

    return summary

AF3 Confidence Interpretation

Chai-1 (Local Open-Source)

Installation

pip install chai-lab

Basic Prediction

from chai_lab.chai1 import run_inference
import numpy as np
from pathlib import Path

def predict_chai1(fasta_path, output_dir='chai_output'):
    '''Run Chai-1 structure prediction'''
    Path(output_dir).mkdir(exist_ok=True)

    candidates = run_inference(
        fasta_file=Path(fasta_path),
        output_dir=Path(output_dir),
        num_trunk_recycles=3,        # 3: Standard. Use 5+ for difficult targets.
        num_diffn_timesteps=200,     # 200: Standard. 500 for higher quality.
        seed=42,
        device='cuda:0'
    )
    return candidates

# Candidates are sorted by confidence
# candidates.cif files contain predicted structures

Chai-1 with Ligands

# Chai-1 supports protein-ligand complexes
# Include ligand SMILES in input FASTA with special format

def create_chai_fasta_with_ligand(protein_seq, ligand_smiles, output_file):
    '''Create Chai-1 input with protein and ligand'''
    with open(output_file, 'w') as f:
        f.write('>protein|chain_A\n')
        f.write(f'{protein_seq}\n')
        f.write('>ligand|chain_B\n')
        f.write(f'{ligand_smiles}\n')

Boltz-1 (Open-Source Complex Prediction)

Installation

pip install boltz

Basic Prediction

from boltz import Boltz1

def predict_boltz1(sequences, output_dir='boltz_output'):
    '''Run Boltz-1 structure prediction'''
    model = Boltz1()

    result = model.predict(
        sequences=sequences,
        output_dir=output_dir,
        recycling_steps=3,   # 3: Standard. Increase for difficult targets.
        sampling_steps=200   # 200: Standard. 500 for publication quality.
    )
    return result

Boltz-1 for Complexes

# Boltz-1 handles heteromeric complexes
def predict_complex_boltz(chain_sequences):
    '''Predict protein complex with Boltz-1'''
    model = Boltz1()

    result = model.predict(
        sequences=chain_sequences,  # List of sequences for each chain
        output_dir='complex_output'
    )

    # Extract interface metrics
    return result

ColabFold (AlphaFold2 + MMseqs2)

Command Line

# Install ColabFold
pip install colabfold

# Run prediction
colabfold_batch input.fasta output_dir/

# With custom templates
colabfold_batch input.fasta output_dir/ --templates

# For complexes (use : to separate chains)
# Create FASTA like: >complex\nSEQUENCE1:SEQUENCE2

Python API

from colabfold.batch import run_colabfold

def predict_colabfold(fasta_file, output_dir, use_templates=False):
    '''Run ColabFold prediction'''
    run_colabfold(
        input_path=fasta_file,
        result_dir=output_dir,
        use_templates=use_templates,
        num_models=5,           # 5: Standard. Use 1 for quick predictions.
        num_recycles=3,         # 3: Standard. Increase for multimers.
        model_order=[1,2,3,4,5]
    )

Comparing Predictions

from Bio.PDB import PDBParser, Superimposer
import numpy as np

def compare_predictions(pdb_files, labels=None):
    '''Compare multiple structure predictions'''
    parser = PDBParser(QUIET=True)
    structures = [parser.get_structure(f'model_{i}', f) for i, f in enumerate(pdb_files)]

    # Extract CA atoms from first chain
    def get_ca_atoms(struct):
        return [r['CA'] for r in struct[0].get_residues() if 'CA' in r]

    all_atoms = [get_ca_atoms(s) for s in structures]

    # Pairwise RMSD
    n = len(structures)
    rmsd_matrix = np.zeros((n, n))

    for i in range(n):
        for j in range(i+1, n):
            min_len = min(len(all_atoms[i]), len(all_atoms[j]))
            super_imposer = Superimposer()
            super_imposer.set_atoms(all_atoms[i][:min_len], all_atoms[j][:min_len])
            rmsd_matrix[i,j] = rmsd_matrix[j,i] = super_imposer.rms

    return rmsd_matrix

# Compare ESMFold vs AlphaFold3 vs Chai-1
rmsd = compare_predictions(['esmfold.pdb', 'af3.pdb', 'chai1.pdb'])
print('RMSD matrix:')
print(rmsd)

When to Use Each Model

Memory Requirements

Related Skills

• alphafold-predictions - Download pre-computed AlphaFold structures
• structure-io - Parse and write structure files
• geometric-analysis - RMSD, superimposition, distance calculations
• structure-navigation - Navigate predicted structure hierarchy

Modern Structure Prediction

Overview

Predict protein structures using state-of-the-art ML models including ESMFold, AlphaFold3, Chai-1, and Boltz-1. These tools enable rapid structure prediction for single proteins and complexes, including protein-ligand interactions.

Prerequisites

# ESMFold (local)
pip install fair-esm

# Chai-1
pip install chai-lab

# Boltz-1
pip install boltz

# ColabFold
pip install colabfold

# For API-only usage, only requests is needed
pip install requests

Quick Start

Tell your AI agent what you want to do:

• "Predict the structure of this protein sequence using ESMFold"
• "Run AlphaFold3 on my protein complex"
• "Compare predictions from multiple structure prediction methods"
• "Predict a protein-ligand complex with Chai-1"

Example Prompts

Single Protein Prediction

"Predict the structure of this protein sequence using the fastest method"

"Run ESMFold on my sequence and analyze the confidence scores"

"Get an AlphaFold3 prediction for this protein"

Complex Prediction

"Predict the structure of this protein-protein complex"

"Run Boltz-1 on my heterodimer sequences"

"Model my protein binding to this small molecule ligand"

Comparison and Validation

"Compare ESMFold, AlphaFold3, and Chai-1 predictions for this sequence"

"Calculate RMSD between different structure predictions"

"Which regions have high confidence across all prediction methods?"

Batch Processing

"Predict structures for all sequences in this FASTA file"

"Run ESMFold on my list of protein sequences"

What the Agent Will Do

1. Determine the best prediction method based on your needs (speed, accuracy, complex support) 2. Prepare the input sequence(s) in the appropriate format 3. Run the prediction via API or local installation 4. Extract and interpret confidence metrics (pLDDT, pTM, PAE) 5. Save the predicted structure in PDB or mmCIF format 6. Provide guidance on interpreting low-confidence regions

Tips

• ESMFold is fastest for single chains and doesn't require MSA
• AlphaFold3 server is best for complexes but has usage limits
• Chai-1 and Boltz-1 are open-source alternatives for complex prediction
• pLDDT > 70 indicates confident predictions; < 50 suggests disorder
• For complexes, check ipTM (interface pTM) to assess binding prediction quality
• Compare multiple methods for critical applications
• Low-confidence regions may indicate intrinsically disordered regions