Model Context Protocol Integration

Willkommen zu Teil 7 unseres achtteiligen Leitfadens GitLab Duo Agent Platform: Der vollständige Einstiegsleitfaden, in dem du lernst, KI-Agenten und Workflows in deinem Entwicklungslebenszyklus zu erstellen und bereitzustellen. Folge Tutorials, die dich von deiner ersten Interaktion zu produktionsreifen Automatisierungs-Workflows mit vollständiger Anpassung führen.

In diesem Artikel:

• Was ist Model Context Protocol (MCP)
• GitLab als MCP-Client (Verbindung zu externen Services)
• GitLab als MCP-Server (externe KI-Tools greifen auf GitLab zu)
• Setup und Konfiguration
• Real-World-Beispiele

KI kann die Entwicklung beschleunigen, indem sie Code generiert, debuggt und Routineaufgaben automatisiert. Aber allein ist sie auf trainierte Daten oder öffentliche Quellen beschränkt, während Entwickler(innen) oft Zugriff auf interne Systeme wie Project-Tracker, Dashboards, Datenbanken, Design-Dateien in Figma oder Dokumente in Google Drive benötigen. Jetzt in die GitLab Duo Agent Platform integriert, gibt das Model Context Protocol (MCP) KI sicheren Zugriff auf interne Services, sodass Entwickler(innen) umfassende Unterstützung direkt in ihren Workflows erhalten können.

🎯 Probiere GitLab Duo Agent Platform noch heute aus!

Was ist MCP?

MCP, erstmals 2024 von Anthropic eingeführt, ist ein offener Standard, der KI mit Daten und Tools verbindet. Es funktioniert als sicherer bidirektionaler Kanal: MCP-Clients (KI-Anwendungen, autonome Agenten oder Entwicklungstools) fordern Daten oder Aktionen an, und MCP-Server liefern vertrauenswürdige, autorisierte Antworten von ihren verbundenen Datenquellen. MCP-Server fungieren als sichere Brücken zu verschiedenen Systemen: Sie können sich mit Datenbanken, APIs, Dateisystemen, Cloud-Services oder jedem externen Service verbinden, um Daten abzurufen und bereitzustellen. Dies ermöglicht es KI-Tools und -Agenten, über ihre anfänglichen Trainingsdaten hinauszugehen, indem sie auf Echtzeit-Informationen zugreifen und Aktionen ausführen können, wie das Umplanen von Meetings oder Überprüfen der Kalenderverfügbarkeit, während strikte Sicherheits-, Datenschutz- und Audit-Kontrollen aufrechterhalten werden.

Entwickler-fokussierte MCP-Beispiele

Entwickler(innen) erschließen leistungsstarke Fähigkeiten, wenn sie MCP mit ihren Entwicklungstools und Workflows verbinden. Hier sind praktische Beispiele, was KI mit MCP-Servern in einem Entwicklungskontext tun kann:

• Offene Issues überprüfen und Merge Requests erstellen
• Deployment-Logs und Error-Traces abrufen
• Team-Kommunikation in Slack über technische Entscheidungen prüfen
• Meetings umplanen oder Kalenderverfügbarkeit für Team-Koordination prüfen

Diese entwickler-fokussierten Fähigkeiten ermöglichen es KI, sinnvolle Unterstützung direkt in den Workflows von Entwickler(innen) bereitzustellen, ohne Context-Switching zwischen Tools zu erfordern.

Warum MCP verwenden?

Du fragst dich vielleicht: Warum MCP verwenden, wenn KI bereits direkt System-APIs aufrufen kann? Die Herausforderung ist, dass jede API ihre eigene Authentifizierung, Datenformate und Verhaltensweisen hat, was erfordern würde, dass KI Custom Connectors für jedes System verwendet und diese kontinuierlich wartet, während sich APIs weiterentwickeln, was direkte Integrationen komplex und fehleranfällig macht. MCP adressiert dies, indem es eine standardisierte, sichere Schnittstelle bereitstellt, die Authentifizierung, Berechtigungen und Datenübersetzung handhabt. Dies ermöglicht es KI-Tools, sich zuverlässig mit jedem System zu verbinden, während Integration vereinfacht und konsistentes, sicheres Verhalten gewährleistet wird.

