io.github.jztan/redmine-mcp-server MCP Server

Redmine MCP Server

A Model Context Protocol (MCP) server that connects AI assistants to Redmine. It exposes your Redmine instance's projects, issues, time tracking, wiki pages, and files as MCP tools.

mcp-name: io.github.jztan/redmine-mcp-server

<p align="center"> <a href="https://redmine-mcp-server.jztan.com"> <img src="https://raw.githubusercontent.com/jztan/redmine-mcp-server/develop/assets/redmine-mcp-demo.gif" alt="An AI agent triaging a Redmine sprint backlog through redmine-mcp-server" width="820" /> </a> </p> <p align="center">_{An AI agent triaging a Redmine sprint through redmine-mcp-server. <a href="https://redmine-mcp-server.jztan.com">Try the live demo →</a>}</p>

Tool reference | Changelog | Contributing | Troubleshooting

Features

• 51 MCP Tools (plus 1 operator tool gated by REDMINE_MCP_EXPOSE_ADMIN_TOOLS=true): Issues, projects, time tracking, wiki, Gantt, file operations, membership management, products, contacts (CRM), DMSF documents, and more
• Interactive Kanban Board: show_triage_board renders a live, drag-and-drop issue board right in the chat via the MCP Apps extension
• Flexible Authentication: API key, username/password, or OAuth2 per-user tokens
• Prompt Injection Protection: User-controlled content wrapped in boundary tags for safe LLM consumption
• Read-Only Mode: Restrict to read-only operations via REDMINE_MCP_READ_ONLY environment variable
• HTTP File Serving: Secure attachment access via UUID-based URLs with automatic expiry
• Pagination Support: Handle large result sets with configurable limits
• MCP Compliant: Built on FastMCP with HTTP transport
• Docker Ready: Dockerfile, docker-compose setup, and prebuilt images on GHCR

Quick Start

1. Install the package

   pip install redmine-mcp-server
   

2. Create a .env file with your Redmine credentials (see Installation for template)
3. Start the server

   redmine-mcp-server
   

4. Add the server to your MCP client using one of the guides in MCP Client Configuration.

Once running, the server listens on http://localhost:8000 with the MCP endpoint at /mcp, health check at /health, and file serving at /files/{file_id}.

Installation

Prerequisites

• Python 3.10+ (for local installation)
• Docker (alternative deployment, uses Python 3.13)
• Access to a Redmine instance

Redmine Compatibility

The integration suite passes in full against Redmine 6.1 and 7.0. Older versions are untested. Individual tools list their own minimum where one is known (global search needs 3.3.0+, issue watchers 2.3.0+, project time-entry activities 3.4.0+), so on an older server those specific tools fail rather than the whole server.

OAuth2 is the one hard requirement: it needs Redmine 6.1+ for Doorkeeper support. See docs/oauth-setup.md.

Install from PyPI (Recommended)

# Install the package
pip install redmine-mcp-server

# Create configuration file .env
cat > .env << 'EOF'
# Redmine connection (required)
REDMINE_URL=https://your-redmine-server.com

# Authentication - Use either API key (recommended) or username/password
REDMINE_API_KEY=your_api_key
# OR use username/password:
# REDMINE_USERNAME=your_username
# REDMINE_PASSWORD=your_password

# Server configuration (optional, defaults shown)
SERVER_HOST=0.0.0.0
SERVER_PORT=8000

# Public URL for file serving (optional)
PUBLIC_HOST=localhost
PUBLIC_PORT=8000

# File management (optional)
ATTACHMENTS_DIR=./attachments
AUTO_CLEANUP_ENABLED=true
CLEANUP_INTERVAL_MINUTES=10
ATTACHMENT_EXPIRES_MINUTES=60
EOF

# Edit .env with your actual Redmine settings
nano .env  # or use your preferred editor

# Run the server
redmine-mcp-server
# Or alternatively:
python -m redmine_mcp_server.main

The server runs on http://localhost:8000 with the MCP endpoint at /mcp, health check at /health, and file serving at /files/{file_id}.

Environment Variables Configuration

<details> <summary><strong>Environment Variables</strong></summary>

