Predicción de estructura y afinidad de unión con herramientas de código abierto: superando las limitaciones de AlphaFold3 con Boltz-2 y Chai-1

En mayo de 2024, el lanzamiento de AlphaFold3 supuso un nuevo hito en el campo de la biología estructural. Sin embargo, para que los laboratorios o equipos de desarrollo de fármacos puedan utilizar AlphaFold3 a nivel local, deben superar dos obstáculos: una base de datos de genomas de varios terabytes y una licencia exclusiva para uso académico. En noviembre de 2024, el MIT/Genentech lanzó Boltz-1 como código abierto (con licencia MIT), y en 2025, Boltz-2 integró la predicción de la afinidad de unión, lo que permitió crear una herramienta que puede utilizarse en la práctica para el cribado de fármacos, con una velocidad 1000 veces mayor que la de la perturbación de la energía libre (FEP+). En este artículo, se explica cómo construir una línea de desarrollo de fármacos de última generación utilizando esta combinación de herramientas de código abierto.

📚 Recomendación de contenidos previos (muy recomendable)

Este artículo es el punto culminante de la serie avanzada de IA y biología. Le recomendamos encarecidamente que vea primero los siguientes artículos de DryBench antes de empezar.

• DryBench ai-native #3: Transformers y embeddings
• DryBench ai-native #12: Fundamentos de PyTorch
• DryBench ai-native #14: Claude Code y Cursor
• DryBench ai-native #15: Integración de la bio-IA

Si empieza sin haber visto los contenidos previos, le resultará difícil seguir el ritmo, ya que este artículo comienza con el código práctico sin explicar la arquitectura Transformer para el procesamiento de coordenadas 3D, cómo PyTorch carga los parámetros de modelos grandes en la memoria de la GPU y utiliza optimizaciones como la precisión mixta y la atención rápida, cómo Claude Code automatiza las líneas de desarrollo y cómo se integra la predicción de estructuras en el panorama general de la bio-IA.

Ya aprendimos esto en DryBench

En DryBench ai-native #3, aprendimos que los Transformers pueden extenderse a datos estructurados arbitrarios, como coordenadas 3D y gráficos, además de las secuencias; en #12, aprendimos cómo PyTorch carga los parámetros de modelos grandes en la memoria de la GPU y utiliza optimizaciones como la precisión mixta y la atención rápida; en #14, aprendimos que Claude Code es una herramienta práctica que simplifica la creación de scripts para líneas de desarrollo repetitivas; y en #15, aprendimos cómo se integra la predicción de estructuras en el panorama general de la bio-IA.

Pero debemos analizar por qué, desde la perspectiva de un equipo real de desarrollo de fármacos, la afirmación de que "con AlphaFold3 es suficiente" resulta insuficiente. Con solo la predicción de la estructura, no se sabe con cuánta fuerza se une el ligando (afinidad). Tradicionalmente, esta respuesta se obtenía mediante cálculos de FEP (perturbación de energía libre), lo que requería varios días o semanas por ligando. Boltz-2 integra estos dos aspectos (estructura + afinidad) en una sola pasada de red neuronal, obteniendo resultados en milisegundos. Este es el punto de inflexión en el cribado de nuevos fármacos, y este artículo trata sobre su aplicación práctica.

Definición del problema central

Requisitos prácticos del cribado de nuevos fármacos

Para una proteína diana (por ejemplo, una quinasa específica), es necesario seleccionar los compuestos "hit" más prometedores de una biblioteca de más de 1000 pequeñas moléculas candidatas. Enfoques tradicionales:

• Docking (AutoDock Vina, Glide): segundos o minutos por ligando. Sin embargo, aunque la pose sea aproximadamente correcta, la precisión de la afinidad es baja (correlación r ~ 0,4-0,5).
• FEP+ (Schrödinger): varios días por ligando. Alta precisión (r ~ 0,8+). Sin embargo, es comercial y la licencia es muy costosa.
• AlphaFold3: excelente para la estructura del complejo, pero no proporciona la afinidad directamente. Se requiere una puntuación adicional.
• Boltz-2: proporciona la estructura + afinidad (aproximación de log10 IC50) de forma integrada. Precisión similar a FEP+. Milisegundos a segundos por ligando.

Objetivos de la canalización que se trata en este artículo:

