> 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, über MCP externe Tools und Dienste aufrufen kann. Wenn du MCP mit einem lokalen Modell verbindest, kann es sicher deine lokalen Dateien, Apps, Datenbanken und Tools verwenden, statt nur aus dem Gedächtnis zu chatten, um einen nützlicheren, privateren und austauschbaren KI-Assistenten aufzubauen, der in deiner echten Umgebung handeln kann.

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

MCP-Tools arbeiten zusammen mit 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 seine 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 Übersicht über dieses Repo und erkläre, wo Authentifizierung, Abrechnung und Datenzugriff stattfinden.“ - Das offizielle GitHub-MCP und GitMCP können zur Analyse von Repos verwendet werden.
* **Das Web mit Embeddings durchsuchen** - Exas MCP-Server kann für semantische Websuchen mit Unterstützung für kontextuelle Embeddings verwendet werden.
* **Website-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 werden zwei Wege verwenden, um dein lokales Modell auf deinem Gerät mit MCP-Servern zu verbinden. Beide verwenden 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-Leitfaden</a><a href="/pages/5e7bff3f8bf3f0aa817278939681700fe60de09c#llama.cpp-guide" class="button primary">Llama.cpp-MCP-Leitfaden</a>

### 🦥 Unsloth-Leitfaden

In diesem Beispiel verwenden wir Unsloth, um ein beliebiges lokales 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. Die gleichen Schritte funktionieren für jeden MCP-Server.

{% stepper %}
{% step %}

#### Unsloth einrichten

Der einfachste Einstieg ist die Installation der [Unsloth Desktop](/docs/de/desktop.md) App. Sie unterstützt [MacOS](/docs/de/erste-schritte/install/mac.md), Linux, [Windows](/docs/de/erste-schritte/install/windows-installation.md), [NVIDIA](/docs/de/erste-schritte/install/pip-install.md), [AMD](/docs/de/erste-schritte/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 Sie lieber manuell installieren:

**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="/files/c0afcd7295db230a5ef999cc42dd25e2c4cbdbe1" alt=""><figcaption></figcaption></figure>

Unsloth Studio hat standardmäßig MCP-Unterstützung für Context7, Exa und Hugging Face. Wenn du Exa aktivierst [Websuche](/docs/de/neu/studio/chat.md#advanced-web-search) wird das standardmäßige Suchwerkzeug, das wir haben, deaktiviert.
{% 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**: eine freundliche Bezeichnung, z. B. `Vercel`.
2. **URL**: den 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 eine 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, lasse OAuth ausgeschaltet 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 erfolgreich ist, klicke auf **Server hinzufügen** um ihn zu speichern.

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

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

{% step %}

#### **Überprüfen, ob die Tools geladen wurden**

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

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

Wenn es aktiviert ist, wird es hervorgehoben. Du kannst es 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 **Select model** Dropdown aus und beginne zu chatten. Das Modell kann nun bei Bedarf selbstständig die Tools des Servers aufrufen.

Oben wurde ein lokales `gemma-4-E2B-it-GGUF` gefragt *„Can you use Vercel MCP server?“* und es nannte 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="/files/dc0539ddac45c08e3337915f9f3187a9d83c9c3e" alt=""><figcaption></figcaption></figure>
{% endstep %}
{% endstepper %}

#### Mehrere MCP-Server verwenden

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

Wenn du fragst: „Can Unsloth support Qwen finetuning“, liefert Exa dazu großartige Details:

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

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

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

Dann gib „Suche auf Hugging Face nach unsloth/Qwen-Modellen“ ein, 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 einfacher Sprache, echte Arbeit zu erledigen. Einige Beispiele mit dem Vercel-Server:

* **Einen fehlgeschlagenen Build debuggen**: *„Rufe die Build-Protokolle 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**: *„Suche in den Vercel-Dokumenten, wie man eine benutzerdefinierte Domain einrichtet.“*
* **Domain-Recherche**: *„Ist `myproject.dev` verfügbar, und wie viel würde es kosten?“*

### 🦙 Llama.cpp-Leitfaden

{% 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 Modell Gemma 4 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 findest du in unserem [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": "Sag in einem Satz Hallo."}]
  }'
```

{% endstep %}

{% step %}

#### Eine MCP-Dateisystem-Sandbox erstellen

```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 deinen tatsächlichen Arbeitsbereichspfad. IBMs `mcp-cli` Dokumentation verwendet dieselbe `server_config.json` Struktur und denselben `npx -y @modelcontextprotocol/server-filesystem /path/to/allowed/files` Dateisystemkonfiguration.
{% endstep %}

{% step %}

#### Einen terminalbasierten MCP-Host gegen llama.cpp ausführen

Verwende IBMs `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`, Unterstützung für Projekte `server_config.json`, und unterstützt zur Laufzeit benutzerdefinierte OpenAI-kompatible Provider über `--api-base` und `--api-key`.

`mcp-cli` benötigt zum Start eine Konfigurationsdatei. Daher ist es notwendig, einen Schritt zum Erstellen hinzuzufügen. 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-Arbeitsbereich auf.
```

Dann:

```
Erstelle hello.txt mit einer einzeiligen Begrüßung und lies es 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 sich ein Server nicht verbinden lässt oder seine Tools nicht erscheinen, überprüfe, ob die URL der Basis-Endpunkt des Servers ist (z. B. `https://mcp.vercel.com`), nicht eine Doc- 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 der Token gültig ist.

Klicken Sie auf **Aktualisieren** wenn die Tools nach der Verbindung nicht angezeigt werden, und stelle sicher, dass sowohl der einzelne Serverschalter als auch der **Use MCP Servers** Hauptschalter aktiviert sind.

### Sicherheitshinweise

Verbinde nur MCP-Server, denen du vertraust. Prüfe die angeforderten Berechtigungen und lasse die menschliche Bestätigung für Aktionen aktiviert, die private Daten lesen, Bereitstellungen ändern, Domains kaufen oder Projekte modifizieren. Sei besonders vorsichtig, wenn du MCP-Server mit Websuche oder anderen Tools kombinierst, da 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 es nützlich ist                                                                                                                                                                                                                           |
| ----------------------------------- | ---------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **GitHub-MCP**                      | Repos, Issues, PRs, Codesuche, Actions               | Offizielles GitHub-MCP mit Remote- und lokaler Einrichtung, das Repos, Issues, Pull Requests, Actions, Codesicherheit und mehr abdeckt. ([GitHub](https://github.com/github/github-mcp-server))                                                 |
| **Context7**                        | Aktuelle Bibliotheksdokumentation und Beispiele      | Liefert aktuelle, versionsspezifische Dokumentation 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 nutzen. Gehostetes MCP kann Arbeitsbereichsinhalte 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 zugehörigen Objekten. ([Linear](https://linear.app/changelog/2025-05-01-mcp))                                                      |
| **Vercel-MCP**                      | Bereitstellungen, Protokolle, Dokumentation, Domains | Nützlich für Frontend-/Web-Workflows: Bereitstellungen, Protokolle, Dokumentation und Projektkontext prüfen. 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 Produktion                          | Hilft Agents, Sentry-Issues, Traces, Fehler und Leistungsdaten in Human-in-the-loop-Entwicklungsworkflows zu prüfen. ([GitHub](https://github.com/getsentry/sentry-mcp))                                                                        |
| **Dateisystem-/lokale-Dateien-MCP** | 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 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.