vizro-mcp 0.0.1.dev0__py3-none-any.whl

vizro_mcp/server.py

@@ -0,0 +1,400 @@
+"""MCP server for Vizro-AI chart and dashboard creation."""
+
+import mimetypes
+import webbrowser
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Literal, Optional
+
+import vizro.models as vm
+from mcp.server.fastmcp import FastMCP
+from pydantic import ValidationError
+from vizro import Vizro
+
+from vizro_mcp._schemas import (
+    AgGridEnhanced,
+    ChartPlan,
+    ContainerSimplified,
+    DashboardSimplified,
+    FilterSimplified,
+    GraphEnhanced,
+    PageSimplified,
+    ParameterSimplified,
+    TabsSimplified,
+    get_overview_vizro_models,
+    get_simple_dashboard_config,
+)
+from vizro_mcp._utils import (
+    GAPMINDER,
+    IRIS,
+    SAMPLE_DASHBOARD_CONFIG,
+    STOCKS,
+    TIPS,
+    DFInfo,
+    DFMetaData,
+    convert_github_url_to_raw,
+    create_pycafe_url,
+    get_dataframe_info,
+    get_python_code_and_preview_link,
+    load_dataframe_by_format,
+    path_or_url_check,
+)
+
+# PyCafe URL for Vizro snippets
+PYCAFE_URL = "https://py.cafe"
+
+
+@dataclass
+class ValidationResults:
+    """Results of the validation tool."""
+
+    valid: bool
+    message: str
+    python_code: str
+    pycafe_url: Optional[str]
+    browser_opened: bool
+
+
+@dataclass
+class DataAnalysisResults:
+    """Results of the data analysis tool."""
+
+    valid: bool
+    message: str
+    df_info: Optional[DFInfo]
+    df_metadata: Optional[DFMetaData]
+
+
+# TODO: what do I need to do here, as things are already set up?
+mcp = FastMCP(
+    "MCP server to help create Vizro dashboards and charts.",
+)
+
+
+@mcp.tool()
+def get_sample_data_info(data_name: Literal["iris", "tips", "stocks", "gapminder"]) -> DFMetaData:
+    """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
+
+    Args:
+        data_name: Name of the dataset to get sample data for
+
+    Returns:
+        Data info object containing information about the dataset.
+    """
+    if data_name == "iris":
+        return IRIS
+    elif data_name == "tips":
+        return TIPS
+    elif data_name == "stocks":
+        return STOCKS
+    elif data_name == "gapminder":
+        return GAPMINDER
+
+
+@mcp.tool()
+def validate_model_config(
+    config: dict[str, Any],
+    data_infos: list[DFMetaData],  # Should be Optional[..]=None, but Cursor complains..
+    auto_open: bool = True,
+) -> ValidationResults:
+    """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.
+
+    Args:
+        config: Either a JSON string or a dictionary representing a Vizro model configuration
+        data_infos: List of DFMetaData objects containing information about the data files
+        auto_open: Whether to automatically open the PyCafe link in a browser
+
+    Returns:
+        ValidationResults object with status and dashboard details
+    """
+    Vizro._reset()
+
+    try:
+        dashboard = vm.Dashboard.model_validate(config)
+    except ValidationError as e:
+        return ValidationResults(
+            valid=False,
+            message=f"Validation Error: {e!s}",
+            python_code="",
+            pycafe_url=None,
+            browser_opened=False,
+        )
+
+    else:
+        result = get_python_code_and_preview_link(dashboard, data_infos)
+
+        pycafe_url = result.pycafe_url if all(info.file_location_type == "remote" for info in data_infos) else None
+        browser_opened = False
+
+        if pycafe_url and auto_open:
+            try:
+                browser_opened = webbrowser.open(pycafe_url)
+            except Exception:
+                browser_opened = False
+
+        return ValidationResults(
+            valid=True,
+            message="Configuration is valid for Dashboard!",
+            python_code=result.python_code,
+            pycafe_url=pycafe_url,
+            browser_opened=browser_opened,
+        )
+
+    finally:
+        Vizro._reset()
+
+
+@mcp.tool()
+def get_model_json_schema(model_name: str) -> dict[str, Any]:
+    """Get the JSON schema for the specified Vizro model.
+
+    Args:
+        model_name: Name of the Vizro model to get schema for (e.g., 'Card', 'Dashboard', 'Page')
+
+    Returns:
+        JSON schema of the requested Vizro model
+    """
+    # Dictionary mapping model names to their simplified versions
+    modified_models = {
+        "Page": PageSimplified,
+        "Dashboard": DashboardSimplified,
+        "Graph": GraphEnhanced,
+        "AgGrid": AgGridEnhanced,
+        "Table": AgGridEnhanced,
+        "Tabs": TabsSimplified,
+        "Container": ContainerSimplified,
+        "Filter": FilterSimplified,
+        "Parameter": ParameterSimplified,
+    }
+
+    # Check if model_name is in the simplified models dictionary
+    if model_name in modified_models:
+        return modified_models[model_name].model_json_schema()
+
+    # Check if model exists in vizro.models
+    if not hasattr(vm, model_name):
+        return {"error": f"Model '{model_name}' not found in vizro.models"}
+
+    # Get schema for standard model
+    model_class = getattr(vm, model_name)
+    return model_class.model_json_schema()
+
+
+@mcp.tool()
+def get_vizro_chart_or_dashboard_plan(user_plan: Literal["chart", "dashboard"]) -> str:
+    """Get instructions for creating a Vizro chart or dashboard. Call FIRST when asked to create Vizro things."""
+    if user_plan == "chart":
+        return """
+IMPORTANT:
+    - KEEP IT SIMPLE: rather than iterating yourself, ask the user for more instructions
+    - ALWAYS VALIDATE:if you iterate over a valid produced solution, make sure to ALWAYS call the
+        validate_chart_code tool to validate the chart code, display the figure code to the user
+    - DO NOT modify the background (with plot_bgcolor) or color sequences unless explicitly asked for
+
+Instructions for creating a Vizro chart:
+    - analyze the datasets needed for the chart using the load_and_analyze_data tool - the most important
+        information here are the column names and column types
+    - if the user provides no data, but you need to display a chart or table, use the get_sample_data_info
+        tool to get sample data information
+    - create a chart using plotly express and/or plotly graph objects, and call the function `custom_chart`
+    - call the validate_chart_code tool to validate the chart code, display the figure code to the user (as artifact)
+    - do NOT call any other tool after, especially do NOT create a dashboard
+            """
+    elif user_plan == "dashboard":
+        return f"""
+IMPORTANT:
+    - KEEP IT SIMPLE: rather than iterating yourself, ask the user for more instructions
+    - ALWAYS VALIDATE:if you iterate over a valid produced solution, make sure to ALWAYS call the
+        validate_model_config tool again to ensure the solution is still valid
+    - DO NOT show any code or config to the user until you have validated the solution, do not say you are preparing
+        a solution, just do it and validate it
+    - IF STUCK: try enquiring the schema of the component in question
+
+
+Instructions for creating a Vizro dashboard:
+    - IF the user has no plan (ie no components or pages), use the config at the bottom of this prompt
+        and validate that solution without any additions, OTHERWISE:
+    - analyze the datasets needed for the dashboard using the load_and_analyze_data tool - the most
+        important information here are the column names and column types
+    - if the user provides no data, but you need to display a chart or table, use the get_sample_data_info
+        tool to get sample data information
+    - make a plan of what components you would like to use, then request all necessary schemas
+        using the get_model_json_schema tool
+    - assemble your components into a page, then add the page or pages to a dashboard, DO NOT show config or code
+        to the user until you have validated the solution
+    - ALWAYS validate the dashboard configuration using the validate_model_config tool
+    - if you display any code artifact, you must use the above created code, do not add new config to it
+
+Models you can use:
+{get_overview_vizro_models()}
+
+Very simple dashboard config:
+{get_simple_dashboard_config()}
+    """
+
+
+@mcp.tool()
+def load_and_analyze_data(path_or_url: str) -> DataAnalysisResults:
+    """Load data from various file formats into a pandas DataFrame and analyze its structure.
+
+    Supported formats:
+    - CSV (.csv)
+    - JSON (.json)
+    - HTML (.html, .htm)
+    - Excel (.xls, .xlsx)
+    - OpenDocument Spreadsheet (.ods)
+    - Parquet (.parquet)
+
+    Args:
+        path_or_url: Local file path or URL to a data file
+
+    Returns:
+        DataAnalysisResults object containing DataFrame information and metadata
+    """
+    # Handle files and URLs
+    path_or_url_type = path_or_url_check(path_or_url)
+    mime_type, _ = mimetypes.guess_type(str(path_or_url))
+    processed_path_or_url = path_or_url
+
+    if path_or_url_type == "remote":
+        processed_path_or_url = convert_github_url_to_raw(path_or_url)
+    elif path_or_url_type == "local":
+        processed_path_or_url = Path(path_or_url)
+    else:
+        return DataAnalysisResults(valid=False, message="Invalid path or URL", df_info=None, df_metadata=None)
+
+    try:
+        df, read_fn = load_dataframe_by_format(processed_path_or_url, mime_type)
+
+    except Exception as e:
+        return DataAnalysisResults(valid=False, message=f"Failed to load data: {e!s}", df_info=None, df_metadata=None)
+
+    df_info = get_dataframe_info(df)
+    df_metadata = DFMetaData(
+        file_name=Path(path_or_url).stem if isinstance(processed_path_or_url, Path) else Path(path_or_url).name,
+        file_path_or_url=str(processed_path_or_url),
+        file_location_type=path_or_url_type,
+        read_function_string=read_fn,
+    )
+
+    return DataAnalysisResults(valid=True, message="Data loaded successfully", df_info=df_info, df_metadata=df_metadata)
+
+
+@mcp.prompt()
+def create_starter_dashboard():
+    """Prompt template for getting started with Vizro."""
+    content = f"""
+Create a super simple Vizro dashboard with one page and one chart and one filter:
+- No need to call any tools except for validate_model_config
+- Call this tool with the precise config as shown below
+- The PyCafe link will be automatically opened in your default browser
+- THEN show the python code after validation, but do not show the PyCafe link
+- Be concise, do not explain anything else, just create the dashboard
+- Finally ask the user what they would like to do next, then you can call other tools to get more information,
+    you should then start with the get_chart_or_dashboard_plan tool
+
+{SAMPLE_DASHBOARD_CONFIG}
+"""
+    return content
+
+
+@mcp.prompt()
+def create_eda_dashboard(
+    file_path_or_url: str,
+) -> str:
+    """Prompt template for creating an EDA dashboard based on one dataset."""
+    content = f"""
+Create an EDA dashboard based on the following dataset:{file_path_or_url}. Proceed as follows:
+1. Analyze the data using the load_and_analyze_data tool first, passing the file path or github url {file_path_or_url}
+    to the tool.
+2. Create a dashboard with 4 pages:
+    - Page 1: Summary of the dataset using the Card component and the dataset itself using the plain AgGrid component.
+    - Page 2: Visualizing the distribution of all numeric columns using the Graph component with a histogram.
+        - use a Parameter that targets the Graph component and the x argument, and you can select the column to
+            be displayed
+        - IMPORTANT:remember that you target the chart like: <graph_id>.x and NOT <graph_id>.figure.x
+        - do not use any color schemes etc.
+        - add filters for all categorical columns
+    - Page 3: Visualizing the correlation between all numeric columns using the Graph component with a scatter plot.
+    - Page 4: Two interesting charts side by side, use the Graph component for this. Make sure they look good
+        but do not try something beyond the scope of plotly express
+"""
+    return content
+
+
+@mcp.tool()
+def validate_chart_code(
+    config: ChartPlan,
+    data_info: DFMetaData,
+    auto_open: bool = True,
+) -> ValidationResults:
+    """Validate the chart code created by the user and optionally open the PyCafe link in a browser.
+
+    Args:
+        config: A ChartPlan object with the chart configuration
+        data_info: Metadata for the dataset to be used in the chart
+        auto_open: Whether to automatically open the PyCafe link in a browser
+
+    Returns:
+        ValidationResults object with status and dashboard details
+    """
+    Vizro._reset()
+
+    try:
+        chart_plan_obj = ChartPlan.model_validate(config)
+    except ValidationError as e:
+        return ValidationResults(
+            valid=False,
+            message=f"Validation Error: {e!s}",
+            python_code="",
+            pycafe_url=None,
+            browser_opened=False,
+        )
+    else:
+        dashboard_code = chart_plan_obj.get_dashboard_template(data_info=data_info)
+
+        # Generate PyCafe URL if all data is remote
+        pycafe_url = create_pycafe_url(dashboard_code) if data_info.file_location_type == "remote" else None
+        browser_opened = False
+
+        if auto_open and pycafe_url:
+            try:
+                browser_opened = webbrowser.open(pycafe_url)
+            except Exception:
+                browser_opened = False
+
+        return ValidationResults(
+            valid=True,
+            message="Chart only dashboard created successfully!",
+            python_code=chart_plan_obj.get_chart_code(vizro=True),
+            pycafe_url=pycafe_url,
+            browser_opened=browser_opened,
+        )
+
+    finally:
+        Vizro._reset()
+
+
+@mcp.prompt()
+def create_vizro_chart(
+    chart_type: str,
+    file_path_or_url: Optional[str] = None,
+) -> str:
+    """Prompt template for creating a Vizro chart."""
+    content = f"""
+ - Create a chart using the following chart type: {chart_type}.
+ - You MUST name the function containing the fig `custom_chart`
+ - Make sure to analyze the data using the load_and_analyze_data tool first, passing the file path or github url
+ {file_path_or_url} OR choose the most appropriate sample data using the get_sample_data_info tool.
+ Then you MUST use the validate_chart_code tool to validate the chart code.
+            """
+    return content

