OpenDataMCP logo

OpenDataMCP

Organization
opendatamcp

Connect any Open Data to any LLM with Model Context Protocol.

Publisheropendatamcp
Repositoryopendatamcp
LanguagePython
Forks
21
Stars
152
Available tools
21
Transport typestdio
Categories
LicenseMIT
Links
  • Connect tools to AI workflows

    OpenDataMCP exposes MCP capabilities that can be used by compatible AI clients and agents.

  • 21 available tools

    Browse the callable actions below, including names and descriptions when provided by the server.

  • Ready-to-copy setup

    Use the installation snippets to configure this server in your preferred MCP client.

  • Open source signals

    152 stars and 21 forks from the linked repository.

Open Data Model Context Protocol

vc3598_Hyper-realistic_Swiss_landscape_pristine_SBB_red_train_p_40803c2e-43f5-410e-89aa-f6bdcb4cd089

See it in action

https://github.com/user-attachments/assets/760e1a16-add6-49a1-bf71-dfbb335e893e

We enable 2 things:

  • Open Data Access: Access to many public datasets right from your LLM application (starting with Claude, more to come).
  • Publishing: Get community help and a distribution network to distribute your Open Data. Get everyone to use it!

How do we do that?

  • Access: Setup our MCP servers in your LLM application in 2 clicks via our CLI tool (starting with Claude, see Roadmap for next steps).
  • Publish: Use provided templates and guidelines to quickly contribute and publish on Open Data MCP. Make your data easily discoverable!

Usage

Access: Access Open Data using Open Data MCP CLI Tool

Prerequisites

If you want to use Open Data MCP with Claude Desktop app client you need to install the Claude Desktop app.

You will also need uv to easily run our CLI and MCP servers.

macOS
bash
# you need to install uv through homebrew as using the install shell script 
# will install it locally to your user which make it unavailable in the Claude Desktop app context.
brew install uv
Windows
bash
# (UNTESTED)
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

Open Data MCP - CLI Tool

Overview
bash
# show available commands
uvx odmcp 

# show available providers
uvx odmcp list

# show info about a provider
uvx odmcp info $PROVIDER_NAME

# setup a provider's MCP server on your Claude Desktop app
uvx odmcp setup $PROVIDER_NAME

# remove a provider's MCP server from your Claude Desktop app
uvx odmcp remove $PROVIDER_NAME
Example

Quickstart for the Switzerland SBB (train company) provider:

bash
# make sure claude is installed
uvx odmcp setup ch_sbb

Restart Claude and you should see a new hammer icon at the bottom right of the chat.

You can now ask questions to Claude about SBB train network disruption and it will answer based on data collected on data.sbb.ch.

Publish: Contribute by building and publishing public datasets

Prerequisites

  1. Install UV Package Manager

    bash
    # macOS
    brew install uv
    
    # Windows (PowerShell)
    powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
    
    # Linux/WSL
    curl -LsSf https://astral.sh/uv/install.sh | sh
  2. Clone & Setup Repository

    bash
    # Clone the repository
    git clone https://github.com/OpenDataMCP/OpenDataMCP.git
    cd OpenDataMCP
    
    # Create and activate virtual environment
    uv venv
    source .venv/bin/activate  # Unix/macOS
    # or
    .venv\Scripts\activate     # Windows
    
    # Install dependencies
    uv sync
  3. Install Pre-commit Hooks

    bash
    # Install pre-commit hooks for code quality
    pre-commit install