GitLabs MCP-Unterstützung

GitLab erweitert Duo Agentic Chat mit MCP-Unterstützung und durchbricht die Barrieren, die KI zuvor von den Tools isoliert haben, die Entwickler(innen) täglich verwenden. Dies ermöglicht es Entwicklern, direkt von ihrer bevorzugten IDE aus in natürlicher Sprache auf ihr gesamtes Toolkit zuzugreifen, sodass GitLab Duo Agent Platform umfassende Unterstützung liefern kann, ohne den Entwicklungsflow zu unterbrechen oder störende Context-Switches zu erzwingen. GitLab bietet umfassende MCP-Unterstützung durch zwei komplementäre Workflows:

• MCP-Client-Workflow: Duo Agent Platform dient als MCP-Client und ermöglicht Features den Zugriff auf verschiedene externe Tools und Services.
• MCP-Server-Workflow: GitLab bietet auch MCP-Server-Fähigkeiten und ermöglicht KI-Tools und -Anwendungen wie Claude Desktop, Cursor und anderen MCP-kompatiblen Tools, sich sicher mit deiner GitLab-Instanz zu verbinden.

Interaktive Walkthrough-Demo des MCP-Client-Workflows

Stell dir dieses typische Montagmorgen-Szenario vor: Der Checkout-Service deines Unternehmens wirft Timeout-Errors. Kunden können keine Käufe abschließen, und du musst schnell untersuchen. Normalerweise würdest du Jira öffnen, um das Incident-Ticket zu überprüfen, durch Slack für Updates scrollen und Grafana-Dashboards auf Error-Spikes überprüfen. Mit GitLabs MCP-Unterstützung kannst du all dies in natürlicher Sprache direkt aus dem Chat in deiner IDE tun. MCP korreliert Daten über all deine Systeme hinweg und gibt dir sofort das vollständige Bild, ohne deinen Entwicklungs-Workflow zu verlassen. Um diese Fähigkeit aus erster Hand zu erleben, haben wir einen interaktiven Walkthrough erstellt, der das obige Payment-Service-Szenario illustriert. Klicke auf das Bild unten, um die Demo zu starten.

GitLab MCP-Client einrichten

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

• Feature Preview aktivieren – Navigiere in deinen Group-Einstellungen zu GitLab Duo in der linken Sidebar und aktiviere die Checkbox für „Turn on experiment and beta GitLab Duo features" unter dem Feature preview-Bereich.
• MCP für deine Group aktivieren – Aktiviere MCP-Unterstützung in deinen GitLab-Group-Einstellungen, um Duo-Features die Verbindung zu externen Systemen zu ermöglichen.
• MCP-Server einrichten – Definiere die MCP-Server im JSON-Format in der mcp.json-Datei. 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-Setup. json { "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" } } }

• 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 später für grundlegende MCP-Unterstützung, 6.35.6 oder später für volle Unterstützung). Für vollständige Schritt-für-Schritt-Anweisungen, Konfigurationsbeispiele und Troubleshooting-Tipps siehe die GitLab MCP Clients Dokumentation.

Beispielprojekt

