Your AI shouldn't just read tickets. It should work them.

redmine-mcp-server gives AI agents 53 tools to triage, update, comment on, and close Redmine issues, the way a project manager would.

$ pip install redmine-mcp-server
View on GitHub

Works with any MCP client

Claude Code VS Code Cursor Codex CLI Kiro
An AI agent on a live Redmine
scripted walkthrough, no real Redmine connected · the agent edits the Issues page below by calling the server's 53 MCP tools, registered in Claude Code as redmine
HomeMy pageProjectsHelp Logged in as alex.riveraMy accountSign out
⌄Cartly≡
Cartly
Search: Cartly
+OverviewActivityRoadmapIssuesSpent timeGanttWikiSettings
Issues
⊕ New issue⋯
› Filters
open isSprint 14
Add filter
› Options
Apply Clear Save custom query
# TrackerStatus ⌄Priority SubjectAssigneeDue date
claude — ~/work/cartly-app
✻ Claude Code v2.1.284Opus 5.5 · ~/work/cartly-app
▸ press Run the agent to start
▏
? for shortcuts
0tool calls
0issues touched
0comments added
0issues closed
This is a scripted walkthrough against canned data. The JSON in each tool call matches the real server's response shape field-for-field, including the <insecure-content> boundary tags that wrap untrusted user text. Nothing here connects to a live Redmine.

Live apps, right in your chat.

The demo above simulates the loop. These are the real thing: interactive apps rendered inside the conversation through the official MCP Apps extension, driven by the same tool calls.

A drag-and-drop triage board.

show_triage_board draws a project's issues as an interactive Kanban board. Drag a card to another column and the agent writes the status change to Redmine via update_redmine_issue; if Redmine rejects the transition, the card snaps back and explains why.

Interactive Kanban board rendered in the chat by show_triage_board, with issue cards grouped in open, in-progress, and closed columns

A live project dashboard.

show_project_dashboard renders open vs closed, overdue, due this week, an open-by-priority breakdown, and recent activity. Click any figure to drill into the matching issue list in-panel, and hit Refresh to re-fetch. It is read-only.

Interactive project dashboard rendered in the chat by show_project_dashboard, showing open vs closed counts, overdue and due-this-week figures, an open-by-priority breakdown, and recent activity

A project timeline.

show_project_timeline lays out a project's schedule as a Gantt view: issue bars from their start and due dates, grouped by target version, with a milestone on each release date and a Today line. Overdue work is outlined in red, and clicking a bar or milestone shows its details. It is read-only.

Interactive project timeline rendered in the chat by show_project_timeline, with issue bars grouped by version, milestone diamonds, a Today line, and a details popover open on one issue

All three need an MCP client that renders MCP Apps. Tried them? Leave feedback in the discussion.

Far more than triage.

The demo shows one workflow. The server's 53 core tools, 68 with plugins, cover the rest of Redmine.

Search all of Redmine at once

One search_entire_redmine call spans issues, wiki pages, and news.

Write the wiki, not just read it

Create, update, and version wiki pages with manage_redmine_wiki_page.

Log and import time

Record time entries with manage_time_entry, or bulk-import a week of them with import_time_entries.

Read the Gantt and the roadmap

get_gantt_chart returns dated issues, dependencies, and milestones, so the agent can reason about a real timeline.

Move files and attachments

Upload from base64, a URL, or a path; attach files to issues and notes; download attachments through expiring URLs.

Speaks the plugin ecosystem

RedmineUP Agile (including sprint, position, and story-point writes), the full CRM PRO REST API (contacts, deals, notes, tags, saved queries, deal categories, and product lines), products, and checklists, plus DMSF documents and AlphaNodes issue tags, as first-class tools.

Built to be cheap on context

Ask for the fields you need and a list of issues costs about 95% fewer tokens. Every list paginates, and issue history pages separately, so one call never floods the window.

Multi-tenant per-user auth

OAuth2, OAuthProxy, or per-user API keys on older Redmine: the agent acts as each user, not one shared key.

Ships as a container

A prebuilt image on GHCR plus a docker-compose setup, or run it straight from PyPI. Health check at /health.

Why not just hand the agent the REST API?

Redmine's REST API is good. Pointing a model straight at it is the part that goes wrong.

 A generic HTTP toolredmine-mcp-server
