Init Analysis logo

Init Analysis

OrganizationPopular
OpenLAIR
init-analysis

This skill should be used when the user asks to "run initial analysis", "analyze single-cell data", "QC my data", "run bioinformatics pipeline", "generate analysis report", "explore my dataset", "do exploratory data analysis", "initial data analysis", or needs to perform quality control, dimensionality reduction, clustering, or marker analysis on single-cell biology data (CyTOF, scRNA-seq, flow cytometry, proteomics).

Overview

PublisherOpenLAIR
Repositorydr-claw
Skill nameinit-analysis
Stars
1.2K
Forks
136
Bundled files
Instructions only
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by OpenLAIR on GitHub. Read the source before you install it.

Installation

Install the Init Analysis AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/OpenLAIR/dr-claw/tree/main/skills/bioinformatics-init-analysis/skills/init-analysis
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/OpenLAIR/dr-claw.git /tmp/dr-claw
mkdir -p .claude/skills
cp -r /tmp/dr-claw/skills/bioinformatics-init-analysis/skills/init-analysis .claude/skills/init-analysis
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Init Analysis in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Init Analysis on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Init Analysis is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Bioinformatics Initial Data Analysis

Automated 7-step analysis pipeline for high-dimensional single-cell biology data with plain-language report generation.

Supported Data Types

The pipeline auto-detects input data type:

Data TypeFile FormatsDetection Pattern
scRNA-seq.h5ad, .h5 (10X), .mtx + barcodesGene names, count matrix
CyTOF.csv, .h5adPhospho-markers (p.ERK, p.AKT, etc.)
Flow cytometry.fcs, .csvSurface markers, scatter channels

Approach 1: Full Pipeline (Recommended)

Run the complete 7-step analysis:

bash
python3 scripts/run_pipeline.py <input_path> \
    [--data-type auto|cytof|scrnaseq|flow] \
    [--subsample 500] \
    [--output-dir ./analysis_output] \
    [--report-style clinical|technical]

Arguments:

  • input_path: Path to data file (.h5ad, .csv, .h5) or directory of CSV files
  • --data-type: Data type override (default: auto for auto-detection)
  • --subsample: Max cells per group for tractable analysis (default: 500)
  • --output-dir: Output directory (default: ./analysis_output)
  • --report-style: clinical for plain-language medical summaries, technical for bioinformatics detail (default: clinical)

Output Files:

analysis_output/
├── figures/                    # All generated plots (PNG)
├── processed/
│   └── adata_processed.h5ad   # Processed AnnData object
├── report.html                 # Complete analysis report
└── analysis_summary.json       # Machine-readable summary statistics

Approach 2: Modular Steps

For custom workflows, import individual step modules:

python
from step1_load_data import load_data
from step2_qc import run_qc
from step3_normalize import normalize_data
from step4_dim_reduction import run_dim_reduction
from step5_clustering import run_clustering
from step6_marker_analysis import run_marker_analysis
from step7_report import generate_report

Each step function accepts an AnnData object and returns the modified AnnData plus a dictionary of results/figures.

Pipeline Steps

Step 1: Data Loading

Load data from various formats into AnnData. For directories of CSVs (e.g., CyTOF per-cell-line files), automatically concatenate with metadata. Apply subsampling if dataset is large.

Step 2: Quality Control

Data-type-aware QC:

  • CyTOF: MAD-based outlier detection per marker, signal distributions, batch effects across cell lines
  • scRNA-seq: Mitochondrial %, genes per cell, counts per cell, doublet detection
  • Universal: Missing value assessment, distribution violin plots, outlier flagging

Step 3: Normalization

  • CyTOF: Data is typically pre-transformed (arcsinh). Verify transformation, apply z-score for dim. reduction.
  • scRNA-seq: Library size normalization (CPM) -> log1p -> HVG selection -> z-score scaling
  • Store raw values in adata.raw for downstream differential analysis.

Step 4: Dimensionality Reduction

PCA with scree plot and loadings analysis, followed by UMAP visualization colored by all available metadata and key markers.

Step 5: Clustering

Leiden graph-based clustering at multiple resolutions. Evaluate with ARI, NMI, Silhouette scores if reference labels exist. Visualize cluster composition across metadata categories.

Step 6: Marker Analysis

Wilcoxon rank-sum differential expression per cluster. Marker correlation heatmap. If treatment/condition metadata exists: treatment response analysis with boxplots and effect heatmaps. If time metadata exists: time-course dynamics.

Step 7: Report Generation

Generate HTML report with embedded figures and interpretations. Two styles:

  • Clinical: Written for medical doctors and non-bioinformaticians. Each plot includes "What this shows", "Key findings", and "Clinical relevance" sections.
  • Technical: Standard bioinformatics report with methods, parameters, and statistical details.

Reference Files

For detailed guidance, consult:

  • references/plot_interpretation_guide.md - How to explain each plot type to non-experts
  • references/cytof_specifics.md - CyTOF-specific QC, normalization, and markers
  • references/scrnaseq_specifics.md - scRNA-seq-specific processing details
  • references/statistical_methods.md - Plain-language glossary of statistical methods

Important Notes

  • CyTOF data is often pre-transformed: Check value ranges before applying arcsinh. Values in range [-1, 15] indicate arcsinh-transformed data.
  • Large datasets: Always subsample for initial exploration. Use 500-2000 cells per group.
  • NaN handling: Always run nan_to_num after z-score scaling — constant-value features produce NaN.
  • Leiden timeout: For >50K cells, Leiden clustering may take >10 minutes. Reduce subsample size.
  • Report audience: Default to clinical style unless user requests technical detail.

Frequently asked questions

What does the Init Analysis AI skill do?

This skill should be used when the user asks to "run initial analysis", "analyze single-cell data", "QC my data", "run bioinformatics pipeline", "generate analysis report", "explore my dataset", "do exploratory data analysis", "initial data analysis", or needs to perform quality control, dimensionality reduction, clustering, or marker analysis on single-cell biology data (CyTOF, scRNA-seq, flow cytometry, proteomics).

Why use Init Analysis on TypingMind?

Because you install it once and use it with any model. Init Analysis is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Init Analysis in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/OpenLAIR/dr-claw/tree/main/skills/bioinformatics-init-analysis/skills/init-analysis. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Init Analysis?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Init Analysis?

As many as you like. As long as a model supports skills, you can use Init Analysis with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Init Analysis AI skill free?

It is published on GitHub by OpenLAIR. Check the repository for licensing terms. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