Variable	Required	Default	Description
REDMINE_URL	Yes	–	Base URL of your Redmine instance
REDMINE_AUTH_MODE	No	legacy	Authentication mode: legacy, legacy-per-user, oauth, or oauth-proxy (see Authentication)
REDMINE_PER_USER_TRUST_PROXY	Yes*	false	Required for legacy-per-user mode. Operator attestation: "this server sits behind TLS and my proxy does not forward client X-Forwarded-Proto."
REDMINE_PER_USER_AUDIT_IDENTITY	No	false	legacy-per-user only: resolve and log the Redmine user ID per request (adds one extra round-trip)
REDMINE_API_KEY	Yes†	–	API key (legacy mode only)
REDMINE_USERNAME	Yes†	–	Username for basic auth (legacy mode only)
REDMINE_PASSWORD	Yes†	–	Password for basic auth (legacy mode only)
REDMINE_MCP_BASE_URL	Yes‡	http://localhost:3040	Public base URL of this server, no trailing slash (OAuth modes only)
FASTMCP_STREAMABLE_HTTP_PATH	No	/mcp	MCP transport path inside REDMINE_MCP_BASE_URL
REDMINE_INTROSPECT_CLIENT_ID	Yes‡	–	Doorkeeper OAuth client ID used by the MCP server to introspect Bearer tokens (RFC 7662). Register a confidential OAuth app in Redmine (see docs/oauth-setup.md Step 2).
REDMINE_INTROSPECT_CLIENT_SECRET	Yes‡	–	Secret for the introspection client
REDMINE_MCP_JWT_SIGNING_KEY	Yes§	–	Stable signing/encryption key used by FastMCP OAuthProxy tokens and storage
REDMINE_OAUTH_CLIENT_ID	No	–	Optional upstream Redmine OAuth client ID for oauth-proxy; defaults to REDMINE_INTROSPECT_CLIENT_ID
REDMINE_OAUTH_CLIENT_SECRET	No	–	Optional upstream Redmine OAuth client secret for oauth-proxy; defaults to REDMINE_INTROSPECT_CLIENT_SECRET
FASTMCP_HOME	No	platform default	FastMCP data directory. In oauth-proxy mode, encrypted OAuthProxy state is stored below FASTMCP_HOME/oauth-proxy/
REDMINE_MCP_ALLOWED_CLIENT_REDIRECT_URIS	No	loopback only	oauth-proxy client redirect-URI allowlist (glob patterns, comma/space separated). Unset = http://localhost:* and http://127.0.0.1:*; * = allow any
HEALTH_INTROSPECTION_TTL_SECONDS	No	30	TTL (seconds) for the /health Doorkeeper introspection probe cache. Set to 0 to disable caching.
SERVER_HOST	No	0.0.0.0	Host/IP the MCP server binds to
SERVER_PORT	No	8000	Port the MCP server listens on
PUBLIC_HOST	No	localhost	Hostname used when generating download URLs
PUBLIC_PORT	No	8000	Public port used for download URLs
REDMINE_PUBLIC_URL	No	–	Publicly-reachable URL of your Redmine instance. When set, content_url values returned on attachments are rewritten from REDMINE_URL's origin to this one (preserving path/query/fragment and any reverse-proxy subpath). Useful when REDMINE_URL is the internal container hostname unreachable from MCP clients. When unset, the raw URL Redmine echoes back is returned.
ATTACHMENTS_DIR	No	./attachments	Directory for downloaded attachments
ATTACHMENT_MAX_DOWNLOAD_BYTES	No	209715200 (200 MB)	Cap applied to every get_redmine_attachment download regardless of content type. Exceeding the cap aborts the download mid-stream and deletes the partial file.
REDMINE_MCP_UPLOAD_FILE_ROOTS	No	–	Extra directories allowed as file_path upload sources (OS path separator-separated). ATTACHMENTS_DIR is always allowed. Unset restricts uploads to ATTACHMENTS_DIR only.
AUTO_CLEANUP_ENABLED	No	true	Toggle automatic cleanup of expired attachments
CLEANUP_INTERVAL_MINUTES	No	10	Interval for cleanup task
ATTACHMENT_EXPIRES_MINUTES	No	60	Expiry window for generated download URLs
REDMINE_MCP_EXPOSE_ADMIN_TOOLS	No	false	Expose operator/admin tools on the MCP surface. Currently gates cleanup_attachment_files. The background cleanup task runs regardless of this flag.
REDMINE_SSL_VERIFY	No	true	Enable/disable SSL certificate verification
REDMINE_SSL_CERT	No	–	Path to custom CA certificate file
REDMINE_SSL_CLIENT_CERT	No	–	Path to client certificate for mutual TLS
REDMINE_TIMEOUT	No	30	Whole seconds to wait for a Redmine HTTP response before failing the call. Applied as a connect timeout of at most 10s plus a read timeout of the full value. Set to 0 to wait indefinitely, which restores the previous behavior and can hang the request.
REDMINE_MCP_READ_ONLY	No	false	Block all write operations (create/update/delete) when set to true
REDMINE_OAUTH_SCOPE_ENFORCEMENT	No	on	OAuth modes only: deny tool calls whose access token lacks the tool's Redmine permission scopes, and filter tools/list accordingly. Set to off temporarily while re-consenting older tokens (details)
REDMINE_OAUTH_DISCOVERY_AS	No	redmine	OAuth modes only: which authorization server discovery advertises. redmine names your Redmine; self advertises this server (issuer = REDMINE_MCP_BASE_URL) and serves RFC 8414 metadata at its own canonical well-known location, which clients that probe there need, Cursor among them (details)
REDMINE_MCP_SCOPES	No	–	OAuth modes only: advertise a subset of scopes in discovery, matching the permissions your Redmine OAuth Application actually enables. Avoids invalid_scope at consent when a client requests the full advertised list
REDMINE_AGILE_ENABLED	No	false	Enable RedmineUP Agile plugin support: get_redmine_issue returns story_points, agile_sprint_id, agile_position; update_redmine_issue accepts story_points
REDMINE_CHECKLISTS_ENABLED	No	false	Enable RedmineUP Checklists plugin support: get_checklist, create_checklist_item, update_checklist_item (requires Checklists Pro plugin)
REDMINE_PRODUCTS_ENABLED	No	false	Enable RedmineUP Products plugin support: manage_product (action=list/get/create/update)
REDMINE_CRM_ENABLED	No	false	Enable RedmineUP CRM plugin support: manage_contact (action=list/get/create/update/delete/assign_to_project/remove_from_project)
REDMINE_DMSF_ENABLED	No	false	Enable DMSF document-management plugin support: manage_document (action=list/get/create/update). Requires redmine_dmsf plugin on the Redmine server.
REDMINE_TAGS_ENABLED	No	false	Enable AlphaNodes additional_tags plugin support: get_redmine_issue returns a tags array, and create_redmine_issue/update_redmine_issue accept a tag_list. Requires the additional_tags plugin and the view_issue_tags / create_issue_tags / edit_issue_tags permissions on the Redmine server.
REDMINE_AUTOFILL_REQUIRED_CUSTOM_FIELDS	No	false	Enable one retry for issue creation by filling missing required custom fields
REDMINE_REQUIRED_CUSTOM_FIELD_DEFAULTS	No	{}	JSON object mapping required custom field names to fallback values used when creating issues
REDMINE_ALLOW_PRIVATE_FETCH_URLS	No	false	Warning: disables all SSRF protection for attachment fetching. Never set to true in production.

