What is Mcp Server Redmine

mcp-server-redmine is a Model Context Protocol (MCP) server implementation designed for Redmine, integrating with Redmine’s REST API to provide ticket and project information to Large Language Models (LLMs).

Use cases

Use cases include automating issue tracking, project management, and time entry logging, as well as integrating Redmine data with other applications or services to enhance productivity and reporting.

How to use

To use mcp-server-redmine, configure it with the necessary command and environment variables, including the Redmine server URL and API key. The configuration can be done in JSON format as shown in the README.

Key features

Key features include support for searching and managing issues, projects, and time entries. Users can filter, create, update, and delete these entities, as well as customize fields and manage project details.

Where to use

mcp-server-redmine can be used in project management environments where Redmine is utilized, particularly in software development, IT service management, and any domain requiring task tracking and collaboration.

Redmine MCP Server

This is a Model Context Protocol (MCP) server implementation for Redmine. It integrates with Redmine’s REST API to provide ticket and project information to LLMs.

Features

Supports stable resources from Redmine REST API:

• Issues (1.0~)
• Projects (1.0~)
• Users (1.1~)
• Time Entries (1.1~)

Tools

Issues

• Search Issues
  • Filter by project, status, assignee, etc.
  • Keyword search
  • Custom field support
• Create/Update Issues
  • Set tracker, status, priority
  • Configure custom fields
  • Add comments
• Delete Issues

Projects

• Search Projects
  • Filter by active/archived/closed status
  • Keyword search
• Get Project Details
  • Include trackers, categories information
• Create/Update Projects
  • Configure modules and trackers
  • Set member inheritance
• Archive/Unarchive Projects
• Delete Projects

Time Entries

• Search Time Entries
  • Filter by project, user, date range
• Get Time Entry Details
• Create/Update Time Entries
  • Record against project or issue
  • Specify activity
  • Custom field support
• Delete Time Entries

Usage with Claude

To use this server with Claude, configure it as follows:

{
  "mcp-server-redmine": {
    "command": "npx",
    "args": [
      "-y",
      "--prefix",
      "/path/to/mcp-server-redmine",
      "mcp-server-redmine"
    ],
    "env": {
      "REDMINE_HOST": "https://your-redmine.example.com",
      "REDMINE_API_KEY": "your-api-key-here"
    }
  }
}

Configuration Options

• command: Command to execute the npm package
• args:
  • -y: Auto-respond “yes” to prompts
  • --prefix: Specify installation directory
  • Last argument specifies the package name
• env: Environment variables
  • REDMINE_HOST: Redmine server URL
  • REDMINE_API_KEY: Your Redmine API key

Setup

Getting an API Key

1. Enable REST API in Redmine admin settings
2. Get API key from user settings page

Environment Variables

Set the following environment variables:

• REDMINE_API_KEY: API key obtained from Redmine user settings
• REDMINE_HOST: Redmine server URL (e.g., https://redmine.example.com)

Testing

Unit Tests

# Run tests
npm test

For data safety, only GET operations are included in tests.

Inspector Testing

Use MCP Inspector to verify functionality.

GUI Mode

# Build
npm run build

# Set execute permission (important)
chmod +x dist/index.js

# Launch inspector
npx @modelcontextprotocol/inspector dist/index.js

CLI Mode

The @modelcontextprotocol/inspector also offers a CLI mode for more direct interaction and scripting.

Key CLI Features:

• Connect to MCP Server:
  • Local build: npx @modelcontextprotocol/inspector --cli node build/index.js
  • Remote URL: npx @modelcontextprotocol/inspector --cli https://my-mcp-server.example.com
  • Using a config file: npx @modelcontextprotocol/inspector --cli --config path/to/config.json --server myserver
• Get Server Information:
  • List available tools: --method tools/list
  • List available resources: --method resources/list
  • List available prompts: --method prompts/list
• Execute Tools:
  • Call a specific tool with arguments: --method tools/call --tool-name <tool_name> --tool-arg <key>=<value>
• Environment Variables and Arguments:
  • Pass environment variables to the server: -e <key>=<value>
  • Separate Inspector flags from server arguments with --.

Basic CLI Command Examples:

• Connect to a local server and list available tools:

  npx @modelcontextprotocol/inspector --cli node build/index.js --method tools/list
  

• Connect to a remote server:

  npx @modelcontextprotocol/inspector --cli https://my-mcp-server.example.com
  

• Connect using a configuration file and execute a specific tool:

  npx @modelcontextprotocol/inspector --cli --config path/to/config.json --server myserver --method tools/call --tool-name mytool --tool-arg key=value
  

For more detailed information, refer to the MCP Inspector README.

Permissions

Some features require administrator privileges:

User-Related Operations

• list_users: Admin required
• create_user: Admin required
• update_user: Admin required
• delete_user: Admin required

Available information varies based on user permission levels. For details, see Redmine API Documentation.

Development

Requirements

• Node.js 18 or higher
• npm 9 or higher

Libraries

• @modelcontextprotocol/sdk: MCP SDK
• zod: Schema validation
• typescript: Type system

Directory Structure

.
├── src/
│   ├── tools/            # Tool definitions
│   │   ├── issues.ts
│   │   ├── projects.ts
│   │   ├── time_entries.ts
│   │   └── index.ts
│   ├── formatters/       # Formatters
│   │   ├── issues.ts
│   │   ├── projects.ts
│   │   ├── time_entries.ts
│   │   └── index.ts
│   ├── lib/              # Common libraries
│   │   ├── client.ts     # Redmine API client
│   │   ├── config.ts     # Configuration management
│   │   └── types.ts      # Type definitions
│   ├── handlers.ts       # Request handlers
│   └── index.ts          # Entry point
├── docs/
│   └── adr/              # Architecture Decision Records
├── package.json          # Project configuration
├── tsconfig.json         # TypeScript configuration
└── README.md             # Documentation

Building

# Install dependencies
npm install

# Build
npm run build

# Start development server
npm run dev

Architecture Decision Records

Major design decisions are documented in docs/adr. Refer to these documents when adding or modifying features.

License

MIT

Related Projects

• Model Context Protocol
• MCP TypeScript SDK
• Redmine