GitLab MCP Server

Verbinde deinen KI-Assistenten mit GitLab, damit er Merge Requests prüfen, Pipelines auswerten, Issues verwalten und Releases entwerfen kann – in einfacher Sprache. Ein einziges statisches Binary (oder ein Container), 1000+ GitLab-Tools für die gesamte REST- und GraphQL-API, kompatibel mit Claude, Cursor, VS Code und jedem MCP-Client.

Du sprichst mit deinem KI-Assistenten; er erledigt die GitLab-Arbeit. Keine Projekt-IDs, API-Endpunkte oder JSON, die du dir merken musst.

„Prüfe Merge Request !15 – ist er sicher zu mergen?" · „Warum ist die letzte Pipeline fehlgeschlagen?" · „Liste offene Issues auf, die mir zugewiesen sind" · „Erstelle Release Notes von v1.0 bis v2.0"

🤖 Nutzt du einen KI-Assistenten? Gib ihm diese Repository-URL und bitte ihn, den Server für deinen Client zu installieren. Alles, was ein Modell braucht, um das ohne Benutzeroberfläche zu erledigen – die deklarative Konfiguration pro Client, claude mcp add-Einzeiler und die Standardwerte – steht in llms.txt (kein interaktiver Assistent erforderlich).

Installation in 60 Sekunden

Wähle eine Option. Jeder Weg endet damit, dass du deinem Assistenten einen Prompt eingibst.

Installation mit einem Klick

Jeder Button registriert den Docker-basierten Server (das Image wird beim ersten Start automatisch gezogen; du musst Docker installiert haben). In der Zeile Claude Desktop wird stattdessen eine native .mcpb-Desktop-Erweiterung heruntergeladen (macOS universal + Windows, kein Docker) – öffne sie mit Claude Desktop und trage die Einstellungen ein. Du brauchst einen Token? Erstelle ein Personal Access Token mit dem api-Scope. Self-managed GitLab? Füge nach der Installation eine GITLAB_URL-Umgebungsvariable in der MCP-Konfiguration deines Clients hinzu.

Claude Code (claude mcp add)

Docker (keine Installation – zieht das Image beim ersten Start):

claude mcp add gitlab --env GITLAB_TOKEN=glpat-xxxx --transport stdio \
  -- docker run -i --rm -e GITLAB_TOKEN ghcr.io/jmrplens/gitlab-mcp-server:latest --http=false

Oder installiere zuerst das native Binary und registriere es dann:

# macOS/Linux (Homebrew)
brew install jmrplens/tap/gitlab-mcp-server
# Linux/macOS (script)
curl -fsSL https://raw.githubusercontent.com/jmrplens/gitlab-mcp-server/main/scripts/install.sh | sh
# Windows (winget)
winget install --id jmrplens.gitlab-mcp-server -e
# Windows (PowerShell)
irm https://raw.githubusercontent.com/jmrplens/gitlab-mcp-server/main/scripts/install.ps1 | iex

claude mcp add gitlab --env GITLAB_TOKEN=glpat-xxxx -- gitlab-mcp-server

Self-managed GitLab? Füge --env GITLAB_URL=https://gitlab.example.com hinzu (und --env GITLAB_SKIP_TLS_VERIFY=true für selbstsignierte Zertifikate).

Geführte Einrichtung (jeder Client, keine Flags zum Merken)

Das Binary enthält einen Setup-Assistenten, der dein GitLab-Token abfragt und deinen MCP-Client für dich konfiguriert – ideal, wenn du kein JSON bearbeiten möchtest:

gitlab-mcp-server --setup

Er erkennt VS Code, Claude Desktop, Claude Code, Cursor und Windsurf automatisch und schreibt die passende Konfiguration. Unter Windows startest du ihn per Doppelklick auf die .exe.

Manuelles JSON (Claude Desktop, Cursor, VS Code, …)

