GitLab Duo Agent Platform: MCP-Integration für KI

Künstliche Intelligenz kann die Entwicklung durch Code-Generierung, Debugging und Automatisierung von Routineaufgaben beschleunigen. Allerdings ist KI auf trainierte Daten oder öffentliche Quellen beschränkt, während Entwickler häufig Zugriff auf interne Systeme benötigen: Issue-Tracker, Dashboards, Datenbanken, Design-Dateien in Figma oder Dokumente in Google Drive.

Das Model Context Protocol (MCP), jetzt in die GitLab Duo Agent Platform integriert, ermöglicht der KI sicheren Zugriff auf interne Tools. Entwickler erhalten so umfassende Unterstützung direkt in ihrem Workflow.

Was ist MCP?

MCP wurde 2024 von Anthropic als offener Standard eingeführt und verbindet KI mit Daten und Tools. Das Protokoll funktioniert als sicherer bidirektionaler Kanal: MCP-Clients (KI-Anwendungen, autonome Agenten oder Entwicklungstools) fordern Daten oder Aktionen an, während MCP-Server autorisierte Antworten aus ihren verbundenen Datenquellen bereitstellen.

MCP-Server fungieren als sichere Brücken zu verschiedenen Systemen: Sie können sich mit Datenbanken, APIs, Dateisystemen, Cloud-Services oder beliebigen externen Tools verbinden, um Daten abzurufen und bereitzustellen. Dies ermöglicht KI-Tools, über ihre initialen Trainingsdaten hinauszugehen, indem sie auf Echtzeitinformationen zugreifen und Aktionen ausführen können – beispielsweise Meetings verschieben oder Kalender-Verfügbarkeiten prüfen. Dabei bleiben strikte Sicherheits-, Datenschutz- und Audit-Kontrollen gewahrt.

Warum nutzt KI MCP anstatt APIs direkt?

Die Frage liegt nahe: Warum MCP verwenden, wenn KI bereits System-APIs direkt aufrufen kann? Die Herausforderung besteht darin, dass jede API eigene Authentifizierungsmechanismen, Datenformate und Verhaltensweisen aufweist. KI müsste für jedes System eigene Konnektoren entwickeln und diese kontinuierlich warten, wenn sich APIs weiterentwickeln. Dies macht direkte Integrationen komplex und fehleranfällig.

MCP adressiert dieses Problem durch eine standardisierte, sichere Schnittstelle, die Authentifizierung, Berechtigungen und Datenübersetzung zentral behandelt. KI-Tools können so zuverlässig mit beliebigen Systemen verbinden, während die Integration vereinfacht wird und konsistentes, sicheres Verhalten gewährleistet bleibt.

GitLabs MCP-Unterstützung

GitLab erweitert Duo Agentic Chat um MCP-Unterstützung und beseitigt damit die bisherigen Einschränkungen, die KI von den täglichen Entwickler-Tools isoliert haben. Entwickler können auf ihr gesamtes Toolkit direkt aus ihrer bevorzugten IDE heraus zugreifen – in natürlicher Sprache. Die GitLab Duo Agent Platform liefert so umfassende Unterstützung, ohne den Entwicklungsfluss zu unterbrechen oder Kontextwechsel zu erzwingen.

In deutschen Unternehmen ist die Integration mit verschiedenen internen Systemen besonders relevant: Neben weit verbreiteten Tools wie JIRA, Confluence und Microsoft Teams kommen häufig auch unternehmensspezifische Ticketing-Lösungen, ERP-Systeme oder branchenspezifische Anwendungen zum Einsatz. Die MCP-Integration ermöglicht es der KI, mit diesem heterogenen Tool-Ökosystem zu arbeiten, ohne für jedes System separate Integrationen entwickeln zu müssen.

GitLab bietet umfassende MCP-Unterstützung durch zwei komplementäre Workflows:

• MCP-Client-Workflow: Die Duo Agent Platform fungiert als MCP-Client und ermöglicht Features den Zugriff auf verschiedene externe Tools und Services.

