pi-skill-search 0.1.0

package/skills/omc-setup/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: omc-setup
+description: Install or refresh oh-my-claudecode for plugin, npm, and local-dev setups from the canonical setup flow
+---
+
+# OMC Setup
+
+This is the **only command you need to learn**. After running this, everything else is automatic.
+
+**When this skill is invoked, immediately execute the workflow below. Do not only restate or summarize these instructions back to the user.**
+
+Note: All `~/.claude/...` paths in this guide respect `CLAUDE_CONFIG_DIR` when that environment variable is set.
+
+## Best-Fit Use
+
+Choose this setup flow when the user wants to **install, refresh, or repair OMC itself**.
+
+- Marketplace/plugin install users should land here after `/plugin install oh-my-claudecode`
+- npm users should land here after `npm i -g oh-my-claude-sisyphus@latest`
+- local-dev and worktree users should land here after updating the checked-out repo and rerunning setup
+
+## Flag Parsing
+
+Check for flags in the user's invocation:
+- `--help` → Show Help Text (below) and stop
+- `--local` → Phase 1 only (target=local), then stop
+- `--global` → Phase 1 only (target=global), then stop
+- `--force` → Skip Pre-Setup Check, run full setup (Phase 1 → 2 → 3 → 4)
+- No flags → Run Pre-Setup Check, then full setup if needed
+
+## Help Text
+
+When user runs with `--help`, display this and stop:
+
+```
+OMC Setup - Configure oh-my-claudecode
+
+USAGE:
+  omc-setup           Run initial setup wizard (or update if already configured)
+  omc-setup --local   Configure local project (.claude/CLAUDE.md)
+  omc-setup --global  Configure global settings (~/.claude/CLAUDE.md)
+  omc-setup --force   Force full setup wizard even if already configured
+  omc-setup --help    Show this help
+
+MODES:
+  Initial Setup (no flags)
+    - Interactive wizard for first-time setup
+    - Configures CLAUDE.md (local or global)
+    - Sets up HUD statusline
+    - Checks for updates
+    - Offers MCP server configuration
+    - Configures team mode defaults (agent count, type, model)
+    - If already configured, offers quick update option
+
+  Local Configuration (--local)
+    - Downloads fresh CLAUDE.md to ./.claude/
+    - Backs up existing CLAUDE.md to .claude/CLAUDE.md.backup.YYYY-MM-DD
+    - Project-specific settings
+    - Use this to update project config after OMC upgrades
+
+  Global Configuration (--global)
+    - Downloads fresh CLAUDE.md to ~/.claude/
+    - Backs up existing CLAUDE.md to ~/.claude/CLAUDE.md.backup.YYYY-MM-DD
+    - Default: explicitly overwrites ~/.claude/CLAUDE.md so plain `claude` also uses OMC
+    - Optional preserve mode keeps the user's base `CLAUDE.md` and installs OMC into `CLAUDE-omc.md` for `omc` launches
+    - Applies to all Claude Code sessions
+    - Cleans up legacy hooks
+    - Use this to update global config after OMC upgrades
+
+  Force Full Setup (--force)
+    - Bypasses the "already configured" check
+    - Runs the complete setup wizard from scratch
+    - Use when you want to reconfigure preferences
+
+EXAMPLES:
+  omc-setup           # First time setup (or update CLAUDE.md if configured)
+  omc-setup --local   # Update this project
+  omc-setup --global  # Update all projects
+  omc-setup --force   # Re-run full setup wizard
+
+For more info: https://github.com/Yeachan-Heo/oh-my-claudecode
+```

