MCP Redmine
MCP Redmine connects an MCP client (e.g. Claude Desktop) to a Redmine instance so it can browse and modify Redmine data through the Redmine REST API.
redmine_paths_list – list all available API endpoint paths from the bundled Redmine OpenAPI spec (e.g.
/issues.json,/projects.json,/time_entries.json).redmine_paths_info – retrieve full OpenAPI specifications (methods, parameters, schemas) for one or more given path templates.
redmine_request – make arbitrary Redmine API calls (GET/POST/PUT/DELETE) with a path, optional method, body data, and query params, returning status code, body, and errors as YAML; this covers searching/browsing projects and issues, creating and updating issues with markdown, managing time entries, and updating statuses/fields.
redmine_upload – upload a local file to Redmine and get an attachment token (requires
REDMINE_ALLOWED_DIRECTORIES).redmine_download – download an attachment by ID to a local file path within allowed directories.
Supporting behavior: responses are YAML or JSON, custom headers and CA bundles are configurable, a read-only mode can block all writes, and HTTP transports with per-client X-Redmine-API-Key headers are supported for multi-user deployments.
Allows Claude to interact with a Redmine instance, including searching/browsing projects and issues, creating/updating issues with markdown support, uploading/downloading file attachments, managing time entries, updating issue statuses and fields, and accessing the Redmine API
Click on "Deploy 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., "@MCP Redmine show me open issues for project 'website redesign'"
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.
MCP Redmine
Status: Maintained, in daily use.
Let Claude be your Redmine assistant! MCP Redmine connects Claude Desktop to your Redmine instance, allowing it to:
Search and browse projects and issues
Create and update issues with full markdown support
Upload and download file attachments
Manage and track time entries
Update issue statuses and fields
Access comprehensive Redmine API functionality
Uses httpx for API requests and integrates with the Redmine OpenAPI specification for comprehensive API coverage.

