redmine-mcp-stateless
The redmine-mcp-stateless server enables AI assistants like Claude to fully manage a Redmine instance via its REST API. Credentials are passed per-request via HTTP headers and never stored on the server, enabling secure multi-tenant deployment.
Issue Management
list_issues— Browse issues with filters for project, status, and assigneeget_issue— Retrieve full issue details including all comments (journals) and attachmentscreate_issue— Create issues with subject, description, tracker, status, priority, and assigneeupdate_issue— Modify issue fields and/or add commentsupdate_journal— Edit existing comments on issues (requires Redmine 5.0+)list_issues_with_journals— Retrieve issues with all comments, useful for progress reviews per assigneesearch_issues_full— Full-text search across issue subjects, descriptions, and all comments
Project Management
list_projects— Retrieve all available Redmine projectsget_project— Retrieve detailed information about a specific project
Master / Reference Data
list_statuses,list_trackers,list_priorities— Retrieve available statuses, trackers, and prioritieslist_users— Retrieve users (may require admin privileges), useful for resolving assignee IDs by name
Deployment: Runs as an HTTP server on RHEL (systemd) or Docker, with stdio mode available for local use.
Enables management of Redmine issues, projects, and journals, providing tools for listing, creating, and updating issues, performing full-text searches across comments and descriptions, and retrieving project metadata and user information.
RedmineMCP
An MCP (Model Context Protocol) server that lets Claude Code operate Redmine directly. Runs as an HTTP server on RHEL or Docker. Credentials are never stored on the server — they are passed per-request via HTTP headers from the Claude Code configuration file.
Key Features
Context-First Design Returns journals (comments) alongside issues so the AI can reason about history, generate accurate follow-up proposals, and summarize progress.
Stateless Design API keys are passed per-request from the client and never stored on the server. This brings three practical benefits:
Maximum security — Even if the server is compromised, there are no API keys stored on it to steal.
Multi-tenant out of the box — Deploy one server for the whole team. Each user simply sets their own API key on the Claude side; no per-user configuration is needed on the server.
Zero maintenance for credential changes — When a Redmine password or API key changes, only the client-side Claude configuration needs updating. The server requires no changes.
Powerful Full-Text Search
search_issues_fullsearches across subject, description, and all comments, returning results in an AI-friendly format.
Related MCP server: redmine-mcp
Requirements
Redmine 5.0+ (Redmine 5.0+ required for
update_journal)Python 3.12
RHEL (systemd deployment) or Docker
Redmine Initial Setup
Before using RedmineMCP, enable the Redmine REST API (disabled by default).
Log in as an administrator
Administration → Settings → API tab → check Enable REST web service and save
To get an API key:
Open My account from the top-right menu
Click Show next to API access key
Use this key as
X-Redmine-API-Keyin the Claude Code configuration
Architecture
Client PC (Claude Code / Mac or Windows)
↓ HTTP :8000 + headers (X-Redmine-URL / X-Redmine-API-Key)
Server (RHEL or Docker)
↓ REST API
RedmineInstallation
Option A — RHEL (systemd)
1. Transfer files to the server
ssh root@<server> "mkdir -p /tmp/redmine-mcp-stateless"
scp redmine_mcp_interface.py redmine_mcp_server.py requirements.txt \
redmine-mcp-stateless.service install.sh uninstall.sh \
root@<server>:/tmp/redmine-mcp-stateless/2. Run the installer
cd /tmp/redmine-mcp-stateless
chmod +x install.sh
./install.shinstall.sh performs the following:
Pre-flight checks (root, OS, Python 3.12, required files)
Creates a dedicated
redmine-mcp-statelesssystem userCopies files to
/opt/redmine-mcp-stateless/and creates a Python virtual environmentConfigures logrotate
Registers and starts a systemd service
Configures SELinux (registers port 8000 as
http_port_t)Opens port 8000 in firewalld
Verifies service startup and port listening
3. Verify
systemctl status redmine-mcp-stateless
journalctl -u redmine-mcp-stateless -fTo uninstall
bash uninstall.shOption B — Docker
Runs the MCP server as a container. Requires an existing Redmine instance accessible from the host.
1. Build and start
docker compose up -d --build2. Verify
docker compose ps
docker compose logs -f redmine-mcp-statelessStop
docker compose downClaude Code Configuration
Add the following to ~/.claude.json:
RHEL
{
"mcpServers": {
"redmine-mcp-stateless": {
"type": "sse",
"url": "http://<server-IP>:8000/sse",
"headers": {
"X-Redmine-URL": "https://<your-redmine>",
"X-Redmine-API-Key": "<your-api-key>"
}
}
}
}Docker
{
"mcpServers": {
"redmine-mcp-stateless": {
"type": "sse",
"url": "http://localhost:8000/sse",
"headers": {
"X-Redmine-URL": "https://<your-redmine>",
"X-Redmine-API-Key": "<your-api-key>"
}
}
}
}stdio transport (for registry inspection / local use)
The server normally runs with SSE (HTTP). Setting the environment variable MCP_TRANSPORT=stdio switches it to stdio transport. In this mode, credentials are passed via environment variables instead of HTTP headers:
MCP_TRANSPORT=stdio REDMINE_URL=https://<your-redmine> REDMINE_API_KEY=<your-api-key> \
python redmine_mcp_interface.pyThis mode exists mainly for MCP registry inspection (e.g. Glama). Use SSE for shared team deployment.
Available Tools
Issues
Tool | Description |
| List issues with optional filters (project, status, assignee) |
| Issue details including all comments and attachments |
| Create a new issue |
| Update an issue or add a comment |
| Edit an existing comment (requires Redmine 5.0+) |
| List issues with all comments — useful for per-assignee progress review |
| Full-text search across subject, description, and comments |
Projects
Tool | Description |
| List all projects |
| Project details |
Master Data
Tool | Description |
| Available issue statuses |
| Available trackers |
| Available priorities |
| User list (may require admin privileges) |
Retrievable Data
Category | Fields |
Project | ID, identifier, name, description, status |
Issue | ID, subject, description, status, project, tracker, priority, assignee, created/updated date |
Journal (comment) | comment ID, body, created date, author |
Attachment | file ID, filename, file size, MIME type, description, author, created date |
Status / Tracker / Priority | ID, name |
User | ID, login, first name, last name, full name |
File Structure
File | Description |
| MCP server entry point |
| Redmine REST API client |
| Python dependencies |
| Container image (python:3.12-slim) |
| Docker Compose configuration |
| systemd unit file |
| RHEL installation script |
| Uninstallation script |
| Example Claude Code configuration |
Security Notes
Redmine URL and API key are never stored on the server
Passed per-request via
X-Redmine-URLandX-Redmine-API-KeyheadersStored temporarily in a
ContextVarand discarded after each request completesOn RHEL, the service runs as a dedicated unprivileged user (
redmine-mcp-stateless)
License
MIT
Available Tools
13 toolscreate_issueC
Creates a new issue.
Args:
project_id: Project ID or identifier
subject: Subject
description: Description
tracker_id: Tracker ID
status_id: Status ID
priority_id: Priority ID
assigned_to_id: Assignee ID
Inputs: subject (required), project_id (required), status_id, tracker_id, +3 more. Returns: result
get_issueB
Returns details of the specified issue, including comments and attachments.
Args:
issue_id: Issue number
Inputs: issue_id (required). Returns: result
get_projectC
Returns details of the specified project.
Args:
project_id: Project ID or identifier
Inputs: project_id (required). Returns: result
list_issuesC
Returns a list of issues.
Args:
project_id: Project ID (all projects if omitted)
status_id: Status ID or "open" / "closed" / "*"
assigned_to_id: Assignee ID
limit: Number of results (max 100)
offset: Starting offset
Inputs: limit, offset, status_id, project_id, +1 more. Returns: result
list_issues_with_journalsB
Returns a list of issues with all comments. Useful for reviewing progress per assignee.
Args:
assigned_to_id: Assignee ID (obtain via list_users)
project_id: Project ID (all projects if omitted)
status_id: Status ID or "open" / "closed" / "*"
limit: Number of issues to fetch (max 100)
offset: Starting offset
Inputs: limit, offset, status_id, project_id, +1 more. Returns: result
list_prioritiesA
Returns a list of available issue priorities. Used for priority_id in create_issue / update_issue.
Inputs: no named parameters. Returns: result
list_projectsB
Returns a list of Redmine projects.
Inputs: no named parameters. Returns: result
list_statusesB
Returns a list of available issue statuses.
Inputs: no named parameters. Returns: result
list_trackersB
Returns a list of available trackers.
Inputs: no named parameters. Returns: result
list_usersA
Returns a list of Redmine users. Useful for looking up assignee IDs by name. Note: May require Redmine administrator privileges.
Inputs: no named parameters. Returns: result
search_issues_fullA
Full-text search for issues by keyword. Returns results with description and all comments. Searches across subject, description, and all comments.
Args:
query: Search keyword
project_id: Filter by project ID (all projects if omitted)
limit: Maximum number of results (all results if omitted)
Inputs: query (required), limit, project_id. Returns: result
update_issueC
Updates an issue.
Args:
issue_id: Issue number
subject: New subject
description: New description
status_id: New status ID
priority_id: New priority ID
assigned_to_id: New assignee ID
notes: Comment
Inputs: issue_id (required), notes, subject, status_id, +3 more. Returns: result
update_journalB
Edits a journal (comment) on an issue. Requires Redmine 5.0+.
Args:
journal_id: Comment ID (journals[].id from get_issue response)
notes: New comment content
Inputs: notes (required), journal_id (required). Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 13 tools
Most tools have distinct purposes, but list_issues and list_issues_with_journals have significant overlap in functionality and parameters, which could cause confusion. The other tools are clearly differentiated by their target resources and actions.
All tools follow a consistent verb_noun naming pattern with snake_case throughout. The naming is predictable and readable, with clear action-resource pairs like create_issue, list_projects, and update_journal.
With 13 tools, this server is well-scoped for Redmine issue and project management. The count is appropriate, covering core operations without being overwhelming, and each tool serves a clear purpose in the domain.
The toolset provides strong coverage for issue and project management, including CRUD operations for issues, listing resources, and search. A minor gap is the lack of project creation/deletion tools, but agents can still perform core workflows effectively.
Maintenance
Related MCP Connectors
A MCP server built for developers enabling Git based project management with project and personal…
Remote MCP server for notes, tasks, kanban boards and docs - the Slates agentic workspace
MCP Server for an Agent Task Marketplace
One MCP server for all your MCP servers: code mode, per-tool permissions, approvals and audit.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceAn MCP server providing 63 tools to interact with Redmine instances, covering issues, projects, time entries, and wiki pages. It utilizes streamable HTTP transport and supports per-client authentication for secure management of Redmine resources.13 npm-
- AlicenseNot gradedqualityBmaintenanceA stateless MCP server for Redmine that allows users to interact with issues, time entries, wiki, projects, and more via their own API keys.4MIT
- AlicenseCqualityDmaintenanceModel Context Protocol (MCP) server for Redmine that provides comprehensive access to the Redmine REST API, enabling users to operate Redmine from MCP clients such as Claude Desktop.9014 npmMIT
- AlicenseBqualityDmaintenanceMCP server for Redmine project management, enabling tools for managing projects, issues, users, time entries, groups, memberships, versions, wiki, news, attachments, search, and Agile sprints via the Redmine REST API.8921 npm1MIT