@wentorai/research-plugins 1.0.0 → 1.2.0

package/skills/analysis/dataviz/data-visualization-principles/SKILL.md

@@ -0,0 +1,171 @@
+---
+name: data-visualization-principles
+description: "Design principles for creating effective and honest data visualizations"
+metadata:
+  openclaw:
+    emoji: "📊"
+    category: "analysis"
+    subcategory: "dataviz"
+    keywords: ["data visualization", "chart design", "visual encoding", "chart selection", "color theory", "publication figures"]
+    source: "https://clawhub.ai/data-visualization"
+---
+
+# Data Visualization Design Principles
+
+## Overview
+
+Effective data visualization reveals patterns, communicates findings, and supports evidence-based arguments. Poor visualization obscures or misleads. This guide covers the fundamental principles of visual encoding, chart type selection, color usage, and common pitfalls — applicable to any plotting tool (matplotlib, ggplot2, Stata, Excel, D3.js).
+
+## Visual Encoding Hierarchy
+
+Not all visual channels are created equal. Humans perceive some encodings more accurately than others:
+
+```
+Most accurate (use for primary comparisons):
+  1. Position on a common scale (bar chart, dot plot)
+  2. Position on non-aligned scales (small multiples)
+  3. Length (bar chart)
+  4. Angle / Slope (line chart trends)
+
+Moderately accurate:
+  5. Area (bubble chart — but easily misjudged)
+  6. Volume (3D — almost always misleading, avoid)
+  7. Color saturation / luminance (heatmap)
+
+Least accurate (use for categorical grouping only):
+  8. Color hue (distinguishing categories, not quantities)
+  9. Shape (point markers — circle vs. triangle)
+  10. Texture / Pattern (rarely useful)
+```
+
+**Implication**: Encode your most important comparison as position, not as color or area.
+
+## Chart Selection Guide
+
+| Data Relationship | Best Chart | Avoid |
+|-------------------|-----------|-------|
+| **Compare values** across categories | Bar chart (horizontal for many categories) | Pie chart (hard to compare slices) |
+| **Show distribution** of one variable | Histogram, density plot, box plot | Bar chart of means (hides distribution) |
+| **Compare distributions** across groups | Violin plot, ridgeline plot, strip plot | Multiple overlapping histograms |
+| **Show trend** over time | Line chart | Bar chart (for continuous time) |
+| **Show relationship** between 2 variables | Scatter plot | Line chart (implies ordering) |
+| **Show composition** (parts of whole) | Stacked bar (absolute) or 100% bar (relative) | Pie chart, 3D pie chart |
+| **Show correlation matrix** | Heatmap with numbers | Scatter matrix (too many panels) |
+| **Compare many metrics** per item | Radar chart (sparingly), parallel coordinates | Multiple bar charts |
+| **Show geographic patterns** | Choropleth map, dot map | 3D terrain maps |
+| **Show network structure** | Node-edge graph, adjacency matrix | Overly dense hairball graphs |
+
+## Design Rules
+
+### Rule 1: Maximize Data-Ink Ratio
+
+Remove everything that doesn't communicate data:
+
+```
+Remove:
+  ✗ Background grid (or make very light gray)
+  ✗ 3D effects on 2D data
+  ✗ Decorative elements (clipart, unnecessary icons)
+  ✗ Redundant legends (if only one series)
+  ✗ Box around the plot (chart junk)
+
+Keep:
+  ✓ Data points / bars / lines
+  ✓ Axis labels with units
+  ✓ Title that states the finding (not just "Figure 1")
+  ✓ Direct labels on data (instead of legend when possible)
+```
+
+### Rule 2: Start Y-Axis at Zero (for Bar Charts)
+
+```
+Bar chart: ALWAYS start at 0 (bars encode length)
+Line chart: Starting at 0 is optional (lines encode slope/trend)
+Exception: If all values are close (e.g., 98-102), show the relevant range
+           but clearly mark the broken axis
+```
+
+### Rule 3: Use Informative Titles
+
+```
+Bad:  "Figure 3: Results"
+Bad:  "Figure 3: Accuracy by Method"
+Good: "Figure 3: Our method improves accuracy by 12% over the best baseline"
+Best: "Our method (BERT-RAG) achieves 89.2% accuracy, outperforming
+       all baselines on the SQuAD benchmark"
+```
+
+### Rule 4: Color Usage
+
+```python
+# Qualitative palette (categorical data — 2-8 categories)
+# Use colorblind-friendly palettes
+CATEGORICAL = ['#4477AA', '#EE6677', '#228833', '#CCBB44',
+               '#66CCEE', '#AA3377', '#BBBBBB']
+
+# Sequential palette (ordered data — low to high)
+# Single hue, varying lightness
+# Use: matplotlib "viridis", "plasma", "cividis"
+
+# Diverging palette (data with meaningful center point)
+# Two hues diverging from neutral center
+# Use: "RdBu" (red-blue), "BrBG" (brown-teal)
+
+# Rules:
+# - Maximum 7 colors for categorical data
+# - Never use rainbow (perceptually non-uniform)
+# - Test in grayscale: can you still distinguish?
+# - Red-green colorblindness affects ~8% of men
+```
+
+## Publication-Ready Formatting
+
+```python
+import matplotlib.pyplot as plt
+
+# Publication-quality defaults
+plt.rcParams.update({
+    'font.family': 'sans-serif',
+    'font.sans-serif': ['Arial', 'Helvetica'],
+    'font.size': 10,
+    'axes.labelsize': 11,
+    'axes.titlesize': 12,
+    'xtick.labelsize': 9,
+    'ytick.labelsize': 9,
+    'legend.fontsize': 9,
+    'figure.dpi': 300,
+    'savefig.dpi': 300,
+    'savefig.bbox': 'tight',
+    'axes.spines.top': False,      # Remove top spine
+    'axes.spines.right': False,    # Remove right spine
+    'lines.linewidth': 1.5,
+    'axes.linewidth': 0.8,
+})
+
+# Single column figure (journal standard: 85mm ≈ 3.35in)
+fig, ax = plt.subplots(figsize=(3.35, 2.5))
+
+# Double column figure (170mm ≈ 6.7in)
+fig, axes = plt.subplots(1, 2, figsize=(6.7, 2.5))
+```
+
+## Common Mistakes
+
+| Mistake | Why It's Wrong | Fix |
+|---------|---------------|-----|
+| Pie chart for comparison | Humans are bad at comparing angles | Use bar chart |
+| 3D bar chart | 3D perspective distorts bar heights | Use 2D bars |
+| Dual y-axes | Misleading — scale choice changes the story | Two separate panels |
+| Truncated y-axis on bar chart | Exaggerates differences | Start at 0 |
+| Too many colors | Cognitive overload | Max 7 categories; group the rest as "Other" |
+| Low resolution figures | Blurry in print | Export at 300 DPI minimum |
+| Missing units | "What does the y-axis mean?" | Always label with units |
+| Legend far from data | Reader must scan back and forth | Direct label the data |
+
+## References
+
+- Tufte, E. R. (2001). *The Visual Display of Quantitative Information*. Graphics Press.
+- Wilke, C. O. (2019). *Fundamentals of Data Visualization*. O'Reilly.
+- Rougier, N. P., et al. (2014). "Ten Simple Rules for Better Figures." *PLOS Computational Biology*, 10(9).
+- [ColorBrewer 2.0](https://colorbrewer2.org/)
+- [Datawrapper Blog](https://blog.datawrapper.de/) — Excellent chart design advice

package/skills/analysis/dataviz/echarts-visualization-guide/SKILL.md

@@ -0,0 +1,250 @@
+---
+name: echarts-visualization-guide
+description: "Guide to Apache ECharts for interactive research data dashboards"
+metadata:
+  openclaw:
+    emoji: "📈"
+    category: "analysis"
+    subcategory: "dataviz"
+    keywords: ["ECharts", "interactive charts", "data dashboard", "Apache ECharts", "scientific charts", "research visualization"]
+    source: "https://github.com/apache/echarts"
+---
+
+# Apache ECharts Visualization Guide
+
+## Overview
+
+Apache ECharts is a powerful, free, and open-source interactive charting and data visualization library with over 66K stars on GitHub. Originally developed by Baidu and now an Apache Software Foundation top-level project, ECharts provides a declarative configuration-based approach to building rich, interactive visualizations that run smoothly in any modern browser.
+
+For academic researchers, ECharts offers an excellent balance between ease of use and customization depth. Its declarative option-based API means researchers can produce complex multi-series charts, geographic visualizations, and animated transitions without writing low-level rendering code. This is particularly useful when building research dashboards or interactive supplementary materials for publications.
+
+ECharts supports over 20 chart types out of the box, including line, bar, scatter, pie, radar, candlestick, heatmap, treemap, sunburst, parallel coordinates, sankey diagrams, and geographic maps. Its built-in support for large datasets (via progressive rendering and data sampling) makes it suitable for visualizing experimental results with hundreds of thousands of data points.
+
+## Basic Configuration and Chart Types
+
+ECharts uses a declarative JSON configuration object to define charts. This approach makes it straightforward to build visualizations programmatically from research data.
+
+### Setting Up ECharts
+
+```html
+<div id="chart" style="width: 800px; height: 500px;"></div>
+<script src="https://cdn.jsdelivr.net/npm/echarts@5/dist/echarts.min.js"></script>
+<script>
+  const chart = echarts.init(document.getElementById('chart'));
+</script>
+```
+
+### Multi-Series Line Chart for Time-Series Data
+
+```javascript
+const option = {
+  title: {
+    text: 'Gene Expression Over Time',
+    left: 'center',
+    textStyle: { fontSize: 16, fontWeight: 'bold' }
+  },
+  tooltip: {
+    trigger: 'axis',
+    formatter: params => {
+      let html = `<strong>Hour ${params[0].axisValue}</strong><br/>`;
+      params.forEach(p => {
+        html += `${p.marker} ${p.seriesName}: ${p.value.toFixed(3)}<br/>`;
+      });
+      return html;
+    }
+  },
+  legend: { data: ['Gene A', 'Gene B', 'Gene C'], bottom: 10 },
+  xAxis: {
+    type: 'category',
+    name: 'Time (hours)',
+    data: [0, 2, 4, 8, 12, 24, 48, 72]
+  },
+  yAxis: {
+    type: 'value',
+    name: 'Relative Expression',
+    nameLocation: 'middle',
+    nameGap: 50
+  },
+  series: [
+    {
+      name: 'Gene A',
+      type: 'line',
+      data: [1.0, 1.2, 2.4, 5.1, 8.3, 12.1, 10.5, 9.2],
+      smooth: true,
+      lineStyle: { width: 2 }
+    },
+    {
+      name: 'Gene B',
+      type: 'line',
+      data: [1.0, 0.9, 0.7, 0.5, 0.3, 0.2, 0.15, 0.1],
+      smooth: true,
+      lineStyle: { width: 2 }
+    },
+    {
+      name: 'Gene C',
+      type: 'line',
+      data: [1.0, 1.1, 1.3, 1.8, 3.2, 6.7, 8.9, 11.4],
+      smooth: true,
+      lineStyle: { width: 2 }
+    }
+  ]
+};
+
+chart.setOption(option);
+```
+
+### Scatter Plot with Error Regions
+
+```javascript
+const scatterOption = {
+  title: { text: 'Treatment Response vs Dosage', left: 'center' },
+  xAxis: { type: 'value', name: 'Dosage (mg/kg)' },
+  yAxis: { type: 'value', name: 'Response Score' },
+  tooltip: {
+    formatter: p => `Dosage: ${p.value[0]}<br/>Response: ${p.value[1]}`
+  },
+  visualMap: {
+    min: 0, max: 100,
+    dimension: 2,
+    inRange: { color: ['#3B82F6', '#EF4444'] },
+    text: ['High', 'Low'],
+    calculable: true
+  },
+  series: [{
+    type: 'scatter',
+    symbolSize: d => Math.sqrt(d[2]) * 2,
+    data: experimentalData.map(d => [d.dosage, d.response, d.confidence])
+  }]
+};
+```
+
+## Advanced Research Visualizations
+
+### Heatmap for Gene Expression Matrices
+
+```javascript
+const heatmapOption = {
+  title: { text: 'Sample Correlation Matrix', left: 'center' },
+  tooltip: {
+    position: 'top',
+    formatter: p => {
+      return `${sampleNames[p.value[0]]} vs ${sampleNames[p.value[1]]}<br/>` +
+             `Correlation: ${p.value[2].toFixed(4)}`;
+    }
+  },
+  grid: { left: 120, top: 60, right: 80, bottom: 100 },
+  xAxis: {
+    type: 'category',
+    data: sampleNames,
+    axisLabel: { rotate: 45 }
+  },
+  yAxis: {
+    type: 'category',
+    data: sampleNames
+  },
+  visualMap: {
+    min: -1, max: 1,
+    calculable: true,
+    orient: 'vertical',
+    right: 10,
+    top: 'center',
+    inRange: {
+      color: ['#2166AC', '#F7F7F7', '#B2182B']
+    }
+  },
+  series: [{
+    type: 'heatmap',
+    data: correlationData,
+    label: { show: true, formatter: p => p.value[2].toFixed(2), fontSize: 9 },
+    emphasis: {
+      itemStyle: { shadowBlur: 10, shadowColor: 'rgba(0,0,0,0.5)' }
+    }
+  }]
+};
+```
+
+### Radar Chart for Multi-Dimensional Comparison
+
+```javascript
+const radarOption = {
+  title: { text: 'Model Performance Comparison', left: 'center' },
+  legend: { data: ['Model A', 'Model B', 'Baseline'], bottom: 10 },
+  radar: {
+    indicator: [
+      { name: 'Accuracy', max: 1.0 },
+      { name: 'Precision', max: 1.0 },
+      { name: 'Recall', max: 1.0 },
+      { name: 'F1 Score', max: 1.0 },
+      { name: 'AUC-ROC', max: 1.0 },
+      { name: 'Speed (norm)', max: 1.0 }
+    ]
+  },
+  series: [{
+    type: 'radar',
+    data: [
+      { value: [0.94, 0.91, 0.89, 0.90, 0.96, 0.72], name: 'Model A' },
+      { value: [0.92, 0.95, 0.85, 0.90, 0.94, 0.88], name: 'Model B' },
+      { value: [0.85, 0.82, 0.80, 0.81, 0.87, 0.95], name: 'Baseline' }
+    ]
+  }]
+};
+```
+
+## Responsive Design and Theming
+
+ECharts supports custom themes and responsive resizing, which is important when embedding visualizations in research web applications.
+
+```javascript
+// Register a custom academic theme
+echarts.registerTheme('academic', {
+  color: ['#3B82F6', '#EF4444', '#10B981', '#F59E0B', '#8B5CF6', '#EC4899'],
+  backgroundColor: '#FFFFFF',
+  textStyle: { fontFamily: 'Inter, sans-serif' },
+  title: { textStyle: { color: '#1F2937', fontSize: 16 } },
+  line: { smooth: false, symbolSize: 6 }
+});
+
+// Initialize chart with the academic theme
+const chart = echarts.init(document.getElementById('chart'), 'academic');
+
+// Handle responsive resizing
+window.addEventListener('resize', () => chart.resize());
+```
+
+## Data Loading and Integration
+
+```javascript
+// Load CSV data and convert to ECharts format
+async function loadExperimentData(csvUrl) {
+  const response = await fetch(csvUrl);
+  const text = await response.text();
+  const rows = text.split('\n').slice(1);
+
+  const data = rows.map(row => {
+    const [sample, condition, value, error] = row.split(',');
+    return { sample, condition, value: parseFloat(value), error: parseFloat(error) };
+  });
+
+  return data;
+}
+
+// Export chart as PNG for publications
+function downloadChart(chartInstance, filename) {
+  const url = chartInstance.getDataURL({
+    type: 'png',
+    pixelRatio: 3,
+    backgroundColor: '#fff'
+  });
+  const link = document.createElement('a');
+  link.href = url;
+  link.download = filename || 'chart.png';
+  link.click();
+}
+```
+
+## References
+
+- Apache ECharts official site: https://echarts.apache.org
+- ECharts GitHub repository: https://github.com/apache/echarts
+- ECharts examples gallery: https://echarts.apache.org/examples
+- ECharts configuration handbook: https://echarts.apache.org/en/option.html

package/skills/analysis/dataviz/metabase-analytics-guide/SKILL.md

@@ -0,0 +1,242 @@
+---
+name: metabase-analytics-guide
+description: "Guide to Metabase for open-source research data analytics and dashboards"
+metadata:
+  openclaw:
+    emoji: "📋"
+    category: "analysis"
+    subcategory: "dataviz"
+    keywords: ["Metabase", "business intelligence", "SQL analytics", "data dashboard", "research analytics", "self-hosted BI"]
+    source: "https://github.com/metabase/metabase"
+---
+
+# Metabase Analytics Guide
+
+## Overview
+
+Metabase is a powerful open-source business intelligence and analytics tool with over 46K stars on GitHub. It allows researchers and data analysts to explore data, create visualizations, and build dashboards without writing SQL, though it fully supports custom SQL queries for advanced users. Metabase connects to a wide variety of databases and provides a browser-based interface that makes data exploration accessible to team members regardless of their technical background.
+
+For academic research groups and labs, Metabase serves as an excellent self-hosted platform for tracking experimental data, monitoring research progress, and creating shared dashboards for collaborative projects. Its ability to connect directly to PostgreSQL, MySQL, SQLite, and many other databases means it can be pointed at existing research data stores without data migration. Researchers can set up automated reports, scheduled email digests, and shared dashboards that keep the entire team informed.
+
+Metabase's no-code query builder is particularly valuable in interdisciplinary research teams where not all members are comfortable with SQL. Principal investigators, graduate students, and collaborators can all explore the same datasets through an intuitive visual interface while power users retain full SQL access for complex analyses.
+
+## Installation and Setup
+
+### Docker Deployment (Recommended)
+
+```bash
+# Quick start with Docker
+docker run -d -p 3000:3000 \
+  --name metabase \
+  -v metabase-data:/metabase-data \
+  -e MB_DB_TYPE=postgres \
+  -e MB_DB_DBNAME=metabase_app \
+  -e MB_DB_PORT=5432 \
+  -e MB_DB_USER=$METABASE_DB_USER \
+  -e MB_DB_PASS=$METABASE_DB_PASS \
+  -e MB_DB_HOST=db-host \
+  metabase/metabase
+
+# Access at http://localhost:3000
+```
+
+### Docker Compose for Research Lab Setup
+
+```yaml
+version: "3.9"
+services:
+  metabase:
+    image: metabase/metabase:latest
+    container_name: research-metabase
+    ports:
+      - "3000:3000"
+    environment:
+      MB_DB_TYPE: postgres
+      MB_DB_DBNAME: metabase_app
+      MB_DB_PORT: 5432
+      MB_DB_USER: ${METABASE_DB_USER}
+      MB_DB_PASS: ${METABASE_DB_PASS}
+      MB_DB_HOST: postgres
+      MB_SITE_NAME: "Research Lab Analytics"
+    depends_on:
+      - postgres
+    volumes:
+      - metabase-data:/metabase-data
+
+  postgres:
+    image: postgres:16
+    environment:
+      POSTGRES_DB: metabase_app
+      POSTGRES_USER: ${POSTGRES_USER}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
+    volumes:
+      - pg-data:/var/lib/postgresql/data
+
+volumes:
+  metabase-data:
+  pg-data:
+```
+
+## Connecting Research Databases
+
+Metabase supports connecting to many database types commonly used in research environments.
+
+### Supported Data Sources for Research
+
+- **PostgreSQL** - Primary research databases, experimental records
+- **MySQL/MariaDB** - Legacy lab information management systems
+- **SQLite** - Local experiment databases, embedded analytics
+- **BigQuery** - Large-scale genomic or observational datasets
+- **MongoDB** - Semi-structured research data, document stores
+- **CSV uploads** - Quick ad-hoc analysis of exported data
+
+### Database Connection Configuration
+
+Navigate to Admin > Databases > Add Database in the Metabase UI. For a typical research PostgreSQL database:
+
+```
+Display name: Lab Experiment Database
+Host: research-db.lab.university.edu
+Port: 5432
+Database name: experiments
+Username: (use environment variable $DB_USER)
+Password: (use environment variable $DB_PASS)
+```
+
+Enable "Auto-run queries" and set "Scan frequency" to daily for research databases that update regularly.
+
+## Building Research Dashboards
+
+### Experiment Tracking Dashboard
+
+A common research use case is tracking experiment progress and results. Here is an example SQL query for monitoring experiment completion rates:
+
+```sql
+-- Experiment completion overview
+SELECT
+    e.project_name,
+    COUNT(*) AS total_experiments,
+    COUNT(CASE WHEN e.status = 'completed' THEN 1 END) AS completed,
+    COUNT(CASE WHEN e.status = 'in_progress' THEN 1 END) AS in_progress,
+    COUNT(CASE WHEN e.status = 'failed' THEN 1 END) AS failed,
+    ROUND(
+        COUNT(CASE WHEN e.status = 'completed' THEN 1 END)::NUMERIC /
+        NULLIF(COUNT(*), 0) * 100, 1
+    ) AS completion_rate
+FROM experiments e
+WHERE e.created_at >= CURRENT_DATE - INTERVAL '90 days'
+GROUP BY e.project_name
+ORDER BY completion_rate DESC;
+```
+
+### Sample Analysis Summary
+
+```sql
+-- Sample processing metrics
+SELECT
+    DATE_TRUNC('week', s.processed_at) AS week,
+    s.sample_type,
+    COUNT(*) AS samples_processed,
+    AVG(s.quality_score) AS avg_quality,
+    PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY s.processing_time)
+        AS median_processing_hours
+FROM samples s
+WHERE s.processed_at >= CURRENT_DATE - INTERVAL '6 months'
+GROUP BY DATE_TRUNC('week', s.processed_at), s.sample_type
+ORDER BY week DESC, sample_type;
+```
+
+### Publication Pipeline Tracker
+
+```sql
+-- Track manuscript progress across the lab
+SELECT
+    p.title,
+    p.lead_author,
+    p.status,
+    p.target_journal,
+    p.submission_date,
+    CASE
+        WHEN p.status = 'draft' THEN 1
+        WHEN p.status = 'internal_review' THEN 2
+        WHEN p.status = 'submitted' THEN 3
+        WHEN p.status = 'revision' THEN 4
+        WHEN p.status = 'accepted' THEN 5
+        WHEN p.status = 'published' THEN 6
+    END AS stage_number,
+    CURRENT_DATE - p.last_updated AS days_since_update
+FROM publications p
+WHERE p.year >= EXTRACT(YEAR FROM CURRENT_DATE) - 1
+ORDER BY stage_number, p.last_updated;
+```
+
+## Automated Reporting and Alerts
+
+Metabase supports scheduled reports and conditional alerts, which are useful for research operations.
+
+### Setting Up Scheduled Reports
+
+1. Create a dashboard with key metrics (experiment counts, quality scores, etc.)
+2. Click the sharing icon and select "Subscriptions"
+3. Configure email delivery schedule (e.g., weekly Monday 9 AM)
+4. Add recipients from the research team
+
+### Alert Configuration
+
+```
+Question: "Failed experiments in last 7 days"
+Alert when: Results are above threshold (e.g., > 5 failures)
+Check frequency: Daily
+Notify: Lab manager email, Slack channel
+```
+
+This allows labs to automatically detect quality issues in experimental workflows.
+
+## Embedding Metabase in Research Applications
+
+Metabase supports embedding dashboards into other web applications via iframes or its embedding SDK.
+
+```html
+<!-- Embed a dashboard in a lab portal -->
+<iframe
+  src="http://metabase.lab.internal/public/dashboard/abc123-def456"
+  frameborder="0"
+  width="100%"
+  height="800"
+  allowtransparency
+></iframe>
+```
+
+For authenticated embedding, use signed JWTs to control access:
+
+```python
+import jwt
+import time
+
+embedding_secret = os.environ["METABASE_EMBEDDING_SECRET"]
+
+payload = {
+    "resource": {"dashboard": 42},
+    "params": {"project_id": 7},
+    "exp": int(time.time()) + 600  # 10-minute expiry
+}
+
+signed = jwt.encode(payload, embedding_secret, algorithm="HS256")
+embed_url = f"http://metabase.lab.internal/embed/dashboard/{signed}"
+```
+
+## Best Practices for Research Teams
+
+- **Organize by project**: Create separate Metabase collections for each research project or grant
+- **Use saved questions**: Standardize common analyses as saved questions that team members can reuse
+- **Document queries**: Add descriptions to all saved questions explaining the methodology and assumptions
+- **Access control**: Use Metabase groups to control which team members can view sensitive data
+- **Regular backups**: Schedule database backups, especially for the Metabase application database
+- **Version tracking**: Export dashboard definitions as JSON for version control alongside research code
+
+## References
+
+- Metabase official documentation: https://www.metabase.com/docs
+- Metabase GitHub repository: https://github.com/metabase/metabase
+- Metabase embedding documentation: https://www.metabase.com/docs/latest/embedding
+- Metabase API reference: https://www.metabase.com/docs/latest/api