> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devinenterprise.com/llms.txt
> Use this file to discover all available pages before exploring further.

# MCP (Model Context Protocol) Marktplatz

MCP ist ein offenes Protokoll, mit dem Devin Hunderte externer Tools und Datenquellen nutzen kann. Devin unterstützt 3 Transportmethoden (stdio, SSE und HTTP).

<div id="why-use-mcp">
  ## Warum MCP verwenden?
</div>

Mit MCP kann Devin dir helfen:

* Sentry-, Datadog- und Vercel-Logs zu durchsuchen
* [Devin als Data Analyst zu verwenden](https://devin.ai/ai-data-analyst-1), in Slack mit Datenbank-MCPs
* SonarQube-, CircleCI- und Jam-Issues zu untersuchen
* in großer Zahl Linear-Tickets, Notion-Dokumente, Google Docs (über Zapier) und mehr zu erstellen
* Kontext aus Airtable, Stripe und Hubspot einzubinden und mit ihnen zu interagieren
* und vieles mehr!

<div id="get-started-with-mcps">
  ## Erste Schritte mit MCPs
</div>

Navigiere zu [Settings > Connections > MCP-Server](https://app.devin.ai/settings/connections?tab=mcps), um MCPs zu durchsuchen und zu aktivieren.

<CardGroup cols={2}>
  <Card title="Nutze Devin für Datenanalysen in Slack, indem du Devin mit Datenbank-MCPs verbindest" icon="chart-simple" href="https://devin.ai/ai-data-analyst-1/">
    Sieh dir unsere Schritt-für-Schritt-Anleitung an!
  </Card>

  <Card title="MCP-Anwendungsfälle entdecken" icon="grid-2" href="/de/use-cases/gallery/index">
    Entdecken Sie praktische Beispiele von Devin mit MCPs wie Datadog, Sentry, Linear, Figma und mehr.
  </Card>
</CardGroup>

<div id="configuration-tips">
  ## Konfigurationstipps
</div>

<Note>
  Für MCPs, die sich mit OAuth authentifizieren, fordert Devin Sie auf, eine URL aufzurufen, um Ihr Konto zu verbinden. **Wir empfehlen dringend, ein Servicekonto zu verwenden** – nicht Ihr persönliches Konto –, da der Zugriff innerhalb Ihrer Organisation geteilt wird.
</Note>

<Note>
  Sie finden das MCP, das Sie suchen, nicht? Organisationsadministratoren können über die Schaltfläche **Add a custom MCP** jeden MCP-Server hinzufügen. Wenn Sie keine Admin-Berechtigungen haben, verwenden Sie **Suggest MCP Integration**, um einen anzufordern.

  Gibt es Probleme? Kontaktieren Sie uns über unsere [Support-Seite](https://app.devin.ai/settings/support) oder per E-Mail an [support@cognition.ai](mailto:support@cognition.ai).
</Note>

<div id="setting-up-a-custom-mcp-server">
  ## Einrichten eines benutzerdefinierten MCP-Servers
</div>

Wenn das benötigte MCP nicht im Marketplace zu finden ist, können Organisationsadministratoren über die Schaltfläche **Add a custom MCP** einen beliebigen MCP-Server hinzufügen. Devin unterstützt drei Transporttypen für benutzerdefinierte Server:

<Note>
  Zum Hinzufügen benutzerdefinierter MCP-Server ist die Berechtigung **Manage MCP Servers** erforderlich. Wenn die Schaltfläche **Add a custom MCP** nicht angezeigt wird, wenden Sie sich an Ihren Organisationsadministrator oder verwenden Sie die Option **Suggest MCP Integration**, um einen neuen Server anzufordern.
</Note>

| Transport | Am besten geeignet für                                  | Erforderliche Felder                 |
| --------- | ------------------------------------------------------- | ------------------------------------ |
| **STDIO** | Lokale CLI-basierte Server (z. B. `npx`, `uvx`, Docker) | Command, Args, Environment Variables |
| **SSE**   | Remote-Server mit Server-Sent Events                    | Server-URL, Header                   |
| **HTTP**  | Remote-Server mit Streamable HTTP                       | Server-URL, Header                   |

<div id="step-by-step-adding-a-custom-mcp-server">
  ### Schritt-für-Schritt: Hinzufügen eines benutzerdefinierten MCP-Servers
</div>

1. Navigieren Sie zu [Settings > Connections > MCP-Server](https://app.devin.ai/settings/connections?tab=mcps).
2. Klicken Sie oben auf der Seite auf **Add a custom MCP**.
3. Geben Sie die Serverdetails ein:
   * **Server Name**: Ein aussagekräftiger Name für den Server (z. B. „Internal API Gateway“).
   * **Icon** (optional): Ein Emoji oder eine URL, die als Server-Icon verwendet werden soll.
   * **Short Description**: Eine kurze Zusammenfassung der Aufgaben des Servers.
4. Wählen Sie den **Transporttyp** (STDIO, SSE oder HTTP).
5. Füllen Sie die transportspezifischen Konfigurationsfelder aus (siehe unten [Konfigurationsformat](#configuration-format)).
6. Klicken Sie auf **Save**, um den Server zu erstellen.
7. Klicken Sie auf **Test listing tools**, um die Verbindung zu überprüfen. Devin startet eine isolierte Testumgebung, verbindet sich mit Ihrem Server und versucht, die verfügbaren Tools zu erkennen.

<Note>
  Die Schaltfläche **Test listing tools** ist deaktiviert, bis Sie Ihre Konfiguration gespeichert haben. Wenn die Validierung fehlschlägt, prüfen Sie die angezeigte Fehlermeldung – sie zeigt an, ob das Problem bei der Verbindung, der Authentifizierung oder einem Timeout liegt.
</Note>

<div id="configuration-format">
  ### Konfigurationsformat
</div>

<Note>
  Die folgenden Beispiele zeigen JSON-Darstellungen der Konfigurationsfelder jedes Transports. In der Praxis füllen Sie diese über das Webformular aus – Sie müssen kein JSON schreiben oder einfügen. Das JSON-Format wird hier zur Klarstellung und als Referenz für API-basierte oder programmatische Setups angegeben.
</Note>

<div id="stdio-transport">
  #### STDIO-Transport
</div>

Verwenden Sie STDIO für Server, die als lokale Prozesse ausgeführt werden. Sie geben den Befehl zum Starten des Servers an, zusammen mit allen Argumenten und Umgebungsvariablen.

**Felder:**

* **Command** (erforderlich): Die auszuführbare Datei (z. B. `npx`, `uvx`, `docker`).
* **Arguments**: Befehlszeilenargumente, die an den Server übergeben werden.
* **Environment Variables**: Schlüssel-Wert-Paare, die in der Prozessumgebung des Servers gesetzt werden. Verwenden Sie diese, um API keys, Token oder Konfigurationswerte zu übergeben.

**Beispiel — ein benutzerdefinierter STDIO-Server mit `npx`:**

```json theme={null}
{
  "transport": "STDIO",
  "command": "npx",
  "args": ["-y", "@example/my-mcp-server"],
  "env_variables": {
    "API_KEY": "your-api-key",
    "API_BASE_URL": "https://internal-api.example.com"
  }
}
```

**Beispiel — ein benutzerdefinierter STDIO-Server mit Docker:**

```json theme={null}
{
  "transport": "STDIO",
  "command": "docker",
  "args": ["run", "-i", "--rm", "-e", "DB_CONNECTION_STRING", "my-org/my-mcp-server:latest"],
  "env_variables": {
    "DB_CONNECTION_STRING": "postgresql://user:pass@host:5432/mydb"
  }
}
```

<div id="sse-and-http-transports">
  #### SSE- und HTTP-Übertragungen
</div>

Verwenden Sie SSE oder HTTP für Remote-Server, die über das Netzwerk erreichbar sind. HTTP (Streamable HTTP) wird für neue Integrationen empfohlen; SSE wird für ältere (Legacy-)Server unterstützt.

**Felder:**

* **Server URL** (erforderlich): Die Endpunkt-URL des MCP-Servers.
* **Authentication method**: Wählen Sie zwischen `None`, `Auth Header` oder `OAuth`.
  * Für **Auth Header**: Geben Sie den Header-Schlüssel (standardmäßig `Authorization`) und den Header-Wert an (z. B. `Bearer your-token`).
  * Für **OAuth**: Devin fordert Sie während Ihrer ersten Sitzung auf, einen OAuth-Flow abzuschließen.

**Beispiel — ein Remote-HTTP-Server mit Bearer-Token-Authentifizierung:**

```json theme={null}
{
  "transport": "HTTP",
  "url": "https://mcp.internal-service.example.com/mcp",
  "auth_method": "auth_header",
  "headers": {
    "Authorization": "Bearer your-api-token"
  }
}
```

**Beispiel — ein Remote-SSE-Server ohne Authentifizierung:**

```json theme={null}
{
  "transport": "SSE",
  "url": "https://mcp.example.com/sse"
}
```

<Tip>
  Wenn Sie zwischen SSE und HTTP wählen, bevorzugen Sie **HTTP** (Streamable HTTP). SSE ist ein Legacy-Protokoll und wird im gesamten MCP-Ökosystem schrittweise außer Betrieb genommen.
</Tip>

<div id="common-patterns">
  ## Gängige Muster
</div>

<div id="connecting-to-an-internal-api">
  ### Verbindung mit einer internen API
</div>

Stellen Sie Ihre interne API als MCP-Server bereit, damit Devin sie direkt abfragen kann. Verwenden Sie den STDIO-Transport mit einem Wrapper, der MCP-Tool-Aufrufe in API-Anfragen umsetzt.

```json theme={null}
{
  "transport": "STDIO",
  "command": "npx",
  "args": ["-y", "@example/api-mcp-bridge"],
  "env_variables": {
    "API_BASE_URL": "https://api.internal.example.com",
    "API_TOKEN": "your-internal-api-token"
  }
}
```

Alternativ können Sie, sofern Ihre interne API über das Netzwerk erreichbar ist, den HTTP-Transport verwenden:

```json theme={null}
{
  "transport": "HTTP",
  "url": "https://api.internal.example.com/mcp",
  "headers": {
    "Authorization": "Bearer your-internal-api-token"
  }
}
```

<div id="connecting-to-a-database">
  ### Verbindung zu einer Datenbank
</div>

Verwenden Sie einen Datenbank-MCP-Server, um Devin Lese- oder Schreibzugriff auf Ihre Daten zu ermöglichen. Es gibt viele Community-gepflegte Server für gängige Datenbanken.

```json theme={null}
{
  "transport": "STDIO",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://user:password@host:5432/database"]
}
```

<Note>
  Für Produktivdatenbanken sollte eine **read-only**-Verbindungszeichenfolge oder ein Datenbankbenutzer mit eingeschränkten Berechtigungen verwendet werden. Devin führt Abfragen auf Grundlage von Benutzeranweisungen aus, daher ist es wichtig, die Zugriffsrechte entsprechend einzugrenzen.
</Note>

<div id="connecting-to-a-custom-tool-or-script">
  ### Anbindung eines benutzerdefinierten Tools oder Skripts
</div>

Stelle beliebige CLI-Tools oder Skripte als MCP-Server bereit. Zum Beispiel ein Python-basierter Server mit `uvx`:

```json theme={null}
{
  "transport": "STDIO",
  "command": "uvx",
  "args": ["my-custom-mcp-server"],
  "env_variables": {
    "CONFIG_PATH": "/path/to/config.json"
  }
}
```

Oder ein Docker-basierter Server für die isolierte Ausführung:

```json theme={null}
{
  "transport": "STDIO",
  "command": "docker",
  "args": ["run", "-i", "--rm", "my-org/custom-mcp-server:latest"]
}
```

<div id="using-environment-variables-for-secrets">
  ### Verwendung von Umgebungsvariablen für Secrets
</div>

Geben Sie sensible Werte über Umgebungsvariablen weiter, statt sie in Argumenten hardcodiert zu hinterlegen. Die Devin-[Secrets](/de/product-guides/secrets)-Funktion kann diese Werte verwalten — speichern Sie Ihre API-Schlüssel oder Token als Secrets und verwenden Sie sie anschließend in Ihrer MCP-Serverkonfiguration.

<div id="troubleshooting-custom-mcp-servers">
  ## Fehlerbehebung bei eigenen MCP-Servern
</div>

<div id="test-listing-tools-fails">
  ### "Test listing tools" schlägt fehl
</div>

| Symptom                                                 | Wahrscheinliche Ursache                                           | Lösung                                                                                                                                                                     |
| ------------------------------------------------------- | ----------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| "Verify server URL and network connectivity"            | Die Server-URL ist nicht erreichbar                               | Stellen Sie sicher, dass die URL korrekt ist und aus dem Internet (oder aus Devins Netzwerk bei Verwendung eines VPN) erreichbar ist                                       |
| "Check authentication credentials and permissions"      | Ungültige oder fehlende Authentifizierungsdaten                   | Überprüfen Sie Ihren API key, Ihr Token oder Ihre OAuth-Konfiguration                                                                                                      |
| "Server took too long to respond - check server status" | Der Server hat nicht innerhalb des Timeouts geantwortet           | Stellen Sie sicher, dass der Server läuft und reagiert; prüfen Sie, ob Firewall-Regeln die Verbindung blockieren                                                           |
| "MCP server validation failed" (allgemein)              | Befehl nicht gefunden, fehlende Abhängigkeiten oder Serverabsturz | Überprüfen Sie bei STDIO-Servern, dass der Befehl existiert und lokal ausgeführt werden kann; stellen Sie sicher, dass alle erforderlichen Umgebungsvariablen gesetzt sind |

<div id="server-connects-but-tools-arent-available">
  ### Server stellt eine Verbindung her, aber Tools sind nicht verfügbar
</div>

* Überprüfen Sie, ob der Server die `tools/list`-Methode des MCP-Protokolls korrekt implementiert.
* Stellen Sie bei STDIO-Servern sicher, dass der Prozess gültige JSON-RPC-Nachrichten nach stdout schreibt und von stdin liest — Logging- oder Debug-Ausgaben nach stdout verletzen das Protokoll.
* Prüfen Sie, dass Umgebungsvariablen korrekt gesetzt sind. Fehlende Werte (z. B. ein leerer API key) können dazu führen, dass der Server zwar startet, aber keine Tools registriert.

<div id="oauth-authentication-issues">
  ### OAuth-Authentifizierungsprobleme
</div>

* Wenn Sie zur Authentifizierung aufgefordert werden, führen Sie den OAuth-Flow im geöffneten Browserfenster aus. Devin wartet auf den Callback.
* Wenn die Authentifizierung fehlschlägt, überprüfen Sie, ob die OAuth-Redirect-URI beim Anbieter korrekt konfiguriert ist.
* Nur Nutzer mit der Berechtigung **Manage MCP Servers** können OAuth-basierte MCP-Server authentifizieren. Wenn Sie eine Berechtigungsfehlermeldung erhalten, wenden Sie sich an den Admin Ihrer Organisation.

<Note>
  Verwenden Sie für OAuth-basierte MCPs **ein Servicekonto** statt Ihres persönlichen Kontos. Der Zugriff wird in Ihrer gesamten Organisation geteilt, und alle Sitzungen der Mitglieder verwenden dieselbe authentifizierte Verbindung.
</Note>

<div id="general-debugging-tips">
  ### Allgemeine Debugging-Tipps
</div>

* **Überprüfe den Server zuerst lokal.** Bevor du einen benutzerdefinierten Server zu Devin hinzufügst, stelle sicher, dass er funktioniert, indem du den Befehl ausführst oder die URL von deinem eigenen Rechner aus aufrufst.
* **Überprüfe Devins Sitzungsprotokolle.** Wenn ein Server während einer Sitzung fehlschlägt, protokolliert Devin den Fehler. Suche in der Sitzungsausgabe nach MCP-bezogenen Meldungen.
* **Vereinfache und iteriere.** Starte mit der minimalen Konfiguration (z. B. ohne Authentifizierung, mit Standardeinstellungen) und erhöhe die Komplexität, sobald die grundlegende Verbindung funktioniert.
* **Überprüfe Umgebungsvariablen.** Ein häufiges Problem sind fehlende oder falsch benannte Environment-Variablen. Kontrolliere, dass jede erforderliche Variable in der Konfiguration gesetzt ist.

<Tip>
  Wenn du einen eigenen MCP-Server entwickelst, bietet die [Model Context Protocol-Spezifikation](https://modelcontextprotocol.io/introduction) ausführliche Dokumentation zum Protokoll, zu Transporttypen und Tool-Definitionen.
</Tip>

***

<div id="marketplace-mcps">
  ## Marketplace-MCPs
</div>

Im Folgenden finden Sie Konfigurationsdetails für bestimmte MCPs, die im Marketplace verfügbar sind.

<div id="vercel-atlassian-notion-sentry-neon-asana-jam-and-many-more">
  ### Vercel, Atlassian, Notion, Sentry, Neon, Asana, Jam und viele mehr
</div>

Viele MCPs in unserem Marketplace können ohne Konfiguration mit nur einem Klick aktiviert werden!

Klicken Sie einfach auf „Enable“. Sie werden während Ihrer Devin-Sitzung oder wenn Sie auf „Test listing tools“ klicken dazu aufgefordert, ein Servicekonto zu verbinden.

Verfügbare MCPs sind unter anderem:

* AlloyDB
* Asana
* Atlassian
* BigQuery
* Cloud SQL (MySQL)
* Cloud SQL (PostgreSQL)
* Cloud SQL (SQL Server)
* Cloudflare
* Cortex
* Dataplex
* Figma
* Fireflies
* Firestore
* Jam
* Linear
* Looker
* Metabase
* MySQL
* Neon
* Notion
* PostgreSQL
* Prisma
* Sentry
* Spanner
* SQL Server
* Vercel
* Mehr dazu weiter unten!

<Note>
  **Linear**: Wenn Sie die [Linear-Integration](/de/integrations/linear) bereits eingerichtet haben, verfügt Devin bereits über native Linear-Tools, sodass Sie den Linear-MCP nicht separat konfigurieren müssen.
</Note>

<div id="datadog">
  ### Datadog
</div>

Dies ist der offizielle Datadog-Remote-MCP-Server. Wenn Sie ihn im Marketplace aktivieren, werden Sie aufgefordert, sich über OAuth mit Ihrem Datadog-Konto zu authentifizieren.

Außerdem müssen Sie beim Aktivieren des MCP Ihre Datadog-Site/-Region auswählen (z. B. US1, US3, US5, EU, AP1, AP2, US1-FED).

[Dokumentation](https://docs.datadoghq.com/bits_ai/mcp_server/)

<div id="slack">
  ### Slack
</div>

Dies ist der offizielle Remote-MCP-Server für Slack. Wenn Sie ihn im Marketplace aktivieren, werden Sie aufgefordert, sich über OAuth mit Ihrem Slack-Konto zu authentifizieren.

Beachten Sie, dass hier OAuth auf Nutzerebene verwendet wird: Wenn die Verbindung mit organisationsweitem Zugriff hergestellt wird, teilen sich alle Mitglieder der Organisation dieselbe Nutzeridentität. Wir empfehlen daher, persönlichen Zugriff zu verwenden.

[Dokumentation](https://docs.slack.dev/ai/slack-mcp-server)

<div id="supabase">
  ### Supabase
</div>

Sie müssen ein persönliches Zugriffstoken angeben, das Sie unter [https://supabase.com/dashboard/account/tokens](https://supabase.com/dashboard/account/tokens) erstellen und einsehen können.

[Dokumentation](https://mcpservers.org/servers/supabase-community/supabase-mcp)

<div id="figma">
  ### Figma
</div>

Dies ist der offizielle Figma-Remote-MCP-Server. Wenn du das MCP im Marketplace aktivierst, wirst du aufgefordert, dich über OAuth mit deinem Figma-Konto zu authentifizieren.

Wenn du dieses MCP verwendest, sende Devin einen Link zu deiner Figma-Datei.

[Dokumentation](https://developers.figma.com/docs/figma-mcp-server/remote-server-installation/)

<div id="stripe">
  ### Stripe
</div>

Sie müssen einen Authorization-Header im Format `Bearer &lt;TOKEN&gt;` angeben, wobei `&lt;TOKEN&gt;` Ihr Stripe-API-Schlüssel ist. Weitere Informationen finden Sie unter: [https://docs.stripe.com/mcp#bearer-token](https://docs.stripe.com/mcp#bearer-token)

[Dokumentation](https://docs.stripe.com/mcp)

<div id="zapier">
  ### Zapier
</div>

Sie müssen einen Authorization-Header angeben, der dem Format `Bearer <TOKEN>` entspricht.

Sie müssen Ihr Bearer-Token aus der Server-URL extrahieren, die unter [https://mcp.zapier.com/mcp/servers](https://mcp.zapier.com/mcp/servers) > Connect bereitgestellt wird.

Ihre Server-URL sieht etwa wie folgt aus: [https://mcp.zapier.com/api/mcp/s/\*\*\*\*\*/mcp](https://mcp.zapier.com/api/mcp/s/*****/mcp)

Extrahieren Sie den mit Sternchen markierten Abschnitt (\*\*\*\*\*) und verwenden Sie ihn im von Ihnen angegebenen Authorization-Header: `Bearer *****`

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/oqBYXWmkhuOhl3HZ/images/Zapier_MCP.png?fit=max&auto=format&n=oqBYXWmkhuOhl3HZ&q=85&s=4369b99546ea6d4168d1c6a3e186195b" alt="Devin" width="1201" height="649" data-path="images/Zapier_MCP.png" />
</Frame>

[Dokumentation](https://zapier.com/mcp)

<div id="airtable">
  ### Airtable
</div>

Sie müssen einen Airtable-API-Schlüssel angeben. Ihre API-Schlüssel finden Sie unter [https://airtable.com/create/tokens](https://airtable.com/create/tokens)

[Dokumentation](https://www.npmjs.com/package/airtable-mcp-server)

<div id="docker-hub">
  ### Docker Hub
</div>

Erforderliche Zugangsdaten:

* Docker-Hub-Benutzername: Diesen kannst du in „My Hub“ finden
* Personal Access Token: Gehe zu „Account settings“ > „Personal access tokens“ und erstelle ein Token
  <Frame>
    <img src="https://mintcdn.com/cognitionai-enterprise/JQ4gdhcxD51zUhW4/images/dockermcp.png?fit=max&auto=format&n=JQ4gdhcxD51zUhW4&q=85&s=93ca26c0361a410120b0ed9c313a930a" alt="Devin" width="1836" height="942" data-path="images/dockermcp.png" />
  </Frame>

[Dokumentation](https://hub.docker.com/r/mcp/dockerhub)

<div id="sonarqube">
  ### SonarQube
</div>

So erhalten Sie die erforderlichen Zugangsdaten:

* SonarQube-Token: Rufen Sie **My Account > Security** auf und generieren Sie dort Ihr API-Token.
* SonarQube-Org: Dies ist Ihr Benutzername; ein Beispiel sehen Sie im Bild unten.
  <Frame>
    <img src="https://mintcdn.com/cognitionai-enterprise/A1NrXl_1--Cgx5nh/images/sonarqubemcp.png?fit=max&auto=format&n=A1NrXl_1--Cgx5nh&q=85&s=e5054e50938f9c50e35ecb01b5336ffd" alt="Devin" width="1836" height="652" data-path="images/sonarqubemcp.png" />
  </Frame>
* SonarQube-URL:
  * Für self-hosted: Das Format ist [http://localhost:9000](http://localhost:9000/) oder [https://sonarqube.mycompany.com](https://sonarqube.mycompany.com/)
  * Für SonarCloud: Verwenden Sie [https://sonarcloud.io](https://sonarcloud.io/)

[Dokumentation](https://github.com/SonarSource/sonarqube-mcp-server)

<div id="netlify">
  ### Netlify
</div>

Sie müssen ein Personal Access Token (PAT) angeben, das Sie unter [https://app.netlify.com/user/applications#personal-access-tokens](https://app.netlify.com/user/applications#personal-access-tokens) anzeigen und erstellen können. Stellen Sie sicher, dass Sie das PAT direkt nach der Erstellung kopieren. Sie können es später nicht mehr einsehen!

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/oD-FO9nMcsNLafKf/images/netlify.png?fit=max&auto=format&n=oD-FO9nMcsNLafKf&q=85&s=a84824c48aae17d32da4f0d410cf2bfd" alt="Devin" width="1334" height="782" data-path="images/netlify.png" />
</Frame>

[Dokumentation](https://docs.netlify.com/welcome/build-with-ai/netlify-mcp-server/)

<div id="pulumi">
  ### Pulumi
</div>

Ein Pulumi-Zugriffstoken kann im Abschnitt „Access tokens“ in der Seitenleiste des Pulumi-Dashboards erhalten werden.

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/p6mfZwd14EeP9cx_/images/pulumi.png?fit=max&auto=format&n=p6mfZwd14EeP9cx_&q=85&s=7365b1d99d3036bd1b8967eff22a06c0" alt="Devin" width="1827" height="902" data-path="images/pulumi.png" />
</Frame>

[Dokumentation](https://www.pulumi.com/docs/iac/using-pulumi/mcp-server/)

<div id="parallel">
  ### Parallel
</div>

Sie benötigen einen API-Schlüssel, den Sie auf [https://platform.parallel.ai/](https://platform.parallel.ai/) generieren können.

[Dokumentation](https://docs.parallel.ai/features/remote-mcp)

<div id="heroku">
  ### Heroku
</div>

Sie benötigen einen API-Schlüssel. Diesen finden Sie unter [https://dashboard.heroku.com/account](https://dashboard.heroku.com/account)

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/oqBYXWmkhuOhl3HZ/images/Heroku.png?fit=max&auto=format&n=oqBYXWmkhuOhl3HZ&q=85&s=f8d4fc8875f4698fb4d8f4aa66dd7a45" alt="Devin" width="1087" height="672" data-path="images/Heroku.png" />
</Frame>

[Dokumentation](https://www.heroku.com/blog/introducing-official-heroku-mcp-server/)

<div id="circleci">
  ### CircleCI
</div>

Sie müssen zwei Umgebungsvariablen konfigurieren:

* `CIRCLECI_TOKEN` - CircleCI API-Token, das unter [https://app.circleci.com/settings/user/tokens](https://app.circleci.com/settings/user/tokens) erstellt werden kann. Stellen Sie sicher, dass Sie das API-Token direkt nach der Erstellung kopieren. Sie können es danach nicht mehr einsehen!

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/oqBYXWmkhuOhl3HZ/images/CircleCI.png?fit=max&auto=format&n=oqBYXWmkhuOhl3HZ&q=85&s=519e872376d5a77abc06b28c681090f9" alt="Devin" width="1301" height="893" data-path="images/CircleCI.png" />
</Frame>

* `CIRCLECI_BASE_URL` \[Optional] - Diese Variable ist optional und wird nur für On-Premises-Kunden benötigt. Der Standardwert lautet `"https://circleci.com"`

[Dokumentation](https://hub.docker.com/r/mcp/circleci)

<div id="cortex">
  ### Cortex
</div>

Du musst ein persönliches Cortex-Zugriffstoken bereitstellen, um dieses MCP zu verwenden:

1. Melde dich bei deiner Cortex-Instanz an.
2. Gehe im linken Menü zu *Settings → My access tokens*.
3. Klicke auf *Create new token*.
4. Gib einen Namen und eine Beschreibung für das Token ein.
5. Klicke auf *Create token* und kopiere das Token.

Stelle bei der Verwendung dieses MCP sicher, dass Devin mit der richtigen Cortex-API-URL konfiguriert ist (Standardwert: `https://api.getcortexapp.com`).

[Dokumentation](https://docs.cortex.io/get-started/mcp)

<div id="square">
  ### Square
</div>

Sie müssen einen Authorization-Header im Format `Bearer <TOKEN>` angeben, wobei `<TOKEN>` Ihr Square-Access-Token ist. Weitere Informationen finden Sie unter: [https://developer.squareup.com/docs/build-basics/access-tokens](https://developer.squareup.com/docs/build-basics/access-tokens)

[Dokumentation](https://developer.squareup.com/docs/mcp)

<div id="hubspot">
  ### Hubspot
</div>

Du musst ein Access-Token als Umgebungsvariable bereitstellen. So erhältst du dein Access-Token:

1. Erstelle eine private App in HubSpot:
2. Gehe zu Settings > Integrations > Private Apps
3. Klicke auf „Create private app“
4. Benenne deine App und setze die erforderlichen Scopes
5. Klicke auf „Create app“
6. Kopiere das generierte Access-Token aus dem Tab „Auth“

[Dokumentation](https://www.npmjs.com/package/@hubspot/mcp-server)

<div id="redis">
  ### Redis
</div>

Erforderliche Zugangsdaten:

* Redis-Host
* Redis-Port
* Redis-Benutzername
* Redis-Passwort

[Dokumentation](https://redis.io/docs/latest/integrate/redis-mcp/client-conf/)

<div id="google-maps">
  ### Google Maps
</div>

Sie müssen (1) einen API-Schlüssel angeben und (2) die einzelnen APIs aktivieren, auf die Devin Zugriff haben soll.

Um Ihren API-Schlüssel zu erhalten, navigieren Sie zu [https://console.cloud.google.com/apis/credentials](https://console.cloud.google.com/apis/credentials) und öffnen Sie die Seitenleiste > APIs & Services > Credentials.

Um eine einzelne API zu aktivieren, suchen Sie nach der API und klicken Sie auf „Enable“.

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/oqBYXWmkhuOhl3HZ/images/MapsMCP1.png?fit=max&auto=format&n=oqBYXWmkhuOhl3HZ&q=85&s=5054d6697f072d088d531f4b42aa2975" alt="Devin" width="1602" height="957" data-path="images/MapsMCP1.png" />
</Frame>

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/oqBYXWmkhuOhl3HZ/images/MapsMCP2.png?fit=max&auto=format&n=oqBYXWmkhuOhl3HZ&q=85&s=cac430aaaec5353619807a9e880d73a3" alt="Devin" width="1840" height="885" data-path="images/MapsMCP2.png" />
</Frame>

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/oqBYXWmkhuOhl3HZ/images/MapsMCP4.png?fit=max&auto=format&n=oqBYXWmkhuOhl3HZ&q=85&s=ff52adfbdecdd26b72d592420c6d8f56" alt="Devin" width="1088" height="831" data-path="images/MapsMCP4.png" />
</Frame>

[Dokumentation](https://www.npmjs.com/package/@modelcontextprotocol/server-google-maps)

<div id="playwright">
  ### Playwright
</div>

Für diese Integration sind keine Umgebungsvariablen nötig! Aktivieren Sie einfach die Integration.

[Dokumentation](https://hub.docker.com/r/mcp/playwright)

<div id="firecrawl">
  ### Firecrawl
</div>

Sie benötigen einen API-Schlüssel (`FIRECRAWL_API_KEY`), den Sie unter [https://www.firecrawl.dev/app/api-keys](https://www.firecrawl.dev/app/api-keys) einsehen und erstellen können.

[Dokumentation](https://hub.docker.com/r/mcp/firecrawl#use-this-mcp-server)

<div id="elasticsearch">
  ### ElasticSearch
</div>

Sie müssen zwei Umgebungsvariablen angeben:

* `ES_URL` - ElasticSearch-URL oder -Endpoint, der auf der Seite `/overview` in Elasticsearch zu finden ist.
* `ES_API_KEY` - ElasticSearch-API-Schlüssel, der auf der Seite `/indices/index_details/<name>/data` in Elasticsearch erstellt werden kann.

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/JQ4gdhcxD51zUhW4/images/elasticsearch.png?fit=max&auto=format&n=JQ4gdhcxD51zUhW4&q=85&s=eb064fe58f44f992873b29a086e731b1" alt="Devin" width="1383" height="637" data-path="images/elasticsearch.png" />
</Frame>

`ES_SSL_SKIP_VERIFY` ist eine optionale Umgebungsvariable. Wenn sie auf `true` gesetzt ist, wird die Überprüfung des SSL/TLS-Zertifikats bei der Verbindung zu Elasticsearch übersprungen.

[Dokumentation](https://hub.docker.com/r/mcp/elasticsearch)

<div id="postgres">
  ### Postgres
</div>

Die einzige erforderliche Anmeldeinformation ist die Postgres-Verbindungszeichenfolge.

[Dokumentation](https://www.npmjs.com/package/@modelcontextprotocol/server-postgres?activeTab=readme)

<div id="plaid">
  ### Plaid
</div>

Die einzige erforderliche Anmeldeinformation ist ein OAuth-Bearer-Access-Token, das Sie erhalten, indem Sie den folgenden Code ausführen:

```jsx theme={null}
curl -X POST https://production.plaid.com/oauth/token \
-H 'Content-Type: application/json' \
-d '{
"client_id": "YOUR_PLAID_CLIENT_ID",
"client_secret": "YOUR_PRODUCTION_SECRET",
"grant_type": "client_credentials",
"scope": "mcp:dashboard"
}'
```

Um die Client-ID und das Client Production Secret zu erhalten, rufen Sie [https://dashboard.plaid.com/developers/keys](https://dashboard.plaid.com/developers/keys) auf.

[Dokumentation](https://plaid.com/docs/resources/mcp/)

<div id="replicate">
  ### Replicate
</div>

Die einzige erforderliche Anmeldeinformation ist das API-Token, das unter [https://replicate.com/account/api-tokens](https://replicate.com/account/api-tokens) zu finden ist.

[Dokumentation](https://replicate.com/docs/reference/mcp)

<div id="grafana">
  ### Grafana
</div>

Sie müssen 2 Umgebungsvariablen bereitstellen:

* Grafana-URL
* Grafana-Servicekontotoken: Um das Token zu erhalten, gehen Sie in der Seitenleiste zu Administration > Users and access > Service accounts > Add service account (falls Sie noch keines hinzugefügt haben) > Add service account token

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/JQ4gdhcxD51zUhW4/images/grafana.png?fit=max&auto=format&n=JQ4gdhcxD51zUhW4&q=85&s=07d1f8c4160b53743368c0c7cc6df2bf" alt="Devin" width="1862" height="987" data-path="images/grafana.png" />
</Frame>

<div id="pinecone">
  ### Pinecone
</div>

HINWEIS: Die Pinecone MCP unterstützt nur Indizes mit integrierten Embeddings. Indizes für Vektoren, die Sie mit externen Embedding-Modellen erstellen, werden mit Stand 16.07.2025 noch nicht unterstützt.

Das einzige benötigte Berechtigungsmerkmal ist der Pinecone-API-Schlüssel, den Sie über die Seite „API Keys“ im Pinecone-Dashboard erhalten können, wie unten zu sehen:

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/oD-FO9nMcsNLafKf/images/pinecone.png?fit=max&auto=format&n=oD-FO9nMcsNLafKf&q=85&s=b5141e1593f2cb0479ec040802280762" alt="Devin" width="1840" height="947" data-path="images/pinecone.png" />
</Frame>

<div id="snyk">
  ### Snyk
</div>

1. Konfiguriere zunächst den MCP-Server. Die Dokumentation ist [hier](https://docs.snyk.io/integrations/developer-guardrails-for-agentic-workflows/quickstart-guides-for-mcp/devin-guide) verfügbar. Hinweis: Stelle sicher, dass du am Ende eine Umgebungsvariable hinzufügst (in der Dokumentation nicht aufgeführt).
   <Frame>
     <img src="https://mintcdn.com/cognitionai-enterprise/fh-R0_T65dbpUS2r/images/snyk.png?fit=max&auto=format&n=fh-R0_T65dbpUS2r&q=85&s=1c5a165b7e2ccdac68beaacf0a413c3d" alt="Devin" width="939" height="797" data-path="images/snyk.png" />
   </Frame>
2. Installiere die Snyk-CLI auf Devins Maschine. Die Dokumentation ist [hier](https://docs.snyk.io/developer-tools/snyk-cli/install-or-update-the-snyk-cli) verfügbar.

```jsx theme={null}
brew tap snyk/tap
brew install snyk-cli

snyk --disable-trust
```

Hinweis: Einige Snyk-Tests erfordern Vertrauenseinstellungen, um ausgeführt zu werden – installiere Snyk auf dem Rechner, nachdem Homebrew installiert wurde. Die Dokumentation ist [hier](https://docs.snyk.io/integrations/developer-guardrails-for-agentic-workflows/troubleshooting-for-the-snyk-mcp-server#folder-trust) verfügbar.

**Tipp**:
Wenn alles korrekt konfiguriert ist, sollte die vollständige Liste der Snyk-Scans bereits beim ersten Durchlauf ausgeführt werden. Abhängig vom Framework erfordern einige Scans jedoch das Setzen des Flags `unmanaged: true` (z. B. C++). Aktuell kannst du dies im Knowledge-Bereich oder während deiner Devin-Sitzung setzen – hier ein Beispiel:

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/fh-R0_T65dbpUS2r/images/synk-example.png?fit=max&auto=format&n=fh-R0_T65dbpUS2r&q=85&s=b1e3752ddfc4c1d5f7cbf9d56c11d630" alt="Devin" width="1020" height="158" data-path="images/synk-example.png" />
</Frame>

**Tipp**: Wir haben ein [Beispiel-Playbook](https://app.devin.ai/settings/playbooks/163db5ecab7e47e6a82c71bf8d338678) erstellt, um dir den Einstieg zu erleichtern.

[Dokumentation](https://docs.snyk.io/integrations/developer-guardrails-for-agentic-workflows/quickstart-guides-for-mcp/devin-guide)