• Secuencia de la proteína diana + 1000 SMILES de ligandos candidatos → completar el cribado en menos de 24 horas.
• Clasificación automática de los 20 candidatos con mayor afinidad + generación automática de visualizaciones de PyMOL.
• Procesamiento de múltiples conformaciones: muestreo de varias poses para un solo ligando y, a continuación, puntuación de conjunto.
• Aplicación estricta de la reproducibilidad: todas las ejecuciones se definen con un único archivo de configuración YAML y se realiza un seguimiento mediante etiquetas.

¿Por qué Boltz-2 y Chai-1 en lugar de AlphaFold3?

• Licencia: AlphaFold3 requiere la aprobación para uso académico no comercial y se requiere una negociación por separado para el uso comercial. Boltz-1/2 y Chai-1 son de código abierto (Boltz con licencia MIT [1], Chai con licencia gratuita para investigación + licencia por separado para uso comercial [2]).
• Carga de la infraestructura: AlphaFold3 requiere la sincronización local de varias bases de datos de varios TB, como UniRef, MGnify y PDB. Boltz-2 puede utilizar la API remota de MMseqs2 [1].
• Integración de la afinidad: AF3 solo proporciona la estructura. Boltz-2 proporciona la predicción integrada de la estructura + afinidad [1].
• Velocidad: Boltz-2 es 1000 veces más rápido que FEP+ (según el artículo [3]).
• Libertad comercial: La licencia MIT no restringe el uso comercial. Chai-1 ofrece una API comercial de pago.

Conjunto de herramientas y requisitos de infraestructura

Requisitos de infraestructura:

• Mínimo para uso práctico: 1 GPU de centro de datos con 24 GB de VRAM o una GPU de consumo de gama alta (por ejemplo, RTX 4090 de 24 GB). Boltz-2 consume aproximadamente 15 GB de VRAM en fp16, y los complejos grandes pueden requerir 20 GB o más.
• Alternativa de CPU: Muy lento (más de 30 minutos por predicción), prácticamente inviable para uso práctico.
• RAM: 32 GB o más.
• Disco: Aproximadamente 2 a 5 GB para los pesos de Boltz, aproximadamente 5 GB para los pesos de Chai-1 y varios GB para la caché de MSA.
• Red: Varios MB de comunicación por objetivo al llamar a la API remota de MMseqs2.

Coste estimado para la reproducción por parte de un usuario: Si no se dispone de una GPU local, consulte la lista de precios por hora de las instancias de GPU bajo demanda en la nube (por ejemplo, una instancia de 24 GB de VRAM). El cribado de 1000 ligandos requiere aproximadamente de 2 a 4 horas de GPU (según las pruebas del artículo de Boltz-2 [3]).

Implementación práctica de la canalización

Flujo general:

Paso 1. Construcción remota de MSA de la proteína objetivo

En lugar de instalar MMseqs2 localmente y descargar UniRef, utilice una API remota. Boltz admite varios servidores MSA remotos [4].

from pathlib import Path
from dataclasses import dataclass

import requests


@dataclass
class MSAResult:
    """Resultado de un alineamiento múltiple de secuencias."""
    query_id: str
    a3m_content: str  # MSA en formato a3m
    depth: int         # Profundidad del MSA: número de secuencias incluidas


def build_msa_remote(
    query_sequence: str,
    query_id: str = "target",
    api_base: str = "https://api.colabfold.com",
    max_depth: int = 5000,
) -> MSAResult:
    """Construye remotamente un MSA con el servidor ColabFold y backend MMseqs2.

    La documentación oficial de Boltz recomienda ColabFold o la API BioLM [4].
    """
    # Llamada real a la API; ejemplo con ColabFold MMseqs2
    payload = {"query": f">{query_id}\n{query_sequence}", "mode": "env"}
    resp = requests.post(f"{api_base}/ticket/msa", data=payload, timeout=600)
    resp.raise_for_status()
    ticket = resp.json()["id"]

    # Sondea hasta que termine
    import time
    while True:
        status = requests.get(f"{api_base}/ticket/{ticket}", timeout=30).json()
        if status["status"] == "COMPLETE":
            break
        elif status["status"] == "ERROR":
            raise RuntimeError(f"Falló la construcción del MSA: {status}")
        time.sleep(5)

    # Descarga el resultado a3m
    a3m_resp = requests.get(f"{api_base}/result/download/{ticket}", timeout=60)
    a3m_resp.raise_for_status()
    a3m_content = a3m_resp.text
    depth = a3m_content.count("\n>")

    return MSAResult(query_id=query_id, a3m_content=a3m_content, depth=depth)