* Required when REDMINE_AUTH_MODE=legacy-per-user. † Required when REDMINE_AUTH_MODE=legacy. Either REDMINE_API_KEY or REDMINE_USERNAME+REDMINE_PASSWORD must be set. API key is recommended. ‡ Required when REDMINE_AUTH_MODE=oauth or REDMINE_AUTH_MODE=oauth-proxy. § Required when REDMINE_AUTH_MODE=oauth-proxy. Secret values can also be supplied with Docker/Kubernetes-style file variables: REDMINE_INTROSPECT_CLIENT_SECRET_FILE, REDMINE_MCP_JWT_SIGNING_KEY_FILE, and REDMINE_OAUTH_CLIENT_SECRET_FILE.

When REDMINE_AUTOFILL_REQUIRED_CUSTOM_FIELDS=true, create_redmine_issue retries once on relevant custom-field validation errors (for example <Field Name> cannot be blank or <Field Name> is not included in the list) and fills values only from:

• the Redmine custom field default_value, or
• REDMINE_REQUIRED_CUSTOM_FIELD_DEFAULTS

Example:

REDMINE_AUTOFILL_REQUIRED_CUSTOM_FIELDS=true
REDMINE_REQUIRED_CUSTOM_FIELD_DEFAULTS='{"Required Field A":"Value A","Required Field B":"Value B"}'

</details>

SSL Certificate Configuration

Configure SSL certificate handling for Redmine servers with self-signed certificates or internal CA infrastructure.

<details> <summary><strong>Self-Signed Certificates</strong></summary>

If your Redmine server uses a self-signed certificate or internal CA:

# In .env file
REDMINE_URL=https://redmine.company.com
REDMINE_API_KEY=your_api_key
REDMINE_SSL_CERT=/path/to/ca-certificate.crt

