Skip to content
Back to search

OpenDataMCP

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

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/opendatamcp--opendatamcp/badge.svg)](/listings/opendatamcp--opendatamcp)

HTML

<a href="/listings/opendatamcp--opendatamcp"><img src="/api/listings/opendatamcp--opendatamcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 260 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Open Data Model Context Protocol
  2. ![vc3598_Hyper-realistic_Swiss_landscape_pristine_SBB_red_train_p_40803c2e-43f5-410e-89aa-f6bdcb4cd089](https://github.com/user-attachments/assets/80c823dd-0b26-4d06-98f9-5c6d7c9103de)
  3. <p align="center">
  4. <em>Connect Open Data to LLMs in minutes!</em>
  5. </p>
  6. <p align="center">
  7. <a href="https://github.com/OpenDataMCP/OpenDataMCP/actions/workflows/ci.yml" target="_blank">
  8. <img src="https://github.com/OpenDataMCP/OpenDataMCP/actions/workflows/ci.yml/badge.svg" alt="CI">
  9. </a>
  10. <a href="https://pypi.org/project/odmcp" target="_blank">
  11. <img src="https://img.shields.io/pypi/v/odmcp?color=%2334D058&label=pypi%20package" alt="Package version">
  12. </a>
  13. <a href="https://github.com/OpenDataMCP/OpenDataMCP/blob/main/LICENSE" target="_blank">
  14. <img src="https://img.shields.io/github/license/OpenDataMCP/OpenDataMCP.svg" alt="License">
  15. </a>
  16. <a href="https://pepy.tech/badge/odmcp" target="_blank">
  17. <img src="https://pepy.tech/badge/odmcp?cache-control=no-cache" alt="License">
  18. </a>
  19. <a href="https://github.com/OpenDataMCP/OpenDataMCP/stargazers" target="_blank">
  20. <img src="https://img.shields.io/github/stars/OpenDataMCP/OpenDataMCP.svg?cache-control=no-cache" alt="Stars">
  21. </a>
  22. </p>
  23. ## See it in action
  24. https://github.com/user-attachments/assets/760e1a16-add6-49a1-bf71-dfbb335e893e
  25. We enable 2 things:
  26. * **Open Data Access**: Access to many public datasets right from your LLM application (starting with Claude, more to come).
  27. * **Publishing**: Get community help and a distribution network to distribute your Open Data. Get everyone to use it!
  28. How do we do that?
  29. * **Access**: Setup our MCP servers in your LLM application in 2 clicks via our CLI tool (starting with Claude, see Roadmap for next steps).
  30. * **Publish**: Use provided templates and guidelines to quickly contribute and publish on Open Data MCP. Make your data easily discoverable!
  31. ## Usage
  32. ### <u>Access</u>: Access Open Data using Open Data MCP CLI Tool
  33. #### Prerequisites
  34. If you want to use Open Data MCP with Claude Desktop app client you need to install the [Claude Desktop app](https://claude.ai/download).
  35. You will also need `uv` to easily run our CLI and MCP servers.
  36. ##### macOS
  37. ```bash
  38. # you need to install uv through homebrew as using the install shell script
  39. # will install it locally to your user which make it unavailable in the Claude Desktop app context.
  40. brew install uv
  41. ```
  42. ##### Windows
  43. ```bash
  44. # (UNTESTED)
  45. powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
  46. ```
  47. #### Open Data MCP - CLI Tool
  48. ##### Overview
  49. ```bash
  50. # show available commands
  51. uvx odmcp
  52. # show available providers
  53. uvx odmcp list
  54. # show info about a provider
  55. uvx odmcp info $PROVIDER_NAME
  56. # setup a provider's MCP server on your Claude Desktop app
  57. uvx odmcp setup $PROVIDER_NAME
  58. # remove a provider's MCP server from your Claude Desktop app
  59. uvx odmcp remove $PROVIDER_NAME
  60. ```
  61. ##### Example
  62. Quickstart for the Switzerland SBB (train company) provider:
  63. ```bash
  64. # make sure claude is installed
  65. uvx odmcp setup ch_sbb
  66. ```
  67. Restart Claude and you should see a new hammer icon at the bottom right of the chat.
  68. You can now ask questions to Claude about SBB train network disruption and it will answer based on data collected on `data.sbb.ch`.
  69. ### <u>Publish</u>: Contribute by building and publishing public datasets
  70. #### Prerequisites
  71. 1. **Install UV Package Manager**
  72. ```bash
  73. # macOS
  74. brew install uv
  75. # Windows (PowerShell)
  76. powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
  77. # Linux/WSL
  78. curl -LsSf https://astral.sh/uv/install.sh | sh
  79. ```
  80. 2. **Clone & Setup Repository**
  81. ```bash
  82. # Clone the repository
  83. git clone https://github.com/OpenDataMCP/OpenDataMCP.git
  84. cd OpenDataMCP
  85. # Create and activate virtual environment
  86. uv venv
  87. source .venv/bin/activate # Unix/macOS
  88. # or
  89. .venv\Scripts\activate # Windows
  90. # Install dependencies
  91. uv sync
  92. ```
  93. 3. **Install Pre-commit Hooks**
  94. ```bash
  95. # Install pre-commit hooks for code quality
  96. pre-commit install
  97. ```
  98. #### Publishing Instructions
  99. 1. **Create a New Provider Module**
  100. * Each data source needs its own python module.
  101. * Create a new Python module in `src/odmcp/providers/`.
  102. * Use a descriptive name following the pattern: `{country_code}_{organization}.py` (e.g., `ch_sbb.py`).
  103. * Start with our [template file](https://github.com/OpenDataMCP/OpenDataMCP/blob/main/src/odmcp/providers/__template__.py) as your base.
  104. 2. **Implement Required Components**
  105. * Define your Tools & Resources following the template structure
  106. * Each Tool or Resource should have:
  107. - Clear description of its purpose
  108. - Well-defined input/output schemas using Pydantic models
  109. - Proper error handling
  110. - Documentation strings
  111. 3. **Tool vs Resource**
  112. * Choose **Tool** implementation if your data needs:
  113. - Active querying or computation
  114. - Parameter-based filtering
  115. - Complex transformations
  116. * Choose **Resource** implementation if your data is:
  117. - Static or rarely changing
  118. - Small enough to be loaded into memory
  119. - Simple file-based content
  120. - Reference documentation or lookup tables
  121. * Reference the [MCP documentation](https://github.com/modelcontextprotocol/python-sdk?tab=readme-ov-file#primitives) for guidance
  122. 4. **Testing**
  123. * Add tests in the `tests/` directory
  124. * Follow existing test patterns (see other provider tests)
  125. * Required test coverage:
  126. - Basic functionality
  127. - Edge cases
  128. - Error handling
  129. 5. **Validation**
  130. * Test your MCP server using our experimental client: `uv run src/odmcp/providers/client.py`
  131. * Verify all endpoints respond correctly
  132. * Ensure error messages are helpful
  133. * Check performance with typical query loads
  134. For other examples, check our existing providers in the `src/odmcp/providers/` directory.
  135. ## Contributing
  136. 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.
  137. For that we need your help!
  138. ### Discord
  139. 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](https://discord.gg/hDg4ZExjGs)
  140. ### Our Core Guidelines
  141. Because of our target scale we want to keep things simple and pragmatic at first. Tackle issues with the community as they come along.
  142. 1. **Simplicity and Maintainability**
  143. * Minimize abstractions to keep codebase simple and scalable
  144. * Focus on clear, straightforward implementations
  145. * Avoid unnecessary complexity
  146. 2. **Standardization / Templates**
  147. * Follow provided templates and guidelines consistently
  148. * Maintain uniform structure across providers
  149. * Use common patterns for similar functionality
  150. 3. **Dependencies**
  151. * Keep external dependencies to a minimum
  152. * Prioritize single repository/package setup
  153. * Carefully evaluate necessity of new dependencies
  154. 4. **Code Quality**
  155. * Format code using ruff
  156. * Maintain comprehensive test coverage with pytest
  157. * Follow consistent code style
  158. 5. **Type Safety**
  159. * Use Python type hints throughout
  160. * Leverage Pydantic models for API request/response validation
  161. * Ensure type safety in data handling
  162. ### Tactical Topics (our current priorities)
  163. * [x] Initialize repository with guidelines, testing framework, and contribution workflow
  164. * [x] Implement CI/CD pipeline with automated PyPI releases
  165. * [x] Develop provider template and first reference implementation
  166. * [ ] **Integrate additional open datasets (actively seeking contributors)**
  167. * [ ] Establish clear guidelines for choosing between Resources and Tools
  168. * [ ] Develop scalable repository architecture for long-term growth
  169. * [ ] Expand MCP SDK parameter support (authentication, rate limiting, etc.)
  170. * [ ] Implement additional MCP protocol features (prompts, resource templates)
  171. * [ ] Add support for alternative transport protocols beyond stdio (SSE)
  172. * [ ] Deploy hosted MCP servers for improved accessibility
  173. ## Roadmap
  174. Let’s build the open source infrastructure that will allow all LLMs to access all Open Data together!
  175. ### Access:
  176. * Make Open Data available to all LLM applications (beyond Claude)
  177. * Make Open Data data sources searchable in a scalable way
  178. * Make Open Data available through MCP remotely (SSE) with publicly sponsored infrastructure
  179. ### Publish:
  180. * Build the many Open Data MCP servers to make all the Open Data truly accessible (we need you!).
  181. * On our side we are starting to build MCP servers for Switzerland ~12k open dataset!
  182. * Make it even easier to build Open Data MCP servers
  183. 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!
  184. As Anthropic's MCP evolves we will adapt and upgrade Open Data MCP.
  185. ## Limitations
  186. * All data served by Open Data MCP servers should be Open.
  187. * Please oblige to the data licenses of the data providers.
  188. * Our License must be quoted in commercial applications.
  189. ## References
  190. * Kudos to [Anthropic's open source MCP](https://spec.modelcontextprotocol.io/) release enabling initiative like this one.
  191. ## License
  192. This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.