package/skills/omc-teams/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: omc-teams
+description: CLI-team runtime for claude, codex, or gemini workers in tmux panes when you need process-based parallel execution
+---
+
+# OMC Teams Skill
+
+Spawn N CLI worker processes in tmux panes to execute tasks in parallel. Supports `claude`, `codex`, and `gemini` agent types.
+
+`/omc-teams` is a legacy compatibility skill for the CLI-first runtime: use `omc team ...` commands (not deprecated MCP runtime tools).
+
+## Usage
+
+```bash
+omc-teams N:claude "task description"
+omc-teams N:codex "task description"
+omc-teams N:gemini "task description"
+```
+
+### Parameters
+
+- **N** - Number of CLI workers (1-10)
+- **agent-type** - `claude` (Claude CLI), `codex` (OpenAI Codex CLI), or `gemini` (Google Gemini CLI)
+- **task** - Task description to distribute across all workers
+
+### Examples
+
+```bash
+/omc-teams 2:claude "implement auth module with tests"
+/omc-teams 2:codex "review the auth module for security issues"
+/omc-teams 3:gemini "redesign UI components for accessibility"
+```
+
+## Requirements
+
+- **tmux binary** must be installed and discoverable (`command -v tmux`)
+- **Classic tmux session optional** for in-place pane splitting (`$TMUX` set). Inside cmux or a plain terminal, `omc team` falls back to a detached tmux session instead of splitting the current surface.
+- **claude** CLI: `npm install -g @anthropic-ai/claude-code`
+- **codex** CLI: `npm install -g @openai/codex`
+- **gemini** CLI: `npm install -g @google/gemini-cli`
+
+## Workflow
+
+### Phase 0: Verify prerequisites
+
+Check tmux explicitly before claiming it is missing:
+
+```bash
+command -v tmux >/dev/null 2>&1
+```
+
+- If this fails, report that **tmux is not installed** and stop.
+- If `$TMUX` is set, `omc team` can reuse the current tmux window/panes directly.
+- If `$TMUX` is empty but `CMUX_SURFACE_ID` is set, report that the user is running inside **cmux**. Do **not** say tmux is missing or that they are "not inside tmux"; `omc team` will launch a **detached tmux session** for workers instead of splitting the cmux surface.
+- If neither `$TMUX` nor `CMUX_SURFACE_ID` is set, report that the user is in a **plain terminal**. `omc team` can still launch a **detached tmux session**, but if they specifically want in-place pane/window topology they should start from a classic tmux session first.
+- If you need to confirm the active tmux session, use:
+
+```bash
+tmux display-message -p '#S'
+```
+
+### Phase 1: Parse + validate input
+
+Extract:
+
+- `N` — worker count (1–10)
+- `agent-type` — `claude|codex|gemini`
+- `task` — task description
+
+Validate before decomposing or running anything:
+
+- Reject unsupported agent types up front. `/omc-teams` only supports **`claude`**, **`codex`**, and **`gemini`**.
+- If the user asks for an unsupported type such as `expert`, explain that `/omc-teams` launches external CLI workers only.
+- For native Claude Code team agents/roles, direct them to **`team`** instead.
+
+### Phase 2: Decompose task
+
+Break work into N independent subtasks (file- or concern-scoped) to avoid write conflicts.
+
+### Phase 2.5: Resolve workspace root for multi-repo plans
+

