MCP-Integration

Was ist MCP (Model Context Protocol)?

Model Context Protocol (MCP) ist ein Integrationssystem, das die Fähigkeiten von Verdent durch die Anbindung an externe Werkzeuge, Datenquellen und Dienste erweitert.

Kernkonzept: MCP ermöglicht es Verdent, mit Systemen jenseits des integrierten Werkzeugsatzes zu interagieren, und erlaubt nahtlose Integration mit:

• Externen APIs und Webdiensten
• Datenbanksystemen
• Cloud-Plattformen (AWS, Azure, GCP)
• Projektmanagement-Werkzeugen
• CI/CD-Pipelines
• Individuellen internen Werkzeugen

Architektur: MCP-Server fungieren als Brücken zwischen Verdent und externen Systemen. Jeder MCP-Server stellt bestimmte Fähigkeiten bereit, die Verdent während Coding-Sitzungen aufrufen kann, ähnlich wie integrierte Werkzeuge wie file_read oder bash.

Konfigurationsspeicherung: MCP-Serverkonfigurationen werden in ~/.verdent/mcp.json gespeichert und über das Einstellungsmenü verwaltet.

Vorteile der MCP-Integration

Erweiterte Fähigkeiten

Zugriff auf externe Systeme: Verbinden Sie Verdent mit Werkzeugen und Diensten, die über die integrierte Funktionalität nicht verfügbar sind. Fragen Sie Datenbanken ab, interagieren Sie mit Cloud-Diensten oder integrieren Sie projektspezifische APIs, ohne Ihren Coding-Workflow zu verlassen.

Individuelle Werkzeugentwicklung: Erstellen Sie MCP-Server, die auf die individuellen Anforderungen Ihres Projekts zugeschnitten sind. Entwickeln Sie spezialisierte Integrationen für interne Werkzeuge, proprietäre APIs oder domänenspezifische Systeme.

Interoperabilität

Ökosystem nutzen: Nutzen Sie das wachsende MCP-Ökosystem. Von der Community entwickelte MCP-Server bieten vorgefertigte Integrationen für gängige Werkzeuge und Dienste.

Standardisiertes Protokoll: MCP bietet eine einheitliche Schnittstelle für die Werkzeugintegration und stellt sicher, dass neue Fähigkeiten sich reibungslos in das bestehende Werkzeugsystem von Verdent einfügen.

Workflow-Automatisierung

Nahtlose Integration: MCP-Server werden Teil des Werkzeugsatzes von Verdent. Der Agent verwendet MCP-Werkzeuge automatisch, wenn dies angebracht ist, oder Sie können sie für bestimmte Aufgaben explizit aufrufen.

Kontextbewusste Operationen: MCP-Integrationen verstehen den Kontext Ihrer Codebasis und ermöglichen intelligente Interaktionen mit externen Systemen basierend auf dem aktuellen Entwicklungsstand.

Einrichten von MCP-Servern

Konfigurationsprozess

Zugriff auf MCP-Einstellungen:

1. Öffnen Sie das Einstellungsmenü in Verdent
2. Navigieren Sie zum Abschnitt MCP-Server
3. Zeigen oder bearbeiten Sie die Konfiguration von ~/.verdent/mcp.json

Konfigurationsdatei: MCP-Server werden über die Datei ~/.verdent/mcp.json konfiguriert, die Serververbindungen, Authentifizierung und Integrationsparameter definiert. Das vollständige Schema finden Sie im Abschnitt MCP-Konfiguration weiter unten.

Konfigurationsverwaltung

Server hinzufügen: Konfigurieren Sie neue MCP-Server, indem Sie Einträge mit Verbindungsdetails und Authentifizierungsdaten in mcp.json hinzufügen.

Mehrere Server: Verdent unterstützt mehrere gleichzeitige MCP-Server und ermöglicht so die Integration mit mehreren externen Systemen gleichzeitig.

Verbindungen testen: Validieren Sie MCP-Serverkonfigurationen, um erfolgreiche Verbindungen sicherzustellen, bevor Sie sie in Entwicklungs-Workflows verwenden.

Serverstatus

Überwachen Sie den Verbindungsstatus im Einstellungsbereich von MCP:

Werkzeuge aktualisieren: Klicken Sie auf die Schaltfläche zum Aktualisieren, um verfügbare Werkzeuge eines Servers nach Konfigurationsänderungen oder Verbindungsproblemen neu zu erkennen.

