Redmine Enhanced MCP Server

Q: Which integrations are available for this server?

Provides tools for interacting with Redmine API, enabling issue management, project browsing, file attachments, time tracking, and more.

Q: How do I use Redmine Enhanced MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Redmine Enhanced MCP Server show me issues assigned to me" 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.

by olssonsten

Overview Schema Related Servers Score Discussions

Python

Remote

MCP Redmine Enhanced (Active Fork)

Fork Notice: This is an active fork of runekaagaard/mcp-redmine maintained to ensure stability and availability when upstream development is limited.

Enhanced Features

This fork adds several powerful enhancements over the original:

🎯 Advanced Response Filtering: Intelligent filtering with preset configurations (minimal, clean, essential_issues)
📝 Journal Filtering: Filter code-related entries from issue journals for cleaner output
🔒 Enhanced Security: ReDoS protection and comprehensive input validation
⚡ MCP Capabilities: Dynamic capability reporting based on API paths
🧪 Comprehensive Testing: 106+ tests covering security and edge cases
🚀 Automated Publication: Complete PyPI publication workflow with pre-checks

Related MCP server: Redmine MCP Server

Core Functionality

Let Claude be your Redmine assistant! MCP Redmine connects your MCP client to your Redmine instance, allowing it to:

Search and browse projects and issues
Create and update issues with full markdown support
Upload and download file attachments
Manage and track time entries
Update issue statuses and fields
Access comprehensive Redmine API functionality

Uses httpx for API requests and integrates with the Redmine OpenAPI specification for comprehensive API coverage.

MCP Redmine in action

Installation

Option 1: Using uvx (Recommended)

The easiest way to install MCP Redmine Enhanced:

{
  "mcpServers": {
    "redmine": {
      "command": "uvx",
      "args": [
        "--from", "mcp-redmine-enhanced==2025.09.13.162715.post0",
        "--refresh-package", "mcp-redmine-enhanced",
        "mcp-redmine"
      ],
      "env": {
        "REDMINE_URL": "https://your-redmine-instance.example.com",
        "REDMINE_API_KEY": "your-api-key",
        "REDMINE_REQUEST_INSTRUCTIONS": "/path/to/instructions.md"
      }
    }
  }
}

Prerequisites: Install uv if you don't have it:

Linux/macOS: curl -LsSf https://astral.sh/uv/install.sh | sh
macOS (Homebrew): brew install uv
Windows: powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

Option 2: Using pip

If you prefer using pip, first install the package globally:

pip install mcp-redmine-enhanced

Then configure Claude Desktop:

{
  "mcpServers": {
    "redmine": {
      "command": "mcp-redmine",
      "env": {
        "REDMINE_URL": "https://your-redmine-instance.example.com",
        "REDMINE_API_KEY": "your-api-key",
        "REDMINE_REQUEST_INSTRUCTIONS": "/path/to/instructions.md"
      }
    }
  }
}

Option 3: Development from Git

For the latest features and automatic updates:

{
  "mcpServers": {
    "redmine": {
      "command": "uvx",
      "args": [
        "--from", "git+https://github.com/olssonsten/mcp-redmine.git",
        "--refresh-package", "mcp-redmine-enhanced",
        "mcp-redmine"
      ],
      "env": {
        "REDMINE_URL": "https://your-redmine-instance.example.com",
        "REDMINE_API_KEY": "your-api-key",
        "REDMINE_REQUEST_INSTRUCTIONS": "/path/to/instructions.md"
      }
    }
  }
}

Package Details:

PyPI Package: mcp-redmine-enhanced
Console Script: mcp-redmine (for compatibility)
Latest Version: 2025.09.13.140055.post0
Repository: https://github.com/olssonsten/mcp-redmine

For developers who want to contribute or modify the code, clone the repository and use the local development setup described in Option 3 above.

Alternative: Docker Installation

If you prefer using Docker:

Build Docker Image