Usage with Claude Desktop
1. Installation using uv
Ensure you have uv installed.
uv --versionInstall uv if you haven't already.
Linux
curl -LsSf https://astral.sh/uv/install.sh | shmacOS
brew install uvwindows
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.10.15.204909",
"--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"
}
}
}
}2. Installation using docker
Ensure you have docker installed.
docker --versionPull the published image from GitHub Container Registry:
docker pull ghcr.io/runekaagaard/mcp-redmine:latestOr build the image yourself:
git clone git@github.com:runekaagaard/mcp-redmine.git
cd mcp-redmine
docker build -t ghcr.io/runekaagaard/mcp-redmine .Add to your claude_desktop_config.json:
{
"mcpServers": {
"redmine": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"-e", "REDMINE_URL",
"-e", "REDMINE_API_KEY",
"-e", "REDMINE_REQUEST_INSTRUCTIONS",
"-e", "REDMINE_ALLOWED_DIRECTORIES",
"-v", "/path/to/instructions.md:/app/INSTRUCTIONS.md",
"-v", "/path/to/uploads:/app/uploads",
"ghcr.io/runekaagaard/mcp-redmine:latest"
],
"env": {
"REDMINE_URL": "https://your-redmine-instance.example.com",
"REDMINE_API_KEY": "your-api-key",
"REDMINE_REQUEST_INSTRUCTIONS": "/app/INSTRUCTIONS.md",
"REDMINE_ALLOWED_DIRECTORIES": "/app/uploads"
}
}
}
}3. Other MCP clients and transports
MCP Redmine works with any MCP client (Claude Code, Cursor, IntelliJ-based IDEs, n8n, etc.) - point your client at the same command and environment variables as above, following your client's documentation for registering MCP servers.
By default the server speaks stdio. For clients or setups that connect over HTTP, start the server with one of the HTTP transports:
# Recommended HTTP transport (serves on http://HOST:PORT/mcp)
mcp-redmine --transport streamable-http --host 0.0.0.0 --port 8000
# Legacy SSE transport, for older clients (serves on http://HOST:PORT/sse)
mcp-redmine --transport sse --host 0.0.0.0 --port 8000Multi-user HTTP deployments
When running as a shared HTTP server, each client can send its own Redmine API key in an
X-Redmine-API-Key request header, so actions are attributed to the calling user instead
of one shared service account. The header takes precedence; REDMINE_API_KEY remains the
fallback (and the only option on stdio). Example with Claude Code:
claude mcp add --transport http --header "X-Redmine-API-Key: <your-personal-key>" \
redmine http://shared-server:8000/mcpOnly do this over trusted networks or TLS - the header carries a credential.
Related MCP server: Redmine Enhanced MCP Server
Environment Variables
Variable | Required | Default | Description |
| Yes | - | URL of your Redmine instance. Subpaths are supported (e.g., |
| Yes* | - | Your Redmine API key (see below for how to get it). *Optional when every client sends |
| 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 example2) |
| No | (empty) | Custom HTTP headers to include in all requests. Format: |
| No |
| Response format: |
| For upload/download | (disabled) | Required for file operations. Comma-separated list of directories where upload/download are allowed (e.g., |
| No | (disabled) | Set to |
| No | (system CAs) | Path to a custom CA certificate bundle (e.g. |
| No | (disabled) | Set to |
Note: When running via Docker, the
REDMINE_REQUEST_INSTRUCTIONSenvironment variable must point to a path inside the container, not a path on the host machine. Therefore, if you want to use a local file, you need to mount it into the container at the correct location.
Security Note: The
REDMINE_ALLOWED_DIRECTORIESsetting protects against path traversal attacks. Paths containing../are resolved before validation, ensuring files can only be accessed within the allowed directories.
Getting Your Redmine API Key
Log in to your Redmine instance
Go to "My account" (typically found in the top-right menu)
On the right side of the page, you should see "API access key"
Click "Show" to view your existing key or "Generate" to create a new one
Copy this key for use in your configuration
API
Tools
redmine_paths_list
Return a list of available API paths from OpenAPI spec
No input required
Returns a YAML string containing a list of path templates:
- /issues.json - /projects.json - /time_entries.json ...redmine_paths_info
Get full path information for given path templates
Input:
path_templates(list of strings)Returns YAML string containing API specifications for the requested paths:
/issues.json: get: operationId: getIssues parameters: - $ref: '#/components/parameters/format' ...redmine_request
Make a request to the Redmine API
Inputs:
path(string): API endpoint path (e.g. '/issues.json')method(string, optional): HTTP method to use (default: 'get')data(object, optional): Dictionary for request body (for POST/PUT)params(object, optional): Dictionary for query parameters
Returns YAML string containing response status code, body and error message:
status_code: 200 body: issues: - id: 1 subject: "Fix login page" ... error: ""redmine_upload
Upload a file to Redmine and get a token for attachment
Requires
REDMINE_ALLOWED_DIRECTORIESto be setInputs:
file_path(string): Fully qualified path to the file to upload (must be within allowed directories)description(string, optional): Optional description for the file
Returns YAML string with the same format as redmine_request, including upload token:
status_code: 201 body: upload: id: 7 token: "7.ed32257a2ab0f7526c0d72c32994c58b131bb2c0775f7aa84aae01ea8397ea54" error: ""redmine_attachment_image
Fetch an image attachment (e.g. an inline screenshot referenced as
!screenshot.png!in an issue description) and return it as viewable image content, letting the LLM actually see itInput:
attachment_id(integer)Returns image content on success (max 5 MB, images only), or a YAML error string on failure
redmine_download
Download an attachment from Redmine and save it to a local file
Requires
REDMINE_ALLOWED_DIRECTORIESto be setInputs:
attachment_id(integer): The ID of the attachment to downloadsave_path(string): Fully qualified file path (not directory) where the file should be saved (must be within allowed directories)filename(string, optional): Optional filename for the Redmine download URL (determined automatically from attachment metadata if not provided)
Returns YAML string with download results:
status_code: 200 body: saved_to: "/path/to/downloaded/file.pdf" filename: "file.pdf" error: ""
Examples
Creating a new issue
Let's create a new bug report in the "Website" project:
1. Title: "Homepage not loading on mobile devices"
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."
3. Priority: High
4. Assign to: John SmithSearching for issues
Can you find all high priority issues in the "Website" project that are currently unassigned?Updating issue status
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."Logging time
Log 3.5 hours against issue #456 for "Implementing user authentication" done today.MCP Directory Listings
MCP Redmine is listed in the following MCP directory sites and repositories:
Developing
First clone the github repository and install the dependencies:
git clone git@github.com:runekaagaard/mcp-redmine.git
cd mcp-redmine
uv syncThen set this in claude_desktop_config.json:
...
"command": "uv",
"args": ["run", "--directory", "/path/to/mcp-redmine", "-m", "mcp_redmine.server"],
...My Other LLM Projects
MCP Alchemy - Connect Claude Desktop to databases for exploring schema and running SQL.
MCP Notmuch Sendmail - Email assistant for Claude Desktop using notmuch.
MCP Show-on-Kindle - Copy a file to a Kindle running KOReader and open it on screen.
Diffpilot - Multi-column git diff viewer with file grouping and tagging.
Claude Local Files - Access local files in Claude Desktop artifacts.
Contributing
Contributions are warmly welcomed! Whether it's bug reports, feature requests, documentation improvements, or code contributions - all input is valuable. Feel free to:
Open an issue to report bugs or suggest features
Submit pull requests with improvements
Enhance documentation or share your usage examples
Ask questions and share your experiences
The goal is to make Redmine project management with Claude even better, and your insights and contributions help achieve that.
Acknowledgments
This project builds on the excellent work of others:
httpx - For handling HTTP requests
Redmine OpenAPI Specification - For the comprehensive API specification
Redmine - The flexible project management web application
License
Mozilla Public License Version 2.0
Available Tools
5 toolsredmine_downloadA
Download an attachment from Redmine and save it to a local file
Args: attachment_id: The ID of the attachment to download save_path: Fully qualified file path (not directory) where the file should be saved to (must be within REDMINE_ALLOWED_DIRECTORIES) filename: Optional filename for the Redmine download URL. If not provided, will be determined from attachment metadata. Does not affect the local save path.
Returns: str: YAML string containing download status, file path, and any error messages
Inputs: save_path (required), attachment_id (required), filename. Returns: result
redmine_paths_infoB
Get full path information for given path templates
Args: path_templates: List of path templates (e.g. ['/issues.json', '/projects.json'])
Returns: str: YAML string containing API specifications for the requested paths
Inputs: path_templates (required). Returns: result
redmine_paths_listA
Return a list of available API paths from OpenAPI spec
Retrieves all endpoint paths defined in the Redmine OpenAPI specification. Remember that you can use the redmine_paths_info tool to get the full specfication for a path.
Returns: str: YAML string containing a list of path templates (e.g. '/issues.json')
Inputs: no named parameters. Returns: result
redmine_requestA
Make a request to the Redmine API
Args: path: API endpoint path (e.g. '/issues.json') method: HTTP method to use (default: 'get') data: Dictionary for request body (for POST/PUT) params: Dictionary for query parameters
Returns: str: YAML string containing response status code, body and error message
Inputs: path (required), data, method, params. Returns: result
redmine_uploadA
Upload a file to Redmine and get a token for attachment
Args: file_path: Fully qualified path to the file to upload (must be within REDMINE_ALLOWED_DIRECTORIES) description: Optional description for the file
Returns: str: YAML string containing response status code, body and error message The body contains the attachment token
Inputs: file_path (required), description. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 5 tools
The tools are clearly distinct: redmine_request is a generic API caller, while the paths_list and paths_info are dedicated to API discovery, and upload/download are for file operations. No two tools appear to serve the same purpose, minimizing agent misselection.
All tools share the 'redmine_' prefix, but the suffixes are not uniformly verb_noun (e.g., 'request' vs 'paths_list' vs 'upload'). The pattern is predominantly clear and readable, with minor inconsistency between the two path-related tools.
With 5 tools, the server falls comfortably within the ideal range. Each tool serves a specific role: a generic request handler, two API discovery helpers, and two file operations. No unnecessary duplication or bloat.
The generic redmine_request tool can access all Redmine API endpoints, making the surface functionally complete. The additional tools for path discovery and file transfer fill practical niches, leaving no obvious gaps in the server's purpose.
Maintenance
Related MCP Connectors
Manage Redbooth tasks, task lists, comments, tags and files from Claude and other AI assistants.
Read your tracked time and projects, pause tracking or add a note, from Claude or ChatGPT.
Connect to Atlassian Jira, Confluence, Loom, and more to search, create, and manage your work.
Connect Claude to your Platform7n workspaces: chat, links, work and decks. One-click OAuth.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables AI applications to interact with Redmine project management systems for issue tracking, time logging, and project management through natural language.MIT
- AlicenseAqualityDmaintenanceConnect Claude to your Redmine instance to search, browse, create and update issues, manage time entries, and upload/download attachments.51Mozilla Public 2.0
- AlicenseAqualityDmaintenanceEnables natural language interaction with Redmine via Claude Code or other MCP clients, supporting project, issue, and wiki management.111MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI clients (Cursor, Claude Desktop) to manage Redmine issues, projects, time tracking, and wiki pages through natural language.1ISC