package/skills/omero-integration/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: omero-integration
+description: Microscopy data management platform. Access images via Python, retrieve datasets, analyze pixels, manage ROIs/annotations, batch processing, for high-content screening and microscopy workflows.
+---
+
+# OMERO Integration
+
+## Overview
+
+OMERO is an open-source platform for managing, visualizing, and analyzing microscopy images and metadata. Access images via Python API, retrieve datasets, analyze pixels, manage ROIs and annotations, for high-content screening and microscopy workflows.
+
+## When to Use This Skill
+
+This skill should be used when:
+- Working with OMERO Python API (omero-py) to access microscopy data
+- Retrieving images, datasets, projects, or screening data programmatically
+- Analyzing pixel data and creating derived images
+- Creating or managing ROIs (regions of interest) on microscopy images
+- Adding annotations, tags, or metadata to OMERO objects
+- Storing measurement results in OMERO tables
+- Creating server-side scripts for batch processing
+- Performing high-content screening analysis
+
+## Core Capabilities
+
+This skill covers eight major capability areas. Each is documented in detail in the references/ directory:
+
+### 1. Connection & Session Management
+**File**: `(see docs)`
+
+Establish secure connections to OMERO servers, manage sessions, handle authentication, and work with group contexts. Use this for initial setup and connection patterns.
+
+**Common scenarios:**
+- Connect to OMERO server with credentials
+- Use existing session IDs
+- Switch between group contexts
+- Manage connection lifecycle with context managers
+
+### 2. Data Access & Retrieval
+**File**: `(see docs)`
+
+Navigate OMERO's hierarchical data structure (Projects → Datasets → Images) and screening data (Screens → Plates → Wells). Retrieve objects, query by attributes, and access metadata.
+
+**Common scenarios:**
+- List all projects and datasets for a user
+- Retrieve images by ID or dataset
+- Access screening plate data
+- Query objects with filters
+
+### 3. Metadata & Annotations
+**File**: `(see docs)`
+
+Create and manage annotations including tags, key-value pairs, file attachments, and comments. Link annotations to images, datasets, or other objects.
+
+**Common scenarios:**
+- Add tags to images
+- Attach analysis results as files
+- Create custom key-value metadata
+- Query annotations by namespace
+
+### 4. Image Processing & Rendering
+**File**: `(see docs)`
+
+Access raw pixel data as NumPy arrays, manipulate rendering settings, create derived images, and manage physical dimensions.
+
+**Common scenarios:**
+- Extract pixel data for computational analysis
+- Generate thumbnail images
+- Create maximum intensity projections
+- Modify channel rendering settings
+
+### 5. Regions of Interest (ROIs)
+**File**: `(see docs)`
+
+Create, retrieve, and analyze ROIs with various shapes (rectangles, ellipses, polygons, masks, points, lines). Extract intensity statistics from ROI regions.
+
+**Common scenarios:**
+- Draw rectangular ROIs on images
+- Create polygon masks for segmentation
+- Analyze pixel intensities within ROIs
+- Export ROI coordinates
+
+### 6. OMERO Tables
+**File**: `(see docs)`
+
+Store and query structured tabular data associated with OMERO objects. Useful for analysis results, measurements, and metadata.
+
+**Common scenarios:**
+- Store quantitative measurements for images
+- Create tables with multiple column types
+- Query table data with conditions
+- Link tables to specific images or datasets
+
+### 7. Scripts & Batch Operations
+**File**: `(see docs)`
+
+Create OMERO.scripts that run server-side for batch processing, automated workflows, and integration with OMERO clients.
+
+**Common scenarios:**
+- Process multiple images in batch
+- Create automated analysis pipelines
+- Generate summary statistics across datasets
+- Export data in custom formats
+
+### 8. Advanced Features
+**File**: `(see docs)`
+
+Covers permissions, filesets, cross-group queries, delete operations, and other advanced functionality.
+
+**Common scenarios:**
+

package/skills/open-notebook/SKILL.md