Publishing Instructions

  1. Create a New Provider Module

    • Each data source needs its own python module.
    • Create a new Python module in src/odmcp/providers/.
    • Use a descriptive name following the pattern: {country_code}_{organization}.py (e.g., ch_sbb.py).
    • Start with our template file as your base.
  2. Implement Required Components

    • Define your Tools & Resources following the template structure
    • Each Tool or Resource should have:
      • Clear description of its purpose
      • Well-defined input/output schemas using Pydantic models
      • Proper error handling
      • Documentation strings
  3. Tool vs Resource

    • Choose Tool implementation if your data needs:
      • Active querying or computation
      • Parameter-based filtering
      • Complex transformations
    • Choose Resource implementation if your data is:
      • Static or rarely changing
      • Small enough to be loaded into memory
      • Simple file-based content
      • Reference documentation or lookup tables
    • Reference the MCP documentation for guidance
  4. Testing

    • Add tests in the tests/ directory
    • Follow existing test patterns (see other provider tests)
    • Required test coverage:
      • Basic functionality
      • Edge cases
      • Error handling
  5. Validation

    • Test your MCP server using our experimental client: uv run src/odmcp/providers/client.py
    • Verify all endpoints respond correctly
    • Ensure error messages are helpful
    • Check performance with typical query loads

For other examples, check our existing providers in the src/odmcp/providers/ directory.

Contributing

We have an ambitious roadmap and we want this project to scale with the community. The ultimate goal is to make the millions of datasets publicly available to all LLM applications.

For that we need your help!

Discord

We want to build a helping community around the challenge of bringing open data to LLM's. Join us on discord to start chatting: https://discord.gg/QPFFZWKW

Our Core Guidelines

Because of our target scale we want to keep things simple and pragmatic at first. Tackle issues with the community as they come along.

  1. Simplicity and Maintainability

    • Minimize abstractions to keep codebase simple and scalable
    • Focus on clear, straightforward implementations
    • Avoid unnecessary complexity
  2. Standardization / Templates

    • Follow provided templates and guidelines consistently
    • Maintain uniform structure across providers
    • Use common patterns for similar functionality
  3. Dependencies

    • Keep external dependencies to a minimum
    • Prioritize single repository/package setup
    • Carefully evaluate necessity of new dependencies
  4. Code Quality

    • Format code using ruff
    • Maintain comprehensive test coverage with pytest
    • Follow consistent code style
  5. Type Safety

    • Use Python type hints throughout
    • Leverage Pydantic models for API request/response validation
    • Ensure type safety in data handling

Tactical Topics (our current priorities)

  • Initialize repository with guidelines, testing framework, and contribution workflow
  • Implement CI/CD pipeline with automated PyPI releases
  • Develop provider template and first reference implementation
  • Integrate additional open datasets (actively seeking contributors)
  • Establish clear guidelines for choosing between Resources and Tools
  • Develop scalable repository architecture for long-term growth
  • Expand MCP SDK parameter support (authentication, rate limiting, etc.)
  • Implement additional MCP protocol features (prompts, resource templates)
  • Add support for alternative transport protocols beyond stdio (SSE)
  • Deploy hosted MCP servers for improved accessibility

Roadmap

Let’s build the open source infrastructure that will allow all LLMs to access all Open Data together!

Access:

  • Make Open Data available to all LLM applications (beyond Claude)
  • Make Open Data data sources searchable in a scalable way
  • Make Open Data available through MCP remotely (SSE) with publicly sponsored infrastructure

Publish:

  • Build the many Open Data MCP servers to make all the Open Data truly accessible (we need you!).
  • On our side we are starting to build MCP servers for Switzerland ~12k open dataset!
  • Make it even easier to build Open Data MCP servers

We are very early, and lack of dataset available is currently the bottleneck. Help yourself! Create your Open Data MCP server and get users to use it as well from their LLMs applications. Let’s connect LLMs to the millions of open datasets from governments, public entities, companies and NGOs!

As Anthropic's MCP evolves we will adapt and upgrade Open Data MCP.

Limitations

  • All data served by Open Data MCP servers should be Open.
  • Please oblige to the data licenses of the data providers.
  • Our License must be quoted in commercial applications.

References

License

This project is licensed under the MIT License - see the LICENSE file for details

Installation

TypingMind
Prerequisites:

Node.js 18+

{
  "mcpServers": {
    "blender": {
      "command": "uvx",
      "args": [
        "blender-mcp"
      ]
    }
  }
}

Available Tools

  • get_scene_info

    Get detailed information about the current Blender scene

  • get_object_info
    Get detailed information about a specific object in the Blender scene.
    
    Parameters:
    - object_name: The name of the object to get information about
    
  • get_viewport_screenshot
    Capture a screenshot of the current Blender 3D viewport.
    
    Parameters:
    - max_size: Maximum size in pixels for the largest dimension (default: 800)
    
    Returns the screenshot as an Image.
    
  • execute_blender_code
    Execute arbitrary Python code in Blender. Make sure to do it step-by-step by breaking it into smaller chunks.
    
    Parameters:
    - code: The Python code to execute
    
  • get_polyhaven_categories
    Get a list of categories for a specific asset type on Polyhaven.
    
    Parameters:
    - asset_type: The type of asset to get categories for (hdris, textures, models, all)
    
  • search_polyhaven_assets
    Search for assets on Polyhaven with optional filtering.
    
    Parameters:
    - asset_type: Type of assets to search for (hdris, textures, models, all)
    - categories: Optional comma-separated list of categories to filter by
    
    Returns a list of matching assets with basic information.
    
  • download_polyhaven_asset
    Download and import a Polyhaven asset into Blender.
    
    Parameters:
    - asset_id: The ID of the asset to download
    - asset_type: The type of asset (hdris, textures, models)
    - resolution: The resolution to download (e.g., 1k, 2k, 4k)
    - file_format: Optional file format (e.g., hdr, exr for HDRIs; jpg, png for textures; gltf, fbx for models)
    
    Returns a message indicating success or failure.
    
  • set_texture
    Apply a previously downloaded Polyhaven texture to an object.
    
    Parameters:
    - object_name: Name of the object to apply the texture to
    - texture_id: ID of the Polyhaven texture to apply (must be downloaded first)
    
    Returns a message indicating success or failure.
    
  • get_polyhaven_status
    Check if PolyHaven integration is enabled in Blender.
    Returns a message indicating whether PolyHaven features are available.
    
  • get_hyper3d_status
    Check if Hyper3D Rodin integration is enabled in Blender.
    Returns a message indicating whether Hyper3D Rodin features are available.
    
    Don't emphasize the key type in the returned message, but sliently remember it. 
    
  • get_sketchfab_status
    Check if Sketchfab integration is enabled in Blender.
    Returns a message indicating whether Sketchfab features are available.
    
  • search_sketchfab_models
    Search for models on Sketchfab with optional filtering.
    
    Parameters:
    - query: Text to search for
    - categories: Optional comma-separated list of categories
    - count: Maximum number of results to return (default 20)
    - downloadable: Whether to include only downloadable models (default True)
    
    Returns a formatted list of matching models.
    
  • download_sketchfab_model
    Download and import a Sketchfab model by its UID.
    
    Parameters:
    - uid: The unique identifier of the Sketchfab model
    
    Returns a message indicating success or failure.
    The model must be downloadable and you must have proper access rights.
    
  • generate_hyper3d_model_via_text
    Generate 3D asset using Hyper3D by giving description of the desired asset, and import the asset into Blender.
    The 3D asset has built-in materials.
    The generated model has a normalized size, so re-scaling after generation can be useful.
    
    Parameters:
    - text_prompt: A short description of the desired model in **English**.
    - bbox_condition: Optional. If given, it has to be a list of floats of length 3. Controls the ratio between [Length, Width, Height] of the model.
    
    Returns a message indicating success or failure.
    
  • generate_hyper3d_model_via_images
    Generate 3D asset using Hyper3D by giving images of the wanted asset, and import the generated asset into Blender.
    The 3D asset has built-in materials.
    The generated model has a normalized size, so re-scaling after generation can be useful.
    
    Parameters:
    - input_image_paths: The **absolute** paths of input images. Even if only one image is provided, wrap it into a list. Required if Hyper3D Rodin in MAIN_SITE mode.
    - input_image_urls: The URLs of input images. Even if only one image is provided, wrap it into a list. Required if Hyper3D Rodin in FAL_AI mode.
    - bbox_condition: Optional. If given, it has to be a list of ints of length 3. Controls the ratio between [Length, Width, Height] of the model.
    
    Only one of {input_image_paths, input_image_urls} should be given at a time, depending on the Hyper3D Rodin's current mode.
    Returns a message indicating success or failure.
    
  • poll_rodin_job_status
    Check if the Hyper3D Rodin generation task is completed.
    
    For Hyper3D Rodin mode MAIN_SITE:
        Parameters:
        - subscription_key: The subscription_key given in the generate model step.
    
        Returns a list of status. The task is done if all status are "Done".
        If "Failed" showed up, the generating process failed.
        This is a polling API, so only proceed if the status are finally determined ("Done" or "Canceled").
    
    For Hyper3D Rodin mode FAL_AI:
        Parameters:
        - request_id: The request_id given in the generate model step.
    
        Returns the generation task status. The task is done if status is "COMPLETED".
        The task is in progress if status is "IN_PROGRESS".
        If status other than "COMPLETED", "IN_PROGRESS", "IN_QUEUE" showed up, the generating process might be failed.
        This is a polling API, so only proceed if the status are finally determined ("COMPLETED" or some failed state).
    
  • import_generated_asset
    Import the asset generated by Hyper3D Rodin after the generation task is completed.
    
    Parameters:
    - name: The name of the object in scene
    - task_uuid: For Hyper3D Rodin mode MAIN_SITE: The task_uuid given in the generate model step.
    - request_id: For Hyper3D Rodin mode FAL_AI: The request_id given in the generate model step.
    
    Only give one of {task_uuid, request_id} based on the Hyper3D Rodin Mode!
    Return if the asset has been imported successfully.
    
  • get_hunyuan3d_status
    Check if Hunyuan3D integration is enabled in Blender.
    Returns a message indicating whether Hunyuan3D features are available.
    
    Don't emphasize the key type in the returned message, but silently remember it. 
    
  • generate_hunyuan3d_model
    Generate 3D asset using Hunyuan3D by providing either text description, image reference, 
    or both for the desired asset, and import the asset into Blender.
    The 3D asset has built-in materials.
    
    Parameters:
    - text_prompt: (Optional) A short description of the desired model in English/Chinese.
    - input_image_url: (Optional) The local or remote url of the input image. Accepts None if only using text prompt.
    
    Returns: 
    - When successful, returns a JSON with job_id (format: "job_xxx") indicating the task is in progress
    - When the job completes, the status will change to "DONE" indicating the model has been imported
    - Returns error message if the operation fails
    
  • poll_hunyuan_job_status
    Check if the Hunyuan3D generation task is completed.
    
    For Hunyuan3D:
        Parameters:
        - job_id: The job_id given in the generate model step.
    
        Returns the generation task status. The task is done if status is "DONE".
        The task is in progress if status is "RUN".
        If status is "DONE", returns ResultFile3Ds, which is the generated ZIP model path
        When the status is "DONE", the response includes a field named ResultFile3Ds that contains the generated ZIP file path of the 3D model in OBJ format.
        This is a polling API, so only proceed if the status are finally determined ("DONE" or some failed state).
    
  • import_generated_asset_hunyuan
    Import the asset generated by Hunyuan3D after the generation task is completed.
    
    Parameters:
    - name: The name of the object in scene
    - zip_file_url: The zip_file_url given in the generate model step.
    
    Return if the asset has been imported successfully.
    