def save_a3m(msa: MSAResult, output_dir: Path) -> Path:
    """Guarda el archivo a3m."""
    output_dir.mkdir(parents=True, exist_ok=True)
    path = output_dir / f"{msa.query_id}.a3m"
    path.write_text(msa.a3m_content)
    return path

Paso 2. Normalización de la biblioteca de ligandos

SMILES permite representar la misma molécula con múltiples notaciones, por lo que es necesario realizar una normalización. RDKit es el estándar.

from rdkit import Chem
from rdkit.Chem import AllChem, Descriptors, Lipinski
import pandas as pd


def canonicalize_smiles(smiles: str) -> str | None:
    """Devuelve el SMILES canónico o None si no puede analizarlo."""
    mol = Chem.MolFromSmiles(smiles)
    if mol is None:
        return None
    return Chem.MolToSmiles(mol, canonical=True)


def lipinski_filter(smiles: str) -> dict:
    """Evalúa la regla de cinco de Lipinski y devuelve propiedades fisicoquímicas."""
    mol = Chem.MolFromSmiles(smiles)
    if mol is None:
        return {"valid": False}
    props = {
        "MW": Descriptors.MolWt(mol),
        "LogP": Descriptors.MolLogP(mol),
        "HBA": Lipinski.NumHAcceptors(mol),
        "HBD": Lipinski.NumHDonors(mol),
        "RotB": Lipinski.NumRotatableBonds(mol),
    }
    violations = sum([
        props["MW"] > 500,
        props["LogP"] > 5,
        props["HBA"] > 10,
        props["HBD"] > 5,
    ])
    props["valid"] = True
    props["lipinski_violations"] = violations
    props["lipinski_pass"] = violations <= 1
    return props


def prepare_ligand_library(smiles_list: list[str]) -> pd.DataFrame:
    """Normaliza la biblioteca de ligandos y aplica filtros fisicoquímicos."""
    records = []
    for i, raw in enumerate(smiles_list):
        canon = canonicalize_smiles(raw)
        if canon is None:
            continue
        props = lipinski_filter(canon)
        records.append({
            "ligand_id": f"L{i:04d}",
            "smiles_raw": raw,
            "smiles_canonical": canon,
            **props,
        })
    df = pd.DataFrame(records)
    return df[df["lipinski_pass"]].reset_index(drop=True)

Paso 3. Creación de la configuración YAML de Boltz-2

Boltz especifica la proteína, el ligando y el MSA en un único archivo YAML [4].

import yaml


def build_boltz_config(
    protein_sequence: str,
    protein_msa_path: Path,
    ligand_smiles: str,
    ligand_id: str,
    output_dir: Path,
) -> Path:
    """Genera una configuración YAML de Boltz por cada par proteína-ligando."""
    config = {
        "version": 1,
        "sequences": [
            {
                "protein": {
                    "id": "A",
                    "sequence": protein_sequence,
                    "msa": str(protein_msa_path),
                }
            },
            {
                "ligand": {
                    "id": "L",
                    "smiles": ligand_smiles,
                }
            },
        ],
        "constraints": [],
        "properties": [
            {"affinity": {"binder": "L"}}  # Activa la predicción de afinidad, nueva en Boltz-2
        ],
    }
    output_dir.mkdir(parents=True, exist_ok=True)
    yaml_path = output_dir / f"{ligand_id}.yaml"
    with open(yaml_path, "w") as f:
        yaml.safe_dump(config, f, sort_keys=False)
    return yaml_path

Paso 4. Inferencia por lotes de Boltz-2

Realiza predicciones iterando sobre varios ligandos. Gestiona las sesiones teniendo en cuenta la memoria de la GPU.

import subprocess
import json


@dataclass
class BoltzResult:
    """Resultado de una predicción de Boltz-2."""
    ligand_id: str
    pdb_path: Path            # Estructura 3D predicha del complejo
    plddt_mean: float         # Confianza estructural (0～100)
    iptm: float               # pTM de interfaz (0～1)
    affinity_log_ic50: float  # log10(IC50 mol/L) predicho; más negativo implica mayor potencia
    inference_time_sec: float


