# MCP-Integration (/de/docs/verdent-manager/configuration/mcp)
> Erweitern Sie Verdent mit Model Context Protocol-Servern und Plugins
## Was ist MCP (Model Context Protocol)? [#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 [#vorteile-der-mcp-integration]
### Erweiterte Fähigkeiten [#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 [#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 [#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 [#einrichten-von-mcp-servern]
### Konfigurationsprozess [#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 [#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 [#serverstatus]
Überwachen Sie den Verbindungsstatus im Einstellungsbereich von MCP:
| Status | Beschreibung |
| ------------------ | ------------------------------------------------------ |
| **Erfolgreich** | Server verbunden und Werkzeuge verfügbar |
| **Fehlgeschlagen** | Verbindungsfehler (klicken Sie, um Details anzuzeigen) |
| **Wird geladen** | Server initialisiert |
**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 [#mcp-konfiguration]
### Grundeinrichtung [#grundeinrichtung]
**Speicherort:** `.mcp.json` im Projektstammverzeichnis oder `~/.verdent/mcp.json` (global)
```json PostgreSQL Server
{
"mcpServers": {
"postgres": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-postgres",
"postgresql://localhost:5432/myapp_dev"
]
}
}
}
```
```json GitHub Server
{
"mcpServers": {
"github": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-github"
],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
}
}
}
}
```
```json Multiple Servers
{
"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
**Mehr über MCP erfahren:**
* [Model Context Protocol-Spezifikation](https://modelcontextprotocol.io/specification)
* [MCP-Server-Verzeichnis](https://mcp.so/servers) – verfügbare MCP-Server durchsuchen
* [Offizielle MCP-Server](https://github.com/modelcontextprotocol) – PostgreSQL, GitHub, Filesystem und mehr
***
## MCP-Plugins und -Erweiterungen [#mcp-plugins-und--erweiterungen]
### Verfügbare Plugins [#verfügbare-plugins]
MCP-Plugins bieten vorgefertigte Integrationen für gängige Werkzeuge und Dienste. Durchsuchen Sie das Community-Verzeichnis unter [mcp.so/servers](https://mcp.so/servers) oder das [offizielle MCP-Server-Repo](https://github.com/modelcontextprotocol) 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 [#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 [#entwicklung-individueller-mcp-server]
### Individuelle Server erstellen [#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](https://modelcontextprotocol.io/specification).
**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 [#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 [#desktopspezifische-mcp-funktionen]
### Projektbezogene Konfiguration [#projektbezogene-konfiguration]
| Konfigurationsebene | Speicherort | Geltungsbereich |
| ------------------- | -------------------------------------- | ----------------------------- |
| **Global** | `~/.verdent/mcp.json` | Alle Projekte |
| **Projekt** | `.mcp.json` im Projektstammverzeichnis | Einzelnes Projekt |
| **Worktree** | Erbt vom Projekt | Erbt die Projektkonfiguration |
### MCP mit mehreren Worktrees [#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 [#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 [#mcp-workflow-beispiele]
### Integration von Datenbankabfragen [#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 [#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 [#überwachung-von-cicd-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 [#sicherheitsaspekte]
### Authentifizierung und Autorisierung [#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 [#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 [#fehlerbehebung-bei-der-mcp-integration]
### Häufige Probleme [#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 [#hilfe-erhalten]
**Support-Kanäle:**
* Verdent-Support: [support@verdent.ai](mailto:support@verdent.ai)
* [MCP-Protokolldokumentation](https://modelcontextprotocol.io)
* [Verdent-Discord-Community](https://discord.com/invite/NGjXEZcbJq)
**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 [#häufig-gestellte-fragen]
Operationen von MCP-Servern verbrauchen Credits basierend auf dem Modell, das die Ergebnisse verarbeitet. Der MCP-Server selbst verbraucht keine Credits direkt.
Nein. MCP-Server werden auf Benutzerebene konfiguriert, nicht pro Projekt. Alle konfigurierten Server stehen in allen Ihren Projekten zur Verfügung.
Zugangsdaten in mcp.json werden lokal auf Ihrem Rechner gespeichert und niemals an Verdent-Server gesendet. Verwenden Sie für sensible Werte Umgebungsvariablen (`${VAR_NAME}`).
MCP-Server starten bei Bedarf und laufen während Ihrer Sitzung. Sie verbrauchen keine Ressourcen, wenn Verdent geschlossen ist.
MCP-Server haben die von Ihnen konfigurierten Berechtigungen. Verwenden Sie nach Möglichkeit nur lesenden Zugriff und schränken Sie destruktive Operationen ein.
Bitten Sie Verdent, ein Werkzeug des MCP-Servers zu verwenden. Erfolgreiche Antworten zeigen, dass die Verbindung funktioniert. Bei Problemen lesen Sie den Abschnitt zur Fehlerbehebung.