git clone https://github.com/olssonsten/mcp-redmine.git
cd mcp-redmine
docker build -t mcp-redmine-enhanced .

Configure Claude Desktop

{
  "mcpServers": {
    "redmine": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "REDMINE_URL",
        "-e", "REDMINE_API_KEY",
        "-e", "REDMINE_REQUEST_INSTRUCTIONS",
        "-v", "/path/to/instructions.md:/app/INSTRUCTIONS.md",
        "mcp-redmine-enhanced"
      ],
      "env": {
        "REDMINE_URL": "https://your-redmine-instance.example.com",
        "REDMINE_API_KEY": "your-api-key",
        "REDMINE_REQUEST_INSTRUCTIONS": "/app/INSTRUCTIONS.md"
      }
    }
  }
}

Note: When using Docker, the REDMINE_REQUEST_INSTRUCTIONS environment variable must point to a path inside the container. Mount your local instruction file into the container at the correct location.

Environment Variables

REDMINE_URL: URL of your Redmine instance (required)
REDMINE_API_KEY: Your Redmine API key (required, see below for how to get it)
REDMINE_REQUEST_INSTRUCTIONS: Path to a file containing additional instructions for the redmine_request tool (optional). I've found it works great to have the LLM generate that file after a session. (example1 example2)

Note: When running via Docker, the REDMINE_REQUEST_INSTRUCTIONS environment variable must point to a path inside the container, not a path on the host machine.
Therefore, if you want to use a local file, you need to mount it into the container at the correct location.

Getting Your Redmine API Key

Log in to your Redmine instance
Go to "My account" (typically found in the top-right menu)
On the right side of the page, you should see "API access key"
Click "Show" to view your existing key or "Generate" to create a new one
Copy this key for use in your configuration

API

Tools

redmine_paths_list
- Return a list of available API paths from OpenAPI spec
- No input required
- Returns a YAML string containing a list of path templates:
```
- /issues.json
- /projects.json
- /time_entries.json
...
```
redmine_paths_info
- Get full path information for given path templates
- Input: path_templates (list of strings)
- Returns YAML string containing API specifications for the requested paths:
```
/issues.json:
  get:
    operationId: getIssues
    parameters:
      - $ref: '#/components/parameters/format'
    ...
```
redmine_request
- Make a request to the Redmine API
- Inputs:
  - path (string): API endpoint path (e.g. '/issues.json')
  - method (string, optional): HTTP method to use (default: 'get')
  - data (object, optional): Dictionary for request body (for POST/PUT)
  - params (object, optional): Dictionary for query parameters
  - mcp_filter (object, optional): MCP response filtering (use redmine_paths_info to discover options)
- Returns YAML string containing response status code, body and error message:
```
status_code: 200
body:
  issues:
    - id: 1
      subject: "Fix login page"
      ...
error: ""
mcp_filtered: true  # Added when filtering is applied
```
redmine_upload
- Upload a file to Redmine and get a token for attachment
- Inputs:
  - file_path (string): Fully qualified path to the file to upload
  - description (string, optional): Optional description for the file
- Returns YAML string with the same format as redmine_request, including upload token:
```
status_code: 201
body:
  upload:
    id: 7
    token: "7.ed32257a2ab0f7526c0d72c32994c58b131bb2c0775f7aa84aae01ea8397ea54"
error: ""
```
redmine_download
- Download an attachment from Redmine and save it to a local file
- Inputs:
  - attachment_id (integer): The ID of the attachment to download
  - save_path (string): Fully qualified path where the file should be saved
  - filename (string, optional): Optional filename to use (determined automatically if not provided)
- Returns YAML string with download results:
```
status_code: 200
body:
  saved_to: "/path/to/downloaded/file.pdf"
  filename: "file.pdf"
error: ""
```

Examples

Creating a new issue

Let's create a new bug report in the "Website" project:

1. Title: "Homepage not loading on mobile devices"
2. Description: "When accessing the homepage from iOS or Android devices, the loading spinner appears but the content never loads. This issue started after the last deployment."
3. Priority: High
4. Assign to: John Smith

