Skip to main content
Glama

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

  1. Context-First Design Returns journals (comments) alongside issues so the AI can reason about history, generate accurate follow-up proposals, and summarize progress.

  2. 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.

  3. Powerful Full-Text Search search_issues_full searches 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).

  1. Log in as an administrator

  2. Administration → Settings → API tab → check Enable REST web service and save

To get an API key:

  1. Open My account from the top-right menu

  2. Click Show next to API access key

  3. Use this key as X-Redmine-API-Key in 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
Redmine

Installation

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.sh

install.sh performs the following:

  • Pre-flight checks (root, OS, Python 3.12, required files)

  • Creates a dedicated redmine-mcp-stateless system user

  • Copies files to /opt/redmine-mcp-stateless/ and creates a Python virtual environment

  • Configures 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 -f

To uninstall

bash uninstall.sh

Option 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 --build

2. Verify

docker compose ps
docker compose logs -f redmine-mcp-stateless

Stop

docker compose down

Claude 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.py

This mode exists mainly for MCP registry inspection (e.g. Glama). Use SSE for shared team deployment.


Available Tools

Issues

Tool

Description

list_issues

List issues with optional filters (project, status, assignee)

get_issue

Issue details including all comments and attachments

create_issue

Create a new issue

update_issue

Update an issue or add a comment

update_journal

Edit an existing comment (requires Redmine 5.0+)

list_issues_with_journals

List issues with all comments — useful for per-assignee progress review

search_issues_full

Full-text search across subject, description, and comments

Projects

Tool

Description

list_projects

List all projects

get_project

Project details

Master Data

Tool

Description

list_statuses

Available issue statuses

list_trackers

Available trackers

list_priorities

Available priorities

list_users

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

redmine_mcp_interface.py

MCP server entry point

redmine_mcp_server.py

Redmine REST API client

requirements.txt

Python dependencies

Dockerfile

Container image (python:3.12-slim)

compose.yml

Docker Compose configuration

redmine-mcp-stateless.service

systemd unit file

install.sh

RHEL installation script

uninstall.sh

Uninstallation script

example-claude-code-config.json

Example Claude Code configuration


Security Notes

  • Redmine URL and API key are never stored on the server

  • Passed per-request via X-Redmine-URL and X-Redmine-API-Key headers

  • Stored temporarily in a ContextVar and discarded after each request completes

  • On RHEL, the service runs as a dedicated unprivileged user (redmine-mcp-stateless)


License

MIT

Available Tools

13 tools
create_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

    A3.6/5.0

    Scored across 13 tools

    Disambiguation4/5

    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.

    Naming Consistency5/5

    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.

    Tool Count5/5

    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.

    Completeness4/5

    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

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      D
      maintenance
      An 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
      -
    • A
      license
      Not graded
      quality
      B
      maintenance
      A stateless MCP server for Redmine that allows users to interact with issues, time entries, wiki, projects, and more via their own API keys.
      4
      MIT
    • A
      license
      C
      quality
      D
      maintenance
      Model 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.
      90
      14 npm
      MIT
    • A
      license
      B
      quality
      D
      maintenance
      MCP 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.
      89
      21 npm
      1
      MIT