> 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). # Lokale LLMs mit Claude Code ausführen Leitfaden zur Verwendung offener Modelle mit Claude Code auf deinem lokalen Gerät. Diese Schritt-für-Schritt-Anleitung zeigt dir, wie du offene LLMs und APIs vollständig lokal mit Claude Code verbindest, inklusive Screenshots. Führe es mit jedem offenen Modell wie Qwen3.6, DeepSeek und Gemma aus. {% 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 Agenten- und Coding-Modelle sind (funktioniert auf Geräten 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) womit du LLMs unter macOS, Linux und Windows ausführen/bereitstellen kannst. 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, während die Genauigkeit erhalten bleibt. {% endcolumn %} {% column width="41.666666666666664%" %}

{% endcolumn %} {% endcolumns %} Claude Code-Einrichtung 📖 Tutorial zur Einrichtung eines lokalen Modells ## 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 navigiere zu deinem Projektordner. Dann gib `claude` in die `Shell` ein, um zu beginnen. ```bash cd ~/projects/my-project claude ``` {% endtab %} {% tab title="Windows" %} #### **Claude Code installieren:** Gib in `PowerShell` ein, um Claude Code zu installieren: ```powershell irm https://claude.ai/install.ps1 | iex ``` Nach der Installation navigiere zu deinem Projektordner. Dann gib `claude` in die `powershell` ein, um zu beginnen.

cd /path/to/your/project
claude

{% endtab %} {% endtabs %} ### :detective:Behebung einer um 90 % langsameren Inferenz in Claude Code {% hint style="warning" %} Claude Code stellt neuerdings voran und fügt einen Claude-Code-Attribution-Header hinzu, der **den KV-Cache ungültig macht, wodurch die Inferenz mit lokalen Modellen 90 % langsamer wird**. {% endhint %} Die Attribution ist eine Zeile, die dem **Beginn des System-Prompts** (`x-anthropic-billing-header: cc_version=...; cch=...;`) dessen Wert sich bei jeder Anfrage ändert, sodass der gesamte Prompt-Präfix bei jeder Runde den KV-Cache verfehlt. Die einfachste Lösung besteht darin, es direkt beim Start von Claude Code inline 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 berücksichtigen auch `export CLAUDE_CODE_ATTRIBUTION_HEADER=0`; ältere Builds ignorierten die Shell-Variable, daher ist die `--settings` oben gezeigte Form (oder die unten stehende Einstellungsdatei) die zuverlässige Wahl. {% endhint %} Um es dauerhaft zu machen, füge `CLAUDE_CODE_ATTRIBUTION_HEADER` auf 0 gesetzt in `"env"` in `~/.claude/settings.json`. Zum Beispiel: `cat > ~/.claude/settings.json` und füge dann das Folgende hinzu (beim Einfügen ENTER drücken, dann mit CTRL+D 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 Einstellungsdatei unverändert.

{
  "promptSuggestionEnabled": false,
  "env": {
    "CLAUDE_CODE_ENABLE_TELEMETRY": "0",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
    "CLAUDE_CODE_ATTRIBUTION_HEADER" : "0"
  },
  "attribution": {
    "commit": "",
    "pr": ""
  },
  "plansDirectory" : "./plans",
  "prefersReducedMotion" : true,
  "terminalProgressBarEnabled" : false,
  "effortLevel" : "high"
}

## 📖 Schnellstart-Tutorials {% columns %} {% column %} Bevor wir beginnen, müssen wir zuerst die Einrichtung für das spezifische 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 einzigartiges selbstheilendes [Tool-Calling](/docs/de/neu/studio/chat.md#auto-healing-tool-calling) und [Websuche](/docs/de/neu/studio/chat.md#code-execution) Fähigkeiten. Siehe rechts Claude Code, verbunden mit Unsloth: {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} Verbinde Claude Code 🦥 Unsloth-Tutorial llama.cpp-Tutorial ## 🦥 Unsloth-Tutorial Für dieses Tutorial werden wir lokale Modelle über eine UI mit Claude Code verbinden/bereitstellen, 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 * [**Selbstheilendes** Tool-Calling](/docs/de/neu/studio.md#execute-code--heal-tool-calling) + **Websuche** * [**Code-Ausführung**](/docs/de/neu/studio.md#run-models-locally) (Python, Bash) * [Automatische Inferenz](https://unsloth.ai/docs/desktop#feature-deep-dive) Parameterauswahl (temp, top-p usw.) * Schnelle CPU- und GPU-Inferenz über llama.cpp * [LLMs trainieren](/docs/de/neu/studio.md#no-code-training) 2x schneller mit 70 % weniger VRAM Siehe unten für die Installationsanweisungen: {% endcolumn %} {% column %}

