LaminDB

Was macht LaminDB?

Übersicht

LaminDB ist ein quelloffenes, lineage-natives Lakehouse für die Biologie. Es macht Datensätze und Modelle durchsuchbar, nachvollziehbar, validiert, reproduzierbar und FAIR (Findable, Accessible, Interoperable, Reusable), während Daten in offenen Formaten auf lokalen Dateisystemen, S3, GCS, Hugging Face, SQLite und Postgres gespeichert werden können.

Zentrales Wertversprechen:

• Durchsuchbarkeit: Suchen und Filtern von Artefakten, Datensätzen, Runs, Features, Schemas und Sammlungen
• Nachvollziehbarkeit: Verfolgen von Eingaben, Ausgaben, Parametern, Quellcode und Umgebungen für Notebooks, Skripte, Funktionen und Pipelines
• Validierung: Kuratieren von DataFrames, AnnData, SpatialData, TileDB-SOMA, Parquet, Zarr und anderen biologischen Formaten mit Schemas
• FAIR-Compliance: Standardisierung von Annotationen mit Bionty-gestützten Ontologien und benutzerdefinierten Registern
• Änderungsmanagement: Organisation von Arbeit mit Projekten, Branches, Spaces, Sammlungen und gespeicherten Notizen oder Plänen

Wann man diesen Skill verwendet

Verwenden Sie diesen Skill, wenn:

• Verwaltung biologischer Datensätze: scRNA-seq, Bulk-RNA-seq, räumliche Transkriptomik, Durchflusszytometrie, multimodale Daten, EHR-Daten
• Verfolgung von Computer-Workflows: Notebooks, Skripte, Funktionen, Shell-Skripte und Pipeline-Ausführungen (Nextflow, Snakemake, Redun)
• Kuratieren und Validieren von Daten: Schema-Validierung, Standardisierung, ontologiebasierte Annotation
• Arbeiten mit biologischen Ontologien: Gene, Proteine, Zelltypen, Gewebe, Krankheiten, Signalwege (über Bionty)
• Aufbau von Data Lakehouses: Einheitliche Abfrageschnittstelle über mehrere Datensätze hinweg
• Sicherstellung der Reproduzierbarkeit: Automatische Versionierung, Nachverfolgung der Datenherkunft, Erfassen der Umgebung
• Integration von ML-Pipelines: Verbindung mit Weights & Biases, MLflow, Hugging Face, Lightning, scVI-tools
• Bereitstellung von Dateninfrastruktur: Einrichtung lokaler oder cloudbasierter Datenverwaltungssysteme
• Zusammenarbeit an Datensätzen: Teilen kuratierter, annotierter Daten mit standardisierten Metadaten

Kernfunktionen

LaminDB bietet sechs miteinander verbundene Funktionsbereiche, die jeweils im Referenzordner ausführlich dokumentiert sind.

1. Kernkonzepte und Datenherkunft (Data Lineage)

Kernentitäten:

• Artefakte: Versionierte Datensätze (DataFrame, AnnData, Parquet, Zarr, etc.)
• Records & ULabels: Experimentelle Entitäten, typisierte Records und einfache Labels
• Sammlungen: Versionierte, unveränderliche Mengen von Artefakten
• Runs & Transforms: Nachverfolgung der Berechnungsherkunft (welcher Code welche Daten erzeugt hat)
• Features: Typisierte Metadatenfelder für Annotation und Abfrage
• Projekte, Branches & Spaces: Projektgruppierung, Änderungsmanagement und Zugriffsgrenzen

Wichtige Workflows:

• Erstellen und Versionieren von Artefakten aus Dateien oder Python-Objekten
• Verfolgen der Notebook-/Skriptausführung mit ln.track() und ln.finish()
• Verfolgen von Funktions-Workflows mit @ln.flow() und @ln.step()
• Annotieren von Artefakten mit Records, ULabels, Projekten und typisierten Features
• Visualisieren von Datenherkunftsdiagrammen mit artifact.view_lineage()
• Abfragen nach Herkunft (alle Ausgaben von bestimmtem Code/Eingaben finden)

Referenz: references/core-concepts.md – Lesen Sie dies für detaillierte Informationen zu Artefakten, Records, Runs, Transforms, Features, Versionierung und Nachverfolgung der Datenherkunft.

2. Datenverwaltung und Abfrage

Abfragefunktionen:

• Erkundung und Suche in Registern mit Autovervollständigung
• Einzelnen Datensatz abrufen mit get(), one(), one_or_none()
• Filtern mit Vergleichsoperatoren (__gt, __lte, __contains, __startswith)
• Feature-basierte Abfragen, einschließlich Ausdrucksabfragen mit Feature-Objekten
• Registerübergreifende Navigation mit doppelter Unterstrich-Syntax
• Volltextsuche über Register hinweg
• Fortgeschrittene logische Abfragen mit ln.Q-Objekten (UND, ODER, NICHT)
• Streamen großer Datensätze, ohne sie in den Speicher zu laden

Wichtige Workflows:

• Artefakte mit Filtern und Sortierung durchsuchen
• Abfragen nach Features, Erstellungsdatum, Ersteller, Größe, etc.
• Große Dateien in Blöcken oder mit Array-Slicing streamen
• Daten mit hierarchischen Schlüsseln organisieren
• Artefakte in Sammlungen gruppieren

Referenz: references/data-management.md – Lesen Sie dies für umfassende Abfragemuster, Filterbeispiele, Streaming-Strategien und Best Practices zur Datenorganisation.

3. Annotation und Validierung

Kuratierungsprozess:

1. Validierung: Bestätigen, dass Datensätze den gewünschten Schemas entsprechen
2. Standardisierung: Korrigieren von Tippfehlern, Zuordnen von Synonymen zu kanonischen Begriffen
3. Annotation: Verknüpfen von Datensätzen mit Metadatenentitäten für die Durchsuchbarkeit

Schema-Typen:

• Flexible Schemas: Nur bekannte Spalten validieren, zusätzliche Metadaten zulassen
• Minimale erforderliche Schemas: Wesentliche Spalten angeben, weitere zulassen
• Strenge Schemas: Vollständige Kontrolle über Struktur und Werte

Unterstützte Datentypen:

• DataFrames (Parquet, CSV)
• AnnData (Einzelzellgenomik)
• MuData (multimodal)
• SpatialData (räumliche Transkriptomik)
• TileDB-SOMA (skalierbare Arrays)

Wichtige Workflows:

• Defnieren von Features und Schemas für die Datenvalidierung
• Verwenden von DataFrameCurator, AnnDataCurator, SpatialDataCurator oder TiledbsomaExperimentCurator für die Validierung
• Standardisieren von Werten mit .cat.standardize()
• Zuordnen zu Ontologien mit .cat.add_ontology()
• Speichern kuratierter Artefakte mit Schemaverknüpfung
• Abfragen validierter Datensätze nach Features

Referenz: references/annotation-validation.md – Lesen Sie dies für detaillierte Kuratierungs-Workflows, Schema-Design-Muster, Umgang mit Validierungsfehlern und Best Practices.

4. Biologische Ontologien

Verfügbare Ontologien (über Bionty):

• Gene (Ensembl), Proteine (UniProt)
• Zelltypen (CL), Zelllinien (CLO)
• Gewebe (Uberon), Krankheiten (Mondo, DOID)
• Phänotypen (HPO), Signalwege (GO)
• Experimentelle Faktoren (EFO), Entwicklungsstadien
• Organismen (NCBItaxon), Wirkstoffe (DrugBank)

Wichtige Workflows:

• Importieren öffentlicher Ontologien mit bt.CellType.import_source()
• Durchsuchen von Ontologien mit Schlüsselwort- oder exakter Übereinstimmung
• Standardisieren von Begriffen mithilfe von Synonymzuordnung
• Erkunden hierarchischer Beziehungen (Eltern, Kinder, Vorfahren)
• Validieren von Daten gegen Ontologiebegriffe
• Annotieren von Datensätzen mit Ontologie-Einträgen
• Erstellen benutzerdefinierter Begriffe und Hierarchien
• Umgang mit Kontexten mehrerer Organismen (Mensch, Maus, etc.)

Referenz: references/ontologies.md – Lesen Sie dies für umfassende Ontologie-Operationen, Standardisierungsstrategien, Hierarchie-Navigation und Annotations-Workflows.

5. Integrationen

Workflow-Manager:

• Nextflow: Verfolgen von Pipeline-Prozessen und -Ausgaben
• Snakemake: Integration in Snakemake-Regeln
• Redun: Kombinieren mit Redun-Task-Tracking
• Lightning: Speichern von Checkpoints und Trainingsmetadaten

MLOps-Plattformen:

• Weights & Biases: Verknüpfen von Experimenten mit Datenartefakten
• MLflow: Verfolgen von Modellen und Experimenten
• Hugging Face: Verfolgen von Modell-Feinabstimmungen
• scVI-tools: Workflows zur Einzelzellanalyse

Speichersysteme:

• Lokales Dateisystem, AWS S3, Google Cloud Storage
• S3-kompatibel (MinIO, Cloudflare R2)
• HTTP/HTTPS-Endpunkte (schreibgeschützt)
• HuggingFace-Datasets

