# Einen Server deaktivieren, ohne ihn zu entfernen
```
### Über die Konfigurationsdatei
Füge Server direkt im Abschnitt `mcpServers` deiner Konfigurationsdatei hinzu:
```json theme={null}
// .devin/config.json
{
"mcpServers": {
"server-name": {
"command": "npx",
"args": ["-y", "@company/mcp-server"],
"env": {
"API_KEY": "your-key"
}
}
}
}
```
Server auf Projektebene werden über die Versionsverwaltung mit deinem Team geteilt.
```json theme={null}
// ~/.config/devin/config.json
{
"mcpServers": {
"my-server": {
"command": "node",
"args": ["/path/to/my-server.js"],
"env": {}
}
}
}
```
Server auf Nutzerebene gelten für alle deine Projekte.
```json theme={null}
// .devin/config.local.json
{
"mcpServers": {
"server-name": {
"command": "npx",
"args": ["-y", "@company/mcp-server"],
"env": {
"API_KEY": "my-personal-key"
}
}
}
}
```
Lokale Konfigurationen werden von Git ignoriert — verwende sie für persönliche API keys.
***
## Optionen für die Serverkonfiguration
MCP-Server können auf zwei Arten konfiguriert werden: als **lokaler Befehl** (stdio-Transport) oder als **Remote-Server** (HTTP-Transport).
### Lokaler Befehl (stdio)
| Feld | Typ | Erforderlich | Beschreibung |
| ---------- | --------- | ------------ | -------------------------------------------------------------------------------------------------------------------------------------- |
| `command` | string | Ja | Das auszuführende Programm |
| `args` | string\[] | Nein | Befehlszeilenargumente |
| `env` | object | Nein | Zu setzende Umgebungsvariablen |
| `disabled` | boolean | Nein | Auf `true` setzen, um diesen Server zu überspringen (siehe [Aktivieren und Deaktivieren von Servern](#enabling-and-disabling-servers)) |
### Remote-Server (Streamable HTTP)
| Feld | Typ | Erforderlich | Beschreibung |
| ------------------- | ------- | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `url` | string | Ja | Die URL des Endpunkts des MCP-Servers |
| `transport` | string | Nein | `"http"` (Streamable HTTP, Standard für URL-basierte Server) oder `"sse"` (veraltetes SSE). Wenn `"http"` festgelegt ist oder weggelassen wird, versucht die CLI zuerst Streamable HTTP und fällt bei 4xx-Fehlern auf SSE zurück ([gemäß Spezifikation](https://spec.modelcontextprotocol.io/specification/2025-03-26/basic/transports/#backwards-compatibility)). Legen Sie `"sse"` explizit fest, wenn sich der SSE-Endpunkt des Servers unter einem anderen Pfad befindet. |
| `headers` | object | Nein | Benutzerdefinierte HTTP-Header, die in Anfragen gesendet werden |
| `oauthClientId` | string | Nein | Vorregistrierte OAuth-Client-ID für Server, die keine dynamische Client-Registrierung (DCR) unterstützen, z. B. GitHub. Siehe den Abschnitt „Vorregistrierte OAuth-Clients“ weiter unten. |
| `oauthClientSecret` | string | Nein | OAuth-Client-Secret für vertrauliche Clients. Zusammen mit `oauthClientId` verwenden. |
| `disabled` | boolean | Nein | Auf `true` setzen, um diesen Server zu überspringen (siehe [Aktivieren und Deaktivieren von Servern](#enabling-and-disabling-servers)) |
### Beispiele
```json theme={null}
{
"mcpServers": {
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_TOKEN": "ghp_..."
}
}
}
}
```
```json theme={null}
{
"mcpServers": {
"notion": {
"url": "https://mcp.notion.com/mcp",
"transport": "http"
}
}
}
```
Führen Sie nach dem Hinzufügen eines OAuth-basierten Servers `devin mcp login notion` aus, um die Authentifizierung durchzuführen. Weitere Informationen finden Sie unten unter [Authentifizierung](#authentication).
```json theme={null}
{
"mcpServers": {
"linear": {
"url": "https://mcp.linear.app/mcp",
"transport": "http"
}
}
}
```
```json theme={null}
{
"mcpServers": {
"atlassian": {
"url": "https://mcp.atlassian.com/v1/mcp",
"transport": "http"
}
}
}
```
Führen Sie nach dem Hinzufügen `devin mcp login atlassian` aus, um die Authentifizierung durchzuführen. Jeder MCP-Client (Windsurf, Claude Code, Devin CLI) verwaltet seine eigene OAuth-Sitzung. Sie müssen sich also separat anmelden, auch wenn Sie sich bereits in einem anderen Tool authentifiziert haben.
```json theme={null}
{
"mcpServers": {
"my-tools": {
"command": "python",
"args": ["./scripts/mcp-server.py"],
"env": {
"DB_URL": "postgres://localhost/mydb"
}
}
}
}
```
***
## Authentifizierung
Einige Remote-MCP-Server erfordern eine OAuth-Authentifizierung. Nachdem du deiner Konfiguration einen OAuth-basierten Server hinzugefügt hast, melde dich mit dem Befehl `login` an:
```bash theme={null}
devin mcp login
```
Zum Beispiel:
```bash theme={null}
devin mcp login notion # Mit Notion authentifizieren
devin mcp login linear # Mit Linear authentifizieren
```
Dadurch öffnet sich ein Browserfenster, in dem du den Zugriff autorisieren kannst. Die OAuth-Token werden lokal gespeichert und automatisch erneuert.
Du kannst optional bestimmte OAuth-Geltungsbereiche anfordern:
```bash theme={null}
devin mcp login notion --scopes read,write
```
So entfernen Sie gespeicherte Anmeldedaten für einen Server:
```bash theme={null}
devin mcp logout
```
Wenn der Server OAuth unterstützt, werden Sie bei der ersten Verwendung des Servers außerdem automatisch zur Authentifizierung aufgefordert.
### Vorregistrierte OAuth-Clients
Die meisten OAuth-basierten MCP-Server unterstützen die [dynamische Client-Registrierung](https://datatracker.ietf.org/doc/html/rfc7591) (DCR), sodass Devin CLI sich automatisch registriert und Sie keine Client-Zugangsdaten angeben müssen.
Einige Anbieter (z. B. GitHub) unterstützen DCR nicht und erfordern stattdessen einen **vorregistrierten** OAuth-Client. Geben Sie für diese die Client-ID an — und ein Client-Secret, falls es sich um einen vertraulichen Client handelt — über `oauthClientId` / `oauthClientSecret`:
```json theme={null}
{
"mcpServers": {
"my-server": {
"url": "https://mcp.example.com/mcp",
"transport": "http",
"oauthClientId": "Iv1.abc123def456",
"oauthClientSecret": "${env:MY_MCP_CLIENT_SECRET}"
}
}
}
```
Wenn `oauthClientId` gesetzt ist, überspringt Devin CLI die dynamische Client-Registrierung und verwendet während des OAuth-Ablaufs Ihren vorregistrierten Client. Führen Sie `devin mcp login ` aus (oder authentifizieren Sie sich bei der ersten Verwendung), um sich wie gewohnt anzumelden.
Sie können diese Werte auch über die Befehlszeile festlegen, wenn Sie einen Server hinzufügen oder sich bei einem Server anmelden:
```bash theme={null}
devin mcp add my-server --oauth-client-id --oauth-client-secret
devin mcp login my-server --oauth-client-id --oauth-client-secret
```
`oauthClientId` / `oauthClientSecret` sind OAuth-Client-Anmeldedaten, die während des Autorisierungsflusses verwendet werden. Sie sind **keine** allgemeinen Anmeldedaten für einzelne Requests — wenn ein Server ein statisches Token erwartet, verwende stattdessen `headers` (HTTP) oder `env` (stdio).
Checke kein Client Secret in eine gemeinsam genutzte Konfiguration ein. Referenziere es über eine Umgebungsvariable (`${env:VAR}`), lies es aus einer Datei (`${file:/path}`) oder speichere es in `.devin/config.local.json` (gitignored). Siehe unten den Abschnitt "Verwalten von Secrets".
***
## Aktivieren und Deaktivieren von Servern
Sie können einen MCP-Server vorübergehend deaktivieren, ohne seine Konfiguration zu entfernen. Ein deaktivierter Server wird bei der Tool-Erkennung übersprungen — seine Tools werden nicht angezeigt, und der Serverprozess wird nicht gestartet.
```bash theme={null}
devin mcp disable # Einen Server deaktivieren
devin mcp enable # Wieder aktivieren
```
Dies setzt das Flag `"disabled": true` für den Server-Eintrag in der Konfigurationsdatei. Verwenden Sie `-s`/`--scope`, um einen bestimmten Geltungsbereich festzulegen:
```bash theme={null}
devin mcp disable -s project my-server
devin mcp enable -s user my-server
```
Sie können das Flag auch direkt in Ihrer Konfigurationsdatei setzen:
```json theme={null}
{
"mcpServers": {
"my-server": {
"command": "npx",
"args": ["-y", "@company/mcp-server"],
"disabled": true
}
}
}
```
Das Deaktivieren ist nützlich, wenn Sie die Konfiguration eines Servers (einschließlich Umgebungsvariablen und OAuth-Anmeldedaten) beibehalten, ihn aber vorübergehend nicht verwenden möchten — zum Beispiel, um die Startzeit zu verkürzen oder ein Problem zu isolieren.
***
## Secrets verwalten
Committe niemals API keys oder Secrets in die Versionsverwaltung. Verwende `.devin/config.local.json` für sensible Werte.
Für Teamprojekte wird folgendes Vorgehen empfohlen:
1. Definiere den Server in `.devin/config.json` mit Platzhaltern oder ohne Umgebungsvariablen
2. Jedes Teammitglied fügt seine persönlichen Keys in `.devin/config.local.json` hinzu
Die lokale Konfigurationsdatei wird automatisch von Git ausgeschlossen.
***
## MCP-Berechtigungen
Sie können in Ihrer Berechtigungskonfiguration bestimmte MCP-Tools vorab genehmigen, ablehnen oder jedes Mal eine Rückfrage erzwingen:
```json theme={null}
{
"permissions": {
"allow": [
"mcp__github__list_issues",
"mcp__github__create_issue"
],
"deny": [
"mcp__github__delete_repo"
],
"ask": [
"mcp__linear__*"
]
}
}
```
**Muster für den Berechtigungsabgleich:**
| Pattern | Entspricht |
| ------------------- | ----------------------------------------------- |
| `mcp__server__tool` | Ein bestimmtes Tool auf einem bestimmten Server |
| `mcp__server__*` | Alle Tools auf einem bestimmten Server |
| `mcp__*` | Alle MCP-Tools auf allen Servern |
***
## Einschränkungen auf Organisationsebene
Wenn Sie Teil eines Enterprise-Teams sind, kann Ihr Admin einschränken, mit welchen MCP-Servern Sie eine Verbindung herstellen können. Ein von Ihnen konfigurierter Server kann blockiert werden, wenn MCP für Ihr Team deaktiviert ist oder wenn er weder auf der Allowlist Ihres Teams noch in einer erzwungenen **MCP Registry** enthalten ist — in diesem Fall wird keine Verbindung hergestellt und seine Tools sind nicht verfügbar. Weitere Informationen finden Sie unter [Team Settings — MCP Registry](/de/cli/enterprise/team-settings#mcp-registry).
***
## Fehlerbehebung
Wenn beim Verbinden mit einem Remote-MCP-Server Fehler wie `Auth required` oder `AuthRequired` angezeigt werden, erfordert der Server eine OAuth-Authentifizierung.
Führen Sie Folgendes aus:
```bash theme={null}
devin mcp login
```
Jeder MCP-Client authentifiziert sich unabhängig. Selbst wenn Sie sich bereits in Windsurf oder Claude Code authentifiziert haben, müssen Sie `devin mcp login` für Devin CLI separat ausführen.
Um Ihren Authentifizierungsstatus zu prüfen, versuchen Sie, die Anmeldedaten zu entfernen und erneut hinzuzufügen:
```bash theme={null}
devin mcp logout
devin mcp login
```
Prüfen Sie, ob der Befehl außerhalb von Devin CLI funktioniert:
```bash theme={null}
npx -y @modelcontextprotocol/server-github
```
Prüfen Sie, ob alle erforderlichen Umgebungsvariablen gesetzt sind.
Bitten Sie den Agenten, die MCP-Server und Tools aufzulisten. Möglicherweise braucht der Server einen Moment für die Initialisierung.
Prüfen Sie Ihre Berechtigungskonfiguration. MCP-Tools fragen standardmäßig nach einer Bestätigung. Fügen Sie sie zu `permissions.allow` hinzu, um sie automatisch zu genehmigen.
Beim Verbinden mit einem HTTP-Server versucht Devin CLI zuerst **Streamable HTTP**. Wenn der Server mit einem HTTP-4xx-Fehler antwortet (z. B. 404 oder 405), wird automatisch auf **Legacy SSE** unter **derselben konfigurierten URL** zurückgegriffen. Dies entspricht den [Hinweisen zur Abwärtskompatibilität in der MCP-Spezifikation](https://spec.modelcontextprotocol.io/specification/2025-03-26/basic/transports/#backwards-compatibility).
Der Fallback wird nur bei 4xx-Antworten ausgelöst — Verbindungsfehler, Timeouts und 5xx-Antworten werden direkt gemeldet, ohne einen SSE-Versuch.
Wenn sich der SSE-Endpunkt Ihres Servers unter einem anderen Pfad befindet (z. B. `/sse` statt `/mcp`), setzen Sie `"transport": "sse"` mit der SSE-URL, um direkt eine Verbindung herzustellen, ohne es zuerst über Streamable HTTP zu versuchen.
Wenn beide Transportarten fehlschlagen, enthält die Fehlermeldung Details aus beiden Versuchen, um die Fehlerbehebung zu erleichtern.