Biotite¶

A structure analysis toolkit providing PDB chain extraction and C-alpha RMSD computation as API endpoints, enabling automated structure comparison and chain-level analysis in multi-model workflows.

License: BSD-3-Clause · Molecules: protein, complex · Tasks: utility, feature_extraction

Actions: generate, predict · Variants: 1

At a glance¶

Use it when

You need to evaluate predicted protein structures against experimental references by computing C-alpha RMSD after optimal superimposition
You are benchmarking multiple structure prediction methods (Chai-1, ESMFold, AF2 NIM) on the same target and need standardized RMSD comparisons
You need to extract individual chains from multi-chain complex predictions for downstream analysis with sequence or structure-based models
You are building an automated structure prediction evaluation pipeline that runs without manual intervention
You need to compare conformational changes between different states of the same protein (apo vs holo, wild-type vs mutant)
You want to extract chain sequences and coordinates from complex PDB files without manual PDB parsing

Strengths

Provides two essential structural analysis utilities (RMSD computation and chain extraction) as API-accessible endpoints, enabling fully automated structure comparison pipelines without local software installation
C-alpha RMSD computation with optimal Kabsch superimposition is the gold-standard metric for quantifying structural similarity between predicted and experimental protein structures
Multi-chain complex support for both chain extraction and paired-chain RMSD, enabling analysis of protein-protein complexes from structure prediction tools (Chai-1, RF3)
Used in 6 workflow protocols in this catalog, making it one of the most-integrated utility tools for structure prediction evaluation and downstream analysis
CPU-only operation with moderate resources (2 CPUs, 8 GB RAM) -- no GPU required for structural analysis, keeping costs low
Chain extraction returns both amino acid sequence and PDB coordinate data, enabling seamless handoff to sequence-based models (ESM2) and structure-based models (ThermoMPNN)
BSD-3-Clause license permits unrestricted use in academic and commercial settings

Limitations

Limited to C-alpha RMSD -- does not compute all-atom RMSD, side-chain RMSD, or GDT-TS scores that may be needed for comprehensive structure evaluation
No visualization capabilities -- returns numerical RMSD values and PDB text, but cannot generate molecular graphics or structure overlays
Protein-specific -- nucleic acid sequences are not extracted (only amino acid mapping), and small molecule ligands are ignored in RMSD calculations
No structural alignment score (TM-score) which is more robust than RMSD for comparing proteins of different sizes or with partial structural similarity
Chain extraction requires knowing chain IDs a priori -- no automatic chain identification or classification functionality
Limited structural analysis scope -- only RMSD and chain extraction; no contact analysis, surface area computation, or secondary structure assignment

Reach for something else when

You need comprehensive structural analysis including contact maps, surface area, secondary structure, or B-factor analysis -- use ProDy or local structural analysis tools
You need protein-protein interaction analysis with hydrogen bonds, salt bridges, and hydrophobic contacts -- use ProDy's encode action for interaction characterization
You need TM-score or GDT-TS rather than RMSD for structure comparison -- Biotite does not compute these metrics
You need visualization or molecular graphics -- use PyMOL or ChimeraX locally
You need to analyze molecular dynamics trajectories -- use MDAnalysis for trajectory-specific analyses
You need to analyze nucleic acid or small molecule components of a complex -- Biotite focuses on protein chains

Alternatives

Model	Better when	Worse when
prody	ProDy provides comprehensive interaction analysis (6 interaction types: H-bonds, salt bridges, hydrophobic contacts, pi-stacking, cation-pi, disulfide) plus RMSD computation with both structural and sequence-based alignment options	ProDy is more complex and resource-intensive (4 CPUs, 16 GB RAM); Biotite is simpler and lighter for cases where only RMSD and chain extraction are needed

API & schema¶

Call an action with POST /api/v1/{slug}/{action} — the request envelope is {"items": [...], "params": {...}} and a success returns {"results": [...]}. See the HTTP API page for the base URL, error shape, and full contract.

`generate`¶

Call it

