redmine-mcp

Ein zustandsloser Model Context Protocol-Server für Redmine. Platzieren Sie ihn vor eine beliebige Redmine- Instanz und lassen Sie Claude (oder einen beliebigen MCP-fähigen LLM-Client) Tickets lesen und schreiben, Zeiten erfassen, das Wiki durchsuchen und Projekte im Namen des Benutzers durchsuchen, wobei jeder Benutzer seinen eigenen API-Schlüssel verwendet.

• Kein Zustand: keine Datenbank, keine Sitzungen, kein gemeinsames Geheimnis. Der Server leitet jede Anfrage unter Verwendung des mitgelieferten API-Schlüssels an Redmine weiter.

• Ein Server, viele Benutzer: Das Einzige, was der Betreiber konfiguriert, ist die Upstream-REDMINE_URL. Jeder MCP-Client liefert seinen eigenen X-Redmine-API-Key. Die Berechtigungen entsprechen denen, die in Redmine definiert sind.

• Abdeckung: Tickets (CRUD + Notizen), Projekte, Mitgliedschaften, Benutzer, Zeiteinträge, Wiki (PUT-Upsert), Anhänge (Hochladen + Herunterladen), Volltextsuche, Status, Tracker, Kategorien, benutzerdefinierte Felder, Aufzählungen.

Schnellstart

Lokal (uv)

uv sync
REDMINE_URL=https://redmine.example.com uv run redmine-mcp

Der MCP-Endpunkt befindet sich jetzt unter http://127.0.0.1:8080/mcp.

Container (GHCR)

docker run --rm -p 8080:8080 \
  -e REDMINE_URL=https://redmine.example.com \
  ghcr.io/kalvadtech/redmine-mcp:latest

Das Image ist ein mehrstufiges Alpine-Image, läuft als Nicht-Root-Benutzer und stellt Port 8080 bereit.

Related MCP server: Redmine MCP Server

Einbindung in Ihren MCP-Client

Finden Sie Ihren Redmine-API-Schlüssel unter Mein Konto > API-Zugriffsschlüssel. Beide unten aufgeführten Clients kommunizieren über Streamable HTTP mit demselben MCP-Endpunkt; keine weitere Client-Konfiguration ist erforderlich.

Claude Code

.mcp.json in Ihrem Projektstammverzeichnis:

{
  "mcpServers": {
    "redmine": {
      "type": "http",
      "url": "http://127.0.0.1:8080/mcp",
      "headers": {
        "X-Redmine-API-Key": "your-40-char-key"
      }
    }
  }
}

opencode

opencode.json in Ihrem Projektstammverzeichnis (oder Ihrem opencode-Konfigurationsverzeichnis):

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "redmine": {
      "type": "remote",
      "url": "http://127.0.0.1:8080/mcp",
      "enabled": true,
      "headers": {
        "X-Redmine-API-Key": "{env:REDMINE_API_KEY}"
      }
    }
  }
}

opencode unterstützt {env:VAR}-Interpolation in headers, sodass der API-Schlüssel nicht in der Konfigurationsdatei landet: REDMINE_API_KEY=... opencode.

Konfiguration

CLI-Flags für redmine-mcp:

--host        bind address (default 127.0.0.1)
--port        port (default 8080)
--log-level   uvicorn log level (default info)

Der Server bricht beim Start sofort ab, wenn REDMINE_URL fehlt oder kein http(s) ist.

Authentifizierungsmodell

Die Redmine-URL wird nicht vom Benutzer bereitgestellt; sie ist pro Bereitstellung über REDMINE_URL festgelegt. Dies eliminiert das SSRF-Risiko: Clients können den Server nicht auf beliebige Hosts verweisen.

Das einzige Anmeldeinformation, das ein Client sendet, ist sein eigener Redmine-API-Schlüssel im X-Redmine-API-Key-Header. Der Server leitet ihn als denselben Header an Redmine weiter (sodass er nicht als Query-String in den Redmine-Zugriffsprotokollen landet), verwendet ihn für eine Anfrage und verwirft ihn dann. Es gibt kein Caching, kein gemeinsames Dienstkonto und keine Identitätswechsel.

Tools

59 Tools decken jede Ressourcenfamilie ab, die Redmine über seine REST-API bereitstellt. Listen-Tools geben {items, total_count, limit, offset} für einfaches Paging zurück.