MCP-Konfiguration

Grundeinrichtung

Speicherort: .mcp.json im Projektstammverzeichnis oder ~/.verdent/mcp.json (global)

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://localhost:5432/myapp_dev"
      ]
    }
  }
}

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://localhost:5432/myapp_dev"
      ]
    },
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}

Konfigurationsschlüssel:

• mcpServers – erforderlicher Top-Level-Schlüssel für die MCP-Konfiguration
• command – auszuführende ausführbare Datei (in der Regel npx für Node.js-Pakete)
• args – an den Befehl übergebene Argumente (Paketname, Verbindungszeichenfolgen usw.)
• env – Umgebungsvariablen für Authentifizierung/Konfiguration

MCP-Plugins und -Erweiterungen

Verfügbare Plugins

MCP-Plugins bieten vorgefertigte Integrationen für gängige Werkzeuge und Dienste. Durchsuchen Sie das Community-Verzeichnis unter mcp.so/servers oder das offizielle MCP-Server-Repo für die aktuelle Verfügbarkeit.

Gängige Plugin-Kategorien:

• Datenbankintegrationen: PostgreSQL-, MySQL-, MongoDB-Abfragewerkzeuge
• Cloud-Dienste: API-Interaktionen mit AWS, Azure, GCP
• Entwicklerwerkzeuge: Integrationen mit GitHub, GitLab, Jira, Linear
• CI/CD-Plattformen: Jenkins, GitHub Actions, CircleCI
• Monitoring-Dienste: Datadog, New Relic, Sentry
• Kommunikation: Benachrichtigungen für Slack, Discord, Microsoft Teams

Plugin-Installation

Installationsmethoden: Plugins werden über die Einstellungsoberfläche von MCP installiert und konfiguriert, wobei in der Regel Folgendes erforderlich ist:

• Plugin-Kennung oder -Quelle
• Konfigurationsparameter
• Authentifizierungsdaten (falls zutreffend)

Abhängigkeitsverwaltung: MCP-Plugins können Abhängigkeiten von externen Diensten oder Bibliotheken haben. Installationsprozesse übernehmen die Auflösung von Abhängigkeiten wenn möglich automatisch.

Entwicklung individueller MCP-Server

Individuelle Server erstellen

Fortgeschrittene Anwender können individuelle MCP-Server erstellen, um proprietäre Werkzeuge oder domänenspezifische Systeme zu integrieren.

Entwicklungsansatz: Individuelle MCP-Server implementieren die MCP-Protokollspezifikation und stellen Werkzeugfähigkeiten bereit, die Verdent aufrufen kann. Details zur Implementierung und SDKs finden Sie in der Model Context Protocol-Spezifikation.

Anwendungsfälle für individuelle Server:

• Interne API-Integration: Verbindung zu unternehmensspezifischen APIs und Diensten
• Brücken zu Altsystemen: Ermöglicht Verdent die Interaktion mit bestehender Infrastruktur
• Spezialisierte Datenquellen: Zugriff auf proprietäre Datenbanken oder Data Warehouses
• Workflow-Automatisierung: Auslösen individueller Build-, Deployment- oder Testpipelines

Integrationsmuster

Konfiguration auf Arbeitsbereichsebene: MCP-Server können auf Arbeitsbereichsebene für projektspezifische Integrationen konfiguriert werden, sodass Teams MCP-Konfigurationen über die Versionskontrolle gemeinsam nutzen können.

Werkzeug-Interoperabilität: Von MCP bereitgestellte Werkzeuge lassen sich nahtlos mit den integrierten Werkzeugen von Verdent (file_read, bash, spawn_subagent) kombinieren und ermöglichen so komplexe Workflows, die mehrere Werkzeugtypen verbinden.

Desktopspezifische MCP-Funktionen

Projektbezogene Konfiguration

MCP mit mehreren Worktrees

MCP-Server funktionieren über Worktrees hinweg:

• Gemeinsame Server: Die grundlegende MCP-Konfiguration des Arbeitsbereichs wird von allen Worktrees gemeinsam genutzt
• Isolierte Operationen: Jeder Worktree behält einen separaten MCP-Sitzungsstatus
• Paralleler Zugriff: Mehrere Worktrees können gleichzeitig dieselben MCP-Server verwenden

