redmine-mcp-server

Duplicate an existing Redmine issue with optional field overrides. Uses Redmine's native copy mechanism (``copy_from`` parameter) which preserves the original issue's fields while allowing selected overrides.

Create a new issue in Redmine. Open a ticket, file a bug, submit a feature request, log a support case, or report a task. Use this tool to create a single issue with a subject and optional description, plus any standard or custom fields (``tracker_id``, ``status_id``, ``priority_id``, ``assigned_to_id``, ``fixed_version_id``, ``parent_issue_id``, ``start_date``, ``due_date``, custom field values, etc.). For duplicating an existing issue see ``copy_issue``; for editing an existing issue see ``update_redmine_issue``. Compatibility notes: - Supports serialized ``fields`` payload (JSON object string) - Supports optional ``extra_fields`` payload as object/JSON string - Retries once with auto-filled required custom fields if Redmine reports relevant validation errors on required custom fields (e.g. blank/invalid) and ``REDMINE_AUTOFILL_REQUIRED_CUSTOM_FIELDS=true``. - When ``REDMINE_TAGS_ENABLED=true``, a ``tag_list`` key in ``fields`` (list of names or comma-separated string) sets AlphaNodes additional_tags tags on the new issue. Requires the ``create_issue_tags``/``edit_issue_tags`` permission; silently ignored when the feature is disabled (default). - A custom field goes in ``fields`` by name (``{"Department": "Sales"}``) or by id as ``cf_<id>`` (``{"cf_2": "Sales"}``), the ids being those ``list_project_issue_custom_fields`` returns. Either form is checked against the project's fields first, and nothing is written when it fails: an id the project does not enable is refused, and so is a name that matches no field and has spaces or capitals or is within a typo of a field name. The refusal names the project's fields. - Any other snake_case ``fields`` key is sent as a top-level attribute, which Redmine ignores without an error if it does not know it. Such keys are listed in ``unverified_fields``, omitted when there are none.

Reserve a slot for a file on the caller's own machine, and say where to send it. Use this whenever the file to attach lives on the caller's side. It is the only route that does not put the file's bytes through the conversation: there is no way to pipe a file into a tool argument, so a ``content_base64`` payload is written out character by character by the model, and a payload of a few thousand characters does not reliably survive that (#305). Three steps: 1. Call this. It answers with ``upload_url``, ``ticket`` and ``expires_at``. 2. Send the file to ``upload_url`` in one HTTP request, with the ticket in the ``X-Upload-Ticket`` header and the file as the body:: curl -sS -H "X-Upload-Ticket: TICKET" --data-binary @file.png URL The response carries ``upload_id``, ``size`` and ``sha256``. Multipart is deliberately not accepted: the whole body would be buffered before its size could be checked. 3. Name that ``upload_id`` as the content source: in ``uploads`` on ``create_redmine_issue`` / ``update_redmine_issue`` / ``manage_redmine_wiki_page``, or on ``upload_file``. The ticket is good for one upload, for a few minutes (``REDMINE_MCP_UPLOAD_TICKET_MINUTES``, default 15), up to ``max_bytes``. It authorises nothing else. The staged file is swept on the same expiry as a downloaded attachment, so a failed attach can be retried without sending the file again. Only the user who called this can name the ``upload_id`` afterwards; anyone else is told it does not exist. If the server cannot tell who that user is, it refuses the ticket rather than reserve a slot anyone could read.

Delete a file from a Redmine project. **Important:** Redmine's ``DELETE /attachments/{id}.json`` endpoint removes ANY attachment by ID, not just project files. If ``file_id`` refers to an issue/wiki attachment (e.g., from ``get_redmine_issue(include_attachments=True)``), that attachment will be deleted from its issue. To avoid accidentally removing issue attachments when you meant to remove a project file, the tool verifies the target attachment is project-scoped (its ``container_type`` is ``Project``) before deleting. Pass ``confirm_delete_any_attachment=True`` to bypass this check when you explicitly want to delete an issue/wiki attachment.

