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

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

pip install redmine-mcp-server
Scripted walkthrough below, no real Redmine is connected.
Redmine 6.1 & 7.0 tested · Python 3.10+ · MIT licensed · Self-hosted, no SaaS · on GitHub
An AI agent on a live Redmine
it sees the same Issues page you do — and edits it with MCP tool calls
HomeMy pageProjectsHelp Logged in as alex.rivera
Home » Projects » Cartly
Cartly
OverviewActivityRoadmapIssuesGanttWikiSettings
Issues
Filters: Status: open Due date: ≤ 2026-06-20 Sprint 14 Apply
# ▾ TrackerStatusPriority SubjectAssigneeDue date
claude — ~/work/cartly-app
✻ Welcome to Claude Coderedmine-mcp-server connected over MCP · 51 tools available
▸ press Run the agent to start
▏
? for shortcuts● redmine-mcp-server (MCP)
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.
MCP Apps

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.

Both 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 same 51 tools cover the rest of Redmine.

Search all of Redmine at once

One search_entire_redmine call spans issues, wiki pages, projects, 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 or bulk-import a week of them with manage_time_entry.

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), contacts (CRM), 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. 51 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 with cascade preview 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 and project dashboard 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 requires explicit confirmation flags and shows a cascade-impact preview before anything irreversible happens.

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.

1

Install from PyPI.

pip install redmine-mcp-server

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

2

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.

3

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 always requires explicit confirmation flags and shows a cascade-impact preview first, in either mode.

Does my Redmine data leave my network?

Not through this server. It runs on your own infrastructure and talks to exactly two things: your Redmine and your MCP client. 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, Codex CLI, and Kiro have step-by-step guides in the README, and Cursor 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?

Three 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 Redmine older than 6.1, where OAuth is unavailable, legacy-per-user mode takes an X-Redmine-API-Key header per request and gets you the same per-user identity.

Do I need to install Redmine plugins?

No. 45 of the 51 tools work against a stock Redmine with no plugins at all.

Six are plugin-gated and need both the plugin installed and a matching environment variable: checklists, products, CRM contacts, and DMSF documents. RedmineUP Agile and AlphaNodes Additional Tags add fields to tools you already have rather than new tools, so sprint, story point, and tag support appears automatically when those plugins are present.

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 51 tools. The full set spans list_redmine_issues, get_redmine_issue, update_redmine_issue, show_triage_board, show_project_dashboard, 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 51 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, and show_project_dashboard renders a live, read-only project snapshot with click-through drill-ins to matching issue lists.

How it stays safe

The server runs on your own infrastructure and talks only to your Redmine and your MCP client. 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 requires explicit confirmation with a cascade-impact preview.

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 the story behind it, see the blog post on linking a legacy system to a modern AI agent.

Copied