@@ -0,0 +1,100 @@
+---
+name: open-notebook
+description: Self-hosted, open-source alternative to Google NotebookLM for AI-powered research and document analysis. Use when organizing research materials into notebooks, ingesting diverse content sources (PDFs, videos, audio, web pages, Office documents), generating AI-powered notes and summaries, creating multi-speaker podcasts from research, chatting with documents using context-aware AI, searching across materials with full-text and vector search, or running custom content transformations. Supports 16+ AI providers including OpenAI, Anthropic, Google, Ollama, Groq, and Mistral with complete data privacy through self-hosting.
+---
+
+# Open Notebook
+
+## Overview
+
+Open Notebook is an open-source, self-hosted alternative to Google's NotebookLM that enables researchers to organize materials, generate AI-powered insights, create podcasts, and have context-aware conversations with their documents — all while maintaining complete data privacy.
+
+Unlike Google's Notebook LM, which has no publicly available API outside of the Enterprise version, Open Notebook provides a comprehensive REST API, supports 16+ AI providers, and runs entirely on your own infrastructure.
+
+**Key advantages over NotebookLM:**
+- Full REST API for programmatic access and automation
+- Choice of 16+ AI providers (not locked to Google models)
+- Multi-speaker podcast generation with 1-4 customizable speakers (vs. 2-speaker limit)
+- Complete data sovereignty through self-hosting
+- Open source and fully extensible (MIT license)
+
+**Repository:** https://github.com/lfnovo/open-notebook
+
+## Quick Start
+
+### Prerequisites
+
+- Docker Desktop installed
+- API key for at least one AI provider (or local Ollama for free local inference)
+
+# Download the docker-compose file
+curl -o docker-compose.yml https://raw.githubusercontent.com/lfnovo/open-notebook/main/docker-compose.yml
+
+# Set the required encryption key
+export OPEN_NOTEBOOK_ENCRYPTION_KEY="your-secret-key-here"
+
+# Launch the services
+docker-compose up -d
+```
+
+Access the application:
+- **Frontend UI:** http://localhost:8502
+- **REST API:** http://localhost:5055
+- **API Documentation:** http://localhost:5055/docs
+
+### Configure AI Provider
+
+After startup, configure at least one AI provider:
+
+1. Navigate to **Settings > API Keys** in the UI
+2. Add credentials for your preferred provider (OpenAI, Anthropic, etc.)
+3. Test the connection and discover available models
+4. Register models for use across the platform
+
+Or configure via the REST API:
+
+```python
+import requests
+
+BASE_URL = "http://localhost:5055/api"
+
+# Add a credential for an AI provider
+response = requests.post(f"{BASE_URL}/credentials", json={
+    "provider": "openai",
+    "name": "My OpenAI Key",
+    "api_key": "sk-..."
+})
+credential = response.json()
+
+# Discover available models
+response = requests.post(
+    f"{BASE_URL}/credentials/{credential['id']}/discover"
+)
+discovered = response.json()
+
+# Register discovered models
+requests.post(
+    f"{BASE_URL}/credentials/{credential['id']}/register-models",
+    json={"model_ids": [m["id"] for m in discovered["models"]]}
+)
+```
+
+## Core Features
+
+### Notebooks
+Organize research into separate notebooks, each containing sources, notes, and chat sessions.
+
+```python
+import requests
+
+BASE_URL = "http://localhost:5055/api"
+
+# Create a notebook
+response = requests.post(f"{BASE_URL}/notebooks", json={
+    "name": "Cancer Genomics Research",
+    "description": "Literature review on tumor mutational burden"
+})
+notebook = response.json()
+notebook_id = notebook["id"]
+
+

package/skills/openephys/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: openephys
+description: Electrophysiology recording and neural data analysis. Use when working with neural recording systems, spike sorting, local field potentials, neuropixel probes, or electrophysiological signal processing. Trigger on imports of openephys, spikeinterface, probeinterface, or mentions of neural recording, neuropixel, spikeglx, electrophysiolog.
+---
+# openephys
+
+Use this skill for electrophysiology data acquisition and analysis.
+
+## Core patterns
+
+- **Load recordings**: `read_openephys('session_folder')` for continuous data.
+- **Spike extraction**: Use `spikeinterface` for modern spike sorting pipelines.
+- **LFP analysis**: Bandpass filter 1-300 Hz for local field potentials.
+- **Probe config**: `probeinterface` for neuropixel probe geometry mapping.
+
+## Rules
+
+- Always check sampling rate consistency across channels before analysis.
+- Use memmap or chunked loading for large continuous files (>10GB).
+- Reference signals appropriately (common average, median, or bipolar).
+
+## Anti-patterns
+
+- Don't load entire recordings into RAM — stream or chunk.
+- Don't apply spike sorting without artifact removal first.
+- Don't mix probe configurations without recalculating channel maps.
+
+

package/skills/opentrons-integration/SKILL.md

