接入你的智能体
发布者自己的命令。不是 PlugMCP 端点。
用我们的密钥与日志托管一份副本。
uvx redmine-mcp-server==2.22.0Claude Code 没有针对本地命令的安装链接。复制下方命令并在终端中运行。
REDMINE_URL=<value> REDMINE_USERNAME=<value> REDMINE_PASSWORD=<secret> REDMINE_API_KEY=<secret> SERVER_HOST=<value> SERVER_PORT=<value> PUBLIC_HOST=<value> PUBLIC_PORT=<value> ATTACHMENTS_DIR=<value> AUTO_CLEANUP_ENABLED=<value> CLEANUP_INTERVAL_MINUTES=<value> ATTACHMENT_EXPIRES_MINUTES=<value> claude mcp add jztan-redmine-mcp-server -- uvx redmine-mcp-server==2.22.0在终端中运行。
{ "mcpServers": { "jztan-redmine-mcp-server": { "command": "uvx", "args": [ "redmine-mcp-server==2.22.0" ], "env": { "REDMINE_URL": "<value>", "REDMINE_USERNAME": "<value>", "REDMINE_PASSWORD": "<secret>", "REDMINE_API_KEY": "<secret>", "SERVER_HOST": "<value>", "SERVER_PORT": "<value>", "PUBLIC_HOST": "<value>", "PUBLIC_PORT": "<value>", "ATTACHMENTS_DIR": "<value>", "AUTO_CLEANUP_ENABLED": "<value>", "CLEANUP_INTERVAL_MINUTES": "<value>", "ATTACHMENT_EXPIRES_MINUTES": "<value>" } } }}claude_desktop_config.json
远程 URL 还是本机命令? 两种安装方式的区别
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
REDMINE_MCP_EXPOSE_ADMIN_TOOLS=true): Issues, projects, news, time tracking, wiki, Gantt, file operations, membership management, products, contacts and deals (CRM), DMSF documents, Helpdesk email replies and ticket contacts, and moreshow_triage_board renders a live, drag-and-drop issue board right in the chat via the MCP Apps extensionREDMINE_MCP_READ_ONLY environment variablepip install redmine-mcp-server
.env file with your Redmine credentials (see Installation for template)redmine-mcp-server
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}.
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.
Per-user authentication works on any version: OAuth2 needs Redmine 6.1+ for Doorkeeper, and the other per-user modes do not. See Authentication to pick a mode.
# 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}.
* 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.
¶ Required when REDMINE_AUTH_MODE=api-key-login.
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:
default_value, orREDMINE_REQUIRED_CUSTOM_FIELD_DEFAULTSIn practice only the second one can fire. The server reads project custom fields from GET /projects/{id}.json?include=issue_custom_fields, which Redmine renders as id and name only, so it never sees default_value -- see list_project_issue_custom_fields. Set the env map if you want autofill to have anything to work with.
Example:
REDMINE_AUTOFILL_REQUIRED_CUSTOM_FIELDS=true
REDMINE_REQUIRED_CUSTOM_FIELD_DEFAULTS='{"Required Field A":"Value A","Required Field B":"Value B"}'
Configure SSL certificate handling for Redmine servers with self-signed certificates or internal CA infrastructure.
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
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).
⚠️ 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.
For SSL troubleshooting, see the Troubleshooting Guide.
The server supports five authentication modes, selected via REDMINE_AUTH_MODE. It defaults to legacy, so existing deployments keep working with no changes; OAuth2 support is purely additive.
The advanced modes are collapsed below. For full setup, the OAuth2 Setup Guide covers oauth and oauth-proxy, the api-key-login guide covers api-key-login, and the legacy-per-user guide covers legacy-per-user.
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
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.
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.
The server acts as its own OAuth authorization server, so MCP clients connect with nothing but its URL. On first use the client opens a browser, the user pastes their personal Redmine API key into a page this server serves, and every tool call from then on runs as that user. No key goes into any client configuration, and passwords are never asked for.
REDMINE_AUTH_MODE=api-key-login
REDMINE_URL=https://redmine.example.com
REDMINE_MCP_BASE_URL=https://redmine-mcp.example.com # public https URL of this server
REDMINE_MCP_JWT_SIGNING_KEY=... # encrypts the stored keys
The server stores each user's key encrypted below FASTMCP_HOME/api-key-login/, so that directory needs a persistent volume and the mode runs as a single replica. OAuth scopes here are a narrowing the client asks for, not Redmine permissions; Redmine's own permissions stay the boundary. Read the api-key-login guide for the security model, session rules and client setup before enabling it.
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.
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. A client that starts MCP servers itself can run this one over stdio instead, with no running server and no bridge: see stdio transport.
The examples below assume
legacyoroauthmode. Inlegacy-per-usermode each client must also send anX-Redmine-API-Keyheader; see legacy-per-user mode above for header-aware configs.
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:
Cmd/Ctrl+Shift+P)MCP: Open User Configuration (for global) or MCP: Open Workspace Folder Configuration (for project-specific){
"servers": {
"redmine": {
"type": "http",
"url": "http://127.0.0.1:8000/mcp"
}
}
}
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"
}
}
}
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"
}
}
}
Claude Desktop's config file supports stdio transport only. Use FastMCP's proxy via uv to bridge to this HTTP server.
Setup:
{
"mcpServers": {
"redmine": {
"command": "uv",
"args": [
"run",
"--with", "fastmcp",
"fastmcp",
"run",
"http://127.0.0.1:8000/mcp"
]
}
}
}
Config file locations:
~/Library/Application Support/Claude/claude_desktop_config.json%APPDATA%\Claude\claude_desktop_config.jsonNote: The Redmine MCP server must be running before starting Claude Desktop.
Cursor talks to HTTP MCP servers directly, with no bridge.
~/.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"
}
}
}
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.
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.
Kiro primarily supports stdio-based MCP servers. For HTTP servers, use an HTTP-to-stdio bridge:
.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
}
}
}
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.
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"]
}
}
}
With REDMINE_MCP_TRANSPORT=stdio the client starts the server as its own process and talks to it over stdin/stdout. Nothing listens on a port, and the HTTP bridges above are not needed. This works in legacy mode only, since the other modes authenticate each HTTP request.
Claude Code:
claude mcp add redmine \
-e REDMINE_URL=https://your-redmine-server.com \
-e REDMINE_API_KEY=your_api_key \
-e REDMINE_MCP_TRANSPORT=stdio \
-e ATTACHMENTS_DIR=/absolute/path/to/redmine-attachments \
-- uvx redmine-mcp-server
Claude Desktop, Codex CLI, Kiro and other command-based clients:
{
"mcpServers": {
"redmine": {
"command": "uvx",
"args": ["redmine-mcp-server"],
"env": {
"REDMINE_URL": "https://your-redmine-server.com",
"REDMINE_API_KEY": "your_api_key",
"REDMINE_MCP_TRANSPORT": "stdio",
"ATTACHMENTS_DIR": "/absolute/path/to/redmine-attachments"
}
}
}
}
Without an HTTP server there are no URLs to hand out, so get_redmine_attachment returns a local file_path and create_upload_ticket declines; attach local files with file_path instead (allowed folders: ATTACHMENTS_DIR plus REDMINE_MCP_UPLOAD_FILE_ROOTS). Set ATTACHMENTS_DIR to an absolute path: the default ./attachments is relative to the folder the client starts the server in, which is often the project you have open.
# Test connection by checking health endpoint
curl http://localhost:8000/health
The server works against a stock Redmine instance. Six optional plugins add more, shown as eight rows below because CRM's deals and Helpdesk's tickets carry their own flags. 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 tools appear in the client's tool list only when their env var is set; with the flag off they are not registered on the MCP surface at all.
Agile and Additional Tags add fields to tools you already have, so they
register no new tools. The other seven 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.
Tools for a Redmine plugin written in house can be added from a separate package without forking this server; see Extensions.
A deployment can expose a subset of these with REDMINE_MCP_ALLOW_TOOLS; everything else disappears from tools/list and is refused by call_tool.
This MCP server provides 53 core tools for interacting with Redmine, plus 15 plugin tools that are listed only when the matching REDMINE_*_ENABLED flag is set (68 in total), and 1 operator tool exposed by REDMINE_MCP_EXPOSE_ADMIN_TOOLS=true (maximum of 69). A client connected to a vanilla Redmine sees just the 53 core tools. For full documentation of every tool, see the Tool Reference.
Core tools (53, always available): Project Management (10), Issue Operations (13), Time Tracking (4), Discovery / Enumeration (7), Search & Wiki (2), News (4), File Operations (5), Gantt (1), Interactive Apps (6), Meta (1).
Plugin-gated tools (15, listed only when their flag is set): Checklists (3), Products (1), Contacts / CRM (2), Deals / CRM (3), shared CRM notes and saved queries (2, either CRM flag), deal product lines (1, deals plus products), Documents / DMSF (1), Helpdesk (1), Helpdesk tickets (1). Each requires the matching Redmine plugin installed and its env flag set; with the flag off the tools are not registered on the MCP surface.
Operator tools (1, admin-gated): cleanup_attachment_files, registered only when REDMINE_MCP_EXPOSE_ADMIN_TOOLS=true.
These tools require only a Redmine instance and credentials, with no extra plugins or feature flags.
Project Management (10 tools)
list_redmine_projects - List accessible projects (active only unless filters asks for more), narrowed server-side and optionally paginatedlist_project_issue_custom_fields - List issue custom fields configured for a projectlist_redmine_versions - List versions/milestones for a projectmanage_redmine_version - Create, update, or delete a version/milestonemanage_redmine_project - Create a project, edit its settings, or close and reopen itlist_project_members - List members and roles of a projectsummarize_project_status - Get comprehensive project status summarylist_redmine_roles - List all roles defined in the Redmine instance (for discovering valid role_ids)get_project_modules - Retrieve the enabled modules for a projectmanage_project_member - Add, update, or remove a project membershipIssue 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 querycreate_redmine_issue - Create new issues, with optional file attachments via the uploads parameterupdate_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 overrideslist_subtasks - List subtasks (child issues) of a given parentget_private_notes - Retrieve private notes on an issuemanage_issue_relation - List, create, or delete issue relationsmanage_issue_watcher - Add or remove a watcher on an issuemanage_issue_note - Edit a journal note's text or toggle its privacymanage_issue_category - List, create, update, or delete issue categoriesget_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 rangemanage_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 entriesimport_time_entries - Bulk import time entries via sequential API calls with per-entry error reportingDiscovery / 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 projectlist_redmine_issue_statuses - List all issue statuses with their is_closed flaglist_redmine_issue_priorities - List all priority levelslist_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 pagesNews (4 tools): project announcements -- release notes, maintenance windows
list_redmine_news - List news, optionally for one projectget_redmine_news - Read one news item with its comments and attachmentsmanage_redmine_news - Create or update a news item (Redmine 4.1+)delete_redmine_news - Delete a news item, with confirmation (Redmine 4.1+)File Operations (5 tools)
list_files - List files uploaded to a project's Files sectioncreate_upload_ticket - Reserve an upload slot and return a single-use URL, so a file on the caller's machine reaches the server without its bytes passing through the modelupload_file - Upload a new file to a project (from a staged upload_id, a URL, base64 content, or a server-side file_path), optionally tied to a versiondelete_file - Delete a file from a projectget_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 milestonesInteractive 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-backget_triage_board_data - Board data source backing the board's Refresh actionshow_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 listsget_project_dashboard_data - App-only data source backing the dashboard's Refresh actionshow_project_timeline - Render a project's schedule as an interactive timeline: issue bars by version, milestone diamonds, and a Today lineget_project_timeline_data - App-only data source backing the timeline's Refresh actionMeta (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.These tools require a corresponding Redmine plugin installed on the server and the matching environment variable set to true on the MCP server. They are listed in tools/list only when their flag is set; with the flag off they are not registered on the MCP surface (and a direct call still returns a feature-disabled error).
Checklists (3 tools): set REDMINE_CHECKLISTS_ENABLED=true; requires the RedmineUP Checklists Pro plugin
get_checklist - Retrieve all checklist items for an issuecreate_checklist_item - Add a new checklist item to an issueupdate_checklist_item - Update a checklist item's text, done state, or positionProducts (1 tool): set REDMINE_PRODUCTS_ENABLED=true; requires the RedmineUP Products plugin
manage_product - List, get, create, or update productsContacts (CRM) (2 tools): set REDMINE_CRM_ENABLED=true; requires the RedmineUP CRM plugin. In OAuth mode the flag also adds the CRM permissions to the advertised scopes, so grant them on the OAuth application and have users re-consent. Set REDMINE_CRM_EDITION=pro on a Pro install to allow the contact list filters the Light build does not register
manage_contact - List, get, create, update, delete, or assign/remove project association for contactslist_contact_tags - Tags in use on contacts, with colors, for the tags filter and tag_listDeals (CRM) (3 tools): set REDMINE_DEALS_ENABLED=true; requires the Pro edition of the same CRM plugin, and the deals project module enabled on the project. Deals have their own flag because the Light edition defines none of the deal permissions, so advertising them would break consent for Light deployments
manage_deal - List, get, create, update, or delete dealslist_deal_statuses - Deal statuses (admin-only on the plugin side) and a project's deal categories, for use before creating a dealmanage_deal_category - List, create, rename, or delete a project's deal categoriesCRM notes and saved queries (2 tools, shared): available when either REDMINE_CRM_ENABLED or REDMINE_DEALS_ENABLED is set; each call is gated on the flag matching the note's or query's source
manage_crm_note - Get, create, update, or delete CRM notes on contacts and dealslist_crm_queries - Saved contact or deal queriesDeal product lines (1 tool): needs both REDMINE_DEALS_ENABLED=true and REDMINE_PRODUCTS_ENABLED=true; the endpoint exists only when the Products plugin is installed next to CRM
add_deal_product - Add a catalogue or free-form product line to a dealDocuments (DMSF) (1 tool): set REDMINE_DMSF_ENABLED=true; requires the redmine_dmsf plugin
manage_document - List, get, create (upload), or update (new revision) DMSF documentsHelpdesk (1 tool): set REDMINE_HELPDESK_ENABLED=true; requires the RedmineUP Helpdesk plugin
send_helpdesk_email_reply - Email a reply to a Helpdesk ticket's customer, optionally changing the ticket statusHelpdesk tickets (1 tool): set REDMINE_HELPDESK_TICKETS_ENABLED=true; requires the RedmineUP Helpdesk plugin and the RedmineUP CRM plugin
manage_helpdesk_ticket - Read a ticket's Helpdesk data, or move it to another existing contactHidden 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)# 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
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.
Use the automated deployment script:
chmod +x deploy.sh
./deploy.sh
If you run into any issues, checkout our troubleshooting guide.
See the roadmap for planned features and future development.
Contributions are welcome! Please see our contributing guide for details.
Thank you to everyone who has helped improve this project through code, reviews, testing, and feature requests:
@sebastianelsner · @mihajlovicjj · @timcomport · @aadnehovda · @Vitexus · @Bricklou · @martindglaser · @LaurensRietveld · @pdostal · @stevehollis-orderflow · @knasiotis · @azelcs · @fionnb · @goizper · @mmahmed · @andilem · @gino8080 · @siva01c · @chesterXalan · @mliebischer
Per-release contributor credits are listed in the Changelog.
Thanks also to RedmineUP for providing evaluation copies of CRM PRO and Helpdesk PRO, which let the CRM and Helpdesk tools be verified against real Pro instances.
This project is licensed under the MIT License - see the LICENSE file for details.
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
Tool design & architecture
Production
role_ids=[True] bug that quietly assigned an elevated roleMCP server connecting AI assistants to Redmine: issues, projects, wikis, time tracking, agile boards, and CRM, with OAuth2 multi-user support
{ "mcpServers": { "jztan-redmine-mcp-server": { "command": "uvx", "args": [ "redmine-mcp-server==2.22.0" ], "env": { "REDMINE_URL": "<value>", "REDMINE_USERNAME": "<value>", "REDMINE_PASSWORD": "<secret>", "REDMINE_API_KEY": "<secret>", "SERVER_HOST": "<value>", "SERVER_PORT": "<value>", "PUBLIC_HOST": "<value>", "PUBLIC_PORT": "<value>", "ATTACHMENTS_DIR": "<value>", "AUTO_CLEANUP_ENABLED": "<value>", "CLEANUP_INTERVAL_MINUTES": "<value>", "ATTACHMENT_EXPIRES_MINUTES": "<value>" } } }}工具
暂无工具列表。远程服务器在首次健康检查后会获得工具列表。
常见问题
在本页复制适用于 Cursor、Claude Desktop、Claude Code 或 VS Code 的 stdio 配置。它使用发布者的安装方式,而不是 PlugMCP 代理。
发布者列出了以下环境变量:REDMINE_URL, REDMINE_USERNAME, REDMINE_PASSWORD, REDMINE_API_KEY, SERVER_HOST, SERVER_PORT, PUBLIC_HOST, PUBLIC_PORT, ATTACHMENTS_DIR, AUTO_CLEANUP_ENABLED, CLEANUP_INTERVAL_MINUTES, ATTACHMENT_EXPIRES_MINUTES。
Redmine 通过 stdio 在本地运行。
上次检查时间:2026-10-27。 MCP server connecting AI assistants to Redmine: issues, projects, wikis, time tracking, agile boards, and CRM, with OAuth2 multi-user support