Projektwechsel

Beim Wechseln von Projekten:

• Die MCP-Server des aktuellen Projekts werden geladen
• Globale MCP-Server bleiben verfügbar
• Die MCP-Verbindungen des vorherigen Projekts werden im Hintergrund aufrechterhalten

MCP-Workflow-Beispiele

Integration von Datenbankabfragen

Szenario: Abfrage der Produktionsdatenbank zur Fehlersuche bei Datenproblemen.

MCP-Ansatz:

User: "Check the orders table for customer ID 12345"
Verdent: [Uses MCP database server to execute safe read-only query]
        Results: 3 orders found for customer 12345
        [Displays formatted results]

Der MCP-Datenbankserver übernimmt Authentifizierung, Abfragevalidierung und Ergebnisformatierung.

Interaktion mit Cloud-Diensten

Szenario: Überprüfung der AWS-Lambda-Funktionsprotokolle auf Fehler.

MCP-Ansatz:

User: "Show me recent errors from the payment-processor Lambda function"
Verdent: [Invokes MCP AWS integration]
        [Retrieves CloudWatch logs for specified function]
        [Filters for ERROR level entries]
        [Presents formatted error summaries]

Der MCP-AWS-Server verwaltet Authentifizierung, API-Aufrufe und Protokollauswertung.

Überwachung von CI/CD-Pipelines

Szenario: Build-Status vor der Bereitstellung von Änderungen überprüfen.

MCP-Ansatz:

User: "Is the master branch build passing?"
Verdent: [Queries MCP CI/CD integration]
        Build #245: ✓ Passed (2 minutes ago)
        All tests passed, ready for deployment

Der MCP-CI/CD-Server verfolgt den Pipeline-Status und liefert Echtzeit-Feedback.

Sicherheitsaspekte

Authentifizierung und Autorisierung

Verwaltung von Zugangsdaten: MCP-Server übernehmen die Authentifizierung bei externen Diensten. Zugangsdaten werden sicher in der MCP-Konfiguration gespeichert und niemals im Chatverlauf oder im Code offengelegt.

Berechtigungsbereich: Konfigurieren Sie MCP-Server mit den minimal notwendigen Berechtigungen. Verwenden Sie nach Möglichkeit nur lesenden Zugriff und schränken Sie destruktive Operationen ein.

Sichere Operationen

Befehlsüberprüfung: Operationen mit MCP-Werkzeugen erscheinen im Konversationsverlauf und bieten so Transparenz und Kontrolle.

Audit-Protokollierung: Operationen von MCP-Servern erscheinen im Chatverlauf von Verdent und erzeugen so eine Prüfspur der Interaktionen mit externen Systemen.

Fehlerbehebung bei der MCP-Integration

Häufige Probleme

Verbindungsfehler:

• Überprüfen Sie die Netzwerkverbindung zum MCP-Server
• Prüfen Sie die Authentifizierungsdaten in mcp.json
• Stellen Sie sicher, dass der MCP-Server läuft und erreichbar ist
• Validieren Sie die Syntax der Konfigurationsdatei

Berechtigungsfehler:

• Bestätigen Sie, dass API-Schlüssel oder Zugangsdaten die erforderlichen Berechtigungen haben
• Prüfen Sie Dienstkontingente oder Ratenbegrenzungen
• Überprüfen Sie, ob Firewall-Regeln den MCP-Datenverkehr zulassen

Probleme beim Werkzeugaufruf:

• Stellen Sie sicher, dass der MCP-Server die erwarteten Werkzeuge korrekt bereitstellt
• Prüfen Sie, ob die Werkzeugparameterformate den Erwartungen des Servers entsprechen
• Überprüfen Sie die Protokolle des MCP-Servers auf Fehlerdetails

Hilfe erhalten

Support-Kanäle:

• Verdent-Support: support@verdent.ai
• MCP-Protokolldokumentation
• Verdent-Discord-Community

Diagnoseinformationen: Geben Sie beim Melden von MCP-Problemen Folgendes an:

• Typ und Version des MCP-Servers
• Konfigurationsdetails (bereinigt von Zugangsdaten)
• Fehlermeldungen aus dem Chatverlauf
• Protokolle des MCP-Servers (falls zugänglich)

Häufig gestellte Fragen