diff --git a/esm/README.md b/esm/README.md
new file mode 100644
index 00000000..b2c9d24c
--- /dev/null
+++ b/esm/README.md
@@ -0,0 +1,156 @@
+# ESM-2
+
+This repository provides an implementation of Meta's ESM-2 protein language model
+in MLX.[^1] ESM-2 is Meta’s second-generation Evolutionary Scale Model, a
+transformer-based protein language model trained on millions of diverse protein
+sequences with a masked language modeling objective.
+
+![Example contact prediction map](assets/contact_prediction.png)
+
+_Example contact prediction map for a universal stress protein. In this case, ESM-2 650M achieves 86.4% precision at long-range contacts._
+
+## Setup
+
+Install the requirements:
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+Below are the available ESM-2 models:
+| Model | Parameters | Layers |
+|-------|------------|--------|
+| [`esm2_t6_8M_UR50D`](https://huggingface.co/facebook/esm2_t6_8M_UR50D) | 8M | 6 |
+| [`esm2_t12_35M_UR50D`](https://huggingface.co/facebook/esm2_t12_35M_UR50D) | 35M | 12 |
+| [`esm2_t30_150M_UR50D`](https://huggingface.co/facebook/esm2_t30_150M_UR50D) | 150M | 30 |
+| [`esm2_t33_650M_UR50D`](https://huggingface.co/facebook/esm2_t33_650M_UR50D) | 650M | 33 |
+| [`esm2_t36_3B_UR50D`](https://huggingface.co/facebook/esm2_t36_3B_UR50D) | 3B | 36 |
+| [`esm2_t48_15B_UR50D`](https://huggingface.co/facebook/esm2_t48_15B_UR50D) | 15B | 48 |
+
+Convert a model to MLX format:
+
+```bash
+python convert.py --hf-path facebook/esm2_t33_650M_UR50D
+```
+
+This will save the converted model in a checkpoints directory.
+
+### Basic Inference
+
+```python
+from esm import ESM2
+
+# Load model and tokenizer
+tokenizer, model = ESM2.from_pretrained("checkpoints/mlx-esm2_t33_650M_UR50D")
+
+# Example protein sequence (human insulin)
+sequence = "MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN"
+
+# Tokenize and run inference
+tokens = tokenizer.encode(sequence)
+result = model(tokens)
+logits = result["logits"]  # Shape: (batch, length, vocab_size)
+```
+
+### Masked Language Modeling
+
+```bash
+# For a complete example, see main.py
+python main.py --sequence "YOUR_SEQUENCE" --mask-position 50
+```
+
+### Embeddings
+
+```python
+# Get sequence-level representations
+seq_repr = model.get_sequence_representations(tokens, layer=-1)  # Shape: (batch, embed_dim)
+
+# Extract per-residue representations from specific layers
+representations = model.extract_features(tokens, repr_layers=[20, 30, 33])
+final_layer = representations[33]  # Shape: (batch, length, embed_dim)
+```
+
+### Contact Prediction
+
+```python
+# Predict residue-residue contacts
+contacts = model.predict_contacts(tokens)  # Shape: (batch, length, length)
+
+# Or compute contacts together with logits, representations, etc.
+outputs = model(tokens, return_contacts=True)
+contacts = outputs["contacts"]
+```
+
+### Examples
+
+**Mutation Effect Prediction**: [notebooks/mutation_effect_prediction.ipynb](notebooks/mutation_effect_prediction.ipynb)
+
+This notebook demonstrates how to use ESM-2 for zero-shot mutation effect prediction by scoring amino acid substitutions based on their likelihood under the model. We validate the approach using experimental fitness data from β-lactamase TEM, showing how ESM-2 captures functional constraints without requiring structural information.
+
+**Embeddings**: [notebooks/embeddings.ipynb](notebooks/embeddings.ipynb)
+
+This notebook explores how ESM-2 generates meaningful protein embeddings that capture evolutionary and functional relationships between proteins. We analyze six diverse human proteins to demonstrate how the learned representations cluster proteins by function and reveal biological similarities.
+
+**Contact Prediction**: [notebooks/contact_prediction.ipynb](notebooks/contact_prediction.ipynb)
+
+This notebook shows how to predict residue-residue contacts in protein structures using ESM-2's attention patterns. We evaluate contact prediction performance on three diverse proteins, demonstrating how the model captures both local and long-range structural relationships directly from sequence data.
+
+### Benchmarking
+
+Benchmark MLX performance:
+
+```bash
+python benchmarks/benchmark_mx.py
+```
+
+Benchmark PyTorch MPS performance:
+
+```bash
+python benchmarks/benchmark_pt.py
+```
+
+Expected performance on M4 MacBook Pro (ESM-2 650M, batch_size = 5):
+
+- MLX: 299 ms per step, 16.71 sequences/sec
+- PyTorch MPS: 402 ms per step, 12.43 sequences/sec
+
+### Testing
+
+Verify correctness against original implementation:
+
+```bash
+python test.py
+```
+
+This tests tokenizer and model outputs (logits, hidden states, and attentions) for equivalence with the original implementation.
+
+### Citations:
+
+```bibtex
+@article{rives2019biological,
+  author={Rives, Alexander and Meier, Joshua and Sercu, Tom and Goyal, Siddharth and Lin, Zeming and Liu, Jason and Guo, Demi and Ott, Myle and Zitnick, C. Lawrence and Ma, Jerry and Fergus, Rob},
+  title={Biological Structure and Function Emerge from Scaling Unsupervised Learning to 250 Million Protein Sequences},
+  year={2019},
+  doi={10.1101/622803},
+  url={https://www.biorxiv.org/content/10.1101/622803v4},
+  journal={PNAS}
+}
+
+```
+
+```bibtex
+@article{Lin2023,
+  author={Zeming Lin et al.},
+  title={Evolutionary-scale prediction of atomic-level protein structure with a language model},
+  journal={Science},
+  volume={379},
+  pages={1123--1130},
+  year={2023},
+  doi={10.1126/science.ade2574},
+  url={https://doi.org/10.1126/science.ade2574}
+}
+```
+
+[^1]: Refer to the [paper](https://www.science.org/doi/10.1126/science.ade2574) and [code](https://github.com/facebookresearch/esm) for more details.
diff --git a/esm/assets/contact_prediction.png b/esm/assets/contact_prediction.png
new file mode 100644
index 00000000..8720fb82
Binary files /dev/null and b/esm/assets/contact_prediction.png differ
diff --git a/esm/benchmarks/benchmark_mx.py b/esm/benchmarks/benchmark_mx.py
new file mode 100644
index 00000000..c970d34e
--- /dev/null
+++ b/esm/benchmarks/benchmark_mx.py
@@ -0,0 +1,47 @@
+import sys
+import time
+from pathlib import Path
+
+import mlx.core as mx
+
+# Add parent directory to Python path
+cur_path = Path(__file__).parents[1].resolve()
+sys.path.append(str(cur_path))
+
+from esm import ESM2
+
+# Example protein sequence (Green Fluorescent Protein)
+protein_sequence = "MSKGEELFTGVVPILVELDGDVNGHKFSVSGEGEGDATYGKLTLKFICTTGKLPVPWPTLVTTFSYGVQCFSRYPDHMKQHDFFKSAMPEGYVQERTIFFKDDGNYKTRAEVKFEGDTLVNRIELKGIDFKEDGNILGHKLEYNYNSHNVYIMADKQKNGIKVNFKIRHNIEDGSVQLADHYQQNTPIGDGPVLLPDNHYLSTQSALSKDPNEKRDHMVLLEFVTAAGITHGMDELYK"
+
+# Load pretrained ESM-2 model and its tokenizer from local checkpoint
+tokenizer, model = ESM2.from_pretrained("checkpoints/mlx-esm2_t33_650M_UR50D")
+
+# Number of sequences to process in each forward pass
+batch_size = 5
+
+# Number of timing iterations for performance measurement
+steps = 50
+
+# Tokenize the protein sequence into integer IDs for the model
+# Replicate the same sequence 'batch_size' times to create a batch
+tokens = tokenizer.batch_encode([protein_sequence] * batch_size)
+
+# Warm-up phase
+for _ in range(10):
+    result = model(tokens)
+    mx.eval(result["logits"])  # Force computation to complete
+
+# Measure average inference time over 'steps' iterations
+tic = time.time()
+for _ in range(steps):
+    result = model(tokens)
+    mx.eval(result["logits"])  # Synchronize and ensure computation finishes
+toc = time.time()
+
+# Compute metrics: average time per step (ms) and throughput (sequences/sec)
+ms_per_step = 1000 * (toc - tic) / steps
+throughput = batch_size * 1000 / ms_per_step
+
+# Display results
+print(f"Time (ms) per step: {ms_per_step:.3f}")
+print(f"Throughput: {throughput:.2f} sequences/sec")
diff --git a/esm/benchmarks/benchmark_pt.py b/esm/benchmarks/benchmark_pt.py
new file mode 100644
index 00000000..44f28e5b
--- /dev/null
+++ b/esm/benchmarks/benchmark_pt.py
@@ -0,0 +1,52 @@
+import time
+
+import torch
+from transformers import AutoTokenizer, EsmForMaskedLM
+
+# Example protein sequence (Green Fluorescent Protein)
+protein_sequence = "MSKGEELFTGVVPILVELDGDVNGHKFSVSGEGEGDATYGKLTLKFICTTGKLPVPWPTLVTTFSYGVQCFSRYPDHMKQHDFFKSAMPEGYVQERTIFFKDDGNYKTRAEVKFEGDTLVNRIELKGIDFKEDGNILGHKLEYNYNSHNVYIMADKQKNGIKVNFKIRHNIEDGSVQLADHYQQNTPIGDGPVLLPDNHYLSTQSALSKDPNEKRDHMVLLEFVTAAGITHGMDELYK"
+
+# Hugging Face model identifier for ESM-2 (33 layers, 650M params, UR50D training set)
+model_name = "facebook/esm2_t33_650M_UR50D"
+
+# Load tokenizer and model; move model to Apple Metal Performance Shaders (MPS) device
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = EsmForMaskedLM.from_pretrained(model_name).to("mps")
+
+# Number of sequences per forward pass
+batch_size = 5
+
+# Number of timing iterations
+steps = 50
+
+# Tokenize input sequence and replicate for the batch
+# Replicate the same sequence 'batch_size' times to create a batch
+inputs = tokenizer(
+    [protein_sequence] * batch_size,
+    return_tensors="pt",
+    padding=True,
+    truncation=True,
+    max_length=1024,
+)
+input_ids = inputs["input_ids"].to("mps")
+attention_mask = inputs["attention_mask"].to("mps")
+
+# Warm-up phase
+for _ in range(10):
+    outputs = model(input_ids=input_ids, attention_mask=attention_mask)
+    torch.mps.synchronize()  # Ensure all queued ops on MPS are complete before next step
+
+# Timed inference loop
+tic = time.time()
+for _ in range(steps):
+    outputs = model(input_ids=input_ids, attention_mask=attention_mask)
+    torch.mps.synchronize()  # Wait for computation to finish before timing next iteration
+toc = time.time()
+
+# Compute performance metrics
+ms_per_step = 1000 * (toc - tic) / steps
+throughput = batch_size * 1000 / ms_per_step
+
+# Report results
+print(f"Time (ms) per step: {ms_per_step:.3f}")
+print(f"Throughput: {throughput:.2f} sequences/sec")
diff --git a/esm/convert.py b/esm/convert.py
new file mode 100644
index 00000000..bfbc4be7
--- /dev/null
+++ b/esm/convert.py
@@ -0,0 +1,177 @@
+import argparse
+import json
+import shutil
+from pathlib import Path
+from typing import Dict
+
+import mlx.core as mx
+import torch
+from huggingface_hub import snapshot_download
+
+
+def download(hf_repo: str) -> Path:
+    """Download model from Hugging Face."""
+    return Path(
+        snapshot_download(
+            repo_id=hf_repo,
+            allow_patterns=["*.safetensors", "*.json", "*.bin", "*.txt"],
+        )
+    )
+
+
+def remap_key(key: str) -> str:
+    """Remap HuggingFace ESM key names to MLX format."""
+
+    # Skip position embeddings and position_ids
+    if "position_embeddings" in key or "position_ids" in key:
+        return None
+
+    # Map lm_head components properly
+    if key == "lm_head.decoder.weight":
+        return "lm_head.weight"
+    if key == "lm_head.decoder.bias":
+        return "lm_head.bias"
+    if key == "lm_head.dense.weight":
+        return "lm_head.dense.weight"
+    if key == "lm_head.dense.bias":
+        return "lm_head.dense.bias"
+    if key == "lm_head.layer_norm.weight":
+        return "lm_head.layer_norm.weight"
+    if key == "lm_head.layer_norm.bias":
+        return "lm_head.layer_norm.bias"
+
+    # Core remapping patterns
+    key = key.replace("esm.embeddings.word_embeddings", "embed_tokens")
+    key = key.replace("esm.encoder.emb_layer_norm_after", "emb_layer_norm_after")
+    key = key.replace("esm.encoder.layer.", "layer_")
+    key = key.replace("esm.contact_head", "contact_head")
+    key = key.replace("lm_head", "lm_head")
+
+    # Attention patterns
+    key = key.replace(".attention.self.", ".self_attn.")
+    key = key.replace(".attention.output.dense", ".self_attn.out_proj")
+    key = key.replace(".attention.LayerNorm", ".self_attn_layer_norm")
+    key = key.replace(".query", ".q_proj")
+    key = key.replace(".key", ".k_proj")
+    key = key.replace(".value", ".v_proj")
+    key = key.replace(".rotary_embeddings", ".rot_emb")
+
+    # FFN patterns
+    key = key.replace(".intermediate.dense", ".fc1")
+    key = key.replace(".output.dense", ".fc2")
+    key = key.replace(".LayerNorm", ".final_layer_norm")
+
+    return key
+
+
+def load_weights(model_path: Path) -> Dict:
+    """Load weights from safetensors or PyTorch bin files."""
+
+    # Check for safetensors file
+    safetensors_path = model_path / "model.safetensors"
+    if safetensors_path.exists():
+        print("Loading from safetensors...")
+        return mx.load(str(safetensors_path))
+
+    # Check for single bin file
+    single_bin_path = model_path / "pytorch_model.bin"
+    if single_bin_path.exists():
+        print("Loading from pytorch_model.bin...")
+        state_dict = torch.load(str(single_bin_path), map_location="cpu")
+        return {k: v.numpy() for k, v in state_dict.items()}
+
+    # Check for sharded bin files
+    index_file = model_path / "pytorch_model.bin.index.json"
+    if index_file.exists():
+        print("Loading from sharded bin files...")
+        with open(index_file) as f:
+            index = json.load(f)
+
+        # Get unique shard files
+        shard_files = set(index["weight_map"].values())
+
+        # Load all shards
+        state_dict = {}
+        for shard_file in sorted(shard_files):
+            print(f"  Loading shard: {shard_file}")
+            shard_path = model_path / shard_file
+            shard_dict = torch.load(str(shard_path), map_location="cpu")
+            state_dict.update(shard_dict)
+
+        return {k: v.numpy() for k, v in state_dict.items()}
+
+    raise ValueError(f"No model weights found in {model_path}")
+
+
+def convert(model_path: Path) -> Dict[str, mx.array]:
+    """Convert ESM weights to MLX format."""
+
+    # Load weights from any format
+    weights = load_weights(model_path)
+
+    # Convert keys and create MLX arrays
+    mlx_weights = {}
+    for key, value in weights.items():
+        mlx_key = remap_key(key)
+        if mlx_key is not None:
+            mlx_weights[mlx_key] = (
+                mx.array(value) if not isinstance(value, mx.array) else value
+            )
+
+    # If lm_head.weight is missing but embed_tokens.weight exists, set up weight sharing
+    # (This is for smaller models that don't have a separate lm_head.decoder.weight)
+    if "lm_head.weight" not in mlx_weights and "embed_tokens.weight" in mlx_weights:
+        mlx_weights["lm_head.weight"] = mlx_weights["embed_tokens.weight"]
+
+    return mlx_weights
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert ESM weights to MLX format")
+    parser.add_argument(
+        "--hf-path", default="facebook/esm2_t6_8M_UR50D", help="Hugging Face model path"
+    )
+    parser.add_argument("--mlx-path", default=None, help="Output path for MLX model")
+    parser.add_argument(
+        "--checkpoints-dir",
+        default="checkpoints",
+        help="Directory to save checkpoints (default: checkpoints)",
+    )
+
+    args = parser.parse_args()
+
+    # Download model
+    print(f"Downloading {args.hf_path}...")
+    model_path = download(args.hf_path)
+
+    # Set output path
+    if args.mlx_path is None:
+        model_name = args.hf_path.split("/")[-1]
+        checkpoints_dir = Path(args.checkpoints_dir)
+        checkpoints_dir.mkdir(parents=True, exist_ok=True)
+        args.mlx_path = checkpoints_dir / f"mlx-{model_name}"
+    mlx_path = Path(args.mlx_path)
+    mlx_path.mkdir(parents=True, exist_ok=True)
+
+    # Convert weights
+    print("Converting weights...")
+    mlx_weights = convert(model_path)
+
+    # Save weights
+    print(f"Saving MLX weights to {mlx_path}...")
+    mx.save_safetensors(str(mlx_path / "model.safetensors"), mlx_weights)
+
+    # Copy config and other files
+    print("Copying config...")
+    shutil.copy(model_path / "config.json", mlx_path / "config.json")
+
+    for file_name in ["special_tokens_map.json", "tokenizer.json", "vocab.txt"]:
+        src_file = model_path / file_name
+        if src_file.exists():
+            shutil.copy(src_file, mlx_path / file_name)
+
+    print(f"Conversion complete! MLX model saved to {mlx_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/esm/esm/__init__.py b/esm/esm/__init__.py
new file mode 100644
index 00000000..1c2139d4
--- /dev/null
+++ b/esm/esm/__init__.py
@@ -0,0 +1,19 @@
+"""
+ESM-2 protein language model implementation in MLX
+"""
+
+from .attention import MultiheadAttention
+from .model import ESM2
+from .modules import ContactPredictionHead, RobertaLMHead, TransformerLayer
+from .rotary_embedding import RotaryEmbedding
+from .tokenizer import ProteinTokenizer
+
+__all__ = [
+    "ESM2",
+    "ProteinTokenizer",
+    "ContactPredictionHead",
+    "RobertaLMHead",
+    "TransformerLayer",
+    "MultiheadAttention",
+    "RotaryEmbedding",
+]
diff --git a/esm/esm/attention.py b/esm/esm/attention.py
new file mode 100644
index 00000000..be535b25
--- /dev/null
+++ b/esm/esm/attention.py
@@ -0,0 +1,153 @@
+from typing import Optional, Tuple
+
+import mlx.core as mx
+import mlx.nn as nn
+
+from .rotary_embedding import RotaryEmbedding
+
+
+class MultiheadAttention(nn.Module):
+    """
+    Multi-head attention layer with rotary position embeddings, as used in ESM-2.
+
+    This module implements both self-attention (when `key` and `value` are not
+    provided) and cross-attention. It projects input sequences into queries,
+    keys, and values, applies rotary position embeddings to encode relative
+    position information, computes scaled dot-product attention over multiple
+    heads in parallel, and returns a combined output projection.
+
+    Args:
+        embed_dim (int): Total embedding dimension of the model input and output.
+        num_heads (int): Number of parallel attention heads. Must divide `embed_dim`.
+    """
+
+    def __init__(
+        self,
+        embed_dim,
+        num_heads,
+    ):
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.num_heads = num_heads
+        self.head_dim = embed_dim // num_heads
+        assert (
+            self.head_dim * num_heads == self.embed_dim
+        ), "embed_dim must be divisible by num_heads"
+        self.scaling = self.head_dim**-0.5
+
+        # Linear projections for queries, keys, and values (with bias)
+        self.q_proj = nn.Linear(embed_dim, embed_dim, bias=True)
+        self.k_proj = nn.Linear(embed_dim, embed_dim, bias=True)
+        self.v_proj = nn.Linear(embed_dim, embed_dim, bias=True)
+
+        # Linear projection for output (with bias)
+        self.out_proj = nn.Linear(embed_dim, embed_dim, bias=True)
+
+        # ESM-2 uses rotary embeddings
+        self.rot_emb = RotaryEmbedding(dim=self.head_dim)
+
+    def __call__(
+        self,
+        query,
+        key: Optional[mx.array] = None,
+        value: Optional[mx.array] = None,
+        key_padding_mask: Optional[mx.array] = None,
+        attn_mask: Optional[mx.array] = None,
+        need_head_weights: bool = False,
+    ) -> Tuple[mx.array, Optional[mx.array]]:
+        """
+        Multi-head attention forward pass.
+
+        Args:
+            query: Tensor of shape (tgt_len, batch, embed_dim).
+            key: Optional tensor of shape (src_len, batch, embed_dim). Defaults to `query`.
+            value: Optional tensor of shape (src_len, batch, embed_dim). Defaults to `query`.
+            key_padding_mask: Optional mask of shape (batch, src_len) to ignore padded positions.
+            attn_mask: Optional mask for attention (e.g., causal mask).
+            need_head_weights: If True, return attention weights for each head separately.
+
+        Returns:
+            attn_output: Tensor of shape (tgt_len, batch, embed_dim).
+            attn_weights_out: Attention weights of shape
+                (num_heads, batch, tgt_len, src_len) if per-head,
+                or (batch, tgt_len, src_len) if averaged.
+        """
+
+        tgt_len, bsz, embed_dim = query.shape
+        assert embed_dim == self.embed_dim
+
+        # For self-attention, use query as key and value if not provided
+        if key is None:
+            key = query
+        if value is None:
+            value = query
+
+        # Project queries, keys, values
+        q = self.q_proj(query)
+        k = self.k_proj(key)
+        v = self.v_proj(value)
+
+        q = q * self.scaling
+
+        # Reshape for multi-head attention
+        q = q.reshape(tgt_len, bsz * self.num_heads, self.head_dim).swapaxes(0, 1)
+        k = k.reshape(-1, bsz * self.num_heads, self.head_dim).swapaxes(0, 1)
+        v = v.reshape(-1, bsz * self.num_heads, self.head_dim).swapaxes(0, 1)
+
+        src_len = k.shape[1]
+
+        # Apply rotary embeddings if present
+        if self.rot_emb:
+            q, k = self.rot_emb(q, k)
+
+        # Compute attention weights
+        attn_weights = q @ k.swapaxes(-2, -1)
+
+        assert list(attn_weights.shape) == [bsz * self.num_heads, tgt_len, src_len]
+
+        # Apply attention mask
+        if attn_mask is not None:
+            attn_mask = mx.expand_dims(attn_mask, 0)
+            attn_weights = attn_weights + attn_mask
+
+        # Apply key padding mask
+        if key_padding_mask is not None:
+            attn_weights = attn_weights.reshape(bsz, self.num_heads, tgt_len, src_len)
+            # Convert key_padding_mask to boolean and expand dimensions
+            # key_padding_mask: [bsz, src_len] -> [bsz, 1, 1, src_len]
+            mask = mx.expand_dims(
+                mx.expand_dims(key_padding_mask.astype(mx.bool_), 1), 2
+            )
+            # Apply mask: set attention to -inf where mask is True (padded positions)
+            attn_weights = mx.where(mask, -mx.inf, attn_weights)
+            attn_weights = attn_weights.reshape(bsz * self.num_heads, tgt_len, src_len)
+
+        # Apply softmax
+        attn_weights_float = mx.softmax(attn_weights.astype(mx.float32), axis=-1)
+        attn_probs = attn_weights_float
+
+        # Compute attention output
+        attn = attn_probs @ v
+        assert list(attn.shape) == [bsz * self.num_heads, tgt_len, self.head_dim]
+
+        # Reshape output
+        attn = attn.swapaxes(0, 1).reshape(tgt_len, bsz, embed_dim)
+        attn = self.out_proj(attn)
+
+        # Return attention weights if requested
+        attn_weights_out: Optional[mx.array] = None
+        if need_head_weights:
+            # Return attention weights for each head separately
+            attn_weights_out = (
+                attn_weights_float.reshape(bsz, self.num_heads, tgt_len, src_len)
+                .astype(attn.dtype)
+                .swapaxes(0, 1)
+            )
+        else:
+            # Return averaged attention weights
+            attn_weights_out = mx.mean(
+                attn_weights_float.reshape(bsz, self.num_heads, tgt_len, src_len),
+                axis=1,
+            ).astype(attn.dtype)
+
+        return attn, attn_weights_out
diff --git a/esm/esm/model.py b/esm/esm/model.py
new file mode 100644
index 00000000..83185aee
--- /dev/null
+++ b/esm/esm/model.py
@@ -0,0 +1,340 @@
+import json
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+import mlx.core as mx
+import mlx.nn as nn
+
+from .modules import ContactPredictionHead, RobertaLMHead, TransformerLayer
+from .tokenizer import ProteinTokenizer
+
+
+class ESM2(nn.Module):
+    """
+    ESM-2 protein language model in MLX.
+
+    Args:
+        num_layers (int): Number of transformer layers.
+        embed_dim (int): Embedding dimension.
+        attention_heads (int): Number of attention heads.
+        tokenizer (Optional[ProteinTokenizer]): Tokenizer to use (created if None).
+        token_dropout (bool): Apply token-dropout masking behavior.
+    """
+
+    def __init__(
+        self,
+        num_layers: int = 33,
+        embed_dim: int = 1280,
+        attention_heads: int = 20,
+        tokenizer: Optional[ProteinTokenizer] = None,
+        token_dropout: bool = True,
+    ):
+        super().__init__()
+        self.num_layers = num_layers
+        self.embed_dim = embed_dim
+        self.attention_heads = attention_heads
+
+        # Initialize tokenizer
+        if tokenizer is None:
+            tokenizer = ProteinTokenizer()
+        self.tokenizer = tokenizer
+        self.vocab_size = len(tokenizer)
+
+        # Special token IDs / config
+        self.padding_idx = tokenizer.pad_id
+        self.mask_idx = tokenizer.mask_id
+        self.cls_idx = tokenizer.cls_id
+        self.eos_idx = tokenizer.eos_id
+        self.prepend_bos = tokenizer.prepend_bos
+        self.append_eos = tokenizer.append_eos
+        self.token_dropout = token_dropout
+
+        self._init_submodules()
+
+    def _init_submodules(self) -> None:
+        """Initialize embeddings, transformer stack, and output heads."""
+        self.embed_scale = 1
+
+        # Token embeddings
+        self.embed_tokens = nn.Embedding(self.vocab_size, self.embed_dim)
+
+        # Transformer layers (register each layer so MLX tracks parameters)
+        self._layer_indices = list(range(self.num_layers))
+        for i in self._layer_indices:
+            layer = TransformerLayer(
+                self.embed_dim,
+                4 * self.embed_dim,  # FFN dimension = 4×embed_dim
+                self.attention_heads,
+            )
+            setattr(self, f"layer_{i}", layer)
+
+        # Contact prediction head (uses all layers × heads attentions)
+        self.contact_head = ContactPredictionHead(
+            self.num_layers * self.attention_heads,
+            self.prepend_bos,
+            self.append_eos,
+            eos_idx=self.eos_idx,
+        )
+
+        # Final norm + LM head (tied weights)
+        self.emb_layer_norm_after = nn.LayerNorm(self.embed_dim)
+        self.lm_head = RobertaLMHead(
+            embed_dim=self.embed_dim,
+            output_dim=self.vocab_size,
+            weight=self.embed_tokens.weight,
+        )
+
+    def __call__(
+        self,
+        tokens: mx.array,
+        repr_layers: List[int] = [],
+        need_head_weights: bool = False,
+        return_contacts: bool = False,
+    ) -> Dict[str, mx.array]:
+        """
+        Forward pass through ESM-2.
+
+        Args:
+            tokens: Tensor of token IDs with shape (B, T).
+            repr_layers: Layers to return hidden states from (0..num_layers).
+            need_head_weights: If True, return attention weights.
+            return_contacts: If True, compute residue-residue contact probabilities.
+
+        Returns:
+            dict with:
+                logits: (B, T, V)
+                representations: {layer_idx: (B, T, E)}
+                attentions: (B, L, H, T, T) if requested
+                contacts: (B, T', T') if requested
+        """
+        if return_contacts:
+            need_head_weights = True
+
+        # Ensure tokens is 2D (B, T)
+        if tokens.ndim == 1:
+            tokens = mx.expand_dims(tokens, axis=0)
+        assert tokens.ndim == 2
+
+        # Padding mask (B, T)
+        padding_mask = mx.equal(tokens, self.padding_idx)
+
+        # Embed tokens (B, T, E)
+        x = self.embed_scale * self.embed_tokens(tokens)
+
+        # Token dropout: zero masked tokens + rescale based on observed mask ratio
+        if self.token_dropout:
+            # x.masked_fill_((tokens == self.mask_idx).unsqueeze(-1), 0.0)
+            mask_positions = mx.equal(tokens, self.mask_idx)
+            x = mx.where(mask_positions[:, :, None], 0.0, x)
+            
+            # x: B x T x C
+            mask_ratio_train = 0.15 * 0.8
+            src_lengths = mx.sum(~padding_mask, axis=-1)  # Shape: (B,)
+            mask_ratio_observed = mx.sum(mask_positions, axis=-1).astype(x.dtype) / src_lengths  # Shape: (B,)
+            x = x * (1 - mask_ratio_train) / (1 - mask_ratio_observed)[:, None, None]
+
+        # Zero out padding positions
+        if padding_mask.any():
+            x = x * (1 - padding_mask[:, :, None].astype(x.dtype))
+
+        # Track requested representations
+        repr_layers = set(repr_layers)
+        hidden_representations: Dict[int, mx.array] = {}
+        if 0 in repr_layers:
+            hidden_representations[0] = x
+
+        if need_head_weights:
+            attn_weights: List[mx.array] = []
+
+        # (B, T, E) -> (T, B, E) for transformer layers
+        x = mx.swapaxes(x, 0, 1)
+
+        # If no padding anywhere, skip the mask
+        if not padding_mask.any():
+            padding_mask = None
+
+        # Transformer stack
+        for layer_idx in self._layer_indices:
+            layer = getattr(self, f"layer_{layer_idx}")
+            x, attn = layer(
+                x,
+                self_attn_padding_mask=padding_mask,
+                need_head_weights=need_head_weights,
+            )
+
+            # Save hidden representation if requested (store back as (B, T, E))
+            if (layer_idx + 1) in repr_layers:
+                hidden_representations[layer_idx + 1] = mx.swapaxes(x, 0, 1)
+
+            # Save per-layer attentions if requested (H, B, T, T) -> (B, H, T, T)
+            if need_head_weights:
+                attn_weights.append(mx.swapaxes(attn, 0, 1))
+
+        # Final layer norm, back to (B, T, E)
+        x = self.emb_layer_norm_after(x)
+        x = mx.swapaxes(x, 0, 1)
+
+        # Save final hidden if requested
+        if (layer_idx + 1) in repr_layers:
+            hidden_representations[layer_idx + 1] = x
+
+        # Language modeling logits
+        x = self.lm_head(x)
+
+        # Build result dict
+        result: Dict[str, mx.array] = {
+            "logits": x,
+            "representations": hidden_representations,
+        }
+
+        # Collect attentions and optional contacts
+        if need_head_weights:
+            # Stack layers -> (B, L, H, T, T)
+            attentions = mx.stack(attn_weights, axis=1)
+
+            # Mask out padded positions if present
+            if padding_mask is not None:
+                attention_mask = 1 - padding_mask.astype(attentions.dtype)
+                attention_mask = mx.expand_dims(attention_mask, 1) * mx.expand_dims(
+                    attention_mask, 2
+                )
+                attentions = attentions * attention_mask[:, None, None, :, :]
+
+            result["attentions"] = attentions
+
+        # Compute contacts if requested
+        if return_contacts:
+            contacts = self.contact_head(tokens, attentions)
+            result["contacts"] = contacts
+
+        return result
+
+    def predict_contacts(self, tokens: mx.array) -> mx.array:
+        """
+        Predict residue-residue contacts.
+
+        Args:
+            tokens: Tensor of shape (B, T).
+
+        Returns:
+            mx.array: Contact probabilities of shape (B, T', T').
+        """
+        return self(tokens, return_contacts=True)["contacts"]
+
+    def extract_features(
+        self,
+        tokens: mx.array,
+        repr_layers: Optional[List[int]] = None,
+        return_all_hiddens: bool = False,
+    ) -> Dict[int, mx.array]:
+        """
+        Extract hidden representations from selected layers.
+
+        Args:
+            tokens: Tensor of shape (B, T).
+            repr_layers: Layer indices to return (default: last layer).
+            return_all_hiddens: If True, return all layers (0..num_layers).
+
+        Returns:
+            dict: {layer_idx: (B, T, E)} for requested layers.
+        """
+        if return_all_hiddens:
+            repr_layers = list(range(self.num_layers + 1))
+        elif repr_layers is None:
+            repr_layers = [self.num_layers]
+
+        result = self(tokens, repr_layers=repr_layers)
+        return result["representations"]
+
+    def get_sequence_representations(
+        self,
+        tokens: mx.array,
+        layer: int = -1,
+    ) -> mx.array:
+        """
+        Average token representations into a per-sequence embedding.
+
+        Args:
+            tokens: Tensor of shape (B, T).
+            layer: Layer index to use (-1 or num_layers for last).
+
+        Returns:
+            mx.array: Sequence embeddings of shape (B, E).
+        """
+        if layer == -1:
+            layer = self.num_layers
+
+        representations = self.extract_features(tokens, repr_layers=[layer])
+        repr = representations[layer]
+
+        # Mask: non-padding and not CLS; optionally not EOS
+        mask = mx.logical_and(
+            mx.not_equal(tokens, self.padding_idx),
+            mx.not_equal(tokens, self.cls_idx),
+        )
+        if self.append_eos:
+            mask = mx.logical_and(mask, mx.not_equal(tokens, self.eos_idx))
+
+        # Mean over valid positions
+        mask = mask[:, :, None].astype(repr.dtype)
+        masked_repr = repr * mask
+        seq_lens = mx.sum(mask, axis=1, keepdims=True)
+        seq_repr = mx.sum(masked_repr, axis=1) / mx.maximum(seq_lens[:, :, 0], 1.0)
+
+        return seq_repr
+
+    @classmethod
+    def from_pretrained(cls, model_path: str) -> Tuple[ProteinTokenizer, "ESM2"]:
+        """
+        Load model weights and config from a directory.
+
+        Expects:
+            - config.json
+            - model.safetensors
+            - vocab.txt (optional, will use default if not found)
+            - special_tokens_map.json (optional, will use default if not found)
+
+        Args:
+            model_path: Path to directory with weights and config.
+
+        Returns:
+            (tokenizer, model): Initialized tokenizer and ESM2 model.
+        """
+        model_dir = Path(model_path)
+        config_path = model_dir / "config.json"
+        with open(config_path, "r") as f:
+            config = json.load(f)
+
+        # Check for vocab and special tokens files
+        vocab_path = model_dir / "vocab.txt"
+        special_tokens_path = model_dir / "special_tokens_map.json"
+
+        if vocab_path.exists() and special_tokens_path.exists():
+            tokenizer = ProteinTokenizer(
+                vocab_file=str(vocab_path),
+                special_tokens_map_file=str(special_tokens_path),
+            )
+        else:
+            tokenizer = ProteinTokenizer()
+
+        model = cls(
+            num_layers=config["num_hidden_layers"],
+            embed_dim=config["hidden_size"],
+            attention_heads=config["num_attention_heads"],
+            tokenizer=tokenizer,
+            token_dropout=config["token_dropout"],
+        )
+
+        # Load safetensors as nested dict and update model params
+        weights_path = model_dir / "model.safetensors"
+        flat_weights = mx.load(str(weights_path))
+        nested_weights: Dict[str, dict] = {}
+        for key, value in flat_weights.items():
+            parts = key.split(".")
+            cur = nested_weights
+            for p in parts[:-1]:
+                cur = cur.setdefault(p, {})
+            cur[parts[-1]] = value
+
+        model.update(nested_weights)
+        return tokenizer, model
diff --git a/esm/esm/modules.py b/esm/esm/modules.py
new file mode 100644
index 00000000..c44e9fac
--- /dev/null
+++ b/esm/esm/modules.py
@@ -0,0 +1,212 @@
+from typing import Optional
+
+import mlx.core as mx
+import mlx.nn as nn
+
+from .attention import MultiheadAttention
+
+
+def symmetrize(x: mx.array) -> mx.array:
+    """
+    Make a tensor symmetric over its last two dimensions.
+
+    Args:
+        x: Tensor with shape (..., L, L).
+
+    Returns:
+        mx.array: Symmetrized tensor of shape (..., L, L).
+    """
+    # Add tensor to its transpose over the last two dims
+    return x + mx.swapaxes(x, -1, -2)
+
+
+def apc(x: mx.array) -> mx.array:
+    """
+    Apply Average Product Correction (APC) to remove background co-variation.
+
+    Args:
+        x: Tensor with shape (..., L, L).
+
+    Returns:
+        mx.array: APC-corrected tensor of shape (..., L, L).
+    """
+    # Compute row, column, and total sums
+    a1 = mx.sum(x, axis=-1, keepdims=True)
+    a2 = mx.sum(x, axis=-2, keepdims=True)
+    a12 = mx.sum(x, axis=(-1, -2), keepdims=True)
+
+    # Expected co-variation under independence
+    expected = (a1 * a2) / a12
+    return x - expected
+
+
+class TransformerLayer(nn.Module):
+    """
+    Transformer layer used in ESM-2.
+
+    Args:
+        embed_dim (int): Model embedding dimension.
+        ffn_embed_dim (int): Hidden dimension of the feed-forward network.
+        attention_heads (int): Number of attention heads.
+    """
+
+    def __init__(
+        self,
+        embed_dim: int,
+        ffn_embed_dim: int,
+        attention_heads: int,
+    ):
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.ffn_embed_dim = ffn_embed_dim
+        self.attention_heads = attention_heads
+        self._init_submodules()
+
+    def _init_submodules(self) -> None:
+        """Initialize attention, norms, and feed-forward submodules."""
+        self.self_attn = MultiheadAttention(self.embed_dim, self.attention_heads)
+        self.self_attn_layer_norm = nn.LayerNorm(self.embed_dim)
+        self.fc1 = nn.Linear(self.embed_dim, self.ffn_embed_dim)
+        self.fc2 = nn.Linear(self.ffn_embed_dim, self.embed_dim)
+        self.final_layer_norm = nn.LayerNorm(self.embed_dim)
+
+    def __call__(
+        self,
+        x: mx.array,
+        self_attn_mask: Optional[mx.array] = None,
+        self_attn_padding_mask: Optional[mx.array] = None,
+        need_head_weights: bool = False,
+    ):
+        """
+        Forward pass for the Transformer layer.
+
+        Args:
+            x: Tensor of shape (seq_len, batch, embed_dim).
+            self_attn_mask: Optional attention mask.
+            self_attn_padding_mask: Optional padding mask of shape (batch, seq_len).
+            need_head_weights: If True, return per-head attention weights.
+
+        Returns:
+            x: Tensor of shape (seq_len, batch, embed_dim).
+            attn: Attention weights of shape
+                (num_heads, batch, tgt_len, src_len) if per-head,
+                or (batch, tgt_len, src_len) if averaged.
+        """
+        # Self-attention block
+        residual = x
+        x = self.self_attn_layer_norm(x)
+        x, attn = self.self_attn(
+            query=x,
+            key_padding_mask=self_attn_padding_mask,
+            attn_mask=self_attn_mask,
+            need_head_weights=need_head_weights,
+        )
+        x = residual + x
+
+        # Feed-forward block
+        residual = x
+        x = self.final_layer_norm(x)
+        x = nn.gelu(self.fc1(x))
+        x = self.fc2(x)
+        x = residual + x
+
+        return x, attn
+
+
+class RobertaLMHead(nn.Module):
+    """
+    Masked Language Modeling (MLM) head with tied weights.
+
+    Args:
+        embed_dim (int): Embedding dimension of the backbone.
+        output_dim (int): Vocabulary size.
+        weight (mx.array): Embedding weight matrix for tied projection.
+    """
+
+    def __init__(self, embed_dim: int, output_dim: int, weight: mx.array):
+        super().__init__()
+        self.dense = nn.Linear(embed_dim, embed_dim)
+        self.layer_norm = nn.LayerNorm(embed_dim)
+        self.weight = weight
+        self.bias = mx.zeros(output_dim)
+
+    def __call__(self, features: mx.array) -> mx.array:
+        """
+        Forward pass for the MLM head.
+
+        Args:
+            features: Tensor of shape (seq_len, batch, embed_dim).
+
+        Returns:
+            mx.array: Logits of shape (seq_len, batch, output_dim).
+        """
+        # Transform features before projection to vocab
+        x = self.dense(features)
+        x = nn.gelu(x)
+        x = self.layer_norm(x)
+        return mx.matmul(x, self.weight.T) + self.bias
+
+
+class ContactPredictionHead(nn.Module):
+    """
+    Predict residue-residue contact probabilities from attention maps.
+
+    Args:
+        in_features (int): Number of attention channels (layers × heads).
+        prepend_bos (bool): If True, drop BOS/CLS token attentions.
+        append_eos (bool): If True, drop EOS token attentions.
+        bias (bool): Whether the regression layer uses a bias term.
+        eos_idx (Optional[int]): Token ID for EOS; required if append_eos=True.
+    """
+
+    def __init__(
+        self,
+        in_features: int,
+        prepend_bos: bool,
+        append_eos: bool,
+        bias: bool = True,
+        eos_idx: Optional[int] = None,
+    ):
+        super().__init__()
+        self.in_features = in_features
+        self.prepend_bos = prepend_bos
+        self.append_eos = append_eos
+        if append_eos and eos_idx is None:
+            raise ValueError("append_eos=True but eos_idx was not provided.")
+        self.eos_idx = eos_idx
+        self.regression = nn.Linear(in_features, 1, bias=bias)
+
+    def __call__(self, tokens: mx.array, attentions: mx.array) -> mx.array:
+        """
+        Forward pass for contact prediction.
+
+        Args:
+            tokens: Tensor of shape (B, T).
+            attentions: Tensor of shape (B, L, H, T, T).
+
+        Returns:
+            mx.array: Contact probabilities of shape (B, T', T'),
+                where T' = T - [prepend_bos] - [append_eos].
+        """
+        # Remove EOS attentions if requested
+        if self.append_eos:
+            eos_mask = mx.not_equal(tokens, self.eos_idx).astype(attentions.dtype)
+            eos_mask = eos_mask[:, None, :] * eos_mask[:, :, None]
+            attentions = attentions * eos_mask[:, None, None, :, :]
+            attentions = attentions[..., :-1, :-1]
+
+        # Remove BOS attentions if requested
+        if self.prepend_bos:
+            attentions = attentions[..., 1:, 1:]
+
+        # Merge (layers × heads) into channel dimension
+        batch_size, layers, heads, seqlen, _ = attentions.shape
+        attentions = attentions.reshape(batch_size, layers * heads, seqlen, seqlen)
+
+        # Symmetrize and apply APC to enhance contact signal
+        attentions = apc(symmetrize(attentions))
+
+        # Apply logistic regression over channels
+        attentions = mx.transpose(attentions, axes=[0, 2, 3, 1])
+        logits = self.regression(attentions)
+        return nn.sigmoid(mx.squeeze(logits, axis=3))
diff --git a/esm/esm/rotary_embedding.py b/esm/esm/rotary_embedding.py
new file mode 100644
index 00000000..47f458eb
--- /dev/null
+++ b/esm/esm/rotary_embedding.py
@@ -0,0 +1,114 @@
+from typing import Tuple
+
+import mlx.core as mx
+import mlx.nn as nn
+
+
+def rotate_half(x: mx.array) -> mx.array:
+    """
+    Rotate last dimension by splitting into two halves and swapping.
+
+    Args:
+        x: Tensor with even-sized last dimension.
+
+    Returns:
+        mx.array: Tensor of same shape as `x` with halves rotated.
+    """
+    # Split into two equal halves along the last dimension
+    x1, x2 = mx.split(x, 2, axis=-1)
+    # Swap halves and negate the second half
+    return mx.concatenate((-x2, x1), axis=-1)
+
+
+def apply_rotary_pos_emb(x: mx.array, cos: mx.array, sin: mx.array) -> mx.array:
+    """
+    Apply rotary position embeddings to a tensor.
+
+    Args:
+        x: Input tensor of shape (..., seq_len, dim).
+        cos: Cosine embedding table of shape (1, seq_len, dim).
+        sin: Sine embedding table of shape (1, seq_len, dim).
+
+    Returns:
+        mx.array: Tensor with rotary position embeddings applied.
+    """
+    # Trim cos/sin to match the sequence length of x
+    cos = cos[:, : x.shape[-2], :]
+    sin = sin[:, : x.shape[-2], :]
+
+    # Elementwise rotation: (x * cos) + (rotate_half(x) * sin)
+    return (x * cos) + (rotate_half(x) * sin)
+
+
+class RotaryEmbedding(nn.Module):
+    """
+    Rotary position embedding (RoPE) module.
+
+    Args:
+        dim (int): Head dimension size (must be even).
+    """
+
+    def __init__(self, dim: int, *_, **__):
+        super().__init__()
+        # Precompute inverse frequency for each pair of dimensions
+        self.inv_freq = 1.0 / (10000 ** (mx.arange(0, dim, 2).astype(mx.float32) / dim))
+
+        # Cache for cosine/sine tables to avoid recomputation
+        self._seq_len_cached = None
+        self._cos_cached = None
+        self._sin_cached = None
+
+    def _update_cos_sin_tables(
+        self, x: mx.array, seq_dimension: int = 1
+    ) -> Tuple[mx.array, mx.array]:
+        """
+        Compute and cache cos/sin tables for the given sequence length.
+
+        Args:
+            x: Reference tensor for sequence length.
+            seq_dimension: Axis containing the sequence length.
+
+        Returns:
+            Tuple of:
+                cos: Cosine table of shape (1, seq_len, dim).
+                sin: Sine table of shape (1, seq_len, dim).
+        """
+        seq_len = x.shape[seq_dimension]
+        # Only update cache if sequence length has changed
+        if seq_len != self._seq_len_cached:
+            self._seq_len_cached = seq_len
+            # Time steps: shape (seq_len,)
+            t = mx.arange(seq_len).astype(self.inv_freq.dtype)
+            # Outer product between time and inverse frequency
+            freqs = mx.einsum("i,j->ij", t, self.inv_freq)
+            # Duplicate frequencies for cos/sin dimensions
+            emb = mx.concatenate((freqs, freqs), axis=-1)
+
+            self._cos_cached = mx.cos(emb)[None, :, :]
+            self._sin_cached = mx.sin(emb)[None, :, :]
+
+        return self._cos_cached, self._sin_cached
+
+    def __call__(self, q: mx.array, k: mx.array) -> Tuple[mx.array, mx.array]:
+        """
+        Apply rotary position embeddings to queries and keys.
+
+        Args:
+            q: Query tensor of shape (..., seq_len, dim).
+            k: Key tensor of shape (..., seq_len, dim).
+
+        Returns:
+            Tuple of:
+                q_rot: Query tensor with RoPE applied.
+                k_rot: Key tensor with RoPE applied.
+        """
+        # Get (and cache) cos/sin tables based on key sequence length
+        self._cos_cached, self._sin_cached = self._update_cos_sin_tables(
+            k, seq_dimension=-2
+        )
+
+        # Apply rotary embeddings to both q and k
+        return (
+            apply_rotary_pos_emb(q, self._cos_cached, self._sin_cached),
+            apply_rotary_pos_emb(k, self._cos_cached, self._sin_cached),
+        )
diff --git a/esm/esm/tokenizer.py b/esm/esm/tokenizer.py
new file mode 100644
index 00000000..7c8caf58
--- /dev/null
+++ b/esm/esm/tokenizer.py
@@ -0,0 +1,241 @@
+import json
+from pathlib import Path
+from typing import List, Optional, Sequence, Union
+
+import mlx.core as mx
+
+# Canonical amino-acid tokens (IUPAC standard + uncommon variants)
+PROTEIN_TOKENS = [
+    "L",
+    "A",
+    "G",
+    "V",
+    "S",
+    "E",
+    "R",
+    "T",
+    "I",
+    "D",
+    "P",
+    "K",
+    "Q",
+    "N",
+    "F",
+    "Y",
+    "M",
+    "H",
+    "W",
+    "C",
+    "X",
+    "B",
+    "U",
+    "Z",
+    "O",
+    ".",
+    "-",
+]
+
+ArrayLike = Union[List[int], mx.array]
+
+
+class ProteinTokenizer:
+    """
+    Protein sequence tokenizer compatible with ESM-2.
+
+    This class converts protein sequences into token IDs and back, following
+    the vocabulary, special tokens, and formatting rules used by ESM-2.
+    """
+
+    def __init__(
+        self,
+        vocab_file: Optional[str] = None,
+        special_tokens_map_file: Optional[str] = None,
+    ):
+        """
+        Initialize the ProteinTokenizer.
+
+        Args:
+            vocab_file: Optional path to a file containing the vocabulary,
+                one token per line.
+            special_tokens_map_file: Optional path to a JSON file defining
+                special token names and values.
+
+        If both files are provided, they override the default vocabulary and
+        special token mappings. Otherwise, defaults are loaded.
+        """
+
+        # Load vocabulary from files if given, otherwise use built-in defaults
+        if vocab_file and special_tokens_map_file:
+            self._load_from_files(vocab_file, special_tokens_map_file)
+        else:
+            self._load_default_vocab()
+
+        # Create token ↔ ID mappings
+        self.token_to_id = {tok: i for i, tok in enumerate(self.vocab)}
+        self.id_to_token = {i: tok for i, tok in enumerate(self.vocab)}
+
+        # Cache special token IDs
+        self.cls_id = self.token_to_id["<cls>"]
+        self.pad_id = self.token_to_id["<pad>"]
+        self.eos_id = self.token_to_id["<eos>"]
+        self.unk_id = self.token_to_id["<unk>"]
+        self.mask_id = self.token_to_id["<mask>"]
+
+        # Behavior flags for ESM-2-style BOS/EOS
+        self.prepend_bos = True
+        self.append_eos = True
+
+    def _load_from_files(self, vocab_file: str, special_tokens_map_file: str) -> None:
+        """Load vocabulary and special tokens from the provided files."""
+        # Vocabulary file: one token per line
+        vocab_path = Path(vocab_file)
+        with open(vocab_path, "r", encoding="utf-8") as f:
+            self.vocab = [line.strip() for line in f if line.strip()]
+
+        # Special tokens mapping file (JSON)
+        special_tokens_path = Path(special_tokens_map_file)
+        with open(special_tokens_path, "r", encoding="utf-8") as f:
+            self.special_tokens_map = json.load(f)
+
+    def _load_default_vocab(self) -> None:
+        """Load the built-in ESM vocabulary and special token mapping."""
+        # ESM convention: prepend special tokens, then amino acids, then <mask>
+        prepend_toks = ["<cls>", "<pad>", "<eos>", "<unk>"]
+        append_toks = ["<mask>"]
+
+        self.vocab = prepend_toks + PROTEIN_TOKENS
+
+        # Pad vocab size to multiple of 8 (original implementation detail)
+        while len(self.vocab) % 8 != 0:
+            self.vocab.append(f"<null_{len(self.vocab) - len(prepend_toks)}>")
+
+        self.vocab.extend(append_toks)
+
+        # Default special tokens map
+        self.special_tokens_map = {
+            "cls_token": "<cls>",
+            "pad_token": "<pad>",
+            "eos_token": "<eos>",
+            "unk_token": "<unk>",
+            "mask_token": "<mask>",
+        }
+
+    def encode(
+        self,
+        sequence: str,
+        *,
+        add_special_tokens: bool = True,
+        return_batch_dim: bool = False,
+        dtype=mx.int32,
+    ) -> mx.array:
+        """
+        Convert a protein sequence into token IDs.
+
+        Args:
+            sequence: Protein sequence (case-insensitive).
+            add_special_tokens: If True, add <cls> at the start and <eos> at the end.
+            return_batch_dim: If True, output shape will be (1, L) instead of (L,).
+            dtype: MLX dtype for the returned array.
+
+        Returns:
+            mx.array: Token IDs of shape (L,) or (1, L).
+        """
+        ids: List[int] = []
+
+        if add_special_tokens and self.prepend_bos:
+            ids.append(self.cls_id)
+
+        # Map each residue to its ID (defaulting to <unk> if not in vocab)
+        for ch in sequence.upper():
+            ids.append(self.token_to_id.get(ch, self.unk_id))
+
+        if add_special_tokens and self.append_eos:
+            ids.append(self.eos_id)
+
+        arr = mx.array(ids, dtype=dtype)
+        return mx.expand_dims(arr, axis=0) if return_batch_dim else arr
+
+    def batch_encode(
+        self,
+        sequences: Sequence[str],
+        *,
+        add_special_tokens: bool = True,
+        max_length: Optional[int] = None,
+        dtype=mx.int32,
+    ) -> mx.array:
+        """
+        Encode multiple protein sequences into a padded batch.
+
+        Args:
+            sequences: List/sequence of protein strings.
+            add_special_tokens: If True, add <cls> and <eos> tokens.
+            max_length: If provided, truncate sequences to this length before padding.
+            dtype: MLX dtype for the returned array.
+
+        Returns:
+            mx.array: Tensor of shape (B, L) with right-padding using <pad> IDs.
+        """
+        # Encode each sequence as (L,)
+        encoded = [
+            self.encode(s, add_special_tokens=add_special_tokens, dtype=dtype)
+            for s in sequences
+        ]
+        encoded = [e if e.ndim == 1 else e[0] for e in encoded]
+
+        if max_length is not None:
+            encoded = [e[:max_length] for e in encoded]
+
+        # Find the longest sequence and right-pad all others
+        max_len = max((int(e.shape[0]) for e in encoded), default=0)
+        padded = []
+        for e in encoded:
+            pad_len = max_len - int(e.shape[0])
+            if pad_len > 0:
+                pad = mx.full((pad_len,), self.pad_id, dtype=dtype)
+                e = mx.concatenate([e, pad], axis=0)
+            padded.append(e)
+
+        return mx.stack(padded, axis=0) if padded else mx.array([], dtype=dtype)
+
+    def decode(
+        self,
+        token_ids: ArrayLike,
+        *,
+        skip_special_tokens: bool = False,
+    ) -> str:
+        """
+        Convert token IDs back into a protein sequence string.
+
+        Args:
+            token_ids: 1-D or 2-D array/list of IDs. If 2-D, only the first row is decoded.
+            skip_special_tokens: If True, remove all special tokens from output.
+
+        Returns:
+            str: Protein sequence.
+        """
+        # Normalize to a 1-D MLX array
+        if hasattr(token_ids, "shape") and hasattr(token_ids, "tolist"):
+            ids = token_ids if token_ids.ndim == 1 else token_ids[0]
+        else:
+            ids = mx.array(token_ids, dtype=mx.int32)
+
+        ids_list = [int(x) for x in ids.tolist()]
+        toks: List[str] = []
+
+        for i in ids_list:
+            tok = self.id_to_token.get(i, "<unk>")
+            if skip_special_tokens and tok in {
+                "<cls>",
+                "<pad>",
+                "<eos>",
+                "<unk>",
+                "<mask>",
+            }:
+                continue
+            toks.append(tok)
+
+        return "".join(toks)
+
+    def __len__(self) -> int:
+        """Return the size of the tokenizer’s vocabulary."""
+        return len(self.vocab)
diff --git a/esm/main.py b/esm/main.py
new file mode 100644
index 00000000..9480a03f
--- /dev/null
+++ b/esm/main.py
@@ -0,0 +1,81 @@
+import argparse
+
+import mlx.core as mx
+
+from esm import ESM2
+
+
+def main():
+    parser = argparse.ArgumentParser(description="ESM-2 MLX Inference")
+    parser.add_argument(
+        "--model-path",
+        default="checkpoints/mlx-esm2_t33_650M_UR50D",
+        help="Path to MLX model checkpoint",
+    )
+    parser.add_argument(
+        "--sequence",
+        default="MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+        help="Protein sequence to test (default: human insulin)",
+    )
+    parser.add_argument(
+        "--mask-position",
+        type=int,
+        default=None,
+        help="Position to mask (default: middle of sequence)",
+    )
+    args = parser.parse_args()
+
+    # Load pretrained ESM-2 model and tokenizer
+    tokenizer, model = ESM2.from_pretrained(args.model_path)
+
+    # Determine sequence and position to mask
+    sequence = args.sequence.upper()
+    mask_pos = (
+        args.mask_position if args.mask_position is not None else len(sequence) // 2
+    )
+    if mask_pos >= len(sequence):
+        mask_pos = len(sequence) - 1
+    original_aa = sequence[mask_pos]  # The original amino acid at masked position
+
+    # Display input info
+    print(f"Original sequence: {sequence}")
+    print(f"Masked sequence: {sequence[:mask_pos]}<mask>{sequence[mask_pos+1:]}")
+    print(f"Predicting position {mask_pos}: {original_aa}\n")
+
+    # Tokenize sequence before and after the mask
+    before = tokenizer.encode(sequence[:mask_pos], add_special_tokens=False)
+    after = tokenizer.encode(sequence[mask_pos + 1 :], add_special_tokens=False)
+
+    # Build token sequence with <cls>, <mask>, and <eos>
+    tokens = mx.array(
+        [
+            [tokenizer.cls_id]
+            + before.tolist()
+            + [tokenizer.mask_id]
+            + after.tolist()
+            + [tokenizer.eos_id]
+        ]
+    )
+    mask_token_pos = 1 + len(before)  # Position of <mask> token
+
+    # Run model to get logits for each token position
+    logits = model(tokens)["logits"]
+    probs = mx.softmax(
+        logits[0, mask_token_pos, :]
+    )  # Softmax over vocabulary at mask position
+
+    # Get top-5 most likely tokens
+    top_indices = mx.argsort(probs)[-5:][::-1]
+
+    # Print predictions
+    print("Top predictions:")
+    for i, idx in enumerate(top_indices):
+        token = tokenizer.vocab[int(idx)]
+        if token in tokenizer.vocab:
+            prob = float(probs[idx])
+            marker = "✓" if token == original_aa else " "
+            print(f"{marker} {i+1}. {token}: {prob:.3f} ({prob*100:.1f}%)")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/esm/notebooks/contact_prediction.ipynb b/esm/notebooks/contact_prediction.ipynb
new file mode 100644
index 00000000..be6dddca
--- /dev/null
+++ b/esm/notebooks/contact_prediction.ipynb
@@ -0,0 +1,602 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "3fbacbe4",
+   "metadata": {},
+   "source": [
+    "## Predicting Protein Contacts with ESM-2\n",
+    "\n",
+    "Understanding how amino acids interact within a folded protein is essential for grasping protein function and stability. Contact prediction, the task of identifying which residues are close together in three-dimensional space, is a key step in the sequence to structure process. ESM-2’s learned attention patterns capture evolutionary signals that encode structural information, which allows the model to predict residue contacts directly from sequence data.\n",
+    "\n",
+    "In this notebook, we'll explore ESM-2's ability to predict protein contacts across three diverse proteins from different organisms:\n",
+    "\n",
+    "**Bacterial Transport:**\n",
+    "- **1a3a (PTS Mannitol Component)**: A phosphoenolpyruvate-dependent sugar phosphotransferase system component from *E. coli*, essential for carbohydrate metabolism\n",
+    "\n",
+    "**Stress Response:**\n",
+    "- **5ahw (Universal Stress Protein)**: A conserved stress response protein from *Mycolicibacterium smegmatis* that helps cells survive harsh conditions\n",
+    "\n",
+    "**Human Metabolism:**\n",
+    "- **1xcr (Ester Hydrolase)**: A human enzyme (C11orf54) involved in lipid metabolism and cellular signaling pathways\n",
+    "\n",
+    "We will evaluate how effectively ESM-2 captures the structural relationships present in these sequences, measuring precision across different sequence separation ranges to assess both local and long-range contact prediction performance. This notebook is a modified version of a [notebook by the same name](https://github.com/facebookresearch/esm/blob/main/examples/contact_prediction.ipynb) from the [offical ESM repsitory](https://github.com/facebookresearch/esm)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "08352b12",
+   "metadata": {},
+   "source": [
+    "### Setup\n",
+    "\n",
+    "Here we import all neccessary libraries."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c1047c94",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31mRunning cells with '.venv (Python 3.11.13)' requires the ipykernel package.\n",
+      "\u001b[1;31mInstall 'ipykernel' into the Python environment. \n",
+      "\u001b[1;31mCommand: '/Users/vincent/Developer/mlx-examples/.venv/bin/python -m pip install ipykernel -U --force-reinstall'"
+     ]
+    }
+   ],
+   "source": [
+    "from typing import List, Tuple, Optional, Dict\n",
+    "import string\n",
+    "\n",
+    "import mlx.core as mx\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "from scipy.spatial.distance import squareform, pdist\n",
+    "import biotite.structure as bs\n",
+    "from biotite.database import rcsb\n",
+    "from biotite.structure.io.pdbx import CIFFile, get_structure\n",
+    "from Bio import SeqIO"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5f0af076",
+   "metadata": {},
+   "source": [
+    "Download multiple sequence alignment (MSA) files for our three test proteins from the ESM repository."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3264b66d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!mkdir -p data\n",
+    "!curl -o data/1a3a_1_A.a3m https://raw.githubusercontent.com/facebookresearch/esm/main/examples/data/1a3a_1_A.a3m\n",
+    "!curl -o data/5ahw_1_A.a3m https://raw.githubusercontent.com/facebookresearch/esm/main/examples/data/5ahw_1_A.a3m\n",
+    "!curl -o data/1xcr_1_A.a3m https://raw.githubusercontent.com/facebookresearch/esm/main/examples/data/1xcr_1_A.a3m"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cbf1d0cb",
+   "metadata": {},
+   "source": [
+    "### Loading the model\n",
+    "\n",
+    "Load the ESM-2 model. Here we will use the 650M parameter version. Change the path below to point to your converted checkpoint."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4406e8a0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "sys.path.append(\"..\")\n",
+    "\n",
+    "from esm import ESM2\n",
+    "\n",
+    "esm_checkpoint = \"../checkpoints/mlx-esm2_t33_650M_UR50D\"\n",
+    "tokenizer, model = ESM2.from_pretrained(esm_checkpoint)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "77596456",
+   "metadata": {},
+   "source": [
+    "### Defining functions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eb5f07ed",
+   "metadata": {},
+   "source": [
+    "#### Parsing alignments"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e754abd7",
+   "metadata": {},
+   "source": [
+    "This function parses multiple sequence alignment files and clean up insertion artifacts. MSA files often contain lowercase letters and special characters (`.`, `*`) to indicate insertions relative to the reference sequence - these need to be removed to get the core aligned sequences."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "43717bea",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "deletekeys = dict.fromkeys(string.ascii_lowercase)\n",
+    "deletekeys[\".\"] = None\n",
+    "deletekeys[\"*\"] = None\n",
+    "translation = str.maketrans(deletekeys)\n",
+    "\n",
+    "def read_sequence(filename: str) -> Tuple[str, str]:\n",
+    "    \"\"\" Reads the first (reference) sequences from a fasta or MSA file.\"\"\"\n",
+    "    record = next(SeqIO.parse(filename, \"fasta\"))\n",
+    "    return record.description, str(record.seq)\n",
+    "\n",
+    "def remove_insertions(sequence: str) -> str:\n",
+    "    \"\"\" Removes any insertions into the sequence. Needed to load aligned sequences in an MSA. \"\"\"\n",
+    "    return sequence.translate(translation)\n",
+    "\n",
+    "def read_msa(filename: str) -> List[Tuple[str, str]]:\n",
+    "    \"\"\" Reads the sequences from an MSA file, automatically removes insertions.\"\"\"\n",
+    "    return [(record.description, remove_insertions(str(record.seq))) for record in SeqIO.parse(filename, \"fasta\")]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "628d7de1",
+   "metadata": {},
+   "source": [
+    "#### Converting structures to contacts\n",
+    "\n",
+    "There are many ways to define a protein contact. Here we're using the definition of 8 angstroms between carbon beta atoms. Note that the position of the carbon beta is imputed from the position of the N, CA, and C atoms for each residue."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "21e0b44b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def extend(a, b, c, L, A, D):\n",
+    "    \"\"\"\n",
+    "    input:  3 coords (a,b,c), (L)ength, (A)ngle, and (D)ihedral\n",
+    "    output: 4th coord\n",
+    "    \"\"\"\n",
+    "    def normalize(x):\n",
+    "        return x / np.linalg.norm(x, ord=2, axis=-1, keepdims=True)\n",
+    "\n",
+    "    bc = normalize(b - c)\n",
+    "    n = normalize(np.cross(b - a, bc))\n",
+    "    m = [bc, np.cross(n, bc), n]\n",
+    "    d = [L * np.cos(A), L * np.sin(A) * np.cos(D), -L * np.sin(A) * np.sin(D)]\n",
+    "    return c + sum([m * d for m, d in zip(m, d)])\n",
+    "\n",
+    "def contacts_from_pdb(\n",
+    "    structure: bs.AtomArray,\n",
+    "    distance_threshold: float = 8.0,\n",
+    "    chain: Optional[str] = None,\n",
+    ") -> np.ndarray:\n",
+    "    \"\"\"Extract contacts from PDB structure.\"\"\"\n",
+    "    mask = ~structure.hetero\n",
+    "    if chain is not None:\n",
+    "        mask &= structure.chain_id == chain\n",
+    "\n",
+    "    N = structure.coord[mask & (structure.atom_name == \"N\")]\n",
+    "    CA = structure.coord[mask & (structure.atom_name == \"CA\")]\n",
+    "    C = structure.coord[mask & (structure.atom_name == \"C\")]\n",
+    "\n",
+    "    Cbeta = extend(C, N, CA, 1.522, 1.927, -2.143)\n",
+    "    dist = squareform(pdist(Cbeta))\n",
+    "    \n",
+    "    contacts = dist < distance_threshold\n",
+    "    contacts = contacts.astype(np.int64)\n",
+    "    contacts[np.isnan(dist)] = -1\n",
+    "    return contacts"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5473f306",
+   "metadata": {},
+   "source": [
+    "#### Computing contact precisions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e361a9f3",
+   "metadata": {},
+   "source": [
+    "Calculate precision metrics to evaluate contact prediction quality. The `compute_precisions` function ranks predicted contacts by confidence and measures how many of the top predictions are true contacts, while `evaluate_prediction` breaks this down by sequence separation ranges (local, short, medium, long-range) since predicting distant contacts is typically much harder than nearby ones."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "62c37bbd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def compute_precisions(\n",
+    "    predictions: mx.array,\n",
+    "    targets: mx.array,\n",
+    "    minsep: int = 6,\n",
+    "    maxsep: Optional[int] = None,\n",
+    "    override_length: Optional[int] = None,\n",
+    ") -> Dict[str, mx.array]:\n",
+    "    \"\"\"Compute precision metrics for contact prediction.\"\"\"\n",
+    "    batch_size, seqlen, _ = predictions.shape\n",
+    "    \n",
+    "    if maxsep is not None:\n",
+    "        sep_mask_2d = mx.abs(mx.arange(seqlen)[None, :] - mx.arange(seqlen)[:, None]) <= maxsep\n",
+    "        targets = targets * sep_mask_2d[None, :]\n",
+    "    \n",
+    "    targets = targets.astype(mx.float32)\n",
+    "    src_lengths = (targets >= 0).sum(axis=-1).sum(axis=-1).astype(mx.float32)\n",
+    "    \n",
+    "    x_ind, y_ind = [], []\n",
+    "    for i in range(seqlen):\n",
+    "        for j in range(i + minsep, seqlen):\n",
+    "            x_ind.append(i)\n",
+    "            y_ind.append(j)\n",
+    "    \n",
+    "    x_ind = mx.array(x_ind)\n",
+    "    y_ind = mx.array(y_ind)\n",
+    "    \n",
+    "    predictions_upper = predictions[:, x_ind, y_ind]\n",
+    "    targets_upper = targets[:, x_ind, y_ind]\n",
+    "\n",
+    "    topk = seqlen if override_length is None else max(seqlen, override_length)\n",
+    "    indices = mx.argsort(predictions_upper, axis=-1)[:, ::-1][:, :topk]\n",
+    "    \n",
+    "    batch_indices = mx.arange(batch_size)[:, None]\n",
+    "    topk_targets = targets_upper[batch_indices, indices]\n",
+    "    \n",
+    "    if topk_targets.shape[1] < topk:\n",
+    "        pad_shape = (topk_targets.shape[0], topk - topk_targets.shape[1])\n",
+    "        padding = mx.zeros(pad_shape)\n",
+    "        topk_targets = mx.concatenate([topk_targets, padding], 1)\n",
+    "\n",
+    "    cumulative_dist = mx.cumsum(topk_targets, -1)\n",
+    "\n",
+    "    gather_lengths = src_lengths[:, None]\n",
+    "    if override_length is not None:\n",
+    "        gather_lengths = override_length * mx.ones_like(gather_lengths)\n",
+    "\n",
+    "    precision_fractions = mx.arange(0.1, 1.1, 0.1)\n",
+    "    gather_indices = (precision_fractions[None, :] * gather_lengths) - 1\n",
+    "    gather_indices = mx.clip(gather_indices, 0, cumulative_dist.shape[1] - 1)\n",
+    "    gather_indices = gather_indices.astype(mx.int32)\n",
+    "\n",
+    "    binned_cumulative_dist = cumulative_dist[batch_indices, gather_indices]\n",
+    "    binned_precisions = binned_cumulative_dist / (gather_indices + 1)\n",
+    "\n",
+    "    pl5 = binned_precisions[:, 1]\n",
+    "    pl2 = binned_precisions[:, 4]\n",
+    "    pl = binned_precisions[:, 9]\n",
+    "    auc = binned_precisions.mean(-1)\n",
+    "\n",
+    "    return {\"AUC\": auc, \"P@L\": pl, \"P@L2\": pl2, \"P@L5\": pl5}\n",
+    "\n",
+    "def evaluate_prediction(\n",
+    "    predictions: mx.array,\n",
+    "    targets: mx.array,\n",
+    ") -> Dict[str, float]:\n",
+    "    \"\"\"Evaluate contact predictions across different sequence separation ranges.\"\"\"\n",
+    "    contact_ranges = [\n",
+    "        (\"local\", 3, 6),\n",
+    "        (\"short\", 6, 12),\n",
+    "        (\"medium\", 12, 24),\n",
+    "        (\"long\", 24, None),\n",
+    "    ]\n",
+    "    metrics = {}\n",
+    "    \n",
+    "    for name, minsep, maxsep in contact_ranges:\n",
+    "        rangemetrics = compute_precisions(\n",
+    "            predictions,\n",
+    "            targets,\n",
+    "            minsep=minsep,\n",
+    "            maxsep=maxsep,\n",
+    "        )\n",
+    "        for key, val in rangemetrics.items():\n",
+    "            metrics[f\"{name}_{key}\"] = float(val[0])\n",
+    "    return metrics"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5873e052",
+   "metadata": {},
+   "source": [
+    "#### Predicting contacts"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2d5778a9",
+   "metadata": {},
+   "source": [
+    "This function wraps the tokenization and model inference steps, converting a raw amino acid sequence into token IDs and passing them through ESM-2's contact prediction head to produce a contact probability matrix."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dddf31a7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def predict_contacts(sequence: str, model, tokenizer) -> mx.array:\n",
+    "    \"\"\" Predict contacts for a given sequence \"\"\"\n",
+    "    tokens = tokenizer.encode(sequence)\n",
+    "    contacts = model.predict_contacts(tokens)\n",
+    "    return contacts"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "62562401",
+   "metadata": {},
+   "source": [
+    "#### Plotting results\n",
+    "\n",
+    "This function visualizes contacts as a symmetric matrix where both axes index residue positions. The lower triangle shows the model’s confidence as a blue heatmap, with darker cells indicating higher confidence. The upper triangle overlays evaluation markers: blue dots are correctly predicted contacts (true positives), red dots are predicted but not real (false positives), and grey dots are real contacts the model missed (false negatives)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "03e03791",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_contacts_and_predictions(\n",
+    "    predictions: mx.array,\n",
+    "    contacts: np.ndarray,\n",
+    "    ax,\n",
+    "    title: str,\n",
+    "    cmap: str = \"Blues\",\n",
+    "    ms: float = 1,\n",
+    "):\n",
+    "    \"\"\"Plot contact predictions and true contacts.\"\"\"\n",
+    "    if isinstance(predictions, mx.array):\n",
+    "        predictions = np.array(predictions)\n",
+    "    \n",
+    "    seqlen = contacts.shape[0]\n",
+    "    relative_distance = np.add.outer(-np.arange(seqlen), np.arange(seqlen))\n",
+    "    bottom_mask = relative_distance < 0\n",
+    "    masked_image = np.ma.masked_where(bottom_mask, predictions)\n",
+    "    invalid_mask = np.abs(np.add.outer(np.arange(seqlen), -np.arange(seqlen))) < 6\n",
+    "    predictions_copy = predictions.copy()\n",
+    "    predictions_copy[invalid_mask] = float(\"-inf\")\n",
+    "\n",
+    "    topl_val = np.sort(predictions_copy.reshape(-1))[-seqlen]\n",
+    "    pred_contacts = predictions_copy >= topl_val\n",
+    "    true_positives = contacts & pred_contacts & ~bottom_mask\n",
+    "    false_positives = ~contacts & pred_contacts & ~bottom_mask\n",
+    "    other_contacts = contacts & ~pred_contacts & ~bottom_mask\n",
+    "\n",
+    "    ax.imshow(masked_image, cmap=cmap)\n",
+    "    ax.plot(*np.where(other_contacts), \"o\", c=\"grey\", ms=ms)\n",
+    "    ax.plot(*np.where(false_positives), \"o\", c=\"r\", ms=ms)\n",
+    "    ax.plot(*np.where(true_positives), \"o\", c=\"b\", ms=ms)\n",
+    "    ax.set_title(title)\n",
+    "    ax.axis(\"square\")\n",
+    "    ax.set_xlim([0, seqlen])\n",
+    "    ax.set_ylim([0, seqlen])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9364c984",
+   "metadata": {},
+   "source": [
+    "### Predict and visualize\n",
+    "Here we'll use ESM-2 contact prediction on our three test proteins and evaluate the results. We'll compute precision metrics across different sequence separation ranges and create contact maps that visualize both the model's predictions and how well they match the true protein structures."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9fa9e59e",
+   "metadata": {},
+   "source": [
+    "#### Read Data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7da50dc2",
+   "metadata": {},
+   "source": [
+    "Load experimental protein structures from the Protein Data Bank and extract true contact maps for evaluation, while also parsing the reference sequences from our MSA files that will serve as input to ESM-2."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2d276137",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "PDB_IDS = [\"1a3a\", \"5ahw\", \"1xcr\"]\n",
+    "\n",
+    "structures = {\n",
+    "    name.lower(): get_structure(CIFFile.read(rcsb.fetch(name, \"cif\")))[0]\n",
+    "    for name in PDB_IDS\n",
+    "}\n",
+    "\n",
+    "contacts = {\n",
+    "    name: contacts_from_pdb(structure, chain=\"A\") \n",
+    "    for name, structure in structures.items()\n",
+    "}\n",
+    "\n",
+    "msas = {\n",
+    "    name: read_msa(f\"data/{name.lower()}_1_A.a3m\")\n",
+    "    for name in PDB_IDS\n",
+    "}\n",
+    "\n",
+    "sequences = {\n",
+    "    name: msa[0] for name, msa in msas.items()\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4ce64f18",
+   "metadata": {},
+   "source": [
+    "#### ESM-2 predictions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1f2da88f",
+   "metadata": {},
+   "source": [
+    "##### Evaluate predictions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0adb0a11",
+   "metadata": {},
+   "source": [
+    "This loop generates contact predictions for each protein using ESM-2, compares them against the experimentally determined structures, and computes precision metrics across different sequence separation ranges to evaluate model performance."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "941b4afa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "predictions = {}\n",
+    "results = []\n",
+    "\n",
+    "for pdb_id in sequences:\n",
+    "    _, sequence = sequences[pdb_id]\n",
+    "    prediction = predict_contacts(sequence, model, tokenizer)\n",
+    "    predictions[pdb_id] = prediction[0]\n",
+    " \n",
+    "    true_contacts = mx.array(contacts[pdb_id])\n",
+    "    \n",
+    "    min_len = min(prediction.shape[1], true_contacts.shape[0])\n",
+    "    pred_trimmed = prediction[:, :min_len, :min_len]\n",
+    "    true_trimmed = true_contacts[:min_len, :min_len]\n",
+    "    true_trimmed = mx.expand_dims(true_trimmed, axis=0)\n",
+    "    \n",
+    "    metrics = evaluate_prediction(pred_trimmed, true_trimmed)\n",
+    "    result = {\"id\": pdb_id, \"model\": \"ESM-2 (Unsupervised)\"}\n",
+    "    result.update(metrics)\n",
+    "    results.append(result)\n",
+    "\n",
+    "results_df = pd.DataFrame(results)\n",
+    "display(results_df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c5c7418a",
+   "metadata": {},
+   "source": [
+    "The results demonstrate that ESM-2 excels at predicting long-range contacts, with precision scores ranging from 40.9% to 86.4% for residues more than 24 positions apart. Performance is consistently higher for distant contacts compared to local ones. For example, the universal stress protein (5ahw) achieves 86.4% precision for long-range contacts but only 2.4% for local contacts between 3 and 6 residues apart. This trend is observed across all three proteins, with medium-range contacts (12–24 residues apart) and short-range contacts (6–12 residues apart) showing intermediate accuracy. These results suggest that ESM-2 has learned to identify evolutionarily conserved structural motifs that connect distant regions of the sequence, which are often critical for protein fold stability and function."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "487cff51",
+   "metadata": {},
+   "source": [
+    "##### Plot contacts and predictions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "10291191",
+   "metadata": {},
+   "source": [
+    "This analysis generates contact map visualizations for all three proteins, presenting ESM-2’s predictions as heatmaps and overlaying the true experimental contacts as colored dots."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "628efc10",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "proteins = [r['id'] for r in results]\n",
+    "fig, axes = plt.subplots(figsize=(6 * len(proteins), 6), ncols=len(proteins))\n",
+    "if len(proteins) == 1:\n",
+    "    axes = [axes]\n",
+    "\n",
+    "for ax, pdb_id in zip(axes, proteins):\n",
+    "    prediction = predictions[pdb_id]\n",
+    "    target = contacts[pdb_id]\n",
+    "    \n",
+    "    result = next(r for r in results if r['id'] == pdb_id)\n",
+    "    long_pl = result['long_P@L']\n",
+    "    \n",
+    "    plot_contacts_and_predictions(\n",
+    "        prediction, target, ax=ax, \n",
+    "        title=f\"{pdb_id}: Long Range P@L: {100 * long_pl:.1f}%\"\n",
+    "    )\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "99e1edaf",
+   "metadata": {},
+   "source": [
+    "The contact maps highlight ESM-2’s strong ability to detect long-range structural relationships. In each panel, the lower triangle shows model predictions, where darker blue regions indicate high-confidence contacts, and the upper triangle shows the corresponding experimental data. Correct predictions appear as blue dots, forming distinct off-diagonal patterns in 5ahw and 1a3a that capture key global fold interactions. Red dots mark false positives, which are relatively rare, while grey dots represent missed contacts. These missed contacts are notably more frequent in 1xcr, consistent with its lower long-range precision. The dense clusters of blue true positives in 5ahw, compared to the sparser, fragmented patterns in 1xcr, clearly illustrate the variation in predictive performance across proteins."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/esm/notebooks/embeddings.ipynb b/esm/notebooks/embeddings.ipynb
new file mode 100644
index 00000000..67f60a33
--- /dev/null
+++ b/esm/notebooks/embeddings.ipynb
@@ -0,0 +1,334 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "acfe011d",
+   "metadata": {},
+   "source": [
+    "## Exploring Protein Relationships Through ESM-2 Embeddings\n",
+    "\n",
+    "Proteins are molecular machines with unique structures that determine their functions. ESM-2 treats protein sequences as a language, learning representations that capture evolutionary and functional relationships without relying on traditional sequence alignment.\n",
+    "\n",
+    "In this notebook, we'll explore how ESM-2 embeddings reveal relationships between six human proteins:\n",
+    "\n",
+    "**Oxygen Transport & Storage:**\n",
+    "- **Hemoglobin Beta**: The oxygen-carrying protein in red blood cells, part of the tetrameric hemoglobin complex\n",
+    "- **Myoglobin**: The oxygen storage protein in muscle tissue, structurally similar to individual hemoglobin subunits\n",
+    "\n",
+    "**Antimicrobial Defense:**\n",
+    "- **Cathelicidin (LL-37)**: An antimicrobial peptide that disrupts bacterial membranes and modulates immune responses\n",
+    "- **Defensin Beta 4A**: A small cysteine-rich antimicrobial peptide that directly kills bacteria and other pathogens\n",
+    "\n",
+    "**Structural Support:**\n",
+    "- **Erythroid Alpha-Spectrin**: Forms the flexible scaffolding that gives red blood cells their shape and helps them squeeze through tiny blood vessels\n",
+    "- **Dystrophin**: A massive protein that connects the muscle cell's internal framework to its surroundings, preventing damage during muscle contraction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "20f98f7f",
+   "metadata": {},
+   "source": [
+    "### Setup\n",
+    "\n",
+    "Here we import all neccessary libraries."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "2bacd1ff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import mlx.core as mx\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "from sklearn.decomposition import PCA\n",
+    "from sklearn.manifold import TSNE\n",
+    "import pandas as pd"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5563c495",
+   "metadata": {},
+   "source": [
+    "These are our protein sequences, obtained from [UniProt](https://www.uniprot.org/)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "b8e9d6d2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "proteins = [\n",
+    "    # Oxygen Transport & Storage\n",
+    "    (\"Hemoglobin Beta\", \"MVHLTPEEKSAVTALWGKVNVDEVGGEALGRLLVVYPWTQRFFESFGDLSTPDAVMGNPKVKAHGKKVLGAFSDGLAHLDNLKGTFATLSELHCDKLHVDPENFRLLGNVLVCVLAHHFGKEFTPPVQAAYQKVVAGVANALAHKYH\"),\n",
+    "    (\"Myoglobin\", \"MGLSDGEWQLVLNVWGKVEADIPGHGQEVLIRLFKGHPETLEKFDKFKHLKSEDEMKASEDLKKHGATVLTALGGILKKKGHHEAEIKPLAQSHATKHKIPVKYLEFISECIIQVLQSKHPGDFGADAQGAMNKALELFRKDMASNYKELGFQG\"),\n",
+    "\n",
+    "    # Antimicrobial Defense\n",
+    "    (\"Cathelicidin (LL-37)\", \"MKTQRDGHSLGRWSLVLLLLGLVMPLAIIAQVLSYKEAVLRAIDGINQRSSDANLYRLLDLDPRPTMDGDPDTPKPVSFTVKETVCPRTTQQSPEDCDFKKDGLVKRCMGTVTLNQARGSFDISCDKDNKRFALLGDFFRKSKEKIGKEFKRIVQRIKDFLRNLVPRTES\"),\n",
+    "    (\"Defensin Beta 4A\", \"MRVLYLLFSFLFIFLMPLPGVFGGIGDPVTCLKSGAICHPVFCPRRYKQIGTCGLPGTKCCKKP\"),\n",
+    "\n",
+    "    # Structural Support\n",
+    "    (\"Erythroid Alpha-Spectrin\", \"MEQFPKETVVESSGPKVLETAEEIQERRQEVLTRYQSFKERVAERGQKLEDSYHLQVFKRDADDLGKWIMEKVNILTDKSYEDPTNIQGKYQKHQSLEAEVQTKSRLMSELEKTREERFTMGHSAHEETKAHIEELRHLWDLLLELTLEKGDQLLRALKFQQYVQECADILEWIGDKEAIATSVELGEDWERTEVLHKKFEDFQVELVAKEGRVVEVNQYANECAEENHPDLPLIQSKQNEVNAAWERLRGLALQRQKALSNAANLQRFKRDVTEAIQWIKEKEPVLTSEDYGKDLVASEGLFHSHKGLERNLAVMSDKVKELCAKAEKLTLSHPSDAPQIQEMKEDLVSSWEHIRALATSRYEKLQATYWYHRFSSDFDELSGWMNEKTAAINADELPTDVAGGEVLLDRHQQHKHEIDSYDDRFQSADETGQDLVNANHEASDEVREKMEILDNNWTALLELWDERHRQYEQCLDFHLFYRDSEQVDSWMSRQEAFLENEDLGNSLGSAEALLQKHEDFEEAFTAQEEKIITVDKTATKLIGDDHYDSENIKAIRDGLLARRDALREKAATRRRLLKESLLLQKLYEDSDDLKNWINKKKKLADDEDYKDIQNLKSRVQKQQVFEKELAVNKTQLENIQKTGQEMIEGGHYASDNVTTRLSEVASLWEELLEATKQKGTQLHEANQQLQFENNAEDLQRWLEDVEWQVTSEDYGKGLAEVQNRLRKHGLLESAVAARQDQVDILTDLAAYFEEIGHPDSKDIRARQESLVCRFEALKEPLATRKKKLLDLLHLQLICRDTEDEEAWIQETEPSATSTYLGKDLIASKKLLNRHRVILENIASHEPRIQEITERGNKMVEEGHFAAEDVASRVKSLNQNMESLRARAARRQNDLEANVQFQQYLADLHEAETWIREKEPIVDNTNYGADEEAAGALLKKHEAFLLDLNSFGDSMKALRNQANACQQQQAAPVEGVAGEQRVMALYDFQARSPREVTMKKGDVLTLLSSINKDWWKVEAADHQGIVPAVYVRRLAHDEFPMLPQRRREEPGNITQRQEQIENQYRSLLDRAEERRRRLLQRYNEFLLAYEAGDMLEWIQEKKAENTGVELDDVWELQKKFDEFQKDLNTNEPRLRDINKVADDLLFEGLLTPEGAQIRQELNSRWGSLQRLADEQRQLLGSAHAVEVFHREADDTKEQIEKKCQALSAADPGSDLFSVQALQRRHEGFERDLVPLGDKVTILGETAERLSESHPDATEDLQRQKMELNEAWEDLQGRTKDRKESLNEAQKFYLFLSKARDLQNWISSIGGMVSSQELAEDLTGIEILLERHQEHRADMEAEAPTFQALEDFSAELIDSGHHASPEIEKKLQAVKLERDDLEKAWEKRKKILDQCLELQMFQGNCDQVESWMVARENSLRSDDKSSLDSLEALMKKRDDLDKAITAQEGKITDLEHFAESLIADEHYAKEEIATRLQRVLDRWKALKAQLIDERTKLGDYANLKQFYRDLEELEEWISEMLPTACDESYKDATNIQRKYLKHQTFAHEVDGRSEQVHGVINLGNSLIECSACDGNEEAMKEQLEQLKEHWDHLLERTNDKGKKLNEASRQQRFNTSIRDFEFWLSEAETLLAMKDQARDLASAGNLLKKHQLLEREMLAREDALKDLNTLAEDLLSSGTFNVDQIVKKKDNVNKRFLNVQELAAAHHEKLKEAYALFQFFQDLDDEESWIEEKLIRVSSQDYGRDLQGVQNLLKKHKRLEGELVAHEPAIQNVLDMAEKLKDKAAVGQEEIQLRLAQFVEHWEKLKELAKARGLKLEESLEYLQFMQNAEEEEAWINEKNALAVRGDCGDTLAATQSLLMKHEALENDFAVHETRVQNVCAQGEDILNKVLQEESQNKEISSKIEALNEKTPSLAKAIAAWKLQLEDDYAFQEFNWKADVVEAWIADKETSLKTNGNGADLGDFLTLLAKQDTLDASLQSFQQERLPEITDLKDKLISAQHNQSKAIEERYAALLKRWEQLLEASAVHRQKLLEKQLPLQKAEDLFVEFAHKASALNNWCEKMEENLSEPVHCVSLNEIRQLQKDHEDFLASLARAQADFKCLLELDQQIKALGVPSSPYTWLTVEVLERTWKHLSDIIEEREQELQKEEARQVKNFEMCQEFEQNASTFLQWILETRAYFLDGSLLKETGTLESQLEANKRKQKEIQAMKRQLTKIVDLGDNLEDALILDIKYSTIGLAQQWDQLYQLGLRMQHNLEQQIQAKDIKGVSEETLKEFSTIYKHFDENLTGRLTHKEFRSCLRGLNYYLPMVEEDEHEPKFEKFLDAVDPGRKGYVSLEDYTAFLIDKESENIKSSDEIENAFQALAEGKSYITKEDMKQALTPEQVSFCATHMQQYMDPRGRSHLSGYDYVGFTNSYFGN\"),\n",
+    "    (\"Dystrophin\", \"MLWWEEVEDCYEREDVQKKTFTKWVNAQFSKFGKQHIENLFSDLQDGRRLLDLLEGLTGQKLPKEKGSTRVHALNNVNKALRVLQNNNVDLVNIGSTDIVDGNHKLTLGLIWNIILHWQVKNVMKNIMAGLQQTNSEKILLSWVRQSTRNYPQVNVINFTTSWSDGLALNALIHSHRPDLFDWNSVVCQQSATQRLEHAFNIARYQLGIEKLLDPEDVDTTYPDKKSILMYITSLFQVLPQQVSIEAIQEVEMLPRPPKVTKEEHFQLHHQMHYSQQITVSLAQGYERTSSPKPRFKSYAYTQAAYVTTSDPTRSPFPSQHLEAPEDKSFGSSLMESEVNLDRYQTALEEVLSWLLSAEDTLQAQGEISNDVEVVKDQFHTHEGYMMDLTAHQGRVGNILQLGSKLIGTGKLSEDEETEVQEQMNLLNSRWECLRVASMEKQSNLHRVLMDLQNQKLKELNDWLTKTEERTRKMEEEPLGPDLEDLKRQVQQHKVLQEDLEQEQVRVNSLTHMVVVVDESSGDHATAALEEQLKVLGDRWANICRWTEDRWVLLQDILLKWQRLTEEQCLFSAWLSEKEDAVNKIHTTGFKDQNEMLSSLQKLAVLKADLEKKKQSMGKLYSLKQDLLSTLKNKSVTQKTEAWLDNFARCWDNLVQKLEKSTAQISQAVTTTQPSLTQTTVMETVTTVTTREQILVKHAQEELPPPPPQKKRQITVDSEIRKRLDVDITELHSWITRSEAVLQSPEFAIFRKEGNFSDLKEKVNAIEREKAEKFRKLQDASRSAQALVEQMVNEGVNADSIKQASEQLNSRWIEFCQLLSERLNWLEYQNNIIAFYNQLQQLEQMTTTAENWLKIQPTTPSEPTAIKSQLKICKDEVNRLSDLQPQIERLKIQSIALKEKGQGPMFLDADFVAFTNHFKQVFSDVQAREKELQTIFDTLPPMRYQETMSAIRTWVQQSETKLSIPQLSVTDYEIMEQRLGELQALQSSLQEQQSGLYYLSTTVKEMSKKAPSEISRKYQSEFEEIEGRWKKLSSQLVEHCQKLEEQMNKLRKIQNHIQTLKKWMAEVDVFLKEEWPALGDSEILKKQLKQCRLLVSDIQTIQPSLNSVNEGGQKIKNEAEPEFASRLETELKELNTQWDHMCQQVYARKEALKGGLEKTVSLQKDLSEMHEWMTQAEEEYLERDFEYKTPDELQKAVEEMKRAKEEAQQKEAKVKLLTESVNSVIAQAPPVAQEALKKELETLTTNYQWLCTRLNGKCKTLEEVWACWHELLSYLEKANKWLNEVEFKLKTTENIPGGAEEISEVLDSLENLMRHSEDNPNQIRILAQTLTDGGVMDELINEELETFNSRWRELHEEAVRRQKLLEQSIQSAQETEKSLHLIQESLTFIDKQLAAYIADKVDAAQMPQEAQKIQSDLTSHEISLEEMKKHNQGKEAAQRVLSQIDVAQKKLQDVSMKFRLFQKPANFEQRLQESKMILDEVKMHLPALETKSVEQEVVQSQLNHCVNLYKSLSEVKSEVEMVIKTGRQIVQKKQTENPKELDERVTALKLHYNELGAKVTERKQQLEKCLKLSRKMRKEMNVLTEWLAATDMELTKRSAVEGMPSNLDSEVAWGKATQKEIEKQKVHLKSITEVGEALKTVLGKKETLVEDKLSLLNSNWIAVTSRAEEWLNLLLEYQKHMETFDQNVDHITKWIIQADTLLDESEKKKPQQKEDVLKRLKAELNDIRPKVDSTRDQAANLMANRGDHCRKLVEPQISELNHRFAAISHRIKTGKASIPLKELEQFNSDIQKLLEPLEAEIQQGVNLKEEDFNKDMNEDNEGTVKELLQRGDNLQQRITDERKREEIKIKQQLLQTKHNALKDLRSQRRKKALEISHQWYQYKRQADDLLKCLDDIEKKLASLPEPRDERKIKEIDRELQKKKEELNAVRRQAEGLSEDGAAMAVEPTQIQLSKRWREIESKFAQFRRLNFAQIHTVREETMMVMTEDMPLEISYVPSTYLTEITHVSQALLEVEQLLNAPDLCAKDFEDLFKQEESLKNIKDSLQQSSGRIDIIHSKKTAALQSATPVERVKLQEALSQLDFQWEKVNKMYKDRQGRFDRSVEKWRRFHYDIKIFNQWLTEAEQFLRKTQIPENWEHAKYKWYLKELQDGIGQRQTVVRTLNATGEEIIQQSSKTDASILQEKLGSLNLRWQEVCKQLSDRKKRLEEQKNILSEFQRDLNEFVLWLEEADNIASIPLEPGKEQQLKEKLEQVKLLVEELPLRQGILKQLNETGGPVLVSAPISPEEQDKLENKLKQTNLQWIKVSRALPEKQGEIEAQIKDLGQLEKKLEDLEEQLNHLLLWLSPIRNQLEIYNQPNQEGPFDVKETEIAVQAKQPDVEEILSKGQHLYKEKPATQPVKRKLEDLSSEWKAVNRLLQELRAKQPDLAPGLTTIGASPTQTVTLVTQPVVTKETAISKLEMPSSLMLEVPALADFNRAWTELTDWLSLLDQVIKSQRVMVGDLEDINEMIIKQKATMQDLEQRRPQLEELITAAQNLKNKTSNQEARTIITDRIERIQNQWDEVQEHLQNRRQQLNEMLKDSTQWLEAKEEAEQVLGQARAKLESWKEGPYTVDAIQKKITETKQLAKDLRQWQTNVDVANDLALKLLRDYSADDTRKVHMITENINASWRSIHKRVSEREAALEETHRLLQQFPLDLEKFLAWLTEAETTANVLQDATRKERLLEDSKGVKELMKQWQDLQGEIEAHTDVYHNLDENSQKILRSLEGSDDAVLLQRRLDNMNFKWSELRKKSLNIRSHLEASSDQWKRLHLSLQELLVWLQLKDDELSRQAPIGGDFPAVQKQNDVHRAFKRELKTKEPVIMSTLETVRIFLTEQPLEGLEKLYQEPRELPPEERAQNVTRLLRKQAEEVNTEWEKLNLHSADWQRKIDETLERLRELQEATDELDLKLRQAEVIKGSWQPVGDLLIDSLQDHLEKVKALRGEIAPLKENVSHVNDLARQLTTLGIQLSPYNLSTLEDLNTRWKLLQVAVEDRVRQLHEAHRDFGPASQHFLSTSVQGPWERAISPNKVPYYINHETQTTCWDHPKMTELYQSLADLNNVRFSAYRTAMKLRRLQKALCLDLLSLSAACDALDQHNLKQNDQPMDILQIINCLTTIYDRLEQEHNNLVNVPLCVDMCLNWLLNVYDTGRTGRIRVLSFKTGIISLCKAHLEDKYRYLFKQVASSTGFCDQRRLGLLLHDSIQIPRQLGEVASFGGSNIEPSVRSCFQFANNKPEIEAALFLDWMRLEPQSMVWLPVLHRVAAAETAKHQAKCNICKECPIIGFRYRSLKHFNYDICQSCFFSGRVAKGHKMHYPMVEYCTPTTSGEDVRDFAKVLKNKFRTKRYFAKHPRMGYLPVQTVLEGDNMETPVTLINFWPVDSAPASSPQLSHDDTHSRIEHYASRLAEMENSNGSYLNDSISPNESIDDEHLLIQHYCQSLNQDSPLSQPRSPAQILISLESEERGELERILADLEEENRNLQAEYDRLKQQHEHKGLSPLPSPPEMMPTSPQSPRDAELIAEAKLLRQHKGRLEARMQILEDHNKQLESQLHRLRQLLEQPQAEAKVNGTTVSSPSTSLQRSDSSQPMLLRVVGSQTSDSMGEEDLLSPPQDTSTGLEEVMEQLNNSFPSSRGRNTPGKPMREDTM\"),\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c9621578",
+   "metadata": {},
+   "source": [
+    "### Loading the model and tokenizing a sequence\n",
+    "\n",
+    "Load the ESM-2 model. Here we will use the 650M parameter version. Change the path below to point to your converted checkpoint.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "05696400",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "sys.path.append(\"..\")\n",
+    "\n",
+    "from esm import ESM2\n",
+    "\n",
+    "esm_checkpoint = \"../checkpoints/mlx-esm2_t33_650M_UR50D\"\n",
+    "tokenizer, model = ESM2.from_pretrained(esm_checkpoint)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2916adbb",
+   "metadata": {},
+   "source": [
+    "Here, we tokenize and decode the protein sequence for human Insulin."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "47178dcd",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Sequence: MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN\n",
+      "Tokens: [20, 5, 4, 22, 20, 10, 4, 4, 14, 4, 4, 5, 4, 4, 5, 4, 22, 6, 14, 13, 14, 5, 5, 5, 18, 7, 17, 16, 21, 4, 23, 6, 8, 21, 4, 7, 9, 5, 4, 19, 4, 7, 23, 6, 9, 10, 6, 18, 18, 19, 11, 14, 15, 11, 10, 10, 9, 5, 9, 13, 4, 16, 7, 6, 16, 7, 9, 4, 6, 6, 6, 14, 6, 5, 6, 8, 4, 16, 14, 4, 5, 4, 9, 6, 8, 4, 16, 15, 10, 6, 12, 7, 9, 16, 23, 23, 11, 8, 12, 23, 8, 4, 19, 16, 4, 9, 17, 19, 23, 17]\n",
+      "Decoded: MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN\n"
+     ]
+    }
+   ],
+   "source": [
+    "human_insulin_sequence = \"MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN\"\n",
+    "tokens = tokenizer.encode(human_insulin_sequence, add_special_tokens=False)\n",
+    "print(f\"Sequence: {human_insulin_sequence}\")\n",
+    "print(f\"Tokens: {tokens.tolist()}\")\n",
+    "print(f\"Decoded: {tokenizer.decode(tokens)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c1b73ded",
+   "metadata": {},
+   "source": [
+    "### Embedding sequences\n",
+    "\n",
+    "To compute the embeddings of our proteins, we pass each protein sequence through ESM-2's tokenizer to convert amino acids into token IDs, then extract the final layer representations using `get_sequence_representations()`. This process gives us a vector for each protein that captures its learned functional and evolutionary features."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "cb470957",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def extract_embeddings_batch(model, protein_list):\n",
+    "    \"\"\"Extract embeddings by processing all sequences in a batch.\"\"\"\n",
+    "    sequences = [seq for _, seq in protein_list]\n",
+    "    names = [name for name, _ in protein_list]\n",
+    "    \n",
+    "    tokens = model.tokenizer.batch_encode(sequences, add_special_tokens=True)\n",
+    "    embeddings = model.get_sequence_representations(tokens, layer=-1)\n",
+    "    \n",
+    "    return embeddings, names"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "38e83142",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Embedding shape: (6, 1280)\n",
+      "Each protein represented by 1280 features\n"
+     ]
+    }
+   ],
+   "source": [
+    "embeddings, protein_names = extract_embeddings_batch(model, proteins)\n",
+    "print(f\"\\nEmbedding shape: {embeddings.shape}\")\n",
+    "print(f\"Each protein represented by {embeddings.shape[1]} features\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fccd2a99",
+   "metadata": {},
+   "source": [
+    "### Protein embedding similarity matrix\n",
+    "\n",
+    "We can measure how similar the protein embeddings are by calculating a similarity matrix. We normalize each embedding to unit length and compute cosine similarities between all pairs, producing a matrix where values close to 1 indicate highly similar proteins and values close to 0 indicate dissimilar ones."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "93d14fff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def compute_similarity_matrix(embeddings):\n",
+    "    \"\"\"Compute cosine similarity matrix for embeddings.\"\"\"\n",
+    "    normalized = embeddings / mx.linalg.norm(embeddings, axis=1, keepdims=True)\n",
+    "    similarity_matrix = normalized @ normalized.T\n",
+    "    return similarity_matrix"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "3485f854",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "similarity_matrix = compute_similarity_matrix(embeddings)\n",
+    "\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "similarity_np = np.array(similarity_matrix)\n",
+    "\n",
+    "sim_df = pd.DataFrame(similarity_np, \n",
+    "                     index=protein_names, \n",
+    "                     columns=protein_names)\n",
+    "\n",
+    "sns.heatmap(sim_df, annot=True, cmap='viridis', \n",
+    "           fmt='.3f', square=True, cbar_kws={'label': 'Cosine Similarity'})\n",
+    "plt.title('Protein Similarity Matrix (ESM-2 Embeddings)', fontsize=14)\n",
+    "plt.xticks(rotation=45, ha='right')\n",
+    "plt.yticks(rotation=0)\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1532dfc5",
+   "metadata": {},
+   "source": [
+    "The similarity matrix highlights clear expected relationships. Erythroid Alpha-Spectrin and Dystrophin are most similar (0.982), reflecting their shared role in cytoskeletal support. Hemoglobin Beta and Myoglobin also show high similarity (0.950), consistent with their oxygen-binding functions. Antimicrobial peptides Cathelicidin and Defensin Beta 4A likewise cluster closely (0.955), reflecting their common role in immunity. Alongside these expected patterns, some unexpected similarities appear, such as between Cathelicidin and Dystrophin (0.948) or Hemoglobin Beta and Alpha-Spectrin (0.931). These likely reflect sequence-level motifs or general structural tendencies that the embeddings capture, rather than direct functional relationships."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "66794597",
+   "metadata": {},
+   "source": [
+    "### PCA visualization\n",
+    "\n",
+    "PCA (Principal Component Analysis) reduces high-dimensional data to a lower-dimensional representation by finding the directions of maximum variance in the data. This allows us to visualize our high-dimensional protein embeddings in 2D space while preserving the most important patterns of similarity and difference between proteins."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "67afd74e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pca = PCA(n_components=2)\n",
+    "pca_result = pca.fit_transform(np.array(embeddings))\n",
+    "\n",
+    "plt.figure(figsize=(12, 5))\n",
+    "\n",
+    "plt.subplot(1, 2, 1)\n",
+    "plt.scatter(pca_result[:, 0], pca_result[:, 1], s=100, alpha=0.7)\n",
+    "for i, name in enumerate(protein_names):\n",
+    "    plt.annotate(name, (pca_result[i, 0], pca_result[i, 1]), \n",
+    "                xytext=(5, 5), textcoords='offset points', fontsize=9)\n",
+    "plt.xlabel(f'PC1 ({pca.explained_variance_ratio_[0]:.1%} variance)')\n",
+    "plt.ylabel(f'PC2 ({pca.explained_variance_ratio_[1]:.1%} variance)')\n",
+    "plt.title('PCA of Protein Embeddings')\n",
+    "plt.grid(True, alpha=0.3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4dd24749",
+   "metadata": {},
+   "source": [
+    "The PCA analysis reveals clear groupings among the proteins, with the first two components capturing the majority of the variance in the embeddings. Hemoglobin Beta and Myoglobin cluster tightly in the upper right, reflecting their shared evolutionary history and common role in oxygen transport. Erythroid Alpha-Spectrin and Dystrophin separate into the lower left quadrant, consistent with their related cytoskeletal functions and structural importance in maintaining cell integrity. Cathelicidin and Defensin Beta 4A form another distinct cluster, aligning with their antimicrobial roles in innate immunity. The spatial separation of these groups highlights how the embeddings capture broad functional and structural distinctions, while also showing within-group proximity that reflects biological similarity."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/esm/notebooks/mutation_effect_prediction.ipynb b/esm/notebooks/mutation_effect_prediction.ipynb
new file mode 100644
index 00000000..ac193bb1
--- /dev/null
+++ b/esm/notebooks/mutation_effect_prediction.ipynb
@@ -0,0 +1,662 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "d28ac072",
+   "metadata": {},
+   "source": [
+    "## Zero-Shot Mutation Effect Prediction with ESM-2\n",
+    "\n",
+    "Protein function depends on its amino acid sequence, and even one change can alter activity, stability, or binding. Traditional methods to study these effects are costly and slow. ESM-2 offers a faster alternative, predicting mutation impacts from sequence alone. Trained on millions of proteins with masked language modeling, it learns which substitutions preserve function and stability from evolutionary patterns.\n",
+    "\n",
+    "In this notebook, we'll be scoring mutations, meaning we will quantify how much each amino acid change is predicted to affect the protein’s function or stability.\n",
+    "\n",
+    "To score a mutation, we:\n",
+    "1. **Mask** the position of interest in the protein sequence\n",
+    "2. **Predict** probabilities for all 20 amino acids at that position  \n",
+    "3. **Compare** the probabilities of the wild-type vs. mutant amino acid\n",
+    "4. **Calculate** a log-likelihood ratio (LLR) score\n",
+    "\n",
+    "**Negative scores** indicate deleterious mutations (model assigns lower probability to the mutant), while **positive scores** suggest beneficial or neutral changes.\n",
+    "\n",
+    "We'll demonstrate mutation effect prediction using **β-lactamase TEM from *E. coli***, a clinically important antibiotic resistance enzyme. This protein hydrolyzes β-lactam antibiotics and is one of the most common resistance mechanisms in clinical isolates. TEM-1 was extensively characterized through deep mutational scanning by [Stiffler et al. (2015)](https://www.cell.com/fulltext/S0092-8674%2815%2900078-1), who measured the fitness effects of nearly 5,000 single amino acid mutations. We'll use their experimental data to validate our ESM-2 predictions and demonstrate how well the model captures functional constraints.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a98816a3",
+   "metadata": {},
+   "source": [
+    "### Setup\n",
+    "\n",
+    "Here we import all neccessary libraries."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "24652854",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import mlx.core as mx\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib.patches import Rectangle\n",
+    "from tqdm.auto import tqdm\n",
+    "import pandas as pd\n",
+    "from scipy.stats import spearmanr"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fb407955",
+   "metadata": {},
+   "source": [
+    "Download the experimental deep mutational scanning dataset from Stiffler et al. (2015) for validation of our predictions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "bd229ffc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\n",
+      "                                 Dload  Upload   Total   Spent    Left  Speed\n",
+      "100 1693k  100 1693k    0     0  7621k      0 --:--:-- --:--:-- --:--:-- 7630k\n"
+     ]
+    }
+   ],
+   "source": [
+    "!mkdir -p data\n",
+    "!curl -o data/BLAT_ECOLX_Ranganathan2015.csv https://raw.githubusercontent.com/facebookresearch/esm/refs/heads/main/examples/variant-prediction/data/BLAT_ECOLX_Ranganathan2015.csv"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "52c8a805",
+   "metadata": {},
+   "source": [
+    "Load the ESM-2 model. Here we will use the 650M parameter version. Change the path below to point to your converted checkpoint."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "5e694b81",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "sys.path.append(\"..\")\n",
+    "\n",
+    "from esm import ESM2\n",
+    "\n",
+    "esm_checkpoint = \"../checkpoints/mlx-esm2_t12_35M_UR50D\"\n",
+    "tokenizer, model = ESM2.from_pretrained(esm_checkpoint)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b69be9f9",
+   "metadata": {},
+   "source": [
+    "Here we define the mature TEM-1 β-lactamase sequence (263 amino acids, signal peptide removed) and coordinate conversion constants for mapping between UniProt numbering and our sequence indices."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "b1b30eae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "UNIPROT_START_OF_MATURE = 24\n",
+    "\n",
+    "sequence = (\n",
+    "    \"HPETLVKVKDAEDQLGARVGYIELDLNSGKILESFRPEERFPMMSTFKVLLCGAVLSRVDAGQEQLGRRIHYSQNDLVEYSPVTEKHLTDGMTVRELCSAAITMSDNTAANLLLTTIGGPKELTAFLHNMGDHVTRLDRWEPELNEAIPNDERDTTMPAAMATTLRKLLTGELLTLASRQQLIDWMEADKVAGPLLRSALPAGWFIADKSGAGERGSRGIIAALGPDGKPSRIVVIYTTGSQATMDERNRQIAEIGASLIKHW\"\n",
+    ")\n",
+    "\n",
+    "amino_acids = list(\"ACDEFGHIKLMNPQRSTVWY\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd0f037c",
+   "metadata": {},
+   "source": [
+    "### Function Definitions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4c42edf4",
+   "metadata": {},
+   "source": [
+    "These functions handle coordinate conversion between UniProt numbering (which includes the signal peptide) and our mature sequence indices, enabling us to map experimental data positions to the correct sequence locations."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "6c619e5c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def u2m0(u_pos):\n",
+    "    \"\"\"Convert UniProt position (1-based) to 0-based index into mature sequence.\"\"\"\n",
+    "    m0 = u_pos - UNIPROT_START_OF_MATURE\n",
+    "    return m0 if 0 <= m0 else None\n",
+    "\n",
+    "def urange_to_m0_span(u_start_incl, u_end_incl):\n",
+    "    \"\"\"Convert UniProt range to [start, end) mature 0-based slice.\"\"\"\n",
+    "    s0 = u2m0(u_start_incl)\n",
+    "    e0 = u2m0(u_end_incl)\n",
+    "    if s0 is None: s0 = 0\n",
+    "    if e0 is None: e0 = -1\n",
+    "    s0 = max(0, s0)\n",
+    "    e0 = min(len(sequence) - 1, e0)\n",
+    "    if s0 > e0:\n",
+    "        return None\n",
+    "    return s0, e0 + 1\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8ac3e9e4",
+   "metadata": {},
+   "source": [
+    "These are the core mutation scoring functions that implement ESM-2's masked language modeling approach. They mask a position in the sequence, predict amino acid probabilities using the model, and calculate log-likelihood ratios (LLR) comparing mutant versus wild-type amino acids."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "5c880801",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_site_log_probs(m0_pos):\n",
+    "    \"\"\"Get log probabilities for all amino acids at a masked position.\"\"\"\n",
+    "    tokens = tokenizer.encode(sequence)\n",
+    "    input_ids = mx.array(tokens).reshape(1, -1)\n",
+    "    masked = mx.array(input_ids)\n",
+    "    masked[0, m0_pos + 1] = tokenizer.mask_id\n",
+    "    logits = model(masked)[\"logits\"]\n",
+    "    return mx.log(mx.softmax(logits[0, m0_pos + 1], axis=-1))\n",
+    "\n",
+    "def score_mutation_llr(u_pos, wt_aa, mut_aa):\n",
+    "    \"\"\"Calculate log-likelihood ratio for a specific mutation.\"\"\"\n",
+    "    m0 = u2m0(u_pos)\n",
+    "    if m0 is None or m0 >= len(sequence):\n",
+    "        return np.nan\n",
+    "    \n",
+    "    log_probs = get_site_log_probs(m0)\n",
+    "    wt_tok = tokenizer.token_to_id.get(wt_aa, tokenizer.unk_id)\n",
+    "    mt_tok = tokenizer.token_to_id.get(mut_aa, tokenizer.unk_id)\n",
+    "    return float(log_probs[mt_tok].item() - log_probs[wt_tok].item())\n",
+    "\n",
+    "def score_position_llrs(m0_pos):\n",
+    "    \"\"\"Get LLR scores for all 20 amino acids at a given position.\"\"\"\n",
+    "    log_probs = get_site_log_probs(m0_pos)\n",
+    "    wt = sequence[m0_pos]\n",
+    "    wt_token = tokenizer.token_to_id.get(wt, tokenizer.unk_id)\n",
+    "    wt_lp = float(log_probs[wt_token].item())\n",
+    "    \n",
+    "    scores = np.zeros(len(amino_acids), dtype=float)\n",
+    "    for i, aa in enumerate(amino_acids):\n",
+    "        mt_tok = tokenizer.token_to_id.get(aa, tokenizer.unk_id)\n",
+    "        scores[i] = float(log_probs[mt_tok].item()) - wt_lp\n",
+    "    return scores\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2579edb",
+   "metadata": {},
+   "source": [
+    "This function generates a mutation effect heatmap for a specified protein region. It calculates LLR scores for all 20 amino acids at each position within the given UniProt range, creating a matrix that visualizes the predicted functional impact of every possible single amino acid substitution."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "b83d7f7d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def generate_heatmap(u_start_incl, u_end_incl):\n",
+    "    \"\"\"Generate mutation effect heatmap for a UniProt range.\"\"\"\n",
+    "    span = urange_to_m0_span(u_start_incl, u_end_incl)\n",
+    "    if span is None:\n",
+    "        raise ValueError(\"Requested UniProt window lies outside the mature sequence.\")\n",
+    "    \n",
+    "    s0, e0 = span\n",
+    "    n_cols = e0 - s0\n",
+    "    heatmap = np.zeros((len(amino_acids), n_cols), dtype=float)\n",
+    "    \n",
+    "    print(f\"Calculating mutation effects for UniProt {u_start_incl}-{u_end_incl} \")\n",
+    "    \n",
+    "    for j, m0 in enumerate(tqdm(range(s0, e0), desc=\"Positions\")):\n",
+    "        heatmap[:, j] = score_position_llrs(m0)\n",
+    "    \n",
+    "    seq_segment = sequence[s0:e0]\n",
+    "    u_positions = list(range(UNIPROT_START_OF_MATURE + s0, UNIPROT_START_OF_MATURE + e0))\n",
+    "    \n",
+    "    return heatmap, seq_segment, u_positions\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "737185d5",
+   "metadata": {},
+   "source": [
+    "This function generates a heatmap visualizing the predicted impact of all possible amino acid substitutions at each position, highlighting regions or residues of interest and coloring them by their log-likelihood ratio scores."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "6570ef2a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_heatmap(heatmap, seq_seg, u_positions, title,\n",
+    "                col_width=0.42, min_width=8.0, max_width=16.0, height=6.0, dpi=160,\n",
+    "                robust=True, lo=2, hi=98, vmin=None, vmax=None,\n",
+    "                highlight=None, box_color=\"black\", box_lw=3.0, tick_fs=9, aa_fs=11):\n",
+    "    \"\"\"Plot mutation effect heatmap.\"\"\"\n",
+    "    \n",
+    "    n_cols = len(seq_seg)\n",
+    "    width = np.clip(col_width * n_cols, min_width, max_width)\n",
+    "    \n",
+    "    if robust and (vmin is None or vmax is None):\n",
+    "        vals = heatmap[np.isfinite(heatmap)]\n",
+    "        if vals.size:\n",
+    "            p_lo, p_hi = np.percentile(vals, [lo, hi])\n",
+    "            vmin = p_lo if vmin is None else vmin\n",
+    "            vmax = p_hi if vmax is None else vmax\n",
+    "    if vmin is None: vmin = -10\n",
+    "    if vmax is None: vmax = 10\n",
+    "    \n",
+    "    fig, ax = plt.subplots(figsize=(width, height), constrained_layout=True, dpi=dpi)\n",
+    "    im = ax.imshow(heatmap, cmap=\"RdBu_r\", aspect=\"auto\", vmin=vmin, vmax=vmax)\n",
+    "    \n",
+    "    ax.set_xticks(range(n_cols))\n",
+    "    ax.set_xticklabels([f\"{aa}{u}\" for aa, u in zip(seq_seg, u_positions)],\n",
+    "                      rotation=90, fontsize=tick_fs)\n",
+    "    ax.set_yticks(range(len(amino_acids)))\n",
+    "    ax.set_yticklabels(amino_acids, fontsize=aa_fs)\n",
+    "    \n",
+    "    ax.set_xlabel(\"Wild-type Residue and Position\", fontsize=12)\n",
+    "    ax.set_ylabel(\"Mutant Amino Acid\", fontsize=12)\n",
+    "    ax.set_title(title, fontsize=14)\n",
+    "    \n",
+    "    cbar = plt.colorbar(im, ax=ax)\n",
+    "    cbar.ax.tick_params(labelsize=tick_fs)\n",
+    "    cbar.set_label(\"Log-Likelihood Ratio\", fontsize=11)\n",
+    "    \n",
+    "    if highlight:\n",
+    "        if not isinstance(highlight, (list, tuple, set)):\n",
+    "            highlight = list(highlight)\n",
+    "        u2col = {u: j for j, u in enumerate(u_positions)}\n",
+    "        for u in highlight:\n",
+    "            j = u2col.get(int(u), None)\n",
+    "            if j is not None:\n",
+    "                ax.add_patch(Rectangle((j - 0.5, -0.5), 1.0, heatmap.shape[0],\n",
+    "                                     fill=False, edgecolor=box_color, linewidth=box_lw))\n",
+    "    \n",
+    "    plt.show()\n",
+    "    return fig"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aa62650c",
+   "metadata": {},
+   "source": [
+    "### Generating Heatmaps"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "82c5be68",
+   "metadata": {},
+   "source": [
+    "#### SxxK motif"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e9500f8",
+   "metadata": {},
+   "source": [
+    "We start with the SxxK catalytic motif, a signature sequence found in Class A β-lactamases. The highlighted serine (S68) forms a covalent acyl-enzyme intermediate with the β-lactam substrate, while the lysine (K71) plays a crucial role in the catalytic mechanism. This region should show strong purifying selection, with most mutations being highly deleterious, making it an excellent test of whether ESM-2 captures functional constraints."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "cef435f3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Calculating mutation effects for UniProt 60-80 \n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Positions: 100%|██████████| 21/21 [00:00<00:00, 72.60it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1411.2x960 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "hm1, seg1, upos1 = generate_heatmap(60, 80)\n",
+    "fig1 = plot_heatmap(\n",
+    "    hm1, seg1, upos1,\n",
+    "    title=\"TEM-1 β-lactamase: SxxK motif region (UniProt 60–80)\",\n",
+    "    highlight=[68, 71]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d4c9b97c",
+   "metadata": {},
+   "source": [
+    "The heatmap highlights ESM-2’s ability to pinpoint functionally critical residues. The catalytic serine (S68) and lysine (K71) exhibit extremely negative scores, nearing -10, indicating that almost any substitution at these sites would severely impair enzyme function. In contrast, surrounding positions display a broader range of tolerance, with some accommodating conservative changes. This pattern shows that ESM-2 has captured the precise functional constraints of the active site purely from evolutionary sequence patterns."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d24e211b",
+   "metadata": {},
+   "source": [
+    "#### Binding patch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7142c147",
+   "metadata": {},
+   "source": [
+    "We next examine the substrate-binding residues 232–234, which form part of the binding patch that interacts directly with the β-lactam substrate. These residues are key to substrate recognition, making them an ideal test of ESM-2’s ability to detect the functional importance of specific contact points."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "474f1fcc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Calculating mutation effects for UniProt 226-238 \n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Positions: 100%|██████████| 13/13 [00:00<00:00, 78.58it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1280x960 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "hm2, seg2, upos2 = generate_heatmap(226, 238)\n",
+    "fig2 = plot_heatmap(\n",
+    "    hm2, seg2, upos2,\n",
+    "    title=\"TEM-1 β-lactamase: Binding patch (UniProt 226–238)\",\n",
+    "    highlight=[232, 233, 234]\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8e0450d9",
+   "metadata": {},
+   "source": [
+    "The heatmap illustrates ESM-2’s recognition of the substrate-binding residues 232–234 as critical contact points. All three positions display strongly negative scores, often approaching -10, indicating that nearly any substitution would likely disrupt substrate binding. This sharp contrast with the more variable tolerance observed at neighboring sites suggests that ESM-2 has accurately learned the essential role of these residues in substrate recognition from evolutionary sequence data alone."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "12cf53a7",
+   "metadata": {},
+   "source": [
+    "####  Ω-loop region"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ef967cd4",
+   "metadata": {},
+   "source": [
+    "We now focus on the Ω-loop region spanning residues 160–180, which contains the catalytic glutamate at position 166. This residue functions as a proton acceptor during catalysis, playing a central role in the enzyme’s mechanism."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "709e747b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Calculating mutation effects for UniProt 160-180 \n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Positions: 100%|██████████| 21/21 [00:00<00:00, 76.40it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1411.2x960 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "hm3, seg3, upos3 = generate_heatmap(160, 180)\n",
+    "fig3 = plot_heatmap(\n",
+    "    hm3, seg3, upos3,\n",
+    "    title=\"TEM-1 β-lactamase: Ω-loop region (UniProt 160–180)\",\n",
+    "    highlight=[166]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d15136f6",
+   "metadata": {},
+   "source": [
+    "The heatmap shows that ESM-2 identifies glutamate 166 as an important catalytic residue, with most substitutions producing negative scores, though generally not as extreme as those seen in the previous examples. This more moderate penalty likely reflects the Ω-loop’s inherent flexibility, which may allow certain substitutions to retain partial function or be accommodated structurally. Additionally, E166’s role as a proton acceptor might be more chemically replaceable than the covalent interactions made by S68 for example, meaning the model does not assign uniformly catastrophic scores to all substitutions."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c92d5f28",
+   "metadata": {},
+   "source": [
+    "### DMS Benchmark\n",
+    "\n",
+    "This function benchmarks ESM-2’s mutation effect predictions against experimental deep mutational scanning (DMS) data from Stiffler et al. (2015). It takes the list of experimentally measured β-lactamase TEM mutations, scores each with ESM-2 using masked-marginal log-likelihood ratios, and then compares the predicted scores to experimental fitness values across antibiotic concentrations. The correlation analysis, reported as Spearman |ρ|, quantifies how well ESM-2’s sequence-only predictions align with measured resistance phenotypes. This provides a direct test of the model’s ability to capture functional effects observed in large-scale experimental screens."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "137fe913",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading DMS mutations from data/BLAT_ECOLX_Ranganathan2015.csv...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Scoring DMS mutations: 100%|██████████| 4996/4996 [00:50<00:00, 98.14it/s] "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Spearman |ρ| vs. experimental fitness:\n",
+      "  2500  μg/mL: |ρ| = 0.556\n",
+      "  625   μg/mL: |ρ| = 0.459\n",
+      "  156   μg/mL: |ρ| = 0.393\n",
+      "  39    μg/mL: |ρ| = 0.284\n",
+      "  0     μg/mL: |ρ| = 0.164\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 840x700 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def run_dms_benchmark(csv_path):\n",
+    "    \"\"\"Compare ESM-2 predictions with experimental DMS data.\"\"\"\n",
+    "    print(f\"Loading DMS mutations from {csv_path}...\")\n",
+    "    df = pd.read_csv(csv_path)\n",
+    "    \n",
+    "    preds = []\n",
+    "    for mut in tqdm(df[\"mutant\"], desc=\"Scoring DMS mutations\"):\n",
+    "        wt = mut[0]\n",
+    "        u_pos = int(mut[1:-1])\n",
+    "        mt = mut[-1]\n",
+    "        llr = score_mutation_llr(u_pos, wt, mt)\n",
+    "        preds.append(llr)\n",
+    "    df[\"esm2_llr\"] = preds\n",
+    "    \n",
+    "    exp_cols = [c for c in [\"2500\", \"625\", \"156\", \"39\", \"0\"] if c in df.columns]\n",
+    "    if exp_cols:\n",
+    "        print(\"\\nSpearman |ρ| vs. experimental fitness:\")\n",
+    "        for col in exp_cols:\n",
+    "            mask = ~(df[col].isna() | df[\"esm2_llr\"].isna())\n",
+    "            if mask.sum() > 0:\n",
+    "                rho = spearmanr(df.loc[mask, \"esm2_llr\"], df.loc[mask, col])[0]\n",
+    "                print(f\"  {col:5} μg/mL: |ρ| = {abs(rho):.3f}\")\n",
+    "        \n",
+    "        top_col = None\n",
+    "        for candidate in [\"2500\", \"1250\", \"1000\", \"625\", \"156\", \"39\"]:\n",
+    "            if candidate in exp_cols:\n",
+    "                top_col = candidate\n",
+    "                break\n",
+    "                \n",
+    "        if top_col:\n",
+    "            mask = ~(df[top_col].isna() | df[\"esm2_llr\"].isna())\n",
+    "            x = df.loc[mask, \"esm2_llr\"].values\n",
+    "            y = df.loc[mask, top_col].values\n",
+    "            \n",
+    "            plt.figure(figsize=(6, 5), dpi=140)\n",
+    "            plt.scatter(x, y, s=8, alpha=0.6)\n",
+    "            plt.xlabel(\"ESM-2 masked-marginal LLR (mut − wt)\")\n",
+    "            plt.ylabel(f\"Experimental fitness @ {top_col} μg/mL\")\n",
+    "            rho = spearmanr(x, y)[0]\n",
+    "            plt.title(f\"TEM-1 DMS: ESM-2 vs. fitness (ρ = {rho:.3f})\")\n",
+    "            plt.tight_layout()\n",
+    "            plt.show()\n",
+    "    else:\n",
+    "        print(\"No experimental concentration columns found.\")\n",
+    "    \n",
+    "    return df\n",
+    "\n",
+    "dms_df = run_dms_benchmark(\n",
+    "    \"data/BLAT_ECOLX_Ranganathan2015.csv\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8c76a31f",
+   "metadata": {},
+   "source": [
+    "The scatter plot shows a moderate correlation (ρ = 0.556) between ESM-2 predictions and experimental fitness, but the relationship is noisy with substantial variation around the trend. In general, more negative ESM-2 scores tend to correspond to lower experimental fitness, yet many individual mutations deviate from this pattern. Some mutations with highly negative LLR scores still maintain reasonable fitness, while others with only modestly negative scores perform poorly. The increase in correlation strength with higher antibiotic concentration (from |ρ| = 0.164 to |ρ| = 0.556) suggests that ESM-2’s evolutionary-based predictions become more relevant under strong selective pressure. However, even at the highest concentration, the considerable scatter indicates that predicting mutation effects remains challenging and that experimental fitness is influenced by factors beyond what ESM-2 can infer from sequence patterns alone. It's important to note that these results are based on the 35M parameter ESM-2 model, and it is likely that larger models would achieve stronger correlations and improved predictive performance."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/esm/requirements.txt b/esm/requirements.txt
new file mode 100644
index 00000000..d7dbbe96
--- /dev/null
+++ b/esm/requirements.txt
@@ -0,0 +1,12 @@
+mlx
+torch
+transformers
+numpy
+pandas
+seaborn
+biopython
+biotite
+scipy
+tqdm
+scikit-learn
+matplotlib
\ No newline at end of file
diff --git a/esm/test.py b/esm/test.py
new file mode 100644
index 00000000..e9fb3bd8
--- /dev/null
+++ b/esm/test.py
@@ -0,0 +1,121 @@
+import unittest
+
+import numpy as np
+from transformers import AutoTokenizer, EsmConfig, EsmForMaskedLM
+
+from esm import ESM2
+
+# Paths for MLX and Hugging Face versions of ESM-2
+MLX_PATH = "checkpoints/mlx-esm2_t12_35M_UR50D"
+HF_PATH = "facebook/esm2_t12_35M_UR50D"
+
+
+def load_mlx_model():
+    """Load MLX ESM-2 model and tokenizer."""
+    tokenizer, model = ESM2.from_pretrained(MLX_PATH)
+    return tokenizer, model
+
+
+def load_hf_model():
+    """Load Hugging Face ESM-2 model and tokenizer with hidden states + attentions."""
+    tokenizer = AutoTokenizer.from_pretrained(HF_PATH)
+    config = EsmConfig.from_pretrained(
+        HF_PATH, output_hidden_states=True, output_attentions=True
+    )
+    model = EsmForMaskedLM.from_pretrained(HF_PATH, config=config)
+    return tokenizer, model
+
+
+class TestESM2(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        # Load both MLX and HF models/tokenizers once for all tests
+        cls.mlx_tokenizer, cls.mlx_model = load_mlx_model()
+        cls.hf_tokenizer, cls.hf_model = load_hf_model()
+
+    def test_tokenizer(self):
+        """Verify MLX tokenizer matches Hugging Face tokenizer behavior."""
+        self.assertEqual(len(self.mlx_tokenizer), len(self.hf_tokenizer))
+
+        sequences = [
+            "MSKGEELFTGVVPILVELDGDVNGHKFSVSGEGEGDATYGKLTLKFICTTGKLPVPWPTLVTTFSYGVQCFSRYPDHMKQHDFFKSAMPEGYVQERTIFFKDDGNYKTRAEVKFEGDTLVNRIELKGIDFKEDGNILGHKLEYNYNSHNVYIMADKQKNGIKVNFKIRHNIEDGSVQLADHYQQNTPIGDGPVLLPDNHYLSTQSALSKDPNEKRDHMVLLEFVTAAGITHGMDELYK",
+            "MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+        ]
+
+        # Compare batched tokenization (padded sequences)
+        mlx_batch = self.mlx_tokenizer.batch_encode(sequences)
+        hf_batch = (
+            self.hf_tokenizer(sequences, return_tensors="pt", padding=True)["input_ids"]
+            .cpu()
+            .numpy()
+        )
+        self.assertEqual(tuple(mlx_batch.shape), tuple(hf_batch.shape))
+        self.assertTrue(
+            np.array_equal(np.array(mlx_batch.tolist(), dtype=hf_batch.dtype), hf_batch)
+        )
+
+        # Compare single-sequence encode/decode
+        for sequence in sequences:
+            mlx_tokens = self.mlx_tokenizer.encode(sequence)
+            hf_tokens = (
+                self.hf_tokenizer(sequence, return_tensors="pt")["input_ids"]
+                .cpu()
+                .numpy()
+                .tolist()[0]
+            )
+            self.assertTrue(np.array_equal(mlx_tokens, hf_tokens))
+            self.assertEqual(
+                self.mlx_tokenizer.decode(mlx_tokens),
+                self.hf_tokenizer.decode(hf_tokens).replace(" ", ""),
+            )
+            self.assertEqual(
+                self.mlx_tokenizer.decode(mlx_tokens, skip_special_tokens=True),
+                self.hf_tokenizer.decode(hf_tokens, skip_special_tokens=True).replace(
+                    " ", ""
+                ),
+            )
+
+    def test_model(self):
+        """Verify MLX and HF model outputs match (logits, hidden states, attentions)."""
+        sequences = [
+            "MSKGEELFTGVVPILVELDGDVNGHKFSVSGEGEGDATYGKLTLKFICTTGKLPVPWPTLVTTFSYGVQCFSRYPDHMKQHDFFKSAMPEGYVQERTIFFKDDGNYKTRAEVKFEGDTLVNRIELKGIDFKEDGNILGHKLEYNYNSHNVYIMADKQKNGIKVNFKIRHNIEDGSVQLADHYQQNTPIGDGPVLLPDNHYLSTQSALSKDPNEKRDHMVLLEFVTAAGITHGMDELYK",
+            "MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN",
+        ]
+        for sequence in sequences:
+            # Tokenize
+            mlx_tokens = self.mlx_tokenizer.encode(sequence, return_batch_dim=True)
+            hf_tokens = self.hf_tokenizer(sequence, return_tensors="pt")["input_ids"]
+
+            # Forward pass
+            mlx_outputs = self.mlx_model(
+                mlx_tokens,
+                repr_layers=[self.mlx_model.num_layers],
+                need_head_weights=True,
+            )
+            hf_outputs = self.hf_model(input_ids=hf_tokens)
+
+            # Compare logits
+            mlx_logits = np.array(mlx_outputs["logits"])
+            hf_logits = hf_outputs["logits"].detach().cpu().numpy()
+            self.assertTrue(np.allclose(mlx_logits, hf_logits, rtol=1e-4, atol=1e-4))
+
+            # Compare final-layer hidden states
+            final_layer = self.mlx_model.num_layers
+            mlx_hidden_states = np.array(mlx_outputs["representations"][final_layer])
+            hf_hidden_states = hf_outputs["hidden_states"][-1].detach().cpu().numpy()
+            self.assertTrue(
+                np.allclose(mlx_hidden_states, hf_hidden_states, rtol=1e-4, atol=1e-4)
+            )
+
+            # Compare attentions for final layer
+            mlx_attentions = np.array(
+                mlx_outputs["attentions"][:, final_layer - 1, :, :, :]
+            )
+            hf_attentions = hf_outputs["attentions"][-1].detach().cpu().numpy()
+            self.assertTrue(
+                np.allclose(mlx_attentions, hf_attentions, rtol=1e-4, atol=1e-4)
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()