redmine-mcp-server
Advanced tools
MCP server that lets AI assistants manage Redmine issues, projects, wikis, and time tracking
A Model Context Protocol (MCP) server that integrates with Redmine project management systems. This server provides seamless access to Redmine data through MCP tools, enabling AI assistants to interact with your Redmine instance.
mcp-name: io.github.jztan/redmine-mcp-server
An AI agent triaging a Redmine sprint through redmine-mcp-server. Try the live demo →
REDMINE_MCP_EXPOSE_ADMIN_TOOLS=true): Issues, projects, time tracking, wiki, Gantt, file operations, membership management, products, contacts (CRM), DMSF documents, 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}.
# 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}.
| 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_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_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:
default_value, orREDMINE_REQUIRED_CUSTOM_FIELD_DEFAULTSExample:
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 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.
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.
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.
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.
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"]
}
}
}
# Test connection by checking health endpoint
curl http://localhost:8000/health
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.
These tools require only a Redmine instance and credentials — no extra plugins or feature flags.
Project Management (9 tools)
list_redmine_projects - List all accessible projectslist_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/milestonelist_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 pagesFile Operations (4 tools)
list_files - List files uploaded to a project's Files sectionupload_file - Upload a new file to a project (from base64 content, a URL, 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 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 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 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) (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 contactsDocuments (DMSF) (1 tool) — set REDMINE_DMSF_ENABLED=true; requires the redmine_dmsf plugin
manage_document - List, get, create (upload), or update (new revision) DMSF documentsHidden 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.
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 · @aadnehovda · @martindglaser · @Vitexus · @timcomport · @Bricklou · @LaurensRietveld
Per-release contributor credits are listed in the Changelog.
This project is licensed under the MIT License - see the LICENSE file for details.
FAQs
MCP server that lets AI assistants manage Redmine issues, projects, wikis, and time tracking
The pypi package redmine-mcp-server receives a total of 415 weekly downloads. As such, redmine-mcp-server popularity was classified as not popular.
We found that redmine-mcp-server demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
A misconfiguration gave three Anthropic models internet access, and one, believing it was in a simulation, shipped a credential-stealing package to PyPI.
Security News
/Company News
Socket has joined the new Composer and Packagist sponsorship program as a launch sponsor, supporting the team that keeps PHP's package ecosystem secure.
Research
/Security News
Benign-looking npm packages split malicious functionality across a dependency chain that deploys a cross-platform RAT targeting Alibaba developers.