vizro_mcp-0.0.1.dev0.dist-info/METADATA

@@ -0,0 +1,212 @@
+Metadata-Version: 2.4
+Name: vizro-mcp
+Version: 0.0.1.dev0
+Summary: MCP server to help create Vizro dashboards and charts
+Author: Vizro Team
+License-File: LICENSE.txt
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: click>=8.1.7
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: mcp[cli]>=1.6.0
+Requires-Dist: pandas[excel,html,parquet]
+Requires-Dist: vizro==0.1.38
+Description-Content-Type: text/markdown
+
+# Vizro MCP server
+
+Vizro-MCP is a [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server, which works alongside a LLM to help you create Vizro dashboards and charts.
+
+## Features of Vizro-MCP
+
+Vizro-MCP provides tools and templates to create a functioning Vizro chart or dashboard step by step. Benefits include:
+
+✅ One consistent framework for charts and dashboards with one common design language. ✅ Validated config output that is readable and easy to alter or maintain. ✅ Live preview of the dashboard to iterate the design until the dashboard is perfect. ✅ Use of local or remote datasets simply by providing a path or URL.
+
+### Without Vizro-MCP
+
+Without Vizro-MCP, if you try to make a dashboard using an LLM, it could choose any framework, and use it without specific guidance, design principles, or consistency. The results are:
+
+❌ A random choice of frontend framework or charting library. ❌ A vibe-coded mess that may or may not run, but certainly is not very maintainable. ❌ No way to easily preview the dashboard. ❌ No easy way to connect to real data.
+
+## 🛠️ Get started
+
+If you are a **developer** and need instructions for running Vizro-MCP from source, skip to the end of this page to [Development or running from source](#development-or-running-from-source).
+
+### Prerequisites
+
+- [uv](https://docs.astral.sh/uv/getting-started/installation/)
+- [Claude Desktop](https://claude.ai/download) or [Cursor](https://www.cursor.com/downloads)
+
+In principle, the Vizro MCP server works with _any_ MCP enabled LLM applications but we recommend Claude Desktop or Cursor as popular choices.
+
+> 🐛 **Note:** There are currently some known issues with [VS Code](https://code.visualstudio.com/) but we are working on this and hope to have Copilot working soon.
+
+> ⚠️ **Warning:** In some hosts (like Claude Desktop) the free plan might be less performant, which may cause issues when the request is too complex. In cases where the request causes the UI to crash, opt for using a paid plan, or reduce your request's complexity.
+
+## Setup Instructions
+
+<details>
+<summary><strong>Claude</strong></summary>
+
+Add the following to your `claude_desktop_config.json` [found via Developer Settings](https://modelcontextprotocol.io/quickstart/user#2-add-the-filesystem-mcp-server).
+
+```json
+{
+  "mcpServers": {
+    "vizro-mcp": {
+      "command": "uvx",
+      "args": [
+        "vizro-mcp"
+      ]
+    }
+  }
+}
+```
+
+> ⚠️ **Warning:** In some cases you may need to provide the full path to your `uv` executable, so instead of `uv` would use something like `/Users/<your-username>/.local/bin/uv`. To discover the path of `uv` on your machine, in your terminal app, type `which uv`.
+
+If you are using Claude Desktop, restart it, and after a few moments, you should see the vizro-mcp menu when opening the settings/context menu:
+
+<img src="assets/claude_working.png" alt="Claude Desktop MCP Server Icon" width="150"/>
+
+</details>
+
+<details>
+<summary><strong>Cursor</strong></summary>
+
+Add the following to `mcp.json` [found via the Cursor Settings](https://docs.cursor.com/context/model-context-protocol#configuration-locations).
+
+```json
+{
+  "mcpServers": {
+    "vizro-mcp": {
+      "command": "uvx",
+      "args": [
+        "vizro-mcp"
+      ]
+    }
+  }
+}
+```
+
+> ⚠️ **Warning:** In some cases you may need to provide the full path to your `uv` executable, so instead of `uv` would use something like `/Users/<your-username>/.local/bin/uv`. To discover the path of `uv` on your machine, in your terminal app, type `which uv`.
+
+Similarly, when using Cursor, after a short pause, you should see a green light in the MCP menu:
+
+<img src="assets/cursor_working.png" alt="Cursor MCP Server Icon" width="400"/>
+
+</details>
+
+In principle, the Vizro MCP server works with _any_ MCP enabled LLM applications but we recommend Claude Desktop or Cursor as popular choices. Different AI tools may use different setup methods or connection settings. Check each tool's docs for details.
+
+## 💻 Usage
+
+### Use prompt templates to get specific dashboards quickly
+
+Prompt templates are not available in all MCP hosts, but when they are, you can use them to get specific dashboards quickly. To access them (e.g. in Claude Desktop), click on the plus icon below the chat, and choose _`Add from vizro-mcp`_.
+
+<img src="assets/claude_prompt.png" alt="Claude Desktop MCP Server Icon" width="300"/>
+
+The **easiest** way to get started with Vizro dashboards is to choose the template `create_starter_dashboard` and just send the prompt. This will create a super simple dashboard with one page, one chart, and one filter. Take it from there!
+
+### Create a Vizro dashboard based on local or remote data
+
+You can also ask the LLM to create specific dashboards based on local or remote data if you already have an idea of what you want. Example prompts could be:
+
+> _Create a Vizro dashboard with one page, a scatter chart, and a filter based on `<insert absolute file path or public URL>` data._
+
+> _Create a simple two page Vizro dashboard, with first page being a correlation analysis of `<insert absolute file path or public URL>` data, and the second page being a map plot of `<insert absolute file path or public URL>` data_
+
+You can even ask for a dashboard without providing data:
+
+> _Create a Vizro dashboard with one page, a scatter chart, and a filter._
+
+In general, it helps to specify Vizro in the prompt and to keep it as precise (and simple) as possible.
+
+### Get a live preview of your dashboard
+
+When the LLM chooses to use the tool `validate_model_config`, and the tool executes successfully, the LLM will return a link to a live preview of the dashboard if only public data accessed via URL is used. By default, the LLM will even open the link in your browser for you unless you tell it not to. In Claude Desktop, you can see the output of the tool by opening the tool collapsible and scrolling down to the very bottom.
+
+<img src="assets/claude_validate.png" width="300"/>
+
+You can also ask the model to give you the link, but it will attempt to regenerate it, which is very error prone and slow.
+
+### Create Vizro charts
+
+The **easiest** way to get started with Vizro charts is to choose the template `create_vizro_chart` and just send the prompt. This will create a simple chart that you can alter. Take it from there!
+
+Alternatively, you can just ask in the chat things like:
+
+> _Create a scatter based on the iris dataset._
+
+> _Create a bar chart based on `<insert absolute file path or public URL>` data._
+
+## 🔍 Transparency and trust
+
+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.
+
+In general the most critical part of the process is the `load_and_analyze_data` tool. This tool, running on your machine, will load local or remote data into a pandas DataFrame and provide a detailed analysis of its structure and content. It only uses `pd.read_xxx`, so in general there is no need to worry about privacy or data security.
+
+The second most critical part is the `validate_model_config` tool. This tool will attempt to instantiate the Vizro model configuration and return the Python code and visualization link for valid configurations. If the configuration is valid, it will also return and attempt to open a link to a live preview of the dashboard, which will take you to [PyCafe](https://py.cafe). If you don't want to open the link, you can tell the LLM to not do so.
+
+## Available Tools (if client allows)
+
+The Vizro MCP server provides the following tools. In general you should not need to use them directly, but in special cases you could ask the LLM to call them directly to help it find its way.
+
+- `get_vizro_chart_or_dashboard_plan` - Get a structured step-by-step plan for creating either a chart or dashboard. Provides guidance on the entire creation process.
+- `get_model_JSON_schema` - Retrieves the complete JSON schema for any specified Vizro model, useful for understanding required and optional parameters.
+- `validate_model_config` - Tests Vizro model configurations by attempting to instantiate them. Returns Python code and visualization links for valid configurations.
+- `load_and_analyze_csv` - Loads a CSV file from a local path or URL into a pandas DataFrame and provides detailed analysis of its structure and content.
+- `validate_chart_code` - Validates the code created for a chart and returns feedback on its correctness.
+- `get_sample_data_info` - Provides information about sample datasets that can be used for testing and development.
+
+## Available Prompts (if client allows)
+
+- `create_starter_dashboard` - Use this prompt template to get started with Vizro dashboards.
+- `create_EDA_dashboard` - Use this prompt template to create an Exploratory Data Analysis (EDA) dashboard based on a local or remote CSV dataset
+- `create_vizro_chart` - Use this prompt template to create a Vizro styled plotly chart based on a local or remote CSV dataset
+
+## Sample data
+
+You can find a set of sample CSVs to try out in the [Plotly repository](https://github.com/plotly/datasets/tree/master).
+
+## Development or running from source
+
+If you are a developer, or if you are running Vizro-MCP from source, you need to clone the Vizro repo. To configure the Vizro MCP server details:
+
+**For Claude**: Add the following to your `claude_desktop_config.json` [found via Developer Settings](https://modelcontextprotocol.io/quickstart/user#2-add-the-filesystem-mcp-server):
+
+**For Cursor**: Add the following to `mcp.json` [found via the Cursor Settings](https://docs.cursor.com/context/model-context-protocol#configuration-locations):
+
+```json
+{
+  "mcpServers": {
+    "vizro-mcp": {
+      "command": "uv",
+      "args": [
+        "run",
+        "--directory",
+        "<PATH TO VIZRO>/vizro-mcp/",
+        "vizro-mcp"
+      ]
+    }
+  }
+}
+```
+
+Replace `<PATH TO VIZRO>` with the actual path to your Vizro repository. You may also need to provide the full path to your `uv` executable, so instead of `"uv"` you would use something like `"/Users/<your-username>/.local/bin/uv"`. To discover the path of `uv` on your machine, in your terminal app, type `which uv`.
+
+## Other cool MCP Servers
+
+Here are some other awesome MCP servers you might want to check out:
+
+- [Context7](https://github.com/upstash/context7) - Provides up-to-date code documentation for any library directly in your prompts. Great for getting the latest API references and examples without relying on outdated training data.
+
+- [Everything MCP](https://github.com/modelcontextprotocol/servers/tree/main/src/everything) - A development-focused MCP server that combines multiple capabilities including web search, code search, and more. Useful for testing and prototyping MCP features. Part of the official MCP servers collection.
+
+You can find more MCP servers in the [official MCP servers repository](https://github.com/modelcontextprotocol/servers/tree/main).

vizro_mcp-0.0.1.dev0.dist-info/RECORD

@@ -0,0 +1,12 @@
+vizro_mcp/__init__.py,sha256=rARL6i447w01mUjVtn3WBb3noEgTzbrNqBinR5SUyrs,384
+vizro_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vizro_mcp/server.py,sha256=cINRBPr0hkN5S5tD_Gf6dYu8vC7QviYCOrCtiAxYYwU,14813
+vizro_mcp/_schemas/__init__.py,sha256=przXt7ukurnDlj3SLRW-K0VO1ksnDDFuS8Njf80xepo,610
+vizro_mcp/_schemas/schemas.py,sha256=r_0i9fRtyMh7W3q3KgnpCbRUDlBaFjG6XQjCtahgEXc,11625
+vizro_mcp/_utils/__init__.py,sha256=q-xdwiyRCaOWWTeG5NC_1CzHWXBH4sUKpIBXbUaKg_Y,670
+vizro_mcp/_utils/utils.py,sha256=gIuKXONR2SvOgA3Vo3ONnkh8Qcc-RLfrexJAjan12zk,9217
+vizro_mcp-0.0.1.dev0.dist-info/METADATA,sha256=nCTKmpfHmHJ6h5TjlZ5zKVqk-CMhal9Ca1QhakaJITo,11747
+vizro_mcp-0.0.1.dev0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+vizro_mcp-0.0.1.dev0.dist-info/entry_points.txt,sha256=iSUzPHvx4Ogsn91tK2C0OHxI44SNCHT1F1zUqbTj5O0,45
+vizro_mcp-0.0.1.dev0.dist-info/licenses/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+vizro_mcp-0.0.1.dev0.dist-info/RECORD,,

vizro_mcp-0.0.1.dev0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

vizro_mcp-0.0.1.dev0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+vizro-mcp = vizro_mcp:main