> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/de/grundlagen/mcp.md).

# Wie man MCP-Server mit lokalen LLMs verwendet

Erfahren Sie mit Screenshots, wie Sie MCP-Server mit offenen KI-Modellen verbinden.

Diese Schritt-für-Schritt-Anleitung zeigt dir, wie man verbindet **Model Context Protocol (MCP)** Server mit lokalen LLMs wie [Qwen](/docs/de/modelle/qwen3.6.md) oder [Gemma](/docs/de/modelle/gemma-4.md), sodass jedes Modell, das du ausführst, über MCP externe Tools und Dienste aufrufen kann. Die Verbindung von MCP mit einem lokalen Modell ermöglicht es ihm, sicher deine lokalen Dateien, Apps, Datenbanken und Tools zu verwenden, statt nur aus dem Gedächtnis zu chatten, um einen nützlicheren, privateren und austauschbaren KI-Assistenten zu bauen, der in deiner realen Umgebung handeln kann.

Wir verwenden die Open-Source-Repos [Unsloth](https://github.com/unslothai/unsloth) und [llama.cpp](#llama.cpp-guide) da sie beliebte Frameworks für lokale Modell-Inferenz/-Bereitstellung sind. MCP funktioniert für lokale GGUF-Modelle und Cloud- [Anbieter-Modelle](/docs/de/integrationen/connections.md). **Wir zeigen auch, wie** [**mehrere MCP-Server**](#using-multiple-mcp-servers) **genutzt werden können.**

MCP-Tools arbeiten neben anderen Modellfähigkeiten wie [Codeausführung](/docs/de/neu/studio/chat.md#code-execution) und [Websuche](/docs/de/neu/studio/chat.md#advanced-web-search), sodass ein einzelnes Modell im selben Thread das Web durchsuchen, Code ausführen und deine verbundenen Dienste aufrufen kann.

### Anwendungsfälle

Sobald ein MCP-Server verbunden ist, kannst du dein lokales Modell bitten, viele automatisierte Aufgaben zu erledigen. Einige Beispiele:

* **Docs durchsuchen:** „Finde die relevanten Docs und fasse die Einrichtungsschritte zusammen.“ - Context7 kann verwendet werden.
* **Eine Codebasis analysieren:** „Erstelle eine Karte dieses Repos und erkläre, wo Authentifizierung, Abrechnung und Datenzugriff stattfinden.“ - Der offizielle GitHub-MCP und GitMCP können verwendet werden, um Repos zu analysieren.
* **Das Web mit Embeddings durchsuchen** - Der MCP-Server von Exa kann für semantische Websuchen mit kontextueller Embedding-Unterstützung verwendet werden.
* **Web-UIs debuggen** - Die MCP-Server von Playwright und Chrome DevTools können verwendet werden, um Websites zu steuern und Fehlerbehebungen für Probleme zu finden.

### Schnellstart

Wir verwenden zwei Wege, um dein lokales Modell auf deinem Gerät mit MCP-Servern zu verbinden. Beide nutzen Open-Source-Pakete: [Unsloth](https://github.com/unslothai/unsloth) und [llama.cpp](llama.cpphttps://github.com/ggml-org/llama.cpp) um dein Modell auszuführen, bereitzustellen und zu deployen.

<a href="/docs/de/grundlagen/mcp.md#unsloth-guide" class="button primary">Unsloth MCP-Anleitung</a><a href="/pages/5e7bff3f8bf3f0aa817278939681700fe60de09c#llama.cpp-guide" class="button primary">Llama.cpp MCP-Anleitung</a>

### 🦥 Unsloth-Anleitung

In diesem Beispiel verwenden wir Unsloth, um jedes lokale Modell wie [Qwen3.6](/docs/de/modelle/qwen3.6.md) oder [Gemma 4](/docs/de/modelle/gemma-4.md) mit den MCP-Servern zu verbinden: [Vercel](https://mcp.vercel.com), [Context7](https://context7.com/), [Exa](https://exa.ai/) und [Hugging Face](https://huggingface.co/docs/hub/en/agents-mcp). Dann fragen wir ein Modell, was es damit tun kann. Die gleichen Schritte funktionieren für jeden MCP-Server.

{% stepper %}
{% step %}

#### Unsloth einrichten

Der einfachste Weg, loszulegen, ist die Installation der [Unsloth Desktop](/docs/de/desktop.md) App. Sie unterstützt [macOS](/docs/de/loslegen/install/mac.md), Linux, [Windows](/docs/de/loslegen/install/windows-installation.md), [NVIDIA](/docs/de/loslegen/install/pip-install.md), [AMD](/docs/de/loslegen/install/amd.md), Intel- und CPU-Setups.

<a href="https://unsloth.ai/download" class="button primary" data-icon="down-to-bracket">Unsloth herunterladen</a>

* <i class="fa-apple">:apple:</i> [Für macOS herunterladen](https://unsloth.ai/download/mac)
* <i class="fa-windows">:windows:</i> [Für Windows herunterladen](https://unsloth.ai/download/windows)
* <i class="fa-linux">:linux:</i> [Für Linux herunterladen](https://unsloth.ai/download/linux)

Oder, wenn du die manuelle Installation bevorzugst:

**macOS, Linux, WSL:**

```bash
curl -fsSL https://unsloth.ai/install.sh | sh
```

**Windows PowerShell:**

```bash
irm https://unsloth.ai/install.ps1 | iex
```

[Siehe hier](/docs/de/desktop.md#get-started) für detaillierte Anweisungen.
{% endstep %}

{% step %}

#### **MCP aktivieren**

Klicke in der Chat-Toolbar auf „MCP“.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FqNVeCtCvYRMqKT9sSZey%2Fimage.png?alt=media&amp;token=9755a1cc-8118-40ba-ba1f-3b9ac0ef773d" alt=""><figcaption></figcaption></figure>

Unsloth Studio hat standardmäßig MCP-Unterstützung für Context7, Exa und Hugging Face. Wenn du Exa einschaltest [Websuche](/docs/de/neu/studio/chat.md#advanced-web-search) wird das standardmäßige Suchwerkzeug deaktiviert, das wir haben.
{% endstep %}

{% step %}

#### **Benutzerdefinierte MCP-Server hinzufügen**

Um den Vercel-MCP-Server hinzuzufügen, klicke auf „Benutzerdefiniertes MCP hinzufügen“, und du erhältst ein Pop-up:

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FaO9zf15MX1jWL7nOmdyK%2Fimage.png?alt=media&amp;token=8ae977f0-8388-414c-9fbd-ae1efff464f2" alt=""><figcaption></figcaption></figure>

Fülle die Server-Details aus:

1. **Anzeigename**: eine freundliche Bezeichnung, z. B. `Vercel`.
2. **URL**: der Basis-Endpunkt des Servers, z. B. `https://mcp.vercel.com`.
3. Wähle unten eine Authentifizierungsmethode aus.

{% tabs %}
{% tab title="OAuth-Anmeldung" %}
Für Server, die browserbasierte Authentifizierung erfordern (GitHub, Linear, Vercel usw.), aktiviere **OAuth-Anmeldung verwenden**. Ein Browserfenster öffnet sich bei der ersten Verbindung, damit du Unsloth autorisieren kannst.
{% endtab %}

{% tab title="Benutzerdefinierter Header" %}
Für Server, die sich mit einem Token authentifizieren, lass OAuth deaktiviert und klicke auf **Header hinzufügen** unter **Benutzerdefinierte Header**. Füge einen `Authorization` Header mit deinem Token hinzu:

```
Authorization: Bearer <dein-token>
```

{% endtab %}
{% endtabs %}

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FbgCzTby2rF3qgleWLNXA%2Fmcp-server-added.png?alt=media&amp;token=8095e37e-a4fa-4857-a5aa-0562af526eca" alt="" width="563"><figcaption></figcaption></figure>
{% endstep %}

{% step %}

#### **Testen & hinzufügen**

Klicke **Verbindung testen** um zu bestätigen, dass Unsloth den Server erreichen kann. Sobald es erfolgreich ist, klicke auf **Server hinzufügen** um ihn zu speichern.

Wenn **Verbindung testen** es fehlschlägt, prüfe, dass die URL der Basis-Endpunkt des Servers ist (nicht eine Dokumentationsseite) und dass deine Authentifizierungsmethode korrekt ist. Siehe die Fehlerbehebung unten.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FJeR2x79EkJaG4jYuOiBt%2Fmcp-add-server.png?alt=media&amp;token=38c4fdee-130f-415b-8c5d-e906f13c1555" alt="" width="563"><figcaption></figcaption></figure>
{% endstep %}

{% step %}

#### **Geladene Tools überprüfen**

Der Server erscheint jetzt in der Liste der MCP-Server. Unsloth lädt seine Tools automatisch und zeigt eine Bestätigung an, z. B. *„Vercel“ aktualisiert (18 Tools)*.

Jeder Server hat Steuerelemente zum **umschalten** ihn ein- oder auszuschalten, **aktualisieren,** seine Tools, **bearbeiten,** ihn oder **löschen** ihn. Stelle sicher, dass sowohl der Schalter des Servers als auch der **MCP-Server verwenden** Hauptschalter aktiviert sind, und schließe dann den Dialog.

Wenn aktiviert, wird es hervorgehoben. Du kannst sie auch deaktivieren, indem du einfach erneut darauf klickst.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FgunafFRR6EdrF0xXjIuG%2Fimage.png?alt=media&amp;token=3a91e79f-33d0-44da-a7a3-ded37a34b594" alt=""><figcaption></figcaption></figure>
{% endstep %}

{% step %}

#### **Im Chat verwenden**

Wähle ein beliebiges Modell aus dem **Modell auswählen** Dropdown-Menü aus und beginne zu chatten. Das Modell kann jetzt die Tools des Servers selbst aufrufen, wenn deine Anfrage es erfordert.

Oben wurde ein lokales `gemma-4-E2B-it-GGUF` gefragt *„Kannst du den Vercel-MCP-Server verwenden?“* und meldete die Aktionen, die es ausführen kann: Projekte verwalten, Protokolle analysieren, Teams auflisten, Zugriffslinks generieren, Domains prüfen und in Vercels Dokumentation suchen.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FoenMZ3aZx2yUX9ueAbmy%2Fmcp-chat-usecase.png?alt=media&amp;token=4284a8da-e77f-4961-8154-742cd75e4b01" alt=""><figcaption></figcaption></figure>
{% endstep %}
{% endstepper %}

#### Mehrere MCP-Server verwenden

Wie wäre es, mehrere MCP-Server wie 3 aufzurufen? Wir verwenden die von Unsloth Studio standardmäßig bereitgestellten MCP-Server Exa, Context7 und Hugging Face und aktivieren alle 3.

Wenn du fragst: „Kann Unsloth Qwen-Finetuning unterstützen?“, liefert Exa dazu großartige Details:

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FbqfXsWpuNJksyX2cLgfz%2Fimage.png?alt=media&amp;token=9f66e3e9-0e78-4016-853d-a7a8b63c4d25" alt=""><figcaption></figcaption></figure>

Dann als Folgefrage: „Durchsuche die Unsloth-Dokumentation, wie man das macht“, und Context7 wird für die Docs verwendet:

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FrPFQ90O4o8SIydVhDndx%2Fimage.png?alt=media&amp;token=35a48ee5-974b-45de-aba9-e9fb1e7833dd" alt=""><figcaption></figcaption></figure>

Dann gib ein: „Durchsuche Hugging Face nach unsloth/Qwen-Modellen“, und der MCP-Server von Hugging Face wird aufgerufen:

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2F9KPBtO3VFxC6Y9e4Hl0d%2Fimage.png?alt=media&amp;token=1c1757dc-4ccb-424f-b98b-29ae173df757" alt=""><figcaption></figcaption></figure>

#### Ein weiteres spezifisches Anwendungsbeispiel

Sobald ein Server verbunden ist, bitte das Modell in einfacher Sprache, echte Arbeit zu erledigen. Einige Beispiele mit dem Vercel-Server:

* **Einen fehlerhaften Build debuggen**: *„Rufe die Build-Logs meiner neuesten Bereitstellung ab und sag mir, warum sie fehlgeschlagen ist.“*
* **Bereitstellungsstatus prüfen**: *„Liste meine neuesten Bereitstellungen und ihren Status auf.“*
* **Die Docs durchsuchen**: *„Durchsuche die Vercel-Dokumentation, wie man eine benutzerdefinierte Domain einrichtet.“*
* **Domain-Recherche**: *„Ist `myproject.dev` verfügbar, und wie viel würde sie kosten?“*

### 🦙 Llama.cpp-Anleitung

{% stepper %}
{% step %}

#### llama.cpp installieren oder bauen

**macOS:**

```bash
brew install llama.cpp
```

Oder für **Linux, Windows, WSL** aus den Quellen bauen:

```bash
git clone https://github.com/ggml-org/llama.cpp
cmake -S llama.cpp -B llama.cpp/build -DCMAKE_BUILD_TYPE=Release
cmake --build llama.cpp/build --config Release -j --target llama-server llama-cli
```

{% endstep %}

{% step %}

#### Starte llama-server mit einem GGUF

Wir verwenden [Gemma 4](/docs/de/modelle/gemma-4.md) E4B GGUF in diesem Beispiel:

```bash
llama-server \\
  -hf unsloth/gemma-4-E4B-it-GGUF:UD-Q4_K_XL \\
  --alias local \\
  --host 127.0.0.1 \\
  --port 8080 \\
  --no-ui \\
  --temp 1.0 \\
  --top-p 0.95 \\
  --top-k 64 \\
  --reasoning off
```

Für das größere Gemma-4-26B-A4B-Modell:

```bash
llama-server \\
  -hf unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_M \\
  --alias local \\
  --host 127.0.0.1 \\
  --port 8080 \\
  --no-ui \\
  --temp 1.0 \\
  --top-p 0.95 \\
  --top-k 64 \\
  --reasoning off
```

Weitere Anpassungen der Inferenzparameter findest du in unserer [Gemma-4-Anleitung](/docs/de/modelle/gemma-4.md).

Du kannst den Server testen:

```bash
curl http://127.0.0.1:8080/v1/chat/completions \\
  -H "Content-Type: application/json" \\
  -H "Authorization: Bearer none" \\
  -d '{
    "model": "local",
    "messages": [{"role": "user", "content": "Sag in einem Satz Hallo."}]
  }'
```

{% endstep %}

{% step %}

#### Erstelle eine MCP-Dateisystem-Sandbox

```bash
mkdir -p ~/mcp-workspace
cd ~/mcp-workspace
pwd
```

Kopiere den absoluten Pfad. Erstelle einen separaten Projektordner für deinen MCP-Host:

```bash
mkdir -p ~/llama-mcp
cd ~/llama-mcp
```

Erstelle `server_config.json`:

{% code expandable="true" %}

```json
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/ABSOLUTE/PATH/TO/mcp-workspace"
      ],
      "env": {}
    }
  }
}
```

{% endcode %}

Ersetze den Pfad durch deinen tatsächlichen Workspace-Pfad. IBMs `mcp-cli` Doku verwenden dieselbe `server_config.json` Form und dieselbe `npx -y @modelcontextprotocol/server-filesystem /path/to/allowed/files` Dateisystemkonfiguration.
{% endstep %}

{% step %}

#### Führe einen terminalbasierten MCP-Host gegen llama.cpp aus

Verwende IBMs `mcp-cli`; es ist ein MCP-Client/Host für die Kommandozeile mit Chat-Modus, Tool-Erkennung und Unterstützung für benutzerdefinierte OpenAI-kompatible Provider. Seine Doku empfiehlt `uvx mcp-cli --help`, Projektunterstützung `server_config.json`, und unterstützt zur Laufzeit benutzerdefinierte OpenAI-kompatible Provider über `--api-base` und `--api-key`.

`mcp-cli` benötigt zum Starten eine Konfigurationsdatei. Daher ist es notwendig, einen Schritt hinzuzufügen, um sie zu erstellen. Zum Beispiel:

{% code title="" expandable="true" %}

```bash
mkdir -p ~/.chuk_llm
cat > ~/.chuk_llm/config.yaml <<'YAML'
openai_compatible:
  client_class: "chuk_llm.llm.providers.openai_client:OpenAILLMClient"
  default_model: "local"
  models: ["*"]
YAML
```

{% endcode %}

Dann ausführen:

```bash
uvx mcp-cli \\
  --provider llamacpp \\
  --api-base http://127.0.0.1:8080/v1 \\
  --api-key none \\
  --model local \\
  --server filesystem \\
  --config-file server_config.json
```

Dann versuche:

```
Liste die Dateien im Dateisystem-Workspace auf.
```

Dann:

```
Erstelle hello.txt mit einer einzeiligen Begrüßung und lies sie dann wieder aus.
```

`mcp-cli` hat standardmäßig die Bestätigung für Tool-Aufrufe aktiviert, sodass du vor der Ausführung von Tools Eingabeaufforderungen sehen solltest.

**Vollständiges Codebeispiel:**

{% code expandable="true" %}

```bash
# Terminal 1
llama-server -hf unsloth/gemma-4-E4B-it-GGUF:UD-Q4_K_XL \\
  --alias local --host 127.0.0.1 --port 8080 --no-ui \\
  --temp 1.0 --top-p 0.95 --top-k 64 \\
  --chat-template-kwargs '{"enable_thinking":false}'

# Terminal 2, im Ordner mit server_config.json
uvx mcp-cli \\
  --provider llamacpp \\
  --api-base http://127.0.0.1:8080/v1 \\
  --api-key none \\
  --model local \\
  --server filesystem \\
  --config-file server_config.json
```

{% endcode %}
{% endstep %}
{% endstepper %}

### Lokale MCP-Server mit Remote-Zugriff oder LAN-Zugriff

Außer `http(s)://` URLs akzeptiert das **Feld URL oder ausführbare Datei** auch einen lokalen Befehl wie `npx`, `uvx` oder den Pfad zu einer Server-Binärdatei, mit ihren Argumenten in den **Arguments** Zeilen. Diese lokalen (stdio-)Server laufen als Programm auf deinem Computer.

Während **Remote-Zugriff** oder **LAN-Zugriff** in den Einstellungen aktiviert ist (oder Unsloth mit `--secure`gestartet wurde), ist Unsloth von anderen Geräten aus erreichbar, sodass lokale Befehle deaktiviert sind und beim Speichern eines solchen Folgendes angezeigt wird:

{% code collapsedlinecount="10" %}

```
Lokale Befehle sind deaktiviert, während Remote Access aktiviert ist, weil der Server von außerhalb dieses Geräts erreichbar ist.
```

{% endcode %}

Du kannst lokale MCP-Server trotzdem auf zwei Arten verwenden:

1. **Führe den Server auf deinem eigenen Rechner über HTTP aus (empfohlen).** Viele MCP-Server können selbst HTTP bereitstellen. Starte ihn so gebunden, dass `127.0.0.1` nur dieser Computer darauf zugreifen kann, und füge dann seine Adresse als URL hinzu. Zum Beispiel für [osmmcp](https://github.com/nervsystems/osmmcp):

   <pre class="language-bash" data-collapsed-line-count="10"><code class="lang-bash">osmmcp --enable-http --http-only --http-addr 127.0.0.1:7082
   </code></pre>

   füge dann `http://127.0.0.1:7082/mcp` im MCP-Dialog hinzu. Das funktioniert in Unsloth Desktop und Studio mit aktiviertem Remote-Zugriff. Führe den MCP-Server auf dem Computer aus, auf dem Unsloth läuft, nicht auf dem Gerät, von dem aus du ihn aufrufst; bei [Docker](/docs/de/loslegen/install/docker.md), `127.0.0.1` ist das der Container selbst, also starte den Server im Container (`docker exec`). Für einen Server, der nur stdio spricht, leistet eine stdio-zu-HTTP-Brücke wie [mcp-proxy](https://github.com/sparfenyuk/mcp-proxy) dasselbe, z. B. `mcp-proxy --port=8099 uvx mcp-server-fetch`, dann füge `http://127.0.0.1:8099/mcp`.
2. **Lokale Befehle explizit erlauben (Studio).** Starte Studio mit selbst gesetzter Variable, und lokale Befehle bleiben aktiviert, während Remote-Zugriff oder LAN-Zugriff eingeschaltet ist:

   <pre class="language-bash" data-collapsed-line-count="10"><code class="lang-bash">UNSLOTH_STUDIO_ALLOW_STDIO_MCP=1 unsloth studio
   </code></pre>

   In Windows PowerShell: `$env:UNSLOTH_STUDIO_ALLOW_STDIO_MCP = "1"; unsloth studio`.

{% hint style="warning" %}
Mit Option 2 kann jeder, der sich über das Netzwerk bei deinem Studio anmeldet, über einen MCP-Server Programme auf deinem Computer ausführen. Verwende es nur mit einem starken Passwort in Netzwerken, denen du vertraust, und bevorzuge Option 1.
{% endhint %}

### Fehlerbehebung

Wenn sich ein Server nicht verbinden lässt oder seine Tools nicht erscheinen, prüfe, ob die URL der Basis-Endpunkt des Servers ist (z. B. `https://mcp.vercel.com`), nicht eine Doku- oder Dashboard-Seite. Bei OAuth-Servern schließe die Browser-Anmeldung ab, wenn sie geöffnet wird; bei tokenbasierten Servern prüfe den `Authorization` Header und dass der Token gültig ist.

Wenn das Speichern eines lokalen Befehls mit „Lokale Befehle sind deaktiviert, während Remote Access aktiviert ist“ fehlschlägt, siehe [Lokale MCP-Server mit Remote-Zugriff oder LAN-Zugriff](#local-mcp-servers-with-remote-access-or-lan-access).

Klicke **Aktualisieren** wenn nach dem Verbinden keine Tools angezeigt werden, und stelle sicher, dass sowohl der einzelne Server-Schalter als auch der **MCP-Server verwenden** Hauptschalter aktiviert sind.

### Sicherheitshinweise

Verbinde nur MCP-Server, denen du vertraust. Überprüfe die angeforderten Berechtigungen und lasse die menschliche Bestätigung für Aktionen aktiviert, die private Daten lesen, Bereitstellungen ändern, Domains kaufen oder Projekte bearbeiten. Sei besonders vorsichtig, wenn du MCP-Server mit Websuche oder anderen Tools kombinierst, da per Prompt injizierte Inhalte versuchen können, unerwünschte Tool-Aufrufe auszulösen.

### Beliebte MCP-Server

Hier ist eine Liste einiger beliebter und nützlicher MCP-Server, mit denen du dich verbinden kannst:

| MCP-Server                               | Am besten für                                   | Warum er nützlich ist                                                                                                                                                                                                                   |
| ---------------------------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **GitHub-MCP**                           | Repos, Issues, PRs, Code-Suche, Actions         | Offizieller GitHub-MCP mit Remote- und lokaler Einrichtung, der Repos, Issues, Pull Requests, Actions, Code-Sicherheit und mehr abdeckt. ([GitHub](https://github.com/github/github-mcp-server))                                        |
| **Context7**                             | Aktuelle Bibliotheksdokumentation und Beispiele | Lädt aktuelle, versionsspezifische Dokumente für Coding-Assistenten statt sich auf veraltete Trainingsdaten zu verlassen. Verwendet `https://mcp.context7.com/mcp`. ([GitHub](https://github.com/upstash/context7))                     |
| **Notion MCP**                           | Dokumente, Notizen, Aufgaben, Projektwissen     | Gut für Teams, die Notion für Spezifikationen, PRDs, Roadmaps oder Notizen verwenden. Der gehostete MCP kann Arbeitsbereichsinhalte lesen und schreiben. ([Notion-Entwickler](https://developers.notion.com/guides/mcp/overview))       |
| **Slack MCP**                            | Suche in Team-Unterhaltungen                    | Ermöglicht KI-Tools, Slack-Nachrichten, Kanäle, Dateien, Threads und Mitgliederinformationen abzufragen; Aktionen hängen von Berechtigungen ab. ([Slack](https://slack.com/help/articles/48855576908307-Guide-to-the-Slack-MCP-server)) |
| **Linear MCP**                           | Tickets, Projekte, Produkt-Workflows            | Offizieller Remote-MCP zum Finden, Erstellen und Aktualisieren von Linear-Tickets, Projekten, Kommentaren und zugehörigen Objekten. ([Linear](https://linear.app/changelog/2025-05-01-mcp))                                             |
| **Vercel MCP**                           | Deployments, Protokolle, Dokumente, Domains     | Nützlich für Frontend-/Web-Workflows: Deployments, Protokolle, Dokumente und Projektkontext prüfen. Prüfen Sie zuerst die Client-Kompatibilität. ([Vercel](https://vercel.com/docs/agent-resources/vercel-mcp?utm_source=chatgpt.com))  |
| **Sentry MCP**                           | Fehlerbehebung in der Produktion                | Hilft Agenten, Sentry-Issues, Traces, Fehler und Leistungsdaten in Human-in-the-Loop-Entwicklungsworkflows zu prüfen. ([GitHub](https://github.com/getsentry/sentry-mcp))                                                               |
| **MCP für Dateisystem / lokale Dateien** | Lokale Projektdateien                           | Nützlich für lokale LLM-Setups, normalerweise über `stdio`. Referenzserver sollten am besten als Beispiele oder Ausgangspunkte behandelt werden. ([GitHub](https://github.com/modelcontextprotocol/servers))                            |


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://unsloth.ai/docs/de/grundlagen/mcp.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.