curl -X POST http://127.0.0.1:8000/api/v1/biotite/generate \
  -H "Content-Type: application/json" \
  -d '{
  "items": [
    {
      "pdb": "<contents of a .pdb file>",
      "chain_ids": [
        "MKTAYIAKQRQISFVKSHFSRQLEERLGLIE"
      ]
    }
  ]
}'

Request — BiotiteExtractChainsRequest

Field	Type	Required	Constraints	Description
`items`	list[BiotiteExtractChainsRequestItem]	yes	items 1–8	Batch of inputs to process in a single request. Up to 8 structures per request.

Nested types

BiotiteExtractChainsRequestItem

Field	Type	Required	Constraints	Description
`pdb`	string	yes	len 1–	PDB structure as string
`chain_ids`	list[string]	yes	items 1–10	List of chain IDs to extract

Raw JSON Schema

{
  "$defs": {
    "BiotiteExtractChainsRequestItem": {
      "additionalProperties": false,
      "properties": {
        "pdb": {
          "description": "PDB structure as string",
          "minLength": 1,
          "title": "Pdb",
          "type": "string"
        },
        "chain_ids": {
          "description": "List of chain IDs to extract",
          "items": {
            "type": "string"
          },
          "maxItems": 10,
          "minItems": 1,
          "title": "Chain Ids",
          "type": "array"
        }
      },
      "required": [
        "pdb",
        "chain_ids"
      ],
      "title": "BiotiteExtractChainsRequestItem",
      "type": "object"
    }
  },
  "additionalProperties": false,
  "properties": {
    "items": {
      "description": "Batch of inputs to process in a single request. Up to 8 structures per request.",
      "items": {
        "$ref": "#/$defs/BiotiteExtractChainsRequestItem"
      },
      "maxItems": 8,
      "minItems": 1,
      "title": "Items",
      "type": "array"
    }
  },
  "required": [
    "items"
  ],
  "title": "BiotiteExtractChainsRequest",
  "type": "object"
}

Response — BiotiteExtractChainsResponse

Field	Type	Required	Constraints	Description
`results`	list[BiotiteExtractChainsResponseResult]	yes		Per-input results, returned in the same order as the request items.

Nested types

BiotiteExtractChainsResponseResult

Field	Type	Required	Constraints	Description
`chain_sequences`	object	yes		Mapping of chain ID to amino acid sequence
`chain_pdb_strings`	object	yes		Mapping of chain ID to PDB structure string

Raw JSON Schema

{
  "$defs": {
    "BiotiteExtractChainsResponseResult": {
      "description": "Result of chain extraction from PDB structure.",
      "properties": {
        "chain_sequences": {
          "additionalProperties": {
            "type": "string"
          },
          "description": "Mapping of chain ID to amino acid sequence",
          "title": "Chain Sequences",
          "type": "object"
        },
        "chain_pdb_strings": {
          "additionalProperties": {
            "type": "string"
          },
          "description": "Mapping of chain ID to PDB structure string",
          "title": "Chain Pdb Strings",
          "type": "object"
        }
      },
      "required": [
        "chain_sequences",
        "chain_pdb_strings"
      ],
      "title": "BiotiteExtractChainsResponseResult",
      "type": "object"
    }
  },
  "properties": {
    "results": {
      "description": "Per-input results, returned in the same order as the request items.",
      "items": {
        "$ref": "#/$defs/BiotiteExtractChainsResponseResult"
      },
      "title": "Results",
      "type": "array"
    }
  },
  "required": [
    "results"
  ],
  "title": "BiotiteExtractChainsResponse",
  "type": "object"
}

`predict`¶

Call it

curl -X POST http://127.0.0.1:8000/api/v1/biotite/predict \
  -H "Content-Type: application/json" \
  -d '{
  "items": [
    {
      "pdb_a": "<contents of a .pdb file>",
      "pdb_b": "<contents of a .pdb file>",
      "chain_a": [
        "MKTAYIAKQRQISFVKSHFSRQLEERLGLIE"
      ],
      "chain_b": [
        "MKTAYIAKQRQISFVKSHFSRQLEERLGLIE"
      ]
    }
  ]
}'