Natives Binary (Claude Desktop mcpServers, Cursor usw.):

{
  "mcpServers": {
    "gitlab": {
      "command": "/path/to/gitlab-mcp-server",
      "env": { "GITLAB_TOKEN": "glpat-xxxxxxxxxxxxxxxxxxxx" }
    }
  }
}

VS Code (.vscode/mcp.json, beachte servers + type):

{
  "servers": {
    "gitlab": {
      "type": "stdio",
      "command": "/path/to/gitlab-mcp-server",
      "env": { "GITLAB_TOKEN": "glpat-xxxxxxxxxxxxxxxxxxxx" }
    }
  }
}

Docker-Variante – ersetze "command"/"args" durch:

"command": "docker",
"args": ["run", "-i", "--rm", "-e", "GITLAB_TOKEN", "ghcr.io/jmrplens/gitlab-mcp-server:latest", "--http=false"]

Cline (VS Code) – öffne die Cline-Seitenleiste → MCP-Server-Symbol → Edit Global MCP oder bearbeite direkt die Einstellungsdatei:

• macOS: ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json

• Linux: ~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json

• Windows: %APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json

Cline verwendet die oben gezeigte mcpServers-Struktur für das native Binary.

Für ein gemeinsames, langlaufendes HTTP-Deployment anstelle von stdio pro Benutzer siehe HTTP-Server-Modus.

Ausprobieren ohne Installation (gehosteter Endpunkt)

Eine öffentliche Instanz läuft unter https://mcp.jmrp.io/gitlab – keine Installation, kein Konto außer deinem eigenen GitLab-Token. Richte einen beliebigen HTTP-fähigen MCP-Client darauf aus:

{
  "mcpServers": {
    "gitlab": {
      "type": "http",
      "url": "https://mcp.jmrp.io/gitlab",
      "headers": { "PRIVATE-TOKEN": "glpat-xxxxxxxxxxxx" }
    }
  }
}

PRIVATE-TOKEN ist erforderlich und wird pro Anfrage mitgesendet – er wird nie auf dem Server gespeichert. GITLAB-URL ist optional und standardmäßig auf https://gitlab.com gesetzt; setze sie, um eine andere Instanz zu erreichen (sie muss aus dem öffentlichen Internet erreichbar sein).

Das ist der schnellste Weg, den Server auszuprobieren, und die richtige Art, ihn dauerhaft zu nutzen, ist immer noch lokal (eine der Optionen oben) – aus einem konkreten Grund, nicht als Haftungsausschluss: Dein Token und jede Anfrage laufen über die Maschine eines anderen. Wenn du ihn lokal ausführst, verlassen deine Zugangsdaten und dein GitLab-Datenverkehr deinen Computer nie – das macht ihn auch zur einzig sinnvollen Option für eine private Self-managed-Instanz.

Der Endpunkt ist stateless streamable HTTP auf der standardmäßigen dynamic-Oberfläche: POST ist der Transport, GET darauf antwortet absichtlich mit 405, und https://mcp.jmrp.io/gitlab/health antwortet mit 200 und {"status":"ok",…}. Ein selbst gehostetes HTTP-Deployment kann auch mit --auth-mode=oauth --gitlab-url=https://gitlab.com --public-url=https://mcp.example.com ausgeführt werden (beide sind erforderlich: OAuth benötigt eine feste Instanz und den von außen erreichbaren Origin, über den RFC 9728 die Ressource identifiziert). Dabei entdecken Clients GitLab über diese Metadaten als Autorisierungsserver und autorisieren im Browser, statt Token zu kopieren – siehe OAuth-App-Setup. Er ist einer der Server, die unter mcp.jmrp.io aufgelistet sind, einem Verzeichnis der MCP-Server, die ich pflege; jeder ist über einen eigenen Endpunkt erreichbar. https://mcp.jmrp.io/servers.json ist dieselbe Liste für automatisierte Clients.

