> 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 du **Model Context Protocol (MCP)** -Server mit lokalen LLMs wie [Qwen](https://unsloth.ai/docs/de/modelle/qwen3.6.md) oder [Gemma](https://unsloth.ai/docs/de/modelle/gemma-4.md)verbindest, sodass jedes Modell, das du ausführst, über MCP externe Tools und Dienste aufrufen kann. Wenn du MCP mit einem lokalen Modell verbindest, kann es sicher auf deine lokalen Dateien, Apps, Datenbanken und Tools zugreifen, statt nur aus dem Gedächtnis zu chatten. So entsteht ein nützlicherer, privaterer und austauschbarer KI-Assistent, der in deiner realen Umgebung handeln kann.

Wir verwenden die Open-Source-Repositories [Unsloth](https://github.com/unslothai/unsloth) und [llama.cpp](#llama.cpp-guide) , da es sich um beliebte Frameworks für die lokale Modellausführung und -bereitstellung handelt. MCP funktioniert mit lokalen GGUF-Modellen und Modellen von Cloud- [Anbietern](https://unsloth.ai/docs/de/integrationen/connections.md). **Wir zeigen außerdem, wie** [**mehrere MCP-Server**](#using-multiple-mcp-servers) **verwendet werden können.**

MCP-Tools funktionieren neben weiteren Modellfunktionen wie [Codeausführung](https://unsloth.ai/docs/de/neu/studio/chat.md#code-execution) und [Websuche](https://unsloth.ai/docs/de/neu/studio/chat.md#advanced-web-search), sodass ein einzelnes Modell im selben Thread im Web suchen, Code ausführen und deine verbundenen Dienste aufrufen kann.

### Anwendungsfälle

Sobald ein MCP-Server verbunden ist, kannst du dein lokales Modell mit vielen automatisierten Aufgaben beauftragen. Hier sind einige Beispiele:

* **Dokumentation durchsuchen:** „Finde die relevanten Dokumente und fasse die Einrichtungsschritte zusammen.“ – Dafür kann Context7 verwendet werden.
* **Eine Codebasis analysieren:** „Verschaffe dir einen Überblick über dieses Repository und erkläre, wo Authentifizierung, Abrechnung und Datenzugriff stattfinden.“ – Dafür können der offizielle GitHub-MCP-Server und GitMCP verwendet werden.
* **Das Web mithilfe von Embeddings durchsuchen** – Exas MCP-Server ermöglicht semantische Websuchen mit Unterstützung für kontextuelle Embeddings.
* **Websites und Benutzeroberflächen debuggen** – Mit den MCP-Servern von Playwright und Chrome DevTools kannst du Websites steuern, um Lösungen für Probleme zu finden.

### Schnellstart

Wir zeigen zwei Möglichkeiten, 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="https://unsloth.ai/docs/de/grundlagen/mcp.md#unsloth-guide" class="button primary">MCP-Anleitung für Unsloth</a><a href="https://unsloth.ai/pages/5e7bff3f8bf3f0aa817278939681700fe60de09c#llama.cpp-guide" class="button primary">MCP-Anleitung für llama.cpp</a>

### 🦥 Unsloth-Anleitung

In diesem Beispiel verwenden wir Unsloth, um ein beliebiges lokales Modell wie [Qwen3.6](https://unsloth.ai/docs/de/modelle/qwen3.6.md) oder [Gemma 4](https://unsloth.ai/docs/de/modelle/gemma-4.md) mit den folgenden 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). Anschließend fragen wir ein Modell, was es damit tun kann. Dieselben Schritte funktionieren mit jedem MCP-Server.

{% stepper %}
{% step %}

#### Unsloth einrichten

Am einfachsten beginnen Sie, indem Sie [Unsloth Desktop](https://unsloth.ai/docs/de/desktop.md) App. Es unterstützt [macOS](https://unsloth.ai/docs/de/loslegen/install/mac.md), Linux, [Windows](https://unsloth.ai/docs/de/loslegen/install/windows-installation.md), [NVIDIA](https://unsloth.ai/docs/de/loslegen/install/pip-install.md), [AMD](https://unsloth.ai/docs/de/loslegen/install/amd.md), Intel- und CPU-Konfigurationen.

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

[Eine ausführliche Anleitung findest du](https://unsloth.ai/docs/de/desktop.md#get-started) hier.
{% endstep %}

{% step %}

#### **MCP aktivieren**

Klicke in der Chat-Symbolleiste 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 unterstützt standardmäßig MCP für Context7, Exa und Hugging Face. Wenn du Exa [Websuche](https://unsloth.ai/docs/de/neu/studio/chat.md#advanced-web-search) aktivierst, wird das standardmäßige Suchtool deaktiviert.
{% endstep %}

{% step %}

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

Um den Vercel-MCP-Server hinzuzufügen, klicke auf „Benutzerdefinierten MCP hinzufügen“. Daraufhin wird ein Pop-up angezeigt:

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

Gib die Serverdetails ein:

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

{% tabs %}
{% tab title="Mit OAuth anmelden" %}
Aktiviere bei Servern, die eine browserbasierte Authentifizierung erfordern (GitHub, Linear, Vercel usw.), die Option **Mit OAuth anmelden**. Beim ersten Verbindungsaufbau wird ein Browserfenster geöffnet, in dem du Unsloth autorisieren kannst.
{% endtab %}

{% tab title="Benutzerdefinierter Header" %}
Wenn sich Server mit einem Token authentifizieren, lasse 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="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 und hinzufügen**

Klicke auf **Verbindung testen** um zu prüfen, ob Unsloth den Server erreichen kann. Wenn der Test erfolgreich ist, klicke auf **Server hinzufügen** um ihn zu speichern.

Wenn **Verbindung testen** fehlschlägt, überprüfe, ob die URL der Basisendpunkt des Servers ist (und nicht eine Dokumentationsseite) und ob die Authentifizierungsmethode korrekt ist. Weitere Informationen findest du unten unter „Fehlerbehebung“.

<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 wird nun in der Liste der MCP-Server angezeigt. Unsloth ruft seine Tools automatisch ab und zeigt eine Bestätigung an, z. B. *„Vercel“ aktualisiert (18 Tools)*.

Für jeden Server gibt es Steuerelemente, um ihn **ein- oder** auszuschalten, **seine Tools zu** aktualisieren, **zu bearbeiten** oder **löschen** es. Stelle sicher, dass sowohl der Schalter des Servers als auch der **MCP-Server verwenden** Hauptschalter eingeschaltet sind, und schließe dann den Dialog.

Wenn die Server aktiviert sind, werden sie 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 den Chat. Wenn deine Anfrage es erfordert, kann das Modell nun selbstständig die Tools des Servers aufrufen.

Oben wurde ein lokales `gemma-4-E2B-it-GGUF` gefragt: *„Kannst du den Vercel-MCP-Server verwenden?“* Das Modell gab an, welche Aktionen es ausführen kann: Projekte verwalten, Protokolle analysieren, Teams auflisten, Zugriffslinks erstellen, Domains überprüfen und in der Vercel-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 aufzurufen, zum Beispiel drei? Wir verwenden die standardmäßig in Unsloth Studio verfügbaren MCP-Server von Exa, Context7 und Hugging Face und aktivieren alle drei.

Wenn du fragst: „Unterstützt Unsloth Qwen-Finetuning?“, liefert Exa ausführliche Informationen dazu:

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

Stelle anschließend die Folgefrage „Suche in der Unsloth-Dokumentation, wie man das macht.“ Dann wird Context7 für die Dokumentation 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>

Gib dann „Suche auf Hugging Face nach Unsloth/Qwen-Modellen“ ein. Daraufhin wird der MCP-Server von Hugging Face 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>

#### Weiteres konkretes Anwendungsbeispiel

Sobald ein Server verbunden ist, kannst du das Modell in natürlicher Sprache mit konkreten Aufgaben beauftragen. Hier sind einige Beispiele für den Vercel-Server:

* **Fehlerhaften Build untersuchen**: *„Rufe die Build-Protokolle meiner letzten Bereitstellung ab und sag mir, warum sie fehlgeschlagen ist.“*
* **Bereitstellungsstatus prüfen**: *„Liste meine letzten Bereitstellungen und deren Status auf.“*
* **Dokumentation durchsuchen**: *„Durchsuche die Vercel-Dokumentation nach einer Anleitung zum Einrichten einer benutzerdefinierten Domain.“*
* **Domain recherchieren**: *„Ist `myproject.dev` verfügbar, und wie viel würde sie kosten?“*

### 🦙 Llama.cpp-Anleitung

{% stepper %}
{% step %}

#### llama.cpp installieren oder erstellen

**macOS:**

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

Oder unter **Linux, Windows und WSL** aus dem Quellcode erstellen:

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

Beim Erstellen aus dem Quellcode wird llama-server nicht im PATH installiert. Füge im Verzeichnis, in dem du git clone ausgeführt hast, das Build-Ausgabeverzeichnis zum PATH der Terminalsitzung hinzu, in der der Server gestartet wird. Unter Linux oder WSL (Bash):

{% code collapsedlinecount="10" %}

```bash
export PATH="$(pwd)/llama.cpp/build/bin:$PATH"
llama-server --help
```

{% endcode %}

Unter Windows mit dem nativen Visual-Studio-Generator befinden sich die Release-Dateien standardmäßig in llama.cpp\build\bin\Release. In PowerShell:

{% code collapsedlinecount="10" %}

```powershell
$env:PATH = "$(Resolve-Path .\llama.cpp\build\bin\Release);$env:PATH"
llama-server.exe --help
```

{% endcode %}

Verwendest du unter Windows einen Generator mit nur einer Konfiguration, etwa Ninja, nutze stattdessen .\llama.cpp\build\bin. Wiederhole die PATH-Einrichtung in jedem neuen Server-Terminal. Wenn du das Verzeichnis gewechselt hast, gib den absoluten Pfad zu deinem Checkout an. Die folgenden mehrzeiligen Befehlsbeispiele verwenden die Bash-Syntax. Führe die Befehle in der nativen PowerShell jeweils in einer Zeile aus oder ersetze die Zeilenfortsetzungszeichen von Bash durch PowerShell-Backticks. Wenn du Homebrew verwendest, kannst du weiterhin direkt llama-server aufrufen.
{% endstep %}

{% step %}

#### llama-server mit einer GGUF-Datei starten

Wir verwenden [Gemma 4](https://unsloth.ai/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-Modell 26B-A4B:

```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 finden Sie in unserem [Gemma-4-Leitfaden](https://unsloth.ai/docs/de/modelle/gemma-4.md).

Sie können 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 %}

#### Eine MCP-Dateisystem-Sandbox erstellen

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

Kopieren Sie den absoluten Pfad. Erstellen Sie einen separaten Projektordner für Ihren MCP-Host:

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

Erstellen Sie `server_config.json`:

{% code expandable="true" %}

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

{% endcode %}

Ersetzen Sie den Pfad durch den tatsächlichen Pfad Ihres Arbeitsbereichs. Die `mcp-cli` -Dokumentation von IBM verwendet dieselbe Struktur für `server_config.json` und dieselbe `npx -y @modelcontextprotocol/server-filesystem /path/to/allowed/files` -Dateisystemkonfiguration.
{% endstep %}

{% step %}

#### Einen Terminal-MCP-Host mit llama.cpp ausführen

Verwenden Sie IBMs `mcp-cli`; dabei handelt es sich um einen MCP-Client/-Host für die Befehlszeile mit Chatmodus, Tool-Erkennung und Unterstützung für benutzerdefinierte OpenAI-kompatible Anbieter. Die Dokumentation empfiehlt `uvx mcp-cli --help`, unterstützt projektbezogene `server_config.json`und unterstützt zur Laufzeit benutzerdefinierte OpenAI-kompatible Anbieter über `--api-base` und `--api-key`.

`mcp-cli` benötigt zum Starten eine Konfigurationsdatei. Daher muss ein Schritt zum Erstellen der Datei hinzugefügt werden. 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 %}

Führen Sie dann Folgendes aus:

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

Probieren Sie dann Folgendes aus:

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

Anschließend:

```
Erstelle die Datei hello.txt mit einem einzeiligen Gruß und lies sie anschließend wieder aus.
```

`mcp-cli` hat die Bestätigung von Tool-Aufrufen standardmäßig aktiviert. Daher sollten vor der Ausführung eines Tools Bestätigungsaufforderungen angezeigt werden.

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

### Game-Engines und 3D-Apps

Unsloth bietet Ein-Klick-MCP-Einträge für **Blender**, **Unity**, **Unreal Engine**, **Godot**, **Figma** und **Roblox Studio**. Siehe [Game-Engines und 3D-Apps](https://unsloth.ai/docs/de/grundlagen/mcp/mcp-engines.md) für eine schrittweise Einrichtung und Demos.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2F5zX7CyoLMVp3Cl811T5u%2Freplace-0.webp?alt=media&amp;token=e0026647-232b-4ebb-b0fd-6f0c0422e96d" alt="A local model building a village in Unreal Engine from Unsloth chat"><figcaption><p>Qwen3.8-27B erstellt aus dem Unsloth-Chat ein Dorf in Unreal Engine 5.8.</p></figcaption></figure>

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

Neben `http(s)://` -URLs kann die **URL oder ausführbare Datei** Feld akzeptiert auch einen lokalen Befehl wie `npx`, `uvx` oder den Pfad zu einer Server-Binärdatei mit den zugehörigen Argumenten in den **Argumente** -Zeilen. Diese lokalen (stdio-)Server laufen als Programm auf Ihrem Computer.

Wenn **Remotezugriff** oder **LAN-Zugriff** in den Einstellungen aktiviert ist (oder Unsloth mit `--secure`gestartet wurde), ist Unsloth von anderen Geräten aus erreichbar. Daher werden lokale Befehle deaktiviert, und beim Speichern wird Folgendes angezeigt:

{% code collapsedlinecount="10" %}

```
Lokale Befehle sind deaktiviert, solange der Remotezugriff aktiviert ist, da der Server von außerhalb dieses Computers erreichbar ist.
```

{% endcode %}

Sie können lokale MCP-Server weiterhin auf zwei Arten verwenden:

1. **Führen Sie den Server über HTTP auf Ihrem eigenen Computer aus (empfohlen).** Viele MCP-Server können selbst HTTP bereitstellen. Starten Sie den Server mit Bindung an `127.0.0.1` , sodass nur dieser Computer darauf zugreifen kann, und fügen Sie 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ügen Sie dann `http://127.0.0.1:7082/mcp` im MCP-Dialog hinzu. Dies funktioniert in Unsloth Desktop und Studio, wenn der Remotezugriff aktiviert ist. Führen Sie den MCP-Server auf dem Computer aus, auf dem Unsloth läuft, nicht auf dem Gerät, mit dem Sie darauf zugreifen. Bei [Docker](https://unsloth.ai/docs/de/loslegen/install/docker.md), `127.0.0.1` ist der Container selbst gemeint. Starten Sie den Server also im Container (`docker exec`). Für einen Server, der nur stdio unterstützt, übernimmt eine stdio-zu-HTTP-Brücke wie [mcp-proxy](https://github.com/sparfenyuk/mcp-proxy) dieselbe Aufgabe, zum Beispiel: `mcp-proxy --port=8099 uvx mcp-server-fetch`Fügen Sie dann `http://127.0.0.1:8099/mcp`.
2. **Lokale Befehle ausdrücklich erlauben (Studio).** Starten Sie Studio, nachdem Sie die Variable selbst festgelegt haben. Dann bleiben lokale Befehle aktiviert, auch wenn Remotezugriff 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 jede Person, die sich über das Netzwerk bei Ihrem Studio anmelden kann, über einen MCP-Server Programme auf Ihrem Computer ausführen. Verwenden Sie diese Option nur mit einem starken Passwort in Netzwerken, denen Sie vertrauen, und bevorzugen Sie Option 1.
{% endhint %}

### Fehlerbehebung

Wenn die Verbindung zu einem Server fehlschlägt oder seine Tools nicht angezeigt werden, prüfen Sie, ob die URL auf den Basis-Endpunkt des Servers verweist (z. B. `https://mcp.vercel.com`) und nicht auf eine Dokumentations- oder Dashboard-Seite. Schließen Sie bei OAuth-Servern die Browseranmeldung ab, wenn sie geöffnet wird. Überprüfen Sie bei tokenbasierten Servern den `Authorization` -Header und ob das Token gültig ist.

Wenn das Speichern eines lokalen Befehls mit „Lokale Befehle sind deaktiviert, solange der Remotezugriff aktiviert ist“ fehlschlägt, lesen Sie [Lokale MCP-Server bei aktiviertem Remotezugriff oder LAN-Zugriff](#local-mcp-servers-with-remote-access-or-lan-access).

Klicken Sie auf **Aktualisieren** , wenn nach dem Verbinden keine Tools angezeigt werden, und vergewissern Sie sich, dass sowohl der Schalter des jeweiligen Servers als auch der Hauptschalter **MCP-Server verwenden** aktiviert sind.

### Sicherheitshinweise

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

### Beliebte MCP-Server

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

| MCP-Server                         | Am besten geeignet für                          | Warum der Server nützlich ist                                                                                                                                                                                                                          |
| ---------------------------------- | ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **GitHub MCP**                     | Repositories, Issues, PRs, Codesuche, Actions   | Offizieller GitHub-MCP-Server mit Remote- und lokaler Einrichtung, der Repositories, Issues, Pull Requests, Actions, Codesicherheit und mehr abdeckt. ([GitHub](https://github.com/github/github-mcp-server))                                          |
| **Context7**                       | Aktuelle Bibliotheksdokumentation und Beispiele | Ruft aktuelle, versionsspezifische Dokumentation für Programmierassistenten ab, 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     | Ideal für Teams, die Notion für Spezifikationen, PRDs, Roadmaps oder Notizen verwenden. Der gehostete MCP-Server kann Arbeitsbereichsinhalte lesen und bearbeiten. ([Notion-Entwickler](https://developers.notion.com/guides/mcp/overview))            |
| **Slack MCP**                      | Suche in Teamgesprächen                         | Ermöglicht KI-Tools, Slack-Nachrichten, Channels, Dateien, Threads und Mitgliederinformationen abzufragen; mögliche 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             | Offizieller Remote-MCP-Server zum Suchen, Erstellen und Aktualisieren von Linear-Issues, Projekten, Kommentaren und zugehörigen Objekten. ([Linear](https://linear.app/changelog/2025-05-01-mcp))                                                      |
| **Vercel MCP**                     | Deployments, Logs, Dokumentation, Domains       | Nützlich für Frontend- und Web-Workflows: Deployments, Logs, Dokumentation und Projektkontext untersuchen. Prüfe zuerst die Client-Kompatibilität. ([Vercel](https://vercel.com/docs/agent-resources/vercel-mcp?utm_source=chatgpt.com))               |
| **Sentry MCP**                     | Debugging in der Produktionsumgebung            | Unterstützt Agents dabei, Sentry-Issues, Traces, Fehler und Performance-Daten in Entwicklungs-Workflows mit menschlicher Beteiligung zu untersuchen. ([GitHub](https://github.com/getsentry/sentry-mcp))                                               |
| **Filesystem-/lokale-Dateien-MCP** | Lokale Projektdateien                           | Nützlich für lokale LLM-Setups, üblicherweise über `stdio`. Referenzserver sollten am besten als Beispiele oder Ausgangspunkte betrachtet 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.
