---
title: "MCP-Server verbinden | mcp.tc"
description: "MCP-Server in Claude Code, claude.ai, Claude Desktop, ChatGPT, Cursor, VS Code und anderen Clients einrichten: Anmeldung, API-Schlüssel und lokale Server."
url: "https://mcp.tc/de/docs/connect"
markdown: "https://mcp.tc/de/docs/connect.md"
lang: "de"
---

# MCP-Server verbinden

So fügst du einen Server von mcp.tc zu Claude Code, claude.ai, Claude Desktop, ChatGPT, Cursor, VS Code und anderen Clients hinzu. Jeder Schritt nutzt die eigene URL oder das Paket des Servers, genau wie die Buttons auf jedem Eintrag.

## Bevor du loslegst

Jeder Eintrag zeigt oben auf seiner Seite, womit du dich verbindest: die eigene URL des Servers bei einem Remote-Server oder den Installationsbefehl bei einem lokalen. Konnten wir beides nicht bestätigen, verweist er auf die Anleitung des Projekts. Die Badges unter dem Namen sagen, was der Server braucht.

Die Schritte unten sind die, die der Abschnitt **Einrichtung** jedes Eintrags zeigt, hier für vier Beispielserver. Wähl einen mit den Tabs; die Wahl gilt für jeden Client auf dieser Seite.

