Alphagenome Single Variant Analysis
google-deepmind/science-skills
Analyzes genetic variant effects on gene expression (RNA-seq), chromatin accessibility (DNASE), histone marks (ChIP), and transcription factors using the AlphaGenome API.
Infer and visualize intercellular communication from scRNA-seq with CellChat (R).
$ npx skills add jaechang-hits/SciAgent-Skills --skill cellchat-cell-communication -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install jaechang-hits/SciAgent-Skills cellchat-cell-communication --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/jaechang-hits/SciAgent-Skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/systems-biology-multiomics/cellchat-cell-communication .claude/skills/cellchat-cell-communication && rm -rf skills-srcUse ~/.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/
Install the "cellchat-cell-communication" agent skill from https://github.com/jaechang-hits/SciAgent-Skills/tree/main/skills/systems-biology-multiomics/cellchat-cell-communication into .claude/skills/cellchat-cell-communication/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "cellchat-cell-communication", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/jaechang-hits/SciAgent-Skills/tree/main/skills/systems-biology-multiomics/cellchat-cell-communicationType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add jaechang-hits/SciAgent-Skills --skill cellchat-cell-communication -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install jaechang-hits/SciAgent-Skills cellchat-cell-communication --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/jaechang-hits/SciAgent-Skills.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/systems-biology-multiomics/cellchat-cell-communication .agents/skills/cellchat-cell-communication && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "cellchat-cell-communication" agent skill from https://github.com/jaechang-hits/SciAgent-Skills/tree/main/skills/systems-biology-multiomics/cellchat-cell-communication into .agents/skills/cellchat-cell-communication/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "cellchat-cell-communication", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add jaechang-hits/SciAgent-Skills --skill cellchat-cell-communication -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install jaechang-hits/SciAgent-Skills cellchat-cell-communication --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/jaechang-hits/SciAgent-Skills.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/systems-biology-multiomics/cellchat-cell-communication .cursor/skills/cellchat-cell-communication && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "cellchat-cell-communication" agent skill from https://github.com/jaechang-hits/SciAgent-Skills/tree/main/skills/systems-biology-multiomics/cellchat-cell-communication into .cursor/skills/cellchat-cell-communication/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "cellchat-cell-communication", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/jaechang-hits/SciAgent-Skills.git --path skills/systems-biology-multiomics/cellchat-cell-communication--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add jaechang-hits/SciAgent-Skills --skill cellchat-cell-communication -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install jaechang-hits/SciAgent-Skills cellchat-cell-communication --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/jaechang-hits/SciAgent-Skills.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/systems-biology-multiomics/cellchat-cell-communication .gemini/skills/cellchat-cell-communication && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "cellchat-cell-communication" agent skill from https://github.com/jaechang-hits/SciAgent-Skills/tree/main/skills/systems-biology-multiomics/cellchat-cell-communication into .gemini/skills/cellchat-cell-communication/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "cellchat-cell-communication", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install jaechang-hits/SciAgent-Skills cellchat-cell-communicationInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add jaechang-hits/SciAgent-Skills --skill cellchat-cell-communication -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/jaechang-hits/SciAgent-Skills.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/systems-biology-multiomics/cellchat-cell-communication .github/skills/cellchat-cell-communication && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "cellchat-cell-communication" agent skill from https://github.com/jaechang-hits/SciAgent-Skills/tree/main/skills/systems-biology-multiomics/cellchat-cell-communication into .github/skills/cellchat-cell-communication/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "cellchat-cell-communication", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add jaechang-hits/SciAgent-Skills --skill cellchat-cell-communication -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install jaechang-hits/SciAgent-Skills cellchat-cell-communication --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/jaechang-hits/SciAgent-Skills.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/systems-biology-multiomics/cellchat-cell-communication .opencode/skills/cellchat-cell-communication && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "cellchat-cell-communication" agent skill from https://github.com/jaechang-hits/SciAgent-Skills/tree/main/skills/systems-biology-multiomics/cellchat-cell-communication into .opencode/skills/cellchat-cell-communication/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "cellchat-cell-communication", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
cellchat-cell-communicationInfer and visualize intercellular communication from scRNA-seq with CellChat (R).
Cellchat Cell Communication is an agent skill from jaechang-hits/SciAgent-Skills. Infer and visualize intercellular communication from scRNA-seq with CellChat (R). Build CellChat from Seurat/counts → subset CellChatDB ligand-receptor pairs → over-expressed genes per group → communication probabilities → pathway signaling → network centrality (senders/receivers/influencers) → chord/heatmap/bubble plots → cross-condition compare. Human, mouse. Use liana for pure-Python.
Its SKILL.md is about 6.8k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.
It sits in Research & Science, covering Bioinformatics and Influencer and creator marketing. It works with Python. The repository describes itself as: 197 bioinformatics & life science skills for Claude Code and AI agents — BixBench 92.0% accuracy. RNA-seq, single-cell, drug discovery, proteomics, and more. Powers OmicsHorizon. The licence is MIT.
8 steps, taken from the step headings in SKILL.md.
Read from SKILL.md and the folder at commit 82c862c. It shows what the files ask for, not the result of running them.
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.
No scripts in the folder and no shell commands in SKILL.md (its code samples are r, yaml and python).
From the folder's file list and the shell code blocks in SKILL.md.
Links to these hosts (documentation or services it may open):
htmlpreview.github.iogithub.comdoi.orgliana-py.readthedocs.ioFrom URLs in SKILL.md, links to its own repository left out.
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Cellchat Cell Communication loads about 6.8k tokens when it runs. Until then it costs about 105 tokens; SKILL.md has 1,471 words of instructions outside code blocks.
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.
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.
The full file from jaechang-hits/SciAgent-Skills at commit 82c862c, republished under its MIT licence (© jaechang-hits). 1,471 words, ~6,834 tokens.
.claude/skills/cellchat-cell-communication/SKILL.md (or your agent's skills folder).CellChat is an R package that infers and visualizes intercellular signaling networks from single-cell RNA-seq data. Starting from a normalized expression matrix and cluster labels, CellChat identifies ligand-receptor interactions supported by CellChatDB — a manually curated database of over 2,000 validated ligand-receptor pairs in human and mouse. Communication probability is modeled using the law of mass action, combining expression levels of ligands, receptors, and cofactors. CellChat aggregates pair-level probabilities into pathway-level signaling networks and quantifies each cell group's role as a signal sender, receiver, mediator, or influencer. The result is a rich, interpretable picture of which cell types talk to which, through which signaling pathways, and how these patterns change between conditions.
netVisual_*CellChat (>= 2.0), Seurat (>= 4.0, for Seurat-based input), NMF, ggplot2, ggalluvial, igraph, dplyr, patchwork, reticulate (optional)# Install CellChat from GitHub (CRAN version may lag)
if (!requireNamespace("BiocManager", quietly = TRUE))
install.packages("BiocManager")
BiocManager::install(c("BiocNeighbors", "ComplexHeatmap"))
install.packages("devtools")
devtools::install_github("jinworks/CellChat")
# Core dependencies
install.packages(c("NMF", "ggplot2", "ggalluvial", "igraph",
"dplyr", "patchwork", "circlize", "RColorBrewer"))Settle these with the user before writing any analysis code.
decisions:
- id: D1
param: cellGroupLabels
kind: derived
source: upstream
ask: "Which annotation column defines the sender and receiver groups?"
default: "the cell-type labels assigned upstream"
- id: D2
param: ligandReceptorDatabase
kind: required
source: user
ask: "Which species database, and should it cover all interactions or only secreted signalling, ECM-receptor, or cell-contact?"
default: "species-matched, all interaction categories"
- id: D3
param: minCellsPerGroup
kind: required
source: user
ask: "How few cells may a group have before its inferred signalling stops being trustworthy?"
default: 10
- id: D4
param: expressionAggregation
kind: optional
source: user
ask: "How should per-group expression be summarized - stringently, or more permissively so weaker signals survive?"
default: "triMean, the most stringent option"
- id: D5
param: populationSizeWeighting
kind: optional
source: user
ask: "Should communication probability account for how many cells each group has?"
default: "weighted"
- id: D6
param: bootstrapIterations
kind: optional_conditional
source: user
ask: "More bootstrap rounds give finer p-values at proportionally more runtime - is the default enough?"
default: 100
- id: D7
param: communicationPatterns
kind: optional_conditional
source: data
ask: "How many latent signalling patterns should the data be decomposed into?"
default: "chosen from the selectK elbow"
- id: D8
param: centralityThreshold
kind: optional
source: user
ask: "Which interactions are strong enough to enter the network-centrality analysis?"
default: "p-value 0.05"D1 is derived because these groups are the annotation the user already settled upstream; re-asking invites a different label set than the one the clusters carry. D4 shifts results more than its default suggests - the stringent aggregation drops interactions expressed in only part of a group, which is usually right and occasionally hides the signal being looked for.
library(CellChat)
library(Seurat)
# Assume `seurat_obj` is a processed Seurat object with cell type identities in Idents()
data.input <- GetAssayData(seurat_obj, assay = "RNA", slot = "data") # normalized counts
meta <- data.frame(labels = Idents(seurat_obj), row.names = names(Idents(seurat_obj)))
cellchat <- createCellChat(object = data.input, meta = meta, group.by = "labels")
cellchat@DB <- CellChatDB.human # or CellChatDB.mouse
cellchat <- subsetData(cellchat)
cellchat <- identifyOverExpressedGenes(cellchat)
cellchat <- identifyOverExpressedInteractions(cellchat)
cellchat <- computeCommunProb(cellchat, type = "triMean")
cellchat <- filterCommunication(cellchat, min.cells = 10)
cellchat <- computeCommunProbPathway(cellchat)
cellchat <- aggregateNet(cellchat)
# Quick summary
print(cellchat)
# e.g. "An object of class CellChat created from a single dataset
# with 8 cell groups and 312 inferred ligand-receptor pairs"Build a CellChat object from either a Seurat object or a raw count matrix with accompanying metadata.
library(CellChat)
library(Seurat)
# --- Option A: from a Seurat object ---
# seurat_obj must have cell type identities set with Idents() or in meta.data
data.input <- GetAssayData(seurat_obj, assay = "RNA", slot = "data") # log-normalized
meta <- data.frame(
labels = Idents(seurat_obj),
row.names = colnames(seurat_obj)
)
cellchat <- createCellChat(object = data.input, meta = meta, group.by = "labels")
# --- Option B: from a count matrix directly ---
# data.input: genes-by-cells normalized matrix (dgCMatrix or dense matrix)
# identity: named factor of cell group labels (length = ncol(data.input))
cellchat <- createCellChat(object = data.input, meta = data.frame(labels = identity),
group.by = "labels")
cat("Cell groups:", levels(cellchat@idents), "\n")
cat("Number of cells:", ncol(data.input), "\n")
# Cell groups: B_cell Endothelial Fibroblast Macrophage NK T_cell Tumor
# Number of cells: 12847Load the species-appropriate ligand-receptor database and optionally subset to a signaling category of interest.
# Load database for the appropriate species
CellChatDB <- CellChatDB.human # use CellChatDB.mouse for mouse data
# Inspect available signaling categories
unique(CellChatDB$interaction$annotation)
# [1] "Secreted Signaling" "ECM-Receptor" "Cell-Cell Contact"
# Option 1: Use all interactions (recommended for discovery)
cellchat@DB <- CellChatDB
# Option 2: Subset to secreted ligand-receptor pairs only (reduces noise)
CellChatDB.use <- subsetDB(CellChatDB, search = "Secreted Signaling",
key = "annotation")
cellchat@DB <- CellChatDB.use
# Subset the CellChat data slots to only genes in the database
cellchat <- subsetData(cellchat)
cat("Genes retained after database subset:", nrow(cellchat@data.signaling), "\n")
# Genes retained after database subset: 1842For each cell group, identify ligands and receptors that are significantly over-expressed compared to other groups.
# Identify over-expressed genes per cell group (uses Seurat-style wilcoxon test)
cellchat <- identifyOverExpressedGenes(cellchat)
# Map over-expressed genes to ligand-receptor pairs in CellChatDB
cellchat <- identifyOverExpressedInteractions(cellchat)
# Inspect how many interactions were identified per group pair
df.net <- subsetCommunication(cellchat)
cat("Total inferred interactions:", nrow(df.net), "\n")
head(df.net[, c("source", "target", "ligand", "receptor", "prob")], 5)
# source target ligand receptor prob
# 1 B_cell Macrophage CD22 PTPRC 0.0318
# 2 Fibroblast Tumor FN1 CD44 0.1072
# ...Compute communication probability for each ligand-receptor pair between every ordered pair of cell groups using the law of mass action. CellChat accounts for multi-subunit complexes and co-stimulatory/co-inhibitory cofactors.
# Compute pairwise communication probability
# type = "triMean": uses 25th percentile × mean × 25th percentile for robustness
# type = "truncatedMean": uses trimmed mean with threshold parameter trim
cellchat <- computeCommunProb(
cellchat,
type = "triMean", # recommended default
trim = 0.1, # fraction to trim (only used if type="truncatedMean")
nboot = 100, # bootstrap iterations for p-value estimation
seed.use = 42,
population.size = TRUE # weight by population size (recommended)
)
# Filter out interactions with too few cells in sender or receiver groups
cellchat <- filterCommunication(cellchat, min.cells = 10)
# Summary of retained interactions
df.net <- subsetCommunication(cellchat)
cat("Interactions after filtering:", nrow(df.net), "\n")
cat("Significant interactions (p<0.05):", sum(df.net$pval < 0.05), "\n")
# Interactions after filtering: 247
# Significant interactions (p<0.05): 189Aggregate ligand-receptor pair probabilities into signaling pathway-level networks (e.g., COLLAGEN, MHC-II, VEGF).
# Aggregate to pathway level
cellchat <- computeCommunProbPathway(cellchat)
# Build aggregate interaction count and weight networks
cellchat <- aggregateNet(cellchat)
# View significant pathways
cat("Significant signaling pathways:\n")
print(cellchat@netP$pathways)
# [1] "MHC-II" "COLLAGEN" "FN1" "VEGF" "CXCL"
# [6] "CCL" "MIF" "APP" "GALECTIN" ...
# Extract pathway-level communication probabilities between groups
df.pathways <- subsetCommunication(cellchat, slot.name = "netP")
head(df.pathways[, c("source", "target", "pathway_name", "prob")], 5)
# source target pathway_name prob
# 1 Fibroblast Tumor COLLAGEN 0.2341
# 2 Macrophage Fibroblast MIF 0.1876
# ...Identify each cell group's network role by computing information flow measures: out-strength (sender), in-strength (receiver), betweenness (mediator), and eigenvector centrality (influencer).
# Compute centrality measures for all pathways
cellchat <- netAnalysis_computeCentrality(cellchat, slot.name = "netP")
# Visualize centrality scores as a heatmap (rows=pathways, cols=cell groups)
# Each dot size: outgoing signal strength; color: incoming signal strength
netAnalysis_signalingRole_heatmap(
cellchat,
pattern = "all", # "outgoing", "incoming", or "all"
signaling = NULL, # NULL = all pathways; or specify e.g. c("COLLAGEN","VEGF")
height = 10,
color.heatmap = "OrRd"
)
# Identify dominant communication patterns using NMF
# outgoing patterns reveal which cell groups co-activate similar pathways
library(NMF)
selectK(cellchat, pattern = "outgoing") # elbow plot to choose K
cellchat <- identifyCommunicationPatterns(
cellchat,
pattern = "outgoing",
k = 3, # number of latent patterns; choose from selectK elbow
width = 8,
height = 6
)CellChat provides several visualization functions for both aggregate and pathway-specific interactions.
library(ggplot2)
library(patchwork)
# --- 7a. Chord diagram: aggregate interaction count and weight ---
par(mfrow = c(1, 2))
netVisual_circle(
cellchat@net$count,
vertex.weight = as.numeric(table(cellchat@idents)),
weight.scale = TRUE,
label.edge = FALSE,
title.name = "Number of interactions"
)
netVisual_circle(
cellchat@net$weight,
vertex.weight = as.numeric(table(cellchat@idents)),
weight.scale = TRUE,
label.edge = FALSE,
title.name = "Interaction strength"
)
# --- 7b. Heatmap: cell-group × cell-group interaction matrix ---
p1 <- netVisual_heatmap(cellchat, measure = "count", color.heatmap = "Blues")
p2 <- netVisual_heatmap(cellchat, measure = "weight", color.heatmap = "Reds")
p1 + p2
# --- 7c. Chord diagram for a specific pathway ---
netVisual_aggregate(
cellchat,
signaling = "COLLAGEN",
layout = "chord",
vertex.receiver = NULL # NULL = show all groups as receivers
)
# --- 7d. Bubble plot: all significant interactions for chosen pathways ---
netVisual_bubble(
cellchat,
sources.use = NULL, # NULL = all senders
targets.use = NULL, # NULL = all receivers
signaling = c("COLLAGEN", "MIF", "VEGF"),
remove.isolate = FALSE
)
ggsave("bubble_plot_selected_pathways.pdf", width = 10, height = 8)When you have two conditions (e.g., healthy and diseased), merge the CellChat objects and compare signaling networks.
# Assume cellchat_ctrl and cellchat_disease are pre-computed CellChat objects
object.list <- list(Control = cellchat_ctrl, Disease = cellchat_disease)
cellchat_merged <- mergeCellChat(object.list, add.names = names(object.list))
# --- Compare total interaction count and strength ---
compareInteractions(cellchat_merged, show.legend = FALSE,
group = c(1, 2), measure = "count")
compareInteractions(cellchat_merged, show.legend = FALSE,
group = c(1, 2), measure = "weight")
# --- Differential interaction chord diagram (gained/lost connections) ---
netVisual_diffInteraction(cellchat_merged, weight.scale = TRUE)
# --- Identify signaling pathways specific to each condition ---
rankNet(cellchat_merged, mode = "comparison", stacked = TRUE, do.stat = TRUE)
# --- Scatter plot: pathways shifted in information flow ---
rankNetPairwise(
cellchat_merged,
comparison = c(1, 2),
slot.name = "netP",
measure = "prob"
)| Parameter | Function | Default | Range / Options | Effect |
|---|---|---|---|---|
type | computeCommunProb | "triMean" | "triMean", "truncatedMean", "thresholdedMean", "median" | Aggregation method for group-level expression; triMean is most stringent |
trim | computeCommunProb | 0.1 | 0–0.25 | Fraction trimmed from each tail; only applies when type="truncatedMean" |
nboot | computeCommunProb | 100 | 50–1000 | Bootstrap iterations for p-value estimation; higher = slower but more accurate |
population.size | computeCommunProb | TRUE | TRUE, FALSE | Weight communication probability by cell group size; recommended for heterogeneous data |
min.cells | filterCommunication | 10 | 5–50 | Minimum number of cells required per sender or receiver group to retain an interaction |
k | identifyCommunicationPatterns | required | 2–6 (choose via selectK) | Number of latent communication patterns; use selectK elbow to select |
thresh | netAnalysis_computeCentrality | 0.05 | 0.01–0.1 | P-value cutoff for retaining interactions in centrality analysis |
sources.use | netVisual_bubble | NULL | cell group name(s) or index | Restrict sender cell groups in bubble plot; NULL = all |
targets.use | netVisual_bubble | NULL | cell group name(s) or index | Restrict receiver cell groups in bubble plot; NULL = all |
CellChat quantifies communication probability using the law of mass action. For a ligand L expressed in cell group A and receptor R (potentially a multi-subunit complex) expressed in cell group B:
P(A → B | L-R) = hill(expr_L_A) × hill(expr_R1_B) × hill(expr_R2_B) × ...where hill(x) = x^n / (K^n + x^n) (Hill function, n=1 by default), and expression values are group-aggregated using the chosen type argument. Multi-subunit receptor complexes require all subunits to be expressed; the probability is the product of Hill-transformed subunit expressions.
CellChatDB is a curated database of experimentally validated ligand-receptor interactions organized into three categories:
# Inspect the database structure
dim(CellChatDB.human$interaction) # [1] 2293 17
head(CellChatDB.human$interaction[, c("interaction_name", "pathway_name",
"ligand", "receptor", "annotation")], 4)
# interaction_name pathway_name ligand receptor annotation
# 1 TGFB1_TGFBR1_TGFBR2 TGFb TGFB1 TGFBR1_TGFBR2 Secreted Signaling
# 2 WNT5A_FZD1_LRP5 WNT WNT5A FZD1_LRP5 Secreted Signaling
# 3 FN1_CD44 FN1 FN1 CD44 ECM-Receptor
# 4 NOTCH1_DLL4 NOTCH NOTCH1 DLL4 Cell-Cell ContactThree categories cover distinct biological mechanisms:
| Role | Centrality Measure | Interpretation |
|---|---|---|
| Sender | Out-degree / out-strength | Cell groups that broadcast signals to many targets |
| Receiver | In-degree / in-strength | Cell groups that receive signals from many sources |
| Mediator | Betweenness centrality | Cell groups that bridge communication between other groups |
| Influencer | Eigenvector centrality | Cell groups connected to other highly-connected groups |
aggregateNet computes two complementary matrices:
cellchat@net$count: number of statistically significant ligand-receptor pairs per cell-group pair (raw interaction count)cellchat@net$weight: sum of communication probabilities across all pairs (interaction strength / information flow)High count with low weight indicates many weak interactions; high weight with low count indicates a few dominant pathways.
Use when you want to export results, apply custom filtering, or feed interactions into downstream pathway analysis.
# All ligand-receptor level interactions (p < 0.05)
df.lr <- subsetCommunication(cellchat, slot.name = "net")
df.lr_sig <- df.lr[df.lr$pval < 0.05, ]
cat("Significant LR interactions:", nrow(df.lr_sig), "\n")
# All pathway-level interactions
df.path <- subsetCommunication(cellchat, slot.name = "netP")
# Interactions involving specific cell groups
df.tumor_recv <- subsetCommunication(cellchat,
targets.use = "Tumor",
slot.name = "net")
cat("Interactions targeting Tumor cells:", nrow(df.tumor_recv), "\n")
# Save to CSV for downstream analysis
write.csv(df.lr_sig, "cellchat_lr_interactions.csv", row.names = FALSE)
write.csv(df.path, "cellchat_pathway_interactions.csv", row.names = FALSE)
write.csv(df.tumor_recv, "cellchat_tumor_receivers.csv", row.names = FALSE)Use when you want a detailed view of which cell types send and receive via one pathway.
# Show chord diagram + violin plots for a single pathway
pathway <- "COLLAGEN"
# Chord diagram
netVisual_aggregate(cellchat, signaling = pathway, layout = "chord")
title(main = paste0(pathway, " signaling network"))
# Contribution of each LR pair to the pathway
netAnalysis_contribution(cellchat, signaling = pathway)
# Gene expression of constituent ligands and receptors
plotGeneExpression(
cellchat,
signaling = pathway,
enriched.only = TRUE, # show only significantly enriched genes
type = "violin"
)Use when checkpointing a completed run before visualization or comparison steps.
# Save the completed CellChat object
saveRDS(cellchat, file = "cellchat_analysis.rds")
cat("Saved to cellchat_analysis.rds\n")
# Reload and resume analysis
cellchat_loaded <- readRDS("cellchat_analysis.rds")
cat("Cell groups:", levels(cellchat_loaded@idents), "\n")
cat("Pathways:", length(cellchat_loaded@netP$pathways), "\n")
# Verify the object is complete
slotNames(cellchat_loaded)
# [1] "data" "data.signaling" "images" "net"
# [5] "netP" "meta" "idents" "var.features"
# [9] "DB" "LR" "options"Use when your pipeline is Python-based or you want a consensus ranking across multiple LR databases.
# Install: pip install liana
import liana
import scanpy as sc
import pandas as pd
# Load preprocessed AnnData (cells x genes, log-normalized)
adata = sc.read_h5ad("my_scrna.h5ad")
# adata.obs["celltype"] must contain cluster/cell-type labels
# Run liana with CellChat resource (consensus across CellChatDB, CellPhoneDB, NATMI, etc.)
liana.mt.rank_aggregate(
adata,
groupby = "celltype",
resource_name = "consensus", # or "cellchat" for CellChat-only LR pairs
expr_prop = 0.1, # min fraction cells expressing ligand/receptor
verbose = True
)
# Results stored in adata.uns["liana_res"]
df = adata.uns["liana_res"]
df_sig = df[df["magnitude_rank"] < 0.05].sort_values("magnitude_rank")
print(df_sig[["source", "target", "ligand_complex", "receptor_complex",
"magnitude_rank"]].head(10))
df_sig.to_csv("liana_interactions.csv", index=False)| Output | Type | Description |
|---|---|---|
cellchat@net$count | R matrix (n_groups × n_groups) | Number of significant LR interactions between each cell-group pair |
cellchat@net$weight | R matrix (n_groups × n_groups) | Aggregate communication probability (information flow) between cell-group pairs |
cellchat@netP$pathways | Character vector | Names of all inferred signaling pathways |
subsetCommunication(cellchat) | data.frame | Table of all LR-level interactions with source, target, ligand, receptor, probability, p-value |
subsetCommunication(cellchat, slot.name="netP") | data.frame | Pathway-level interaction table |
| Chord diagram (PDF/PNG) | Figure | Circular diagram showing interaction strength between cell groups |
| Heatmap (PDF/PNG) | Figure | Cell-group × cell-group interaction count or weight heatmap |
| Bubble plot (PDF/PNG) | Figure | Dot plot showing interaction probabilities per LR pair per group pair |
| Signaling role heatmap (PDF/PNG) | Figure | Pathway × cell-group centrality scores (sender/receiver roles) |
| Problem | Likely Cause | Solution |
|---|---|---|
Error in computeCommunProb: all probabilities are zero | Genes in CellChatDB not detected or filtered out | Confirm subsetData() retains genes: nrow(cellchat@data.signaling) > 0; check that expression matrix is log-normalized (not raw counts) and that gene names match CellChatDB (human: HGNC symbols; mouse: MGI symbols) |
Warning: groups with fewer than min.cells cells are removed | Small clusters dropped at filtering step | Lower min.cells in filterCommunication() (e.g., min.cells = 5) or merge rare clusters before creating the CellChat object |
identifyCommunicationPatterns NMF error or no convergence | Number of patterns k too high or data too sparse | Use selectK() to choose k from the elbow in cophenetic/dispersion curves; try k=2 or k=3 first |
Memory error / session crash during computeCommunProb | Dataset too large for available RAM | Subsample to ≤30,000 cells per condition; or run computeCommunProb with nboot = 50 to reduce bootstrap memory footprint |
| Chord diagram is unreadable (too many cell groups) | Many fine-grained clusters | Aggregate clusters into broader categories before creating CellChat object; or use netVisual_heatmap which scales better with many groups |
mergeCellChat error: cell group labels do not match | Cell type names differ between objects | Harmonize levels(cellchat_ctrl@idents) and levels(cellchat_disease@idents) before merging; use setIdent() to rename groups |
| Gene symbols not recognized (all probabilities 0) | Mixed human/mouse gene naming convention | Confirm species: human genes are ALL CAPS (e.g., TGFB1); mouse genes are title case (e.g., Tgfb1). Set CellChatDB.mouse for mouse data |
© jaechang-hits, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
Just SKILL.md in skills/systems-biology-multiomics/cellchat-cell-communication of jaechang-hits/SciAgent-Skills.
Open the folder on GitHubat commit 82c862c
We found 2 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 2 other GitHub owners. This page covers the copy in jaechang-hits/SciAgent-Skills, which our catalogue first saw on October 7, 2026.
Cellchat Cell Communication 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.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Cellchat Cell Communication this skilljaechang-hits/SciAgent-Skills | 374 | 2 repos | ~6.8k | Automated safety check: Pass | MIT | |
| Alphagenome Single Variant Analysisgoogle-deepmind/science-skills | 3.2k | 2 repos | ~3k | Automated safety check: Notes | Apache-2.0 | |
| 13C Metabolic Flux AnalysisK-Dense-AI/scientific-agent-skills | 48k | 1 repos | ~3.2k | Automated safety check: Pass | MIT | |
| Singlecell Qcxuzhougeng/wisp-science | 1k | — | ~1.6k | Automated safety check: Pass | AGPL-3.0 | |
| Trackplotygidtu/trackplot | 109 | — | ~1.9k | Automated safety check: Pass | BSD-3-Clause | |
| UniProt Database Accessdavila7/claude-code-templates | 33k | 14 repos | ~1.7k | Automated safety check: Pass | MIT |
google-deepmind/science-skills
Analyzes genetic variant effects on gene expression (RNA-seq), chromatin accessibility (DNASE), histone marks (ChIP), and transcription factors using the AlphaGenome API.
K-Dense-AI/scientific-agent-skills
Estimates reaction fluxes inside cells from steady-state carbon-13 labeling data with a bundled mfapy-based solver, and reports which fluxes the data pin down.
xuzhougeng/wisp-science
A skill your agent uses when designing, reviewing, or implementing single-cell RNA-seq QC in Python or R with a human-in-the-loop, data-driven approach.
ygidtu/trackplot
Generate sashimi-style genome visualization plots (coverage, line, heatmap, IGV read-by-read, HiC, circRNA, motif) from BAM/bigWig/depth/HiC inputs.
davila7/claude-code-templates
Queries the UniProt REST API directly to search proteins, fetch FASTA sequences, map IDs between databases and read Swiss-Prot and TrEMBL entries.
QING1105/ezST
End-to-end 10x Visium spatial transcriptomics analysis workflow with staged execution and human review gates.
jaechang-hits/SciAgent-Skills
NEB-IRC activation energy pipeline for reaction barriers using GFN2-xTB and pysisyphus.
jaechang-hits/SciAgent-Skills
3Dmol.js WebGL molecular visualization emitted as self-contained HTML.
jaechang-hits/SciAgent-Skills
Constraint-based (COBRA) analysis of genome-scale metabolic models: FBA, FVA, knockouts, flux sampling, production envelopes, gapfilling, media optimization.
jaechang-hits/SciAgent-Skills
Read, write, and edit ChemDraw CDX/CDXML files with RDKit's rdkit.Chem.rdChemDraw plus direct XML editing, always paired with a rendered PNG.
jaechang-hits/SciAgent-Skills
Programmatic PubMed access via NCBI E-utilities REST API. An agent skill from jaechang-hits/SciAgent-Skills.
jaechang-hits/SciAgent-Skills
Scaffold a new SciAgent-Skills entry. An agent skill from jaechang-hits/SciAgent-Skills.
Works with
Categories
Infer and visualize intercellular communication from scRNA-seq with CellChat (R). Cellchat Cell Communication is an agent skill from jaechang-hits/SciAgent-Skills. Infer and visualize intercellular communication from scRNA-seq with CellChat (R).
Cellchat Cell Communication fits situations like: tasks that involve Bioinformatics; tasks that involve Influencer and creator marketing.
Run `npx skills add jaechang-hits/SciAgent-Skills --skill cellchat-cell-communication -a claude-code`. Or copy the skill folder (skills/systems-biology-multiomics/cellchat-cell-communication in jaechang-hits/SciAgent-Skills) into .claude/skills/cellchat-cell-communication in your project. Claude Code loads it when a task matches its description.
Run `npx skills add jaechang-hits/SciAgent-Skills --skill cellchat-cell-communication -a codex`. Or copy the skill folder (skills/systems-biology-multiomics/cellchat-cell-communication in jaechang-hits/SciAgent-Skills) into .agents/skills/cellchat-cell-communication in your project. Codex loads it when a task matches its description.
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add jaechang-hits/SciAgent-Skills --skill cellchat-cell-communication -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/cellchat-cell-communication, .gemini/skills/cellchat-cell-communication, .github/skills/cellchat-cell-communication and .opencode/skills/cellchat-cell-communication in your project.
SKILL.md names no scripts, command-line tools or credentials: Cellchat Cell Communication is instructions for the agent only. Our summary lists: Python 3.
SKILL.md names 4 domains. As links in the text: htmlpreview.github.io, github.com, doi.org and liana-py.readthedocs.io. This is read from the text; nothing was executed.
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.
Cellchat Cell Communication is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.
About 6.8k tokens (SKILL.md is roughly 27k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.
Skills that share tags, products or a category with Cellchat Cell Communication: Alphagenome Single Variant Analysis (google-deepmind/science-skills, 3.2k stars), 13C Metabolic Flux Analysis (K-Dense-AI/scientific-agent-skills, 48k stars), Singlecell Qc (xuzhougeng/wisp-science, 1k stars) and Trackplot (ygidtu/trackplot, 109 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
jaechang-hits (a GitHub user) maintains it in jaechang-hits/SciAgent-Skills, which has 374 GitHub stars. The repository holds 169 skills in this directory. The repository was last updated on September 29, 2026.
Source: jaechang-hits/SciAgent-Skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.