Request — BiotiteRMSDRequest

Field	Type	Required	Constraints	Description
`items`	list[BiotiteRMSDRequestItem]	yes	items 1–8	Batch of inputs to process in a single request. Up to 8 structure pairs per request.

Nested types

BiotiteRMSDRequestItem

Field	Type	Required	Constraints	Description
`pdb_a`	string	yes	len 1–	First PDB structure as string
`pdb_b`	string	yes	len 1–	Second PDB structure as string
`chain_a`	list[string]	yes	items 1–	Chain IDs from pdb_a for RMSD comparison. Must have the same length as chain_b.
`chain_b`	list[string]	yes	items 1–	Chain IDs from pdb_b for RMSD comparison. Must have the same length as chain_a.

Raw JSON Schema

{
  "$defs": {
    "BiotiteRMSDRequestItem": {
      "additionalProperties": false,
      "properties": {
        "pdb_a": {
          "description": "First PDB structure as string",
          "minLength": 1,
          "title": "Pdb A",
          "type": "string"
        },
        "pdb_b": {
          "description": "Second PDB structure as string",
          "minLength": 1,
          "title": "Pdb B",
          "type": "string"
        },
        "chain_a": {
          "description": "Chain IDs from pdb_a for RMSD comparison. Must have the same length as chain_b.",
          "items": {
            "type": "string"
          },
          "minItems": 1,
          "title": "Chain A",
          "type": "array"
        },
        "chain_b": {
          "description": "Chain IDs from pdb_b for RMSD comparison. Must have the same length as chain_a.",
          "items": {
            "type": "string"
          },
          "minItems": 1,
          "title": "Chain B",
          "type": "array"
        }
      },
      "required": [
        "pdb_a",
        "pdb_b",
        "chain_a",
        "chain_b"
      ],
      "title": "BiotiteRMSDRequestItem",
      "type": "object"
    }
  },
  "additionalProperties": false,
  "properties": {
    "items": {
      "description": "Batch of inputs to process in a single request. Up to 8 structure pairs per request.",
      "items": {
        "$ref": "#/$defs/BiotiteRMSDRequestItem"
      },
      "maxItems": 8,
      "minItems": 1,
      "title": "Items",
      "type": "array"
    }
  },
  "required": [
    "items"
  ],
  "title": "BiotiteRMSDRequest",
  "type": "object"
}

Response — BiotiteRMSDResponse

Field	Type	Required	Constraints	Description
`results`	list[BiotiteRMSDResponseResult]	yes		Per-input results, returned in the same order as the request items.

Nested types

BiotiteRMSDResponseResult

Field	Type	Required	Constraints	Description
`rmsd`	number	yes		Root mean square deviation in Angstroms

Raw JSON Schema

{
  "$defs": {
    "BiotiteRMSDResponseResult": {
      "description": "Result of RMSD computation between two structures.",
      "properties": {
        "rmsd": {
          "description": "Root mean square deviation in Angstroms",
          "title": "Rmsd",
          "type": "number"
        }
      },
      "required": [
        "rmsd"
      ],
      "title": "BiotiteRMSDResponseResult",
      "type": "object"
    }
  },
  "properties": {
    "results": {
      "description": "Per-input results, returned in the same order as the request items.",
      "items": {
        "$ref": "#/$defs/BiotiteRMSDResponseResult"
      },
      "title": "Results",
      "type": "array"
    }
  },
  "required": [
    "results"
  ],
  "title": "BiotiteRMSDResponse",
  "type": "object"
}

Usage¶

One-line summary: A structure analysis toolkit providing PDB chain extraction and C-alpha RMSD computation as API endpoints, enabling automated structure comparison and chain-level analysis in multi-model workflows.

Overview¶

Biotite is a computational biology toolkit for protein structure analysis, based on the biotite Python library. It is not a machine learning model -- it provides deterministic, CPU-only structural analysis algorithms wrapped as BioLM endpoints.