Hard-delete an issue via ``DELETE /issues/{id}.json``. Issue deletion in Redmine is **irreversible** and cascades to the issue's children (subtasks), journals (comments), attachments, time entries, and inbound relations from issues that referenced it. To prevent accidental destruction, this tool refuses unless the caller passes ``confirm_delete=True``; the refusal envelope includes a structured ``impact`` preview (counts of cascaded items) so a caller can decide whether to proceed. If the issue has subtasks, ``confirm_delete=True`` alone is not enough -- the tool also requires ``confirm_delete_with_children=True`` so the cascade-delete of subtasks is opt-in twice. This is the case most likely to surprise a caller. For other lifecycle operations on an issue, use: - ``create_redmine_issue`` to create - ``update_redmine_issue`` to edit fields (including status, priority, custom fields) - ``copy_issue`` to duplicate - ``get_redmine_issue`` to read

Hard-delete a news item via ``DELETE /news/{id}.json``. Deletion is **irreversible** and takes the item's comments and attachments with it. Like the other destructive tools here, this one refuses unless ``confirm_delete=True``, and the refusal carries a preview of what would be lost. Needs a Redmine that exposes the news write endpoints, as core Redmine has since 4.1. For the other operations use ``manage_redmine_news`` (create, update), ``get_redmine_news`` or ``list_redmine_news``.

Retrieve the currently authenticated user's profile. Resolves to ``GET /users/current.json`` under the hood. Works for any authenticated user, not admin-only. Useful when an LLM needs to identify "me" — for example, when a user says "log 2h on this issue for me", the LLM can call this tool to get the current user's ID. With ``include_memberships`` it also answers "which projects am I a member of, and with which roles" in that same request. The only other way to get that is ``list_project_members`` once per project. Each membership is ``{id, project: {id, name}, roles: [{id, name}]}``. A role held through a group carries ``inherited: true``; Redmine omits the key for a role held directly, and so does this tool -- so test for the key, do not expect ``inherited: false``. Redmine limits the list to projects visible to the caller, which covers active and closed projects but not archived ones: an empty list means none visible, not necessarily none held.

Retrieve project timeline (Gantt) data: issues with dates, dependencies, and milestones. Composite tool that aggregates ``GET /issues.json`` (with relations) and ``GET /projects/{id}/versions.json`` into a single structured response suitable for timeline analysis. Returns structured data, not an image. Use cases: "What's the current timeline for project X?", "Which issues are overdue?", "Show me the dependency chain on this project". Uses the core Redmine REST API only — no plugin required. Performance note: Redmine paginates issues at 25 per HTTP call by default, so a request for ``limit=500`` can trigger ~20 underlying API calls. Expect a few seconds of latency on large projects.

Return the MCP server's version, enabled-feature flags, and current user. Use this tool to: - Detect deployment lag: compare ``server_version`` against the release you expect before relying on a recently-shipped fix. - Understand who ``"me"`` resolves to: ``current_user`` shows the identity behind the configured API key. When a shared or robot API key is in use, ``assigned_to_id="me"`` will match **that** account, not the human operator — call this tool first if issue queries assigned to "me" return unexpectedly empty results. - Check which plugin-gated tool families are active.

Retrieve only the private notes/journals of a Redmine issue. Fetches the issue's journals and filters for entries where ``private_notes`` is true. The authenticated user must have the "View private notes" permission for non-empty results.

Backend data source for the project dashboard's Refresh button. Returns the same payload as ``show_project_dashboard`` without a UI resource; the dashboard's iframe calls this over ``tools/call``. Pass the same arguments the dashboard was opened with, so a refresh redraws the same view. Read-only.

Retrieve the enabled modules for a Redmine project. Modules control which features are visible/usable in a project (e.g., ``issue_tracking``, ``time_tracking``, ``wiki``, ``repository``).

Backend data source for the project timeline's Refresh button. Returns the same payload as ``show_project_timeline`` without a UI resource; the timeline's iframe calls this over ``tools/call`` with the arguments the view was opened with. Read-only.

