Redmineflux MCP

Introduction #

Redmineflux MCP Server is an AI integration layer that connects your Redmine project management instance directly to AI assistants such as Claude by Anthropic. Using the Model Context Protocol (MCP) standard, it gives AI tools real-time, two-way access to your Redmine data — issues, projects, time entries, checklists, sprints, helpdesk tickets, workload data, and more.

MCP Integration is available on the Pro Plan and above.

Visit redmineflux.com/cloud-redmine-pricing to view plans and upgrade.

Instead of manually searching Redmine, copying data into a chat window, or writing reports by hand, your team can simply ask an AI assistant questions like:

• “What are my critical issues today?”
• “Log 2 hours on issue #1023 for development work.”
• “Show the agile board for the Mobile App project.”
• “Create a sprint named ‘Release 2.1’ with a 2-week duration.”
• “Which team members are over-allocated this week?”

Redmineflux MCP handles the translation between natural language and Redmine API calls automatically — with full permission enforcement, user-friendly error messages, and support for every Redmineflux plugin included in your plan.

What is MCP (Model Context Protocol)? #

Model Context Protocol (MCP) is an open standard developed by Anthropic that allows AI models to securely connect to external tools, data sources, and APIs. Think of it as a universal plug between an AI assistant and any software product.

When an MCP server is connected to an AI client (such as Claude Desktop or Claude.ai), the AI can:

• Read data from the connected system (e.g., list Redmine issues, view project stats)
• Write data back to the system (e.g., create issues, log time, update statuses)
• Execute actions on behalf of the user (e.g., move a card on the agile board, approve a timesheet)

All communication goes through your hosted Redmineflux MCP server. Your Redmine credentials never leave your infrastructure — the AI only receives the formatted data it needs to answer your question.

Supported AI Clients:

Client	How It Connects
Claude Desktop (Mac)	Via the mcp-remote bridge tool
Claude Desktop (Windows)	Via the mcp-remote bridge tool
Claude.ai Web	Direct connection, built into Claude.ai’s Integrations settings
Claude Code (CLI / VS Code)	Direct HTTP connection, no bridge tool needed
Any other MCP-compatible client	Direct HTTP connection (consult your client’s MCP documentation)

System Requirements #

AI Client Requirements #

Client	Minimum Version
Claude Desktop	Latest (download from claude.ai)
Claude Code CLI	Latest (npm install -g @anthropic-ai/claude-code)
Claude.ai	Web browser, any modern browser
Node.js (Claude Desktop only)	18 or higher — needed to run the mcp-remote bridge via npx

Network Requirements #

• Your AI client machine needs outbound HTTPS access to your Redmineflux MCP server URL (see Finding Your MCP Server URL)
• No inbound access, public URL of your own, or port-forwarding is required — Redmineflux hosts the server for you

How Redmineflux MCP Works #

User Prompt (natural language)
│
▼
AI Assistant (Claude)
│ selects the right tool
▼
Redmineflux MCP Server
│ calls Redmine REST API
▼
Your Redmine Instance
│ returns data
▼
MCP Server formats response
│
▼
AI Assistant presents result to user

Step-by-step flow:

1. User types a request in the AI chat (e.g., “Show open bugs in the Mobile project”)
2. Claude selects the most relevant MCP tool (e.g., redmineflux_core_list_issues)
3. The MCP server sends an authenticated REST API call to your Redmine instance
4. Redmine returns the raw JSON data
5. The MCP server formats it into a readable response
6. Claude presents the formatted result to the user

Plugin detection at startup:

When the MCP server starts, it automatically probes your Redmine instance to detect which Redmineflux plugins are installed. Only tools for detected plugins are registered. If Timesheet Plugin is not installed, timesheet tools are not shown. This prevents confusion from tools that would always return errors.

Finding Your MCP Server URL #

Every Redmineflux Cloud account has its own unique MCP server URL. Find yours in your Redmineflux Cloud dashboard under Integrations → MCP Server. It will look something like this:

https://acme-corp.redmineflux.com/mcp

Note: This is only an example — your actual URL will use your own account’s subdomain, shown on the Integrations page. Wherever this guide shows <YOUR_MCP_SERVER_URL>, replace it with your own URL from that page.

How To: Connect Claude Desktop (Mac / Windows) #

Claude Desktop connects to your Redmineflux MCP server through a small bridge tool called mcp-remote (no separate install needed — it runs automatically via npx when Claude Desktop starts).

Step 1 — Locate the Config File #

macOS:

~/Library/Application Support/Claude/claude_desktop_config.json

Windows:

%APPDATA%\Claude\claude_desktop_config.json

Step 2 — Edit the Config File #