The BioLM Biotite endpoint serves two primary functions: 1. Chain extraction: Parse multi-chain PDB structures and extract individual chains with their amino acid sequences and atomic coordinates 2. RMSD computation: Compute root-mean-square deviation between two protein structures after optimal Kabsch superimposition

These utilities are designed to integrate with structure prediction models in this catalog (Chai1, ESMFold, RF3) for end-to-end structure prediction and evaluation workflows.

Architecture¶

Property	Value
Architecture	Algorithmic (structure analysis toolkit)
Parameters	0 (no learnable parameters)
GPU required	No (CPU only)
Deterministic	Yes
License	BSD-3-Clause

Capabilities & Limitations¶

CAN be used for: - Extracting individual chains from multi-chain PDB structures - Computing amino acid sequences from PDB atomic coordinates - Computing C-alpha RMSD between two protein structures - Comparing predicted structures against experimental references - Batch processing of up to 8 structure pairs per request

CANNOT be used for: - Structure prediction (use Chai1, ESMFold, or RF3 instead) - All-atom RMSD (only C-alpha backbone RMSD is computed) - mmCIF or other structure formats (PDB format only) - Ligand or small molecule analysis - Sequence analysis (use ESM2, Evo, or similar)

Other considerations: - Only model 1 is extracted from multi-model PDB files - Non-standard residues are mapped to "X" in sequence extraction - RMSD computation requires matching C-alpha atom counts between compared chains

Usage Examples¶

# Extract chains from a multi-chain PDB
from models.biotite.schema import (
    BiotiteExtractChainsRequest,
    BiotiteExtractChainsRequestItem,
)

extract_request = BiotiteExtractChainsRequest(
    items=[
        BiotiteExtractChainsRequestItem(
            pdb="ATOM      1  N   ALA A   1 ...\nATOM      6  N   GLY B   1 ...\nEND",
            chain_ids=["A", "B"],
        )
    ]
)

# Compute RMSD between two structures
from models.biotite.schema import (
    BiotiteRMSDRequest,
    BiotiteRMSDRequestItem,
)

rmsd_request = BiotiteRMSDRequest(
    items=[
        BiotiteRMSDRequestItem(
            pdb_a="ATOM  ... (predicted structure) ... END",
            pdb_b="ATOM  ... (reference structure) ... END",
            chain_a=["A"],
            chain_b=["A"],
        )
    ]
)

Architecture & training¶

Architecture¶

Model Type & Innovation¶

Biotite is not a machine learning model. It is a computational biology toolkit for protein structure analysis, wrapped as a BioLM endpoint. The biotite Python library provides efficient, well-tested algorithms for reading, writing, and analyzing macromolecular structures in PDB format.

The BioLM Biotite endpoint exposes two key structural analysis capabilities: 1. Chain extraction (generate action): Parse PDB structures and extract individual chains with their sequences and atomic coordinates. The generate verb follows the catalog's action-verb convention; this is a utility extraction operation, not ML-based generation. 2. RMSD computation (predict action): Compute root-mean-square deviation between two structures after optimal superimposition. The predict verb follows the catalog's action-verb convention; this is a structural metric computation, not ML-based property prediction.

These are essential utilities for structure prediction workflows -- e.g., comparing predicted structures from Chai1 or ESMFold against experimental references, or extracting individual chains from multi-chain complexes for downstream analysis.

Parameters & Layers¶

Property	Value
Architecture	Algorithmic (structure analysis toolkit)
Learnable parameters	0
GPU required	No (CPU only)
Deterministic	Yes

Training Data¶

Not applicable. Biotite uses deterministic algorithms for structure parsing and RMSD computation. No training data is involved.

Loss Function & Objective¶

Not applicable (algorithmic tool).

Tokenization / Input Processing¶

Property	Details
Input type	PDB structure strings
Validation	PDB format validation via `validate_pdb`
Chain IDs	Single-character chain identifiers
Coordinate system	Cartesian (Angstroms)
RMSD atoms	C-alpha (CA) backbone atoms
Batch size	8 items per request

