mcp-redmine-server
This MCP server lets AI assistants read and manage Redmine issues, projects, relations, wiki pages, files, and Git-linked fix workflows through the Redmine API.
Issues: get full issue details, create issues (with optional attachments, subtasks via parent_id, tracker/priority), add comments and optionally change status, and list issues by status name (optionally per project).
Hierarchy & relations: fetch a full issue tree (related plus child/subtask issues) and link issues with relation types like relates, blocks, blocked, duplicates, precedes, follows.
Projects & statuses: list accessible projects, get project details (trackers, enabled modules), get all issue statuses, and list a project's issues with filters for status, tracker, assignee, and pagination.
Wiki: read a wiki page, list all wiki pages in a project, create/update pages with Textile markup (supports parent_title hierarchy and change comments), and delete pages.
Files & attachments: upload a file to get an upload token, attach one or more files to an existing issue, or attach files at issue creation time.
Workflow automation: start a fix (creates a Git branch, sets status to "In Progress", analyzes the task) and complete a fix (sets status to "Resolved", adds a completion comment with commit details, validates a clean working directory).
Automatic Git branch creation and commit tracking integrated with Redmine issue fix workflows (start fix and complete fix tools).
Comprehensive Redmine API integration for issue management, file attachments, workflow automation with Git, issue relations, hierarchy, status filtering, comments, and wiki management.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@mcp-redmine-server list open issues in project"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP Redmine Server
Model Context Protocol (MCP) server for Redmine integration. Provides comprehensive Redmine API access to Claude Code and other MCP-compatible AI assistants.
Features
Issue Management: Create, read, update issues with full details
File Attachments: Upload and attach files/images to issues
Workflow Support: Start/complete fix workflows with Git integration
Relations & Tree: Manage issue relations, subtasks, and hierarchies
Status Filtering: Query issues by status with flexible filtering
Comments: Add comments and update issue status
Git Integration: Automatic branch creation and commit tracking
Wiki Support: Full wiki page management (read, create, update, delete)
Related MCP server: Redmine MCP Server
Available Tools
The server provides the following MCP tools:
Issue Operations
redmine_get_issue - Get detailed issue information
Includes description, status, priority, comments, attachments
Returns full issue object with all metadata
redmine_create_issue - Create new issue
Parameters: title, description, tracker_id, priority_id, parent_id, file_paths
Supports creating subtasks via parent_id
Can attach files during issue creation
redmine_update_issue - Update an existing issue
Parameters: subject, description, status_id, priority_id, tracker_id, assigned_to_id, parent_issue_id, category_id, fixed_version_id, start_date, due_date, estimated_hours, done_ratio, notes, private_notes, custom_fields, project_id
Only the fields you pass are changed, the rest stay untouched
Can move an issue to another project via project_id
redmine_add_comment - Add comment to issue
Can optionally update issue status
Useful for progress updates and status changes
File & Attachment Operations
redmine_upload_file - Upload file to Redmine
Returns upload token for later use
Supports all file types (images, documents, archives, etc.)
redmine_add_attachments - Attach files to existing issue
Upload and attach multiple files in one operation
Automatically adds comment with file list
redmine_download_attachment - Download attachment content
Parameters: attachment_id, output_path
Works for issue, wiki and project file attachments
output_path may be a directory (keeps the original filename)
redmine_get_project_files - List files from the project "Files" section
Returns filename, size, description, version and download URL
redmine_upload_project_file - Upload file to the project "Files" section
Parameters: project_id, file_path, description, version_id
Uploads to project files, not to an issue
Querying & Filtering
redmine_get_issues_by_status - Filter issues by status
Parameters: status_name, limit, project_id
Returns issues with specific status (e.g., "New", "In Progress")
Can filter by project or get from all projects
redmine_get_statuses - Get all available statuses
Returns complete list of project statuses
Useful for discovering valid status names
redmine_get_projects - Get all accessible projects
Lists all Redmine projects available to your API key
Useful for multi-project environments
redmine_get_project - Get project details
Returns project info with trackers and enabled modules
redmine_get_project_issues - Get issues from specific project
Supports pagination and filtering
Filter by status, tracker, assignee
Relations & Hierarchy
redmine_get_issue_tree - Get full issue tree
Returns main issue, related issues, and child issues
Shows complete issue hierarchy
redmine_create_relation - Link two issues
Relation types: relates, blocks, blocked, duplicates, precedes, follows
Creates bidirectional relationships
Workflow Automation
redmine_start_fix - Start fix workflow
Creates Git branch automatically
Updates issue status to "In Progress"
Adds workflow comment
redmine_complete_fix - Complete fix workflow
Updates issue status to "Resolved"
Adds completion comment with commit details
Validates working directory is clean
Wiki Operations
redmine_wiki_get_page - Get wiki page content
Returns page text and metadata
Includes attachments information
redmine_wiki_get_index - List all wiki pages
Returns index of all pages in project
redmine_wiki_put_page - Create or update wiki page
Uses Redmine Textile markup
Supports page hierarchy via parent_title
redmine_wiki_delete_page - Delete wiki page
Permanently removes wiki page from project
Installation
Global Installation (Recommended)
Install the MCP server globally for use across all projects:
# Install dependencies
npm install
# Create global link
npm link
# Verify installation
which mcp-redmineLocal Installation
Or install locally in a specific project:
npm installConfiguration
Environment Variables
Create a .env file or set environment variables:
# Required
export REDMINE_API_KEY=your_api_key_here
# Optional (defaults shown)
export REDMINE_BASE_URL=https://3cad.tech
export REDMINE_PROJECT_ID=8
export REDMINE_PROJECT_IDENTIFIER=cad-techGet Your Redmine API Key
Log in to your Redmine instance
Go to "My account" (top right menu)
Click "Show" under "API access key" on the right sidebar
Copy the API key
Claude Code Integration
Method 1: Global MCP Configuration
Add to your global Claude Code MCP settings (~/.config/claude-code/mcp.json or similar):
{
"mcpServers": {
"redmine": {
"command": "mcp-redmine",
"env": {
"REDMINE_API_KEY": "your_api_key_here",
"REDMINE_BASE_URL": "https://3cad.tech",
"REDMINE_PROJECT_ID": "8",
"REDMINE_PROJECT_IDENTIFIER": "cad-tech"
}
}
}
}Method 2: Project-Specific Configuration
Add to your project's .claude/mcp.json:
{
"mcpServers": {
"redmine": {
"command": "node",
"args": ["path/to/mcp-redmine-server/index.js"],
"env": {
"REDMINE_API_KEY": "your_api_key_here"
}
}
}
}Method 3: Use with dotenv
If using local installation with .env file:
{
"mcpServers": {
"redmine": {
"command": "node",
"args": ["-r", "dotenv/config", "path/to/mcp-redmine-server/index.js"],
"cwd": "path/to/mcp-redmine-server"
}
}
}Usage Examples
Once configured in Claude Code, the AI assistant can use these tools automatically:
Example Conversations
User: "Show me all issues that are in progress"
Claude will use redmine_get_issues_by_status with status_name: "In Progress"
User: "Create a new bug for the login page issue"
Claude will use redmine_create_issue with appropriate tracker_id
User: "Start working on issue #42"
Claude will use redmine_start_fix to:
Create a Git branch
fix/issue-42-...Update issue status to "In Progress"
Add comment with branch name
User: "I've fixed issue #42, the login validation is working now"
Claude will use redmine_complete_fix to:
Update status to "Resolved"
Add completion comment with commits
Provide next steps (PR, merge, etc.)
User: "Show me the full tree of issue #78"
Claude will use redmine_get_issue_tree to show:
Main issue details
All related issues
All child/subtask issues
User: "Create a bug report for the login issue and attach the screenshot from my Desktop"
Claude will:
Use
redmine_upload_fileto upload the screenshotUse
redmine_create_issuewith the upload token to create issue with attachment
User: "Add these error logs to issue #150: /path/to/error.log and /path/to/debug.log"
Claude will use redmine_add_attachments to:
Upload both log files
Attach them to issue #150
Add comment with file list
User: "Create a new feature request with the mockup image attached"
Claude will use redmine_create_issue with file_paths parameter to create issue with attachment in one step
File Upload API Details
How File Attachments Work
Redmine API uses a two-step process for file attachments:
Upload File: First, upload the file to get a token
// Returns: { token: "abc123...", filename: "screenshot.png", filesize: 12345 }Attach to Issue: Use the token when creating/updating an issue
// The token is automatically used in issue creation/update
The MCP server simplifies this by handling both steps automatically:
redmine_add_attachments: Upload files and attach them in one callredmine_create_issuewithfile_paths: Create issue with attachments in one callredmine_upload_file: Manual upload if you need the token for later use
Supported File Types
All file types are supported:
Images: PNG, JPG, GIF, SVG, etc.
Documents: PDF, DOC, DOCX, TXT, MD, etc.
Archives: ZIP, TAR, GZ, RAR, etc.
Code: JS, PY, JAVA, etc.
Logs: LOG, TXT, etc.
Any other binary files
File Path Requirements
Must be absolute paths (e.g.,
/home/user/screenshot.pngorC:\Users\User\image.png)Files must exist and be readable
No size limit enforced by MCP server (Redmine server may have limits)
Testing
Test the MCP server manually:
# Set environment variables
export REDMINE_API_KEY=your_api_key_here
# Run server (it communicates via stdio)
node index.js
# In another terminal, use MCP client to test
# Or test with Claude Code directlyTesting File Uploads
# Example: Create issue with attachment
# This is done automatically by Claude when using the MCP tools
# Just ask: "Create a bug report and attach /path/to/screenshot.png"Troubleshooting
"REDMINE_API_KEY environment variable is required"
Make sure you've set the REDMINE_API_KEY environment variable or created a .env file.
"Connection failed" errors
Check your
REDMINE_BASE_URLis correctVerify your API key is valid
Ensure you have network access to the Redmine server
Check firewall/proxy settings
Git integration not working
Ensure Git is installed and available in PATH
Verify you're running commands from a Git repository
Check you have write permissions for the repository
Architecture
┌─────────────────────────────────────────┐
│ Claude Code / MCP Client │
│ │
└──────────────┬──────────────────────────┘
│ MCP Protocol (stdio)
│
┌──────────────▼──────────────────────────┐
│ MCP Redmine Server │
│ │
│ • Issue Management Tools │
│ • File Upload & Attachments │
│ • Workflow Automation │
│ • Git Integration │
│ • Wiki Management │
│ • Status & Filtering │
│ │
└──────────────┬──────────────────────────┘
│ HTTPS API
│
┌──────────────▼──────────────────────────┐
│ Redmine REST API │
│ │
│ • Issues │
│ • Relations │
│ • Statuses │
│ • Projects │
│ │
└─────────────────────────────────────────┘Security Notes
API Key: Never commit your API key to version control
Environment Variables: Use
.envfiles or secure environment configuration.gitignore: The
.envfile is already in.gitignorePermissions: API key should have appropriate permissions in Redmine
Git Operations: Server executes Git commands - ensure trusted environment
Development
Project Structure
mcp-redmine-server/
├── index.js # Main MCP server implementation
├── package.json # Node.js dependencies and metadata
├── .env.example # Example environment configuration
├── .gitignore # Git ignore rules
└── README.md # This fileAdding New Tools
To add new Redmine functionality:
Add tool definition to
ListToolsRequestSchemahandlerImplement tool logic in
CallToolRequestSchemahandlerAdd corresponding helper function if needed
Update this README with usage examples
Related Projects
Model Context Protocol - MCP specification and SDKs
Redmine API - Official Redmine REST API documentation
License
MIT
Contributing
Contributions are welcome! Please feel free to submit issues or pull requests.
Support
For issues specific to this MCP server, please open a GitHub issue.
For Redmine API questions, refer to the official documentation.
Available Tools
18 toolsredmine_add_attachmentsA
Add one or more file attachments to an existing Redmine issue. Files are uploaded and automatically attached.
Inputs: issue_id (required), file_paths (required).
redmine_add_commentA
Add a comment to an existing Redmine issue and optionally change its status
Inputs: comment (required), issue_id (required), status_id.
redmine_complete_fixA
Complete fix workflow: updates issue status to "Resolved" and adds completion comment with commit details
Inputs: issue_id (required), completion_message (required), working_directory.
redmine_create_issueA
Create a new Redmine issue with specified title and description. Can optionally attach files by providing file paths.
Inputs: title (required), description (required), parent_id, file_paths, +3 more.
redmine_create_relationB
Create a relation between two issues (relates, blocks, duplicates, etc.)
Inputs: issue_id (required), related_issue_id (required), relation_type.
redmine_get_issueA
Get detailed information about a Redmine issue including description, status, priority, assigned user, and comments
Inputs: issue_id (required).
redmine_get_issues_by_statusB
Get all issues with a specific status (e.g., "New", "In Progress", "Resolved"). Can filter by project or get from all projects
Inputs: status_name (required), limit, project_id.
redmine_get_issue_treeA
Get full issue tree including related issues and child/subtask issues
Inputs: issue_id (required).
redmine_get_projectA
Get detailed information about a specific Redmine project including trackers and enabled modules
Inputs: project_id (required).
redmine_get_project_issuesA
Get issues from a specific project with optional filters
Inputs: project_id (required), limit, offset, status_id, +2 more.
redmine_get_projectsA
Get list of all available Redmine projects that the API key has access to
Inputs: limit.
redmine_get_statusesA
Get all available issue statuses in the Redmine project
Inputs: no named parameters.
redmine_start_fixA
Start fix workflow: creates git branch, updates issue status to "In Progress", and provides task analysis
Inputs: issue_id (required), working_directory.
redmine_upload_fileA
Upload a file to Redmine and get an upload token. This token can be used later to attach the file to an issue.
Inputs: file_path (required).
redmine_wiki_delete_pageA
Delete a wiki page from a Redmine project
Inputs: title (required), project_id (required).
redmine_wiki_get_indexA
Get a list of all wiki pages in a Redmine project
Inputs: project_id (required).
redmine_wiki_get_pageA
Get a wiki page content from a Redmine project by page title
Inputs: title (required), project_id (required).
redmine_wiki_put_pageA
Create a new wiki page or update an existing one in a Redmine project. Uses PUT — creates if not exists, updates if exists.
Inputs: text (required), title (required), project_id (required), comments, +1 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 18 tools
Each tool generally maps to one resource/action, with only a few overlapping pairs like get_issue_tree vs get_issue and get_project_issues vs get_issues_by_status. The descriptions sufficiently clarify these boundaries, so an agent can usually select the right tool.
All tools use a consistent redmine_ prefix and snake_case with verb-first names such as get, create, add, start, complete, and upload. Even the wiki PUT operation is named predictably, and there is no mixing of naming conventions.
18 tools is at the upper end of a typical MCP server, but each tool serves a distinct purpose across issues, wiki, projects, attachments, and workflow. It feels slightly heavy but not bloated for the breadth of Redmine features covered.
Issue coverage lacks a generic update_issue or delete_issue; status changes are only available through add_comment or the start_fix/complete_fix workflow. Wiki and project access are well covered, but the core issue lifecycle is incomplete.
Maintenance
Related MCP Connectors
One MCP server for the services your AI needs: memory, files, Microsoft 365, kanban and more.
MCP server unifying ERPs, CRMs, APIs and knowledge base for Claude, ChatGPT and Gemini.
MCP server enabling AI agents to manage Bitrix24 features via standardized protocol
Hosted MCP server connecting AI assistants to 9,000+ apps and 40,000+ actions via Zapier.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables AI assistants to interact with Redmine for task management, time logging, status updates, and progress tracking via the MCP protocol.9MIT
- AlicenseBqualityDmaintenanceMCP server for Redmine project management, enabling tools for managing projects, issues, users, time entries, groups, memberships, versions, wiki, news, attachments, search, and Agile sprints via the Redmine REST API.8921 npm1MIT
- AlicenseAqualityDmaintenanceEnables AI assistants to manage Redmine issues, projects, time tracking, wiki, and files via the MCP protocol.3362 npm6Apache 2.0
- FlicenseAqualityDmaintenanceAn MCP server that connects AI agents to Redmine project data, enabling natural language access to issues, projects, time entries, and more via the REST API.21-