Dann frag einfach: Öffne deinen KI-Client und probiere „Liste meine GitLab-Projekte auf.“ Siehe den Leitfaden „Getting Started“ für Details pro Client und weitere Beispiel-Prompts.

Related MCP server: mcp-gitlab-jira

Warum dieser Server

• GitLab in klarer Sprache. Die KI übersetzt „Ist MR !15 sicher zu mergen?“ in die richtigen API-Aufrufe. Du musst keine Endpunkte, IDs oder JSON anfassen.

• Die gesamte Plattform – 1000+ Tools. Breite Abdeckung von GitLab REST v4 + GraphQL: Projekte, Branches, Tags, Releases, Merge Requests, Issues, Pipelines, Jobs, Gruppen, Benutzer, Wikis, Umgebungen, Deployments, Pakete, Container-Registry, Runner, Feature Flags, CI/CD-Variablen, Sicherheit, Admin, Tokens und mehr.

• Standardmäßig mit geringem Token-Verbrauch. Die standardmäßige dynamische Oberfläche stellt nur 2 Tools (find + execute) bereit und erreicht dabei den gesamten Katalog – passt also in das Kontextfenster jedes Clients. (Token-Verbrauch →)

• Mit echten Modellen erprobt. Ein automatisierter Evaluator führt Anthropic, Google, OpenAI und Qwen gegen Live-GitLab-Instanzen aus: 99,5 % Gesamterfolg bei Tausenden von Operationen. (Ergebnisse →)

• Sicher per Design. Read-only-Modus, Safe-Modus (Dry-Run-Vorschau jeder Mutation), TLS-Optionen für selbst gehostetes GitLab und kontinuierliche Qualitäts-/Sicherheits-Gates von SonarCloud.

• Läuft überall. Eine einzelne statische Binärdatei oder ein Container; Windows, Linux & macOS; amd64 & arm64; stdio (Desktop) und HTTP (remote).

