Chai-1: molecular structure prediction for proteins, DNA, RNA and small molecules

One model for proteins, small molecules, DNA, RNA and glycosylations

Chai-1 is a multi-modal foundation model for molecular structure prediction. Its scope covers proteins, small molecules, DNA, RNA and glycosylations, all handled within a single inference pipeline. A technical report on the model's performance is published on biorxiv at 2024.10.10.615955.

Most structure prediction tools address one molecule type at a time. Chai-1 handles the full complex, which matters when the interaction of interest involves a protein binding a small-molecule ligand, a nucleic acid, or a modified residue. Inputs can include modified residues, nucleotides and ligands as SMILES strings, all passed through a single FASTA file, with no need to split the complex into separate runs for each molecule type. That end-to-end scope is the core design decision.

Without additional flags, each fold run produces five candidate structures built from embeddings alone, without MSA alignment or template retrieval. That default is faster but gives less accuracy on sequences where evolutionary conservation is informative. The README recommends MSA use for improved performance but does not quantify the degree of improvement. Whether five samples are sufficient for a given task depends on how much conformational diversity matters for the downstream application, and that judgment is left to the user.

An A100 80GB or H100 80GB is the recommended GPU; an RTX 4090 works for smaller complexes

The hardware requirement is the first filter for most teams. Running Chai-1 requires Linux, Python 3.10 or later, and a GPU with CUDA and bfloat16 support. The README recommends an A100 80GB, an H100 80GB or an L40S 48GB as the target hardware. An A10 and an A30 will work for smaller complexes, and users have reported success with a consumer-grade RTX 4090, also for smaller complexes.

The Linux requirement is absolute as stated. No macOS or Windows path is documented, which matters for teams whose workstations run either of those operating systems. Teams without a qualifying GPU need to either provision cloud compute or use the web server at lab.chaidiscovery.com, which requires no local setup.

Weights are downloaded automatically on first use and stored inside the package root by default, in a downloads folder within site-packages. For environments where that location is not writable, such as a mounted drive inside a Docker container, the CHAI_DOWNLOADS_DIR environment variable controls where weights land. The README gives this example for overriding the download path:

CHAI_DOWNLOADS_DIR=/tmp/downloads python ./examples/predict_structure.py

Weights are fetched on demand, so the first inference run takes longer than subsequent runs on the same machine.

Install via pip, then fold a FASTA file from the command line

Installation uses pip with the package name chai_lab:

pip install chai_lab==0.6.1

That installs version 0.6.1, the current PyPI release. A daily-build path is also documented for accessing features not yet released:

pip install git+https://github.com/chaidiscovery/chai-lab.git

After installation, the chai-lab fold command takes a FASTA file containing all sequences and an output folder:

chai-lab fold input.fasta output_folder

That produces five PDB files by default. For improved results the README recommends running with MSAs and templates, using these flags:

chai-lab fold --use-msa-server --use-templates-server input.fasta output_folder

Those two flags query the public ColabFold MMseqs2 server, which the README describes as a shared resource. The --use-msa-server flag alone queries for MSAs; --use-templates-server adds template lookup. Running without either flag is faster but the README says performance is better with them. A full list of command-line options is available by running chai-lab fold --help.

The public MSA server is shared; a self-hosted ColabFold instance needs a separate flag

MSA support adds a layer of configuration. Chai-1 accepts MSAs provided as an aligned.pqt file, a format similar to an a3m file but with additional columns for metadata including source database and sequence pairing keys. Code for converting a3m files to the aligned.pqt format is included in the repository.

For automatic MSA generation without preparing a file manually, the --use-msa-server flag queries the public ColabFold MMseqs2 server. The README notes that results reported in the technical preprint and on the web server use a different MSA search strategy than MMseqs2, though it describes results as broadly similar. Teams running a self-hosted ColabFold instance pass the --msa-server-url flag with their own server address:

chai-lab fold --use-msa-server --msa-server-url "https://api.internalcolabserver.com" input.fasta output_folder