Searching for issues

Can you find all high priority issues in the "Website" project that are currently unassigned?

Updating issue status

Please mark issue #123 as "In Progress" and add a comment: "I've started working on this issue. Expect it to be completed by Friday."

Logging time

Log 3.5 hours against issue #456 for "Implementing user authentication" done today.

Using Response Filtering (New)

Get issues with reduced verbosity:
redmine_request("/issues.json", params={"limit": 5}, mcp_filter={"remove_empty": True, "remove_custom_fields": True})

Use preset for clean responses:
redmine_request("/issues.json", mcp_filter="clean")
Filter journals for code reviews:
redmine_request("/issues/123.json", params={"include": "journals"}, mcp_filter={"journals": {"code_review_only": True}})

MCP Directory Listings

MCP Redmine is listed in the following MCP directory sites and repositories:

My Other LLM Projects

MCP Alchemy - Connect Claude Desktop to databases for exploring schema and running SQL.
MCP Notmuch Sendmail - Email assistant for Claude Desktop using notmuch.
Diffpilot - Multi-column git diff viewer with file grouping and tagging.
Claude Local Files - Access local files in Claude Desktop artifacts.

Contributing

Contributions are warmly welcomed! Whether it's bug reports, feature requests, documentation improvements, or code contributions - all input is valuable. Feel free to:

Open an issue to report bugs or suggest features
Submit pull requests with improvements
Enhance documentation or share your usage examples
Ask questions and share your experiences

The goal is to make Redmine project management with Claude even better, and your insights and contributions help achieve that.

Acknowledgments

This project builds on the excellent work of others:

httpx - For handling HTTP requests
Redmine OpenAPI Specification - For the comprehensive API specification
Redmine - The flexible project management web application

License

Mozilla Public License Version 2.0

Available Tools

5 tools

redmine_downloadA

Download an attachment from Redmine and save it to a local file

Args: attachment_id: The ID of the attachment to download save_path: Fully qualified path where the file should be saved to filename: Optional filename to use for the attachment. If not provided, will be determined from attachment data or URL

Returns: str: YAML string containing download status, file path, and any error messages

ParametersJSON Schema

Name	Required	Description	Default
`attachment_id`	Yes
`save_path`	Yes
`filename`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A3.5/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must bear full behavioral burden. It mentions the return format (YAML with status, path, errors) but omits critical details such as file overwrite behavior, authorization requirements, error handling for missing attachments, or network requirements. These gaps significantly reduce transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is structured with a clear first sentence stating the purpose, followed by an Args section and a Returns section. Slightly verbose in listing args, but every sentence adds information. Could be more concise but is effective.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers the core functionality and return format, but lacks behavioral context such as overwrite behavior, error scenarios, or prerequisites. Given the tool's simplicity, it is minimally adequate but not thorough.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With schema coverage at 0%, the description fully compensates by explaining each parameter's meaning and behavior (e.g., filename is optional and determined from data if omitted). This adds significant value beyond the schema's basic titles and types.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool downloads an attachment from Redmine and saves it to a local file, with a specific verb and resource. It distinguishes from siblings like redmine_upload (opposite action) and redmine_request (generic), making the purpose unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when or when not to use this tool compared to alternatives like redmine_request or redmine_upload. It lacks explicit exclusions or context for optimal use, leaving the agent to infer usage from the purpose alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

redmine_paths_infoB

Get full path information including MCP capabilities

Returns both native Redmine API specifications AND available MCP server capabilities for response processing.

Args: path_templates: List of path templates (e.g. ['/issues.json', '/projects.json'])

Returns: str: YAML string containing API specifications and MCP capabilities

ParametersJSON Schema