Download a Redmine attachment and return a usable reference to it. Downloads the attachment to local disk and returns either an HTTP URL (when the server has a publicly reachable hostname configured) or an absolute local file path (in stdio mode). The caller does not need to know which mode is active. **HTTP mode** (any explicit ``PUBLIC_HOST``, or a non-loopback ``SERVER_HOST``): Returns a dict with ``uri``, ``uri_type: "http"``, filename, content_type, size, expires_at, and attachment_id. An explicit ``PUBLIC_HOST=localhost`` also selects this mode so Docker port-forwarded deployments produce a URL the host can reach. **stdio mode** (``REDMINE_MCP_TRANSPORT=stdio``, neither variable set, or only ``SERVER_HOST`` set to a loopback bind address): Returns a dict with ``file_path`` (absolute), ``uri_type: "file"``, filename, content_type, size, expires_at, and attachment_id. The path can be passed directly to Claude Code's ``Read`` tool or pdf-mcp. The file on disk is named ``attachment_<file_id><ext>``, not after the attachment, so to upload the download again with ``upload_file``, pass the returned ``filename`` as ``filename``; that tool otherwise names the attachment after the path. Downloads are capped at ``ATTACHMENT_MAX_DOWNLOAD_BYTES`` (default 200 MB). Files are cleaned up automatically by the background cleanup manager.

Retrieve a specific Redmine issue by ID. Fetch issue details, view a ticket, show a bug report, get issue with comments, journals, attachments, or related metadata. Use this tool to pull a single issue with full context: comments (journals), attachments, custom fields, watchers, relations, subtasks/children, and (when ``REDMINE_AGILE_ENABLED=true``) agile metadata. For listing or filtering across multiple issues see ``list_redmine_issues``; for text search across issues see ``search_redmine_issues``.

Retrieve one news item, with its comments and attachments.

Backend data source for the triage board's Refresh button. Returns the same payload as ``show_triage_board`` without a UI resource; the board's iframe calls this over ``tools/call``. Pass the same arguments the board was opened with, so a refresh redraws the same view. Read-only.

Bulk import multiple time entries in a single call. **Use this tool (NOT ``manage_time_entry(action="create")`` in a loop) whenever the user asks to:** - import a timesheet / weekly timesheet / monthly report - bulk log, batch log, or log multiple entries at once - import several entries, or any list of 2+ time entries - backfill time across many issues or dates - log the same activity for multiple team members at once - log a day's work spanning multiple issues **Prefer this tool over calling ``manage_time_entry(action="create")`` N times** -- it reports partial failures via a ``succeeded``/``failed`` summary and supports ``stop_on_error`` for transactional-style behaviour. Calling ``manage_time_entry(action="create")`` in a loop gives no aggregate feedback and cannot continue past per-entry errors gracefully. Redmine has no native bulk-import endpoint, so this tool creates each entry individually via ``POST /time_entries.json`` under the hood. Per-entry errors are captured and returned alongside successes so a partial import still yields useful feedback. Each entry must be a dict with the standard ``manage_time_entry(action="create")`` fields: ``hours`` (required), plus at least one of ``project_id``/``issue_id``. Optional fields: ``user_id`` (to log on behalf of a teammate), ``activity_id``, ``comments``, ``spent_on``.

List all files uploaded to a Redmine project. Returns file metadata (id, filename, size, content type, description, download URL, author, optional version/release) for every file uploaded under Project > Files. Note: This lists files from Redmine's core "Files" module (enabled per project via Settings > Modules > Files). It does NOT list issue attachments (use ``get_redmine_issue`` with ``include_attachments=True`` for those) and does NOT list DMSF documents (pending separate tools).

List the ids and names of the issue custom fields enabled for a project. Against a stock Redmine only ``id`` and ``name`` carry data. ``field_format``, ``is_required``, ``multiple``, ``default_value``, ``possible_values`` and ``trackers`` come back ``null``, meaning "not readable on this token" -- ``null`` is not ``false`` and not an empty list. In particular ``is_required: null`` does not mean a field is optional, so a create or update can still reject on a field listed here. To set a field, key it in ``fields`` by name or as ``cf_<id>`` with an id from here, or pass ``extra_fields={"custom_fields": [{"id": N, "value": ...}]}``.