• MCP-Server-Workflow: GitLab stellt auch MCP-Server-Funktionen bereit, sodass KI-Tools und Anwendungen wie Claude Desktop, Cursor und andere MCP-kompatible Tools sicher mit deiner GitLab-Instanz verbinden können.

Interaktive Demo des MCP-Client-Workflows

Typisches Szenario an einem Montagmorgen: Der Checkout-Service eines Unternehmens erzeugt Timeout-Fehler. Kunden können keine Käufe abschließen, und du musst schnell untersuchen. Normalerweise würdest du JIRA öffnen, um das Incident-Ticket zu prüfen, durch Slack scrollen für Updates und Grafana-Dashboards auf Fehler-Spitzen überprüfen. Mit GitLabs MCP-Unterstützung kannst du all dies in natürlicher Sprache direkt aus dem Chat in deiner IDE erledigen. MCP korreliert Daten aus allen deinen Systemen und liefert sofort das vollständige Bild – ohne den Entwicklungsworkflow zu verlassen.

Um diese Funktionalität selbst zu erleben, haben wir eine interaktive Demo erstellt, die das Payment-Service-Szenario illustriert. Klicke auf das Bild unten, um die Demo zu starten.

GitLab MCP-Client einrichten

Bevor du Daten über GitLab Duo Agentic Chat oder den Software Development Flow abfragen kannst, musst du MCP in deiner Entwicklungsumgebung konfigurieren. Die Schritte umfassen:

• Feature-Vorschau aktivieren — Navigiere in deinen Gruppeneinstellungen zu GitLab Duo in der linken Seitenleiste und aktiviere die Checkbox "Experimentelle und Beta-Features von GitLab Duo aktivieren" im Bereich Feature-Vorschau.

• MCP für deine Gruppe aktivieren — Aktiviere MCP-Unterstützung in deinen GitLab-Gruppeneinstellungen, damit Duo-Features sich mit externen Systemen verbinden können.

• MCP-Server einrichten — Definiere die MCP-Server im JSON-Format in der Datei mcp.json. Erstelle die Datei an diesem Speicherort:

  • Windows: C:\Users\<username>\AppData\Roaming\GitLab\duo\mcp.json
  • Alle anderen Betriebssysteme: ~/.gitlab/duo/mcp.json

Für Workspace-spezifische Konfigurationen siehe Workspace-Konfiguration einrichten.

    {
      "mcpServers": {
        "server-name": {
          "type": "stdio",
          "command": "path/to/server",
          "args": ["--arg1", "value1"],
          "env": {
            "ENV_VAR": "value"
          }
        },
        "http-server": {
          "type": "http",
          "url": "http://localhost:3000/mcp"
        },
        "sse-server": {
          "type": "sse",
          "url": "http://localhost:3000/mcp/sse"
        }
      }
    }

Die Konfiguration unterstützt verschiedene Verbindungstypen: `stdio` für lokale Prozesse, `http` für HTTP-Services und `sse` für Server-Sent Events. Dies ermöglicht flexible Integration mit unterschiedlichen MCP-Server-Implementierungen.

- **IDE installieren und konfigurieren** — Stelle sicher, dass VSCodium oder Visual Studio Code zusammen mit der GitLab Workflow Extension installiert ist (Version 6.28.2 oder höher für grundlegende MCP-Unterstützung, 6.35.6 oder höher für vollständige Unterstützung).