Supported certificate formats: .pem, .crt, .cer

</details> <details> <summary><strong>Mutual TLS (Client Certificates)</strong></summary>

For environments requiring client certificate authentication:

# In .env file
REDMINE_URL=https://secure.redmine.com
REDMINE_API_KEY=your_api_key
REDMINE_SSL_CERT=/path/to/ca-bundle.pem
REDMINE_SSL_CLIENT_CERT=/path/to/cert.pem,/path/to/key.pem

Note: Private keys must be unencrypted (Python requests library requirement).

</details> <details> <summary><strong>Disable SSL Verification (Development Only)</strong></summary>

⚠️ WARNING: Only use in development/testing environments!

# In .env file
REDMINE_SSL_VERIFY=false

Disabling SSL verification makes your connection vulnerable to man-in-the-middle attacks.

</details>

For SSL troubleshooting, see the Troubleshooting Guide.

Authentication

The server supports four authentication modes, selected via REDMINE_AUTH_MODE. It defaults to legacy, so existing deployments keep working with no changes; OAuth2 support is purely additive.

Your situation	Mode	Redmine
Single shared credential, simplest setup	legacy (default)	any
Multi-user, you control the MCP client	oauth	6.1+
Hosted server, clients self-register (DCR)	oauth-proxy	6.1+
Multi-user, Redmine too old for OAuth	legacy-per-user	< 6.1

The advanced modes are collapsed below. For full setup, the OAuth2 Setup Guide covers oauth and oauth-proxy, and the legacy-per-user guide covers legacy-per-user.

Legacy mode (default)

A single shared credential (API key or username/password) configured once in .env. Every request to Redmine uses the same identity.

REDMINE_AUTH_MODE=legacy        # or omit entirely; this is the default
REDMINE_URL=https://redmine.example.com
REDMINE_API_KEY=your_api_key
# OR:
# REDMINE_USERNAME=your_username
# REDMINE_PASSWORD=your_password

<details> <summary><strong>OAuth2 mode</strong> (multi-user, Redmine 6.1+)</summary>

Each MCP request carries its own Authorization: Bearer <token>, so every user authenticates with their own Redmine account. The server validates each token against Doorkeeper's introspection endpoint before forwarding it, and exposes the OAuth2 discovery and /revoke endpoints clients need.

REDMINE_AUTH_MODE=oauth
REDMINE_URL=https://redmine.example.com
REDMINE_MCP_BASE_URL=https://redmine-mcp.example.com   # public URL of this server

# Confidential OAuth app registered in Redmine admin (see setup guide)
REDMINE_INTROSPECT_CLIENT_ID=...
REDMINE_INTROSPECT_CLIENT_SECRET=...

You register the OAuth app manually in Redmine admin → Applications (no Dynamic Client Registration). Full walkthrough, endpoint reference, and troubleshooting: OAuth2 Setup Guide.

</details> <details> <summary><strong>OAuthProxy mode</strong> (hosted deployments with client self-registration)</summary>

FastMCP acts as the MCP-facing authorization server: it handles DCR for MCP clients, then redirects users to Redmine as the upstream OAuth provider for consent. Use this when clients (e.g. Claude Desktop, VS Code) expect to register themselves.

REDMINE_AUTH_MODE=oauth-proxy
REDMINE_URL=https://redmine.example.com
REDMINE_MCP_BASE_URL=https://redmine-mcp.example.com   # public URL of this server

# Confidential OAuth app registered in Redmine admin (see setup guide)
REDMINE_INTROSPECT_CLIENT_ID=...
REDMINE_INTROSPECT_CLIENT_SECRET=...
REDMINE_MCP_JWT_SIGNING_KEY=...

The upstream Redmine app must register ${REDMINE_MCP_BASE_URL}/auth/callback as its redirect URI. Storage, scaling, and credential-reuse notes are in the OAuth2 Setup Guide.

</details> <details> <summary><strong>legacy-per-user mode</strong> (Redmine older than 6.1)</summary>

For Redmine instances too old for OAuth, each user's MCP client sends its own Redmine API key in an X-Redmine-API-Key header. Each request runs as that user's identity with that user's permissions.

This is an advanced, opt-in mode. It requires TLS end-to-end and a correctly configured reverse proxy. Read docs/legacy-per-user-auth.md for the threat model, firewall guidance, and revocation runbook before enabling it.

mcp-remote (recommended):

