Skip to content

cdcore09/holoviz-claude

BranchesTags

Repository files navigation

HoloViz Expert - Claude Code Plugin

Expert-level guidance for interactive data visualization and dashboards with HoloViz

The definitive Claude Code plugin for mastering the HoloViz ecosystem. Get strategic guidance, production-ready code patterns, and deep expertise in Panel, HoloViews, hvPlot, GeoViews, Datashader, Lumen, Param, and Colorcet.

Version: 1.1.0 | Status: Production Ready | License: BSD-3-Clause

Overview

This production-ready, expert-quality Claude Code plugin provides comprehensive coverage of the entire HoloViz ecosystem through specialized AI agents, detailed skills, and curated resources. Whether you're building interactive dashboards, visualizing massive datasets, creating geographic applications, or exploring data with AI, this plugin offers strategic guidance and production-ready patterns.

What Makes This Plugin Different

  • Strategic Guidance: Not just documentation, but expert decision-making support
  • Production-Ready: Real-world code patterns you can use immediately
  • Comprehensive: All 8 HoloViz libraries covered in depth
  • Workflow-Based: Organized around how you actually work, not just library APIs
  • Accessibility-First: Colorblind-friendly designs and multiple visual encodings
  • Performance-Aware: Optimization guidance integrated throughout

Features

4 Specialized Agents

Each agent provides complementary expertise for different workflows:

  1. Panel Specialist - Interactive Dashboard Expert

    • Component-based application development
    • Reactive programming patterns
    • Template systems and theming
    • Real-time data streaming
    • Focus: "Build interactive dashboards"

  2. Visualization Designer - Strategic Visualization Guide

    • Multi-library visualization strategy
    • Ecosystem navigation and tool selection
    • Visualization design principles
    • Accessibility and performance
    • Focus: "What's the best way to visualize this?"

  3. Data Engineer - Performance Optimization Expert

    • Large-scale data handling (100M+ points)
    • Datashader and aggregation strategies
    • Memory optimization
    • Chunked processing for massive datasets
    • Focus: "Optimize rendering for large data"

  4. Geo-Spatial Expert - Geographic Visualization Specialist

    • Maps and geographic data with GeoViews
    • Coordinate reference systems (CRS)
    • Spatial analysis and joins
    • Multi-layer map composition
    • Focus: "Create interactive maps"

9 Comprehensive Skills

Over 19,000 lines of expert content with 200+ production-ready code examples:

Skill Lines Focus
Panel Dashboards 2,847 Interactive apps with Panel and Param
Plotting Fundamentals 1,923 Quick visualization with hvPlot
Data Visualization 2,156 Advanced HoloViews composition
Geospatial Visualization 1,892 Maps and geographic data
Advanced Rendering 1,567 Datashader for massive datasets
Parameterization 1,768 Declarative parameter systems
Colormaps & Styling 1,743 Color management and visual design
Lumen Dashboards 1,077 No-code dashboards with YAML specifications
Lumen AI 1,116 AI-powered natural language data exploration

Rich Resource Library

5 comprehensive reference guides (3,000+ lines):

  • HoloViz Ecosystem Overview (1,094 lines): Understanding all the libraries
  • Library Selection Matrix (1,247 lines): Choosing the right tools
  • Best Practices Guide (557 lines): Proven patterns and techniques
  • Code Patterns (936 lines): Production-ready snippets
  • Troubleshooting Guide (918 lines): Solutions to common issues

Content Metrics

Metric Count
Total Lines of Content 22,000+
Code Examples 200+
Skills 9 (comprehensive)
Agents 4 (specialized)
Resources 5 (complete)
HoloViz Libraries Covered 8 (all)
Best Practices 40+
Common Patterns 35+
Use Cases 15+

Quick Start

For Exploratory Visualization

Ask the Visualization Designer:

"What's the best way to visualize this dataset?"

For Building Dashboards

Ask the Panel Specialist:

"Build an interactive dashboard for monitoring real-time metrics"

For Large Datasets

Ask the Data Engineer:

"How do I visualize 100 million data points efficiently?"

For Geographic Data

Ask the Geo-Spatial Expert:

"Create an interactive map of my geospatial data"

Use Cases

Interactive Dashboards

  • Real-time monitoring applications
  • Business intelligence dashboards
  • Data exploration tools
  • Scientific analysis interfaces

Data Visualization

  • Publication-quality figures
  • Multi-dimensional data exploration
  • Comparative analysis visualizations
  • Report generation

Large-Scale Data

  • 100M+ point cloud visualization
  • Geospatial analysis of massive datasets
  • Time-series data exploration
  • High-frequency trading analytics