- **Ohne Anmeldung**: [DeepWiki, verifiziert](https://mcp.tc/de/i/deepwiki), ein Remote-Server, den jeder nutzen kann, unter `https://mcp.deepwiki.com/mcp`.
- **Anmeldung**: [Notion, verifiziert](https://mcp.tc/de/i/notion), ein Remote-Server, der dich um eine Anmeldung per OAuth bittet.
- **API-Schlüssel**: ein ausgedachter Server unter `mcp.example.com`, der einen Schlüssel im Header `Authorization` braucht.
- **Lokal**: [Memory, verifiziert](https://mcp.tc/de/i/memory), den dein Client mit `npx -y @modelcontextprotocol/server-memory` startet.

Auf der Seite eines Eintrags sind dieselben Schritte schon für diesen Server ausgefüllt, und die Buttons **Zu … hinzufügen** erledigen den ersten Schritt für dich.

Im Terminal nutzt [mcp-tc](https://mcp.tc/de/cli), unser Open-Source-Kommandozeilentool, dieselben Schritte. `npx mcp-tc add deepwiki --client cursor` fügt den Server so zu deinem Client hinzu, wie es der Abschnitt **Einrichtung** beschreibt: Es zeigt den Befehl, den es ausführen wird, oder die Änderung an deiner Konfigurationsdatei, fragt vorher nach, sichert eine Konfigurationsdatei, bevor es sie schreibt, und lässt API-Schlüssel auf deinem Computer. `npx mcp-tc scan` sucht die Server aus den Konfigurationen deiner Clients auf mcp.tc. Pro Server sendet es nur eine Adresse: seine https-URL ohne Zugangsdaten, Query-Parameter und schlüsselartige Pfadteile oder, bei einem lokalen Server, den Paketnamen oder die URL des Repositorys. Schlüssel, Header und Umgebungsvariablen bleiben auf deinem Computer, und private Adressen werden nie gesendet.

## Claude Code

Claude Code fügt Server im Terminal mit `claude mcp add` hinzu. Auf einem Eintrag kopiert **Zu Claude Code hinzufügen** den Befehl.

### Ohne Anmeldung

1. Führe das in einem Terminal in deinem Projektordner aus:

```
claude mcp add --transport http deepwiki https://mcp.deepwiki.com/mcp
```

2. Starte Claude Code und tippe `/mcp`. **deepwiki** sollte als verbunden angezeigt werden.

Ergänze `--scope user`, damit er in jedem Projekt verfügbar ist, nicht nur in diesem.

### Anmeldung

1. Führe das in einem Terminal in deinem Projektordner aus:

```
claude mcp add --transport http notion https://mcp.notion.com/mcp
```

2. Starte Claude Code, tippe `/mcp`, wähle **notion** und dann **Authenticate**. Ein Browserfenster öffnet sich für die Anmeldung bei Notion.

Ergänze `--scope user`, damit er in jedem Projekt verfügbar ist, nicht nur in diesem.

### API-Schlüssel

1. Führe das in einem Terminal in deinem Projektordner aus:

```
claude mcp add --transport http example https://mcp.example.com/mcp --header "Authorization: Bearer <YOUR_API_KEY>"
```

2. Ersetze den Platzhalter vor dem Ausführen durch deinen Schlüssel und prüfe die Verbindung danach mit `/mcp` in Claude Code.

Ergänze `--scope user`, damit er in jedem Projekt verfügbar ist, nicht nur in diesem.

### Lokal

1. Führe das in einem Terminal in deinem Projektordner aus:

```
claude mcp add --transport stdio memory -- npx -y @modelcontextprotocol/server-memory
```

2. Starte Claude Code und tippe `/mcp`. **memory** sollte als verbunden angezeigt werden.

Ergänze `--scope user`, damit er in jedem Projekt verfügbar ist.

## claude.ai

claude.ai fügt Remote-Server als benutzerdefinierte Connectors hinzu. **Zu claude.ai hinzufügen** öffnet das Connector-Formular mit Name und URL ausgefüllt. Ein Server, der einen API-Schlüssel braucht, geht auch: Trag den Schlüssel im selben Formular unter **Request headers** ein, zum Beispiel `Authorization: Bearer YOUR_KEY`. claude.ai kann keine lokalen Server starten, daher bieten lokale Einträge es nicht an.

### Ohne Anmeldung

1. Öffne das Connector-Formular auf claude.ai. Dieser Button füllt Name und URL für dich aus:

[Zu claude.ai hinzufügen](https://claude.ai/customize/connectors?modal=add-custom-connector&connectorName=DeepWiki&connectorUrl=https%3A%2F%2Fmcp.deepwiki.com%2Fmcp)

2. Prüfe, dass die URL `https://mcp.deepwiki.com/mcp` lautet, und klick auf **Add**.
3. Schalte ihn in einem Chat über das Tool-Menü ein.

Kostenlose Pläne erlauben einen benutzerdefinierten Connector. In Team- und Enterprise-Plänen fügt ihn ein Owner unter **Organization settings → Connectors** hinzu.

### Anmeldung

1. Öffne das Connector-Formular auf claude.ai. Dieser Button füllt Name und URL für dich aus:

[Zu claude.ai hinzufügen](https://claude.ai/customize/connectors?modal=add-custom-connector&connectorName=Notion&connectorUrl=https%3A%2F%2Fmcp.notion.com%2Fmcp)

2. Prüfe, dass die URL `https://mcp.notion.com/mcp` lautet, und klick auf **Add**.
3. Klick auf **Connect** und melde dich an, wenn Notion danach fragt.

Kostenlose Pläne erlauben einen benutzerdefinierten Connector. In Team- und Enterprise-Plänen fügt ihn ein Owner unter **Organization settings → Connectors** hinzu.

### API-Schlüssel

1. Öffne das Connector-Formular auf claude.ai. Dieser Button füllt Name und URL für dich aus:

[Zu claude.ai hinzufügen](https://claude.ai/customize/connectors?modal=add-custom-connector&connectorName=Example&connectorUrl=https%3A%2F%2Fmcp.example.com%2Fmcp)

2. Prüfe, dass die URL `https://mcp.example.com/mcp` lautet. Füge unter **Request headers** `Authorization: Bearer <YOUR_API_KEY>` mit deinem Schlüssel von Example hinzu und klick dann auf **Add**.
3. Schalte ihn in einem Chat über das Tool-Menü ein.

Kostenlose Pläne erlauben einen benutzerdefinierten Connector. In Team- und Enterprise-Plänen fügt ihn ein Owner unter **Organization settings → Connectors** hinzu.

## Claude Desktop

Remote-Server laufen über **Connectors**, dieselben, die du auf claude.ai siehst, auch solche mit API-Schlüssel unter **Request headers**. Lokale Server kommen in seine JSON-Konfigurationsdatei. Wenn der Schlüssel auf deinem Rechner bleiben soll, nimm stattdessen die Bridge `mcp-remote`.

### Ohne Anmeldung

1. Öffne **Customize → Connectors**, klick auf **+ Add** und dann auf **Add custom connector**.
2. Nenne ihn **DeepWiki** und füge diese URL ein:

```
https://mcp.deepwiki.com/mcp
```

3. Klick auf **Add**. Seine Tools erscheinen im Tool-Menü des Chats.

Die JSON-Konfigurationsdatei von Claude Desktop startet nur lokale Server. Remote-Server laufen über Connectors, und Connectors, die du auf claude.ai hinzufügst, erscheinen auch hier.

### Anmeldung

1. Öffne **Customize → Connectors**, klick auf **+ Add** und dann auf **Add custom connector**.
2. Nenne ihn **Notion** und füge diese URL ein:

```
https://mcp.notion.com/mcp
```

3. Klick auf **Add**, dann auf **Connect**, und melde dich an, wenn Notion danach fragt.

Die JSON-Konfigurationsdatei von Claude Desktop startet nur lokale Server. Remote-Server laufen über Connectors, und Connectors, die du auf claude.ai hinzufügst, erscheinen auch hier.

### API-Schlüssel

1. Nutze die Bridge `mcp-remote`, die den Schlüssel auf diesem Rechner behält (ein auf claude.ai angelegter Connector mit dem Schlüssel unter **Request headers** erscheint hier ebenfalls). Öffne **Settings → Developer → Edit Config** und füge hinzu:

`claude_desktop_config.json`:

```
{
  "mcpServers": {
    "example": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.example.com/mcp",
        "--header",
        "Authorization: Bearer <YOUR_API_KEY>"
      ]
    }
  }
}
```

2. Ersetze den Platzhalter durch deinen Schlüssel und starte Claude Desktop neu.

Die Bridge braucht Node.js auf deinem Rechner.

### Lokal

1. Öffne **Settings → Developer → Edit Config**. Das öffnet `claude_desktop_config.json`. Füge hinzu:

`claude_desktop_config.json`:

```
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}
```

2. Speichere die Datei und starte Claude Desktop neu.

Braucht Node.js auf deinem Rechner. Die Datei liegt unter macOS in `~/Library/Application Support/Claude/` und unter Windows in `%APPDATA%\Claude\`.

## ChatGPT

ChatGPT verbindet sich mit Remote-Servern, die du unter Plugins hinzufügst. Wie claude.ai kann es keine lokalen Server starten und keinen API-Schlüssel-Header senden.

### Ohne Anmeldung

1. Geh auf chatgpt.com zu **Plugins**, wähle **+** und dann **Add custom MCP server**.
2. Gib einen Namen für den Server ein.
3. Füge unter **Connection** `https://mcp.deepwiki.com/mcp` als Server-URL ein und wähle als Authentifizierung **No authentication**.
4. Setz den Haken bei **I understand and want to continue** und wähle dann **Create as a plugin**.

Ob du einen eigenen MCP-Server hinzufügen kannst, hängt von deinem ChatGPT-Tarif und den Berechtigungen deines Workspace ab (in Business-Workspaces können es Admins und Owner).

### Anmeldung

1. Geh auf chatgpt.com zu **Plugins**, wähle **+** und dann **Add custom MCP server**.
2. Gib einen Namen für den Server ein.
3. Füge unter **Connection** `https://mcp.notion.com/mcp` als Server-URL ein und wähle als Authentifizierung **OAuth**. ChatGPT schickt dich zur Anmeldung zu Notion.
4. Setz den Haken bei **I understand and want to continue** und wähle dann **Create as a plugin**.

Ob du einen eigenen MCP-Server hinzufügen kannst, hängt von deinem ChatGPT-Tarif und den Berechtigungen deines Workspace ab (in Business-Workspaces können es Admins und Owner).

## Cursor

**Zu Cursor hinzufügen** öffnet die Installationsseite von Cursor mit dem Server schon ausgefüllt. Du kannst ihn auch von Hand in `mcp.json` eintragen.

### Ohne Anmeldung

[Zu Cursor hinzufügen](https://cursor.com/install-mcp?name=deepwiki&config=eyJ1cmwiOiJodHRwczovL21jcC5kZWVwd2lraS5jb20vbWNwIn0%3D)

Oder trag ihn von Hand in `~/.cursor/mcp.json` (alle Projekte) oder `.cursor/mcp.json` (dieses Projekt) ein:

`mcp.json`:

```
{
  "mcpServers": {
    "deepwiki": {
      "url": "https://mcp.deepwiki.com/mcp"
    }
  }
}
```

### Anmeldung

[Zu Cursor hinzufügen](https://cursor.com/install-mcp?name=notion&config=eyJ1cmwiOiJodHRwczovL21jcC5ub3Rpb24uY29tL21jcCJ9)

Oder trag ihn von Hand in `~/.cursor/mcp.json` (alle Projekte) oder `.cursor/mcp.json` (dieses Projekt) ein:

`mcp.json`:

```
{
  "mcpServers": {
    "notion": {
      "url": "https://mcp.notion.com/mcp"
    }
  }
}
```

Cursor zeigt neben dem Server **Needs authentication**. Klick auf die Schaltfläche daneben, um dich anzumelden.

### API-Schlüssel

[Zu Cursor hinzufügen](https://cursor.com/install-mcp?name=example&config=eyJ1cmwiOiJodHRwczovL21jcC5leGFtcGxlLmNvbS9tY3AiLCJoZWFkZXJzIjp7IkF1dGhvcml6YXRpb24iOiJCZWFyZXIgPFlPVVJfQVBJX0tFWT4ifX0%3D)

Oder trag ihn von Hand in `~/.cursor/mcp.json` (alle Projekte) oder `.cursor/mcp.json` (dieses Projekt) ein:

`mcp.json`:

```
{
  "mcpServers": {
    "example": {
      "url": "https://mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_KEY>"
      }
    }
  }
}
```

### Lokal

[Zu Cursor hinzufügen](https://cursor.com/install-mcp?name=memory&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIkBtb2RlbGNvbnRleHRwcm90b2NvbC9zZXJ2ZXItbWVtb3J5Il19)

Oder trag ihn von Hand in `~/.cursor/mcp.json` (alle Projekte) oder `.cursor/mcp.json` (dieses Projekt) ein:

`mcp.json`:

```
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}
```

Braucht Node.js auf deinem Rechner.

## VS Code

**Zu VS Code hinzufügen** öffnet den Installationsdialog von VS Code. Du kannst auch `code --add-mcp` ausführen oder `.vscode/mcp.json` committen, damit alle, die am Projekt arbeiten, den Server haben.

### Ohne Anmeldung

[In VS Code installieren](https://vscode.dev/redirect/mcp/install?name=deepwiki&config=%7B%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fmcp.deepwiki.com%2Fmcp%22%7D)

Oder aus einem Terminal:

```
code --add-mcp '{"name":"deepwiki","type":"http","url":"https://mcp.deepwiki.com/mcp"}'
```

Oder committe ihn ins Repository in `.vscode/mcp.json`:

`.vscode/mcp.json`:

```
{
  "servers": {
    "deepwiki": {
      "type": "http",
      "url": "https://mcp.deepwiki.com/mcp"
    }
  }
}
```

### Anmeldung

[In VS Code installieren](https://vscode.dev/redirect/mcp/install?name=notion&config=%7B%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fmcp.notion.com%2Fmcp%22%7D)

Oder aus einem Terminal:

```
code --add-mcp '{"name":"notion","type":"http","url":"https://mcp.notion.com/mcp"}'
```

Oder committe ihn ins Repository in `.vscode/mcp.json`:

`.vscode/mcp.json`:

```
{
  "servers": {
    "notion": {
      "type": "http",
      "url": "https://mcp.notion.com/mcp"
    }
  }
}
```

VS Code bittet dich beim ersten Start des Servers um eine Anmeldung.

### API-Schlüssel

Füge ihn zu `.vscode/mcp.json` hinzu. VS Code fragt beim ersten Mal nach dem Schlüssel und speichert ihn sicher:

`.vscode/mcp.json`:

```
{
  "servers": {
    "example": {
      "type": "http",
      "url": "https://mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer ${input:api-key}"
      }
    }
  },
  "inputs": [
    {
      "type": "promptString",
      "id": "api-key",
      "description": "API key",
      "password": true
    }
  ]
}
```

### Lokal

[In VS Code installieren](https://vscode.dev/redirect/mcp/install?name=memory&config=%7B%22type%22%3A%22stdio%22%2C%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40modelcontextprotocol%2Fserver-memory%22%5D%7D)

Oder aus einem Terminal:

```
code --add-mcp '{"name":"memory","type":"stdio","command":"npx","args":["-y","@modelcontextprotocol/server-memory"]}'
```

Oder committe ihn ins Repository in `.vscode/mcp.json`:

`.vscode/mcp.json`:

```
{
  "servers": {
    "memory": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}
```

Braucht Node.js auf deinem Rechner.

## Andere Clients

### Devin Desktop (früher Windsurf)

### Ohne Anmeldung

1. Füge ihn zu `~/.config/devin/mcp_config.json` (macOS und Linux) oder `%APPDATA%\devin\mcp_config.json` (Windows) hinzu:

`mcp_config.json`:

```
{
  "mcpServers": {
    "deepwiki": {
      "serverUrl": "https://mcp.deepwiki.com/mcp"
    }
  }
}
```

2. Aktualisiere die Liste der MCP-Server in Cascade.

Devin Desktop ist der neue Name von Windsurf. Für Remote-Server liest es `serverUrl` (oder `url`).

### Anmeldung

1. Füge ihn zu `~/.config/devin/mcp_config.json` (macOS und Linux) oder `%APPDATA%\devin\mcp_config.json` (Windows) hinzu:

`mcp_config.json`:

```
{
  "mcpServers": {
    "notion": {
      "serverUrl": "https://mcp.notion.com/mcp"
    }
  }
}
```

2. Aktualisiere die Liste der MCP-Server in Cascade und melde dich an, wenn du gefragt wirst.

Devin Desktop ist der neue Name von Windsurf. Für Remote-Server liest es `serverUrl` (oder `url`).

### API-Schlüssel

1. Füge ihn zu `~/.config/devin/mcp_config.json` (macOS und Linux) oder `%APPDATA%\devin\mcp_config.json` (Windows) hinzu:

`mcp_config.json`:

```
{
  "mcpServers": {
    "example": {
      "serverUrl": "https://mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_KEY>"
      }
    }
  }
}
```

2. Aktualisiere die Liste der MCP-Server in Cascade.

Devin Desktop ist der neue Name von Windsurf. Für Remote-Server liest es `serverUrl` (oder `url`).

### Lokal

1. Füge ihn zu `~/.config/devin/mcp_config.json` (macOS und Linux) oder `%APPDATA%\devin\mcp_config.json` (Windows) hinzu:

`mcp_config.json`:

```
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}
```

2. Aktualisiere die Liste der MCP-Server in Cascade.

Devin Desktop ist der neue Name von Windsurf.

### Codex

### Ohne Anmeldung

```
codex mcp add deepwiki --url https://mcp.deepwiki.com/mcp
```

Oder bearbeite `~/.codex/config.toml` direkt:

`config.toml`:

```
[mcp_servers.deepwiki]
url = "https://mcp.deepwiki.com/mcp"
```

### Anmeldung

```
codex mcp add notion --url https://mcp.notion.com/mcp
codex mcp login notion
```

Oder bearbeite `~/.codex/config.toml` direkt:

`config.toml`:

```
[mcp_servers.notion]
url = "https://mcp.notion.com/mcp"
```

### API-Schlüssel

```
codex mcp add example --url https://mcp.example.com/mcp --bearer-token-env-var EXAMPLE_API_KEY
```

Oder bearbeite `~/.codex/config.toml` direkt:

`config.toml`:

```
[mcp_servers.example]
url = "https://mcp.example.com/mcp"
bearer_token_env_var = "EXAMPLE_API_KEY"
```

Setze `EXAMPLE_API_KEY` in der Shell, in der Codex läuft, auf deinen Schlüssel.

### Lokal

```
codex mcp add memory -- npx -y @modelcontextprotocol/server-memory
```

Oder bearbeite `~/.codex/config.toml` direkt:

`config.toml`:

```
[mcp_servers.memory]
command = "npx"
args = ["-y", "@modelcontextprotocol/server-memory"]
```

Braucht Node.js auf deinem Rechner.

### Gemini CLI

### Ohne Anmeldung

```
gemini mcp add --transport http deepwiki https://mcp.deepwiki.com/mcp
```

Damit fügst du ihn dem aktuellen Projekt hinzu. Ergänze `-s user`, um ihn überall zu nutzen.

### Anmeldung

```
gemini mcp add --transport http notion https://mcp.notion.com/mcp
```

Führe dann in Gemini CLI `/mcp auth notion` aus, um dich anzumelden.

Damit fügst du ihn dem aktuellen Projekt hinzu. Ergänze `-s user`, um ihn überall zu nutzen.

### API-Schlüssel

```
gemini mcp add --transport http --header "Authorization: Bearer <YOUR_API_KEY>" example https://mcp.example.com/mcp
```

Damit fügst du ihn dem aktuellen Projekt hinzu. Ergänze `-s user`, um ihn überall zu nutzen.

### Lokal

```
gemini mcp add memory npx -- -y @modelcontextprotocol/server-memory
```

Damit fügst du ihn dem aktuellen Projekt hinzu. Ergänze `-s user`, um ihn überall zu nutzen.

### Jeder andere Client

### Ohne Anmeldung

Die meisten Clients akzeptieren diese Form. Manche nennen das URL-Feld anders: `serverUrl` in Devin Desktop, `httpUrl` in der Einstellungsdatei von Gemini CLI.

```
{
  "mcpServers": {
    "deepwiki": {
      "type": "http",
      "url": "https://mcp.deepwiki.com/mcp"
    }
  }
}
```

Zed legt Server in seinen Einstellungen unter `context_servers` ab. Cline braucht `"type": "streamableHttp"`, sonst nimmt es SSE an.

Dein Client startet nur lokale Server? Dann binde den Server über `npx -y mcp-remote https://mcp.deepwiki.com/mcp` ein.

### Anmeldung

Die meisten Clients akzeptieren diese Form. Manche nennen das URL-Feld anders: `serverUrl` in Devin Desktop, `httpUrl` in der Einstellungsdatei von Gemini CLI.

```
{
  "mcpServers": {
    "notion": {
      "type": "http",
      "url": "https://mcp.notion.com/mcp"
    }
  }
}
```

Zed legt Server in seinen Einstellungen unter `context_servers` ab. Cline braucht `"type": "streamableHttp"`, sonst nimmt es SSE an.

Dein Client startet nur lokale Server? Dann binde den Server über `npx -y mcp-remote https://mcp.notion.com/mcp` ein.

### API-Schlüssel

Die meisten Clients akzeptieren diese Form. Manche nennen das URL-Feld anders: `serverUrl` in Devin Desktop, `httpUrl` in der Einstellungsdatei von Gemini CLI.

```
{
  "mcpServers": {
    "example": {
      "type": "http",
      "url": "https://mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_KEY>"
      }
    }
  }
}
```

Zed legt Server in seinen Einstellungen unter `context_servers` ab. Cline braucht `"type": "streamableHttp"`, sonst nimmt es SSE an.

Dein Client startet nur lokale Server? Dann binde den Server über `npx -y mcp-remote https://mcp.example.com/mcp` ein.

### Lokal

Die meisten Clients, die lokale Server starten, akzeptieren diese Form:

```
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}
```

Zed legt Server in seinen Einstellungen unter `context_servers` ab, mit denselben Feldern `command`, `args` und `env`.

Braucht Node.js auf deinem Rechner.

## Anmeldung, API-Schlüssel und lokale Server

### Anmeldung (OAuth)

Wenn sich dein Client zum ersten Mal verbindet, fragt der Server, wer du bist. Dein Client öffnet die Anmeldeseite des Anbieters im Browser, du erlaubst dort den Zugriff, und der Client behält das Token. In Claude Code geschieht das über `/mcp` und **Authenticate**, in Cursor über **Needs authentication** in den MCP-Einstellungen, in Codex mit `codex mcp login` und in Gemini CLI mit `/mcp auth`.

Das Token wird für die eigene URL des Servers ausgestellt, und dein Client sendet es nur dorthin: Die MCP-Anmeldung bindet jedes Token an einen einzigen Server (OAuth Resource Indicators, RFC 8707). Das ist ein Grund, warum jede Einrichtung auf mcp.tc die eigene URL des Servers nutzt, und warum mcp.tc deine Zugangsdaten nie sieht.

### API-Schlüssel

Hol dir einen Schlüssel beim Anbieter. Die Snippets setzen einen Platzhalter wie `<YOUR_API_KEY>` in den Header, den der Server erwartet, meist `Authorization: Bearer <YOUR_API_KEY>`. Ersetze ihn in deiner eigenen Konfiguration und halte diese Datei aus geteilten Repositories heraus. VS Code fragt beim ersten Mal nach dem Schlüssel und speichert ihn sicher, und Codex liest ihn aus einer Umgebungsvariablen. Auf claude.ai und in Claude Desktop trägst du den Schlüssel unter **Request headers** ein, wenn du den benutzerdefinierten Connector anlegst. ChatGPT kann keinen Schlüssel-Header senden.

Manche Server funktionieren ohne Schlüssel und nehmen einen für mehr Zugriff an. Ihr Badge sagt **Anmeldung optional**, ihre Befehle lassen den Schlüssel weg, und der Hinweis unter den Schritten nennt den Header, in dem du ihn senden kannst.

### Lokale Server

Dein Client startet einen lokalen Server als Programm auf deinem Rechner, mit dem Installationsbefehl von seiner Seite. Der Befehl bestimmt, was du installiert haben musst:

- `npx` braucht Node.js.
- `uvx` braucht uv (Python).
- `pipx` braucht pipx (Python).
- `docker` braucht Docker.
- `dnx` braucht .NET 10.

Ein lokaler Server läuft mit den Rechten deines Benutzerkontos, lies also seine Tool-Liste, bevor du ihn hinzufügst. Einstellungen, die er braucht, Schlüssel eingeschlossen, sind Umgebungsvariablen, und die Snippets zeigen sie als Platzhalter. claude.ai und ChatGPT verbinden sich nur mit Remote-Servern und können lokale daher nicht nutzen.

### Anmeldung unbestätigt

Ein grauer Ring und **Anmeldung unbestätigt** bedeuten, dass unsere Prüfung nicht klären konnte, ob der Server eine Anmeldung braucht. Die Schritte nutzen die einfache URL. Fragt der Server nach Zugangsdaten, sagt die Doku des Anbieters, welche.

## Was ein mcp.tc-Link in einem Client tut

Der mcp.tc-Link ist die Seite des Eintrags, keine Server-Adresse. Ein Browser bekommt die Seite. Ein MCP-Client, der sich damit verbindet, bekommt stattdessen einen Fehler: HTTP 409 mit einer JSON-RPC-Nachricht, die die eigene URL des Servers (bei einem lokalen Server seinen Installationsbefehl) und die Seite nennt. Manche Clients zeigen die Nachricht an, sodass du die richtige Adresse daraus kopieren kannst; Claude Code meldet nur „Failed to connect“. Das ist die Antwort, die ein Client unter `mcp.tc/i/deepwiki` bekommt (die Nachricht ist immer auf Englisch, der Sprache, die Clients erwarten):

`HTTP 409, application/json`:

```
{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32001,
    "message": "mcp.tc: this link is a page, not an MCP endpoint. Connect to DeepWiki directly with its own URL: https://mcp.deepwiki.com/mcp (no sign-in needed). Setup for each client: https://mcp.tc/i/deepwiki",
    "data": {
      "listing": "https://mcp.tc/i/deepwiki",
      "endpoint": "https://mcp.deepwiki.com/mcp"
    }
  }
}
```

`data.endpoint` enthält die eigene URL des Servers, `data.command` den Installationsbefehl eines lokalen Servers und `data.listing` die Seite. Ein nicht gelisteter Link antwortet mit 404, ein entfernter Eintrag mit 410.

Warum schickt der Link deinen Client nicht zum Server weiter oder reicht die Anfragen durch? Aktuelle MCP-SDKs (TypeScript ab 1.32, Python ab 1.30) lassen sich nicht auf eine andere Website weiterleiten, und ein Anmelde-Token funktioniert ohnehin nur unter der eigenen URL des Servers. Anfragen durchzureichen würde deinen Client außerdem von mcp.tc abhängig machen, daher ist jeder mcp.tc-Link nur eine Seite.

## Fehlerbehebung

### Mein Client meldet „this link is a page, not an MCP endpoint“

Du hast den mcp.tc-Link hinzugefügt. Ersetze ihn durch die URL aus dieser Meldung, oder kopiere die URL aus dem Kasten oben im Eintrag. Bei einem lokalen Server nimm stattdessen den Installationsbefehl.

### Der Server verbindet sich nicht

Beginnt die hinzugefügte URL mit `https://mcp.tc/i/`, ist das der Link zur Seite: Ersetze ihn durch die eigene URL des Servers aus dem Eintrag. Prüfe sonst, ob die URL genau der im Eintrag entspricht, Pfad eingeschlossen: `https://mcp.deepwiki.com/mcp` und `https://mcp.deepwiki.com` sind verschiedene Adressen. Starte den Client neu, nachdem du eine Konfigurationsdatei bearbeitet hast. Ein Badge **Letzte Prüfung fehlgeschlagen** am Eintrag bedeutet, dass auch unsere täglichen Prüfungen scheitern, das Problem liegt also vielleicht beim Anbieter.

### Der Server fragt ständig nach einer Anmeldung oder antwortet mit 401

Der Server braucht eine Anmeldung, und dein Client hat sie nicht abgeschlossen. Tippe in Claude Code `/mcp`, wähle den Server und dann **Authenticate**. Öffne in Cursor die MCP-Einstellungen und nutze die Schaltfläche neben **Needs authentication**. Führe in Codex `codex mcp login` mit dem Namen des Servers aus, in Gemini CLI `/mcp auth`. Prüfe bei einem API-Schlüssel, ob du den Platzhalter ersetzt hast und der Header zur Doku des Anbieters passt.

### Ein lokaler Server startet nicht

Führe zuerst seinen Installationsbefehl in einem Terminal aus. Scheitert er dort, kann ihn auch der Client nicht starten, und meist fehlt die Laufzeitumgebung: Node.js für `npx`, uv für `uvx`, Docker für `docker`. Ersetze jeden Platzhalter, etwa `<YOUR_API_KEY>` oder `/path/to/allowed/dir`, durch einen echten Wert.

### Mein Client startet nur lokale Server

Binde den Remote-Server mit `npx -y mcp-remote` gefolgt von der eigenen URL des Servers an. Die Bridge läuft auf deinem Rechner und braucht Node.js.

### Im Eintrag steht SSE

Der Server nutzt den älteren SSE-Transport, den manche Clients nicht mehr unterstützen. Claude Code nimmt `--transport sse`, VS Code `"type": "sse"`, und Codex braucht die Bridge `mcp-remote`. Die Einrichtungsschritte des Eintrags nutzen schon das Richtige.

### Die Tools eines Servers haben sich geändert, nachdem ich ihn hinzugefügt habe

Öffne seinen Eintrag und sieh dir den Tab **Verlauf** an. Wenn wir die Tools des Servers lesen können, listet er die seit unserem ersten Abruf hinzugefügten, entfernten oder geänderten Tools auf, mit jeder Beschreibung vorher und nachher. Dein Client nutzt vielleicht noch die Liste, die du früher bestätigt hast, also vergleiche sie mit dem, was er jetzt zeigt. Um bei der nächsten Änderung eine E-Mail zu bekommen, melde dich an und klicke im Eintrag auf **Folgen**.

### Im Eintrag stimmt etwas nicht

Nutze **Eintrag melden** auf seiner Seite. Der Text wird mit KI-Hilfe aus den eigenen Metadaten des Servers geschrieben, Fehler kommen also vor, und ein Mensch liest jede Meldung.

---
Quelle: https://mcp.tc/de/docs/connect. Markdown-Version für KI-Agenten (frag nach `text/markdown` oder häng `.md` an die Adresse an). Überblick über die Website: https://mcp.tc/llms.txt