The self-hosted path removes the shared-resource constraint of the public server and gives more control over which MSA database is searched. Setting up a ColabFold server is outside the scope of the chai-lab repository; the README links to the ColabFold repository for that.

Restraints let users specify inter-chain contacts and covalent bonds to guide folding

A feature the README flags as specific to Chai-1 is user-specified restraints. Restraints specify inter-chain contacts or covalent bonds at various resolutions, supplied as inputs to guide the model during inference rather than applied as post-processing filters. In contexts where partial experimental data is available, such as a known contact from crosslinking or mutagenesis, this lets the model incorporate that evidence rather than ignoring it.

Two documentation directories cover this: examples/restraints/ for inter-chain contacts and examples/covalent_bonds/ for covalent bond specification. Covalent bond support includes branched ligands, which arise in glycosylation contexts where the standard linear representation is insufficient.

This capability lives in the Python API, not in the CLI. The chai-lab fold command does not expose restraints as flags. Accessing restraints requires constructing an AllAtomFeatureContext manually through chai_lab.chai1.run_folding_on_context, which is also the entry point for custom templates, embeddings and MSAs. The README provides examples of each, stored under the examples/ directory, covering embeddings, MSA, template, restraint, and covalent bond contexts individually. Reading those examples before writing production code is the documented path.

The Python API exposes AllAtomFeatureContext for custom templates, embeddings and MSAs

Beyond the CLI, the main programmatic entry point is chai_lab.chai1.run_inference, demonstrated in examples/predict_structure.py. For MSA workflows, examples/msas/predict_with_msas.py shows how to provide MSAs to the model. Running those example scripts directly is the first step the README points to before writing custom code.

For more control, chai_lab.chai1.run_folding_on_context accepts an AllAtomFeatureContext constructed manually. That context carries custom templates, embeddings, MSAs, restraints and covalent bond specifications. The examples/ directory holds worked examples for each of those input types, and looking at them before writing production code that calls run_folding_on_context is the path the README supports.

Custom templates add a two-step process. A m8 file provides a table of template hits to load, and the model downloads the corresponding entries from RCSB. For non-RCSB structures, the CHAI_TEMPLATE_CIF_FOLDER environment variable names a directory holding cif files, named as identifier.cif.gz where identifier matches the m8 file. That naming convention is strict, and files that do not follow it will not be loaded.

Latest tagged release is v0.6.1 from March 2025; last push was 2026-06-30

Version 0.6.1 on PyPI is dated 2025-03-18. Prior releases were v0.6.0 on 2025-02-18 and v0.5.2 on 2024-12-24. The last push to the main branch was on 2026-06-30, which means there is work in the repository after the most recent tagged release, accessible through the git-based install path. Whether that unreleased work changes inference behavior in ways that matter for a given use case is something only the commit history and any associated issue discussions would reveal.

Licence is Apache-2.0, recorded in both the repository metadata and the pyproject.toml. The project is authored by Chai Discovery, described in pyproject.toml as tools for AI and protein research.

Feedback routes are two: GitHub issues for bugs and either GitHub discussions or [email protected] for observations about model performance. Development uses devcontainers to maintain reproducible environments, and a Dockerfile.chailab is present at the repository root for teams that want a containerized setup. For users who consume the pip package and do not contribute to the repository, the devcontainer configuration is not required for a working install.

Editorial conclusion

Chai-1 suits a computational biology team with access to an A100, H100 or L40S GPU that needs to fold multi-modal complexes including small molecules, DNA, RNA or glycosylations in a single run. Skip local deployment if your hardware is below those tiers and the simpler complex types you are working on can be handled by the web server at lab.chaidiscovery.com instead. Before committing to a workflow, confirm that v0.6.1 on PyPI is the version you want, since the daily-build install from GitHub may include unreleased changes that have not yet been tagged.

Frequently asked questions

Official sources

1. chaidiscovery/chai-lab on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases