> 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

Diese Schritt-für-Schritt-Anleitung zeigt dir, wie du verbindest **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, externe Tools und Dienste über MCP aufrufen kann. Das Verbinden von MCP mit einem lokalen Modell ermöglicht es ihm, sicher deine lokalen Dateien, Apps, Datenbanken und Tools zu nutzen, 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 Modellinferenz/-bereitstellung sind. MCP funktioniert mit lokalen GGUF-Modellen und Cloud [Provider-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 einziges 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. Ein paar Beispiele:

* **Dokumente durchsuchen:** „Finde die relevanten Dokumente und fasse die Einrichtungsschritte zusammen.“ – Context7 kann verwendet werden.
* **Eine Codebasis analysieren:** „Ermittle die Struktur dieses Repos und erkläre, wo Authentifizierung, Abrechnung und Datenzugriff stattfinden.“ – Das offizielle GitHub-MCP und GitMCP können verwendet werden, um Repos zu analysieren.
* **Das Web mit Embeddings durchsuchen** – Exas MCP-Server kann für semantische Websuchen mit Unterstützung für kontextuelle Embeddings 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="/pages/5e7bff3f8bf3f0aa817278939681700fe60de09c#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). Danach fragen wir ein Modell, was es damit tun kann. Dieselben Schritte funktionieren mit jedem MCP-Server.

{% stepper %}
{% step %}

#### Unsloth Studio einrichten

Nun müssen wir [Unsloth](/docs/de/neu/studio.md)installieren und einrichten, [Siehe hier](/docs/de/neu/studio/install.md) für detailliertere Anweisungen.

{% tabs %}
{% tab title="macOS" %}

#### Schritt 1: Unsloth einrichten

Starten Sie das `Terminal` auf dem Mac und installieren Sie dann Unsloth, indem Sie den folgenden Befehl eingeben.

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

Die Umgebung und die erforderlichen Pakete werden nun installiert. Geben Sie `Y` ein und drücken Sie Enter, wenn Sie aufgefordert werden fortzufahren. Nach Abschluss der Einrichtung ist der Server lokal auf Port verfügbar `8888`.

<figure><img src="/files/6337582368e5e994ddb66c8a622177d6c41fc7de" alt="" width="375"><figcaption></figcaption></figure>

{% hint style="info" %}
Falls Sie den App-Start während der Installation übersprungen haben, können Sie sie später mit `unsloth studio -p 8888`starten. Um Verbindungen von anderen Geräten in Ihrem Netzwerk zuzulassen, verwenden Sie `unsloth studio -H 0.0.0.0 -p 8888` .
{% endhint %}

#### Schritt 2: Unsloth starten

Öffnen Sie Ihren bevorzugten Browser und geben Sie `http://127.0.0.1:8888`  in das URL-Feld ein. Wenn Sie Unsloth zum ersten Mal installieren, werden Sie zur Passwort-Seite weitergeleitet, wo Sie ein neues Passwort erstellen müssen. Anschließend sollten Sie die Chat-Seite sehen, wie unten gezeigt.
{% endtab %}

{% tab title="Windows" %}

#### Schritt 1: Unsloth einrichten

Öffnen Sie das Startmenü, suchen Sie nach `PowerShell`und starten Sie es. Kopieren Sie den Installationsbefehl und geben Sie ihn ein:

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

die Installation wird automatisch beginnen. Nachdem die Installation abgeschlossen ist, fragt PowerShell, ob Sie Unsloth Studio starten möchte&#x6E;**.**

<figure><img src="/files/6337582368e5e994ddb66c8a622177d6c41fc7de" alt="" width="375"><figcaption></figcaption></figure>

Sie können es auch mit dem folgenden Befehl starten:

```bash
unsloth studio -H 0.0.0.0 -p 8888
```

{% hint style="info" %}
Wenn Sie möchten, dass Ihre Instanz für Clients außerhalb Ihres PCs/Computers erreichbar ist.\
Fügen Sie `-H 0.0.0.0` zum `unsloth studio` Befehl hinzu.
{% endhint %}

#### Schritt 2: Unsloth starten

Öffnen Sie `http://127.0.0.1:8888` in Ihrem Browser. Beim ersten Start erstellen Sie ein neues Passwort, um zur Chat-Seite fortzufahren. **Unsloth Studio** ist jetzt installiert und einsatzbereit.
{% endtab %}

{% tab title="Linux, WSL" %}

#### Schritt 1: Unsloth einrichten

{% tabs %}
{% tab title="Linux" %}
Öffnen Sie Ihre Terminal-Anwendung. Sie können sie starten, indem Sie `Strg + Alt + T`drücken oder nach `Terminal` im Anwendungsmenü Ihres Systems suchen.
{% endtab %}

{% tab title="WSL" %}
Klicken Sie im Windows-Startmenü und geben Sie den Namen Ihrer installierten Distribution ein (z. B. `Ubuntu`), und öffnen Sie sie dann.

{% hint style="warning" %}
Unter **WSL**, stellen Sie sicher, dass Ihre **NVIDIA-Treiber** sind installiert auf **Windows** (nicht innerhalb von WSL) und dass das **CUDA Toolkit** in Ihrer WSL-Distribution installiert ist. Weitere Details finden Sie unten unter Systemanforderungen.
{% endhint %}
{% endtab %}
{% endtabs %}

Um zu installieren, kopieren Sie den Installationsbefehl und führen Sie ihn aus:

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

Dann:

1. Klicken Sie in das Terminalfenster
2. Fügen Sie den Befehl mit ein `Strg + Umschalt + V`
3. Drücken Sie `Enter`

Unsloth beginnt nun mit der Einrichtung der Umgebung und der Installation der erforderlichen Pakete, wie unten gezeigt. Geben Sie **Y** ein und drücken Sie `Enter` wenn Sie gefragt werden, ob Sie Unsloth jetzt starten möchten. Dadurch wird Unsloth auf Ihrem lokalen **8888** Port gestartet.

<figure><img src="/files/ea07e1b505e0d11cc8f39b34d4df520d1d58fe0f" alt=""><figcaption></figcaption></figure>

{% hint style="info" %}
Wenn Sie sich dafür entschieden haben, Unsloth während der Installation nicht zu starten, können Sie die Unsloth-App jederzeit mit `unsloth studio -p 8888` starten. Wenn Sie möchten, dass Ihre Unsloth-Instanz für Clients außerhalb Ihres PCs/Computers erreichbar ist, fügen Sie `-H 0.0.0.0` zum `unsloth studio` Befehl hinzu.
{% endhint %}

#### Schritt 2: Unsloth starten

Öffnen Sie Ihren bevorzugten Browser und geben Sie `http://127.0.0.1:8888`  in das URL-Feld ein. Wenn Sie Unsloth zum ersten Mal installieren, werden Sie zur Passwort-Seite weitergeleitet, wo Sie ein neues Passwort erstellen müssen. Danach sollte Unsloth nun auf der Chat-Seite geöffnet werden, wie unten gezeigt.
{% endtab %}
{% endtabs %}
{% endstep %}

{% step %}

#### **MCP aktivieren**

Klicke in der Chat-Toolbar auf „MCP“.

<figure><img src="/files/c0afcd7295db230a5ef999cc42dd25e2c4cbdbe1" alt=""><figcaption></figcaption></figure>

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

{% step %}

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

Um den Vercel-MCP-Server hinzuzufügen, klicke auf „Benutzerdefinierten MCP hinzufügen“, und es erscheint ein Pop-up:

<figure><img src="/files/fe52882a3c48115eee5615dce251bbeceae2510b" alt=""><figcaption></figcaption></figure>

Fülle die Serverdetails aus:

1. **Anzeigename**: ein freundliches Label, 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**. Beim ersten Verbinden öffnet sich ein Browserfenster, 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 <your-token>
```

{% endtab %}
{% endtabs %}

<figure><img src="/files/87de454829342a58ccb82cfff6a7581f396df020" alt="" width="563"><figcaption></figcaption></figure>
{% endstep %}

{% step %}

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

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

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

<figure><img src="/files/df77316dab9edd35ec2667d9038144b8c0feb31f" 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 **Schalter** ein- und 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; schließe dann den Dialog.

Er wird hervorgehoben, wenn er aktiviert ist. Du kannst ihn auch deaktivieren, indem du einfach erneut darauf klickst.

<figure><img src="/files/f6d79fe92fd79f33c1db48fb155d0e8bfb0badf4" alt=""><figcaption></figcaption></figure>
{% endstep %}

{% step %}

#### **Im Chat verwenden**

Wähle ein beliebiges Modell aus dem **Modell auswählen** Dropdown aus und beginne zu chatten. Das Modell kann nun bei Bedarf eigenständig die Tools des Servers aufrufen.

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

<figure><img src="/files/dc0539ddac45c08e3337915f9f3187a9d83c9c3e" alt=""><figcaption></figcaption></figure>
{% endstep %}
{% endstepper %}

#### Mehrere MCP-Server verwenden

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

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

<figure><img src="/files/9d77a2535a5d0f14480a3c998ad75f4f83c8ba9e" alt=""><figcaption></figcaption></figure>

Dann als Nachfolgefrage: „Suche in den Unsloth-Dokumenten, wie man das macht“, und Context7 wird für die Dokumentation verwendet:

<figure><img src="/files/047da85d9cd6b28c51287f98abf2872adf41eff1" alt=""><figcaption></figcaption></figure>

Dann tippe: „Suche auf Hugging Face nach unsloth/Qwen-Modellen“, und der MCP-Server von Hugging Face wird aufgerufen:

<figure><img src="/files/dfbdac09fc50e981febbb12ab1f16b19c1d38153" alt=""><figcaption></figcaption></figure>

#### Ein weiteres konkretes Anwendungsbeispiel

Sobald ein Server verbunden ist, bitte das Modell in Klartext, echte Arbeit zu erledigen. Ein paar Beispiele mit dem Vercel-Server:

* **Einen fehlschlagenden Build debuggen**: *„Rufe die Build-Logs meines neuesten Deployments ab und sag mir, warum es fehlgeschlagen ist.“*
* **Deployment-Status prüfen**: *„Liste meine jüngsten Deployments und ihren Status auf.“*
* **In den Dokumenten suchen**: *„Suche in der Vercel-Dokumentation, wie man eine benutzerdefinierte Domain einrichtet.“*
* **Domain-Recherche**: *„Ist `myproject.dev` verfügbar, und wie viel würde es kosten?“*

### 🦙 Llama.cpp-Anleitung

{% stepper %}
{% step %}

#### llama.cpp installieren oder bauen

**macOS:**

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

Oder für **Linux, Windows, WSL** aus dem Quellcode 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 %}

#### llama-server mit einem GGUF starten

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

```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
```

Für weitere Anpassungen der Inferenzparameter siehe unseren [Gemma-4-Leitfaden](/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": "Say hello in one sentence."}]
  }'
```

{% 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
```

Erstellen `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 den tatsächlichen Pfad deines Arbeitsbereichs. IBM’s `mcp-cli` Dokumente verwenden dieselbe `server_config.json` Struktur und dieselbe `npx -y @modelcontextprotocol/server-filesystem /path/to/allowed/files` Dateisystemkonfiguration.
{% endstep %}

{% step %}

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

Verwende IBM’s `mcp-cli`; es ist ein MCP-Client/Host für die Kommandozeile mit Chatmodus, Tool-Erkennung und Unterstützung für benutzerdefinierte OpenAI-kompatible Provider. Seine Dokumentation empfiehlt `uvx mcp-cli --help`, Projektunterstützung `server_config.json`, und zur Laufzeit benutzerdefinierte OpenAI-kompatible Provider über `--api-base` und `--api-key`.

`mcp-cli` benötigt zum Starten eine Konfigurationsdatei. Deshalb muss ein Schritt hinzugefügt werden, 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 die Bestätigung für Tool-Aufrufe standardmäßig aktiviert, daher solltest du vor der Ausführung eines Tools Eingabeaufforderungen sehen.

**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 %}

### Fehlerbehebung

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

Klicken Sie auf **Aktualisieren** wenn nach der Verbindung 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. Prüfe angeforderte Berechtigungen und lass die Bestätigung durch einen Menschen für Aktionen aktiviert, die private Daten lesen, Deployments ändern, Domains kaufen oder Projekte modifizieren. Sei besonders vorsichtig, wenn du MCP-Server mit Websuche oder anderen Tools kombinierst, weil 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 geeignet für                          | Warum es nützlich ist                                                                                                                                                                                                                           |
| ----------------------------------- | ----------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **GitHub-MCP**                      | Repos, Issues, PRs, Code-Suche, Actions         | Offizielles GitHub-MCP mit Remote- und Lokal-Setup, das Repos, Issues, Pull Requests, Actions, Codesicherheit und mehr abdeckt. ([GitHub](https://github.com/github/github-mcp-server))                                                         |
| **Context7**                        | Aktuelle Bibliotheksdokumentation und Beispiele | Lädt aktuelle, versionsspezifische Dokumentation für Coding-Assistenten, anstatt 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 nutzen. Das gehostete MCP kann Workspace-Inhalte lesen und schreiben. ([Notion Developers](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; die Aktionen hängen von den Berechtigungen ab. ([Slack](https://slack.com/help/articles/48855576908307-Guide-to-the-Slack-MCP-server)) |
| **Linear-MCP**                      | Issues, Projekte, Produkt-Workflows             | Offizielles Remote-MCP zum Finden, Erstellen und Aktualisieren von Linear-Issues, Projekten, Kommentaren und verwandten Objekten. ([Linear](https://linear.app/changelog/2025-05-01-mcp))                                                       |
| **Vercel-MCP**                      | Deployments, Logs, Dokumente, Domains           | Nützlich für Frontend-/Web-Workflows: Deployments, Logs, Dokumente und Projektkontext prüfen. Zuerst die Client-Kompatibilität überprüfen. ([Vercel](https://vercel.com/docs/agent-resources/vercel-mcp?utm_source=chatgpt.com))                |
| **Sentry-MCP**                      | Fehlersuche in der Produktion                   | Hilft Agenten, Sentry-Issues, Traces, Fehler und Leistungsdaten in Human-in-the-Loop-Entwicklungsworkflows zu untersuchen. ([GitHub](https://github.com/getsentry/sentry-mcp))                                                                  |
| **Dateisystem-/lokale-Dateien-MCP** | Lokale Projektdateien                           | Nützlich für lokale LLM-Setups, meist über `stdio`. Referenzserver sollte man am besten als Beispiele oder Ausgangspunkte betrachten. ([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 dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.