The Vizro MCP server assists in creating, validating, and visualizing Vizro dashboards and charts using an LLM.
Create Dashboards: Generate structured, step-by-step plans for creating Vizro dashboards with consistent frameworks.
Data Handling: Load and analyze structured data from various formats (CSV, JSON, Excel, HTML, Parquet, ODS) from local files or public URLs.
Visualizations: Generate and validate Vizro charts based on data, with support for live previews.
Validation Tools: Validate both dashboards and chart configurations, returning executable Python code or PyCafe links for live visualization.
Development Assistance: Access JSON schemas for any Vizro model (Card, Dashboard, Page) and use prompt templates for quickly generating starter dashboards.
Sample Data: Provide information about pre-defined sample datasets (iris, tips, stocks, gapminder) for testing and development.
Click on "Install 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., "@vizro-mcp create a bar chart showing sales by region from the quarterly data"
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.
Vizro-MCP is a Model Context Protocol (MCP) server, which works alongside an LLM to help you create Vizro dashboards and charts.
To find out more, consult the Vizro-MCP documentation.
Vizro-MCP is best used with Claude Desktop, Cursor or VS Code. However, it can be used with most LLM products that enable configuration of MCP server usage.
đź’ˇ Tip: For best performance, we recommend using the
claude-4-sonnetmodel, or another high-performing model of your choice. Using the often offeredautosetting may lead to inconsistent or unexpected results.
Our documentation offers separate, detailed steps for Claude Desktop, Cursor and VS Code.
The following is for those familiar with MCP server setup who are comfortable with basic configuration settings. You must have downloaded and installed the LLM app you want to configure and use as a MCP host.
You must first install uv.
Next, open a terminal window and type uv to confirm that is available. To get the path to uvx, type the following:
which uvCopy the path returned, and add the following to the JSON file used to configure MCP servers for your LLM app. Be sure to substitute your path to uv as returned above, for the placeholder given:
{
"mcpServers": {
"vizro-mcp": {
"command": "/placeholder-path/uvx",
"args": [
"vizro-mcp"
]
}
}
}Quick install
You must first install Docker.
Next, add the following to the JSON file used to configure MCP servers for your LLM app.
{
"mcpServers": {
"vizro-mcp": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"mcp/vizro"
]
}
}
}To use local data with Docker
Mount your data directory or directories into the container with the following extended configuration. Replace </absolute/path/to/allowed/dir> (syntax for folders) or </absolute/path/to/data.csv> (syntax for files) with the absolute path to your data on your machine. For consistency, we recommend that the dst path matches the src path.
{
"mcpServers": {
"vizro-mcp": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"--mount",
"type=bind,src=</absolute/path/to/allowed/dir>,dst=</absolute/path/to/allowed/dir>",
"--mount",
"type=bind,src=</absolute/path/to/data.csv>,dst=</absolute/path/to/data.csv>",
"mcp/vizro"
]
}
}
}Quick install
Host | Prerequisite | Link | Notes |
For local data access, mount your data directory | |||
For local data access, mount your data directory |
Related MCP server: ML Research MCP
MCP servers are a relatively new concept, and it is important to be transparent about what the tools are capable of so you can make an informed choice as a user. Overall, the Vizro MCP server only reads data, and never writes, deletes or modifies any data on your machine.
Users are responsible for anything done via their host LLM application.
Users are responsible for procuring any and all rights necessary to access any third-party generative AI tools and for complying with any applicable terms or conditions thereof.
Users are wholly responsible for the use and security of the third-party generative AI tools and of Vizro.
Users acknowledge and agree that:
Any results, options, data, recommendations, analyses, code, or other information (“Outputs”) generated by any third-party generative AI tools (“GenAI Tools”) may contain some inaccuracies, biases, illegitimate, potentially infringing, or otherwise inappropriate content that may be mistaken, discriminatory, or misleading.
McKinsey & Company:
(i) expressly disclaims the accuracy, adequacy, timeliness, reliability, merchantability, fitness for a particular purpose, non-infringement, safety or completeness of any Outputs,
(ii) shall not be liable for any errors, omissions, or other defects in, delays or interruptions in such Outputs, or for any actions taken in reliance thereon, and
(iii) shall not be liable for any alleged violation or infringement of any right of any third party resulting from the users’ use of the GenAI Tools and the Outputs.
The Outputs shall be verified and validated by the users and shall not be used without human oversight and as a sole basis for making decisions impacting individuals.
Users remain solely responsible for the use of the Output, in particular, the users will need to determine the level of human oversight needed to be given the context and use case, as well as for informing the users’ personnel and other affected users about the nature of the GenAI Output. Users are also fully responsible for their decisions, actions, use of Vizro and Vizro-MCP and compliance with applicable laws, rules, and regulations, including but not limited to confirming that the Outputs do not infringe any third-party rights.
Vizro-MCP is used by generative AI models because large language models (LLMs) represent significant advancements in the AI field. However, as with any powerful tool, there are potential risks associated with connecting to a generative AI model.
We recommend users research and understand the selected model before using Vizro-MCP. We also recommend users to check the MCP server code before using it.
Users are encouraged to treat AI-generated content as supplementary, always apply human judgment, approach with caution, review the relevant disclaimer page, and consider the following:
The vendor models might lack real-time knowledge or events beyond its last updates. Vizro-MCP output may vary and you should always verify critical information. It is the user's responsibility to discern the accuracy, consistent, and reliability of the generated content.
Get the JSON schema for the specified Vizro model. Server Vizro version: 0.1.60
| Name | Required | Description | Default |
|---|---|---|---|
| model_name | Yes | Name of the Vizro model to get schema for (e.g., 'Card', 'Dashboard', 'Page') |
| Name | Required | Description |
|---|---|---|
| model_name | Yes | |
| json_schema | Yes | |
| additional_info | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of disclosing behavioral traits. It clearly indicates a read operation (no destructive side effects), but does not mention error behavior, rate limits, or permissions. It is adequate for a simple read tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: two sentences, no fluff. It front-loads the purpose and adds a relevant version note. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that an output schema exists (so return values are documented elsewhere) and the tool has only one parameter, the description covers the essential information. It lacks some depth on usage context, but is largely complete for a simple schema retrieval tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers all parameters with detailed descriptions (coverage 100%). The description adds no additional parameter information beyond the schema, which already explains the 'model_name' parameter with examples. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Get') and resource ('JSON schema') and distinguishes the tool from siblings like 'load_and_analyze_data' and 'validate_dashboard_config', which serve different purposes. The purpose is immediately clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not explicitly state when to use this tool vs. alternatives, nor does it provide any context on prerequisites or when not to use it. The mention of the server version is helpful but insufficient as guidance for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
If user provides no data, use this tool to get sample data information.
Use the following data for the below purposes:
- iris: mostly numerical with one categorical column, good for scatter, histogram, boxplot, etc.
- tips: contains mix of numerical and categorical columns, good for bar, pie, etc.
- stocks: stock prices, good for line, scatter, generally things that change over time
- gapminder: demographic data, good for line, scatter, generally things with maps or many categories
Returns:
Data info object containing information about the dataset.
| Name | Required | Description | Default |
|---|---|---|---|
| data_name | Yes | Name of the dataset to get sample data for |
| Name | Required | Description |
|---|---|---|
| file_name | Yes | |
| file_path_or_url | Yes | |
| column_names_types | No | |
| file_location_type | Yes | |
| read_function_string | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations present, so description bears full burden. It discloses return type ('Data info object') and implies read-only behavior, but lacks details on permissions, rate limits, or side effects. Adequate for a simple retrieval tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Well-structured with a bullet list for dataset descriptions. Condition ('If user provides no data') is front-loaded. Slightly verbose but every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the existence of an output schema (not shown), description correctly focuses on input semantics and use case. It adequately covers the tool's role among siblings, which handle user-provided data or code validation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% (single parameter with enum). Description adds significant meaning beyond schema by explaining each dataset's suitability for different visualizations (e.g., 'iris: mostly numerical... good for scatter, histogram').
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: to get sample data information when no data is provided. It lists four specific datasets (iris, tips, stocks, gapminder) and their characteristics, distinguishing it from sibling tools that handle user-provided data or schemas.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use ('If user provides no data'). Provides guidance on dataset selection based on chart types (scatter, bar, line, etc.). Does not explicitly exclude alternatives but usage condition is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get instructions for creating a Vizro chart or dashboard. Call FIRST when asked to create Vizro things.
Must be ALWAYS called FIRST with advanced_mode=False, then call again with advanced_mode=True
if the JSON config does not suffice anymore.
Returns:
Instructions for creating a Vizro chart or dashboard
| Name | Required | Description | Default |
|---|---|---|---|
| user_host | Yes | The host the user is using, if 'ide' you can use the IDE/editor to run python code | |
| user_plan | Yes | The type of Vizro thing the user wants to create | |
| advanced_mode | No | Only call if you need to use custom CSS, custom components or custom actions. No need to call this with advanced_mode=True if you need advanced charts, use `custom_charts` in the `validate_dashboard_config` tool instead. |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, but description explains the two-step calling behavior and the nature of the return (instructions). Some details like auth or rate limits are absent, but the core behavior is clear.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Very concise, front-loaded with purpose, uses bullet points for clarity, every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With output schema present and all parameters described, the description covers the needed context for using the tool correctly, including the call sequence.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and description adds valuable context for advanced_mode parameter, explaining when to use it. This goes beyond what the schema alone provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Get instructions for creating a Vizro chart or dashboard' and specifies it should be called first, making the purpose unambiguous and distinct from sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit guidance: 'Must be ALWAYS called FIRST with advanced_mode=False, then call again with advanced_mode=True if the JSON config does not suffice anymore.' This tells when to use and how to iterate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Use to understand local or remote data files. Must be called with absolute paths or URLs.
Supported formats:
- CSV (.csv)
- JSON (.json)
- HTML (.html, .htm)
- Excel (.xls, .xlsx)
- OpenDocument Spreadsheet (.ods)
- Parquet (.parquet)
Returns:
DataAnalysisResults object containing DataFrame information and metadata
| Name | Required | Description | Default |
|---|---|---|---|
| path_or_url | Yes | Absolute (important!) local file path or URL to a data file |
| Name | Required | Description |
|---|---|---|
| valid | Yes | |
| df_info | Yes | |
| message | Yes | |
| df_metadata | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully bears the burden of behavioral disclosure. It states the action (load and analyze), supported formats, and return type, but does not disclose whether the operation is read-only, potential file size/performance implications, or any side effects. This is adequate but could be more thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: three lines covering purpose, requirement, formats, and return type. It is front-loaded with the main purpose and includes no redundant information. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity of the tool (one parameter, output schema exists), the description covers the essential aspects: purpose, required input format, supported file types, and return type. It may lack details about remote access authentication or error handling, but overall it is sufficiently complete for an agent to use the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage for the single parameter (path_or_url) with a good description. The additional description adds critical usage constraints (absolute paths/URLs) and lists supported file formats, which significantly enhances the parameter semantics beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool is used to 'understand local or remote data files' and specifies supported formats and return type. While the verb 'understand' is somewhat vague, the combination with the tool name and listed formats makes the purpose clear. It is distinguishable from sibling tools that handle schema, validation, and chart planning.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description includes the critical usage constraint 'Must be called with absolute paths or URLs' but provides no explicit guidance on when to use this tool versus alternatives. The siblings are clearly different in function, so it's implicitly appropriate for data loading, but a brief comparison would improve clarity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Validate the chart code created by the user and optionally open the PyCafe link in a browser.
Returns:
ValidationResults object with status and dashboard details
| Name | Required | Description | Default |
|---|---|---|---|
| auto_open | No | Whether to automatically open the PyCafe link in a browser | |
| data_info | Yes | Metadata for the dataset to be used in the chart | |
| chart_config | Yes | A ChartPlan object with the chart configuration |
| Name | Required | Description |
|---|---|---|
| valid | Yes | |
| message | Yes | |
| pycafe_url | Yes | |
| python_code | Yes | |
| browser_opened | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavior. It only states validation and optional browser opening, but omits details like whether code is executed, what constitutes invalid code, side effects, or authentication requirements. The return type is mentioned but not elaborated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very concise with two sentences plus a return note. It front-loads the primary action. However, it could slightly expand on key behaviors without losing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having an output schema (mentioned), the description lacks context about when validation is needed, error handling, or workflow integration with sibling tools. It omits important contextual details for an effective agent invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with detailed descriptions for all parameters, including nested objects. The tool description adds no extra meaning beyond the schema, so it scores the baseline of 3. It does not clarify how parameters relate to validation logic.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool validates chart code and optionally opens a PyCafe link in a browser. It uses a specific verb ('Validate') and resource ('chart code'), and the purpose is distinct from sibling tools like 'get_vizro_chart_or_dashboard_plan' and 'validate_dashboard_config'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, nor does it mention prerequisites, exclusions, or context. It fails to differentiate usage scenarios among sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Validate Vizro model configuration. Run ALWAYS when you have a complete dashboard configuration.
If successful, the tool will return the python code and, if it is a remote file, the py.cafe link to the chart.
The PyCafe link will be automatically opened in your default browser if auto_open is True.
Returns:
ValidationResults object with status and dashboard details
| Name | Required | Description | Default |
|---|---|---|---|
| auto_open | No | Whether to automatically open the PyCafe link in a browser | |
| data_infos | Yes | List of DFMetaData objects containing information about the data files | |
| custom_charts | Yes | List of ChartPlan objects containing information about the custom charts in the dashboard | |
| dashboard_config | Yes | Either a JSON string or a dictionary representing a Vizro dashboard model configuration |
| Name | Required | Description |
|---|---|---|
| valid | Yes | |
| message | Yes | |
| pycafe_url | Yes | |
| python_code | Yes | |
| browser_opened | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses success outputs (Python code, py.cafe link, auto-open behavior) and mentions return type. However, it does not explain what validation entails (syntax checks, data consistency), leaving process details ambiguous.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief (two sentences plus a return line) and front-loads the primary purpose. It avoids unnecessary details, though the second paragraph could be considered an aside. It is appropriately sized for a tool with a comprehensive schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (nested objects, output schema implied), the description mentions return behavior and auto-open but lacks details on validation scope (e.g., what checks are performed, prerequisites). Output schema existence reduces the need to explain return values, but process details are missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description only adds value by noting the auto_open parameter's effect and the return type, which is marginal. It does not elaborate on the required parameters beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states 'Validate Vizro model configuration' with a clear verb and resource. It differentiates from siblings like 'validate_chart_code' which focuses on individual charts, making the tool's purpose distinct.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description advises 'Run ALWAYS when you have a complete dashboard configuration', providing strong contextual guidance. While it doesn't explicitly exclude other scenarios, the sibling tools cover individual parts (e.g., chart validation, data loading), implying this is for full config validation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Scored across 6 tools
Each tool has a clearly distinct purpose: data loading, planning, sample info, dashboard validation, chart validation, and schema retrieval. There is no functional overlap.
Tools follow a verb_noun pattern with some variation (load_and_analyze, get, validate). While mostly consistent, the use of compound verbs like 'load_and_analyze' differs from single verbs, but overall the pattern is clear.
6 tools is well-scoped for the domain of Vizro chart/dashboard creation. Each tool serves a necessary step in the workflow, neither too few nor too many.
The tool set covers the main workflow: data loading, planning, validation, and schema access. However, it lacks tools for editing or deleting existing dashboards, which are minor gaps for a creation-focused server.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
The grounded data layer for any LLM: governed SQL, metrics, lineage and catalog over your data.
Explore your databases, validate SQL, and build & publish data apps in your Mako workspace.
Generate answers & visualizations from your engineering data to track software development health.
Dashboards as data. Author, validate, render, and share dvt dashboards from any MCP client.