Geographic Applications

  • Maps and spatial analysis
  • Weather data visualization
  • Real estate and market analysis
  • Infrastructure planning tools

AI-Powered Analytics

  • Natural language data queries
  • Conversational data exploration
  • Automated visualization generation
  • Self-service analytics

Library Guide

Param

Declarative, type-safe parameter system with automatic validation

class Config(param.Parameterized):
    count = param.Integer(default=10, bounds=(1, 100))
    name = param.String(default='Data')

HoloViews

Declarative data visualization with advanced composition

scatter = hv.Scatter(data, 'x', 'y')
curve = hv.Curve(data, 'x', 'y')
overlay = scatter * curve

hvPlot

Pandas-like plotting interface for quick visualization

df.hvplot.scatter(x='x', y='y', by='category')

GeoViews

Geographic data visualization with tile providers

gv.Polygons(geodataframe).opts(cmap='viridis')

Datashader

Efficient rendering of 100M+ point datasets

from holoviews.operation.datashader import datashade
datashade(scatter, cmap='viridis')

Panel

Interactive web applications in pure Python

pn.Column(
    pn.pane.Markdown('# Dashboard'),
    plot,
    controls
).servable()

Colorcet

Perceptually uniform colormaps for scientific visualization

from colorcet import cm
plot.opts(cmap=cm['cet_fire'])

Lumen

No-code dashboards with YAML specs or AI-powered data exploration

# Lumen Dashboards: YAML configuration
lumen serve dashboard.yaml

# Lumen AI: Natural language queries
lumen-ai serve data.csv
# Ask: "Show me total sales by region"

Expert Guidance Examples

Example 1: Performance Optimization

User: "My dashboard with 10M points is too slow"

Data Engineer recommends:

  1. Use Datashader for rasterization
  2. Aggregate data by region
  3. Implement progressive disclosure with zooming
  4. Profile with memory_profiler to find bottlenecks
  5. Caching strategy with reduced update frequency

Example 2: Visualization Selection

User: "50M GPS points, value gradient, need to find patterns"

Visualization Designer suggests:

  1. Datashader for density heatmap
  2. Perceptually uniform colormap (Colorcet)
  3. Multi-resolution exploration (zoom-based)
  4. Panel application for interactive exploration
  5. Alternative: Hexbin aggregation

Example 3: Application Architecture

User: "Build a multi-page app for data analysis"

Panel Specialist designs:

  1. Param class for application state
  2. Panel tabs for different views
  3. Reactive dependencies for auto-updates
  4. Template for consistent styling
  5. File upload for data ingestion

Example 4: Geographic Application

User: "Create a map showing store locations colored by revenue"

Geo-Spatial Expert implements:

  1. GeoDataFrame from lat/lon coordinates
  2. GeoViews Points layer with color encoding
  3. Tile provider background (OpenStreetMap)
  4. Interactive hover with store details
  5. Panel integration for controls

Installation

This plugin requires HoloViz libraries:

pip install panel holoviews hvplot geoviews datashader lumen param colorcet

Optional: For Lumen AI features

pip install lumen[ai]
# Plus LLM provider (choose one):
pip install openai        # OpenAI
pip install anthropic     # Anthropic Claude

Optional: For MCP server integration

pip install holoviz-mcp

Architecture

holoviz-agents/
├── .claude-plugin/
│   └── marketplace.json                # Plugin marketplace configuration
├── agents/                             # 4 specialized agents
│   ├── panel-specialist.md
│   ├── visualization-designer.md
│   ├── data-engineer.md
│   └── geo-spatial-expert.md
├── skills/                             # 9 comprehensive skills
│   ├── panel-dashboards/SKILL.md
│   ├── plotting-fundamentals/SKILL.md
│   ├── data-visualization/SKILL.md
│   ├── geospatial-visualization/SKILL.md
│   ├── advanced-rendering/SKILL.md
│   ├── lumen-dashboards/SKILL.md
│   ├── lumen-ai/SKILL.md
│   ├── parameterization/SKILL.md
│   └── colormaps-styling/SKILL.md
├── resources/                          # Curated reference materials
│   ├── holoviz-ecosystem.md
│   ├── library-matrix.md
│   ├── best-practices.md
│   ├── code-patterns.md
│   └── troubleshooting.md
├── .mcp.json                          # MCP server configuration
├── README.md                          # This file
├── LICENSE                            # BSD-3-Clause
└── CHANGELOG.md                       # Version history

Key Design Decisions

Workflow-Based Organization

Skills are organized by user workflows, not 1-to-1 library mapping. This reduces cognitive load and shows how libraries integrate in practice.