Vollständige Schritt-für-Schritt-Anleitungen, Konfigurationsbeispiele und Troubleshooting-Tipps findest du in der [GitLab MCP-Clients-Dokumentation](https://docs.gitlab.com/user/gitlab_duo/model_context_protocol/mcp_clients/).

## Beispielprojekt

Ergänzend zur Demo teilen wir das Projekt, das als Grundlage diente. Dieses Projekt ermöglicht es dir, denselben Flow in deiner eigenen Umgebung zu reproduzieren und GitLabs MCP-Funktionen hands-on zu erkunden.

Es demonstriert MCP-Funktionalität in einem simulierten Enterprise-Setup mit Mock-Daten aus JIRA, Slack und Grafana, um ein Incident-Response-Szenario zu modellieren. Die mitgelieferte `mcp.json`-Konfiguration zeigt, wie man sich mit einem lokalen MCP-Server (`enterprise-data-v2`) verbindet oder das Setup optional mit AWS-Services für Cloud-Integration erweitert.

    {
      "mcpServers": {
        "enterprise-data-v2": {
          "type": "stdio",
          "command": "node",
          "args": ["src/server.js"],
          "cwd": "/path/to/your/project"
        },
        "aws-knowledge": {
          "type": "stdio",
          "command": "npx",
          "args": ["mcp-remote", "https://knowledge-mcp.global.api.aws"]
        },
        "aws-console": {
          "type": "stdio",
          "command": "npx",
          "args": ["@imazhar101/mcp-aws-server"],
          "env": {
            "AWS_REGION": "YOUR_REGION",
            "AWS_PROFILE": "default"
          }
        }
      }
    }

Sicherheitshinweis: Der aws-console-Eintrag nutzt ein Community-entwickeltes MCP-Server-Package (@imazhar101/mcp-aws-server) für AWS-Integration, das nicht unabhängig verifiziert wurde. Dies ist ausschließlich für Demonstrations- und Lernzwecke vorgesehen. Für den Produktiveinsatz sollten Packages gründlich evaluiert oder offizielle Alternativen verwendet werden.

Konfiguriere AWS-Credentials über AWS CLI-Profile oder IAM-Rollen, anstatt sie direkt in der Konfigurationsdatei zu hinterlegen. Das AWS SDK erkennt Credentials automatisch aus deiner Umgebung – dies ist der empfohlene Ansatz für Enterprise-Governance und Sicherheits-Compliance.

Um zu starten, clone das Projekt, installiere Dependencies mit npm install und starte dann den lokalen MCP-Server mit npm start. Erstelle eine ~/.gitlab/duo/mcp.json-Datei mit der obigen Konfiguration, aktualisiere den Dateipfad entsprechend deinem lokalen Setup und starte VS Code neu, um die MCP-Konfiguration zu laden. Optional kannst du deine AWS-Credentials hinzufügen, um Live-Cloud-Integration zu erleben.

Projekt hier klonen: GitLab Duo MCP Demo.

Beispiel-Prompts für das Demo-Projekt

Sobald du das Beispielprojekt konfiguriert hast, kannst du deine Daten und Tools direkt aus GitLab Duo Agentic Chat in deiner IDE erkunden. Hier sind einige Prompts zum Ausprobieren:

• "What tools can you access through MCP?"

• "Show me recent Slack discussions about the database issues."

GitLab MCP-Server-Funktionen

Bisher haben wir betrachtet, wie die GitLab Duo Agent Platform als MCP-Client agiert und sich mit externen MCP-Servern verbindet. Nun schauen wir uns die GitLab MCP-Server-Funktionen an.

Der GitLab MCP-Server ermöglicht KI-Tools wie Cursor oder Claude Desktop, sich sicher mit deiner GitLab-Instanz zu verbinden und über natürliche Sprache mit deinen Entwicklungsdaten zu arbeiten. Die Authentifizierung erfolgt über OAuth 2.0 Dynamic Client Registration, sodass KI-Tools sich automatisch registrieren und mit ordnungsgemäßer Autorisierung auf deine GitLab-Daten zugreifen können.

Für den Einsatz in regulierten Branchen sind die OAuth 2.0-Authentifizierung und die vollständigen Audit-Trails wichtige Voraussetzungen. Die Kennzeichnung als experimentelles Feature mit Feature-Flags ermöglicht eine kontrollierte Evaluierung in Test-Umgebungen, bevor die Technologie in produktiven Systemen eingesetzt wird. Bei Self-Managed-Instanzen verbleiben alle Daten in der eigenen Infrastruktur.

Aktuell unterstützt der Server:

• Issues — Details abrufen oder neue Issues erstellen
• Merge Requests — Details, Commits und Dateiänderungen anzeigen
• Pipelines — Jobs und Pipelines für Merge Requests auflisten
• Server-Info — MCP-Server-Version prüfen

Die vollständige Liste verfügbarer Tools und Funktionen findest du in der MCP-Server-Dokumentation.

Interaktive Demo: GitLab MCP-Server in Aktion

Erlebe den GitLab MCP-Server selbst mit unserer interaktiven Demo.

Sie führt dich durch das Einrichten von Cursor mit dem MCP-Server und die Nutzung von Cursor Chat, um sicher mit deiner GitLab-Instanz zu verbinden. Du siehst, wie du Aktionen wie das Anzeigen von Issues, das Erstellen eines neuen Issues und das Prüfen von Merge Requests durchführst – alles direkt über natürliche Sprache, ohne deine Entwicklungsumgebung zu verlassen.

MCP-Server in deinem KI-Tool konfigurieren

Voraussetzungen:

• Stelle sicher, dass Node.js und npm installiert sind
• Prüfe, dass npx global verfügbar ist, indem du npx --version in deinem Terminal ausführst

1. Feature-Flags aktivieren

   • Aktiviere mcp_server und oauth_dynamic_client_registration in deiner GitLab-Instanz.

2. GitLab MCP-Server-Konfiguration zu deinem KI-Tool hinzufügen

   • Füge den MCP-Server-Eintrag zur Konfigurationsdatei deines Tools hinzu (mcp.json für Cursor, claude_desktop_config.json für Claude Desktop):

    {
      "mcpServers": {
        "GitLab": {
          "command": "npx",
          "args": [
            "mcp-remote",
            "https://<your-gitlab-instance>/api/v4/mcp",
            "--static-oauth-client-metadata",
            "{\"scope\": \"mcp\"}"
          ]
        }
      }
    }

Registrierung und Authentifizierung

Bei der ersten Verbindung wird das KI-Tool automatisch:

• Sich als OAuth-Anwendung registrieren
• Autorisierung für den MCP-Scope anfordern

Autorisierung im Browser

Beim Verbinden öffnet der MCP-Client automatisch deinen Standard-Browser, um den OAuth-Flow abzuschließen. Prüfe und genehmige die Anfrage in GitLab, um Zugriff zu gewähren und ein Access-Token für sicheren API-Zugriff zu erhalten.

MCP-Server nutzen

Sobald dein KI-Tool mit dem MCP-Server verbunden ist, kannst du sicher auf GitLab-Daten (Issues, Merge Requests und Pipelines) zugreifen und darauf reagieren – direkt aus deiner Entwicklungsumgebung über natürliche Sprache. Beispiele:

• Get details for issue 42 in project 123
• Create a new issue titled "Fix login bug" with description about password special characters
• Show me all commits in merge request 15 from the gitlab-org/gitlab project
• What files were changed in merge request 25?
• Show me all jobs in pipeline 12345

Dieses Feature ist experimentell, über ein Feature-Flag gesteuert und noch nicht für den Produktiveinsatz bereit.

Vollständige Schritt-für-Schritt-Anleitungen, Konfigurationsbeispiele und Troubleshooting-Tipps findest du in der GitLab MCP-Server-Dokumentation.

Zusammenfassung

Die GitLab Duo Agent Platform führt umfassende Unterstützung für MCP ein und ermöglicht KI-gestützte Entwicklungsworkflows. Mit MCP-Unterstützung agiert GitLab sowohl als Client als auch als Server:

• MCP-Client: Die GitLab Duo Agent Platform kann sicher auf Daten und Tools aus externen Systemen zugreifen und bringt reichhaltigen Kontext direkt in die IDE.

• MCP-Server: Externe KI-Tools wie Cursor oder Claude Desktop können sich mit deiner GitLab-Instanz verbinden, auf Projektdaten zugreifen und Aktionen durchführen – bei strikter Wahrung von Sicherheit und Datenschutz.

Diese bidirektionale Unterstützung reduziert Kontextwechsel, beschleunigt Entwickler-Workflows und stellt sicher, dass KI über dein gesamtes Toolkit hinweg sinnvolle Unterstützung leisten kann.

Heute ausprobieren

Probiere die Beta der GitLab Duo Agent Platform aus und erkunde die MCP-Funktionen.

Weiterführende Informationen

• GitLab 18.4: AI-native development with automation and insight
• Agentic AI guides and resources
• What is Model Context Protocol?