Skip to main content
Glama

mcp-redmine

CI License: MIT Python 3.10+

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:

    1. In Redmine, go to Administration → Settings → API and enable "Enable REST web service" (if not already on).

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

uv tool install mcp-redmine-rest

With pip

pip install mcp-redmine-rest

From 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

REDMINE_URL

Yes

Base URL of your Redmine instance (no trailing slash).

REDMINE_API_KEY

Yes

Your API access key, from My account → API access key.

REDMINE_TIMEOUT

No

Per-request timeout in seconds. Defaults to 15.

REDMINE_UPLOAD_ROOTS

No

Directories the file-upload tools may read from, separated by os.pathsep (; on Windows, : on Linux/macOS). Unset = uploads disabled. See Security.

REDMINE_SSL_VERIFY

No

Verify the Redmine server's TLS certificate. Defaults to true. Set to false only for a trusted self-signed/internal cert you cannot otherwise validate — this disables protection against man-in-the-middle attacks on that connection.

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=15

The 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.json

  • Windows: %APPDATA%\Claude\claude_desktop_config.json

  • Linux: ~/.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-rest

Confirm with:

claude mcp list

Cline (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-rest

If 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

list_issues, get_issue, create_issue, update_issue, bulk_update_issues, delete_issue, add_watcher, remove_watcher, update_journal_note

Issue relations

list_issue_relations, create_issue_relation, delete_issue_relation, chain_issues

Projects

list_projects, get_project, create_project, update_project, archive_project

Project members

list_project_members, add_project_member, update_project_member, remove_project_member

Versions

list_project_versions, create_project_version, update_version, delete_version

Categories

list_project_categories, create_project_category, update_project_category, delete_project_category

Users

get_current_user, list_users, get_user, create_user, update_user, update_my_account

Groups

list_groups, get_group, create_group, update_group, delete_group, add_user_to_group, remove_user_from_group

Roles

list_roles, get_role

Wiki

list_wiki_pages, get_wiki_page, create_or_update_wiki_page, attach_file_to_wiki_page, delete_wiki_page

Time tracking

list_time_entries, get_time_entry, log_time, update_time_entry, delete_time_entry, list_time_entry_activities

Attachments

attach_file_to_issue, get_attachment, update_attachment, delete_attachment

Project files

list_project_files, upload_project_file

News

list_news, get_news_item, create_news, update_news, delete_news

Search

search, list_saved_queries

Metadata

list_statuses_and_priorities, list_trackers, list_custom_fields, list_document_categories

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 env block 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_role shows 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

MIT

Available Tools

73 tools
add_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

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

    A3.9/5.0

    Scored across 73 tools

    Disambiguation5/5

    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.

    Naming Consistency5/5

    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.

    Tool Count4/5

    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.

    Completeness4/5

    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

    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.
      -
    • 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
      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
      1
      MIT