mcp-redmine
The mcp-redmine server connects AI agents to a Redmine instance via its REST API, exposing 73 tools for natural-language management of projects, issues, users, and more.
Issue Management: Create, read, update (including bulk updates), and delete issues; manage watchers and journal notes.
Issue Relations: List, create, and delete relations (
blocks,precedes, etc.); chain a sequence of issues in one call.Project Administration: Create, update, archive/unarchive projects; manage members, versions (milestones), categories, and project files.
User & Group Management: Create, list, update users (lock instead of delete, user deletion intentionally omitted); update own account; create, update, delete groups; add/remove users from groups.
Roles: List roles and get detailed permissions for a role.
Wiki: List pages, read with version history, create/update with nesting support, attach files, delete pages.
Time Tracking: Log, list, get, update, delete time entries; list available time entry activities.
Attachments: Attach local files to issues or wiki pages; get, update (rename/describe), and delete attachments.
Project Files: List and upload files to a project’s Files tab.
News: List, get, create, update, delete project news items.
Search & Saved Queries: Perform full-text search across the instance or a specific project; list saved queries.
Metadata: List issue statuses, priorities, trackers, custom fields, and document categories.
Safety & Constraints: Project and user deletion tools are intentionally excluded (use archiving or locking). File uploads are disabled by default unless REDMINE_UPLOAD_ROOTS is configured to prevent prompt injection. Passwords are never passed through the conversation. Central error handling provides readable messages.
Provides tools for interacting with a Redmine instance, enabling AI agents to manage issues, projects, wiki pages, time tracking, users, groups, and more through the Redmine REST API.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@mcp-redmine List open issues in the Website project assigned to me."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
mcp-redmine
A Model Context Protocol server that connects Claude (Desktop or Code) — or any other MCP client — to a Redmine instance through its REST API.
It exposes 73 tools covering, in practice, the entire stable Redmine REST API: issues, relations, projects, memberships, versions, categories, users, groups, roles, wiki, time tracking, attachments, project files, news, and search. Point your agent at a Redmine project and let it read and manage issues, log time, edit wiki pages, and administer users — all through natural conversation.
Features
Full read/write coverage of issues, including bulk updates, relations, watchers, and comments.
Project administration: create/update/archive projects, manage members, versions, and categories.
User and group administration, with deliberately no "delete user" or "delete project" tool — see Security.
Wiki, including nested pages and file attachments.
Time tracking, attachments, project files, news, and full-text search.
Readable errors: every failure comes back as a clear sentence pulled from Redmine's own validation response, not a raw stack trace.
Nothing to run: a single Python process talking stdio to your MCP client — no database, no server to host, no Docker required.
Related MCP server: redmine-mcp
Prerequisites
Python 3.10+
A Redmine instance with the REST API enabled:
In Redmine, go to Administration → Settings → API and enable "Enable REST web service" (if not already on).
Go to My account → API access key and copy the value.
Installation
The distribution is published as mcp-redmine-rest, and the command it
installs is mcp-redmine-rest. The shorter mcp-redmine name on PyPI belongs
to an unrelated project — don't
install that one expecting this server.
If you're pointing an AI agent at this repository to do the setup for you, llms-install.md is written for exactly that.
With uv (recommended)
uv tool install mcp-redmine-restWith pip
pip install mcp-redmine-restFrom source
git clone https://github.com/alsimoes/mcp-redmine-rest.git
cd mcp-redmine-rest
python3 -m venv venv && source venv/bin/activate # Linux/Mac
pip install -e .On Windows, use py and PowerShell rather than a Git Bash/WSL shell — creating
or recreating the venv from a Unix-style shell on Windows overwrites
venv\pyvenv.cfg with a Unix home path, and every subsequent launch of
venv\Scripts\python.exe fails with No Python at '/usr/bin\python.exe' (or
similar):
git clone https://github.com/alsimoes/mcp-redmine-rest.git
cd mcp-redmine-rest
py -3 -m venv venv
.\venv\Scripts\Activate.ps1
pip install -e .Configuration
The server reads its configuration from environment variables:
Variable | Required | Description |
| Yes | Base URL of your Redmine instance (no trailing slash). |
| Yes | Your API access key, from My account → API access key. |
| No | Per-request timeout in seconds. Defaults to 15. |
| No | Directories the file-upload tools may read from, separated by |
| No | Verify the Redmine server's TLS certificate. Defaults to |
Keeping the key out of the client configuration
Values missing from the environment are read from a .env file, so the API
key does not have to sit in plain text in your MCP client's configuration.
Copy .env.example to .env in the repository root and fill it in — every
variable in the table above is honoured, so the client's env block can be
dropped entirely:
REDMINE_URL=https://redmine.example.com
REDMINE_API_KEY=your_api_key_here
REDMINE_TIMEOUT=15The file is gitignored. Variables already present in the environment always
win, so an env block in your client's configuration still overrides it. To
keep the file somewhere else, set REDMINE_ENV_FILE to its full path.
This matters on Claude Desktop in particular: it launches MCP servers with a
minimal environment it builds itself, so variables you export in your shell
or set with setx never reach the server. Use the env block or a .env
file.
Claude Desktop
Edit (or create) the Claude Desktop configuration file:
Mac:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.jsonLinux:
~/.config/Claude/claude_desktop_config.json
{
"mcpServers": {
"redmine": {
"command": "mcp-redmine-rest",
"env": {
"REDMINE_URL": "https://redmine.example.com",
"REDMINE_API_KEY": "your_api_key_here"
}
}
}
}If you installed from source instead of via uv tool install / pip install, point command at the interpreter in your virtual environment and
pass the script as an argument:
{
"mcpServers": {
"redmine": {
"command": "/full/path/to/mcp-redmine/venv/bin/python",
"args": ["-m", "mcp_redmine"],
"env": {
"REDMINE_URL": "https://redmine.example.com",
"REDMINE_API_KEY": "your_api_key_here"
}
}
}
}On Windows, point command at venv\Scripts\python.exe (with \\ escaped
in JSON):
{
"mcpServers": {
"redmine": {
"command": "C:\\full\\path\\to\\mcp-redmine\\venv\\Scripts\\python.exe",
"args": ["-m", "mcp_redmine"],
"env": {
"REDMINE_URL": "https://redmine.example.com",
"REDMINE_API_KEY": "your_api_key_here"
}
}
}
}Restart Claude Desktop afterwards. The tools icon (🔨) should show the Redmine tools as available.
Claude Code
claude mcp add redmine \
--env REDMINE_URL=https://redmine.example.com \
--env REDMINE_API_KEY=your_api_key_here \
-- mcp-redmine-restConfirm with:
claude mcp listCline (VS Code)
Open the MCP settings from the palette — Ctrl+Shift+P → Cline: Open MCP
Config File — or click the gear next to "MCP Servers" in the Cline sidebar
and choose Configure MCP Servers. Either one opens
cline_mcp_settings.json; add the server there:
{
"mcpServers": {
"redmine": {
"command": "mcp-redmine-rest",
"env": {
"REDMINE_URL": "https://redmine.example.com",
"REDMINE_API_KEY": "your_api_key_here"
}
}
}
}Use the palette command rather than editing the file by hand — it lives deep
in VS Code's global storage
(.../User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json),
and the path differs per platform.
If mcp-redmine-rest is not on the PATH that VS Code sees, use the module
form instead — "command" pointing at the interpreter that has the package
installed, with "args": ["-m", "mcp_redmine"], exactly like the Claude
Desktop examples above.
Reload the window (Ctrl+Shift+P → Developer: Reload Window) and the server
should come up as connected under "MCP Servers". A longer walkthrough,
covering the workspace .mcp.json and the Add-Server UI, is in
CLINE_SETUP.md.
Other MCP clients
Any client that can launch a local process and speak MCP over stdio works the
same way: run mcp-redmine-rest (or python -m mcp_redmine) with
REDMINE_URL and REDMINE_API_KEY set in its environment.
Run locally (optional)
Useful for a quick sanity check before wiring the server into a client:
cp .env.example .env # then edit .env with your values
export $(grep -v '^#' .env | xargs) # or use a tool like direnv
mcp-redmine-restIf there's no connection error, the server is ready — it waits for MCP messages on stdin/stdout, so seeing nothing happen in the terminal is normal. Press Ctrl+C to stop it.
Usage examples
Once configured, just talk to the agent:
"List the open issues assigned to me in the Website project."
"Create a bug in Website titled 'Login button unresponsive on mobile', priority high."
"Move issues #101, #104, and #110 to In Progress and assign them to Alice."
"Log 3.5 hours on issue #204 for today, activity Development."
"What's on the wiki page 'Deployment' for the Infra project?"
"Search for 'timeout' across all projects."
Available tools
73 tools, grouped by resource. The full reference — signatures, parameters,
return shape, and the caveats that matter (like how precedes reschedules
issues, or that list_custom_fields requires an administrator) — lives in
docs/TOOLS.md.
Resource | Tools |
Issues |
|
Issue relations |
|
Projects |
|
Project members |
|
Versions |
|
Categories |
|
Users |
|
Groups |
|
Roles |
|
Wiki |
|
Time tracking |
|
Attachments |
|
Project files |
|
News |
|
Search |
|
Metadata |
|
API coverage
Redmine API resource | Status |
Issues | Complete (list, read, create, update, bulk, delete, watchers) |
Issue relations | Complete |
Projects | Complete minus deletion |
Project members | Complete |
Versions | Complete |
Issue categories | Complete |
Users | Complete minus deletion |
Groups | Complete |
Roles | Complete (the API is read-only) |
Wiki | Complete, including nesting and attachments |
Attachments | Complete |
Project files | Complete |
News | Complete |
Time tracking | Complete |
Search and saved queries | Complete |
Trackers, statuses, priorities, activities, custom fields | Complete (the API is read-only) |
Document categories | Complete (the API is read-only) |
The two omissions are deliberate. delete_project and delete_user are
irreversible and take other people's content down with them — issues, time
entries, wiki pages, authorship. archive_project and update_user with
status=3 cover the real use case reversibly. Deleting for real remains a web
UI operation, where confirmation is explicit and human. See
SECURITY.md for the full reasoning.
Trackers, issue statuses, priorities, and roles have no write operations in the Redmine API — they're configurable only in Administration. That's not a gap in this server.
Outside the stable REST API, and therefore outside this server's scope: repositories and changesets, wiki page protection, and instance-wide settings screens.
Error messages
Errors are handled centrally: when Redmine rejects a call, the server reads
the response body — that's where the real explanation lives, in the errors
field — and returns that sentence. Without a useful body, it falls back to
the HTTP status with a likely reason:
Status | Message |
401 | invalid or missing API key |
403 | not allowed to perform this operation, or the module is disabled for this project |
404 | not found (check the ID, or this endpoint may not exist in this Redmine version) |
409 | conflict — the resource was changed by someone else |
422 | Redmine rejected the data during validation |
This applies to every tool, read and write alike.
Troubleshooting
"REDMINE_URL and REDMINE_API_KEY must be set": the server checks its configuration at startup and exits immediately with this message rather than starting up broken. Check the
envblock in your MCP client's configuration.Every call fails with a network error: confirm the server process can actually reach
REDMINE_URL— MCP clients run the server as a local process, so it needs the same network access as your machine, not the browser.401 on every call: the API key is wrong, or "Enable REST web service" is off in Redmine's settings.
403 on a specific tool: usually a missing permission on the role of the user who owns the API key.
get_roleshows exactly which permissions a role has.A tool responds 404 that you'd expect to work: a few endpoints (
update_journal_note,update_news/delete_news,update_attachment) were added in specific Redmine versions — see docs/TOOLS.md for the minimum version of each.
Security
See SECURITY.md for the full model. In short: an API key grants access equivalent to the user who owns it, so create a dedicated Redmine user with a role scoped to what you want the agent to do, and use that user's key — don't try to limit the agent by editing this server's code.
File uploads are disabled until you set REDMINE_UPLOAD_ROOTS. The
three tools that upload a local file (attach_file_to_issue,
attach_file_to_wiki_page, upload_project_file) refuse every path by
default, precisely because an agent can be steered by injected content
(an issue comment, a wiki page) into uploading a file it was never meant to
read. See SECURITY.md.
Contributing
See CONTRIBUTING.md.
License
Available Tools
73 toolsadd_project_memberB
Add a user as a project member, with one or more roles.
Args: project_identifier: project identifier. user_id: user ID (use list_users). role_ids: list of role IDs (use list_roles).
Inputs: user_id (required), role_ids (required), project_identifier (required). Returns: result
add_user_to_groupA
Add a user to a group, without touching the other members.
Args: group_id: group ID. user_id: user ID.
Inputs: user_id (required), group_id (required). Returns: result
add_watcherA
Add a watcher to an issue.
Args: issue_id: issue ID. user_id: ID of the user to add as a watcher (use list_users).
Inputs: user_id (required), issue_id (required). Returns: result
archive_projectA
Archive or unarchive a project.
An archived project becomes read-only and disappears from listings, without losing anything. It's the reversible alternative to deletion, which this server deliberately does not expose — deletion is irreversible and takes issues, time entries, and wiki content with it. Deleting a project for real is a web UI operation.
Args: project_identifier: project identifier. archive: True archives, False unarchives.
Inputs: project_identifier (required), archive. Returns: result
attach_file_to_issueA
Attach a local file to an issue.
Uploads the file and links it to the issue right after — the two steps Redmine's API requires, in a single call.
The path is resolved on the machine running this MCP server.
Args: issue_id: issue ID. file_path: full path of the file on the server's machine. description: attachment description, shown next to its name. comment: note to add to the history along with the attachment. file_name: display name in Redmine (empty = use the file's own name).
Inputs: issue_id (required), file_path (required), comment, file_name, +1 more. Returns: result
attach_file_to_wiki_pageA
Attach a file to an existing wiki page.
The page's text is preserved: this tool reads the current content and rewrites it together with the attachment, because Redmine's endpoint replaces the whole page.
The path is resolved on the machine running this MCP server.
Args: project_identifier: project identifier. title: title of the page that will receive the attachment. file_path: full path of the file on the server's machine. comment: edit comment, shown in the page's history. file_name: display name (empty = use the file's own name).
Inputs: title (required), file_path (required), project_identifier (required), comment, +1 more. Returns: result
bulk_update_issuesA
Apply the same change to several issues at once.
Useful when the change is identical across issues — moving a batch of cards to a new status, fixing the category for a whole set, assigning a version. There is no equivalent for creation: each issue has its own content, so batching creation would not save anything.
This does not abort on the first error: it tries every issue and reports each individual result.
Every field besides issue_ids uses the same "leave alone" sentinels as update_issue: 0 for IDs, empty string for text and dates, -1 for percentage and hours.
Args: issue_ids: IDs of the issues to change. status_id: new status ID (0 = leave alone). notes: comment appended to each issue's history. priority_id: new priority (0 = leave alone). tracker_id: new tracker (0 = leave alone). category_id: new category (0 = leave alone). fixed_version_id: new target version (0 = leave alone). assigned_to_id: new assignee (0 = leave alone). start_date: new start date, YYYY-MM-DD (empty = leave alone). due_date: new due date, YYYY-MM-DD (empty = leave alone). done_ratio: 0 to 100 (-1 = leave alone). estimated_hours: estimated effort in hours (-1 = leave alone). custom_fields: map of {field_id: value}, e.g. {"1": "5"}.
Inputs: issue_ids (required), notes, due_date, status_id, +9 more. Returns: result
chain_issuesA
Chain a list of issues in sequence.
The first relates to the second, the second to the third, and so on. Useful for enforcing the execution order of a set of tasks without opening the relations form once per pair.
Args: issue_ids: IDs in the desired order (e.g. [22, 25, 49, 51]). relation_type: same set as create_issue_relation. Defaults to 'precedes'. delay: gap in days; only applies to 'precedes' and 'follows'.
Does not abort on the first error: it tries every pair and reports each result. Safe to re-run — Redmine rejects a duplicate relation with 422, which shows up as an error for that pair without affecting the others.
Inputs: issue_ids (required), delay, relation_type. Returns: result
create_groupA
Create a user group.
A group grants permissions to several people at once: add it as a project member and every member inherits the roles.
Args: name: group name. user_ids: initial members' IDs (optional).
Inputs: name (required), user_ids. Returns: result
create_issueA
Create a new issue in Redmine.
Args: project_identifier: project identifier (e.g. 'my-project'). subject: issue title. description: detailed description. tracker_id: tracker ID (varies per instance; use list_trackers). priority_id: priority ID (use list_statuses_and_priorities). status_id: status ID (0 = use the workflow's initial status). category_id: category ID (use list_project_categories). fixed_version_id: target version ID (use list_project_versions). assigned_to_id: assignee's user ID. parent_issue_id: parent issue ID, to create this as a subtask. start_date: start date, YYYY-MM-DD format. due_date: due date, YYYY-MM-DD format. estimated_hours: estimated effort in hours (-1 = not provided). custom_fields: map of {field_id: value}, e.g. {"1": "5"}. Use list_custom_fields to discover the IDs.
Every field besides project and subject is optional; anything not provided is left to the project's defaults.
Inputs: subject (required), project_identifier (required), due_date, status_id, +10 more. Returns: result
create_issue_relationA
Create a relation between two issues.
Args: issue_id: source issue ID. target_issue_id: target issue ID. relation_type: relates, precedes, follows, blocks, blocked, duplicates, duplicated, copied_to, copied_from. delay: gap in days; only applies to 'precedes' and 'follows'.
Warning: 'precedes' and 'follows' are date-driven — creating the relation makes Redmine reschedule the following issue, pushing its start date forward. Use 'relates' when you only want to link the issues without touching dates.
Inputs: issue_id (required), target_issue_id (required), delay, relation_type. Returns: result
create_newsA
Publish a news item in a project.
News is visible to every project member and triggers an email notification according to the instance's configuration — not a silent draft.
Args: project_identifier: project identifier. title: news title. description: news body. summary: summary line shown in the listing.
Inputs: title (required), description (required), project_identifier (required), summary. Returns: result
create_or_update_wiki_pageA
Create a new wiki page, or update an existing one.
Redmine uses the same PUT endpoint for both cases.
Args: project_identifier: project identifier. title: page title (e.g. 'Home'). text: content in Markdown or Textile, depending on the instance's configuration (Administration -> Settings -> General -> Text formatting). comment: comment about the edit (shows up in the page's history). parent_page: title of the page that should become this one's parent, to nest it in the wiki index. Empty = leave the current nesting alone; on a new page, leaves it at the root.
Inputs: text (required), title (required), project_identifier (required), comment, +1 more. Returns: result
create_projectA
Create a project.
Args: name: display name. identifier: URL identifier — lowercase letters, digits, and hyphens, immutable after creation. description: project description. parent_project_id: parent project ID, to create this as a subproject. is_public: whether it's visible to non-member users. The default here is private, more conservative than Redmine's own default.
Inputs: name (required), identifier (required), is_public, description, +1 more. Returns: result
create_project_categoryA
Create an issue category in a project.
Args: project_identifier: project identifier. name: category name (e.g. 'Infrastructure'). assigned_to_id: user assigned by default to issues in this category (0 = none).
Inputs: name (required), project_identifier (required), assigned_to_id. Returns: result
create_project_versionA
Create a version (milestone) in a project.
Args: project_identifier: project identifier. name: version name (e.g. 'v0.1 - Identity'). description: free-text description. status: 'open', 'locked', or 'closed'. due_date: version date, YYYY-MM-DD format.
Inputs: name (required), project_identifier (required), status, due_date, +1 more. Returns: result
create_userA
Create a user. Requires administrator privileges.
The password is generated by Redmine itself and emailed to the person — this tool deliberately does not accept a password as a parameter, so no credential ever passes through the conversation. To set the password manually instead, use the Redmine web UI.
Args: login: username for authentication. firstname: first name. lastname: last name. email: email address, also used to send the credentials. admin: grants administrator privileges. send_information: sends the email with the generated password. Only turn this off if you'll set the password another way — without it, the person cannot log in.
Inputs: email (required), login (required), lastname (required), firstname (required), +2 more. Returns: result
delete_attachmentA
Permanently delete an attachment. The file is removed from the server's disk.
Args: attachment_id: attachment ID.
Inputs: attachment_id (required). Returns: result
delete_groupA
Delete a group.
The users themselves keep existing; they only lose the permissions that came from it.
Args: group_id: group ID.
Inputs: group_id (required). Returns: result
delete_issueA
Permanently delete an issue.
WARNING: this is irreversible and takes the issue's subtasks, time entries, and history with it. Redmine has no trash can. Prefer moving to a closed status (e.g. Cancelled) when the goal is only to take it off the board.
Args: issue_id: ID of the issue to delete.
Inputs: issue_id (required). Returns: result
delete_issue_relationA
Delete a relation between issues by the relation's ID.
Args: relation_id: relation ID (from the 'id' field in list_issue_relations).
Inputs: relation_id (required). Returns: result
delete_newsB
Delete a news item. Available since Redmine 5.1.
Args: news_id: news item ID.
Inputs: news_id (required). Returns: result
delete_project_categoryA
Delete an issue category.
Issues that used the category are left without one, unless you give another category to receive them.
Args: category_id: ID of the category to delete. reassign_to_id: ID of the category that receives the orphaned issues (0 = leave them without a category).
Inputs: category_id (required), reassign_to_id. Returns: result
delete_time_entryB
Delete a time entry by ID.
Inputs: time_entry_id (required). Returns: result
delete_versionA
Delete a version. Issues that reference it are left without a target version.
To take a version out of circulation without losing the historical link, prefer update_version with status='closed'.
Args: version_id: ID of the version to delete.
Inputs: version_id (required). Returns: result
delete_wiki_pageA
Delete a wiki page (and its sub-pages, per Redmine's default behavior).
Args: project_identifier: project identifier. title: title of the page to delete.
Inputs: title (required), project_identifier (required). Returns: result
get_attachmentA
Show an attachment's details: name, size, type, author, and download URL.
Args: attachment_id: attachment ID (shown in get_issue, in the 'attachments' list).
Inputs: attachment_id (required). Returns: result
get_current_userA
Return the user that owns the API key configured on this server.
Useful for confirming which identity issues are being created under, and whether that user is an administrator.
Inputs: no named parameters. Returns: result
get_groupA
Show a group's details: its members and the projects it belongs to.
Args: group_id: group ID.
Inputs: group_id (required). Returns: result
get_issueA
Return every detail of an issue.
Includes the description, attachments, relations, watchers, and subtasks.
Args: issue_id: issue ID. include_history: also fetch the comments and change log. Turn this off for long issues when only the current field values matter.
Inputs: issue_id (required), include_history. Returns: result
get_news_itemA
Show a news item's full text and comments.
Args: news_id: news item ID (use list_news).
Inputs: news_id (required). Returns: result
get_projectA
Show a project's details: description, enabled modules, trackers, and categories.
Args: project_identifier: project identifier.
Inputs: project_identifier (required). Returns: result
get_roleA
Show a role's details, including the full list of granted permissions.
Useful for understanding why an operation is being refused, before trying again.
Args: role_id: role ID (use list_roles).
Inputs: role_id (required). Returns: result
get_time_entryA
Show a time entry's details.
Args: time_entry_id: time entry ID (use list_time_entries).
Inputs: time_entry_id (required). Returns: result
get_userB
Show a user's details.
Includes which projects they belong to and with which role.
Args: user_id: user ID.
Inputs: user_id (required). Returns: result
get_wiki_pageA
Read the content of a specific wiki page.
Args: project_identifier: project identifier. title: page title (e.g. 'Home'). Case-sensitive, as in Redmine. version: version number to read (0 = most recent).
Inputs: title (required), project_identifier (required), version. Returns: result
list_custom_fieldsA
List the custom fields visible through the API.
Each entry has an ID, format, and what it applies to. Needed to fill in 'custom_fields' in create_issue and update_issue.
Requires the API key's user to be an administrator.
Inputs: no named parameters. Returns: result
list_document_categoriesA
List the instance's document categories, with their IDs.
These belong to the Documents module; if it's disabled for a project, the list still exists but has no practical use there.
Inputs: no named parameters. Returns: result
list_groupsA
List the instance's user groups. Requires administrator privileges.
Inputs: no named parameters. Returns: result
list_issue_relationsB
List an issue's relations (precedes, blocks, related to, and so on).
Args: issue_id: issue ID.
Inputs: issue_id (required). Returns: result
list_issuesA
List Redmine issues, with filters.
Args: project_identifier: project identifier. Empty = all projects. status: 'open', 'closed', '*' (all), or the ID of a specific status. limit: maximum issues per page. Redmine caps this at 100. tracker_id: filter by tracker (use list_trackers). category_id: filter by category (use list_project_categories). fixed_version_id: filter by target version (use list_project_versions). assigned_to_id: filter by assignee. author_id: filter by who created the issue. parent_issue_id: return the subtasks of an issue. subject_contains: text contained in the subject (partial match). created_after: YYYY-MM-DD, issues created on or after this date. created_before: YYYY-MM-DD, issues created on or before this date. updated_after: YYYY-MM-DD, issues updated on or after this date. custom_fields: map of {field_id: value}, e.g. {"1": "8"}. sort_by: field and direction, e.g. 'priority:desc', 'updated_on:desc', 'id:asc'. Several can be comma-separated. offset: how many issues to skip — use together with 'limit' to paginate. query_id: run a saved query (use list_saved_queries). When given, the other filters are ignored by Redmine.
Returns: JSON with the total number of matching issues (not just this page), so it's possible to tell whether pagination is needed without guessing.
Inputs: limit, offset, status, sort_by, +13 more. Returns: result
list_newsA
List news items.
Args: project_identifier: restrict to a project (empty = all). limit: maximum number of news items.
Inputs: limit, project_identifier. Returns: result
list_project_categoriesA
List a project's issue categories, with their IDs.
Args: project_identifier: project identifier (e.g. 'my-project').
Inputs: project_identifier (required). Returns: result
list_project_filesA
List the files published under a project's Files tab.
Not to be confused with issue attachments: these are project-level artifacts — builds, installers, documents — optionally tied to a version.
Args: project_identifier: project identifier.
Inputs: project_identifier (required). Returns: result
list_project_membersA
List a project's members and each one's roles.
Args: project_identifier: project identifier.
Inputs: project_identifier (required). Returns: result
list_projectsA
List every project available in Redmine.
Inputs: no named parameters. Returns: result
list_project_versionsC
List a project's versions (milestones), with their IDs.
Args: project_identifier: project identifier.
Inputs: project_identifier (required). Returns: result
list_rolesA
List the instance's roles, with their IDs.
Inputs: no named parameters. Returns: result
list_saved_queriesA
List the saved queries (filters) visible to the API key's user.
Args: project_identifier: restrict to a project's queries (empty = all).
Inputs: project_identifier. Returns: result
list_statuses_and_prioritiesA
List the issue statuses and priority levels available on this instance.
Inputs: no named parameters. Returns: result
list_time_entriesA
List time entries, with optional filters.
Args: project_identifier: filter by project (identifier or id). issue_id: filter by a specific issue (0 = ignore this filter). user_id: filter by user; use 'me' for the API key's own user. start_date: minimum date, YYYY-MM-DD format. end_date: maximum date, YYYY-MM-DD format. limit: maximum number of entries returned.
Inputs: limit, user_id, end_date, issue_id, +2 more. Returns: result
list_time_entry_activitiesA
List the activity types available for logging time.
For example: Development, Design, Support.
Inputs: no named parameters. Returns: result
list_trackersA
List the instance's trackers (issue types), with their IDs.
IDs vary per instance — use this tool before create_issue instead of assuming Redmine's default values.
Inputs: no named parameters. Returns: result
list_usersA
List Redmine users.
Requires administrator privileges.
Args: status: 1 = active, 2 = registered awaiting activation, 3 = locked. name: filter by login, first name, last name, or email (partial match). limit: maximum number of users returned.
Inputs: name, limit, status. Returns: result
list_wiki_pagesA
List every wiki page of a project.
Args: project_identifier: project identifier (e.g. 'my-project').
Inputs: project_identifier (required). Returns: result
log_timeA
Log time spent, tied to either an issue or a project.
Args: hours: amount of time worked (e.g. 2.5). date: date the work was done, YYYY-MM-DD format. issue_id: issue ID (use this OR project_identifier, not both). project_identifier: project identifier (if not tying this to a specific issue). activity_id: activity type ID (varies per instance; use list_time_entry_activities to see the options). comment: description of what was done.
Inputs: date (required), hours (required), comment, issue_id, +2 more. Returns: result
remove_project_memberA
Remove a member from a project.
The user loses access, but what they created remains — issues, comments, and time entries stay recorded under their name.
Args: membership_id: membership ID (the 'membership_id' field in list_project_members), not the user's ID.
Inputs: membership_id (required). Returns: result
remove_user_from_groupC
Remove a user from a group.
Args: group_id: group ID. user_id: user ID.
Inputs: user_id (required), group_id (required). Returns: result
remove_watcherA
Remove a watcher from an issue.
Args: issue_id: issue ID. user_id: ID of the user to remove.
Inputs: user_id (required), issue_id (required). Returns: result
searchA
Search for text across issues, wiki pages, news, and other Redmine objects.
Args: query: text to search for. project_identifier: restrict to a project (empty = the whole instance). titles_only: search titles only, not the body. open_issues_only: restrict to open issues. all_words: require every word in the query; False = match any of them. limit: maximum number of results.
Inputs: query (required), limit, all_words, titles_only, +2 more. Returns: result
update_attachmentA
Rename an attachment or change its description, without re-uploading it.
Available since Redmine 5.0; older versions respond with 404.
Args: attachment_id: attachment ID. file_name: new display name (empty = leave alone). description: new description (empty = leave alone).
Inputs: attachment_id (required), file_name, description. Returns: result
update_groupA
Update a group.
Args: group_id: group ID. name: new name (empty = leave alone). user_ids: new, COMPLETE list of members — anyone not in it is removed from the group. To add one person without touching the rest, use add_user_to_group.
Inputs: group_id (required), name, user_ids. Returns: result
update_issueA
Update an existing issue. Only changes the fields that are provided.
Args: issue_id: ID of the issue to update. status_id: new status ID (0 = leave alone). notes: comment to add to the history (does not replace the description). subject: new title (empty = leave alone). description: new description — REPLACES the existing one entirely. priority_id: new priority (0 = leave alone). tracker_id: new tracker (0 = leave alone). category_id: new category (0 = leave alone). fixed_version_id: new target version (0 = leave alone). assigned_to_id: new assignee (0 = leave alone). parent_issue_id: new parent issue (0 = leave alone). start_date: new start date, YYYY-MM-DD (empty = leave alone). due_date: new due date, YYYY-MM-DD (empty = leave alone). done_ratio: 0 to 100 (-1 = leave alone). estimated_hours: estimated effort in hours (-1 = leave alone). custom_fields: map of {field_id: value}, e.g. {"1": "5"}.
"Leave alone" sentinels: 0 for IDs, empty string for text and dates, -1 for percentage and hours. There is no way to clear a field through this tool — to blank out a date or remove an assignee, use the Redmine web UI.
Inputs: issue_id (required), notes, subject, due_date, +12 more. Returns: result
update_journal_noteA
Edit the text of a comment already posted to an issue's history.
The journal ID is the 'id' field of each entry in 'journals', visible via get_issue — not to be confused with the issue ID.
This endpoint is marked alpha in the Redmine documentation and may not exist in older versions; a 404 usually means that.
Args: journal_id: ID of the history entry (journal). text: new text for the comment.
Inputs: text (required), journal_id (required). Returns: result
update_my_accountA
Update the account of the user that owns the API key.
Args: firstname: new first name (empty = leave alone). lastname: new last name (empty = leave alone). email: new email (empty = leave alone).
Inputs: email, lastname, firstname. Returns: result
update_newsA
Update a published news item.
Available since Redmine 5.1; older versions respond with 404.
Args: news_id: news item ID. title: new title (empty = leave alone). description: new body (empty = leave alone). summary: new summary (empty = leave alone).
Inputs: news_id (required), title, summary, description. Returns: result
update_projectA
Update a project. Only changes the fields that are provided.
The 'identifier' cannot be changed after creation — that's a Redmine limitation, not one of this server.
Args: project_identifier: project identifier. name: new display name (empty = leave alone). description: new description (empty = leave alone). homepage: project URL (empty = leave alone).
Inputs: project_identifier (required), name, homepage, description. Returns: result
update_project_categoryA
Update an issue category.
Args: category_id: category ID (use list_project_categories). name: new name (empty = leave alone). assigned_to_id: new default assignee (0 = leave alone).
Inputs: category_id (required), name, assigned_to_id. Returns: result
update_project_memberA
Replace a member's roles.
The given list becomes the complete list — any role not in it is removed.
Args: membership_id: membership ID (the 'membership_id' field in list_project_members), not the user's ID. role_ids: new, complete list of role IDs.
Inputs: role_ids (required), membership_id (required). Returns: result
update_time_entryA
Update an existing time entry.
Args: time_entry_id: ID of the time entry to update. hours: new hours value (0 = leave alone). comment: new comment (empty = leave alone). activity_id: new activity ID (0 = leave alone).
Inputs: time_entry_id (required), hours, comment, activity_id. Returns: result
update_userA
Update a user. Requires administrator privileges.
Locking is the reversible alternative to deletion: the user loses access but everything they created stays attributed to them. This server does not expose user deletion for that reason — deleting for real is still a web UI operation.
Args: user_id: user ID. login: new login (empty = leave alone). firstname: new first name (empty = leave alone). lastname: new last name (empty = leave alone). email: new email (empty = leave alone). status: 1 = active, 3 = locked (0 = leave alone). admin: 1 grants, 0 revokes, -1 leaves alone.
Inputs: user_id (required), admin, email, login, +3 more. Returns: result
update_versionA
Update an existing version. Only changes the fields that are provided.
Args: version_id: version ID (use list_project_versions). name: new name (empty = leave alone). description: new description (empty = leave alone). status: 'open', 'locked', or 'closed' (empty = leave alone). Closing a version removes it from the choices offered to new issues, without affecting the ones that already reference it. due_date: new date, YYYY-MM-DD (empty = leave alone).
Inputs: version_id (required), name, status, due_date, +1 more. Returns: result
upload_project_fileA
Publish a file under a project's Files tab.
The path is resolved on the machine running this MCP server.
Args: project_identifier: project identifier. file_path: full path of the file on the server's machine. description: description shown in the listing. version_id: ties the file to a version (0 = none). file_name: display name (empty = use the file's own name).
Inputs: file_path (required), project_identifier (required), file_name, version_id, +1 more. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 73 tools
Every tool targets a distinct resource and action; even the two file-uploading tools (attach_file_to_issue, upload_project_file) are clearly separated by destination, and create_or_update_wiki_page is explicit about its dual nature. No two tools appear to do the same thing.
All tools follow a verb_noun (or verb_adjective_noun) snake_case convention; the few composite verbs like chain_issues and bulk_update_issues still fit the pattern. No camelCase or mixed styles.
With 73 tools, this is a large surface, but it mirrors the breadth of Redmine's API across projects, issues, wiki, news, users, groups, time entries, and more. Every tool addresses a specific endpoint or workflow, so the count is justified even if it feels heavy for an agent.
The coverage is comprehensive across the main Redmine resources, including lifecycle operations for issues, projects, versions, categories, users, groups, wiki pages, news, and time entries. Minor gaps remain — the Documents module only exposes categories, not document files, and there is no way to manage project modules or issue workflows.
Maintenance
Related MCP Connectors
One MCP server for all your MCP servers: code mode, per-tool permissions, approvals and audit.
MCP Server for JFrog, providing tools for development and artifact management.
2,000+ MCP servers read at source level. Know what one does before you connect. Free, no key.
Remote MCP server for managing Muninx tickets, messages, ticket search, and support analytics.
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.-
- 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
- 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.891MIT
- AlicenseNot gradedqualityCmaintenanceMCP server for Redmine that enables interaction with issues, wiki pages, and time entries through natural language.ISC