def run_boltz_prediction(
    yaml_path: Path,
    output_dir: Path,
    device: str = "cuda",
    use_msa_server: bool = False,
) -> BoltzResult:
    """Ejecuta la CLI de Boltz-2; en producción también puede usarse su API de Python."""
    import time
    start = time.time()

    cmd = [
        "boltz", "predict",
        str(yaml_path),
        "--out_dir", str(output_dir),
        "--devices", "1",
        "--accelerator", "gpu" if device == "cuda" else "cpu",
    ]
    if use_msa_server:
        cmd.append("--use_msa_server")

    result = subprocess.run(cmd, capture_output=True, text=True, check=True)
    elapsed = time.time() - start

    # Boltz genera output_dir/{name}/{name}_model_0.pdb y confidence.json
    name = yaml_path.stem
    pdb_path = output_dir / name / f"{name}_model_0.pdb"
    conf_path = output_dir / name / f"confidence_{name}_model_0.json"

    with open(conf_path) as f:
        conf = json.load(f)

    # La afinidad se obtiene de otro JSON, un campo nuevo de Boltz-2
    affinity_path = output_dir / name / f"affinity_{name}.json"
    affinity_data = json.loads(affinity_path.read_text()) if affinity_path.exists() else {}

    return BoltzResult(
        ligand_id=name,
        pdb_path=pdb_path,
        plddt_mean=float(conf.get("complex_plddt", 0.0)),
        iptm=float(conf.get("iptm", 0.0)),
        affinity_log_ic50=float(affinity_data.get("affinity_pred_value", 0.0)),
        inference_time_sec=elapsed,
    )

Paso 5. Orquestación del cribado por lotes

Recorrer toda la biblioteca de ligandos + gestionar los fallos + mostrar el progreso.

from tqdm import tqdm


def batch_screen(
    protein_sequence: str,
    protein_msa: MSAResult,
    ligand_library: pd.DataFrame,
    work_dir: Path,
    device: str = "cuda",
) -> pd.DataFrame:
    """Criba toda la biblioteca de ligandos."""
    msa_path = save_a3m(protein_msa, work_dir / "msa")

    results = []
    failures = []
    for _, row in tqdm(ligand_library.iterrows(), total=len(ligand_library), desc="Screening"):
        try:
            yaml_path = build_boltz_config(
                protein_sequence=protein_sequence,
                protein_msa_path=msa_path,
                ligand_smiles=row["smiles_canonical"],
                ligand_id=row["ligand_id"],
                output_dir=work_dir / "configs",
            )
            boltz_result = run_boltz_prediction(
                yaml_path=yaml_path,
                output_dir=work_dir / "predictions",
                device=device,
                use_msa_server=False,
            )
            results.append({
                "ligand_id": boltz_result.ligand_id,
                "smiles": row["smiles_canonical"],
                "affinity_log_ic50": boltz_result.affinity_log_ic50,
                "plddt": boltz_result.plddt_mean,
                "iptm": boltz_result.iptm,
                "pdb_path": str(boltz_result.pdb_path),
                "inference_sec": boltz_result.inference_time_sec,
                "MW": row.get("MW"),
                "LogP": row.get("LogP"),
            })
        except Exception as e:
            failures.append({"ligand_id": row["ligand_id"], "error": str(e)})

    df_results = pd.DataFrame(results).sort_values("affinity_log_ic50")
    df_failures = pd.DataFrame(failures)
    df_failures.to_csv(work_dir / "failures.csv", index=False)
    return df_results

Paso 6. Visualización Top-K en PyMOL

Representación automática de las posturas de unión de los principales candidatos.

def render_pymol(
    pdb_path: Path,
    output_png: Path,
    ray_trace: bool = True,
) -> None:
    """Renderizado headless con PyMOL."""
    script = f"""
load {pdb_path}, complex
hide everything
show cartoon, complex and polymer
show sticks, complex and organic
color grey70, complex and polymer
color yellow, complex and organic
bg_color white
zoom complex and organic, 5
{"ray 1200, 900" if ray_trace else ""}
png {output_png}, dpi=150
quit
"""
    script_path = output_png.parent / "render.pml"
    script_path.write_text(script)
    subprocess.run(["pymol", "-cq", str(script_path)], check=True)


def render_top_k(results_df: pd.DataFrame, output_dir: Path, k: int = 20) -> None:
    output_dir.mkdir(parents=True, exist_ok=True)
    for _, row in results_df.head(k).iterrows():
        render_pymol(
            pdb_path=Path(row["pdb_path"]),
            output_png=output_dir / f"{row['ligand_id']}.png",
        )

Flujo de trabajo integrado