Name	Required	Description	Default
`path_templates`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not mention whether the tool is read-only, requires authentication, has rate limits, or any side effects. For an info tool, a read-only hint would be expected, but it is absent. The description only states the output format.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and well-structured, with a clear first sentence and an Args/Returns section that organizes input and output. It avoids unnecessary elaboration, though the example could be more precise.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's low complexity (one parameter, simple string output) and the presence of an output schema, the description sufficiently covers input and output. However, it lacks contextual details like error handling or performance implications.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 0% description coverage, so the description compensates by explaining the 'path_templates' parameter as a list of path templates with an example. However, it does not specify item types or constraints beyond the example, leaving some ambiguity.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: getting full path information including MCP capabilities. It specifies that it returns Redmine API specifications and MCP server capabilities. However, it does not explicitly distinguish itself from sibling tools like redmine_paths_list, which may list available paths.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives (e.g., redmine_paths_list) or any prerequisites, limitations, or scenarios. It only describes what the tool does without contextual usage advice.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

redmine_paths_listA

Return a list of available API paths from OpenAPI spec

Retrieves all endpoint paths defined in the Redmine OpenAPI specification. Remember that you can use the redmine_paths_info tool to get the full specfication for a path.

Returns: str: YAML string containing a list of path templates (e.g. '/issues.json')

ParametersJSON Schema

Name	Required	Description	Default
No parameters

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, description carries the burden. It states it returns a YAML string listing path templates. No side effects are implied; the tool is read-only. Behavior is transparent given its function.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Extremely concise: two short sentences plus a return type line. No wasted words, information is front-loaded and immediately actionable.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a no-parameter listing tool, the description fully covers purpose, return format, and relationship to sibling. Context signals (0 params, output schema) confirm completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters exist; schema coverage is 100%. The description adds no parameter info (unnecessary). Baseline of 4 applies for zero-parameter tools.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clear verb-resource pair: 'Return a list of available API paths'. Explicitly distinguishes from sibling 'redmine_paths_info' by noting it gives full specification, making this tool's scope unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit usage guidance: mentions alternative 'redmine_paths_info' for full spec. No explicit when-not-to-use, but given the tool's simplicity, the guidance is sufficient and clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

redmine_requestA

Make a request to the Redmine API

Args: path: API endpoint path (e.g. '/issues.json') method: HTTP method to use (default: 'get') data: Dictionary for request body (for POST/PUT) params: Dictionary for query parameters mcp_filter: Optional MCP response filtering (use redmine_paths_info to discover options)

Returns: str: YAML string containing response status code, body and error message

ParametersJSON Schema

Name	Required	Default
`path`	Yes
`method`	No	get
`data`	No
`params`	No
`mcp_filter`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A3.6/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description explains that the tool makes HTTP requests and returns a YAML string with status code, body, and error message. However, with no annotations, it does not disclose authentication requirements, potential side effects, or rate limits. The behavior is partially described.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is structured with Args and Returns sections, and the one-line summary is front-loaded. It is concise and covers all parameters without unnecessary verbosity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the 5 parameters, 0% schema coverage, and no annotations, the description provides adequate parameter explanations and return format. However, it lacks broader contextual notes like error handling or rate limits, leaving some gaps for an agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Despite 0% schema description coverage, the description explains each parameter in detail: path (endpoint), method (default get), data (for POST/PUT), params (query params), mcp_filter (for MCP filtering). This adds significant meaning beyond the bare schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it makes a request to the Redmine API, which is a specific verb+resource. It distinguishes itself from sibling tools like redmine_download, redmine_upload, etc., which are specialized operations.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this generic request tool versus the specialized sibling tools (e.g., redmine_paths_info for path discovery, redmine_download for downloads). The description does not include when-not-to-use or alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

redmine_uploadB

Upload a file to Redmine and get a token for attachment

Args: file_path: Fully qualified path to the file to upload description: Optional description for the file

Returns: str: YAML string containing response status code, body and error message The body contains the attachment token

ParametersJSON Schema

Name	Required	Description	Default
`file_path`	Yes
`description`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