Tickets

• list_issues (Projekt, Status, Bearbeiter, Tracker, Kategorie, Version, gespeicherte Abfrage, Freitextsuche, Sortierung, Include)

• get_issue (Include: Journale, Anhänge, Beziehungen, Kinder, Beobachter)

• create_issue (inkl. uploads-Token, custom_fields, watcher_user_ids)

• update_issue (inkl. notes, private_notes)

• add_issue_note (dünner Wrapper)

• delete_issue

Ticket-Beziehungen

• list_issue_relations, get_relation, create_issue_relation (bezieht sich auf / blockiert / geht voraus / etc., mit delay für vorausgehend/folgend), delete_relation

Journale (Ticket-Notizen)

• update_journal_note - Bearbeiten Sie den Text oder die Vertraulichkeit einer vorhandenen Notiz. Verwenden Sie add_issue_note, um eine neue Notiz hinzuzufügen.

Projekte und Versionen

• list_projects, get_project

• list_versions, get_version, create_version, update_version, delete_version

Mitgliedschaften

• list_memberships, get_membership, add_project_member (Benutzer oder Gruppe), update_membership, remove_membership

Benutzer, mein Konto, Gruppen, Rollen

• list_users, get_user (akzeptiert den literalen String "current")

• get_my_account, update_my_account

• list_groups, get_group, create_group, update_group, delete_group, add_user_to_group, remove_user_from_group

• list_roles, get_role (mit Berechtigungen)

Zeiteinträge

• list_time_entries (Datumsbereiche, Benutzer, Projekt, Ticket)

• create_time_entry (Ticket oder Projekt, Stunden, Aktivität, spent_on, Kommentare)

• update_time_entry, delete_time_entry

Wiki

• list_wiki_pages, get_wiki_page (mit Version)

• create_or_update_wiki_page (PUT-Upsert)

• delete_wiki_page

Anhänge und Dateien

• get_attachment, download_attachment (begrenzt auf 25 MiB, base64-Ausgabe)

• upload_attachment (gibt ein Token zurück, um es über uploads bei create_issue / update_issue anzuhängen)

• list_files, upload_file (One-Shot-Upload + Anhängen an den Dateibereich eines Projekts, mit optionaler version_id und Beschreibung)

Nachrichten, Abfragen, Suche und Metadaten

• list_news (projektübergreifend oder pro Projekt)

• list_queries (gespeicherte Abfragen; übergeben Sie die ID als query_id an list_issues)

• search (Volltextsuche über Tickets, Nachrichten, Dokumente, Wiki, etc.)

• list_issue_statuses, list_trackers, list_issue_categories, list_custom_fields

• list_issue_priorities, list_time_entry_activities, list_document_categories

Bereitstellung

Für eine einzelne Redmine-Instanz führen Sie einen Container pro Umgebung aus:

docker run -d --name redmine-mcp \
  --restart unless-stopped \
  -p 8080:8080 \
  -e REDMINE_URL=https://redmine.example.com \
  ghcr.io/kalvadtech/redmine-mcp:latest

Platzieren Sie ihn hinter Ihrem üblichen Reverse-Proxy und der TLS-Terminierung. Das MCP- Protokoll ist serverseitig nur HTTP; Benutzer erhalten TLS über Ihren Proxy.

Für mehrere Redmine-Instanzen führen Sie einen Container pro Instanz mit eigener REDMINE_URL aus und routen Sie am Proxy nach Hostname / Pfad.

Entwicklung

uv sync
uv run pytest
uv run ruff check .
uv run mypy src

Die Testsuite ist vollständig offline und verwendet respx, um die Redmine-HTTP-API zu mocken. Es gibt keine Integrationstests gegen ein Live-Redmine; bringen Sie Ihr eigenes mit.

Mitwirken

Pull Requests sind willkommen. Bitte:

• folgen Sie den Conventional Commits,

• halten Sie Änderungen prägnant und gut abgegrenzt (eine logische Änderung pro Commit),

• fügen Sie Tests für jede Verhaltensänderung hinzu oder aktualisieren Sie diese,

• führen Sie pytest, ruff und mypy sauber aus, bevor Sie den PR öffnen.

Lizenz

MIT (c) 2026 Kalvad.