Open the file in a text editor and add the Redmineflux MCP server entry inside the mcpServers object:

{
"mcpServers": {
"redmineflux": {
"command": "npx",
"args": [
"mcp-remote@0.1.17",
"<YOUR_MCP_SERVER_URL>",
"--transport",
"http-only",
"--header",
"X-Redmine-API-Key: <YOUR_API_KEY>"
]
}
}
}

Worked example: if your MCP server URL is https://acme-corp.redmineflux.com/mcp and your API key is a1b2c3d4e5, the entry becomes:

{
"mcpServers": {
"redmineflux": {
"command": "npx",
"args": [
"mcp-remote@0.1.17",
"https://acme-corp.redmineflux.com/mcp",
"--transport",
"http-only",
"--header",
"X-Redmine-API-Key: a1b2c3d4e5"
]
}
}
}

Step 3 — Restart Claude Desktop #

Close and reopen Claude Desktop. The first connection briefly fetches mcp-remote via npx, then the Redmineflux MCP tools become available.

Step 4 — Verify Connection #

In a new Claude conversation, type:

“Show me my Redmine projects”

If the connection is successful, Claude will return your project list.

Note: This requires Node.js 18+ installed on your machine, so npx can run.

How To: Connect Claude.ai Web App #

Claude.ai’s web interface connects directly to your Redmineflux MCP server — no bridge tool or self-hosting needed.

Step 1 — Add to Claude.ai Settings #

1. Open claude.ai in your browser
2. Click your profile picture → Settings
3. Navigate to Integrations → Model Context Protocol
4. Click Add Integration
5. Enter your MCP server URL (see Finding Your MCP Server URL) — for example, https://acme-corp.redmineflux.com/mcp
6. Click Connect

Step 2 — Authenticate #

When prompted, provide your Redmine API key. Every request you make carries your key, so your actions are always authenticated with your own Redmine account and permissions — even if your whole team connects to the same Redmineflux MCP server.

How To: Connect Claude Code (CLI / VS Code) #

Claude Code connects directly to your Redmineflux MCP server over HTTP — no bridge tool needed. You can register it for one project only, or globally for every project you open.

Option A — Add via Claude Code CLI #

For the current project only:

claude mcp add redmineflux --transport http <YOUR_MCP_SERVER_URL> --header "X-Redmine-API-Key: <YOUR_API_KEY>"

For every project (recommended for most users):

claude mcp add redmineflux --transport http --scope user <YOUR_MCP_SERVER_URL> --header "X-Redmine-API-Key: <YOUR_API_KEY>"

Worked example (global, all projects): if your MCP server URL is https://acme-corp.redmineflux.com/mcp and your API key is a1b2c3d4e5:

claude mcp add redmineflux --transport http --scope user https://acme-corp.redmineflux.com/mcp --header "X-Redmine-API-Key: a1b2c3d4e5"

Option B — Edit the Config File Manually #

Project-only: create or edit .claude/mcp.json in your project folder:

{
"mcpServers": {
"redmineflux": {
"type": "http",
"url": "<YOUR_MCP_SERVER_URL>",
"headers": {
"X-Redmine-API-Key": "<YOUR_API_KEY>"
}
}
}
}

Global, all projects: edit ~/.claude.json (Windows: %USERPROFILE%\.claude.json) and add the same entry under the top-level mcpServers key.

Step — Verify in VS Code #

1. Open VS Code with the Claude extension installed
2. Open the Claude panel (sidebar)
3. Start a new conversation and type: “List my Redmine projects”
4. Claude will use the MCP tools to fetch and display your projects

How To: Get Your Redmine API Key #

The Redmine API key authenticates all MCP requests on your behalf. Each user has their own unique key.

1. Log in to your Redmine instance
2. Click your username in the top-right corner
3. Select My Account
4. Scroll to the API access key section at the bottom right
5. Click Show to reveal the key
6. Click Reset to generate a new key if needed
7. Copy the key and paste it into your MCP configuration

Important: Treat your API key like a password. Do not share it or commit it to version control. The MCP server uses this key to perform all actions — it has the same permissions as your Redmine user account.

How To: Use MCP Tools in a Conversation #

Once connected, you can interact with Redmine entirely through natural language. Claude automatically selects the right tool for your request.

Example Commands #

Issues:

• “Show all open bugs in the Mobile App project”
• “Create a new issue: ‘Fix login timeout’ in the API project, assign to John”
• “Update issue #1042 status to In Progress”
• “What are my critical issues today?”

Time Tracking:

• “Log 2.5 hours on issue #1023 for development”
• “Show time entries for the past week in the Backend project”

Agile Board:

• “Show the agile board for project ztflux”
• “Move issue #1042 to Done column”
• “Create a sprint named ‘Sprint 5’ for 2 weeks”
• “List all sprints in the Mobile project”

Workload:

• “Who is over-allocated this week?”
• “Show capacity for the development team”
• “Add a holiday on December 25th to the Default scheme”

Timesheet:

• “Submit my timesheet for this week”
• “Show pending timesheet approvals”
• “Approve timesheet for user vaishnavi.bhawsar”

Helpdesk:

• “List all open support tickets”
• “Create a new ticket from customer@example.com”
• “Show SLA status for ticket #205”

Knowledge Base:

• “List all spaces in the knowledge base”
• “Create a new KB page titled ‘API Setup Guide’ in the Dev space”

Checklists:

• “Add a checklist to issue #1042 called ‘Code Review'”
• “Mark all checklist items in checklist #5 as done”

Test Cases:

• “Create a test run for the Login module”
• “List all failed test cases in the current sprint”

DevOps:

• “Show recent commits for the Backend project”
• “List open pull requests”
• “Trigger a build for the main branch”

How To: Check Which Plugins Are Detected #

The MCP server detects installed plugins automatically at startup. To see which plugins are active in your current session:

1. In any Claude conversation, type: “Which Redmineflux plugins are detected?” or “Show the MCP server version and installed plugins”
2. Claude will call the redmineflux_system_version tool and display output like:

Plugins detected: agile, crm, helpdesk, invoice, timesheet, workload
Core Redmine tools: always available

Tip: Only the plugins actually installed and enabled on your Redmine instance will appear — the example above shows a sample, not the full list of every plugin that exists. If a plugin you expect to see is missing, verify it is installed and enabled in Redmine at Administration → Plugins.

Plugin Tools Overview #

Redmineflux MCP provides tools for both core Redmine functionality and every Redmineflux plugin: Agile Board, Workload, Timesheet, Helpdesk, Checklist, Knowledge Base, Issue Template, Invoice, CRM, Tags, Budget & Audit, Testcase Management, and DevOps. Core tools are always available; plugin tools are auto-detected based on which plugins are installed on your Redmine instance.

With every plugin installed, the MCP server provides over 500 tools covering every aspect of project management — from creating issues and logging time to managing sprints, approving timesheets, and handling support tickets.

Permissions Setup in Redmine #

The MCP server operates with the permissions of the Redmine user whose API key is configured. To use all features, the user must have the appropriate Redmine roles and permissions.

Minimum Permissions for Full MCP Access #

Navigate to: Administration → Roles and Permissions → [Your Role] → Save

Permission	Required For
view_issues	Reading issues, checklists, search
add_issues	Creating new issues
edit_issues	Updating issues, checklists, tags
delete_issues	Deleting issues
log_time	Logging time entries
view_time_entries	Viewing time reports
edit_project	Archiving/unarchiving and editing project settings
view_agile_board	Reading agile board data
manage_agile_board_settings	Managing columns, board settings
manage_sprints	Creating/updating sprints
manage_tags, view_tags	Creating, updating, deleting, and viewing tags
manage_issues_tags, manage_project_tags, manage_time_entries_tags	Tagging issues, projects, and time entries
view_issue_templates	Listing and viewing templates
create_issue_templates, apply_issue_templates	Creating and applying project/global templates
edit_issue_templates	Editing templates
delete_issue_templates	Deleting templates
manage_helpdesk	Helpdesk SLA, holiday, organization, and support-level management
approve_timesheets	Approving a submitted timesheet
manage_deals	Creating/editing CRM deals

Additional plugin-specific permissions exist for Invoice, Workload, Checklist, and Knowledge Base — each plugin’s own permission set becomes visible under Administration → Roles and Permissions once that plugin’s module is enabled for the role.

Tip: For full access without per-permission setup, grant the user Administrator access in Redmine. Administrator users bypass most permission checks automatically.

API Key User Best Practices #

• Create a dedicated Redmine user for MCP integrations (e.g., mcp-bot)
• Grant it the minimum permissions your team needs
• Rotate the API key periodically via My Account → API access key → Reset
• For team deployments, each user can provide their own API key

Troubleshooting #

Problem: “No tools available” in Claude #

Cause: The MCP connection details in your client config are incorrect.

Solution:

1. Double-check your config exactly matches the example for your client
2. Confirm Node.js is installed (node --version) if you’re using Claude Desktop
3. Confirm you have outbound HTTPS access to your MCP server URL
4. Restart your AI client after changing the config file

Problem: “Authentication failed — your API key is invalid or expired” #

Cause: The API key in the config is wrong or the user’s account is inactive.

Solution:

1. Log in to Redmine → My Account → API access key → copy the key again
2. Update the API key in your MCP config
3. Ensure the Redmine user account is active (not locked)
4. Restart the AI client after updating the config

Problem: Plugins not detected (e.g., Agile Board tools missing) #

Cause: The plugin is not installed or not enabled in Redmine.

Solution:

1. Log in as Redmine admin
2. Navigate to Administration → Plugins and verify the plugin is listed
3. Navigate to Administration → Roles and Permissions and verify the module is enabled for the role
4. Check the module is enabled for the project under Project → Settings → Modules
5. Wait a few minutes for detection to refresh, or contact Redmineflux support

Problem: “You do not have permission” errors #

Cause: The Redmine user behind the API key lacks the required permission for that action.

Solution:

1. Log in as Redmine admin
2. Navigate to Administration → Roles and Permissions
3. Select the role assigned to your API key user
4. Enable the required permission (see Permissions Setup)
5. Save and retry

Problem: Tool call times out or hangs #

Cause: Redmine is slow to respond or the network connection is unstable.

Solution:

1. Check Redmine server health and logs
2. Retry the request — transient errors are automatically retried
3. If the issue persists, contact Redmineflux support

Problem: Plugin was uninstalled but tools still appear #

Cause: Detection may take a short time to refresh after uninstalling.

Solution: Wait a few minutes and try again, or contact Redmineflux support to refresh detection immediately.

Frequently Asked Questions (FAQs) #

Q1: Does Redmineflux MCP send my Redmine data to Anthropic or any third party?

No. Your Redmine data is only sent to the AI model (Claude) for processing your specific request — never stored by the MCP server itself. Anthropic’s data handling follows their standard privacy policy.

Q2: Can multiple users share one MCP server?

Yes. Multiple users can connect to the same MCP server URL. Each user provides their own Redmine API key via the X-Redmine-API-Key header, so all actions are authenticated with their individual Redmine credentials and permissions.

Q3: What happens if I ask about a plugin that is not installed?

The MCP server detects installed plugins at startup and only registers tools for detected plugins. If a plugin is not installed, its tools are not available at all — Claude will simply not have those capabilities, rather than returning confusing errors.

Q4: Can I use Redmineflux MCP with Redmine instances that have custom fields?

Yes. Custom fields are fully supported. You can pass custom field values when creating or updating issues using the custom_fields parameter, e.g., [{"id": 5, "value": "Production"}].

Q5: Does it work with Redmine Cloud or self-hosted instances?

Both. As long as your Redmineflux account is on the Pro Plan or above and you have a valid API key, it works with any Redmine deployment — cloud or self-hosted.

Q6: Can I restrict what the AI can do in Redmine?

Yes. The AI can only perform actions permitted by the Redmine user whose API key is configured. To restrict actions, create a dedicated Redmine role with only the permissions you want to allow, assign it to your MCP user, and use that user’s API key.

Q7: How many tools does Redmineflux MCP provide?

With every Redmineflux plugin installed, the MCP server provides over 500 tools across core Redmine functionality and all supported plugins. Without any plugins, around 90 core tools are always available. See redmineflux.com for the full plugin list by plan.

Q8: Does it support multiple Redmine instances?

Contact Redmineflux support to discuss multi-instance setups for your account.

Q9: Is an internet connection required?

Yes — your AI client needs outbound internet access to reach your Redmineflux MCP server URL.

Q10: What AI models work with Redmineflux MCP?

Redmineflux MCP is designed for Claude by Anthropic (Claude Desktop, Claude.ai, Claude Code). It uses the standard MCP protocol, so any MCP-compatible AI client can connect, but Claude is the recommended and tested client.

Q11: What should I do if I encounter a bug or have a feature request?

Please submit a ticket at your Redmine instance or contact the Redmineflux support team at redmineflux.com/support. Include the MCP server version (redmineflux_system_version tool) and a description of the issue.

Updates and Revisions #

• Redmineflux manages MCP server updates on the hosted infrastructure — no action needed on your end for most updates
• Monitor the official Redmineflux website for major MCP feature announcements
• If a client-side config change is ever needed, it will be announced with updated setup instructions
• Rotate your API key periodically for security best practices

Conclusion #

Redmineflux MCP Server bridges the gap between natural language AI assistants and your Redmine project management platform. By connecting Claude to your Redmine instance, your team can perform complex project management tasks — creating issues, managing sprints, tracking time, approving timesheets, handling support tickets — through simple conversation, without ever leaving your AI assistant.

With support for every Redmineflux plugin, automatic plugin detection, per-user authentication, and user-friendly error messages, the MCP server is designed to be both powerful and approachable for teams of any size.