• 45 MCP-Ressourcen (schreibgeschützte Daten: Projekte, Issues, Pipelines, MRs, Branches, Mitglieder, das oberflächenbewusste gitlab://tools-Manifest und Best-Practice-Leitfäden für Workflows). 26 Einzelobjekt-Arten sind ebenfalls abonnierbar.

• 37 MCP-Prompts (Code-Review, Pipeline-Status, Risikobewertung, Release-Notes, Standup, Analysen, Audit und mehr).

• 4 Elicitation-Assistenten (interaktive Issue/MR/Release/Projekt-Erstellung).

• 4 MCP-Fähigkeiten (Completions, Fortschritt, Elicitation und Ressourcen-Abonnements – Live-resources/updated-Benachrichtigungen, die per Polling bedient werden) und 51 Tool-Icons (50 Bereichs-Icons plus das Projekt-Logo) zur visuellen Identifikation in MCP-Clients.

• Paginierung bei jedem Listen-Endpunkt mit vollständigen Metadaten.

Tool-Oberflächen

Der Server kann GitLab in drei Formen präsentieren, gesteuert über TOOL_SURFACE. Die Standardeinstellung erfordert keine Konfiguration.

Die Tool-Anzahl skaliert mit deiner GitLab-Edition (GITLAB_TIER); höhere Stufen legen mehr Aktionen offen. Siehe Dynamic Toolset und Meta-Tools-Referenz für das Ranking-Modell, die Sicherheitsvorkehrungen und die vollständigen Kataloge. Für dynamische Läufe, bei denen Ressourcen den Kontext dominieren, setze CAPABILITY_SURFACE=minimal.

Token-Verbrauch

Gemessen mit go run ./cmd/audit_tokens/ -footprint gegen den aktuellen Katalog. Die Summen schätzen den Startkontext, der für einen MCP-Client sichtbar ist: sichtbare Tool-Schemas plus gemeinsame Ressourcen und Prompts, unter Verwendung des cl100k_base-Tokenizers (GPT-4/GPT-3.5-Codierung). Für die vollständige Matrix (Meta- und Einzel-Oberflächen, alle META_PARAM_SCHEMA-Modi) siehe Token-Footprint-Referenz.

Standardkonfiguration: Mit nicht gesetztem TOOL_SURFACE bzw. TOOL_SURFACE=dynamic, CAPABILITY_SURFACE=full, nicht gesetztem META_TOOLS, META_PARAM_SCHEMA=opaque und nicht gesetztem GITLAB_TIER (wird erkannt, Fallback free) verwendet der Server die dynamische find/execute-Oberfläche. Verwende TOOL_SURFACE=meta nur, wenn du explizit Domain-Meta-Tools möchtest; verwende TOOL_SURFACE=individual nur, wenn dein Client den vollständigen Tool-Katalog verarbeiten kann.

Die Zeilen verwenden den Community-Edition-Basiskatalog, sofern die Spalte „Stufe“ nichts anderes angibt. GITLAB_TIER steuert, welche Aktionen verfügbar sind; höhere Stufen legen mehr Tools und damit mehr erreichbare Aktionen offen.

Kompatibilität

Getestet mit: VS Code + GitHub Copilot, Claude Desktop, Claude Code, Cursor, Windsurf, JetBrains-IDEs, Zed, Kiro, Cline. Siehe die vollständige Kompatibilitätsmatrix.

Bewertung der Tool-Nutzung von KI-Modellen

Das Projekt enthält einen automatisierten Evaluator für die modellseitige MCP-Qualität. Er führt reine Schema-Prüfungen gegen den Tool-Katalog aus oder führt validierte Modell-Tool-Aufrufe über MCP gegen Docker-GitLab-CE- oder lizenzierte Enterprise-Instanzen aus, die mit Fixtures bestückt sind. Er misst, ob jedes Modell die richtige Aktion wählt, gültige Parameter sendet, sich von behebbaren GitLab-Fehlern erholt und die Sicherheitsvorkehrungen für destruktive Aktionen respektiert – über Anthropic, Google, OpenAI und Qwen hinweg.

Aktuell veröffentlichtes Ergebnis: Docker CE dynamic 20260627-232303.

Der veröffentlichte Modell-Evaluationssatz umfasst 596 Aufgabenversuche und 2220 erwartete MCP-Operationen. Über die ausgewählten Berichte hinweg erzeugten Modelle 2265 Tool-Aufrufe bei 2265 Modellanfragen, mit 99,5 % aggregiertem End-Erfolg. Siehe KI-Modell-Evaluationsergebnisse für die detaillierte aktuelle Matrix.

Aktuell veröffentlichtes Ergebnis: Docker Enterprise meta 20260527.

Dokumentation

Die vollständige Dokumentation findest du unter jmrp.io/docs/gitlab-mcp-server. Nutze diese Übersicht als maßgebliche Referenz für einen bestimmten Bereich:

FAQ

Ja. Setze GITLAB_URL auf die URL deiner Instanz. Wenn GITLAB_URL weggelassen wird, verwendet der stdio-Modus https://gitlab.com. Selbstsignierte TLS-Zertifikate werden über GITLAB_SKIP_TLS_VERIFY=true unterstützt.

Wenn du den Server selbst ausführst – lokal über stdio oder in deiner eigenen Infrastruktur über HTTP – gehen alle API-Aufrufe direkt an deine GitLab-Instanz. Die einzige Anfrage, die an einen anderen Ort geht, ist die Update-Prüfung gegen GitHub Releases, die standardmäßig aktiviert und mit AUTO_UPDATE=false deaktiviert werden kann.

Die Ausnahme ist der gehostete Endpunkt: Die Verwendung von https://mcp.jmrp.io/gitlab bedeutet, dass dein Token und jede Anfrage über diese Maschine laufen. Dort wird nichts gespeichert, aber es ist ein fremder Server – genau deshalb sagt der Abschnitt zum gehosteten Dienst, dass du ihn weiterhin lokal verwenden sollst.

Siehe PRIVACY.md für genau das, was die Update-Prüfung sendet, und SECURITY.md für das Sicherheitsmodell.

Ja. Setze GITLAB_READ_ONLY=true, um alle ändernden Tools (create, update, delete) zu deaktivieren. Es sind dann nur noch Leseoperationen verfügbar.

Alternativ kannst du GITLAB_SAFE_MODE=true für einen Trockenlauf-Modus setzen: Ändernde Tools bleiben sichtbar, geben aber eine strukturierte JSON-Vorschau zurück, anstatt ausgeführt zu werden. Das ist nützlich für Audits, Schulungen oder um zu prüfen, was ein KI-Assistent tun würde.

Sowohl Community Edition (CE) als auch Enterprise Edition (EE). Setze GITLAB_TIER=premium oder GITLAB_TIER=ultimate im stdio-Modus, um zusätzliche Tools für Premium-/Ultimate-Funktionen zu aktivieren (DORA-Metriken, Schwachstellen, Compliance usw.); lasse es ungesetzt, um die Stufe anhand der Instanzlizenz zu erkennen (Fallback free). Im HTTP-Modus kann --tier die Stufe erzwingen, andernfalls wird sie pro Token+URL-Pooleintrag aus der Lizenz erkannt.

Der Server enthält eine Wiederholungslogik mit Backoff für Rate-Limits der GitLab-API. Fehler werden als vorübergehend (wiederholbar) oder dauerhaft klassifiziert, mit umsetzbaren Hinweisen in den Fehlermeldungen.

Jeder MCP-kompatible Client: VS Code + GitHub Copilot, Claude Desktop, Cursor, Claude Code, Windsurf, JetBrains-IDEs, Zed, Kiro und andere. Der integrierte Setup-Assistent kann die meisten Clients automatisch konfigurieren.

Aus dem Quellcode erstellen

git clone https://github.com/jmrplens/gitlab-mcp-server.git
cd gitlab-mcp-server
make build

Das veröffentlichte Container-Image ist ghcr.io/jmrplens/gitlab-mcp-server:latest. Weitere Informationen zu Cross-Kompilierung, Docker Compose und Mitwirkungsrichtlinien findest du im Development Guide.

Datenschutzerklärung

Der Server läuft vollständig auf deiner Maschine und hat keine Telemetrie, kein Analytics und kein eigenes Backend – Daten fließen nur zwischen deinem MCP-Client und der von dir konfigurierten GitLab-Instanz (plus einer optionalen Update-Prüfung signierter Binärdateien gegen GitHub Releases). Dein Token wird ausschließlich zur Authentifizierung von GitLab-Anfragen verwendet und niemals protokolliert. Vollständige Details: PRIVACY.md.

Mitwirken & Sicherheit

• Mitwirken: Siehe CONTRIBUTING.md für Entwicklungsrichtlinien, Branch-Namenskonventionen, Commit-Konventionen und den PR-Prozess.

• Sicherheit: Siehe SECURITY.md für die Sicherheitsrichtlinie und die Meldung von Schwachstellen.

• Verhaltenskodex: Siehe CODE_OF_CONDUCT.md (Contributor Covenant v2.1).

Repository-Spiegel: GitHub ist das kanonische Repository. Ein schreibgeschützter Spiegel ist auf GitLab.com für die Auffindbarkeit verfügbar; bitte reiche Beiträge über GitHub ein.

Dateianzahl

Funktionen

Bemerkenswerte Verhältnisse

Codemuster

Projekt

Ruhmeshalle

Weil wir es können

Gepflegt von José M. Requena Plens · Projektseite · Gehostete Instanz: mcp.jmrp.io/gitlab