mcpField
R
Redmine Fastmcp Server With Oauth

Redmine Fastmcp Server With Oauth

Remote
github.com/tuzumkuruDeveloper Tools10Updated 1w ago
Repository

About Redmine Fastmcp Server With Oauth

Redmine Fastmcp Server With Oauth is a centrally deployed MCP server for Redmine, aimed at teams whose users authenticate through Redmine OAuth. It keeps Redmine access tokens server-side and provides tools, prompts, and resources for issues, projects, time entries, and wikis.

Key features

  1. 01OAuth 2.0 user authorization through Redmine
  2. 02Search, list, create, and update issues
  3. 03Manage projects and project versions
  4. 04Read and update wiki pages
  5. 05Access time entries and Redmine resources

Use cases

  1. 01Search issues and inspect their details
  2. 02Create or update issues with user authorization
  3. 03Review project versions and time entries
  4. 04Retrieve or revise project wiki pages

MCP support

Exposes Redmine operations as MCP tools, prompts, and resources over Streamable HTTP. Clients receive a FastMCP-issued JWT; Redmine OAuth tokens remain on the server.

Configuration

Remote servers need no local install. Pick your client, then copy the config or install in one click.

Endpoint<<YourServerURL>>
Copy install command
Claude CodeTerminal
Cursor.cursor/mcp.json
VS Code.vscode/mcp.json
Claude Desktopclaude_desktop_config.json
Windsurf~/.codeium/windsurf/mcp_config.json

Run commands in a terminal; paste JSON into the client’s MCP config and restart. Servers that need sign-in will prompt on first connect.

Tools

Details

From the project README

mcp-redmine-oauth — Redmine FastMCP Server with OAuth

A centrally-deployed MCP server for Redmine with OAuth 2.0 authentication. An administrator deploys it once; users connect by authorizing through Redmine — no API keys or per-user setup required. Built with FastMCP 3.

How it works

MCP Client (Claude Desktop, MCP Inspector, …)
        │  MCP over Streamable HTTP
        │  Authorization: Bearer <fastmcp-jwt>
        ▼
┌─────────────────────────────┐
│      FastMCP 3 Server       │
│  OAuthProxy (port 8000)     │──── token exchange ────▶ Redmine OAuth
│  Token store (in-memory)    │◀─── access token ────────
│                             │
│  Tools                      │──── REST API ───────────▶ Redmine API
└─────────────────────────────┘

The MCP client only ever sees a FastMCP-issued JWT. The Redmine OAuth token is stored server-side and never exposed to the client.

Prerequisites

  • Python 3.11+
  • A running Redmine 6.1+ instance with REST API enabled
  • An OAuth application registered in Redmine (see below)

Redmine Setup

1. Enable the REST API

Administration → Settings → API → Enable REST web service (check and save).

2. Register an OAuth Application

Administration → Applications → New Application

FieldValue
Redirect URIhttp://<MCP_BASE_URL>/auth/callback
Confidential clientYes
ScopesEnable all required scopes for full functionality

Copy the generated Client ID, Client Secret.

Setup

git clone https://github.com/tuzumkuru/mcp-redmine-oauth.git
cd mcp-redmine-oauth
cp .env.example .env

Fill in your values:

REDMINE_URL=http://your-redmine-host
REDMINE_CLIENT_ID=your-client-id
REDMINE_CLIENT_SECRET=your-client-secret

Running

pip install -e .
mcp-redmine-oauth

The MCP server will be available at http://localhost:8000/mcp.

To test with MCP Inspector:

npx @modelcontextprotocol/inspector

Open http://localhost:6274, set transport to Streamable HTTP, and enter http://localhost:8000/mcp.

Running with Docker

docker compose up --build

The container reads configuration from .env. Make sure MCP_BASE_URL is set to the externally-reachable URL of the server (not localhost if clients connect from other machines).

Set MCP_HOST_PORT in .env to change the host-side port (default 8000).

Environment Variables

VariableRequiredDefaultDescription
REDMINE_URLYes—Base URL of your Redmine instance
REDMINE_CLIENT_IDYes—OAuth app Client ID
REDMINE_CLIENT_SECRETYes—OAuth app Client Secret
REDMINE_SCOPESNo(all declared)Allowlist filter: space-separated scopes your Redmine app supports (see Scope Handling)
MCP_HOSTNo0.0.0.0Bind host
MCP_PORTNo8000Bind port
MCP_BASE_URLNohttp://localhost:MCP_PORTPublic-facing URL used for OAuth redirects
REDMINE_PUBLIC_URLNoREDMINE_URLRedmine URL as users open it in a browser, used in draft links. Set it when the server reaches Redmine at an internal address

