> 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ühren Sie lokale LLMs mit Claude Code aus Leitfaden zur Verwendung offener Modelle mit Claude Code auf Ihrem lokalen Gerät. Diese Schritt-für-Schritt-Anleitung zeigt dir mit Screenshots, wie du offene LLMs und APIs vollständig lokal mit Claude Code verbindest. 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 agentische 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/servieren kannst. Du kannst jedes andere Modell verwenden. Für Modell-Quantisierungen nutzen wir Unsloth [Dynamische GGUFs](/docs/de/grundlagen/dynamic-3.0-ggufs.md) um jedes quantisierte LLM auszuführen und dabei die Genauigkeit zu erhalten. {% endcolumn %} {% column width="41.666666666666664%" %}

Claude Code, der lokal mit Qwen3.5 läuft.

{% endcolumn %} {% endcolumns %} Claude Code-Einrichtung 📖 Tutorial zur lokalen Modelle einrichten ## 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 verarbeitet. {% 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. Dann tippe `claude` in die `Shell` um zu beginnen. ```bash cd ~/projects/my-project claude ``` {% endtab %} {% tab title="Windows" %} #### **Claude Code installieren:** Wechsle in `PowerShell` um Claude Code zu installieren: ```powershell irm https://claude.ai/install.ps1 | iex ``` Nach der Installation wechsle in deinen Projektordner. Dann tippe `claude` in die `powershell` um zu beginnen.

cd /path/to/your/project
claude

{% endtab %} {% endtabs %} ### :detective:Behebung von 90 % langsamerer Inferenz in Claude Code {% hint style="warning" %} Claude Code fügt neuerdings 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 vorangestellt wird an den **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 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 berücksichtigen auch `export CLAUDE_CODE_ATTRIBUTION_HEADER=0`; ältere Builds ignorierten die Shell-Variable, daher ist die `--settings` Form oben (oder die Einstellungsdatei unten) 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` hinzu. Zum Beispiel: `cat > ~/.claude/settings.json` dann füge das untenstehende ein (beim Einfügen ENTER drücken, dann STRG+D zum Speichern). Falls 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 zunächst die Einrichtung für das konkrete Modell abschließen, das Sie verwenden werden. Wir verwenden [Unsloth](/docs/de/neu/studio.md) (eine Web-UI) und llama.cpp, beides Open-Source-Frameworks zum Ausführen und Bereitstellen von LLMs auf Ihren Mac-, Linux- und Windows-Geräten. Unsloth verfügt außerdem über einzigartige selbstheilende [Tool-Calling](/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 %}

{% endcolumn %} {% endcolumns %} Claude Code verbinden 🦥 Unsloth-Tutorial llama.cpp-Tutorial ## 🦥 Unsloth-Tutorial Für dieses Tutorial werden wir lokale Modelle über eine UI mit Claude Code bereitstellen/verbinden, indem wir [Unsloth](https://github.com/unslothai/unsloth). 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 * [**Selbstheilend** Tool-Aufrufe](/docs/de/neu/studio.md#execute-code--heal-tool-calling) + **Websuche** * [**Codeausfü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 Installationsanweisungen finden Sie unten: {% endcolumn %} {% column %}

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