Beispiel für ein in Unsloth laufendes 2-Bit-Qwen3.6.

{% 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/loslegen/install/mac.md), Linux, [Windows](/docs/de/loslegen/install/windows-installation.md), [NVIDIA](/docs/de/loslegen/install/pip-install.md), [AMD](/docs/de/loslegen/install/amd.md), Intel- und CPU-Setups. Unsloth herunterladen * [Für macOS herunterladen](https://unsloth.ai/download/mac) * [Für Windows herunterladen](https://unsloth.ai/download/windows) * [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 das Unsloth-Installationsprogramm (`.dmg`, `.exe` -Dateien) 2. Ziehe Unsloth auf dem Mac in den Ordner „Programme“ oder schließe die Einrichtung unter Windows ab. 3. Starte die App und warte, bis die Installation abgeschlossen ist {% endstep %} {% step %} #### Wähle ein Modell Öffne oben im Dropdown „Modell auswählen“ oder den Tab „Model Hub“, wähle ein Modell und eine Quantisierung, die zu deinem Gerät passt, und lade es dann herunter. Sobald der Download abgeschlossen ist, kannst du mit dem Chatten beginnen – keine Einrichtung erforderlich.

{% endstep %} {% step %} #### Unsloth ist jetzt bereit Um mit dem Chatten zu beginnen, gib 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 generieren:** Bilder, Videos und TTS lokal erstellen und trainieren

{% endstep %} {% endstepper %} ### Leitfaden zum Laden von Modellen + API {% stepper %} {% step %} #### Modell auswählen Bevor du die API verwendest, lade ein Modell aus dem **Modell auswählen** Dropdown-Menü oben links auf der Chat-Seite.

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:

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

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 \ --reasoning-effort medium ``` {% hint style="success" %} Wenn keine Einstellungs-/Sampling-Flags gesetzt sind, wählt Unsloth automatisch die besten/empfohlenen Einstellungen für das Modell aus, einschließlich Kontextlänge, Temperatur usw. {% endhint %} Mit einem in Unsloth Studio geladenen Modell öffne deinen Projektordner und führe aus: ```bash unsloth start claude ```

Claude Code connected to a local model through Unsloth Studio — Claude Code läuft gegen das in Unsloth Studio geladene Modell.

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 unverändert. Claude Code speichert Unterhaltungen bereits in seinem normalen Sitzungsspeicher, daher `--persist` ist nicht nötig. 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 es lieber manuell einrichten 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:** Setze die lokale API-URL: ```bash export ANTHROPIC_BASE_URL="http://localhost:8888" ``` Kopiere deinen Schlüssel aus Unsloth Studio → Settings → API (oder aus der Konsole, wenn du es startest mit `unsloth run`, wo er ausgegeben wird als `sk-unsloth-...`), 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` (denselben String, den du an `claude --model`). {% endtab %} {% tab title="Windows" %} **Konfiguration:** Setze die lokale API-URL in PowerShell: ```powershell $env:ANTHROPIC_BASE_URL = "http://localhost:8888" ``` Kopiere deinen Schlüssel aus **Unsloth Studio → Settings → API**, und setze ihn dann: ```powershell $env:ANTHROPIC_AUTH_TOKEN = "sk-unsloth-xxxxxxxxxxxx" ``` **Optional:** Verwende den Namen des aktuell in Unsloth geladenen Modells als Standard. ```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 %} ### Starte Claude Code Starte Claude Code mit dem Modell, das derzeit in Unsloth geladen ist. Wir werden verwenden `gemma-4-26B-A4B-it-GGUF`, 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 Geschwindigkeitsschub 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.

{% hint style="warning" %} Siehe [#fixing-90-slower-inference-in-claude-code](#fixing-90-slower-inference-in-claude-code "mention") zuerst, um zu beheben, dass offene Modelle wegen der KV-Cache-Invalidierung 90 % langsamer sind. {% endhint %} Verwende diesen Prompt, 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 ist es. Nutze die Websuche, um 10 echte Instruction/Chat/SFT-Datensätze auf Hugging Face zu finden, fasse deine Ergebnisse kurz zusammen und erkläre während der Recherche, warum jeder Datensatz für SFT relevant ist; erstelle dann sft_report.md als sauber ausgearbeiteten Markdown-Bericht mit Rang, Datensatzname, Ersteller, 3–5 relevanten Tags, einer kurzen verständlichen Zusammenfassung und dem Grund, 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 Datensatz-Einträge enthält, und ende mit: „Erfolgreich ein Modell mit Unsloth feinabgestimmt!“ ``` {% endcode %} Nachdem du den Prompt abgeschickt hast, durchsucht der Agent das Web, bewertet die Ergebnisse und schreibt den Abschlussbericht. Das kann ein paar Minuten dauern. Einige Workflows erfordern möglicherweise, dass du Aktionen genehmigst oder Folgeaufforderungen beantwortest.

{% hint style="info" %} Einige Workflows erfordern möglicherweise, dass du Aktionen genehmigst oder Folgeaufforderungen beantwortest. {% endhint %} Sobald es abgeschlossen ist, wird die generierte `sft_report.md` so ähnlich aussehen.

{% hint style="warning" %} Wenn du `Unable to connect to API (ConnectionRefused)` siehst, denke daran, unset zu machen `ANTHROPIC_BASE_URL` über `unset ANTHROPIC_BASE_URL` Wenn du feststellst, dass offene Modelle 90 % langsamer sind, [sieh dir zuerst hier an](#fixing-90-slower-inference-in-claude-code) um die Ungültigmachung des KV-Caches zu beheben. {% endhint %} ### Optional: den System-Prompt verkleinern Claude Code wurde für die gehosteten Modelle von Anthropic entwickelt, daher ist sein Standard-System-Prompt groß. Bei lokalen Modellen kannst du ihn für schnellere Antworten und bessere Wiederverwendung des KV-Caches verkleinern, 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 und Datei lesen/bearbeiten), und `--exclude-dynamic-system-prompt-sections` verschiebt maschinenspezifische Abschnitte aus dem Prompt-Präfix. Beides verkleinert den Prompt und verbessert die Wiederverwendung des KV-Caches, wodurch lokale Modelle spürbar schneller werden. Sie sind optional und ändern die oben beschriebene Verbindungseinrichtung nicht. {% endhint %} ### Optional: Den Unsloth-Server anpassen Claude Code verwendet das in Unsloth laufende Modell. Du kannst anpassen, wie sich der Server beim Start verhält. ```bash # Für einen Coding-Agenten bereitstellen: --disable-tools reicht die eigenen Tools des Agenten durch unsloth run \ --model unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL \ --disable-tools \\ --reasoning off \\ -p 8888 ``` {% hint style="warning" %} Verwende `--disable-tools` beim Steuern von Claude Code (oder jedem externen Coding-Agenten). Standardmäßig führt Unsloth Studio seine eigenen serverseitigen Tools aus, wodurch die Tool-Aufrufe des Agenten verschluckt werden, sodass Claude Code antwortet, aber niemals Dateien bearbeitet. `--disable-tools` wechselt zu Passthrough, sodass die eigenen Write/Edit/Bash-Tools von Claude Code 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:UD-Q4_K_XL \ -H 0.0.0.0 \ -p 8888 ``` Dies startet den Server auf `0.0.0.0:8888`, sodass andere Geräte in Ihrem lokalen Netzwerk eine Verbindung herstellen können. Verwende `-p` um den Port zu ändern, auf dem der Server läuft. Verwende `-H 0.0.0.0` wenn du möchtest, dass sich Telefone, Laptops oder andere Geräte in deinem Netzwerk verbinden. Für eine erweiterte Laufzeitkonfiguration siehe den Abschnitt [API-Tuning](https://unsloth.ai/docs/basics/api#unsloth-run-command) . ## 🦙 Llama.cpp-Tutorial Bevor wir beginnen, müssen wir zuerst die Einrichtung für das spezifische 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` womit du LLMs effizient bereitstellen und deployen kannst. Das Modell wird auf Port 8001 bereitgestellt, wobei alle Agent-Tools über einen einzigen OpenAI-kompatiblen Endpunkt geleitet werden. #### Qwen3.5-Tutorial Wir werden verwenden [Qwen3.5](/docs/de/modelle/qwen3.5.md)-35B-A3B und bestimmte Einstellungen für schnelle, genaue Coding-Aufgaben. Wenn du nicht genug VRAM hast und ein **intelligenteres** Modell **Qwen3.5-27B** ist eine gute 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 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, was fantastisch ist, wenn du genug VRAM hast. {% endhint %} {% stepper %} {% step %} #### llama.cpp installieren Wir müssen `llama.cpp` um lokale LLMs bereitzustellen/zu servieren und sie in Claude Code usw. zu verwenden. Wir folgen den offiziellen Build-Anweisungen für korrekte GPU-Bindings und maximale Leistung. Ändere `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn du keine GPU hast oder nur CPU-Inferenz möchtest. **Für Apple-Mac-/Metal-Geräte**, setze `-DGGML_CUDA=OFF` 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 ```

{% endstep %} {% step %} #### Modelle lokal herunterladen und verwenden Lade das Modell herunter über `huggingface_hub` in Python (nach der Installation via `pip install huggingface_hub hf_transfer`). Wir verwenden die **UD-Q4\_K\_XL** Quantisierung für das beste Verhältnis von Größe und Genauigkeit. Du findest alle Unsloth-GGUF-Uploads in unserer [Sammlung hier](/docs/de/loslegen/unsloth-model-catalog.md). Wenn Downloads hängen bleiben, siehe [Hugging Face Hub, XET-Debugging](/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 ```

{% hint style="success" %} Wir haben `unsloth/Qwen3.5-35B-A3B-GGUF` , 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 %}

{% endstep %} {% step %} #### Starte den Llama-Server Um Qwen3.5 für agentische Workloads bereitzustellen, verwenden wir `llama-server`. Wir wenden [Qwens empfohlene Sampling-Parameter](/docs/de/modelle/qwen3.5.md#recommended-settings) für den Thinking-Modus an: `temp 0.6`, `top_p 0.95` , `top-k 20`. Beachte, dass sich diese Werte ändern, wenn du den Non-Thinking-Modus oder andere Aufgaben verwendest. Führe diesen Befehl in einem neuen Terminal aus (verwende `tmux` oder öffne ein neues Terminal). Das Folgende sollte **passt perfekt in eine 24-GB-GPU (RTX 4090) (nutzt 23 GB)** `--fit auf` wird ebenfalls automatisch auslagern, aber wenn du schlechte Leistung siehst, reduziere `--ctx-size` . {% hint style="info" %} Wir haben `--cache-type-k q8_0 --cache-type-v q8_0` für die KV-Cache-Quantisierung, um weniger VRAM zu verbrauchen. Für volle Präzision verwende `--cache-type-k bf16 --cache-type-v bf16` .Hinweis: Der bf16-KV-Cache könnte 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 Thinking 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}"`

{% endhint %} {% endstep %} {% endstepper %} ### Starte Claude Code mit llama-server {% hint style="success" %} Wir haben `unsloth/GLM-4.7-Flash-GGUF` verwendet, aber du kannst alles verwenden 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 zu beheben, dass offene Modelle wegen der KV-Cache-Invalidierung 90 % langsamer sind. {% endhint %} Navigiere zu deinem 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 ```

Um Claude Code so einzustellen, dass Befehle ohne jegliche Genehmigungen ausgeführt werden, mache **(ACHTUNG: Dadurch wird Claude Code Code nach Belieben ausführen, ohne irgendeine Genehmigung!)** {% code overflow="wrap" %} ```bash claude --model unsloth/GLM-4.7-Flash --dangerously-skip-permissions ``` {% endcode %} Probiere diese Eingabeaufforderung aus, um ein einfaches Unsloth-Finetuning zu installieren und auszuführen: {% code overflow="wrap" %} ``` Du darfst nur im aktuellen Arbeitsverzeichnis project/ arbeiten. Suche nicht nach CLAUDE.md - das ist es. Installiere Unsloth über eine virtuelle Umgebung mit uv. Verwende `python -m venv unsloth_env` und dann `source unsloth_env/bin/activate`, falls möglich. Siehe https://unsloth.ai/docs/get-started/install/pip-install für die Vorgehensweise (rufe sie auf und lies sie). Führe dann einen einfachen Unsloth-Finetuning-Lauf aus, wie in https://github.com/unslothai/unsloth beschrieben. Dir steht 1 GPU zur Verfügung. ``` {% endcode %}

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

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