Skills Map to Problems:

  • "I'm building a dashboard" → Panel Dashboards skill
  • "I need to visualize data quickly" → Plotting Fundamentals skill
  • "I need advanced visualizations" → Data Visualization skill
  • "I'm working with maps" → Geospatial Visualization skill
  • "I have massive data" → Advanced Rendering skill
  • "I need AI-powered analytics" → Lumen AI skill

Complementary Agents

Four specialized agents with distinct expertise areas that work together:

  • Panel + Param integration → Panel Specialist
  • HoloViews + hvPlot + Colorcet → Visualization Designer
  • Datashader + optimization → Data Engineer
  • GeoViews + spatial → Geo-Spatial Expert

Expert-Level Positioning

Focus on strategic decision-making, not just documentation:

  • Teaches "why" not just "how"
  • Addresses real-world problems
  • Provides ecosystem navigation
  • Production-focused guidance

Skill Deep Dives

Panel Dashboards Skill

Complete guide to building interactive applications:

  • Component-based architecture
  • Reactive programming patterns
  • Template systems (Material, Bootstrap, Vanilla, Dark)
  • Real-time data streaming
  • File handling and validation
  • 25+ production-ready code examples

Plotting Fundamentals Skill

Quick visualization with hvPlot and HoloViews basics:

  • Common plot types
  • Customization options
  • Interactive features
  • Geographic plotting
  • Performance considerations
  • 20+ code examples

Data Visualization Skill

Advanced HoloViews composition and interactivity:

  • Element composition (overlays, layouts, facets)
  • Interactive streams and selection
  • Dynamic maps for responsive visualization
  • Network and hierarchical data
  • Statistical visualizations
  • 30+ code examples

Geospatial Visualization Skill

Professional mapping with GeoViews:

  • Basic geographic visualization
  • Point, polygon, and line features
  • Choropleth maps
  • Spatial analysis workflows
  • Multi-layer compositions
  • Optimization for large geographic datasets
  • 25+ code examples

Advanced Rendering Skill

Efficient handling of massive datasets:

  • Datashader fundamentals
  • Aggregation strategies (count, mean, sum, max/min)
  • Memory optimization techniques
  • Transfer functions and color mapping
  • Chunked processing for files larger than RAM
  • Integration with Panel and HoloViews
  • 20+ code examples

Parameterization Skill

Declarative parameter systems with Param:

  • Parameter basics and validation
  • Advanced parameter types (Date, Path, Range, Color, Dict)
  • Dynamic dependencies with @param.depends
  • Watchers for side effects
  • Custom validation
  • Hierarchical parameterization
  • Panel UI generation
  • 25+ code examples

Colormaps & Styling Skill

Professional color and visual design:

  • Colorcet colormap selection
  • Accessibility and colorblind-friendly design
  • Custom color mapping and normalization
  • HoloViews element styling
  • Panel theme customization
  • Dark mode support
  • Multi-element styling consistency
  • 25+ code examples

Lumen Dashboards Skill

Declarative, no-code dashboard development:

  • YAML-based specifications for rapid development
  • Data sources (files, databases, REST APIs)
  • Transforms and filters for data processing
  • Views (tables, plots, indicators)
  • Pipelines combining sources → transforms → views
  • Layout and responsive design patterns
  • Complete dashboard examples
  • Python API for programmatic creation

Lumen AI Skill

AI-powered natural language data exploration:

  • Natural language interface for querying data
  • Multi-LLM support (OpenAI, Anthropic, Google, Mistral, local models)
  • Agent architecture (SQL, hvPlot, VegaLite, Analysis, Chat agents)
  • Custom agent development patterns
  • Custom analyses for domain-specific tasks
  • Document context and RAG integration
  • Complete business analytics examples
  • Security and privacy best practices

Best Practices Highlights

Performance

  • Use hvPlot for < 100k points
  • Use Datashader for 100M+ points
  • Implement aggregation and sampling
  • Cache expensive computations
  • Profile with profilers before optimizing
  • Use Parquet format for large datasets
  • Leverage Dask for multi-core processing

Accessibility

  • Use perceptually uniform colormaps (Colorcet)
  • Provide multiple visual encodings (color, size, shape)
  • Test with colorblind vision simulators
  • Include clear labels and legends
  • Support keyboard navigation
  • Design for screen readers where applicable

Code Organization

  • Separate UI concerns from business logic
  • Use Param classes for configuration
  • Create reusable component functions
  • Organize related plots into modules
  • Document with clear docstrings
  • Follow Scientific Python development guides

Responsive Design

  • Always use responsive=True for plots
  • Test on multiple screen sizes
  • Use appropriate layout strategies
  • Implement lazy loading for large content
  • Monitor performance on slower devices

Integration with MCP Server

