New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

LaminDB Biological Data Management

by davila7 in davila7/claude-code-templates

Manages biological datasets with LaminDB: versioned artifacts, run lineage, ontology-based annotation, schema validation and links to workflow managers and ML tools.

MITAuto-check passedResearch & Science

Install LaminDB Biological Data Management

skills CLI
$ npx skills add davila7/claude-code-templates --skill lamindb -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install davila7/claude-code-templates lamindb --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/davila7/claude-code-templates.git skills-src && mkdir -p .claude/skills && cp -r skills-src/cli-tool/components/skills/scientific/lamindb .claude/skills/lamindb && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
lamindb
GitHub stars
32k
Used in
12 other repos
Token cost
~3.6k tokens
SKILL.md length
1,207 words
Files
7 (incl. references)
Skills in repo
477
Repo updated
First seen
Licence
MIT

At a glance

Manages biological datasets with LaminDB: versioned artifacts, run lineage, ontology-based annotation, schema validation and links to workflow managers and ML tools.

  • Works in 6 steps: Core Concepts and Data Lineage → Data Management and Querying → Annotation and Validation → …
  • Recording which code and inputs produced a dataset in a biology project
  • SKILL.md covers Overview, When to Use This Skill, Core Capabilities and Common Use Case Workflows, plus 4 more sections
  • Calls uv

What it does

LaminDB is an open-source Python data framework for biology that aims to make datasets queryable, traceable, reproducible and FAIR. The skill covers its core entities (artifacts, records, runs and transforms, and typed features), tracking notebooks and scripts with `ln.track()` and `ln.finish()`, and viewing lineage graphs with `artifact.view_lineage()`.

It also covers curating and validating data against biological ontologies for genes, proteins, cell types, tissues and diseases through Bionty, building a lakehouse-style query layer across datasets, and connecting to Nextflow, Snakemake, Weights & Biases, MLflow, HuggingFace and scVI-tools. Six reference files split the material into core concepts, data management, annotation and validation, ontologies, integrations, and setup and deployment.

When your agent uses it

  • Recording which code and inputs produced a dataset in a biology project
  • Validating single-cell data against gene or cell type ontologies
  • Versioning and annotating AnnData or Parquet artifacts with typed features
  • Setting up a local or cloud LaminDB instance for a lab

Example prompts

  • “Track this notebook with LaminDB and register the output AnnData file as a versioned artifact.”
  • “Validate the cell type column in my dataset against the Bionty ontology and list the terms that fail.”
  • “Show the lineage graph for the artifact we saved after the clustering step.”

Requirements

  • A Python environment with LaminDB
  • A local or cloud LaminDB instance

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. Core Concepts and Data Lineage
  2. Data Management and Querying
  3. Annotation and Validation
  4. Biological Ontologies
  5. Integrations
  6. Setup and Deployment

What it can do on your machine

Read from SKILL.md and the folder at commit 14680ec. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • uv

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • docs.lamin.ai
    • github.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

LaminDB Biological Data Management loads about 3.6k tokens when it runs, and up to ~22k if it reads all its reference files. Until then it costs about 165 tokens; SKILL.md has 1,207 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~165
When it runs · the whole SKILL.md, loaded when a task matches
~3.6k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~22k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from davila7/claude-code-templates at commit 14680ec, republished under its MIT licence (© davila7). 1,207 words, ~3,575 tokens.

