> 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/claude-code.md).

# So führst du lokale LLMs mit Claude Code aus

Diese Schritt-für-Schritt-Anleitung zeigt dir, wie du offene LLMs und APIs vollständig lokal mit Claude Code verbindest – inklusive Screenshots. Ausführen mit jedem offenen Modell wie Qwen3.6, DeepSeek und Gemma.

{% columns %}
{% column width="58.333333333333336%" %}
Für dieses Tutorial verwenden wir die offenen Modelle: [Gemma 4](/docs/de/modelle/gemma-4.md) und [Qwen3.5](/docs/de/modelle/qwen3.5.md) die starke agentische und Coding-Modelle sind (funktioniert auf einem Gerät mit 24 GB RAM/Unified Memory).

Für die Inferenz verwenden wir [Unsloth Desktop](https://github.com/unslothai/unsloth) und [`llama.cpp`](https://github.com/ggml-org/llama.cpp) das es dir ermöglicht, LLMs unter macOS, Linux und Windows auszuführen/bereitzustellen. Du kannst jedes andere Modell verwenden. Für Modell-Quants nutzen wir Unsloth [Dynamic GGUFs](/docs/de/grundlagen/dynamic-3.0-ggufs.md) um jedes quantisierte LLM auszuführen und dabei die Genauigkeit beizubehalten.
{% endcolumn %}

{% column width="41.666666666666664%" %}

<figure><img src="/files/71dc8d04c5322ed18a0af5f03d72f1ec3f286b24" alt=""><figcaption><p>Claude Code, der mit Qwen3.5 lokal ausgeführt wird.</p></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

<a href="/pages/d12c953ceacbd6c3e44f3aa911056928e0488f5b#claude-code-setup" class="button primary" data-icon="claude">Claude-Code-Einrichtung</a><a href="/pages/d12c953ceacbd6c3e44f3aa911056928e0488f5b#quickstart-tutorials" class="button primary">📖 Anleitung zur Einrichtung eines lokalen Modells</a>

## <i class="fa-claude">:claude:</i> Claude-Code-Einrichtung

Bevor wir unser lokales LLM einrichten, müssen wir Claude Code installieren. Claude Code ist ein terminalbasierter Coding-Agent, der deine Codebasis versteht und komplexe Git-Workflows mithilfe natürlicher Sprache handhabt.

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

#### **Claude Code installieren:**

Füge dies in dein Terminal ein, um Claude Code zu installieren:

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

Nach der Installation wechsle in deinen Projektordner. Tippe dann `claude` in die `Shell` um zu beginnen.

```bash
cd ~/projects/my-project 
claude
```

{% endtab %}

{% tab title="Windows" %}

#### **Claude Code installieren:**

Gib ein in `PowerShell` um Claude Code zu installieren:

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

Nach der Installation wechsle in deinen Projektordner. Tippe dann `claude` in die `powershell` um zu beginnen.

<pre class="language-powershell"><code class="lang-powershell"><strong>cd /pfad/zu/deinem/projekt
</strong>claude
</code></pre>

<div data-with-frame="true"><figure><img src="/files/dc60e37e6bd78543c5dcf44efe33f0dedd4500e7" alt="" width="563"><figcaption></figcaption></figure></div>
{% endtab %}
{% endtabs %}

### :detective:Behebung von 90 % langsamerer Inferenz in Claude Code

{% hint style="warning" %}
Claude Code fügt kürzlich einen Claude-Code-Attribution-Header voran und hinzu, der **den KV-Cache ungültig macht, wodurch die Inferenz mit lokalen Modellen 90 % langsamer wird**.
{% endhint %}

Die Attribution ist eine Zeile, die an den **Beginn des System-Prompts** (`x-anthropic-billing-header: cc_version=...; cch=...;`) vorangestellt wird, dessen Wert sich bei jeder Anfrage ändert, sodass der gesamte Prompt-Präfix bei jedem Durchlauf den KV-Cache verfehlt.

Die einfachste Lösung ist, sie direkt beim Start von Claude Code zu deaktivieren, sodass keine Datei bearbeitet werden muss:

{% code overflow="wrap" %}

```bash
claude --settings '{"env":{"CLAUDE_CODE_ATTRIBUTION_HEADER":"0","CLAUDE_CODE_ENABLE_TELEMETRY":"0"}}' --model unsloth/gemma-4-26B-A4B-it-GGUF
```

{% endcode %}

{% hint style="info" %}
Neuere Claude-Code-Versionen beachten außerdem `export CLAUDE_CODE_ATTRIBUTION_HEADER=0`; ältere Builds ignorierten die Shell-Variable, daher ist die `--settings` Variante oben (oder die Konfigurationsdatei unten) die zuverlässige Wahl.
{% endhint %}

Um es dauerhaft zu machen, füge `CLAUDE_CODE_ATTRIBUTION_HEADER` mit dem Wert 0 in `"env"` in `~/.claude/settings.json`ein. Zum Beispiel: `cat > ~/.claude/settings.json` und füge dann den folgenden Inhalt ein (nach dem Einfügen ENTER drücken und dann STRG+D, um zu speichern). Wenn du bereits eine `~/.claude/settings.json` Datei hast, füge einfach `"CLAUDE_CODE_ATTRIBUTION_HEADER" : "0"` zum Abschnitt "env" hinzu und lasse den Rest der Konfigurationsdatei unverändert.

<pre class="language-json"><code class="lang-json">{
  "promptSuggestionEnabled": false,
  "env": {
    "CLAUDE_CODE_ENABLE_TELEMETRY": "0",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
    <a data-footnote-ref href="#user-content-fn-1">"CLAUDE_CODE_ATTRIBUTION_HEADER" : "0"</a>
  },
  "attribution": {
    "commit": "",
    "pr": ""
  },
  "plansDirectory" : "./plans",
  "prefersReducedMotion" : true,
  "terminalProgressBarEnabled" : false,
  "effortLevel" : "high"
}
</code></pre>

## 📖 Schnellstart-Tutorials

{% columns %}
{% column %}
Bevor wir beginnen, müssen wir zunächst die Einrichtung für das konkrete Modell abschließen, das du verwenden wirst. Wir verwenden [Unsloth](/docs/de/neu/studio.md) (eine Web-UI) und llama.cpp, die Open-Source-Frameworks zum Ausführen und Bereitstellen von LLMs auf deinen Mac-, Linux- und Windows-Geräten sind.

Unsloth hat außerdem einzigartige selbstheilende [Tool-Aufruf-](/docs/de/neu/studio/chat.md#auto-healing-tool-calling) und [Websuche](/docs/de/neu/studio/chat.md#code-execution) Funktionen. Siehe rechts Claude Code, verbunden mit Unsloth:
{% endcolumn %}

{% column %}

<div data-with-frame="true"><figure><img src="/files/4d7f67e24fb64209883a9782fb1c8e4d7782a66f" alt=""><figcaption></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

<a href="/pages/d12c953ceacbd6c3e44f3aa911056928e0488f5b#connect-claude-code" class="button primary" data-icon="claude">Claude Code verbinden</a><a href="/pages/d12c953ceacbd6c3e44f3aa911056928e0488f5b#unsloth-tutorial" class="button primary">🦥 Unsloth-Tutorial</a><a href="https://unsloth.ai/docs/basics/claude-code#llama.cpp-tutorial" class="button primary"> llama.cpp-Tutorial</a>

## 🦥 Unsloth-Tutorial

Für dieses Tutorial stellen wir lokale Modelle über eine UI für Claude Code bereit/verbinden sie, indem wir [Unsloth](https://github.com/unslothai/unsloth)verwenden. Unsloth funktioniert unter Windows, WSL, Linux und macOS.

{% columns %}
{% column %}

* Suchen, herunterladen, [GGUFs ausführen](/docs/de/neu/studio.md#run-models-locally) und Safetensor-Modelle
* [**Selbstheilende** Tool-Aufrufe](/docs/de/neu/studio.md#execute-code--heal-tool-calling) + **Websuche**
* [**Code-Ausführung**](/docs/de/neu/studio.md#run-models-locally) (Python, Bash)
* [Automatisches Tuning der Inferenz-](https://unsloth.ai/docs/desktop#feature-deep-dive) Parameterauswahl (temp, top-p usw.)
* Schnelle CPU- und GPU-Inferenz via llama.cpp
* [LLMs trainieren](/docs/de/neu/studio.md#no-code-training) 2x schneller mit 70 % weniger VRAM

Siehe unten für Installationsanweisungen:
{% endcolumn %}

{% column %}

<div data-with-frame="true"><figure><img src="/files/16c0b18ba770d26abf1c3a92209b60c094a825a0" alt=""><figcaption><p>Beispiel für ein in Unsloth laufendes Qwen3.6 mit 2 Bit.</p></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

{% stepper %}
{% step %}

#### Unsloth herunterladen

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

{% endstep %}

{% step %}

#### Installieren

1. Öffne den Unsloth-Installer (`.dmg`, `.exe` Dateien)
2. Ziehe Unsloth auf dem Mac in den Ordner „Applications“ oder schließe das Setup unter Windows ab.
3. Starte die App und warte, bis die Installation abgeschlossen ist
   {% endstep %}

{% step %}

#### Wähle ein Modell

Öffne oben das Dropdown „Select model“ oder den Tab „Model hub“, wähle ein Modell und eine Quantisierung, die zu deinem Gerät passt, und lade es dann herunter. Sobald es fertig ist, kannst du mit dem Chatten beginnen – keine Einrichtung erforderlich.

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

{% step %}

#### Unsloth ist jetzt bereit

Um mit dem Chatten zu beginnen, tippe eine Nachricht ein und drücke Enter.

* **Tools verbinden:** [Claude Code](/docs/de/grundlagen/claude-code.md), [Codex](/docs/de/grundlagen/codex.md), Websuche, [MCP](/docs/de/grundlagen/mcp.md) und mehr
* **Modelle trainieren:** Text, Diffusion, Embeddings und mehr feinabstimmen
* **Medien erzeugen:** Bilder, Videos und TTS lokal erstellen und trainieren

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

### Modelllade- und API-Anleitung

{% stepper %}
{% step %}

#### Modell auswählen

Bevor du die API verwendest, lade ein Modell aus dem **Modell auswählen** Dropdown oben links auf der Chat-Seite.

<figure><img src="/files/35a6966ece42497bdc299b98050269c7636c7c98" alt=""><figcaption></figcaption></figure>

In dieser Anleitung verwenden wir: `unsloth/gemma-4-26B-A4B-it-GGUF` mit der empfohlenen `UD-Q4_K_XL` Quantisierung.
{% endstep %}

{% step %}

#### Modell testen

Bevor du den Client verwendest, sende eine kurze Nachricht:

<div data-with-frame="true"><figure><img src="/files/245fe14776c68639a801acfab0d58e75d6cf1ce4" alt="" width="563"><figcaption></figcaption></figure></div>

{% hint style="info" %}
Das bestätigt, dass das Modell korrekt geladen wurde und bereit ist zu antworten.
{% endhint %}
{% endstep %}

{% step %}

#### **Unsloth-API-Schlüssel**

Öffne in Unsloth **Einstellungen → API** um deinen API-Schlüssel anzuzeigen oder zu erstellen.

<figure><img src="/files/96dbb4b6e52ce8bc33d050cacf1e90d03b66c1ae" alt=""><figcaption></figcaption></figure>

Behandle deinen API-Schlüssel wie ein Passwort und vermeide, ihn in Screenshots oder Repositories offenzulegen.
{% endstep %}
{% endstepper %}

## ⚙️ Claude Code verbinden

Jetzt, da wir das lokale LLM für Claude Code eingerichtet haben, konfigurieren wir Claude Code so, dass es mit deinem Tool funktioniert. Du kannst dich entweder einfach verbinden mit `unsloth start` unten verbinden oder es [manuell](#connect-manually).

### ⚡ Claude Code ausführen mit `unsloth start`

Um Claude direkt mit einem Modell zu starten, führe aus:

```bash
unsloth start claude \
    --model unsloth/qwen3.8-27B-GGUF-GGUF:UD-Q4_K_XL
    --temp 1.0 \
    --top-p 0.95 \
    --top-k 20 \
    --min-p 0.0 \
    --chat-template-kwargs '{"reasoning_effort":"medium"}'
```

Unsloth wählt automatisch die richtigen Parameter aus, aber du kannst sie trotzdem ändern.

Öffnen Sie bei einem in Unsloth Studio geladenen Modell Ihren Projektordner und führen Sie Folgendes aus:

```bash
unsloth start claude
```

<figure><img src="/files/090f12de77326b94f443cf743bf3318b7416910e" alt="Claude Code connected to a local model through Unsloth Studio"><figcaption><p>Claude Code, das gegen das in Unsloth Studio geladene Modell läuft.</p></figcaption></figure>

Unsloth setzt für diesen Start den lokalen Endpunkt, den API-Schlüssel, das Modell und die Kontextlänge. Deine normale Claude-Code-Konfiguration bleibt unberührt.

Claude Code speichert Unterhaltungen bereits in seinem normalen Sitzungsspeicher, daher `--persist` wird nicht benötigt. Setze deine letzte Sitzung fort mit:

```bash
unsloth start claude --continue
```

Siehe die vollständige `unsloth start` Referenz zum Laden eines Modells über die Kommandozeile, entfernte Unsloth-Server und erweiterte Optionen.

Der Rest dieser Anleitung behandelt die manuelle `llama.cpp` Einrichtung.

#### 🔌 Manuell verbinden

Wenn du die Einrichtung lieber manuell vornehmen möchtest, kannst du damit beginnen, die folgenden Umgebungsvariablen zu setzen. Diese Variablen bleiben standardmäßig nicht zwischen Sitzungen erhalten.

{% tabs %}
{% tab title="MacOS, Linux, WSL" %}
**Konfiguration:** Lokale API-URL setzen:

```bash
export ANTHROPIC_BASE_URL="http://localhost:8888"
```

Kopiere deinen Schlüssel aus Unsloth Studio → Einstellungen → API (oder aus der Konsole, wenn du es mit `unsloth run`startest, wo er als `sk-unsloth-...`ausgegeben wird), und setze ihn dann.

{% code overflow="wrap" %}

```bash
export ANTHROPIC_AUTH_TOKEN="sk-unsloth-xxxxxxxxxxxx"
```

{% endcode %}

Setze außerdem ein leeres `ANTHROPIC_API_KEY` damit Claude Code nicht nach einem Cloud-Schlüssel fragt:

```bash
export ANTHROPIC_API_KEY=""
```

Optional: Verwende den Namen des aktuell in Unsloth geladenen Modells als Standard.

```bash
export ANTHROPIC_MODEL="unsloth/gemma-4-26B-A4B-it-GGUF"
```

Verwende die vollständige Modell-ID genau so, wie sie in `GET http://localhost:8888/v1/models` erscheint (derselbe String, den du an `claude --model`).
{% endtab %}

{% tab title="Windows" %}
**Konfiguration:** Lokale API-URL in Powershell setzen:

```powershell
$env:ANTHROPIC_BASE_URL = "http://localhost:8888"
```

Kopiere deinen Schlüssel aus **Unsloth Studio → Einstellungen → API**und setze ihn dann:

```powershell
$env:ANTHROPIC_AUTH_TOKEN = "sk-unsloth-xxxxxxxxxxxx"
```

**Optional:** Verwende den Namen des aktuell in Unsloth geladenen Modells, um ihn als Standard festzulegen.

```powershell
$env:ANTHROPIC_MODEL = "gemma-4-26B-A4B-it-GGUF"
```

{% hint style="info" %}
Der Modellname sollte das Modell sein, das derzeit in Unsloth Studio geladen ist.
{% endhint %}
{% endtab %}
{% endtabs %}

### Claude Code starten

Claude Code mit dem derzeit in Unsloth geladenen Modell starten.

Wir werden `gemma-4-26B-A4B-it-GGUF`verwenden, aber du kannst jedes mit Unsloth kompatible Modell verwenden.

```shellscript
claude --model unsloth/gemma-4-26B-A4B-it-GGUF
```

{% hint style="info" %}
Für einen zusätzlichen Geschwindigkeits-Boost bei lokalen Modellen kannst du auch starten mit `--bare --exclude-dynamic-system-prompt-sections`. Siehe unten Optional: den System-Prompt verkleinern.
{% endhint %}

Claude Code sollte das ausgewählte Modell öffnen und anzeigen.

<figure><img src="/files/754efbbba589910e6ca1eed3af043812cac256e9" alt=""><figcaption></figcaption></figure>

{% hint style="warning" %}
Siehe [#fixing-90-slower-inference-in-claude-code](#fixing-90-slower-inference-in-claude-code "mention") zuerst, um offene Modelle zu reparieren, die wegen KV-Cache-Ungültigmachung 90 % langsamer sind.
{% endhint %}

Probiere diesen Prompt aus, um hochwertige SFT-Datensätze zu recherchieren und zu bewerten:

{% code overflow="wrap" %}

```
Du darfst nur in project/ arbeiten. Suche nicht nach CLAUDE.md — das hier ist es. Verwende die Websuche, um 10 echte Instruction-/Chat-/SFT-Datensätze auf Hugging Face zu finden, fasse deine Ergebnisse kurz zusammen und erkläre beim Recherchieren, warum jeder Datensatz für SFT relevant ist; erstelle dann sft_report.md als einen ausgearbeiteten Markdown-Bericht mit Rang, Datensatzname, Ersteller, 3–5 relevanten Tags, einer kurzen Zusammenfassung in einfachem Englisch und einem Hinweis, warum er für SFT nützlich ist. Halte alles knapp und lesbar, ohne riesige Metadaten-Dumps, eingefügte Rohbeschreibungen, übergroße Tag-Listen oder irrelevante Datensätze. Die Aufgabe ist abgeschlossen, sobald sft_report.md 10 saubere, gut geschriebene Datensatzeinträge enthält, und ende mit: „Successfully finetuned a model with Unsloth!"
```

{% endcode %}

Nachdem du den Prompt abgeschickt hast, wird der Agent das Web durchsuchen, die Ergebnisse bewerten und den Abschlussbericht schreiben. Das kann ein paar Minuten dauern.

Einige Workflows erfordern möglicherweise, dass du Aktionen genehmigst oder Rückfragen beantwortest.

<figure><img src="/files/d7273f89484e689eba23f584ac8357b9958e556b" alt="" width="563"><figcaption></figcaption></figure>

{% hint style="info" %}
Einige Workflows erfordern möglicherweise, dass du Aktionen genehmigst oder Folgefragen beantwortest.
{% endhint %}

Sobald abgeschlossen, wird die erzeugte `sft_report.md` ähnlich aussehen wie dies.

<figure><img src="/files/53c1eee2d5dd765686fe47c37e14eaecde8352ab" alt="" width="375"><figcaption></figcaption></figure>

{% hint style="warning" %}
Wenn du `Unable to connect to API (ConnectionRefused)` siehst, denke daran, `ANTHROPIC_BASE_URL` über `unset ANTHROPIC_BASE_URL`

Wenn du feststellst, dass offene Modelle 90 % langsamer sind, [sieh hier zuerst nach](#fixing-90-slower-inference-in-claude-code) um zu beheben, dass der KV-Cache ungültig gemacht wird.
{% endhint %}

### Optional: den System-Prompt verkleinern

Claude Code wurde für Anthropic-Hosting-Modelle entwickelt, daher ist der Standard-System-Prompt groß. Bei lokalen Modellen kannst du ihn für schnellere Antworten und bessere KV-Cache-Wiederverwendung kürzen, indem du beim Start zwei Flags hinzufügst:

{% code overflow="wrap" %}

```shellscript
claude --model unsloth/gemma-4-26B-A4B-it-GGUF --bare --exclude-dynamic-system-prompt-sections
```

{% endcode %}

{% hint style="info" %}
`--bare` überspringt die automatische Erkennung von Hooks, Skills, Plugins, MCP-Servern und CLAUDE.md (Claude behält Bash- sowie Datei-Lese-/Bearbeitungsfunktionen), und `--exclude-dynamic-system-prompt-sections` verschiebt machinespezifische Abschnitte aus dem Prompt-Präfix heraus. Beides verkleinert den Prompt und verbessert die KV-Cache-Wiederverwendung, was lokale Modelle spürbar schneller macht. Sie sind optional und ändern die obige Verbindungseinrichtung nicht.
{% endhint %}

### Optional: den Unsloth-Server anpassen

Claude Code verwendet das in Unsloth laufende Modell. Du kannst das Verhalten des Servers beim Start anpassen.

```bash
# Für einen Coding-Agenten bereitstellen: --disable-tools reicht die eigenen Tools des Agents durch
unsloth run \
  --model unsloth/gemma-4-26B-A4B-it-GGUF \
  --disable-tools \
  --reasoning off \
  -p 8888
```

{% hint style="warning" %}
Verwende `--disable-tools` wenn Claude Code (oder einen anderen externen Coding-Agenten) gesteuert wird. Standardmäßig führt Unsloth Studio seine eigenen serverseitigen Tools aus, wodurch die Tool-Aufrufe des Agents verschluckt werden, sodass Claude Code antwortet, aber niemals Dateien bearbeitet. `--disable-tools` wechselt zu Passthrough, sodass Claudes eigene Write/Edit/Bash-Tools verwendet werden.
{% endhint %}

Verwende `--reasoning off` um das Denken auszuschalten, oder `--reasoning on` um es für Modelle einzuschalten, die Reasoning unterstützen.

```bash
# Die API im lokalen Netzwerk bereitstellen
unsloth run \
  --model unsloth/gemma-4-26B-A4B-it-GGUF \
  -H 0.0.0.0 \
  -p 8888
```

Dies startet den Server auf `0.0.0.0:8888`, sodass sich andere Geräte in Ihrem lokalen Netzwerk verbinden können.

Verwende `-p` um zu ändern, auf welchem Port der Server läuft. Verwende `-H 0.0.0.0` wenn Handys, Laptops oder andere Geräte in deinem Netzwerk eine Verbindung herstellen sollen.

Für eine weitergehende Laufzeitkonfiguration siehe den Hauptabschnitt [API-Abstimmung](https://unsloth.ai/docs/basics/api#unsloth-run-command) Abschnitt.

## 🦙 Llama.cpp-Tutorial

Bevor wir beginnen, müssen wir zunächst die Einrichtung für das konkrete Modell abschließen, das du verwenden wirst. Wir verwenden `llama.cpp` das ein Open-Source-Framework zum Ausführen von LLMs auf deinen Mac-, Linux-, Windows- usw\.-Geräten ist. Llama.cpp enthält `llama-server` das es ermöglicht, LLMs effizient bereitzustellen und zu deployen. Das Modell wird auf Port 8001 bereitgestellt, wobei alle Agent-Tools über einen einzigen OpenAI-kompatiblen Endpunkt geleitet werden.

#### Qwen3.5-Tutorial

Wir werden [Qwen3.5](/docs/de/modelle/qwen3.5.md)-35B-A3B und spezielle Einstellungen für schnelle, genaue Coding-Aufgaben verwenden. Wenn du nicht genug VRAM hast und ein **intelligenteres** Modell **Qwen3.5-27B** ist eine großartige Wahl, aber es wird etwa 2x langsamer sein, oder du kannst andere Qwen3.5-Varianten wie 9B, 4B oder 2B verwenden.

{% hint style="info" %}
Verwende Qwen3.5-27B, wenn du ein **intelligenteres** Modell möchtest oder wenn du nicht genug VRAM hast. Es wird jedoch etwa 2x langsamer sein als 35B-A3B. Oder du kannst [**Qwen3-Coder-Next**](/docs/de/modelle/qwen3-coder-next.md) verwenden, das fantastisch ist, wenn du genug VRAM hast.
{% endhint %}

{% stepper %}
{% step %}

#### llama.cpp installieren

Wir müssen `llama.cpp` um lokale LLMs bereitzustellen/bereitzustellen, damit sie in Claude Code usw. verwendet werden können. Wir folgen den offiziellen Build-Anweisungen für korrekte GPU-Bindings und maximale Leistung. Ändere `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn Sie keine GPU haben oder einfach CPU-Inferenz möchten. **Für Apple-Mac-/Metal-Geräte**, setzen Sie `-DGGML_CUDA=OFF` und fahren Sie dann wie gewohnt fort – Metal-Unterstützung ist standardmäßig aktiviert.

```bash
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev git-all -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp
```

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

{% step %}

#### Modelle lokal herunterladen und verwenden

Lade das Modell herunter über `huggingface_hub` in Python (nach der Installation über `pip install huggingface_hub hf_transfer`). Wir verwenden die **UD-Q4\_K\_XL** Quantisierung für das beste Größen-/Genauigkeitsverhältnis. Alle Unsloth-GGUF-Uploads finden Sie in unserer [Sammlung hier](/docs/de/erste-schritte/unsloth-model-catalog.md). Wenn Downloads hängen bleiben, siehe [Debugging für Hugging Face Hub, XET](/docs/de/grundlagen/troubleshooting-and-faqs/hugging-face-hub-xet-debugging.md)

```bash
hf download unsloth/Qwen3.5-35B-A3B-GGUF \
    --local-dir unsloth/Qwen3.5-35B-A3B-GGUF \
    --include "*UD-Q4_K_XL*" # Verwende "*UD-Q2_K_XL*" für Dynamic 2bit
```

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

{% hint style="success" %}
Wir haben `unsloth/Qwen3.5-35B-A3B-GGUF` verwenden, aber du kannst eine andere Variante wie 27B oder ein anderes Modell wie `unsloth/`[`Qwen3-Coder-Next`](/docs/de/modelle/qwen3-coder-next.md)`-GGUF`.
{% endhint %}

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

{% step %}

#### Starten Sie den Llama-Server

Um Qwen3.5 für agentische Workloads bereitzustellen, verwenden wir `llama-server`. Wir wenden an [von Qwen empfohlene Sampling-Parameter](/docs/de/modelle/qwen3.5.md#recommended-settings) für den Thinking-Modus: `temp 0.6`, `top_p 0.95` , `top-k 20`. Beachte, dass sich diese Werte ändern, wenn du Nicht-Thinking-Modus oder andere Aufgaben verwendest.

Führen Sie diesen Befehl in einem neuen Terminal aus (verwenden Sie `tmux` oder öffnen Sie ein neues Terminal). Das Folgende sollte **passt perfekt in eine 24GB-GPU (RTX 4090) (verwendet 23GB)** `--fit auf` wird ebenfalls automatisch auslagern, aber wenn Sie schlechte Leistung sehen, reduzieren Sie `--ctx-size` .

{% hint style="info" %}
Wir haben `--cache-type-k q8_0 --cache-type-v q8_0` für KV-Cache-Quantisierung zur Verringerung des VRAM-Verbrauchs. Für volle Präzision verwende `--cache-type-k bf16 --cache-type-v bf16` .Hinweis: bf16-KV-Cache kann auf manchen Maschinen etwas langsamer sein.
{% endhint %}

```bash
./llama.cpp/llama-server \\
    --model unsloth/Qwen3.5-35B-A3B-GGUF/Qwen3.5-35B-A3B-UD-Q4_K_XL.gguf \
    --alias "unsloth/Qwen3.5-35B-A3B" \
    --temp 0.6 \
    --top-p 0.95 \
    --top-k 20 \
    --min-p 0.00 \
    --port 8001 \\
    --kv-unified \\
    --cache-type-k q8_0 --cache-type-v q8_0
```

{% hint style="success" %}
Du kannst das Denken für Qwen3.5 auch deaktivieren, was die Leistung für agentische Coding-Aufgaben verbessern kann. Um Thinking mit llama.cpp zu deaktivieren, füge dies dem llama-server-Befehl hinzu:

`--chat-template-kwargs "{\"enable_thinking\": false}"`

<img src="/files/97cefe30500398f36322e3abca6ac84ae206c488" alt="" data-size="original">
{% endhint %}
{% endstep %}
{% endstepper %}

### Claude Code mit llama-server starten

{% hint style="success" %}
Wir haben `unsloth/GLM-4.7-Flash-GGUF` , aber Sie können auch etwas wie `unsloth/Qwen3.6-27B-GGUF`.
{% endhint %}

{% hint style="warning" %}
Siehe [#fixing-90-slower-inference-in-claude-code](#fixing-90-slower-inference-in-claude-code "mention") zuerst, um offene Modelle zu reparieren, die wegen KV-Cache-Ungültigmachung 90 % langsamer sind.
{% endhint %}

Wechsle in deinen Projektordner (`mkdir project ; cd project`) und führe aus:

```bash
claude --model unsloth/GLM-4.7-Flash
```

Um Qwen3.6-35B-A3B zu verwenden, ändere es einfach zu:

```bash
claude --model unsloth/Qwen3.6-35B-A3B
```

<div data-with-frame="true"><figure><img src="/files/a527b9eda682e762510bcc0ac431ea8092f0e51a" alt="" width="563"><figcaption></figcaption></figure></div>

Um Claude Code so einzustellen, dass Befehle ohne jegliche Genehmigungen ausgeführt werden, tue dies **(ACHTUNG: Dadurch wird Claude Code Code ohne jegliche Genehmigungen ausführen, ganz wie es ihm gefällt!)**

{% code overflow="wrap" %}

```bash
claude --model unsloth/GLM-4.7-Flash --dangerously-skip-permissions
```

{% endcode %}

Probiere diesen Prompt aus, um ein einfaches Unsloth-Finetuning zu installieren und auszuführen:

{% code overflow="wrap" %}

```
Du darfst nur im cwd project/ arbeiten. Suche nicht nach CLAUDE.md – das hier ist es. Installiere Unsloth über eine virtuelle Umgebung mit uv. Verwende nach Möglichkeit `python -m venv unsloth_env` und dann `source unsloth_env/bin/activate`. Siehe https://unsloth.ai/docs/get-started/install/pip-install dazu, wie (hole es dir und lies es). Führe dann einen einfachen Unsloth-Finetuning-Lauf aus, der unter https://github.com/unslothai/unsloth beschrieben ist. Du hast Zugriff auf 1 GPU.
```

{% endcode %}

<div data-with-frame="true"><figure><img src="/files/e0a425cc7c492be7351cfc77d143adb530640a77" alt="" width="563"><figcaption></figcaption></figure></div>

Nach kurzer Wartezeit wird Unsloth über uv in einer venv installiert und geladen:

<div data-with-frame="true"><figure><img src="/files/1872f761f8d387ce7f11b0a4624f30b618c23ed0" alt="" width="563"><figcaption></figcaption></figure></div>

und schließlich wirst du ein erfolgreich mit Unsloth feinabgestimmtes Modell sehen!

<div data-with-frame="true"><figure><img src="/files/b529ad04568468ccc24a43889b11ecace803a97d" alt="" width="563"><figcaption></figcaption></figure></div>

{% hint style="warning" %}
Wenn du `Unable to connect to API (ConnectionRefused)` siehst, denke daran, `ANTHROPIC_BASE_URL` über `unset ANTHROPIC_BASE_URL`

Wenn du feststellst, dass offene Modelle 90 % langsamer sind, [sieh hier zuerst nach](#fixing-90-slower-inference-in-claude-code) um zu beheben, dass der KV-Cache ungültig gemacht wird.
{% endhint %}

[^1]: Das muss verwendet werden!


---

# 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/claude-code.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.