Getting it right The model composes URLs, query filters, and JSON bodies from memory, and finds out it was wrong from a 422. 53 typed tools with validated parameters. Enumeration tools hand back the valid tracker, status, priority, and role IDs before a write is attempted.
Context cost Whole payloads land in the window, including every field and every journal entry you did not ask for. Field selection trims a list of issues by roughly 95%, every list paginates, and issue history pages separately.
Guardrails Whatever the credential can do, the model can do, with no way to scope it down or preview the damage. Read-only mode, per-tool OAuth scope enforcement, and a required confirmation flag, with a cascade-impact preview on refusal, before an issue is deleted.
Untrusted text A ticket description arrives as plain prose, indistinguishable from your own instructions. User-controlled text is wrapped in <insecure-content> boundary tags so the model reads it as data.
What you see JSON, pasted into the chat. An interactive Kanban board, project dashboard, and timeline rendered in the conversation, writing back through the same tools.

Your Redmine stays yours.

An agent that can close and delete tickets needs guardrails, not good intentions. Every one of these is in the server today.

Runs on your infrastructure

The server talks to your Redmine and your MCP client. There is no vendor in the middle and no hosted service to sign up for. MIT licensed, source on GitHub.

Read-only until you say otherwise

Set REDMINE_MCP_READ_ONLY=true and every write branch is blocked while reads keep working. The safe way to evaluate against production data.

OAuth scopes enforced per tool call

In OAuth mode each tool requires the Redmine permissions it actually uses, per action for the manage_* tools. Unmapped tools are denied by default and tools/list is filtered to the token's scopes.

Untrusted text is fenced off

Descriptions, notes, and search excerpts are wrapped in <insecure-content> boundary tags before they reach the model, so a ticket cannot smuggle instructions into your agent.

Destructive actions ask first

delete_redmine_issue refuses without an explicit confirmation flag and returns a cascade-impact preview with the refusal; subtasks need a second flag.

Hardened network edges

URL-based uploads are SSRF-checked, attachment downloads are size-capped and served through expiring UUID URLs, and TLS settings (custom CA, mTLS) are honored on every call site.

Connected in about a minute.

Install it, point it at your Redmine, register the endpoint with your agent.

01

Install from PyPI.

pip install redmine-mcp-server

Prefer a container? ghcr.io/jztan/redmine-mcp-server is published for every release.

02

Point it at your Redmine in .env, then start it.

REDMINE_URL=https://redmine.example.com
REDMINE_API_KEY=your_api_key
# evaluating? add REDMINE_MCP_READ_ONLY=true

redmine-mcp-server

Serves MCP on http://127.0.0.1:8000/mcp. For a team, swap the API key for OAuth2 or per-user keys.

03

Register it with your agent.

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

Or add the same server block to ~/.claude.json by hand.

Questions people ask first.

Which Redmine versions are supported?

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

OAuth2 is the one hard requirement: it needs Redmine 6.1 or newer for Doorkeeper support. API key and username/password authentication have no such floor.

Can the agent write to my Redmine, or only read it?

It writes. Creating and updating issues, adding notes, logging time, editing wiki pages, and managing members, versions, categories, and relations are all tool calls.

If you would rather it did not, set REDMINE_MCP_READ_ONLY=true and every write branch is blocked while reads keep working. Deleting an issue is refused unless confirm_delete=true is passed, and the refusal carries a cascade-impact preview; an issue with subtasks needs a second flag. In read-only mode deletion is blocked outright.

Does my Redmine data leave my network?

Not through this server. It runs on your own infrastructure and talks to your Redmine and your MCP client, plus any URL an agent explicitly asks it to upload a file from (SSRF-checked). There is no hosted service, no telemetry, and no third party in the path.

What your AI client then sends to its model provider is between you and that client, the same as for any other tool it runs.

Which AI clients does it work with?

Any client that speaks MCP. Claude Code, Claude Desktop, VS Code with Copilot, Cursor, Codex CLI, and Kiro have step-by-step guides in the README, and other clients use the generic HTTP configuration.

The server exposes streamable HTTP at /mcp. Clients that only speak stdio connect through a bridge, which the setup guides cover.

How does it handle a whole team rather than one user?

Several ways. A single shared API key is the simple default. OAuth2 gives every user their own token, so the agent acts as that person with that person's permissions, and each tool call is checked against the scopes their token actually carries. OAuthProxy covers hosted deployments where clients register themselves.

On Easy Redmine or Redmine older than 6.1, where OAuth is unavailable, api-key-login mode has each user paste their own API key into a login page once, and legacy-per-user mode takes an X-Redmine-API-Key header per request. Both give the same per-user identity.

