> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devin.ai/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. Wie die Verbindung geteilt wird, hängt von der **Access**-Einstellung des Servers ab:

  * **Organization**: Alle Mitglieder teilen sich eine einzige authentifizierte Verbindung. **Wir empfehlen dringend, ein Servicekonto zu verbinden** – nicht Ihr persönliches Konto –, da es in den Sitzungen aller Mitglieder verwendet wird.
  * **Personal**: Jedes Organisationsmitglied authentifiziert sich einzeln mit seinem eigenen Konto, daher ist es in Ordnung, Ihr persönliches Konto zu verbinden. Beachten Sie, dass andere Nutzer weiterhin mit Ihren Sitzungen interagieren können, daher sollte dies nicht als Sicherheitsgrenze betrachtet werden.
</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. Wenn Ihr Anbieter vorregistrierte OAuth-Anwendungen erfordert (ohne dynamische Client-Registrierung), geben Sie unter **OAuth credentials** Ihre eigene Client-ID und Ihr eigenes Secret an und fügen Sie Devins Callback-URL `https://api.devin.ai/mcp/oauth/callback` in den Einstellungen Ihrer OAuth-Anwendung zur Redirect-URI-Allowlist hinzu.
* **Access** (nur OAuth): Wählen Sie aus, wer die authentifizierte Verbindung verwendet.
  * **Organization**: Alle Member teilen sich eine einzige Verbindung. Verbinden Sie ein Servicekonto statt eines persönlichen Kontos.
  * **Personal**: Jedes Organization-Mitglied authentifiziert sich einzeln mit seinem eigenen Konto.

**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. Wenn Sie Ihre eigenen OAuth-Client-Anmeldedaten verwenden, muss der Anbieter Devins Callback-URL `https://api.devin.ai/mcp/oauth/callback` als Redirect-URI zulassen — viele Anbieter lehnen den OAuth-Flow ab, wenn diese URL nicht auf der Whitelist steht.
* 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>
  Für OAuth-basierte MCPs mit **Organization**-Zugriff **verwenden Sie ein Servicekonto** statt Ihres persönlichen Kontos — alle Sitzungen der Mitglieder verwenden dieselbe authentifizierte Verbindung. Mit **Personal**-Zugriff authentifiziert sich jedes Mitglied mit seinem eigenen Konto, daher ist ein persönliches Konto in Ordnung.
</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/a0js040y87FuBerW/images/Zapier_MCP.png?fit=max&auto=format&n=a0js040y87FuBerW&q=85&s=5214ff282660e04757b9169fae807cfa" 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/ifLkKLaMB-vvINwf/images/dockermcp.png?fit=max&auto=format&n=ifLkKLaMB-vvINwf&q=85&s=82758d25926fe6644f01b6d4e058b6f7" 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/k89q9Lsp7DOurdC0/images/sonarqubemcp.png?fit=max&auto=format&n=k89q9Lsp7DOurdC0&q=85&s=6067e168952a0a54ff703e95bf3a4453" 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/s_eAbNGhbOgn5ZqZ/images/netlify.png?fit=max&auto=format&n=s_eAbNGhbOgn5ZqZ&q=85&s=485845854f9cd20aa1cf15e857fae2b5" 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/gfRQhyCSwUhbMkzA/images/pulumi.png?fit=max&auto=format&n=gfRQhyCSwUhbMkzA&q=85&s=0a8b46d0f5110776741d3414abcd7350" 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/a0js040y87FuBerW/images/Heroku.png?fit=max&auto=format&n=a0js040y87FuBerW&q=85&s=0ccdfe37f97537389a3810301be2e50d" 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/a0js040y87FuBerW/images/CircleCI.png?fit=max&auto=format&n=a0js040y87FuBerW&q=85&s=6eb8d1a812f6a8b715a196f0fe3a01d3" 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/a0js040y87FuBerW/images/MapsMCP1.png?fit=max&auto=format&n=a0js040y87FuBerW&q=85&s=3d20b29ef11e1b713f435f87402aa962" alt="Devin" width="1602" height="957" data-path="images/MapsMCP1.png" />
</Frame>

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

<Frame>
  <img src="https://mintcdn.com/cognitionai/a0js040y87FuBerW/images/MapsMCP4.png?fit=max&auto=format&n=a0js040y87FuBerW&q=85&s=fc8243ef585f3f57ecb716ade31c5ff1" 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/ifLkKLaMB-vvINwf/images/elasticsearch.png?fit=max&auto=format&n=ifLkKLaMB-vvINwf&q=85&s=5e0cab4b8525d2377c6353f95f94fbbc" 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/ifLkKLaMB-vvINwf/images/grafana.png?fit=max&auto=format&n=ifLkKLaMB-vvINwf&q=85&s=e16f4c261b07fda96ad235d4be993367" 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/s_eAbNGhbOgn5ZqZ/images/pinecone.png?fit=max&auto=format&n=s_eAbNGhbOgn5ZqZ&q=85&s=8229b659a0e8f78eee7cb145e49d2d0e" 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/F6MIT2LaffywIXqC/images/snyk.png?fit=max&auto=format&n=F6MIT2LaffywIXqC&q=85&s=50fde971b376243d74fcf09ee4014993" 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/F6MIT2LaffywIXqC/images/synk-example.png?fit=max&auto=format&n=F6MIT2LaffywIXqC&q=85&s=b7d4e1923f90e00e1c7106515fa2ee20" 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)