B3.4/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, and the description lacks details on side effects (e.g., file storage, permissions), rate limits, or idempotency. It only states the basic operation without behavioral traits beyond the core action.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is relatively concise with clear Args and Returns sections. However, the Args section partially duplicates schema information, which could be omitted for brevity. Still well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool uploads files and has siblings, the description covers the basic purpose and parameters but lacks usage context, error handling details, and behavioral traits. The presence of an output schema (not shown) reduces the need for return value details, but completeness is average.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Despite 0% schema description coverage, the description adds meaning for both parameters: 'file_path' as 'Fully qualified path' and 'description' as 'Optional description'. This compensates for the missing schema comments, though additional constraints (e.g., file size) are absent.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description explicitly states 'Upload a file to Redmine and get a token for attachment,' clearly identifying the action, resource, and outcome. It distinguishes from siblings like redmine_download, redmine_paths_info, etc., which serve different purposes.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool vs alternatives (e.g., redmine_request for non-file operations). No prerequisites or exclusions mentioned, leaving the agent to infer use cases.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.7/5.0

Disambiguation4/5

The tools are mostly distinct: upload/download file operations, generic API request, and path discovery. However, redmine_paths_info and redmine_paths_list have overlapping purposes (both deal with paths), though their specific outputs differ.

Naming Consistency5/5

All tools follow a consistent 'redmine_' prefix with descriptive suffixes (download, paths_info, paths_list, request, upload). The naming pattern is uniform and predictable.

Tool Count5/5

With 5 tools, the server is well-scoped for a Redmine integration. It provides essential file upload/download, a generic API request tool, and discovery tools, avoiding unnecessary bloat.

Completeness3/5

The generic redmine_request tool covers all Redmine API endpoints, so agents can perform any operation. However, there are no dedicated tools for common tasks like issue CRUD or project management, which may make the server less intuitive.

Maintenance

ActivityInactive

ResponsivenessSyncing

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

platform7n
tech.p7n
Connect Claude to your Platform7n workspaces — chat, links, and tasks. One-click OAuth.
Communication Project Management Workplace & Productivity
2
Fathom MCP Server
io.github.agencyenterprise
Connect Claude to Fathom meeting recordings, transcripts, and summaries
Communication App Automation Search
216
NetworkOS
com.thenetworkos
Your professional network in Claude — search contacts, log notes, and send warm intros.
CRM Note Taking
2
Rootr
io.github.inspirio-co
Connect your team's living knowledge base — docs, data, issues, CRM — to Claude and ChatGPT.
RAG Systems Knowledge & Memory CRM
2

Related MCP Servers

MCP Redmine
Project Management App Automation
runekaagaard
A
license
A
quality
D
maintenance
Connects Claude Desktop to Redmine for seamless project and issue management, including searching, creating, updating, and tracking tasks using Redmine's API.
Updated a month ago (2026-07-31 22:25 UTC)
5
233
Mozilla Public 2.0
Redmine MCP Server
Project Management Workplace & Productivity
Wint3rmute
A
license
Not graded
quality
D
maintenance
Enables AI applications to interact with Redmine project management systems for issue tracking, time logging, and project management through natural language.
Updated 7 months ago (2026-01-28 18:51 UTC)
24
MIT
mcp-server-redmine
Project Management Developer Tools
mirceaion
A
license
Not graded
quality
B
maintenance
Enables AI assistants to create, update, and query Redmine issues and projects directly from conversations.
Updated 5 days ago (2026-08-28 10:31 UTC)
903
MIT
Redmine MCP Server
Project Management Developer Tools
junstellar
A
license
A
quality
C
maintenance
Enables natural language interaction with Redmine via Claude Code or other MCP clients, supporting project, issue, and wiki management.
Updated 2 months ago (2026-07-03 22:39 UTC)
11
1
MIT

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/olssonsten/mcp-redmine'

If you have feedback or need assistance with the MCP directory API, please join our Discord server