Array-Stores:

• TileDB-SOMA (mit cellxgene-Unterstützung)
• DuckDB für SQL-Abfragen auf Parquet-Dateien

Visualisierung:

• Vitessce für interaktive Visualisierung räumlicher/Einzelzelldaten

Versionskontrolle:

• Git-Integration zur Nachverfolgung von Quellcode

Referenz: references/integrations.md – Lesen Sie dies für Integrationsmuster, Codebeispiele und Fehlerbehebung für Drittsysteme.

6. Einrichtung und Bereitstellung

Installation:

• Aktuelles stabiles Baseline: lamindb==2.5.1 (veröffentlicht am 2026-06-01; Python >=3.10, <=3.14)
• Basis: uv pip install 'lamindb==2.5.1'
• Mit Erweiterungen: uv pip install 'lamindb[gcp,zarr-v2,fcs]==2.5.1'
• Minimaler Namespace nur: uv pip install 'lamindb-core==2.5.1'
• Bionty-Modul: in der LaminDB-Dokumentation enthalten und verfügbar als uv pip install 'bionty==2.4.0'
• Optionale Module: Überprüfte Releases für Wetlab- oder klinische Schema-Module fixieren, anstatt die neuesten Versionen zu installieren

Instanztypen:

• Lokales SQLite (Entwicklung)
• Cloud-Speicher + SQLite (kleine Teams)
• Cloud-Speicher + PostgreSQL (Produktion)

Speicheroptionen:

• Lokales Dateisystem
• AWS S3 mit konfigurierbaren Regionen und Berechtigungen
• Google Cloud Storage
• S3-kompatible Endpunkte (MinIO, Cloudflare R2)

Konfiguration:

• Cache-Verwaltung für Cloud-Dateien
• Konfigurationen für Multi-User-Systeme
• Git-Repository-Synchronisation
• Benannte Umgebungsvariablen für Anmeldedaten und Verbindungs-URLs

Bereitstellungsmuster:

• Migration von lokaler Entwicklung zur Cloud-Produktion
• Multi-Region-Bereitstellungen
• Gemeinsamer Speicher mit persönlichen Instanzen

Referenz: references/setup-deployment.md – Lesen Sie dies für detaillierte Installations-, Konfigurations-, Speicher-Einrichtung, Datenbankverwaltung, Sicherheits-Best-Practices und Fehlerbehebung.

Sicherheits- und Sicherheitsstandardeinstellungen

Bei der Hilfe bei der LaminDB-Einrichtung oder Integrationen:

• Anzeigen, Protokollieren oder Übertragen Sie niemals tatsächliche API-Schlüssel, Cloud-Anmeldedaten, Datenbankkennwörter oder vollständige Verbindungszeichenfolgen, die Geheimnisse enthalten.
• Bevorzugen Sie IAM-Rollen, Workload Identity, Secret Manager oder benannte Umgebungsvariablen wie LAMIN_DB_URL, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY und GOOGLE_APPLICATION_CREDENTIALS; überprüfen Sie nur, ob eine benannte Variable vorhanden ist, nicht ihren Wert.
• Vor dem Speichern von Inhalten aus REST-APIs, externen Datenbanken oder benutzerbereitgestellten Dateien validieren und bereinigen Sie diese mit einem expliziten Schema oder Kurator.
• Fixieren Sie für reproduzierbare Installationen Paketversionen oder verwenden Sie eine Sperrdatei. Floating-Installationen sind nur akzeptabel, wenn der Benutzer explizit das neueste Upstream-Release wünscht.

Workflows für häufige Anwendungsfälle

Anwendungsfall 1: Einzelzell-RNA-seq-Analyse mit Ontologie-Validierung

import lamindb as ln
import bionty as bt
import anndata as ad

# Starten der Verfolgung eines Notebook-/Skriptlaufs
ln.track(params={"analysis": "scRNA-seq QC and annotation"})

# Importieren der Zelltyp-Ontologie
bt.CellType.import_source()

# Laden der Daten
adata = ad.read_h5ad("raw_counts.h5ad")

# Validieren und Standardisieren von Zelltypen
adata.obs["cell_type"] = bt.CellType.standardize(adata.obs["cell_type"])

# Kuratieren mit Schema
curator = ln.curators.AnnDataCurator(adata, schema)
curator.validate()
artifact = curator.save_artifact(key="scrna/validated.h5ad")

# Verknüpfen ontologiegestützter Annotationen für die Durchsuchbarkeit
cell_types = bt.CellType.from_values(adata.obs["cell_type"])
artifact.cell_types.add(*cell_types)

