latchbio-integration

Par mkurman · zorai

Plateforme Latch pour les workflows en bioinformatique. Créez des pipelines avec le SDK Latch, les décorateurs @workflow/@task, déployez des workflows serverless, LatchFile/LatchDir, intégration Nextflow/Snakemake.

npx skills add https://github.com/mkurman/zorai --skill latchbio-integration

Intégration LatchBio

Vue d'ensemble

Latch est un framework Python pour construire et déployer des workflows de bioinformatique comme des pipelines serverless. Construit sur Flyte, créez des workflows avec les décorateurs @workflow/@task, gérez les données cloud avec LatchFile/LatchDir, configurez les ressources et intégrez les pipelines Nextflow/Snakemake.

Capacités principales

La plateforme Latch propose quatre domaines de fonctionnalité :

1. Création et déploiement de workflows

  • Définissez des workflows serverless avec des décorateurs Python
  • Support pour les pipelines Python natifs, Nextflow et Snakemake
  • Conteneurisation automatique avec Docker
  • Interfaces utilisateur sans code auto-générées
  • Contrôle de version et reproductibilité

2. Gestion des données

  • Abstractions de stockage cloud (LatchFile, LatchDir)
  • Organisation structurée des données avec Registry (Projects → Tables → Records)
  • Opérations de données type-safe avec liens et énumérations
  • Transfert automatique de fichiers entre local et cloud
  • Correspondance par pattern glob pour la sélection de fichiers

3. Configuration des ressources

  • Décorateurs de tâche préconfigurés (@small_task, @large_task, @small_gpu_task, @large_gpu_task)
  • Spécifications de ressources personnalisées (CPU, mémoire, GPU, stockage)
  • Support GPU (K80, V100, A100)
  • Configuration des timeouts et du stockage
  • Stratégies d'optimisation des coûts

4. Workflows vérifiés

  • Pipelines pré-construits prêts pour la production
  • Bulk RNA-seq, DESeq2, analyse de voies biologiques
  • AlphaFold et ColabFold pour la prédiction de structure protéique
  • Outils single-cell (ArchR, scVelo, emptyDropsR)
  • Analyse CRISPR, phylogénétique et bien plus

Démarrage rapide

Installation et configuration

# Installer Latch SDK
python3 -m uv pip install latch

# Se connecter à Latch
latch login

# Initialiser un nouveau workflow
latch init my-workflow

# Enregistrer le workflow sur la plateforme
latch register my-workflow

Prérequis :

  • Docker installé et en cours d'exécution
  • Identifiants de compte Latch
  • Python 3.8+

Exemple de workflow basique

from latch import workflow, small_task
from latch.types import LatchFile

@small_task
def process_file(input_file: LatchFile) -> LatchFile:
    """Traiter un fichier unique"""
    # Logique de traitement
    return output_file

@workflow
def my_workflow(input_file: LatchFile) -> LatchFile:
    """
    Mon workflow de bioinformatique

    Args:
        input_file: Fichier de données d'entrée
    """
    return process_file(input_file=input_file)

Quand utiliser cette compétence

Cette compétence doit être utilisée dans les scénarios suivants :

Développement de workflows :

  • « Créer un workflow Latch pour l'analyse RNA-seq »
  • « Déployer mon pipeline sur Latch »
  • « Convertir mon pipeline Nextflow en Latch »
  • « Ajouter le support GPU à mon workflow »
  • Travail avec les décorateurs @workflow, @task

Gestion des données :

  • « Organiser mes données de séquençage dans Latch Registry »
  • « Comment utiliser LatchFile et LatchDir ? »
  • « Configurer le suivi des échantillons dans Latch »
  • Travail avec les chemins latch:///

Configuration des ressources :

  • « Configurer GPU pour AlphaFold sur Latch »
  • « Ma tâche manque de mémoire »
  • « Comment optimiser les coûts du workflow ? »
  • Travail avec les décorateurs de tâche