@@ -0,0 +1,110 @@
+---
+name: opentrons-integration
+description: Official Opentrons Protocol API for OT-2 and Flex robots. Use when writing protocols specifically for Opentrons hardware with full access to Protocol API v2 features. Best for production Opentrons protocols, official API compatibility. For multi-vendor automation or broader equipment control use pylabrobot.
+---
+
+# Opentrons Integration
+
+## Overview
+
+Opentrons is a Python-based lab automation platform for Flex and OT-2 robots. Write Protocol API v2 protocols for liquid handling, control hardware modules (heater-shaker, thermocycler), manage labware, for automated pipetting workflows.
+
+## When to Use This Skill
+
+This skill should be used when:
+- Writing Opentrons Protocol API v2 protocols in Python
+- Automating liquid handling workflows on Flex or OT-2 robots
+- Controlling hardware modules (temperature, magnetic, heater-shaker, thermocycler)
+- Setting up labware configurations and deck layouts
+- Implementing complex pipetting operations (serial dilutions, plate replication, PCR setup)
+- Managing tip usage and optimizing protocol efficiency
+- Working with multi-channel pipettes for 96-well plate operations
+- Simulating and testing protocols before robot execution
+
+## Core Capabilities
+
+### 1. Protocol Structure and Metadata
+
+Every Opentrons protocol follows a standard structure:
+
+```python
+from opentrons import protocol_api
+
+# Metadata
+metadata = {
+    'protocolName': 'My Protocol',
+    'author': 'Name <email@example.com>',
+    'description': 'Protocol description',
+    'apiLevel': '2.19'  # Use latest available API version
+}
+
+# Requirements (optional)
+requirements = {
+    'robotType': 'Flex',  # or 'OT-2'
+    'apiLevel': '2.19'
+}
+
+# Run function
+def run(protocol: protocol_api.ProtocolContext):
+    # Protocol commands go here
+    pass
+```
+
+**Key elements:**
+- Import `protocol_api` from `opentrons`
+- Define `metadata` dict with protocolName, author, description, apiLevel
+- Optional `requirements` dict for robot type and API version
+- Implement `run()` function receiving `ProtocolContext` as parameter
+- All protocol logic goes inside the `run()` function
+
+### 2. Loading Hardware
+
+**Loading Instruments (Pipettes):**
+
+```python
+def run(protocol: protocol_api.ProtocolContext):
+    # Load pipette on specific mount
+    left_pipette = protocol.load_instrument(
+        'p1000_single_flex',  # Instrument name
+        'left',               # Mount: 'left' or 'right'
+        tip_racks=[tip_rack]  # List of tip rack labware objects
+    )
+```
+
+Common pipette names:
+
+# Load labware directly on deck
+plate = protocol.load_labware(
+    'corning_96_wellplate_360ul_flat',  # Labware API name
+    'D1',                                # Deck slot (Flex: A1-D3, OT-2: 1-11)
+    label='Sample Plate'                 # Optional display label
+)
+
+# Load tip rack
+tip_rack = protocol.load_labware('opentrons_flex_96_tiprack_1000ul', 'C1')
+
+# Load labware on adapter
+adapter = protocol.load_adapter('opentrons_flex_96_tiprack_adapter', 'B1')
+tips = adapter.load_labware('opentrons_flex_96_tiprack_200ul')
+```
+
+**Loading Modules:**
+
+```python
+# Temperature module
+temp_module = protocol.load_module('temperature module gen2', 'D3')
+temp_plate = temp_module.load_labware('corning_96_wellplate_360ul_flat')
+
+# Magnetic module
+mag_module = protocol.load_module('magnetic module gen2', 'C2')
+mag_plate = mag_module.load_labware('nest_96_wellplate_100ul_pcr_full_skirt')
+
+# Heater-Shaker module
+hs_module = protocol.load_module('heaterShakerModuleV1', 'D1')
+hs_plate = hs_module.load_labware('corning_96_wellplate_360ul_flat')
+
+# Thermocycler module (takes up specific slots automatically)
+tc_module = protocol.load_module('thermocyclerModuleV2')
+tc_plate = tc_module.load_labware('nest_96_wellplate_100ul_pcr_full_skirt')
+
+

package/skills/optimize-for-gpu/SKILL.md

