RFDiffusion NIM

Concevez des PDB de chaînes protéiques pour des protéines de novo, des échafaudages de motifs et des ligands. Utilisez ce guide pour un premier usage hébergé/local ; chargez les fichiers supplémentaires uniquement si nécessaire :

references/api.md : endpoints exacts, schémas, drapeaux Docker, champs de réponse.
references/science.md : modes de conception, forces, limites et transitions.
references/parameters.md : contigs, hotspots, étapes et graines.
references/validation.md : vérifications de cohérence PDB, contig et artefacts.
references/examples.md : modèles de requêtes hébergées/locales compacts.

Choisir un mode

Ne posez une question que si le contexte est ambigu :

API NVIDIA hébergée ou NIM Docker local ?

Hébergée : https://health.api.nvidia.com/v1/biology/ipd/rfdiffusion/generate
Local : http://localhost:8000/biology/ipd/rfdiffusion/generate

Les chemins d'inférence locaux n'incluent pas /v1/. Les requêtes hébergées utilisent Authorization: Bearer $NGC_API_KEY. Le démarrage Docker local pris en charge utilise NGC_API_KEY (ou NVIDIA_API_KEY via le préalable) pour la connexion au registre, les vérifications de droits et les téléchargements de modèles à la première exécution ; passez-la dans le conteneur avec -e NGC_API_KEY. Les requêtes d'inférence locales n'utilisent aucun en-tête d'authentification après le démarrage. Le démarrage sans clé avec cache chaud varie selon l'image/version et ne doit pas être supposé.

Docker local

Pour les réponses de configuration locale, copiez le préalable ci-dessous exactement avant docker login, docker run, le démarrage et la requête locale sans authentification. Ne le remplacez pas par une simple vérification : "${NGC_API_KEY:?Set NGC_API_KEY}", n'inventez pas un cache par défaut et ne supprimez pas le fallback NVIDIA_API_KEY. La configuration par défaut est GPU unique device=0.

set -a
[ -f .env ] && . ./.env
set +a

if [ -z "${NGC_API_KEY:-}" ] && [ -n "${NVIDIA_API_KEY:-}" ]; then
  export NGC_API_KEY="$NVIDIA_API_KEY"
fi
: "${NGC_API_KEY:?Set NGC_API_KEY or NVIDIA_API_KEY}"
: "${LOCAL_NIM_CACHE:?Set LOCAL_NIM_CACHE}"

echo "$NGC_API_KEY" | docker login nvcr.io --username '$oauthtoken' --password-stdin

mkdir -p "${LOCAL_NIM_CACHE}"
chmod 755 "${LOCAL_NIM_CACHE}"

docker run -it \
  --runtime=nvidia \
  --gpus "device=0" \
  -e NGC_API_KEY \
  -v "${LOCAL_NIM_CACHE}:/opt/nim/.cache" \
  -p 8000:8000 \
  nvcr.io/nim/ipd/rfdiffusion:2

Démarrage :

until curl -sf http://localhost:8000/v1/health/ready; do sleep 5; done

DSL Contigs

contigs définit ce qu'il faut conserver et ce qu'il faut générer. Pour la syntaxe de motif complète (longueur fixe, plages, segments de chaîne conservés, ruptures de chaîne), voir references/api.md sous Contigs Language Reference.

Modes de conception :

De novo : contigs="80-120" ; la validation hébergée en direct nécessite un input_pdb ou input_pdb_asset non vide, donc les requêtes inline doivent inclure le PDB factice ci-dessous.
Échafaudage de motifs : lisez target.pdb, passez input_pdb, utilisez un contig comme "A25-35/0 50-80".
Conception de ligand : passez la cible input_pdb, un contig avec le segment cible et ligand, et hotspot_res=["A50", "A51", ...] au format ChainResidue.

DUMMY_PDB = (
    "CRYST1    1.000    1.000    1.000  90.00  90.00  90.00 P 1           1\n"
    "ATOM      1  CA  ALA A   1       0.000   0.000   0.000  1.00  0.00           C\n"
    "END\n"
)

Modèle de requête

import os
from pathlib import Path
import requests

HOSTED = True
url = (
    "https://health.api.nvidia.com/v1/biology/ipd/rfdiffusion/generate"
    if HOSTED else "http://localhost:8000/biology/ipd/rfdiffusion/generate"
)
headers = {"Content-Type": "application/json"}
if HOSTED:
    headers["Authorization"] = f"Bearer {os.getenv('NGC_API_KEY')}"

payload = {
    "input_pdb": DUMMY_PDB,
    "contigs": "80-120",
    "diffusion_steps": 50,
}
response = requests.post(url, headers=headers, json=payload, timeout=300)
response.raise_for_status()
result = response.json()
Path("designed_backbone.pdb").write_text(result["output_pdb"])

Échafaudage de motifs :

payload = {
    "input_pdb": Path("target.pdb").read_text(),
    "contigs": "A25-35/0 50-80",
    "diffusion_steps": 50,
}

Conception de ligand :

payload = {
    "input_pdb": Path("target.pdb").read_text(),
    "contigs": "A1-100/0 50-100",
    "hotspot_res": ["A50", "A51", "A52", "A53", "A54"],
    "diffusion_steps": 50,
}

Enregistrer et interpréter la sortie

Enregistrez result["output_pdb"] comme artefact PDB et signalez elapsed_ms si présent. Les chaînes générées ne sont pas des protéines finales ; alimentez-les avec ProteinMPNN pour la conception de séquence, puis validez les séquences/structures avec Boltz2 ou OpenFold3. Pour les vérifications PDB et contig, lisez references/validation.md.

Limites et dépannage

diffusion_steps : 1-50 ; 50 est la qualité maximale, moins est plus rapide.
GPU unique ; la VRAM GPU minimale est d'environ 12 GB.
hotspot_res utilise des chaînes comme "A50", pas des tuples.
422 signifie généralement que les IDs de chaîne dans contigs/hotspot_res ne correspondent pas à input_pdb, un contig malformé ou un input_pdb omis pour de novo hébergé.
L'URL locale 404 signifie généralement un préfixe /v1/ accidentel.

rfdiffusion-nim