Skip to content
Back to search

mcp-redmine

A redmine MCP server covering close to 100% of redmines API

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/runekaagaard--mcp-redmine/badge.svg)](/listings/runekaagaard--mcp-redmine)

HTML

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

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

Ensure you have uv installed.

uv --version

Install uv if you haven't already.

- Linux

  curl -LsSf https://astral.sh/uv/install.sh | sh

- macOS

  brew install uv

- windows

  powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

Add to your `claude_desktop_config.json`:

  {
    "mcpServers": {
      "redmine": {
        "command": "uvx",
        "args": ["--from", "mcp-redmine==2026.09.10.084818",
                "--refresh-package", "mcp-redmine", "mcp-redmine"],
        "env": {
          "REDMINE_URL": "https://your-redmine-instance.example.com",
          "REDMINE_API_KEY": "your-api-key",
          "REDMINE_REQUEST_INSTRUCTIONS": "/path/to/instructions.md",
          "REDMINE_ALLOWED_DIRECTORIES": "/tmp,/home/user/uploads"
        }
      }
    }
  }

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 · 339 lines

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

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # MCP Redmine
  2. **Status: Maintained, in daily use.**
  3. Let Claude be your Redmine assistant! MCP Redmine connects Claude Desktop to your Redmine instance, allowing it to:
  4. - Search and browse projects and issues
  5. - Create and update issues with full markdown support
  6. - Upload and download file attachments
  7. - Manage and track time entries
  8. - Update issue statuses and fields
  9. - Access comprehensive Redmine API functionality
  10. Uses httpx for API requests and integrates with the Redmine OpenAPI specification for comprehensive API coverage.
  11. ![MCP Redmine in action](https://raw.githubusercontent.com/runekaagaard/mcp-redmine/refs/heads/main/screenshot.png)
  12. ## Usage with Claude Desktop
  13. ### 1. Installation using `uv`
  14. Ensure you have uv installed.
  15. ```bash
  16. uv --version
  17. ```
  18. Install uv if you haven't already.
  19. - Linux
  20. ```bash
  21. curl -LsSf https://astral.sh/uv/install.sh | sh
  22. ```
  23. - macOS
  24. ```zsh
  25. brew install uv
  26. ```
  27. - windows
  28. ```powershell
  29. powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
  30. ```
  31. Add to your `claude_desktop_config.json`:
  32. ```json
  33. {
  34. "mcpServers": {
  35. "redmine": {
  36. "command": "uvx",
  37. "args": ["--from", "mcp-redmine==2026.10.15.204909",
  38. "--refresh-package", "mcp-redmine", "mcp-redmine"],
  39. "env": {
  40. "REDMINE_URL": "https://your-redmine-instance.example.com",
  41. "REDMINE_API_KEY": "your-api-key",
  42. "REDMINE_REQUEST_INSTRUCTIONS": "/path/to/instructions.md",
  43. "REDMINE_ALLOWED_DIRECTORIES": "/tmp,/home/user/uploads"
  44. }
  45. }
  46. }
  47. }
  48. ```
  49. ### 2. Installation using `docker`
  50. Ensure you have docker installed.
  51. ```bash
  52. docker --version
  53. ```
  54. Pull the published image from GitHub Container Registry:
  55. ```bash
  56. docker pull ghcr.io/runekaagaard/mcp-redmine:latest
  57. ```
  58. Or build the image yourself:
  59. ```bash
  60. git clone git@github.com:runekaagaard/mcp-redmine.git
  61. cd mcp-redmine
  62. docker build -t ghcr.io/runekaagaard/mcp-redmine .
  63. ```
  64. Add to your `claude_desktop_config.json`:
  65. ```json
  66. {
  67. "mcpServers": {
  68. "redmine": {
  69. "command": "docker",
  70. "args": [
  71. "run",
  72. "-i",
  73. "--rm",
  74. "-e", "REDMINE_URL",
  75. "-e", "REDMINE_API_KEY",
  76. "-e", "REDMINE_REQUEST_INSTRUCTIONS",
  77. "-e", "REDMINE_ALLOWED_DIRECTORIES",
  78. "-v", "/path/to/instructions.md:/app/INSTRUCTIONS.md",
  79. "-v", "/path/to/uploads:/app/uploads",
  80. "ghcr.io/runekaagaard/mcp-redmine:latest"
  81. ],
  82. "env": {
  83. "REDMINE_URL": "https://your-redmine-instance.example.com",
  84. "REDMINE_API_KEY": "your-api-key",
  85. "REDMINE_REQUEST_INSTRUCTIONS": "/app/INSTRUCTIONS.md",
  86. "REDMINE_ALLOWED_DIRECTORIES": "/app/uploads"
  87. }
  88. }
  89. }
  90. }
  91. ```
  92. ### 3. Other MCP clients and transports
  93. MCP Redmine works with any MCP client (Claude Code, Cursor, IntelliJ-based IDEs, n8n, etc.) - point your
  94. client at the same command and environment variables as above, following your client's documentation for
  95. registering MCP servers.
  96. By default the server speaks stdio. For clients or setups that connect over HTTP, start the server with one
  97. of the HTTP transports:
  98. ```bash
  99. # Recommended HTTP transport (serves on http://HOST:PORT/mcp)
  100. mcp-redmine --transport streamable-http --host 0.0.0.0 --port 8000
  101. # Legacy SSE transport, for older clients (serves on http://HOST:PORT/sse)
  102. mcp-redmine --transport sse --host 0.0.0.0 --port 8000
  103. ```
  104. ### Multi-user HTTP deployments
  105. When running as a shared HTTP server, each client can send its own Redmine API key in an
  106. `X-Redmine-API-Key` request header, so actions are attributed to the calling user instead
  107. of one shared service account. The header takes precedence; `REDMINE_API_KEY` remains the
  108. fallback (and the only option on stdio). Example with Claude Code:
  109. ```bash
  110. claude mcp add --transport http --header "X-Redmine-API-Key: <your-personal-key>" \
  111. redmine http://shared-server:8000/mcp
  112. ```
  113. Only do this over trusted networks or TLS - the header carries a credential.
  114. ## Environment Variables
  115. | Variable | Required | Default | Description |
  116. |----------|----------|---------|-------------|
  117. | `REDMINE_URL` | Yes | - | URL of your Redmine instance. Subpaths are supported (e.g., `http://localhost/redmine/`) |
  118. | `REDMINE_API_KEY` | Yes* | - | Your Redmine API key (see below for how to get it). *Optional when every client sends `X-Redmine-API-Key` (see Multi-user below) |
  119. | `REDMINE_REQUEST_INSTRUCTIONS` | No | - | Path to a file containing additional instructions for the redmine_request tool. I've found it works great to have the LLM generate that file after a session. ([example1](INSTRUCTIONS_EXAMPLE1.md) [example2](INSTRUCTIONS_EXAMPLE2.md)) |
  120. | `REDMINE_HEADERS` | No | (empty) | Custom HTTP headers to include in all requests. Format: `"Header1: Value1, Header2: Value2"`. Useful for proxies that require additional authentication (e.g., `X-Redmine-Username`) |
  121. | `REDMINE_RESPONSE_FORMAT` | No | `yaml` | Response format: `yaml` or `json`. Controls how API responses are formatted |
  122. | `REDMINE_ALLOWED_DIRECTORIES` | For upload/download | (disabled) | **Required for file operations.** Comma-separated list of directories where upload/download are allowed (e.g., `/tmp,/home/user/uploads`). Upload/download are disabled if not set for security |
  123. | `REDMINE_DANGEROUSLY_ACCEPT_INVALID_CERTS` | No | (disabled) | Set to `1` to disable SSL certificate verification. Use only for self-signed certs in trusted environments |
  124. | `REDMINE_CA_BUNDLE` | No | (system CAs) | Path to a custom CA certificate bundle (e.g. `/path/to/ca.crt`) for Redmine instances using a private certificate chain. Prefer this over disabling verification |
  125. | `REDMINE_READ_ONLY` | No | (disabled) | Set to `1` to only allow GET requests. All writing operations (POST/PUT/DELETE, including uploads) are refused |
  126. > **Note**: When running via Docker, the `REDMINE_REQUEST_INSTRUCTIONS` environment variable must point to a **path inside the container**, not a path on the host machine.
  127. > Therefore, if you want to use a local file, you need to **mount it into the container** at the correct location.
  128. > **Security Note**: The `REDMINE_ALLOWED_DIRECTORIES` setting protects against path traversal attacks. Paths containing `../` are resolved before validation, ensuring files can only be accessed within the allowed directories.
  129. ## Getting Your Redmine API Key
  130. 1. Log in to your Redmine instance
  131. 2. Go to "My account" (typically found in the top-right menu)
  132. 3. On the right side of the page, you should see "API access key"
  133. 4. Click "Show" to view your existing key or "Generate" to create a new one
  134. 5. Copy this key for use in your configuration
  135. ## API
  136. ### Tools
  137. - **redmine_paths_list**
  138. - Return a list of available API paths from OpenAPI spec
  139. - No input required
  140. - Returns a YAML string containing a list of path templates:
  141. ```
  142. - /issues.json
  143. - /projects.json
  144. - /time_entries.json
  145. ...
  146. ```
  147. - **redmine_paths_info**
  148. - Get full path information for given path templates
  149. - Input: `path_templates` (list of strings)
  150. - Returns YAML string containing API specifications for the requested paths:
  151. ```yaml
  152. /issues.json:
  153. get:
  154. operationId: getIssues
  155. parameters:
  156. - $ref: '#/components/parameters/format'
  157. ...
  158. ```
  159. - **redmine_request**
  160. - Make a request to the Redmine API
  161. - Inputs:
  162. - `path` (string): API endpoint path (e.g. '/issues.json')
  163. - `method` (string, optional): HTTP method to use (default: 'get')
  164. - `data` (object, optional): Dictionary for request body (for POST/PUT)
  165. - `params` (object, optional): Dictionary for query parameters
  166. - Returns YAML string containing response status code, body and error message:
  167. ```yaml
  168. status_code: 200
  169. body:
  170. issues:
  171. - id: 1
  172. subject: "Fix login page"
  173. ...
  174. error: ""
  175. ```
  176. - **redmine_upload**
  177. - Upload a file to Redmine and get a token for attachment
  178. - **Requires `REDMINE_ALLOWED_DIRECTORIES` to be set**
  179. - Inputs:
  180. - `file_path` (string): Fully qualified path to the file to upload (must be within allowed directories)
  181. - `description` (string, optional): Optional description for the file
  182. - Returns YAML string with the same format as redmine_request, including upload token:
  183. ```yaml
  184. status_code: 201
  185. body:
  186. upload:
  187. id: 7
  188. token: "7.ed32257a2ab0f7526c0d72c32994c58b131bb2c0775f7aa84aae01ea8397ea54"
  189. error: ""
  190. ```
  191. - **redmine_attachment_image**
  192. - Fetch an image attachment (e.g. an inline screenshot referenced as `!screenshot.png!` in an issue
  193. description) and return it as viewable image content, letting the LLM actually see it
  194. - Input: `attachment_id` (integer)
  195. - Returns image content on success (max 5 MB, images only), or a YAML error string on failure
  196. - **redmine_download**
  197. - Download an attachment from Redmine and save it to a local file
  198. - **Requires `REDMINE_ALLOWED_DIRECTORIES` to be set**
  199. - Inputs:
  200. - `attachment_id` (integer): The ID of the attachment to download
  201. - `save_path` (string): Fully qualified file path (not directory) where the file should be saved (must be within allowed directories)
  202. - `filename` (string, optional): Optional filename for the Redmine download URL (determined automatically from attachment metadata if not provided)
  203. - Returns YAML string with download results:
  204. ```yaml
  205. status_code: 200
  206. body:
  207. saved_to: "/path/to/downloaded/file.pdf"
  208. filename: "file.pdf"
  209. error: ""
  210. ```
  211. ## Examples
  212. ### Creating a new issue
  213. ```
  214. Let's create a new bug report in the "Website" project:
  215. 1. Title: "Homepage not loading on mobile devices"
  216. 2. Description: "When accessing the homepage from iOS or Android devices, the loading spinner appears but the content never loads. This issue started after the last deployment."
  217. 3. Priority: High
  218. 4. Assign to: John Smith
  219. ```
  220. ### Searching for issues
  221. ```
  222. Can you find all high priority issues in the "Website" project that are currently unassigned?
  223. ```
  224. ### Updating issue status
  225. ```
  226. Please mark issue #123 as "In Progress" and add a comment: "I've started working on this issue. Expect it to be completed by Friday."
  227. ```
  228. ### Logging time
  229. ```
  230. Log 3.5 hours against issue #456 for "Implementing user authentication" done today.
  231. ```
  232. ## MCP Directory Listings
  233. MCP Redmine is listed in the following MCP directory sites and repositories:
  234. - [MCP.so](https://mcp.so/server/mcp-redmine)
  235. - [Glama](https://glama.ai/mcp/servers/@runekaagaard/mcp-redmine)
  236. ## Developing
  237. First clone the github repository and install the dependencies:
  238. ```
  239. git clone git@github.com:runekaagaard/mcp-redmine.git
  240. cd mcp-redmine
  241. uv sync
  242. ```
  243. Then set this in claude_desktop_config.json:
  244. ```
  245. ...
  246. "command": "uv",
  247. "args": ["run", "--directory", "/path/to/mcp-redmine", "-m", "mcp_redmine.server"],
  248. ...
  249. ```
  250. ## My Other LLM Projects
  251. - **[MCP Alchemy](https://github.com/runekaagaard/mcp-alchemy)** - Connect Claude Desktop to databases for exploring schema and running SQL.
  252. - **[MCP Notmuch Sendmail](https://github.com/runekaagaard/mcp-notmuch-sendmail)** - Email assistant for Claude Desktop using notmuch.
  253. - **[MCP Show-on-Kindle](https://github.com/runekaagaard/mcp-show-on-kindle)** - Copy a file to a Kindle running KOReader and open it on screen.
  254. - **[Diffpilot](https://github.com/runekaagaard/diffpilot)** - Multi-column git diff viewer with file grouping and tagging.
  255. - **[Claude Local Files](https://github.com/runekaagaard/claude-local-files)** - Access local files in Claude Desktop artifacts.
  256. ## Contributing
  257. Contributions are warmly welcomed! Whether it's bug reports, feature requests, documentation improvements, or code contributions - all input is valuable. Feel free to:
  258. - Open an issue to report bugs or suggest features
  259. - Submit pull requests with improvements
  260. - Enhance documentation or share your usage examples
  261. - Ask questions and share your experiences
  262. The goal is to make Redmine project management with Claude even better, and your insights and contributions help achieve that.
  263. ## Acknowledgments
  264. This project builds on the excellent work of others:
  265. - [httpx](https://www.python-httpx.org/) - For handling HTTP requests
  266. - [Redmine OpenAPI Specification](https://github.com/d-yoshi/redmine-openapi) - For the comprehensive API specification
  267. - [Redmine](https://www.redmine.org/) - The flexible project management web application
  268. ## License
  269. Mozilla Public License Version 2.0

Ratings and comments

Sign in to rate this skill.

Sign in

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