Performance & Benchmarks¶

Published Benchmarks¶

Not applicable in the ML sense. Biotite implements standard structural biology algorithms: - RMSD: Root-mean-square deviation after optimal Kabsch superimposition - Chain extraction: Direct PDB parsing and filtering

BioLM Verification Results¶

Test	Input	Tolerance	Status
Chain extraction	Multi-chain PDB, extract chains A and B	Exact match	PASS
RMSD computation	Same structure vs. itself	rel_tol=1e-4, RMSD=0.0	PASS

Comparison to Alternatives¶

Tool	Advantage	Disadvantage
Biotite (this)	Integrated with BioLM; composable with prediction models	Limited to chain extraction and RMSD
BioPython PDB	More comprehensive PDB analysis	Not available as API; requires local setup
PyMOL	Full visualization and analysis	Heavy; GUI-focused; commercial for some uses
MDAnalysis	Trajectory analysis; extensive atom selection	Focused on MD simulations; heavier dependency
ProDy	ENM analysis; dynamics	More specialized; not structure comparison focused

Error Bars & Confidence¶

All computations are deterministic. RMSD is computed using Biotite's struc.superimpose() (Kabsch algorithm) followed by struc.rmsd(), both of which are exact up to floating-point precision.

Strengths & Limitations¶

Pros¶

Fully deterministic -- no randomness or hardware-dependent variation
No GPU required -- runs on CPU with minimal resources
Fast execution -- structure parsing and RMSD computation complete in milliseconds
Composable -- designed to work with structure prediction models (Chai1, ESMFold) in multi-step workflows
Standard algorithms -- uses well-validated Kabsch superimposition for RMSD
Batch processing -- up to 8 items per request

Cons¶

Limited scope -- only chain extraction and RMSD, not a general structure analysis suite
PDB format only -- does not accept mmCIF or other structure formats
C-alpha RMSD only -- does not compute all-atom or side-chain RMSD
Requires matching chain lengths -- RMSD fails if C-alpha atom counts differ between structures
3-letter to 1-letter conversion uses a fixed mapping -- non-standard residues mapped to "X"

Known Failure Modes¶

Mismatched chain lengths: RMSD computation requires identical numbers of C-alpha atoms in compared chains
Missing chains: Requesting extraction of a chain ID not present in the PDB returns an error
Non-standard residues: Residues not in the standard amino acid mapping are converted to "X"
Multi-model PDB files: Only model 1 is extracted
Very large structures: While no hard limit, very large PDB strings may approach memory limits

Implementation Details¶

Inference Pipeline¶

Request
  |-- Route to action:
  |
  |-- [generate] (extract chains)
  |     |-- Validate PDB string
  |     |-- Parse with biotite.structure.io.pdb.PDBFile
  |     |-- Get structure (model=1)
  |     |-- For each requested chain_id:
  |     |     |-- Filter atoms by chain_id
  |     |     |-- Extract sequence (3-letter to 1-letter conversion)
  |     |     |-- Write chain to temporary PDB file
  |     |-- Return chain_sequences and chain_pdb_strings
  |
  |-- [predict] (compute RMSD)
        |-- Validate both PDB strings
        |-- Parse structures A and B
        |-- For each chain pair (a_i, b_i):
        |     |-- Extract C-alpha (CA) coordinates
        |     |-- Verify matching atom counts
        |-- Concatenate all chain coordinates
        |-- Superimpose with struc.superimpose() (Kabsch algorithm)
        |-- Compute RMSD with struc.rmsd()
        |-- Return RMSD in Angstroms

Memory & Compute Profile¶

Property	Value
GPU	None (CPU only)
Memory	8 GB
CPU	2 cores
Cold start	Fast (memory snapshot enabled)

Determinism & Reproducibility¶

Setting	Value
Deterministic	Yes (all computations)
Random seeds	Not applicable
Hardware dependence	None (within floating-point precision)

Caching Behavior¶