Available Tools & Resources

ComponentTypeRequired ScopesDescription
get_issue_detailsToolview_issuesFetch a Redmine issue by ID with description, custom fields, and journals
search_issuesToolview_issues, search_projectFull-text search across issues with pagination
list_issuesToolview_issuesList issues with filters (project, assignee, status, tracker, sort)
get_issue_relationsToolview_issuesGet issue relations (blocking, blocked-by, related, etc.)
get_project_detailsToolview_projectProject details with trackers, categories, and enabled modules
get_project_versionsToolview_projectProject versions/milestones with status and due dates
list_time_entriesToolview_time_entriesList time entries with filters (project, user, date range)
create_issueTooladd_issuesCreate a new issue with subject, tracker, priority, assignee, etc.
update_issueTooledit_issuesUpdate an existing issue (status, assignee, notes, etc.)
create_projectTooladd_projectCreate a new Redmine project
update_projectTooledit_projectUpdate project name, description, visibility, trackers
get_wiki_pageToolview_wiki_pagesGet a wiki page from a project
update_wiki_pageTooledit_wiki_pagesCreate or update a wiki page
rename_wiki_pageToolrename_wiki_pagesRename a wiki page with optional redirect
draft_new_issueTool(login only)Link to Redmine's new-issue form filled in with the proposed values; nothing is saved until the user submits
draft_issue_updateTool(login only)Link to an issue's edit form with the proposed changes and comment filled in, plus a link to the issue page
draft_new_projectTool(login only)Link to Redmine's new-project form filled in; works only for users allowed to add projects, or subprojects of the parent
summarize_ticketPromptview_issuesGenerate a concise summary of an issue with next steps
draft_bug_reportPromptview_projectDraft a structured bug report from rough notes
redmine://projects/activeResourceview_projectList active projects
redmine://trackersResourceview_projectList available trackers
redmine://issue-statusesResourceview_issuesAll issue statuses with IDs and closed flags
redmine://enumerations/prioritiesResourceview_issuesIssue priority levels with IDs
redmine://users/meResource(auth only)Current authenticated user profile

Planned: persistent token storage, dynamic tool disabling by scope, structured logging.

Required Redmine Scopes

Enable these scopes on your Redmine OAuth application (Administration → Applications). They are grouped by the Redmine category as shown in the application settings.

Project
Redmine PermissionScope IdentifierUsed By
View projectsview_projectget_project_details, get_project_versions, redmine://projects/active, redmine://trackers, draft_bug_report
Search projectssearch_projectsearch_issues
Create projectadd_projectcreate_project
Edit projectedit_projectupdate_project
Issue tracking
Redmine PermissionScope IdentifierUsed By
View Issuesview_issuesget_issue_details, search_issues, list_issues, get_issue_relations, redmine://issue-statuses, redmine://enumerations/priorities, summarize_ticket
Add issuesadd_issuescreate_issue
Edit issuesedit_issuesupdate_issue
Time tracking
Redmine PermissionScope IdentifierUsed By
View spent timeview_time_entrieslist_time_entries
Wiki
Redmine PermissionScope IdentifierUsed By
View wikiview_wiki_pagesget_wiki_page
Edit wiki pagesedit_wiki_pagesupdate_wiki_page
Rename wiki pagesrename_wiki_pagesrename_wiki_page

If a scope is not enabled, the tools that require it will return a descriptive error at call time.

Scope Handling

Each tool and resource declares its required OAuth scopes via the @requires_scopes decorator. The server automatically collects all declared scopes and requests them during OAuth authorization.

If your Redmine OAuth app is configured with only a subset of the scopes above, set REDMINE_SCOPES to avoid the error "The requested scope is invalid, unknown, or malformed":

REDMINE_SCOPES=view_issues view_project

When set, only the intersection of tool-declared scopes and REDMINE_SCOPES is requested. Tools whose scopes aren't fully covered (e.g. search_issues needs search_project) will return a descriptive error at call time instead of breaking the entire OAuth flow.

When omitted, all tool-declared scopes are requested — this works when your Redmine app has all of them enabled.

Architecture

See docs/architecture.md for the detailed OAuth flow, token storage, and module design.

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.