def full_screening_pipeline(
    protein_sequence: str,
    protein_id: str,
    smiles_library: list[str],
    work_dir: Path,
    device: str = "cuda",
    top_k: int = 20,
) -> pd.DataFrame:
    """FASTA + biblioteca SMILES → DataFrame de resultados ordenados."""
    print(f"[1/6] Solicitud remota de MSA (longitud de consulta={len(protein_sequence)})")
    msa = build_msa_remote(protein_sequence, query_id=protein_id)
    print(f"      MSA depth={msa.depth}")

    print(f"[2/6] Normalización de la biblioteca de ligandos (sin procesar={len(smiles_library)})")
    library = prepare_ligand_library(smiles_library)
    print(f"      Superan Lipinski={len(library)}")

    print("[3/6] Inicio del cribado por lotes")
    results = batch_screen(protein_sequence, msa, library, work_dir, device)
    results.to_csv(work_dir / "screening_results.csv", index=False)

    print(f"[4/6] Renderizado PyMOL del Top-{top_k}")
    render_top_k(results, work_dir / "top_k_renders", k=top_k)

    print(f"[5/6] Completado: work_dir={work_dir}")
    print("[6/6] Resumen de los cinco mejores ligandos:")
    print(results.head(5)[["ligand_id", "affinity_log_ic50", "plddt", "iptm"]].to_string(index=False))
    return results

Validación del conjunto Chai-1 (mejora opcional)

Chai-1 es un modelo de base abierto de última generación similar a Boltz, por lo que volver a validar los mejores candidatos con Chai-1 puede reducir los falsos positivos [2].

from chai_lab.chai1 import run_inference


def chai_reverification(
    protein_sequence: str,
    ligand_smiles: str,
    output_dir: Path,
    device: str = "cuda",
) -> dict:
    """Vuelve a predecir el mismo par con Chai-1 y combina la puntuación con Boltz."""
    fasta_str = f">protein|name=A\n{protein_sequence}\n>ligand|name=L\n{ligand_smiles}\n"
    fasta_path = output_dir / "chai_input.fasta"
    fasta_path.write_text(fasta_str)
    output_dir.mkdir(parents=True, exist_ok=True)

    result = run_inference(
        fasta_file=fasta_path,
        output_dir=output_dir,
        num_trunk_recycles=3,
        num_diffn_timesteps=200,
        seed=42,
        device=device,
        use_esm_embeddings=True,
    )
    return {
        "pdb_path": result[0],
        "iptm": float(result[0].iptm),  # Campo de ejemplo; consulta la API real
    }


def ensemble_ranking(
    boltz_score: float,
    chai_score: float,
    weight: float = 0.5,
) -> float:
    """Media ponderada de las puntuaciones de ambos modelos; menor implica mayor potencia."""
    return weight * boltz_score + (1 - weight) * chai_score

Rendimiento, costo y casos de falla conocidos

Referencia de rendimiento (basado en evaluaciones públicas)

Costo estimado para la reproducción por parte del alumno

• Costo de la API: 0 (cuando se usa una GPU local). Se utiliza el nivel gratuito de la API remota de MMseqs2.
• Tiempo de GPU: aproximadamente 2～4 horas para un objetivo y el cribado de 1000 ligandos (basado en una GPU de 24 GB de VRAM).
• Si se utiliza la nube bajo demanda, es necesario consultar la tabla de precios por hora.
• Disco: pesos de Boltz de 2～5 GB, PDB de resultados + renderizado de aproximadamente 500 MB.

Tres casos de falla conocidos (recopilados de la comunidad y de artículos)

1. OOM (falta de memoria) en complejos grandes (> 2000 residuos) Síntoma: incluso con 24 GB de VRAM, los complejos grandes y multisuunitarios exceden la memoria. Causa: la atención de Boltz-2 tiene una complejidad de memoria de O(N²) en el número de residuos. Solución: (a) activar la opción --use_flash_attention, (b) forzar fp16, (c) para complejos grandes, predecir por subunidad y luego combinar en el postprocesamiento, (d) se requiere una GPU de 48 GB+ de VRAM. Fuente: Boltz GitHub Issues — hilo "OOM for large complexes" [5].

2. La falta de profundidad de MSA provoca una caída brusca de la precisión Síntomas: Las secuencias nuevas o huérfanas, o las secuencias metagenómicas, a veces muestran una profundidad de MSA < 32 en MMseqs2, y en estos casos, la confianza de pLDDT y afinidad de Boltz-2 disminuye drásticamente. Causa: El modelo base aún depende de las señales de coevolución. Solución: (a) Si la profundidad de MSA < 100, se muestra una advertencia en los resultados, (b) se intenta con varios servidores utilizando la opción --msa_server, (c) se compara con una línea de base en modo de secuencia única (sin MSA) para juzgar la confianza. Fuente: Sección "Calidad de MSA" de la documentación oficial de Boltz [6].