Workflows vérifiés :

  • « Exécuter AlphaFold sur Latch »
  • « Utiliser DESeq2 pour l'expression différentielle »
  • « Workflows pré-construits disponibles »
  • Utilisation du module latch.verified

Documentation détaillée

Cette compétence inclut une documentation de référence complète organisée par capacité :

references/workflow-creation.md

Lisez ceci pour :

  • Créer et enregistrer des workflows
  • Définition et décorateurs de tâche
  • Support Python, Nextflow, Snakemake
  • Plans de lancement et sections conditionnelles
  • Exécution de workflows (CLI et programmatique)
  • Pipelines multi-étapes et parallèles
  • Dépannage des problèmes d'enregistrement

Thèmes clés :

  • Commandes latch init et latch register
  • Décorateurs @workflow et @task
  • Bases de LatchFile et LatchDir
  • Annotations de type et docstrings
  • Plans de lancement avec paramètres prédéfinis
  • Sections UI conditionnelles

references/data-management.md

Lisez ceci pour :

  • Stockage cloud avec LatchFile et LatchDir
  • Système Registry (Projects, Tables, Records)
  • Enregistrements liés et relations
  • Colonnes énumérées et typées
  • Opérations en masse et transactions
  • Intégration avec les workflows
  • Gestion des comptes et espaces de travail

Thèmes clés :

  • Format de chemin latch:///
  • Transfert de fichiers et patterns glob
  • Création et interrogation de tables Registry
  • Types de colonnes (string, number, file, link, enum)
  • Opérations CRUD sur les enregistrements
  • Intégration Workflow-Registry

references/resource-configuration.md

Lisez ceci pour :

  • Décorateurs de ressources de tâche
  • Configuration personnalisée du CPU, mémoire, GPU
  • Types de GPU (K80, V100, A100)
  • Paramètres de timeout et stockage
  • Stratégies d'optimisation des ressources
  • Conception de workflows économes
  • Surveillance et débogage

Thèmes clés :

  • @small_task, @large_task, @small_gpu_task, @large_gpu_task
  • @custom_task avec spécifications précises
  • Configuration multi-GPU
  • Sélection des ressources par type de charge de travail
  • Limites et quotas de plateforme

references/verified-workflows.md

Lisez ceci pour :

  • Workflows pré-construits en production
  • Bulk RNA-seq et DESeq2
  • AlphaFold et ColabFold
  • Analyse single-cell (ArchR, scVelo)
  • Analyse d'édition CRISPR
  • Enrichissement de voies biologiques
  • Intégration avec les workflows personnalisés

Thèmes clés :

  • Imports du module latch.verified
  • Workflows vérifiés disponibles
  • Paramètres et options de workflow
  • Combinaison d'étapes vérifiées et personnalisées
  • Gestion des versions

Patterns de workflows courants

Pipeline RNA-seq complet

from latch import workflow, small_task, large_task
from latch.types import LatchFile, LatchDir

@small_task
def quality_control(fastq: LatchFile) -> LatchFile:
    """Exécuter FastQC"""
    return qc_output

@large_task
def alignment(fastq: LatchFile, genome: str) -> LatchFile:
    """Alignement STAR"""
    return bam_output

@small_task
def quantification(bam: LatchFile) -> LatchFile:
    """featureCounts"""
    return counts

@workflow
def rnaseq_pipeline(
    input_fastq: LatchFile,
    genome: str,
    output_dir: LatchDir
) -> LatchFile:
    """Pipeline d'analyse RNA-seq"""
    qc = quality_control(fastq=input_fastq)
    aligned = alignment(fastq=qc, genome=genome)
    return quantification(bam=aligned)

Workflow accéléré par GPU

from latch import workflow, small_task, large_gpu_task
from latch.types import LatchFile

@small_task
def preprocess(input_file: LatchFile) -> LatchFile:
    """Préparer les données"""
    return processed

@large_gpu_task
def gpu_computation(data: LatchFile) -> LatchFile:
    """Analyse accélérée par GPU"""
    return results

@workflow
def gpu_pipeline(input_file: LatchFile) -> LatchFile:
    """Pipeline avec tâches GPU"""
    preprocessed = preprocess(input_file=input_file)
    return gpu_computation(data=preprocessed)