List members of a Redmine project. Returns all users and groups that are members of the specified project, along with their assigned roles. A role that comes from a group the user belongs to, or from the parent project when this one inherits members, carries ``inherited: true``; Redmine omits the key for a role held directly, and so does this tool -- so test for the key, do not expect ``inherited: false``. A role held both ways appears twice on the same row, once with the key and once without.

List the trackers (issue types) enabled for a specific Redmine project. Unlike ``list_redmine_trackers`` (which returns every tracker defined in the instance), this returns only the trackers available on the given project. Use it to discover valid ``tracker_id`` values before creating an issue in that project.

List all issue priority levels defined in the Redmine instance. Use this tool to discover valid ``priority_id`` values before calling ``create_redmine_issue`` or ``update_redmine_issue``.

List all issue statuses defined in the Redmine instance. Use this tool to discover valid ``status_id`` values before calling ``update_redmine_issue``. You can also pass a status name via the ``status_name`` field in ``update_redmine_issue``, which internally resolves the ID.

List Redmine issues with flexible filtering and pagination support. A general-purpose tool for listing issues from Redmine. Supports filtering by project, status, assignee, tracker, priority, and any other Redmine issue filter. Use this to list all issues in a project, find unassigned issues, or apply any combination of filters. A call with no filter returns the open issues of every project the caller can see, 25 per call, each with its full description. Scope a read with ``project_id`` or another filter, and pass ``fields`` when descriptions are not needed.

List Redmine news (project announcements), newest first. Without ``project_id`` this spans every project the caller can see. Comments and attachments are not included -- the list endpoint does not serve them; use ``get_redmine_news`` for one item's full context.

Lists accessible projects in Redmine. Returns ONLY active projects unless ``filters`` says otherwise. Redmine's ``ProjectQuery`` starts out with a ``status = 1`` filter already set, so a call that passes no ``status`` answers with active projects alone while looking like the whole list. Pass ``filters={"status": "1|5"}`` to get closed projects alongside active ones. ``status`` takes only the ``=`` and ``!`` operators, so ``"*"`` is not a way to ask for every status -- it would be read as a literal value and match nothing. ``filters`` narrows the collection server-side. A filter Redmine cannot read is not an error there -- it answers 200 with the collection unnarrowed -- so check the result against what was asked for. With ``include_custom_fields`` this is the only tool that returns project custom field *values*, which are a different set from the issue custom fields ``list_project_issue_custom_fields`` covers. No tool exposes custom field *definitions* -- ``field_format``, ``is_required``, ``possible_values`` -- for either set: Redmine serves those to administrators only.

List all saved custom queries visible to the current user. Custom queries are saved issue filters (defined via the Redmine web UI). Once discovered, the ``id`` can be passed to ``list_redmine_issues`` via a ``query_id`` filter to run the query. Note: This tool only READS queries. Redmine's REST API does not support creating, updating, or deleting saved queries.

List all roles defined in the Redmine instance. Returns basic role metadata (``id`` and ``name``) for every role configured in Redmine. Use this tool BEFORE calling ``add_project_member`` or ``update_project_member`` to discover the correct ``role_ids`` — role IDs vary between Redmine instances and must not be guessed.

List all trackers (issue types) defined in the Redmine instance. Trackers classify issues (e.g., Bug, Feature, Support). Use this tool to discover valid ``tracker_id`` values before calling ``create_redmine_issue`` or ``update_redmine_issue``.

List Redmine users with optional filtering. Admin permission is required to list all users. Non-admin users may receive a 403. Use this tool to discover valid user IDs (e.g., for assignment, watchers, or time-entry authoring).

List versions (roadmap milestones) for a Redmine project.

List subtasks (child issues) of a given Redmine issue. Retrieves all issues whose ``parent_issue_id`` equals the given ``issue_id``. To create a new subtask, use ``create_redmine_issue`` with the ``parent_issue_id`` field set.

List time entries from Redmine with filtering and pagination. Retrieve time entries with optional filtering by project, issue, user, and date range. Supports pagination for handling large result sets.