{ "mcpServers": { "redmine": {
  "command": "npx",
  "args": ["mcp-remote", "https://your-host/mcp",
           "--header", "X-Redmine-API-Key:${RM_KEY}"],
  "env": { "RM_KEY": "<your redmine api key>" }
}}}

Note the colon with no surrounding spaces in X-Redmine-API-Key:${RM_KEY}. This avoids an arg-escaping bug in Cursor and Claude Desktop on Windows.

VS Code (mcp.json):

Use .vscode/mcp.json (workspace file) or the user profile mcp.json. The workspace .mcp.json silently drops headers (see microsoft/vscode#319528), so do not use that file. Pin VS Code 1.102 or newer.

{
  "servers": {
    "redmine": {
      "type": "http",
      "url": "https://your-host/mcp",
      "headers": { "X-Redmine-API-Key": "${input:rmKey}" },
      "inputs": [{ "id": "rmKey", "type": "promptString",
                   "description": "Redmine API key", "password": true }]
    }
  }
}

Unsupported: any client that cannot set a custom request header, or that reserves the Authorization header for its own OAuth flow.

</details>

MCP Client Configuration

The server exposes an HTTP endpoint at http://127.0.0.1:8000/mcp. Register it with your preferred MCP-compatible agent using the instructions below.

The examples below assume legacy or oauth mode. In legacy-per-user mode each client must also send an X-Redmine-API-Key header; see legacy-per-user mode above for header-aware configs.

<details> <summary><strong>Visual Studio Code (Native MCP Support)</strong></summary>

VS Code has built-in MCP support via GitHub Copilot (requires VS Code 1.102+).

Using CLI (Quickest):

code --add-mcp '{"name":"redmine","type":"http","url":"http://127.0.0.1:8000/mcp"}'

Using Command Palette:

1. Open Command Palette (Cmd/Ctrl+Shift+P)
2. Run MCP: Open User Configuration (for global) or MCP: Open Workspace Folder Configuration (for project-specific)
3. Add the configuration:

   {
     "servers": {
       "redmine": {
         "type": "http",
         "url": "http://127.0.0.1:8000/mcp"
       }
     }
   }
   

4. Save the file. VS Code will automatically load the MCP server.

Manual Configuration: Create .vscode/mcp.json in your workspace (or mcp.json in your user profile directory):

{
  "servers": {
    "redmine": {
      "type": "http",
      "url": "http://127.0.0.1:8000/mcp"
    }
  }
}

</details> <details> <summary><strong>Claude Code</strong></summary>

Add to Claude Code using the CLI command:

claude mcp add --transport http redmine http://127.0.0.1:8000/mcp

Or configure manually in your Claude Code settings file (~/.claude.json):

{
  "mcpServers": {
    "redmine": {
      "type": "http",
      "url": "http://127.0.0.1:8000/mcp"
    }
  }
}

</details> <details> <summary><strong>Claude Desktop (macOS & Windows)</strong></summary>

Claude Desktop's config file supports stdio transport only. Use FastMCP's proxy via uv to bridge to this HTTP server.

Setup:

1. Open Claude Desktop
2. Click the Claude menu (macOS menu bar / Windows title bar) > Settings...
3. Click the Developer tab > Edit Config
4. Add the following configuration:

{
  "mcpServers": {
    "redmine": {
      "command": "uv",
      "args": [
        "run",
        "--with", "fastmcp",
        "fastmcp",
        "run",
        "http://127.0.0.1:8000/mcp"
      ]
    }
  }
}

5. Save the file, then fully quit and restart Claude Desktop
6. Look for the tools icon in the input area to verify the connection

Config file locations:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Note: The Redmine MCP server must be running before starting Claude Desktop.

</details> <details> <summary><strong>Cursor</strong></summary>

Cursor talks to HTTP MCP servers directly, with no bridge.

1. Create ~/.cursor/mcp.json (available in every project) or .cursor/mcp.json in your project root (that project only):

   {
     "mcpServers": {
       "redmine": {
         "url": "http://127.0.0.1:8000/mcp"
       }
     }
   }
   

2. Save the file. Cursor picks the server up automatically; its MCP settings list the server and the tools it loaded.

Note: Cursor identifies a remote server by a bare url and has no type field, unlike the VS Code and Claude Code configs above.

In legacy-per-user mode, add the API key header:

{
  "mcpServers": {
    "redmine": {
      "url": "https://your-host/mcp",
      "headers": { "X-Redmine-API-Key": "<your redmine api key>" }
    }
  }
}

In oauth mode, set REDMINE_OAUTH_DISCOVERY_AS=self on the MCP server. Cursor looks for authorization server metadata at its own canonical well-known location, which the default (redmine) discovery profile does not serve, so the flow stalls without it (#188). See Cursor and self-AS discovery.

</details> <details> <summary><strong>Codex CLI</strong></summary>

Add to Codex CLI using the command:

codex mcp add redmine -- npx -y mcp-client-http http://127.0.0.1:8000/mcp

Or configure manually in ~/.codex/config.toml:

[mcp_servers.redmine]
command = "npx"
args = ["-y", "mcp-client-http", "http://127.0.0.1:8000/mcp"]

Note: Codex CLI primarily supports stdio-based MCP servers. The above uses mcp-client-http as a bridge for HTTP transport.

</details> <details> <summary><strong>Kiro</strong></summary>

Kiro primarily supports stdio-based MCP servers. For HTTP servers, use an HTTP-to-stdio bridge:

1. Create or edit .kiro/settings/mcp.json in your workspace:

   {
     "mcpServers": {
       "redmine": {
         "command": "npx",
         "args": [
           "-y",
           "mcp-client-http",
           "http://127.0.0.1:8000/mcp"
         ],
         "disabled": false
       }
     }
   }
   

2. Save the file and restart Kiro. The Redmine tools will appear in the MCP panel.

Note: Direct HTTP transport support in Kiro is limited. The above configuration uses mcp-client-http as a bridge to connect to HTTP MCP servers.

</details> <details> <summary><strong>Generic MCP Clients</strong></summary>

Most MCP clients use a standard configuration format. For HTTP servers:

{
  "mcpServers": {
    "redmine": {
      "type": "http",
      "url": "http://127.0.0.1:8000/mcp"
    }
  }
}

For clients that require a command-based approach with HTTP bridge:

{
  "mcpServers": {
    "redmine": {
      "command": "npx",
      "args": ["-y", "mcp-client-http", "http://127.0.0.1:8000/mcp"]
    }
  }
}

</details>

Testing Your Setup

# Test connection by checking health endpoint
curl http://localhost:8000/health

Supported Redmine Plugins

The server works against a stock Redmine instance. Six optional plugins add more. To use one, install it on your Redmine server and set the matching env var. Skipping a plugin costs you only that plugin's features.

Plugin	Vendor	Env var	What it adds
Agile	RedmineUP	REDMINE_AGILE_ENABLED	get_redmine_issue returns story_points, agile_sprint_id, agile_position; update_redmine_issue accepts story_points
Checklists	RedmineUP (Pro)	REDMINE_CHECKLISTS_ENABLED	3 tools: get_checklist, create_checklist_item, update_checklist_item
Products	RedmineUP	REDMINE_PRODUCTS_ENABLED	1 tool: manage_product
CRM	RedmineUP	REDMINE_CRM_ENABLED	1 tool: manage_contact
DMSF	danmunn (open source)	REDMINE_DMSF_ENABLED	1 tool: manage_document
Additional Tags	AlphaNodes (open source)	REDMINE_TAGS_ENABLED	get_redmine_issue returns a tags array; create_redmine_issue / update_redmine_issue accept tag_list

Agile and Additional Tags add fields to tools you already have, so they register no new tools. The other four bring their own, which appear in tools/list either way but return a feature-disabled error until you set the flag. Tags also needs the view_issue_tags, create_issue_tags, and edit_issue_tags permissions on the Redmine server.

Available Tools

This MCP server provides 51 tools for interacting with Redmine (plus 1 operator tool exposed by REDMINE_MCP_EXPOSE_ADMIN_TOOLS=true, for a maximum of 52). 6 of the 51 are plugin-gated and activate via env vars. For full documentation of every tool, see the Tool Reference.

Core tools (45, always available): Project Management (9), Issue Operations (13), Time Tracking (4), Discovery / Enumeration (7), Search & Wiki (2), File Operations (4), Gantt (1), Interactive Apps (4), Meta (1).

Plugin-gated tools (6, opt in via env var): Checklists (3), Products (1), Contacts / CRM (1), Documents / DMSF (1). Each requires the matching Redmine plugin installed and its env flag set; they appear in tools/list either way but return a feature-disabled error until enabled.

Operator tools (1, admin-gated): cleanup_attachment_files, registered only when REDMINE_MCP_EXPOSE_ADMIN_TOOLS=true.

<details> <summary><strong>Full tool list with descriptions</strong></summary>

Core tools (45, always available)

These tools require only a Redmine instance and credentials, with no extra plugins or feature flags.

• Project Management (9 tools)

  • list_redmine_projects - List all accessible projects
  • list_project_issue_custom_fields - List issue custom fields configured for a project
  • list_redmine_versions - List versions/milestones for a project
  • manage_redmine_version - Create, update, or delete a version/milestone
  • list_project_members - List members and roles of a project
  • summarize_project_status - Get comprehensive project status summary
  • list_redmine_roles - List all roles defined in the Redmine instance (for discovering valid role_ids)
  • get_project_modules - Retrieve the enabled modules for a project
  • manage_project_member - Add, update, or remove a project membership

• Issue Operations (13 tools)

  • get_redmine_issue - Retrieve detailed issue information (supports journal pagination, watchers, relations, children)
  • list_redmine_issues - List issues with flexible filtering (project, status, assignee, etc.)
  • search_redmine_issues - Search issues by text query
  • create_redmine_issue - Create new issues, with optional file attachments via the uploads parameter
  • update_redmine_issue - Update existing issues, with optional file attachments via the uploads parameter (combine with notes to attach files to a journal note)
  • delete_redmine_issue - Hard-delete an issue with required confirmation flags and a cascade-impact preview before irreversible deletion.
  • copy_issue - Duplicate an existing issue with optional field overrides
  • list_subtasks - List subtasks (child issues) of a given parent
  • get_private_notes - Retrieve private notes on an issue
  • manage_issue_relation - List, create, or delete issue relations
  • manage_issue_watcher - Add or remove a watcher on an issue
  • manage_issue_note - Edit a journal note's text or toggle its privacy
  • manage_issue_category - List, create, update, or delete issue categories
  • Note: get_redmine_issue can include custom_fields and update_redmine_issue can update custom fields by name (for example {"size": "S"}).

• Time Tracking (4 tools)

  • list_time_entries - List time entries with filtering by project, issue, user, and date range
  • manage_time_entry - Create or update a time entry (use user_id to log on behalf of another user)
  • list_time_entry_activities - Discover available activity types for time entries
  • import_time_entries - Bulk import time entries via sequential API calls with per-entry error reporting

• Discovery / Enumeration (7 tools): help LLMs find valid IDs before calling create/update tools

  • list_redmine_trackers - List all trackers (Bug, Feature, Support, etc.)
  • list_project_trackers - List the trackers enabled for a specific project
  • list_redmine_issue_statuses - List all issue statuses with their is_closed flag
  • list_redmine_issue_priorities - List all priority levels
  • list_redmine_users - Filter/list users (admin-only; supports name and group filters)
  • get_current_user - Get the authenticated user's profile (works for non-admins)
  • list_redmine_queries - List saved custom queries (read-only)

• Search & Wiki (2 tools)

  • search_entire_redmine - Global search across issues and wiki pages (Redmine 3.3.0+)
  • manage_redmine_wiki_page - List, get, create, update, delete, or rename wiki pages

• File Operations (4 tools)

  • list_files - List files uploaded to a project's Files section
  • upload_file - Upload a new file to a project (from base64 content, a URL, or a server-side file_path), optionally tied to a version
  • delete_file - Delete a file from a project
  • get_redmine_attachment - Download an attachment (works in both HTTP and stdio mode)

• Gantt (1 tool)

  • get_gantt_chart - Retrieve project timeline data: issues with dates, dependencies, and milestones

• Interactive Apps (4 tools): render live UI in the chat via the MCP Apps extension (requires a client that supports it)

  • show_triage_board - Render a project's issues as an interactive Kanban board grouped by status, with drag-to-change-status write-back
  • get_triage_board_data - Board data source backing the board's Refresh action
  • show_project_dashboard - Render a live project snapshot (open/closed, overdue, due this week, open-by-priority, recent activity) as an interactive dashboard, with click-through drill-ins to matching issue lists
  • get_project_dashboard_data - App-only data source backing the dashboard's Refresh action

• Meta (1 tool)

  • get_mcp_server_info - Report server version, auth mode, read-only state, the authenticated user (current_user), and which plugin-gated tool families are enabled. Use to detect deployment lag before relying on a recently-shipped fix, or to confirm who assigned_to_id="me" resolves to.

Plugin-gated tools (6, opt in via env var)

These tools require a corresponding Redmine plugin installed on the server and the matching environment variable set to true on the MCP server. They appear in tools/list either way, but return a feature-disabled error until their flag is set.

• Checklists (3 tools): set REDMINE_CHECKLISTS_ENABLED=true; requires the RedmineUP Checklists Pro plugin

  • get_checklist - Retrieve all checklist items for an issue
  • create_checklist_item - Add a new checklist item to an issue
  • update_checklist_item - Update a checklist item's text, done state, or position

• Products (1 tool): set REDMINE_PRODUCTS_ENABLED=true; requires the RedmineUP Products plugin

  • manage_product - List, get, create, or update products

• Contacts (CRM) (1 tool): set REDMINE_CRM_ENABLED=true; requires the RedmineUP CRM plugin

  • manage_contact - List, get, create, update, delete, or assign/remove project association for contacts

• Documents (DMSF) (1 tool): set REDMINE_DMSF_ENABLED=true; requires the redmine_dmsf plugin

  • manage_document - List, get, create (upload), or update (new revision) DMSF documents

Operator tools (1, admin-gated)

Hidden from tools/list by default. Set REDMINE_MCP_EXPOSE_ADMIN_TOOLS=true to register them on the MCP surface. The underlying background tasks run regardless of this flag; exposing them only adds the option to drive them through MCP.

• cleanup_attachment_files - Manually trigger cleanup of expired attachment files (the background cleanup task runs automatically regardless)

</details>

Docker Deployment

Quick Start with Docker

# Configure environment
cp .env.docker.example .env.docker
# Edit .env.docker with your Redmine settings

# Run with docker-compose
docker-compose up --build

# Or run directly
docker build -t redmine-mcp-server .
docker run -p 8000:8000 --env-file .env.docker redmine-mcp-server

Use the Published Image

Prebuilt multi-architecture images (linux/amd64, linux/arm64) are published to the GitHub Container Registry on each release, so you can run the server without building it yourself:

docker pull ghcr.io/jztan/redmine-mcp-server:latest
docker run -p 8000:8000 --env-file .env.docker ghcr.io/jztan/redmine-mcp-server:latest

Pin to an exact version (e.g. ghcr.io/jztan/redmine-mcp-server:2.2.0) or track a minor series (e.g. :2.2). Published images are available starting from the next release.

Production Deployment

Use the automated deployment script:

chmod +x deploy.sh
./deploy.sh

Troubleshooting

If you run into any issues, checkout our troubleshooting guide.

Roadmap

See the roadmap for planned features and future development.

Contributing

Contributions are welcome! Please see our contributing guide for details.

Contributors

Thank you to everyone who has helped improve this project through code, reviews, testing, and feature requests:

<!-- contributors:start -->

@sebastianelsner · @mihajlovicjj · @timcomport · @aadnehovda · @Vitexus · @Bricklou · @martindglaser · @LaurensRietveld · @pdostal · @stevehollis-orderflow · @knasiotis · @azelcs · @fionnb · @goizper

<!-- contributors:end --> <a href="https://github.com/jztan/redmine-mcp-server/graphs/contributors"> <img src="https://contrib.rocks/image?repo=jztan/redmine-mcp-server" alt="Contributors" /> </a>

Per-release contributor credits are listed in the Changelog.

License

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

Blog posts

The story behind the releases. Building this server keeps surprising me: full API access that turned out to be a mistake, 69 tools that had to become 43, an OAuth scope bug that only surfaced when a contributor ran the flow against a real Redmine 6 instance. Plenty of the sharpest lessons arrived from other people's deployments rather than mine. I write about that thinking in The Dispatch. Come along if that's your kind of thing.

Background, design notes, and postmortems from building this server:

Getting started

• Redmine MCP Server: Give AI Agents Live Project Data: What the server does, why the tool surface is curated rather than a full API mirror, and how to choose a Redmine MCP server
• How I linked a legacy system to a modern AI agent with MCP: The problem that started this project, and the first two read-only tools

Tool design & architecture

• Designing Reliable MCP Servers: 3 Hard Lessons in Agentic Architecture: Why full API access to an agent was a mistake, and what replaced it
• MCP Tool Sprawl: How I Cut 69 Tools to 43 With a Decorator: The v2 consolidation that cut context overhead and sharpened agent tool selection

Production

• How to Evaluate an MCP Server With an LLM: 17 Bugs Found and Fixed: Driving the server with an agent surfaced 17 problems the test suite missed, including a role_ids=[True] bug that quietly assigned an elevated role
• What It Actually Takes to Ship a Production MCP Server for Redmine: The full journey from prototype to production