{% 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. 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 Sie die manuelle Installation bevorzugen: **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. Öffnen Sie den Unsloth-Installer (`.dmg`, `.exe` Dateien) 2. Ziehen Sie Unsloth auf dem Mac in den Ordner „Programme“ oder schließen Sie die Einrichtung unter Windows ab. 3. Starten Sie die App und warten Sie, bis die Installation abgeschlossen ist {% endstep %} {% step %} #### Wählen Sie ein Modell Öffnen Sie oben das Dropdown-Menü „Modell auswählen“ oder den Tab „Model Hub“, wählen Sie ein Modell und eine Quantisierung, die zu Ihrem Gerät passt, und laden Sie es dann herunter. Sobald der Download abgeschlossen ist, können Sie chatten – keine Einrichtung erforderlich.

{% endstep %} {% step %} #### Unsloth ist jetzt bereit Um mit dem Chatten zu beginnen, geben Sie eine Nachricht ein und drücken Sie 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, Video, TTS lokal erstellen und trainieren

{% endstep %} {% endstepper %} ### Anleitung zum Laden von Modellen und zur API {% stepper %} {% step %} #### Modell auswählen Bevor Sie die API verwenden, laden Sie 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 Sie den Client verwenden, senden Sie eine kurze Nachricht:

{% hint style="info" %} Dies bestätigt, dass das Modell korrekt geladen wurde und bereit ist zu antworten. {% endhint %} {% endstep %} {% step %} #### **Unsloth-API-Schlüssel** Öffnen Sie in Unsloth **Einstellungen → API** um deinen API-Schlüssel anzuzeigen oder zu erstellen.

Behandeln Sie Ihren API-Schlüssel wie ein Passwort und vermeiden Sie es, 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 herstellen oder sie [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 Einstellungen-/Sampling-Flags gesetzt sind, wählt Unsloth automatisch die besten/empfohlenen Einstellungen für das Modell aus, einschließlich Kontextlänge, Temperatur usw. {% endhint %} Öffne bei einem in Unsloth Studio geladenen Modell deinen Projektordner und führe Folgendes aus: ```bash unsloth start claude ```

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

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` nicht benötigt. Fahre mit deiner neuesten 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 → Einstellungen → API (oder aus der Konsole, wenn du es startest mit `unsloth run`, wo er angezeigt wird als `sk-unsloth-...`), und setze ihn dann. {% code overflow="wrap" %} ```bash export ANTHROPIC_AUTH_TOKEN="sk-unsloth-xxxxxxxxxxxx" ``` {% endcode %} Setze außerdem einen leeren `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:** Setze die lokale API-URL in PowerShell: ```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 als Standard. ```powershell $env:ANTHROPIC_MODEL = "gemma-4-26B-A4B-it-GGUF" ``` {% hint style="info" %} Der Modellname sollte das Modell sein, das aktuell in Unsloth Studio geladen ist. {% endhint %} {% endtab %} {% endtabs %} ### Claude Code starten Starte Claude Code mit dem Modell, das aktuell in Unsloth geladen ist. Wir 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: 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 aufgrund einer KV-Cache-Ungültigkeit 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 ist es. Verwende die Websuche, um 10 echte Instruktions-/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 ausgefeilten Markdown-Bericht mit Rang, Datensatzname, Ersteller, 3–5 relevanten Tags, einer kurzen Zusammenfassung in einfachem Englisch und einer Erklärung, 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 beende mit: „Successfully finetuned a model with Unsloth!" ``` {% endcode %} Nachdem du den Prompt abgeschickt hast, durchsucht der Agent das Web, bewertet die Ergebnisse und schreibt den endgültigen Bericht. Das kann ein paar Minuten dauern. Einige Workflows erfordern möglicherweise, dass du Aktionen genehmigst oder Folge-Prompts beantwortest.

{% hint style="info" %} Einige Workflows erfordern möglicherweise, dass du Aktionen genehmigst oder Follow-up-Prompts beantwortest. {% endhint %} Sobald abgeschlossen, wird die erzeugte `sft_report.md` ähnlich aussehen wie dies.

{% hint style="warning" %} Wenn du `Verbindung zur API nicht möglich (ConnectionRefused)` siehst, denke daran, `ANTHROPIC_BASE_URL` über `unset ANTHROPIC_BASE_URL` Wenn dir auffällt, dass offene Modelle 90 % langsamer sind, [sieh zuerst hier 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 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 KV-Cache-Wiederverwendung 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 sowie Datei-Lesen/Bearbeiten), und `--exclude-dynamic-system-prompt-sections` verschiebt systemspezifische Abschnitte aus dem Prompt-Präfix heraus. Beides verkleinert den Prompt und verbessert die KV-Cache-Wiederverwendung, wodurch lokale Modelle spürbar schneller werden. 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 beim Start anpassen, wie sich der Server verhält. ```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:UD-Q4_K_XL \ --disable-tools \ --reasoning off \ -p 8888 ``` {% hint style="warning" %} Verwende `--disable-tools` wenn du Claude Code (oder einen anderen externen Coding-Agenten) steuerst. Standardmäßig führt Unsloth Studio seine eigenen serverseitigen Tools aus, wodurch die Tool-Aufrufe des Agents geschluckt werden, sodass Claude Code antwortet, aber niemals Dateien bearbeitet. `--disable-tools` schaltet auf Passthrough um, sodass Claude Codes 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 freigeben 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 zu ändern, auf welchem Port 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 können. Für eine fortgeschrittenere Laufzeitkonfiguration siehe den Abschnitt [API-Tuning](https://unsloth.ai/docs/basics/api#unsloth-run-command) . ## 🦙 Llama.cpp-Tutorial Bevor wir beginnen, müssen wir zunächst die Einrichtung für das konkrete Modell abschließen, das Sie verwenden werden. Wir verwenden `llama.cpp` das ein Open-Source-Framework zum Ausführen von LLMs auf deinen Geräten mit Mac, Linux, Windows usw. ist. Llama.cpp enthält `llama-server` wodurch 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 [Qwen3.5](/docs/de/modelle/qwen3.5.md)-35B-A3B und spezifische Einstellungen für schnelle, genaue Coding-Aufgaben verwenden. 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 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, 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, die du in Claude Code usw. verwenden kannst. 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 nur 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 ```

{% endstep %} {% step %} #### Modelle lokal herunterladen und verwenden Lade das Modell über `huggingface_hub` in Python herunter (nach der Installation über `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/erste-schritte/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*" # Verwenden Sie "*UD-Q2_K_XL*" für Dynamic 2-Bit ```

{% hint style="success" %} Wir haben `unsloth/Qwen3.5-35B-A3B-GGUF` , aber du kannst eine andere Variante wie 27B oder jedes andere 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 keinen 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) (verbraucht 23 GB)** `--fit on` 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 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 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 zum llama-server-Befehl hinzu: `--chat-template-kwargs "{\"enable_thinking\": false}"`

{% endhint %} {% endstep %} {% endstepper %} ### Claude Code mit llama-server starten {% hint style="success" %} Wir haben `unsloth/GLM-4.7-Flash-GGUF` , 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 aufgrund einer KV-Cache-Ungültigkeit 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 ```

Um Claude Code so einzustellen, dass Befehle ohne Genehmigungen ausgeführt werden, mache **(ACHTUNG: Dadurch führt Claude Code Code nach Belieben aus und führt ihn ohne jegliche Genehmigungen aus!)** {% code overflow="wrap" %} ```bash claude --model unsloth/GLM-4.7-Flash --dangerously-skip-permissions ``` {% endcode %} Probiere diesen Prompt, um ein einfaches Unsloth-Finetuning zu installieren und auszuführen: {% code overflow="wrap" %} ``` Du darfst nur im Arbeitsverzeichnis project/ arbeiten. Suche nicht nach CLAUDE.md - das 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 (hole es und lies es). Führe dann einen einfachen Unsloth-Finetuning-Lauf aus, der in https://github.com/unslothai/unsloth beschrieben ist. Du hast Zugriff auf 1 GPU. ``` {% endcode %}

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

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