Um den Walkthrough zu ergänzen, 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-Fähigkeiten hands-on zu erkunden. Es demonstriert MCP-Funktionalität in einem simulierten Enterprise-Setup und verwendet Mock-Daten von Jira, Slack und Grafana, um ein Incident-Response-Szenario zu modellieren. Die enthaltene 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. json { "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: Das aws-console verwendet ein Community-entwickeltes MCP-Server-Package (@imazhar101/mcp-aws-server) für AWS-Integration, das nicht unabhängig verifiziert wurde. Dies ist nur für Demonstrations- und Lernzwecke gedacht. Für den Produktionseinsatz bewerte Packages gründlich oder verwende offizielle Alternativen.

Konfiguriere außerdem AWS-Credentials über AWS-CLI-Profile oder IAM-Rollen, anstatt sie in der Konfigurationsdatei hardzucoden. Das AWS SDK wird automatisch Credentials aus deiner Umgebung erkennen, was der empfohlene Ansatz für Enterprise-Governance und Sicherheits-Compliance ist.

Um zu starten, klone 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: Füge deine AWS-Credentials hinzu, um Live-Cloud-Integration zu erleben.

Klone das Projekt hier: GitLab Duo MCP Demo.

Beispiel-Prompts zum Ausprobieren mit dem Demo-Projekt

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

• "What tools can you access through MCP?"

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

GitLab MCP-Server-Fähigkeiten

Bisher haben wir uns angesehen, wie GitLab Duo Agent Platform als MCP-Client fungiert und sich mit externen MCP-Servern verbindet. Jetzt lass uns die GitLab MCP-Server-Fähigkeiten erkunden. Der GitLab MCP-Server lässt KI-Tools wie Cursor oder Claude Desktop sich sicher mit deiner GitLab-Instanz verbinden und mit deinen Entwicklungsdaten in natürlicher Sprache arbeiten. Authentifizierung wird über OAuth 2.0 Dynamic Client Registration gehandhabt, sodass sich KI-Tools automatisch registrieren und mit ordnungsgemäßer Autorisierung auf deine GitLab-Daten zugreifen können. 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

Für die vollständige Liste verfügbarer Tools und Fähigkeiten siehe die MCP-Server-Docs.

Interaktiver Walkthrough: GitLab MCP-Server in Aktion

Erlebe den GitLab MCP-Server aus erster Hand mit unserem interaktiven Walkthrough. Er führt dich durch das Setup von Cursor mit dem MCP-Server und die Verwendung von Cursor Chat, um sich sicher mit deiner GitLab-Instanz zu verbinden. Du siehst, wie du Aktionen wie das Anzeigen von Issues, Erstellen eines neuen Issues und Überprüfen von Merge Requests durchführst, alles direkt über natürliche Sprache, ohne deine Entwicklungsumgebung zu verlassen.

Wie du den MCP-Server in deinem KI-Tool konfigurierst

Voraussetzungen:

• Stelle sicher, dass Node.js und npm installiert sind
• Verifiziere, dass npx global zugänglich 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\"}"
        ]
      }
    }
  }

    

Registrieren und authentifizieren

Bei der ersten Verbindung wird das KI-Tool:

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

Im Browser autorisieren

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

Verwendung des MCP-Servers

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

• 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, wird von einem Feature Flag gesteuert und ist noch nicht für den Produktionseinsatz bereit. Für vollständige Schritt-für-Schritt-Anweisungen, Konfigurationsbeispiele und Troubleshooting-Tipps siehe die GitLab MCP-Server-Dokumentation.

Zusammenfassung

GitLab Duo Agent Platform unterstützt MCP und ermöglicht KI-gestützte Entwicklungs-Workflows mit externer Tool-Integration. Mit MCP-Unterstützung fungiert GitLab sowohl als Client als auch als Server:

• MCP-Client: GitLab Duo Agent Platform kann sicher auf Daten und Services von externen Systemen zugreifen und bringt umfassenden 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, während strikte Sicherheit und Datenschutz aufrechterhalten werden. Diese bidirektionale Unterstützung reduziert Context-Switching, beschleunigt Entwickler-Workflows und stellt sicher, dass KI sinnvolle Unterstützung über dein gesamtes Toolkit hinweg bieten kann.

Was kommt als Nächstes?

Du verstehst jetzt, wie du Agenten verwendest, Flows erstellst, Lösungen im AI Catalog entdeckst, Workflows über das Automate-Menü verwaltest und Fähigkeiten mit MCP erweiterst. Der letzte Schritt ist die Anpassung von GitLab Duo an die spezifischen Anforderungen deines Teams. Lerne dies in Teil 8, einschließlich wie du Custom Chat Rules erstellst, effektive System Prompts verfasst, Agent-Tools konfigurierst, MCP-Integrationen einrichtest und Flows für den einzigartigen Workflow deines Teams anpasst.

Ressourcen

• MCP Clients Dokumentation
• MCP Server Dokumentation
• Was ist Model Context Protocol?
• GitLab Duo Agent Platform

Nächster: Teil 8: GitLab Duo anpassen: Chat-Regeln, Prompts und Workflows

Vorheriger: Teil 6: KI-Workflows überwachen, verwalten und automatisieren