List available time entry activities from Redmine. Returns activity types that can be used when creating or updating time entries (e.g., Development, Design, Testing). When called without ``project_id``, returns all global activity types. When called with ``project_id``, returns project-specific activities via ``GET /projects/:id.json?include=time_entry_activities`` (Redmine 3.4.0+). Project-specific IDs differ from global ones — always use project-scoped activities when logging time against a specific project to avoid ``"Activity is not included in the list"`` errors.

List, create, update, or delete a Redmine issue category.

Edit text or toggle privacy of a Redmine journal (issue note). Both actions are writes and are blocked in read-only mode.

List, create, or delete a Redmine issue relation.

Add or remove a watcher on a Redmine issue. Requires Redmine 2.3.0+.

Add, update, or remove a Redmine project membership.

Create or update a Redmine news item (project announcement). Needs a Redmine that exposes the news write endpoint -- core Redmine has since 4.1. A server without it answers with an error rather than silently doing nothing. Deleting is a separate tool, ``delete_redmine_news``, so a deployment can offer announcements without offering their destruction.

Create a Redmine project, edit its settings, or close and reopen it. Use this tool to set up a new project, rename one, change its description, homepage, parent, visibility, enabled modules, trackers or custom field values, or to close a finished project and reopen it later. A closed project stays visible and readable but accepts no edits. This tool writes the project record itself. Its contents have their own tools: ``manage_redmine_version`` for versions, ``manage_project_member`` for memberships, ``manage_issue_category`` for issue categories. Archiving is not offered. Redmine gates ``archive`` and ``unarchive`` on administrator rights rather than on a project permission, so no non-admin token can reach them. Deleting is not offered either: it destroys every issue, wiki page and file in the project and in each of its subprojects.

Create, update, or delete a Redmine version (milestone/roadmap entry).

List, get, create, update, delete, or rename a Redmine wiki page.

Create or update a Redmine time entry.

Search for issues, wiki pages and news across the Redmine instance.

Search Redmine issues matching a query string with pagination support. Performs text search across issues using the Redmine Search API (/search.json), then transparently hydrates the matching ids via /issues.json so structured fields (subject, status, priority, project, assigned_to, author, timestamps) are populated in the response. The follow-up fetch is skipped when ``fields`` only requests id and/or description, which /search.json can serve on its own. Supports server-side pagination to prevent MCP token overflow.

Show a live project dashboard (health snapshot) for a project. Use this whenever the user wants an overview, snapshot, health check, or "how is project X doing" view: open vs closed counts, overdue and due-this-week issues, an open-by-priority breakdown, and recent activity. Natural requests include: "how is <project> doing", "show the dashboard for <project>", "project overview / health / status at a glance", or "what needs attention in <project>". Renders an interactive dashboard in clients that support MCP Apps; other clients receive the same structured data. Prefer ``summarize_project_status`` when the user wants a written narrative summary, and ``show_triage_board`` when they want to work issues in a board. Read-only.

Show a project's schedule as an interactive timeline (Gantt view). Use this when the user wants a timeline, schedule, roadmap, or Gantt view, or asks when a version ships or what is planned over a period: "show the timeline for <project>", "what is the schedule this quarter", "when does v3.0 ship". Issues are drawn as bars from their start and due dates, grouped by target version, with a milestone on each version's due date and a Done section for recently closed work. Renders in clients that support MCP Apps; other clients receive the same structured data. Prefer ``get_gantt_chart`` for raw timeline data or dependency analysis, ``show_project_dashboard`` for a health snapshot, and ``show_triage_board`` to work issues on a board. Read-only. Dates use the server's UTC day.

Show a project's issues as a live, interactive board (Kanban view). Use this whenever the user wants to see, view, browse, open, or triage a project's issues visually instead of as a text list. Natural requests that should call this tool include: "show me the board", "open the issue board for <project>", "give me a kanban / board view", "let me see project X's issues", "triage <project>", "what's the status breakdown for <project>", or any ask to display, visualize, or get an overview of a project's issues. Renders the issues grouped into columns by status in clients that support interactive MCP Apps; other clients still receive the same structured data. Prefer this over ``list_redmine_issues`` when the goal is to look at or work through a project's issues; use ``list_redmine_issues`` when the user explicitly wants a plain list or is filtering issues to feed another step. Read-only.