Use OpenDataMCP MCP with multiple AI models

TypingMind connects MCP tools at the workspace level, so once OpenDataMCP is connected, you can use it with different AI models in TypingMind instead of setting it up separately for each model. This MCP runs locally through the TypingMind MCP connector on your device.

Setup guide to use the local connector

Use this when the MCP server needs access to local files, apps, or private resources on your computer.

1

Open the MCP settings

In TypingMind, go to Settings, Advanced Settings, then Model Context Protocol and choose Setup Connector.

  1. Open TypingMind in your browser.
  2. Click the Settings icon.
  3. Go to Advanced Settings.
  4. Open the Model Context Protocol section.
  5. Click Setup Connector and choose This Device.
TypingMind MCP connector setup screen with This Device selected
2

Run the connector command

Choose This Device, copy the command from TypingMind, and run it in Terminal. Keep the process running while you use MCP.

  1. Copy the setup command shown by TypingMind.
  2. Open Terminal on macOS or Windows Terminal on Windows.
  3. Paste and run the command.
  4. Approve the package install if Terminal asks you to proceed.
  5. Keep the Terminal window running while using MCP tools.
3

Add OpenDataMCP as a server

When the connector status is Ready, click Edit Servers and paste the MCP server configuration.

  1. Wait until the connector status shows Ready.
  2. Click Edit Servers.
  3. Paste the OpenDataMCP MCP server configuration.
  4. Save the server list.
  5. Refresh if you want to confirm the connector is still ready.