ln.finish()

Anwendungsfall 2: Aufbau eines durchsuchbaren Data Lakehouse

import lamindb as ln

# Mehrere Experimente registrieren
for i, file in enumerate(data_files):
    artifact = ln.Artifact.from_anndata(
        ad.read_h5ad(file),
        key=f"scrna/batch_{i}.h5ad",
        description=f"scRNA-seq batch {i}"
    ).save()

    # Mit Features annotieren
    artifact.features.set_values({
        "batch": i,
        "tissue": tissues[i],
        "condition": conditions[i]
    })

# Über alle Experimente hinweg nach annotierten Features abfragen
immune_datasets = ln.Artifact.filter(
    key__startswith="scrna/",
    tissue="PBMC",
    condition="treated"
).to_dataframe()

# Bestimmte Datensätze laden
for artifact in immune_datasets:
    adata = artifact.load()
    # Analysieren

Anwendungsfall 3: ML-Pipeline mit W&B-Integration

import lamindb as ln
import wandb

# Beide Systeme initialisieren
wandb.init(project="drug-response", name="exp-42")
ln.track(params={"model": "random_forest", "n_estimators": 100})

# Trainingsdaten aus LaminDB laden
train_artifact = ln.Artifact.get(key="datasets/train.parquet")
train_data = train_artifact.load()

# Modell trainieren
model = train_model(train_data)

# An W&B protokollieren
wandb.log({"accuracy": 0.95})

# Modell in LaminDB mit W&B-Verknüpfung speichern
import joblib
joblib.dump(model, "model.pkl")
model_artifact = ln.Artifact("model.pkl", key="models/exp-42.pkl").save()
model_artifact.features.set_values({"wandb_run_id": wandb.run.id})

ln.finish()
wandb.finish()

Anwendungsfall 4: Nextflow-Pipeline-Integration

# In einem Nextflow-Prozess-Skript
import lamindb as ln

ln.track()

# Eingabeartefakt laden
input_artifact = ln.Artifact.get(key="raw/batch_${batch_id}.fastq.gz")
input_path = input_artifact.cache()

# Verarbeiten (Alignment, Quantifizierung, etc.)
# ... Nextflow-Prozesslogik ...

# Ausgabe speichern
output_artifact = ln.Artifact(
    "counts.csv",
    key="processed/batch_${batch_id}_counts.csv"
).save()

ln.finish()

Für native Nextflow-Projekte bevorzugen Sie das nf-lamin-Plugin und aktuelle nextflow.config-Muster, sofern verfügbar; verwenden Sie Inline-Python-Verfolgung für kleine oder benutzerdefinierte Pipelineschritte.

Checkliste für den Einstieg

Um LaminDB effektiv zu nutzen:

1. Installation & Einrichtung (references/setup-deployment.md)

   • Fixiertes LaminDB und erforderliche Erweiterungen installieren
   • Authentifizieren mit lamin login
   • Instanz initialisieren mit lamin init --storage ...

2. Kernkonzepte lernen (references/core-concepts.md)

   • Artefakte, Records, Runs, Transforms verstehen
   • Erstellen und Abrufen von Artefakten üben
   • ln.track()/ln.finish() oder @ln.flow()/@ln.step() in Workflows implementieren

3. Abfragen meistern (references/data-management.md)

   • Filtern und Suchen in Registern üben
   • Feature-basierte Abfragen und Ausdrucksfilter lernen
   • Streamen großer Dateien ausprobieren

4. Validierung einrichten (references/annotation-validation.md)

   • Für den Forschungsbereich relevante Features definieren
   • Schemas für Datentypen erstellen
   • Kuratierungs-Workflows üben

5. Ontologien integrieren (references/ontologies.md)

   • Relevante biologische Ontologien importieren (Gene, Zelltypen, etc.)
   • Vorhandene Annotationen validieren
   • Metadaten mit Ontologiebegriffen standardisieren

6. Tools verbinden (references/integrations.md)

   • In vorhandene Workflow-Manager integrieren
   • ML-Plattformen für Experimentverfolgung anbinden
   • Cloud-Speicher und Compute konfigurieren

Wichtige Prinzipien

Befolgen Sie diese Prinzipien bei der Arbeit mit LaminDB:

1. Alles verfolgen: Verwenden Sie ln.track() zu Beginn jeder Analyse für die automatische Erfassung der Datenherkunft

2. Früh validieren: Definieren Sie Schemas und validieren Sie Daten vor einer umfangreichen Analyse

3. Ontologien verwenden: Nutzen Sie öffentliche biologische Ontologien für standardisierte Annotationen

…

[gekürzt für die Übersetzung]