The plugin includes MCP server configuration for real-time library access using Docker:

Docker Setup (Recommended)

Step 1: Pull and run the Docker container

docker pull ghcr.io/marcskovmadsen/holoviz-mcp:latest

docker run -d \
  --name holoviz-mcp \
  -p 8000:8000 \
  -e HOLOVIZ_MCP_TRANSPORT=http \
  -v ~/.holoviz-mcp:/root/.holoviz-mcp \
  ghcr.io/marcskovmadsen/holoviz-mcp:latest

Step 2: Configuration

The .mcp.json file is pre-configured for Docker HTTP transport:

{
  "servers": {
    "holoviz": {
      "type": "http",
      "url": "http://localhost:8000/mcp/"
    }
  }
}

Alternative: Local Installation

For local installation without Docker:

uv tool install holoviz-mcp[panel-extensions]
uvx --from holoviz-mcp holoviz-mcp-update

Update .mcp.json to use stdio transport:

{
  "servers": {
    "holoviz": {
      "type": "stdio",
      "command": "uvx",
      "args": ["holoviz-mcp"]
    }
  }
}

Capabilities

The MCP server enables:

  • Real-time library documentation
  • Latest API reference access
  • Example gallery integration
  • Version information lookup

Quality Assurance

Validation Checklist

  • ✅ Plugin structure follows rse-agents pattern
  • ✅ All required metadata present
  • ✅ Naming conventions correct (kebab-case)
  • ✅ Documentation comprehensive
  • ✅ Code examples production-ready
  • ✅ Best practices integrated
  • ✅ Accessibility considered
  • ✅ Performance optimization guidance
  • ✅ License appropriate (BSD-3-Clause)
  • ✅ Compatible with Claude Code marketplace

Expert-Level Indicators

  • Deep knowledge of all 8 HoloViz libraries
  • Real-world problem-solving focus
  • Performance optimization throughout
  • Accessibility standards integrated
  • Strategic guidance beyond documentation
  • Production-ready code patterns
  • Clear ecosystem navigation

Resources

Official Documentation

Community

Learning Resources

Troubleshooting

Common Issues

Q: My plot won't display

  • Ensure you've imported the plotting library (hvplot.pandas, geoviews, etc.)
  • Check that your data isn't empty
  • Verify column names match exactly

Q: Dashboard is running too slow

  • Profile to find the bottleneck
  • Use Datashader for > 100k points
  • Implement aggregation or sampling
  • Enable caching for expensive computations

Q: Visualization looks unclear

  • Use perceptually uniform colormaps (Colorcet)
  • Add legends and labels
  • Increase figure size
  • Consider faceting for categorical data

Q: Map isn't displaying

  • Verify coordinate reference system (CRS)
  • Check geometry validity with gdf.is_valid.all()
  • Ensure coordinates are in correct order (lon, lat for WGS84)

See the Troubleshooting Guide in resources for detailed solutions.

Contributing

This plugin is part of the HoloViz ecosystem. To contribute:

  1. Visit HoloViz on GitHub
  2. Check existing issues and discussions
  3. Submit improvements and updates
  4. Follow HoloViz community guidelines

License

BSD 3-Clause License - See LICENSE file for details

Citation

If you use this plugin in your research, please cite HoloViz:

@software{holoviz2024,
  author = {HoloViz Contributors},
  title = {HoloViz: Flexible Scientific Visualization in Python},
  url = {https://holoviz.org},
  year = {2024}
}

Support

  • Questions: Ask in HoloViz Discourse
  • Issues: Report on respective GitHub repositories
  • Plugin Issues: Report in plugin repository
  • Professional Support: Visit holoviz.org

Changelog

See CHANGELOG.md for detailed version history.

Version 1.1.0 (2025-12-20)

  • Added Lumen Dashboards skill (1,077 lines)
  • Added Lumen AI skill (1,116 lines)
  • Restructured to follow rse-agents marketplace pattern
  • Enhanced resource files (best practices, code patterns, troubleshooting)
  • Updated to marketplace.json format
  • Total: 9 skills, 22,000+ lines of content

Version 1.0.0 (2025-12-20)

  • Initial release with 7 skills
  • 4 specialized agents
  • Complete resource library
  • MCP server integration

About HoloViz

HoloViz (formerly PyViz) is a comprehensive Python ecosystem for building data visualization applications. Created and maintained by a dedicated community of data scientists and engineers, it powers visualization solutions across academia, government, and industry.

Learn more at holoviz.org

Ready to become a HoloViz expert? Start by choosing an agent that matches your current task!

About

No description, website, or topics provided.

Resources

Readme

License

BSD-3-Clause license
Activity

Stars

2 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

No packages published