Response caching is available as an optional, off-by-default gateway feature (BIOLM_CACHE_ENABLED) -- see the gateway docs; it is not handled by the model container.

Cache key derived from PDB strings, chain IDs, and action type
Cache hits are always valid since outputs are deterministic

Versions & Changelog¶

Version	Date	Changes
v1	--	Initial implementation with generate (chain extraction) and predict (RMSD) actions

Biology¶

Molecule Coverage¶

Primary Molecule Type(s)¶

Biotite operates on protein 3D structures in PDB format. It parses atomic coordinate data and performs structural analysis operations -- chain extraction and RMSD computation -- that are fundamental to structural biology workflows.

The tool handles: - Single-chain proteins: Extract sequences and structures from individual protein chains - Multi-chain complexes: Parse complexes and extract individual chains by chain ID - Protein-protein complexes: Compare structures with multiple paired chains

Cross-Applicability¶

Molecule Type	Applicability	Evidence	Caveats
Protein structures	High	Primary design purpose	PDB format required
Multi-chain complexes	High	Supports paired chain RMSD	Chain IDs must be specified
Protein-ligand complexes	Moderate	Can extract protein chains	Ligand atoms ignored in RMSD (CA only)
Nucleic acid structures	Low	PDB parsing works, but no specific analysis	Sequence extraction uses amino acid mapping
Small molecules	Not supported	No small molecule analysis	Use chemistry-specific tools

Biological Problems Addressed¶

Problem 1: Structure Prediction Evaluation¶

Why this matters: When using ML-based structure prediction tools (Chai1, ESMFold, AlphaFold2), researchers need to evaluate how well the predicted structure matches the experimental reference. RMSD (Root Mean Square Deviation) is the standard metric for quantifying structural similarity.

How Biotite addresses it: The predict action computes C-alpha RMSD between two structures after optimal superimposition using the Kabsch algorithm. This allows direct comparison of: - Predicted vs. experimental structures - Different prediction methods on the same target - Conformational changes between different states of the same protein

Interpreting RMSD values: - < 1.0 Angstroms: Excellent agreement (comparable to experimental resolution) - 1.0--2.0 Angstroms: Good agreement (typical for high-quality predictions) - 2.0--5.0 Angstroms: Moderate agreement (correct fold, local differences) - > 5.0 Angstroms: Poor agreement (likely different conformations or wrong fold)

Problem 2: Chain Extraction from Complexes¶

Why this matters: Structure prediction tools often produce multi-chain complexes (e.g., antibody-antigen, enzyme-substrate, homo-oligomers). Downstream analyses frequently require working with individual chains -- e.g., extracting only the antibody heavy chain, or comparing individual subunits.

How Biotite addresses it: The generate action extracts specified chains from a PDB structure, returning both: - Amino acid sequence: The 1-letter code sequence of each chain - PDB string: The full atomic coordinate data for each chain

This enables chain-level analysis without manual PDB file manipulation.

Problem 3: Multi-Model Workflow Integration¶

Why this matters: Modern computational biology workflows often chain multiple tools together -- predict a structure with Chai1, extract individual chains, compare against a reference, score the sequence with ESM2. Having structure parsing and comparison available as an API endpoint enables these workflows to be fully automated.

How Biotite addresses it: By providing standardized chain extraction and RMSD computation as BioLM endpoints, Biotite integrates directly with structure prediction models in the same catalog. For example: 1. Generate structure with Chai1 or ESMFold 2. Extract chains with Biotite generate 3. Compare with reference using Biotite predict 4. Analyze individual chain sequences with ESM2

Applied Use Cases¶

Use Case 1: Structure Prediction Benchmarking (Published)¶

Source: Kunzmann P, Hamacher K. "Biotite: a unifying open source computational biology framework in Python." BMC Bioinformatics (2018). DOI: 10.1186/s12859-018-2367-z

Biotite is widely used in the computational biology community for structure analysis, comparison, and validation. The BioLM integration enables these capabilities as API-accessible utilities.

Use Case 2: Automated Structure Comparison Pipelines (Anticipated)¶