Workflow intégré à Registry

from latch import workflow, small_task
from latch.registry.table import Table
from latch.registry.record import Record
from latch.types import LatchFile

@small_task
def process_and_track(sample_id: str, table_id: str) -> str:
    """Traiter l'échantillon et mettre à jour Registry"""
    # Récupérer l'échantillon depuis la registry
    table = Table.get(table_id=table_id)
    records = Record.list(table_id=table_id, filter={"sample_id": sample_id})
    sample = records[0]

    # Traiter
    input_file = sample.values["fastq_file"]
    output = process(input_file)

    # Mettre à jour la registry
    sample.update(values={"status": "completed", "result": output})
    return "Success"

@workflow
def registry_workflow(sample_id: str, table_id: str):
    """Workflow intégré à Registry"""
    return process_and_track(sample_id=sample_id, table_id=table_id)

Bonnes pratiques

Conception de workflows

  1. Utilisez les annotations de type pour tous les paramètres
  2. Écrivez des docstrings clairs (apparaissent dans l'UI)
  3. Commencez par les décorateurs de tâche standard, augmentez si nécessaire
  4. Divisez les workflows complexes en tâches modulaires
  5. Implémentez une gestion des erreurs appropriée

Gestion des données

  1. Utilisez des structures de dossiers cohérentes
  2. Définissez les schémas Registry avant l'entrée en masse
  3. Utilisez les enregistrements liés pour les relations
  4. Stockez les métadonnées dans Registry pour la traçabilité

Configuration des ressources

  1. Dimensionnez correctement les ressources (sans sur-allocation)
  2. Utilisez GPU uniquement quand les algorithmes le supportent
  3. Surveillez les métriques d'exécution et optimisez
  4. Concevez pour l'exécution parallèle si possible

Flux de développement

  1. Testez localement avec Docker avant l'enregistrement
  2. Utilisez le contrôle de version pour le code du workflow
  3. Documentez les exigences en ressources
  4. Profilez les workflows pour déterminer les besoins réels

Dépannage

Problèmes courants

Échecs d'enregistrement :

  • Assurez-vous que Docker est en cours d'exécution
  • Vérifiez l'authentification avec latch login
  • Vérifiez toutes les dépendances dans le Dockerfile
  • Utilisez le drapeau --verbose pour des logs détaillés

Problèmes de ressources :

  • Manque de mémoire : Augmentez la mémoire dans le décorateur de tâche
  • Timeouts : Augmentez le paramètre de timeout
  • Problèmes de stockage : Augmentez storage_gib

Accès aux données :

  • Utilisez le format de chemin latch:/// correct
  • Vérifiez que le fichier existe dans l'espace de travail
  • Vérifiez les permissions pour les espaces de travail partagés

Erreurs de type :

  • Ajoutez des annotations de type à tous les paramètres
  • Utilisez LatchFile/LatchDir pour les paramètres fichier/répertoire
  • Assurez-vous que le type de retour du workflow correspond au retour réel

Ressources supplémentaires

Support

Pour les problèmes ou les questions :

  1. Consultez les liens de documentation ci-dessus
  2. Recherchez dans les issues GitHub
  3. Posez des questions dans la communauté Slack
  4. Contactez support@latch.bio

Skills similaires

lamindb
mkurman / zorai

Gérer, annoter et tracer des données biologiques avec une API Python unifiée.

309
nextflow-development
anthropics / knowledge-work-plugins

Déployer et exécuter des pipelines bioinformatiques nf-core sur données locales ou publiques.

19 276
polars-bio
mkurman / zorai

Effectuer des opérations génomiques ultra-rapides sur intervalles et fichiers bioinformatiques avec Polars.

309
biopython
mkurman / zorai

Manipuler séquences biologiques, structures 3D et bases de données NCBI en Python.

309
rowan
mkurman / zorai

Modéliser des molécules et orchestrer des workflows de chimie médicinale dans le cloud.

309