@@ -0,0 +1,119 @@
+---
+name: optimize-for-gpu
+description: "GPU-accelerate Python code using CuPy, Numba CUDA, Warp, cuDF, cuML, cuGraph, KvikIO, cuCIM, cuxfilter, cuVS, cuSpatial, and RAFT. Use whenever the user mentions GPU/CUDA/NVIDIA acceleration, or wants to speed up NumPy, pandas, scikit-learn, scikit-image, NetworkX, GeoPandas, or Faiss workloads. Covers physics simulation, differentiable rendering, mesh ray casting, particle systems (DEM/SPH/fluids), vector/similarity search, GPUDirect Storage file IO, interactive dashboards, geospatial analysis, medical imaging, and sparse eigensolvers. Also use when you see CPU-bound Python code (loops, large arrays, ML pipelines, graph analytics, image processing) that would benefit from GPU acceleration, even if not explicitly requested."
+---
+
+# GPU Optimization for Python with NVIDIA
+
+You are an expert GPU optimization engineer. Your job is to help users write new GPU-accelerated code or transform their existing CPU-bound Python code to run on NVIDIA GPUs for dramatic speedups — often 10x to 1000x for suitable workloads.
+
+## When This Skill Applies
+
+- User wants to speed up numerical/scientific Python code
+- User is working with large arrays, matrices, or dataframes
+- User mentions CUDA, GPU, NVIDIA, or parallel computing
+- User has NumPy, pandas, SciPy, scikit-learn, NetworkX, or scipy.sparse.linalg code that processes large datasets
+- User needs low-level GPU primitives (sparse eigensolvers, device memory management, multi-GPU communication)
+- User is doing machine learning (training, inference, hyperparameter tuning, preprocessing)
+- User is doing graph analytics (centrality, community detection, shortest paths, PageRank, etc.)
+- User is doing vector search, nearest neighbor search, similarity search, or building a RAG pipeline
+- User has Faiss, Annoy, ScaNN, or sklearn NearestNeighbors code that could be GPU-accelerated
+- User wants GPU-accelerated interactive dashboards, cross-filtering, or exploratory data analysis on large datasets
+- User is doing geospatial analysis (point-in-polygon, spatial joins, trajectory analysis, distance calculations) with GeoPandas or shapely
+- User is doing image processing, computer vision, or medical imaging (filtering, segmentation, morphology, feature detection) with scikit-image or OpenCV
+- User is working with whole-slide images (WSI), digital pathology, microscopy, or remote sensing imagery
+
+## Decision Framework: Which Library to Use
+
+Choose the right tool based on what the user's code actually does. Read the appropriate reference file(s) before writing any GPU code.
+
+### CuPy — for array/matrix operations (NumPy replacement)
+**Read:** `(see docs)`
+
+Use CuPy when the user's code is primarily:
+- NumPy array operations (element-wise math, linear algebra, FFT, sorting, reductions)
+- SciPy operations (sparse matrices, signal processing, image filtering, special functions)
+- Any code that chains NumPy calls — CuPy is a drop-in replacement
+
+CuPy wraps NVIDIA's optimized libraries (cuBLAS, cuFFT, cuSOLVER, cuSPARSE, cuRAND) so standard operations are already tuned. Most NumPy code works by changing `import numpy as np` to `import cupy as cp`.
+
+**Best for:** Linear algebra, FFTs, array math, image processing, signal processing, Monte Carlo with array ops, any NumPy-heavy workflow.
+
+### Numba CUDA — for custom GPU kernels
+**Read:** `(see docs)`
+
+Use Numba when the user needs:
+- Custom algorithms that don't map to standard array operations
+- Fine-grained control over GPU threads, blocks, and shared memory
+- Element-wise operations with complex logic (use `@vectorize(target='cuda')`)
+- Reduction operations with custom logic
+- Stencil computations or neighbor-dependent calculations
+- Anything requiring the CUDA programming model directly
+
+Numba compiles Python directly into CUDA kernels. It gives full control over the GPU's thread hierarchy, shared memory, and synchronization — essential for algorithms that can't be expressed as array operations.
+
+**Best for:** Custom kernels, particle simulations, stencil codes, custom reductions, algorithms needing shared memory, any code with complex per-element logic.
+
+### Warp — for simulation, spatial computing, and differentiable programming
+**Read:** `(see docs)`
+
+Use Warp when the user's code is primarily:
+- Physics simulation (particles, cloth, fluids, rigid bodies, DEM, SPH)
+- Geometry processing (mesh operations, ray casting, signed distance fields, marching cubes)
+- Robotics (kinematics, dynamics, control with transforms and quaternions)
+- Differentiable simulation for ML training (integrates with PyTorch/JAX autograd)
+- Any Python simulation loop that needs to be JIT-compiled to GPU
+- Spatial computing with meshes, volumes (NanoVDB), hash grids, or BVH queries
+
+Warp JIT-compiles `@wp.kernel` Python functions to CUDA, with built-in types for spatial computing (vec3, mat33, quat, transform) and primitives for geometry queries (Mesh, Volume, HashGrid, BVH). All kernels are automatically differentiable.
+
+**Best for:** Physics simulation, mesh ray casting, particle systems, differentiable rendering, robotics kinematics, SDF operations, any workload combining spatial data structures with GPU compute.
+
+**Warp vs Numba:** Both compile Python to CUDA, but Warp provides higher-level spatial types (vec3, quat, Mesh, Volume) and automatic differentiation, while Numba gives raw CUDA control (shared memory, block/thread management, atomics). Use Warp for simulation/geometry, Numba for general-purpose custom kernels.
+
+### cuDF — for dataframe operations (pandas replacement)
+**Read:** `(see docs)`
+
+Use cuDF when the user's code is primarily:
+- pandas DataFrame operations (filtering, groupby, joins, aggregations)
+- CSV/Parquet/JSON reading and processing
+- ETL pipelines or data wrangling on large datasets
+- Any pandas-heavy workflow on datasets that fit in GPU memory
+
+cuDF's `cudf.pandas` accelerator mode can speed up existing pandas code with zero code changes. For maximum performance, use the native cuDF API.
+
+**Best for:** Data wrangling, ETL, groupby/aggregations, joins, string processing on dataframes, time series on tabular data.
+
+### cuML — for machine learning (scikit-learn replacement)
+**Read:** `(see docs)`
+
+Use cuML when the user's code is primarily:
+- scikit-learn estimators (classification, regression, clustering, dimensionality reduction)
+- ML preprocessing (scaling, encoding, imputation, feature extraction)
+- Hyperparameter tuning or cross-validation
+- Tree model inference (XGBoost, LightGBM, sklearn Random Forest via FIL)
+- UMAP, t-SNE, HDBSCAN, or KNN on large datasets
+
+cuML's `cuml.accel` accelerator mode can speed up existing sklearn code with zero code changes. For maximum performance, use the native cuML API. Speedups range from 2-10x for simple linear models to 60-600x for complex algorithms like HDBSCAN and KNN.
+
+**Best for:** Classification, regression, clustering, dimensionality reduction, preprocessing pipelines, model inference, any scikit-learn-heavy workflow.
+
+### cuGraph — for graph analytics (NetworkX replacement)
+**Read:** `(see docs)`
+
+Use cuGraph when the user's code is primarily:
+- NetworkX graph algorithms (centrality, community detection, shortest paths, PageRank)
+- Graph construction and analysis on large networks
+- Social network analysis, knowledge graphs, or recommendation systems
+- Any graph algorithm on networks with 10K+ edges
+
+cuGraph's `nx-cugraph` backend can accelerate existing NetworkX code with zero code changes via an environment variable. For maximum performance, use the native cuGraph API with cuDF DataFrames. Speedups range from 10x for small graphs to 500x+ for large graphs (millions of edges).
+
+**Best for:** PageRank, betweenness centrality, community detection (Louvain, Leiden), BFS/SSSP, connected components, link prediction, graph neural network sampling, any NetworkX-heavy workflow.
+
+### KvikIO — for high-performance GPU file IO
+**Read:** `(see docs)`
+
+Use KvikIO when the user's code is primarily:
+
+