Using Biotite RMSD in automated pipelines that compare predicted protein structures against experimental references (e.g., from the PDB), enabling large-scale benchmarking of structure prediction models.

Complementary Models¶

RF3: AF3-like structure prediction model. Use RF3 to predict structures, then Biotite to extract chains and compute RMSD against references.
Chai1: Alternative structure prediction model. Same workflow as RF3.
ESMFold: Single-sequence structure prediction. Compare ESMFold outputs to experimental structures using Biotite RMSD.
ESM2: Protein language model. Extract chain sequences with Biotite generate, then analyze with ESM2 encode.

Alternative Models¶

Alternative	Advantage over Biotite	Disadvantage vs Biotite
BioPython PDB	More comprehensive structure analysis	Not API-accessible; requires local setup
PyMOL	Visualization; extensive analysis commands	Heavy; GUI-focused; not API-accessible
MDAnalysis	Trajectory analysis; flexible atom selection	Focused on simulations; heavier

Biological Background¶

Protein structure is central to understanding protein function. Proteins fold from linear amino acid chains into specific three-dimensional shapes that determine their biological activity. Structural biology aims to determine, predict, and analyze these shapes.

Key concepts relevant to Biotite:

PDB format: The Protein Data Bank format is the standard file format for storing 3D atomic coordinates of macromolecules. Each atom's position is specified in Cartesian coordinates (x, y, z in Angstroms).
Chain: In multi-molecular complexes, each separate polypeptide or nucleic acid strand is assigned a chain identifier (A, B, C, etc.). A homodimer has two chains with the same sequence; a heterodimer has chains with different sequences.
C-alpha (CA) atom: The central carbon atom in each amino acid residue. C-alpha RMSD is the standard metric for comparing backbone conformations because it provides a one-atom-per-residue representation of the protein's overall shape.
RMSD (Root Mean Square Deviation): A measure of the average distance between corresponding atoms in two superimposed structures, in Angstroms. Lower RMSD indicates more similar structures.
Superimposition (Kabsch algorithm): An optimal rotation and translation that minimizes the RMSD between two sets of corresponding atom coordinates. This removes differences due to orientation and position, isolating genuine structural differences.
Residue mapping: Converting between 3-letter amino acid codes (ALA, GLY, etc.) and 1-letter codes (A, G, etc.) is a standard operation in structural bioinformatics.

Sources & license¶

License: BSD-3-Clause (text)

Papers

Biotite: a unifying open source computational biology framework in Python — BMC Bioinformatics, 2018 · DOI

Source repositories

github: https://github.com/biotite-dev/biotite
pypi: https://pypi.org/project/biotite/

Biotite¶

At a glance¶

API & schema¶

generate¶

predict¶

Usage¶

Overview¶

Architecture¶

Capabilities & Limitations¶

Usage Examples¶

Architecture & training¶

Architecture¶

Model Type & Innovation¶

Parameters & Layers¶

Training Data¶

Loss Function & Objective¶

Tokenization / Input Processing¶

Performance & Benchmarks¶

Published Benchmarks¶

BioLM Verification Results¶

Comparison to Alternatives¶

Error Bars & Confidence¶

Strengths & Limitations¶

Pros¶

Cons¶

Known Failure Modes¶

Implementation Details¶

Inference Pipeline¶

Memory & Compute Profile¶

Determinism & Reproducibility¶

Caching Behavior¶

Versions & Changelog¶

Biology¶

Molecule Coverage¶

Primary Molecule Type(s)¶

Cross-Applicability¶

Biological Problems Addressed¶

Problem 1: Structure Prediction Evaluation¶

Problem 2: Chain Extraction from Complexes¶

Problem 3: Multi-Model Workflow Integration¶

Applied Use Cases¶

Use Case 1: Structure Prediction Benchmarking (Published)¶

Use Case 2: Automated Structure Comparison Pipelines (Anticipated)¶

Related Models¶

Complementary Models¶

Alternative Models¶

Biological Background¶

Sources & license¶

`generate`¶

`predict`¶