3. Pose de unión incorrecta debido a la ignorancia de la estereoquímica del ligando Síntomas: Incluso si la estereoquímica se especifica en SMILES, la predicción selecciona aleatoriamente entre varios estereoisómeros. Causa: Pérdida de la etiqueta de quiralidad en la etapa de canonización de SMILES o sesgo en los datos de entrenamiento del modelo base. Solución: (a) Se conserva la estereoquímica original con Chem.MolFromSmiles(canonical=False), (b) se genera un conformador 3D con RDKit AllChem.EmbedMolecule y se intenta introducirlo como SDF, (c) se verifica a posteriori la quiralidad de la pose de los resultados de la predicción. Fuente: Discusiones de RDKit + Problemas de Boltz (varios hilos relacionados con la estereoquímica) [7].

Ideas de expansión

• Descubrimiento de fármacos basado en fragmentos: Se construye una biblioteca de ligandos principalmente con fragmentos (< 300 Da) y luego se realiza un cribado de fragmentos de éxito con Boltz-2 → diseño de un enlazador.
• Análisis comparativo de clases objetivo: Se realiza un cribado repetido de la misma biblioteca de ligandos en toda una familia de quinasas (por ejemplo, MAPK) → mapa de selectividad.
• Ciclo de aprendizaje activo: Se realizan ensayos experimentales reales de las principales predicciones → se proporciona retroalimentación de los resultados → ajuste fino del modelo (especialización de dominio).
• Complejo proteína-proteína + ligando: Boltz admite múltiples cadenas. Se amplía el escenario a la combinación de anticuerpo-antígeno + molécula pequeña.
• Exposición de la herramienta MCP: El agente MCP de la parte 14 llama a esta canalización como una herramienta → investigación autónoma de candidatos a fármacos.

Próxima parte

• Parte 08 docking-hybrid-diffusion: Se refinan las poses de los principales candidatos de esta parte con un híbrido de DiffDock-Glide.
• Episodio 13 protein-design-multimodal: Diseño de una nueva proteína diana con ESM3 → Selección de candidatos a unión con Boltz-2.
• Episodio 14 bio-mcp-agent: Envolver esta canalización con la herramienta MCP para crear un agente autónomo de investigación de fármacos.
• Episodio 15 bio-mcp-server-suite: Servidor MCP personalizado para acceder a los datos de PDBbind y ChEMBL.

Referencias

1. Wohlwend J, Corso G, Passaro S, et al. Boltz-1: modelo fundacional abierto para la predicción de estructuras. MIT/Genentech, 2024. GitHub: https://github.com/jwohlwend/boltz
2. Chai Discovery. "Chai-1: Descifrando las interacciones moleculares de la vida". bioRxiv 2024. https://www.biorxiv.org/content/10.1101/2024.10.10.615955v2 / GitHub: https://github.com/chaidiscovery/chai-lab
3. Passaro S, Corso G, Wohlwend J, et al. "Boltz-2: Hacia una predicción de la afinidad de unión precisa y eficiente". bioRxiv 2025. https://www.biorxiv.org/content/10.1101/2025.06.14.659707v1
4. Documentación oficial de Boltz (uso de la predicción): https://github.com/jwohlwend/boltz/blob/main/docs/prediction.md
5. Problemas de Boltz en GitHub (OOM, MSA, estereoquímica): https://github.com/jwohlwend/boltz/issues
6. Sección MSA de la documentación oficial de Boltz: https://github.com/jwohlwend/boltz/blob/main/docs/msa.md
7. Debates de RDKit (canonicación de la estereoquímica): https://github.com/rdkit/rdkit/discussions
8. Abramson J, Adler J, Dunger J, et al. "Predicción precisa de la estructura de las interacciones biomoleculares con AlphaFold 3". Nature 2024. https://www.nature.com/articles/s41586-024-07487-w
9. Schrödinger FEP+ (comercial): https://www.schrodinger.com/products/fep
10. PDBbind: http://www.pdbbind.org.cn/
11. MMseqs2: https://github.com/soedinglab/MMseqs2
12. ColabFold MSA server (nivel gratuito): https://github.com/sokrypton/ColabFold
13. BioLM API: https://biolm.ai/models/
14. RDKit: https://www.rdkit.org/
15. PyMOL de código abierto: https://github.com/schrodinger/pymol-open-source
16. AutoDock Vina: https://vina.scripps.edu/
17. Conjunto de referencia PDB reciente: https://www.rcsb.org/