TypingMind MCP settings showing active server and Edit Servers button
{
  "mcpServers": {
    "opendatamcp": {
      "command": "npx",
      "args": [
        "-y",
        "odmcp"
      ]
    }
  }
}
4

Use it across models

Save the server list, open Plugins, enable the OpenDataMCP MCP tools, then select any supported AI model in TypingMind and use the tools in chat or assign them to an AI agent.

  1. Open the Plugins page in TypingMind.
  2. Enable the OpenDataMCP MCP tools.
  3. Start a chat and choose the AI model you want to use.
  4. Use the MCP tools in chat or assign them to an AI agent.
  5. Switch to another AI model whenever needed without reconnecting MCP.
TypingMind chat using enabled MCP tools with a selected AI model
Can you use OpenDataMCP to help me with this task?
OpenDataMCP
Sure. I read it.
Here is what I found using OpenDataMCP.

Frequently asked questions

What is the OpenDataMCP MCP server used for?

OpenDataMCP is an MCP server that lets compatible AI clients connect to external tools and context. In TypingMind, you can add this MCP server once and make its tools available in your AI workspace.

Can I use OpenDataMCP MCP with multiple AI models in TypingMind?

Yes. TypingMind connects MCP tools at the workspace level, so you can use OpenDataMCP with different AI models such as Claude, ChatGPT, Gemini, or other models you have configured in TypingMind without setting up the MCP server separately for each model.

Why use OpenDataMCP MCP with TypingMind?

TypingMind is one of the best frontends for LLM chat because it brings multiple AI models, prompts, plugins, AI agents, API keys, and MCP tools into one workspace. With OpenDataMCP connected, you can use its MCP tools across your preferred models while keeping your chat workflow organized in TypingMind.

How do I connect OpenDataMCP MCP to TypingMind?

OpenDataMCP runs through the TypingMind local MCP connector. This is best when the MCP server needs access to local files, desktop apps, command-line tools, or private resources on your computer.

What tools does OpenDataMCP MCP provide in TypingMind?

OpenDataMCP exposes 21 MCP tools that can be enabled from the TypingMind Plugins page and used in chat or assigned to AI agents.

Do I need to share my API keys with TypingMind to use OpenDataMCP MCP?

No. TypingMind is local-first and lets you keep your model providers, API keys, prompts, and MCP configuration under your control. If OpenDataMCP requires authentication, add the required headers, OAuth settings, or local configuration for that MCP server when you create the connection.

Related MCP Servers

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