Download SKILL.mdSave it as .claude/skills/lamindb/SKILL.md (or your agent's skills folder). This skill also uses 6 other files; get the full folder from GitHub.
name
lamindb
description
This skill should be used when working with LaminDB, an open-source data framework for biology that makes data queryable, traceable, reproducible, and FAIR. Use when managing biological datasets (scRNA-seq, spatial, flow cytometry, etc.), tracking computational workflows, curating and validating data with biological ontologies, building data lakehouses, or ensuring data lineage and reproducibility in biological research. Covers data management, annotation, ontologies (genes, cell types, diseases, tissues), schema validation, integrations with workflow managers (Nextflow, Snakemake) and MLOps platforms (W&B, MLflow), and deployment strategies.

LaminDB

Overview

LaminDB is an open-source data framework for biology designed to make data queryable, traceable, reproducible, and FAIR (Findable, Accessible, Interoperable, Reusable). It provides a unified platform that combines lakehouse architecture, lineage tracking, feature stores, biological ontologies, LIMS (Laboratory Information Management System), and ELN (Electronic Lab Notebook) capabilities through a single Python API.

Core Value Proposition:

  • Queryability: Search and filter datasets by metadata, features, and ontology terms
  • Traceability: Automatic lineage tracking from raw data through analysis to results
  • Reproducibility: Version control for data, code, and environment
  • FAIR Compliance: Standardized annotations using biological ontologies

When to Use This Skill

Use this skill when:

  • Managing biological datasets: scRNA-seq, bulk RNA-seq, spatial transcriptomics, flow cytometry, multi-modal data, EHR data
  • Tracking computational workflows: Notebooks, scripts, pipeline execution (Nextflow, Snakemake, Redun)
  • Curating and validating data: Schema validation, standardization, ontology-based annotation
  • Working with biological ontologies: Genes, proteins, cell types, tissues, diseases, pathways (via Bionty)
  • Building data lakehouses: Unified query interface across multiple datasets
  • Ensuring reproducibility: Automatic versioning, lineage tracking, environment capture
  • Integrating ML pipelines: Connecting with Weights & Biases, MLflow, HuggingFace, scVI-tools
  • Deploying data infrastructure: Setting up local or cloud-based data management systems
  • Collaborating on datasets: Sharing curated, annotated data with standardized metadata

Core Capabilities

LaminDB provides six interconnected capability areas, each documented in detail in the references folder.

1. Core Concepts and Data Lineage

Core entities:

  • Artifacts: Versioned datasets (DataFrame, AnnData, Parquet, Zarr, etc.)
  • Records: Experimental entities (samples, perturbations, instruments)
  • Runs & Transforms: Computational lineage tracking (what code produced what data)
  • Features: Typed metadata fields for annotation and querying

Key workflows:

  • Create and version artifacts from files or Python objects
  • Track notebook/script execution with ln.track() and ln.finish()
  • Annotate artifacts with typed features
  • Visualize data lineage graphs with artifact.view_lineage()
  • Query by provenance (find all outputs from specific code/inputs)

Reference: references/core-concepts.md - Read this for detailed information on artifacts, records, runs, transforms, features, versioning, and lineage tracking.

2. Data Management and Querying

Query capabilities:

  • Registry exploration and lookup with auto-complete
  • Single record retrieval with get(), one(), one_or_none()
  • Filtering with comparison operators (__gt, __lte, __contains, __startswith)
  • Feature-based queries (query by annotated metadata)
  • Cross-registry traversal with double-underscore syntax
  • Full-text search across registries
  • Advanced logical queries with Q objects (AND, OR, NOT)
  • Streaming large datasets without loading into memory

Key workflows:

  • Browse artifacts with filters and ordering
  • Query by features, creation date, creator, size, etc.
  • Stream large files in chunks or with array slicing
  • Organize data with hierarchical keys
  • Group artifacts into collections

Reference: references/data-management.md - Read this for comprehensive query patterns, filtering examples, streaming strategies, and data organization best practices.

3. Annotation and Validation

Curation process:

  1. Validation: Confirm datasets match desired schemas
  2. Standardization: Fix typos, map synonyms to canonical terms
  3. Annotation: Link datasets to metadata entities for queryability

Schema types:

  • Flexible schemas: Validate only known columns, allow additional metadata
  • Minimal required schemas: Specify essential columns, permit extras
  • Strict schemas: Complete control over structure and values

Supported data types:

  • DataFrames (Parquet, CSV)
  • AnnData (single-cell genomics)
  • MuData (multi-modal)
  • SpatialData (spatial transcriptomics)
  • TileDB-SOMA (scalable arrays)

Key workflows:

  • Define features and schemas for data validation
  • Use DataFrameCurator or AnnDataCurator for validation
  • Standardize values with .cat.standardize()
  • Map to ontologies with .cat.add_ontology()
  • Save curated artifacts with schema linkage
  • Query validated datasets by features

Reference: references/annotation-validation.md - Read this for detailed curation workflows, schema design patterns, handling validation errors, and best practices.

4. Biological Ontologies

Available ontologies (via Bionty):

  • Genes (Ensembl), Proteins (UniProt)
  • Cell types (CL), Cell lines (CLO)
  • Tissues (Uberon), Diseases (Mondo, DOID)
  • Phenotypes (HPO), Pathways (GO)
  • Experimental factors (EFO), Developmental stages
  • Organisms (NCBItaxon), Drugs (DrugBank)

Key workflows:

  • Import public ontologies with bt.CellType.import_source()
  • Search ontologies with keyword or exact matching
  • Standardize terms using synonym mapping
  • Explore hierarchical relationships (parents, children, ancestors)
  • Validate data against ontology terms
  • Annotate datasets with ontology records
  • Create custom terms and hierarchies
  • Handle multi-organism contexts (human, mouse, etc.)

Reference: references/ontologies.md - Read this for comprehensive ontology operations, standardization strategies, hierarchy navigation, and annotation workflows.

5. Integrations

Workflow managers:

  • Nextflow: Track pipeline processes and outputs
  • Snakemake: Integrate into Snakemake rules
  • Redun: Combine with Redun task tracking

MLOps platforms:

  • Weights & Biases: Link experiments with data artifacts
  • MLflow: Track models and experiments
  • HuggingFace: Track model fine-tuning
  • scVI-tools: Single-cell analysis workflows

Storage systems:

  • Local filesystem, AWS S3, Google Cloud Storage
  • S3-compatible (MinIO, Cloudflare R2)
  • HTTP/HTTPS endpoints (read-only)
  • HuggingFace datasets

Array stores:

  • TileDB-SOMA (with cellxgene support)
  • DuckDB for SQL queries on Parquet files

Visualization:

  • Vitessce for interactive spatial/single-cell visualization

Version control:

  • Git integration for source code tracking

Reference: references/integrations.md - Read this for integration patterns, code examples, and troubleshooting for third-party systems.

Show full SKILL.md (464 more words)Show less
6. Setup and Deployment

Installation:

  • Basic: uv pip install lamindb
  • With extras: uv pip install 'lamindb[gcp,zarr,fcs]'
  • Modules: bionty, wetlab, clinical

Instance types:

  • Local SQLite (development)
  • Cloud storage + SQLite (small teams)
  • Cloud storage + PostgreSQL (production)

Storage options:

  • Local filesystem
  • AWS S3 with configurable regions and permissions
  • Google Cloud Storage
  • S3-compatible endpoints (MinIO, Cloudflare R2)

Configuration:

  • Cache management for cloud files
  • Multi-user system configurations
  • Git repository sync
  • Environment variables

Deployment patterns:

  • Local dev → Cloud production migration
  • Multi-region deployments
  • Shared storage with personal instances

Reference: references/setup-deployment.md - Read this for detailed installation, configuration, storage setup, database management, security best practices, and troubleshooting.

Common Use Case Workflows

Use Case 1: Single-Cell RNA-seq Analysis with Ontology Validation
python
import lamindb as ln
import bionty as bt
import anndata as ad

# Start tracking
ln.track(params={"analysis": "scRNA-seq QC and annotation"})

# Import cell type ontology
bt.CellType.import_source()

# Load data
adata = ad.read_h5ad("raw_counts.h5ad")

# Validate and standardize cell types
adata.obs["cell_type"] = bt.CellType.standardize(adata.obs["cell_type"])

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

# Link ontology annotations
cell_types = bt.CellType.from_values(adata.obs.cell_type)
artifact.feature_sets.add_ontology(cell_types)

ln.finish()
Use Case 2: Building a Queryable Data Lakehouse
python
import lamindb as ln

# Register multiple experiments
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()

    # Annotate with features
    artifact.features.add_values({
        "batch": i,
        "tissue": tissues[i],
        "condition": conditions[i]
    })

# Query across all experiments
immune_datasets = ln.Artifact.filter(
    key__startswith="scrna/",
    tissue="PBMC",
    condition="treated"
).to_dataframe()

# Load specific datasets
for artifact in immune_datasets:
    adata = artifact.load()
    # Analyze
Use Case 3: ML Pipeline with W&B Integration
python
import lamindb as ln
import wandb

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

# Load training data from LaminDB
train_artifact = ln.Artifact.get(key="datasets/train.parquet")
train_data = train_artifact.load()

# Train model
model = train_model(train_data)

# Log to W&B
wandb.log({"accuracy": 0.95})

# Save model in LaminDB with W&B linkage
import joblib
joblib.dump(model, "model.pkl")
model_artifact = ln.Artifact("model.pkl", key="models/exp-42.pkl").save()
model_artifact.features.add_values({"wandb_run_id": wandb.run.id})

ln.finish()
wandb.finish()
Use Case 4: Nextflow Pipeline Integration
python
# In Nextflow process script
import lamindb as ln

ln.track()

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

# Process (alignment, quantification, etc.)
# ... Nextflow process logic ...

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

ln.finish()

Getting Started Checklist

To start using LaminDB effectively:

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

    • Install LaminDB and required extras
    • Authenticate with lamin login
    • Initialize instance with lamin init --storage ...

  2. Learn Core Concepts (references/core-concepts.md)

    • Understand Artifacts, Records, Runs, Transforms
    • Practice creating and retrieving artifacts
    • Implement ln.track() and ln.finish() in workflows

  3. Master Querying (references/data-management.md)

    • Practice filtering and searching registries
    • Learn feature-based queries
    • Experiment with streaming large files

  4. Set Up Validation (references/annotation-validation.md)

    • Define features relevant to research domain
    • Create schemas for data types
    • Practice curation workflows

  5. Integrate Ontologies (references/ontologies.md)

    • Import relevant biological ontologies (genes, cell types, etc.)
    • Validate existing annotations
    • Standardize metadata with ontology terms

  6. Connect Tools (references/integrations.md)

    • Integrate with existing workflow managers
    • Link ML platforms for experiment tracking
    • Configure cloud storage and compute

Key Principles

Follow these principles when working with LaminDB:

  1. Track everything: Use ln.track() at the start of every analysis for automatic lineage capture

  2. Validate early: Define schemas and validate data before extensive analysis

  3. Use ontologies: Leverage public biological ontologies for standardized annotations

  4. Organize with keys: Structure artifact keys hierarchically (e.g., project/experiment/batch/file.h5ad)

  5. Query metadata first: Filter and search before loading large files

  6. Version, don't duplicate: Use built-in versioning instead of creating new keys for modifications

  7. Annotate with features: Define typed features for queryable metadata

  8. Document thoroughly: Add descriptions to artifacts, schemas, and transforms

  9. Leverage lineage: Use view_lineage() to understand data provenance

  10. Start local, scale cloud: Develop locally with SQLite, deploy to cloud with PostgreSQL

Reference Files

This skill includes comprehensive reference documentation organized by capability:

  • references/core-concepts.md - Artifacts, records, runs, transforms, features, versioning, lineage
  • references/data-management.md - Querying, filtering, searching, streaming, organizing data
  • references/annotation-validation.md - Schema design, curation workflows, validation strategies
  • references/ontologies.md - Biological ontology management, standardization, hierarchies
  • references/integrations.md - Workflow managers, MLOps platforms, storage systems, tools
  • references/setup-deployment.md - Installation, configuration, deployment, troubleshooting

Read the relevant reference file(s) based on the specific LaminDB capability needed for the task at hand.

Additional Resources

© davila7, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 6 other files (references) in cli-tool/components/skills/scientific/lamindb of davila7/claude-code-templates.

  • SKILL.md
  • references/annotation-validation.md
  • references/core-concepts.md
  • references/data-management.md
  • references/integrations.md
  • references/ontologies.md
  • references/setup-deployment.md

Open the folder on GitHubat commit 14680ec

Used in 12 other repositories

We found 14 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 12 other GitHub owners. This page covers the copy in davila7/claude-code-templates, which our catalogue first saw on October 7, 2026.

Compare with similar skills

LaminDB Biological Data Management next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

LaminDB Biological Data Management compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
LaminDB Biological Data Management this skilldavila7/claude-code-templates32k12 repos~3.6kAutomated safety check: PassMIT
Lamindbaipoch/medical-research-skills2k—~4.8kAutomated safety check: PassMIT
Latchbio IntegrationK-Dense-AI/scientific-agent-skills48k1 repos~2.5kAutomated safety check: NotesMIT
PacsomaticK-Dense-AI/scientific-agent-skills48k1 repos~1.6kAutomated safety check: PassMIT
ScanpyK-Dense-AI/scientific-agent-skills48k1 repos~5.1kAutomated safety check: PassBSD-3-Clause
Dnanexus IntegrationK-Dense-AI/scientific-agent-skills48k1 repos~3.1kAutomated safety check: PassMIT

Similar skills

  • Lamindb

    aipoch/medical-research-skills

    This skill is applicable when using LaminDB. An agent skill from aipoch/medical-research-skills.

    2k GitHub stars~4.8k tokensUpdated 21 days ago
    Research & ScienceAuto-check passed

  • Latchbio Integration

    K-Dense-AI/scientific-agent-skills

    Builds, registers, debugs, and operates bioinformatics workflows on Latch using the Python SDK, CLI, Latch Data and Registry, Nextflow, Snakemake, programmatic execution, and Latch MCP.

    48k GitHub starsUsed in 1 repo~2.5k tokens
    Research & ScienceAuto-check: notes

  • Pacsomatic

    K-Dense-AI/scientific-agent-skills

    Prepares and launches nf-core/pacsomatic matched tumor-normal PacBio HiFi genomics workflows from unaligned BAM inputs.

    48k GitHub starsUsed in 1 repo~1.6k tokens
    Research & ScienceAuto-check passed

  • Scanpy

    K-Dense-AI/scientific-agent-skills

    Performs Scanpy single-cell RNA-seq QC, normalization, HVG selection, PCA/UMAP/t-SNE, clustering, exploratory marker ranking, pseudobulk preparation, visualization, and Seurat or…

    48k GitHub starsUsed in 1 repo~5.1k tokens
    Research & ScienceAuto-check passed

  • Dnanexus Integration

    K-Dense-AI/scientific-agent-skills

    Builds and operates reproducible genomics workloads on DNAnexus with the dx CLI, dxpy, apps/applets, native workflows, dxCompiler, and Nextflow.

    48k GitHub starsUsed in 1 repo~3.1k tokens
    Research & ScienceAuto-check passed

  • Repro Enforcer

    ClawBio/ClawBio

    Export any bioinformatics analysis as a reproducible bundle with Conda environment, Singularity container definition, and Nextflow pipeline.

    1.2k GitHub starsUsed in 3 repos~413 tokens
    Research & ScienceAuto-check passed

More from davila7/claude-code-templates

All 477 skills in this repo

  • Perplexity Web Search

    davila7/claude-code-templates

    Runs web-grounded searches through Perplexity's Sonar models over OpenRouter for current events, recent literature and cited facts beyond the model's training cutoff.

    32k GitHub starsUsed in 12 repos~3.5k tokens
    Auto-check: notes

  • Neuropixels Data Analysis

    davila7/claude-code-templates

    Analyzes Neuropixels recordings from SpikeGLX or Open Ephys through preprocessing, drift correction, Kilosort4 spike sorting, quality metrics and curation.

    32k GitHub starsUsed in 10 repos~2.8k tokens
    Auto-check passed

  • Scientific Venue Templates

    davila7/claude-code-templates

    Supplies LaTeX templates and formatting rules for journals, conferences, posters, and grant proposals, then can check a draft against them.

    32k GitHub starsUsed in 9 repos~5.1k tokens
    Auto-check: notes

  • Brand Voice Content Creator

    davila7/claude-code-templates

    Analyzes a brand's existing writing to lock in a consistent voice, then builds SEO blog posts and platform-specific social content around it.

    32k GitHub starsUsed in 3 repos~1.9k tokens
    Auto-check passed

  • CAPA Officer

    davila7/claude-code-templates

    Guides corrective and preventive action (CAPA) work in a quality management system, from initiation and root cause analysis through effectiveness verification.

    32k GitHub starsUsed in 1 repo~2k tokens
    Auto-check passed

  • Fda Consultant Specialist

    davila7/claude-code-templates

    Senior FDA consultant and specialist for medical device companies including HIPAA compliance and requirement management.

    32k GitHub starsUsed in 1 repo~2.7k tokens
    Auto-check passed

Works with

Categories

Questions about LaminDB Biological Data Management

What does LaminDB Biological Data Management do?

Manages biological datasets with LaminDB: versioned artifacts, run lineage, ontology-based annotation, schema validation and links to workflow managers and ML tools. LaminDB is an open-source Python data framework for biology that aims to make datasets queryable, traceable, reproducible and FAIR.view_lineage()`.

When should I use LaminDB Biological Data Management?

LaminDB Biological Data Management fits situations like: recording which code and inputs produced a dataset in a biology project; validating single-cell data against gene or cell type ontologies; versioning and annotating AnnData or Parquet artifacts with typed features; setting up a local or cloud LaminDB instance for a lab.

How do I install LaminDB Biological Data Management in Claude Code?

Run `npx skills add davila7/claude-code-templates --skill lamindb -a claude-code`. Or copy the skill folder (cli-tool/components/skills/scientific/lamindb in davila7/claude-code-templates) into .claude/skills/lamindb in your project. Claude Code loads it when a task matches its description.

How do I install LaminDB Biological Data Management in Codex?

Run `npx skills add davila7/claude-code-templates --skill lamindb -a codex`. Or copy the skill folder (cli-tool/components/skills/scientific/lamindb in davila7/claude-code-templates) into .agents/skills/lamindb in your project. Codex loads it when a task matches its description.

Can I use LaminDB Biological Data Management in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add davila7/claude-code-templates --skill lamindb -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/lamindb, .gemini/skills/lamindb, .github/skills/lamindb and .opencode/skills/lamindb in your project.

What does LaminDB Biological Data Management need to run?

Going by SKILL.md and its folder, LaminDB Biological Data Management needs the command-line tools its instructions call (uv). Our summary lists: A Python environment with LaminDB; A local or cloud LaminDB instance.

Does LaminDB Biological Data Management access the network?

SKILL.md names 2 domains. As links in the text: docs.lamin.ai and github.com. This is read from the text; nothing was executed.

Is LaminDB Biological Data Management safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does LaminDB Biological Data Management use?

LaminDB Biological Data Management is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does LaminDB Biological Data Management use?

About 3.6k tokens (SKILL.md is roughly 14k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 19k tokens, read only when the agent opens those files.

What are the alternatives to LaminDB Biological Data Management?

Skills that share tags, products or a category with LaminDB Biological Data Management: Lamindb (aipoch/medical-research-skills, 2k stars), Latchbio Integration (K-Dense-AI/scientific-agent-skills, 48k stars), Pacsomatic (K-Dense-AI/scientific-agent-skills, 48k stars) and Scanpy (K-Dense-AI/scientific-agent-skills, 48k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains LaminDB Biological Data Management?

davila7 (a GitHub user) maintains it in davila7/claude-code-templates, which has 32,463 GitHub stars. The repository holds 477 skills in this directory. The repository was last updated on October 8, 2026.

Source: davila7/claude-code-templates on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.