Do I need to install Redmine plugins?

No. All 53 core tools work against a stock Redmine with no plugins at all.

Fifteen more are plugin-gated (68 in total) and need both the plugin installed and a matching environment variable: checklists, products, the RedmineUP CRM (contacts, deals, notes, tags, saved queries, deal categories, and product lines), DMSF documents, and Helpdesk email replies and ticket contacts. Plugin tools are not even listed to the agent until their flag is set. RedmineUP Agile and AlphaNodes Additional Tags add fields to tools you already have rather than new tools, turned on with REDMINE_AGILE_ENABLED and REDMINE_TAGS_ENABLED.

What does it cost?

Nothing. It is MIT licensed, published on PyPI and GHCR, and listed in the official MCP Registry. You host it yourself, so the only cost is wherever you run it and whatever your AI client charges for tokens.

Take it further.

The demo shows 4 of the server's 53 core tools. The full set spans list_redmine_issues, get_redmine_issue, update_redmine_issue, show_triage_board, show_project_dashboard, show_project_timeline, manage_time_entry, manage_redmine_wiki_page, manage_project_member, search_entire_redmine, get_gantt_chart, upload_file, get_redmine_attachment, and more, covering issues, projects, wikis, time tracking, versions, Gantt data, files, and CRM. Tested against Redmine 6.1 and 7.0, with multi-tenant per-user auth (OAuth2, OAuthProxy, or per-user API keys) and a read-only safety mode.

GitHub PyPI GHCR MCP Registry Docs Blog
About redmine-mcp-server

redmine-mcp-server: Redmine project management for AI agents

redmine-mcp-server is an open-source MCP (Model Context Protocol) server that lets AI agents read and manage a Redmine instance: issues, projects, wikis, time tracking, versions, Gantt data, files, and contacts. It ships as a Python package and a container image, and connects to Claude Desktop, Claude Code, Cursor, VS Code Copilot, Codex CLI, Kiro, and any MCP-compatible client. Its integration suite passes in full against Redmine 6.1 and 7.0.

What it does

Redmine has a capable REST API, but wiring an agent to it directly means handing the model raw HTTP access, which is slow, error-prone, and unsafe. redmine-mcp-server exposes 53 purpose-built tools instead. An agent can list and filter issues, read a ticket with its full history, update status and assignee, add notes, log time, manage wiki pages, pull Gantt timelines, upload and download attachments, and run global search, each as a single typed tool call with predictable, serialized JSON. It can also render interactive apps directly in the chat through the MCP Apps extension: show_triage_board draws a project's issues as drag-and-drop status columns that write back to Redmine, show_project_dashboard renders a live, read-only project snapshot with click-through drill-ins to matching issue lists, and show_project_timeline lays out the schedule as a read-only Gantt view grouped by version.

How it stays safe

The server runs on your own infrastructure and talks to your Redmine and your MCP client, plus any URL an agent explicitly asks it to upload a file from. A read-only mode (REDMINE_MCP_READ_ONLY=true) blocks every write while you evaluate. In OAuth mode, each tool call is checked against the Redmine permission scopes the tool actually uses, per action for the manage_* tools, with unmapped tools denied by default and tools/list filtered to the token's scopes. User-controlled text is wrapped in boundary tags before it reaches the model, URL-based uploads are SSRF-checked, and issue deletion is refused without an explicit confirmation flag, with a cascade-impact preview in the refusal.

What the demo shows

The browser demo is a scripted simulation of a triage workflow against canned data. The JSON returned by each tool matches the real server's response shape field-for-field, including the <insecure-content> boundary tags that wrap user-controlled text (descriptions, notes, comments) so an LLM treats them as untrusted data rather than instructions. Nothing connects to a live Redmine; the point is to show the agent's tool loop, not to be a hosted service.

Install

redmine-mcp-server is MIT-licensed and published on PyPI. Install with pip install redmine-mcp-server, then point it at your Redmine URL with an API key, OAuth2, or per-user auth. The source is on GitHub and the package on PyPI. For a full tour of the server, see the launch post on giving AI agents live project data. For the story behind it, see the blog post on linking a legacy system to a modern AI agent.

Give your agent the backlog.

Open source, MIT licensed, self-hosted. Tested against Redmine 6.1 and 7.0.

$ pip install redmine-mcp-server
View on GitHub
Copied