holoviz-viz-mcp
Provides dashboard templates using Bootstrap for professional layouts.
Provides dashboard templates using Material Design for professional layouts.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@holoviz-viz-mcp Run auto-EDA on the iris dataset"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
holoviz-viz-mcp
The most advanced MCP server for data visualization. Give any AI assistant the power to create interactive charts, run statistical tests, perform auto-EDA, and build polished dashboards — all using the HoloViz ecosystem.
Why this exists
Most AI visualization tools generate static images or hand-roll JavaScript. This server uses Panel's embed mode to produce self-contained interactive HTML with the full Bokeh rendering pipeline — real pan/zoom/hover, linked selections, and Panel widgets. Not a JavaScript approximation.
pn.pane.HoloViews(plot).save(buf, embed=True)One line. Standalone HTML. All Bokeh JS/CSS inlined. No server. No CDN. Open in any browser.
Related MCP server: Data Analytics MCP Toolkit
Feature highlights
Category | What you get |
36 tools | Data loading, transforms, 14 chart types, annotations, crossfiltering, streaming, dashboards, export, and more |
Intelligent analysis | One-call auto-EDA, statistical testing (t-test, ANOVA, regression, chi-square), data quality scoring, natural language queries |
8 MCP Apps | Specialized UI viewers for charts, dashboards, streaming, crossfilter, EDA reports, statistics, time series, and data quality |
9 workflow prompts | Guided workflows for EDA, crossfiltering, statistics, time series, big data, comparisons, storytelling, dashboards, and data quality |
Big data | Datashader-powered visualization for 10K-5M+ points |
Time series | Rolling stats, trend decomposition, anomaly detection, multi-series comparison |
Dual output | Every viz returns PNG preview (inline in chat) + interactive HTML (full Bokeh interactivity) |
Plot versioning | Modify freely, undo anytime — every change creates a new version |
Session persistence | Save/load entire analysis sessions as JSON |
8 sample datasets | iris, penguins, tips, stocks, diamonds, gapminder, weather, earthquakes |
Professional templates | Material Design, Bootstrap, and Fast Design dashboard layouts |
Quick start
Copy-paste these 4 lines to get started:
git clone https://github.com/ghostiee-11/holoviz-viz-mcp.git
cd holoviz-viz-mcp
pip install -e .
claude mcp add holoviz-viz -- holoviz-viz-mcpThat's it — restart your AI client and start asking for visualizations.
One-command setup for any AI client
bash setup.sh claude-desktop # Claude Desktop
bash setup.sh claude-code # Claude Code CLI
bash setup.sh cursor # Cursor
bash setup.sh vscode # VS Code Copilot
bash setup.sh all # All clients at onceRestart your AI client and try:
"Load the iris dataset and create a scatter plot of sepal_length vs sepal_width, colored by species"
"Run auto_eda on the diamonds dataset"
"Test if sepal_length differs significantly between species using a t-test"
See DEMO_PROMPTS.md for 12 ready-to-use demo prompts.
Manual setup
Add to ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"holoviz-viz": {
"command": "holoviz-viz-mcp"
}
}
}claude mcp add holoviz-viz -- holoviz-viz-mcpAdd to ~/.cursor/mcp.json:
{
"mcpServers": {
"holoviz-viz": {
"command": "holoviz-viz-mcp"
}
}
}Add to .vscode/settings.json:
{
"github.copilot.chat.mcpServers": {
"holoviz-viz": {
"command": "holoviz-viz-mcp"
}
}
}Tools (36)
Data Management (5)
Tool | Description |
| Load from CSV/JSON text, URL, or file. Auto-detects Parquet/Excel/JSON from extension |
| 8 built-in datasets: iris, penguins, tips, stocks, diamonds, gapminder, weather, earthquakes |
| List all loaded datasets with shapes and columns |
| Statistical profile with distributions, correlations, and data types |
| Auto-recommend plot types based on column characteristics |
Data Transformation (2)
Tool | Description |
| Filter, groupby, sort, derive columns, sample, drop nulls, pivot |
| Join two datasets on shared columns (inner/left/right/outer) |
Visualization (5)
Tool | Description | Output |
| 14 chart types: scatter, line, bar, barh, area, step, box, violin, hist, heatmap, hexbin, kde, contour, errorbars | PNG + HTML |
| Change title, colors, colormap, size, axis labels, legend position | PNG + HTML |
| Revert to any previous version | PNG + HTML |
| List all plots with IDs and version counts | Text |
| Run arbitrary hvPlot/HoloViews/Panel code | PNG + HTML |
Advanced Visualization (6)
Tool | Description | Output |
| Linked brushing across views — select in one, all update | PNG + HTML |
| Live-updating chart with play/pause/reset controls | PNG + HTML |
| Add hline/vline/hspan/vspan/text/point/arrow annotations | PNG + HTML |
| Composite multiple plots onto shared axes | PNG + HTML |
| Big data visualization for 10K-5M+ points | PNG + HTML |
| Rolling stats, decomposition, anomaly detection, multi-series comparison | PNG + HTML |
Interactive (4)
Tool | Description |
| Process chart clicks — returns percentile, outlier status, group context |
| Set global theme: default, dark, midnight |
| Open any chart as a full Panel app in the browser |
| Stop a running Panel server |
Dashboard & Export (3)
Tool | Description | Output |
| Combine plots in column/row/tabs/grid with Material/Bootstrap/Fast templates | PNG + HTML |
| Get raw interactive HTML for embedding | HTML |
| Export to HTML, PNG, or SVG | Encoded |
Intelligent Analysis (4)
Tool | Description | Output |
| One-call complete EDA: distributions, correlations, missing data, outliers, narrative insights | PNG + HTML |
| T-test, correlation, regression, chi-square, normality, ANOVA — real p-values + diagnostic plots | PNG + HTML |
| Missing values, outliers, type validation, duplicates, quality score (0-100) | PNG + HTML |
| Side-by-side statistical comparison of two datasets | Text |
Natural Language (1)
Tool | Description |
| Plain English -> structured execution plan. "Show sales by region where revenue > 1M" -> filter + groupby + bar chart |
Utility (6)
Tool | Description |
| AI-readable plot description for accessibility and context |
| Duplicate a plot for independent modification |
| Return formatted data rows for AI context |
| Persist datasets + plot specs to JSON |
| Restore a saved session |
| Generate synthetic data (clusters/spiral/grid/uniform, up to 5M points) |
MCP Apps (8 interactive viewers)
Resource URI | Viewer | Key features |
| Chart Viewer | Theme toggle, save, open in browser |
| Dashboard Viewer | Multi-panel layout with stats sidebar |
| Stream Viewer | Live pulse indicator, status bar |
| Crossfilter Viewer | Linked brush hint, open full size |
| EDA Report | Tabbed insights/charts, completion badge |
| Statistics Viewer | P-value highlighting (green/red), side-by-side results+chart |
| Time Series Viewer | Metrics bar, analysis type badge |
| Quality Report | Score gauge (0-100, color-coded), issue severity cards |
Workflow Prompts (9)
Pre-built step-by-step guides that the AI follows:
Prompt | Purpose |
| Complete exploratory data analysis |
| Build linked brushing dashboards |
| Assess and clean data quality |
| Rigorous hypothesis testing |
| Data storytelling with annotations |
| Temporal analysis and trend detection |
| Datashader visualization for large datasets |
| Compare groups or datasets |
| Polished, presentation-ready dashboards |
Architecture
AI Assistant (Claude / Copilot / Cursor / any MCP client)
|
v MCP Protocol (JSON-RPC 2.0 over stdio)
+------------------------------------------------------------------+
| holoviz-viz-mcp Server (FastMCP 3.1) |
| |
| Data Layer (7 tools) Viz Layer (11 tools) |
| load_data, analyze_data create_plot (14 chart types) |
| suggest_visualizations crossfilter, streaming, datashader |
| transform_data, merge annotate, overlay, time_series |
| |
| Intelligence Layer (5 tools) Utility Layer (6 tools) |
| auto_eda describe_plot, clone_plot |
| statistical_test get_data_sample |
| data_quality_report save/load_session |
| natural_language_query generate_large_dataset |
| |
| Rendering Pipeline State Manager |
| hvPlot -> HoloViews Versioned plots with undo |
| -> Panel embed=True Dataset storage |
| Output: PNG + HTML Session persistence |
| |
| 8 MCP Apps | 9 Prompts | 3 Dashboard Templates |
+------------------------------------------------------------------+How the output works
Each visualization tool returns three items in a single MCP response:
TextContent — Plot ID and description
ImageContent — PNG preview (renders inline in chat)
EmbeddedResource — Interactive HTML at
viz://plots/{id}(self-contained Bokeh document)
This dual-output pattern means the AI shows a quick preview while providing the full interactive version.
Examples
Auto-EDA (one call, complete analysis)
> "Run auto_eda on the diamonds dataset"
Returns: 6+ charts (distributions, correlations, categories, scatter),
narrative insights (skewness, outliers, strongest correlations),
all in a single tool call.Statistical testing with real p-values
> "Test if sepal_length differs between iris species"
Returns: t-statistic, p-value, Cohen's d effect size,
box plot comparing groups, significance assessment.Crossfilter (linked brushing)
# Behind the scenes:
from holoviews.selection import link_selections
linked = link_selections(hv.Layout([scatter, hist, box]))
# Brush in scatter -> histogram and box plot filter in real timeTime series decomposition
> "Decompose the weather temperature into trend, seasonal, and residual"
Returns: 4-panel decomposition plot + trend stats + seasonal amplitude.Natural language queries
> natural_language_query("iris", "compare sepal_length by species")
Returns structured plan:
Step 1: transform_data('iris', 'groupby', group_by='species', agg='mean')
Step 2: create_plot('iris_grouped', 'bar', x='species', y='sepal_length')Demos
python demos/quick_demo.py # Full feature tour
python demos/showcase_stock_analysis.py # Stock prices + annotations + dashboard
python demos/showcase_ml_evaluator.py # Feature importance + confusion matrix + crossfilterTesting
pytest tests/ -v
# 148 tests across 16 test files covering:
# state, data, viz, transforms, crossfilter, streaming, annotations,
# export, interaction, auto-EDA, statistics, data quality, NLQ,
# big data, time series, utilities, server integrationProject structure
src/holoviz_viz_mcp/
server.py # FastMCP entry: 36 tools, 8 resources, 9 prompts
state.py # Dataset + plot state with versioning/undo
rendering.py # HoloViews -> PNG/HTML via Panel embed (+ Material/Bootstrap/Fast templates)
tools/
data.py # load, analyze, suggest, list, sample (8 datasets)
transform.py # filter, groupby, pivot, derive, merge
viz.py # create, modify, undo, list, execute_code
crossfilter.py # linked selections via hv.link_selections
streaming.py # live-updating charts with BokehJS streaming
annotations.py # hline, vline, spans, text, points, arrows, overlays
dashboard.py # layout composition with template support
export.py # HTML/PNG/SVG export
interact.py # handle_click, set_theme, launch/stop_panel
auto_eda.py # one-call complete exploratory analysis
statistics.py # t-test, correlation, regression, chi2, normality, ANOVA
data_quality.py # quality report + dataset comparison
nlq.py # natural language query interpretation
bigdata.py # datashader + synthetic data generation
timeseries.py # rolling stats, decomposition, anomaly detection
utils.py # describe, clone, sample, session management
apps/
viz.html # Chart viewer with toolbar
dashboard.html # Dashboard viewer with stats
stream.html # Streaming viewer with pulse indicator
crossfilter.html # Crossfilter viewer with brush hints
eda.html # EDA report with tabbed insights
statistics.html # Statistics viewer with p-value highlights
timeseries.html # Time series viewer with metrics
quality.html # Quality report with score gauge
tests/ # 148 tests across 16 files
demos/ # 3 showcase scriptsTechnical notes
Panel embed vs raw BokehJS: Most MCP viz tools use
bokeh.embed.json_item()for static Bokeh. Panel'sembed=Truecaptures widget state, linked selections, and layout logic into standalone HTML. This is what makes crossfiltering work without a server.Why hvPlot: Consistent
.hvplot()API across pandas, xarray, dask, and geopandas. One API, many backends.State management: Plots are versioned. Every
modify_plotcreates a new version;undo_plotreverts. The AI iterates freely without losing previous work.Statistical rigor: Uses scipy.stats for real hypothesis testing — actual p-values, effect sizes, confidence intervals. Not approximations.
Code execution:
execute_codeis the escape hatch — run arbitrary HoloViews/Panel code in a sandboxed namespace with pd, np, hv, pn, and all loaded datasets.Dashboard templates:
create_dashboardsupportstemplate_style='material'(Material Design),'bootstrap'(Bootstrap), and'fast'(Fast Design) for polished, professional output.
Dependencies
Core: fastmcp, holoviews, hvplot, panel, bokeh, pandas, numpy, scipy
Optional: openpyxl (Excel), pyarrow (Parquet), scikit-learn (sample data)
License
MIT
Available Tools
36 toolsanalyze_dataC
Generate a comprehensive data profile for a loaded dataset.
Inputs: dataset_name (required). Returns: result
annotate_plotA
Add annotations and overlays to an existing plot.
Useful for marking thresholds, highlighting regions, or adding reference lines and labels.
Inputs: plot_id (required), annotation_type (required), x, y, +8 more. Returns: result
auto_edaA
Run a complete exploratory data analysis in one call.
Automatically generates distributions, correlations, categorical breakdowns, and a narrative summary with key insights. Returns a multi-panel dashboard.
Inputs: dataset_name (required), max_plots, include_missing, include_correlations, +1 more. Returns: result
clone_plotA
Create a copy of an existing plot that can be modified independently.
Useful for creating variations of a visualization without altering the original.
Inputs: plot_id (required), new_title. Returns: result
compare_datasetsA
Compare two datasets side-by-side: shapes, columns, distributions, and statistical differences.
Useful for comparing train/test splits, before/after transformations, or different time periods.
Inputs: dataset_a (required), dataset_b (required). Returns: result
create_crossfilterA
Create a linked crossfilter dashboard where selections in one view filter all others.
This is a HoloViews killer feature: brush/select points in any plot and all other plots update in real time to show only the matching data. Only possible with Panel-native rendering.
Inputs: views (required), dataset_name (required), title, color_by. Returns: result
create_dashboardA
Create a dashboard combining multiple plots.
Returns PNG preview + interactive HTML with full Panel layout. Supports professional dashboard templates for polished output.
Inputs: plot_ids (required), title, layout, template_style. Returns: result
create_datashader_plotA
Create a datashader-powered plot for large datasets (10K+ points).
Rasterizes data into a pixel-density heatmap — works with millions of points where scatter plots would be unusable. Uses hvPlot's datashade integration.
Inputs: x (required), y (required), dataset_name (required), cmap, +4 more. Returns: result
create_plotA
Create an interactive plot from a loaded dataset.
Returns both a PNG preview (for inline chat display) and interactive HTML (as an embedded resource for full interactivity).
Inputs: x (required), plot_type (required), dataset_name (required), y, +7 more. Returns: result
create_streaming_plotA
Create a live-updating streaming visualization with simulated real-time data.
The output is a self-contained HTML page with Panel periodic callbacks that simulates streaming data — the chart updates in real time. This works entirely client-side, no server needed.
If a dataset is provided, the streaming simulation replays its data progressively. Otherwise, generates a random walk time series.
Inputs: x, y, title, n_points, +4 more. Returns: result
data_quality_reportB
Generate a comprehensive data quality report with visualizations.
Analyzes missing values, outliers, data types, uniqueness, and consistency. Returns a narrative report with diagnostic plots.
Inputs: dataset_name (required), outlier_method, outlier_threshold. Returns: result
describe_plotA
Generate a human-readable description of a plot for accessibility and context.
Provides a natural language summary including chart type, axes, data range, notable patterns — useful for screen readers and AI context building.
Inputs: plot_id (required). Returns: result
execute_codeA
Execute arbitrary hvPlot/HoloViews/Panel code and return the result.
This is the power-user escape hatch for visualizations that go beyond the structured tools — linked selections, overlays, custom widgets, etc.
The code must assign the final visualization to a variable named result.
Available in scope: pd, np, hv, hvplot, pn, and any loaded datasets.
Inputs: code (required), dataset_name. Returns: result
export_plotA
Export a plot to a specified format and return the encoded content.
Returns the exported content as base64 (for binary formats) or raw text (for HTML). The AI assistant can then save it to a file or display it.
Inputs: plot_id (required), width, format, height. Returns: result
generate_large_datasetA
Generate a large synthetic dataset for big-data visualization demos.
Creates datasets with patterns that are only visible at scale — clusters, spirals, or random noise — perfect for datashader showcases.
Inputs: name, n_points, distribution. Returns: result
get_data_sampleB
Get a sample of rows from a dataset as formatted text.
Useful for providing data context to the AI or for quick inspection.
Inputs: dataset_name (required), n_rows, random, columns. Returns: result
get_plot_htmlB
Get a plot as standalone interactive HTML for embedding.
Inputs: plot_id (required). Returns: result
handle_clickA
Process a click event on a chart and return AI-friendly insights.
When a user clicks on a data point in a visualization, this tool analyzes the clicked point in context and returns insights about it. This enables bidirectional communication: the AI creates a chart, the user clicks a point, and the AI explains what that point means.
Inputs: plot_id (required), x_value, y_value, point_index. Returns: result
launch_panelA
Open a plot as a full interactive Panel app in the browser.
This launches a local Panel server and opens the visualization in your default browser with full Panel interactivity — widgets, linked selections, and all Panel features that can't fit in an iframe.
Inputs: plot_id (required), port, title. Returns: result
list_datasetsA
List all loaded datasets with their shapes and column names.
Inputs: no named parameters. Returns: result
list_plotsA
List all created plots with their IDs, types, and version counts.
Inputs: no named parameters. Returns: result
load_dataA
Load data into the server from CSV text, JSON text, or a URL.
Supports CSV, JSON, Parquet, and Excel formats. For URL loading, the format is auto-detected from the file extension.
Inputs: url, name, format, csv_data, +1 more. Returns: result
load_sample_dataA
Load a built-in sample dataset for quick demos.
Inputs: dataset. Returns: result
load_sessionA
Load a previously saved session, restoring datasets and plot specs.
Inputs: file_path. Returns: result
merge_datasetsB
Merge two datasets together on a common column.
Inputs: on (required), left_name (required), right_name (required), how, +1 more. Returns: result
modify_plotB
Modify an existing plot's appearance. Returns updated PNG + HTML.
Inputs: plot_id (required), cmap, title, width, +5 more. Returns: result
natural_language_queryB
Interpret a natural language query about a dataset and return a structured plan.
Analyzes the query against the dataset's columns and types to produce a step-by-step execution plan using the MCP tools. The AI assistant can then execute these steps.
Inputs: query (required), dataset_name (required). Returns: result
overlay_plotsA
Overlay multiple plots on top of each other (shared axes).
Unlike a dashboard which places plots side by side, overlay composites them onto a single set of axes — useful for comparing distributions, showing model vs actual, etc.
Inputs: plot_ids (required), title. Returns: result
save_sessionA
Save the current session state (datasets + plot specs) to a JSON file.
Allows resuming work later by loading the session back. Note: plot objects are not serialized — only specs and data are saved.
Inputs: file_path. Returns: result
set_themeA
Set the global visualization theme for all subsequent plots.
Affects the background color, font colors, and grid styling of new visualizations created after this call.
Inputs: theme. Returns: result
statistical_testA
Run a statistical test and return results with a diagnostic plot.
Supports t-test, correlation, regression, chi-square, and normality tests. Returns both numerical results (p-values, effect sizes) and a visualization.
Inputs: column_x (required), test_type (required), dataset_name (required), column_y, +2 more. Returns: result
stop_panelA
Stop a running Panel server launched by launch_panel.
Inputs: plot_id. Returns: result
suggest_visualizationsB
Suggest appropriate visualization types based on data characteristics.
Inputs: dataset_name (required). Returns: result
time_series_analysisC
Analyze a time series with rolling statistics, trend detection, and decomposition.
Inputs: date_column (required), dataset_name (required), value_column (required), window, +2 more. Returns: result
transform_dataC
Transform a dataset using common operations. Saves the result as a new dataset.
Inputs: operation (required), dataset_name (required), agg, limit, +8 more. Returns: result
undo_plotA
Undo the last modification to a plot. Returns the previous version.
Inputs: plot_id (required). Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 36 tools
Most tools have clearly distinct purposes with detailed descriptions. Some overlap exists (e.g., analyze_data vs. auto_eda vs. data_quality_report) but descriptions emphasize different aspects. Overall, an agent can reliably distinguish tools.
All tool names follow a consistent verb_noun pattern in snake_case (e.g., analyze_data, create_plot, export_plot). There are no deviations or mixed conventions, making it easy to predict tool names.
With 36 tools, the server is on the heavier side for a typical MCP server. While it provides extensive functionality for visualization and data analysis, the count feels slightly bloated and could be streamlined by merging related tools.
The tool surface is exceptionally complete: data loading, transformation, analysis, statistical testing, plotting, animation, dashboards, crossfilters, streaming, and session management are all covered. There are no obvious gaps for the intended domain.
Maintenance
Related MCP Connectors
MCP server that lets your AI assistant build and deploy apps, hosting each one at a live URL.
MCP server for building and testing AI agents with multi-model experimentation and insights.
MCP server that lets AI assistants use all OneSchema features exposed via the public API.
One MCP server for the services your AI needs: memory, files, Microsoft 365, kanban and more.
Related MCP Servers
- AlicenseAqualityCmaintenanceAn open-source MCP server that connects to various data sources (SQL databases, CSV, Parquet files), allowing AI models to execute SQL queries and generate data visualizations for analytics and business intelligence.1276MIT
- FlicenseBqualityDmaintenanceAn MCP server that provides data visualization and machine learning tools, featuring automated intent-based pipeline routing for data cleaning and model training. It enables LLMs to process CSV or JSON data to generate visual charts, perform regressions, or execute clustering analysis.16-
- FlicenseBqualityDmaintenanceAn MCP server that provides AI assistants with full access to Apache Superset instances, enabling interaction with dashboards, charts, datasets, databases, and SQL execution capabilities.34-
- AlicenseBqualityDmaintenanceA standalone MCP server that brings complete data science capabilities to AI assistants, enabling them to load data, train models, and track experiments through natural language.301MIT