> 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/api/claude-code.md). # Claude Code Leitfaden zur Verwendung offener Modelle mit Claude Code auf deinem 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. Verwende dafür beliebige offene Modelle 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 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) das es dir ermöglicht, LLMs auf macOS, Linux und Windows auszuführen bzw. 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%" %}

Claude Code, lokal mit Qwen3.5 ausgeführt.

{% endcolumn %} {% endcolumns %} Claude Code-Einrichtung 📖 Tutorial: Lokales Modell 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 mit 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 ``` Wechsle nach der Installation in deinen Projektordner. Gib dann `claude` in die `Shell` ein, um zu beginnen. ```bash cd ~/projects/my-project claude ``` {% endtab %} {% tab title="Windows" %} #### **Claude Code installieren:** Gib Folgendes in `PowerShell` ein, um Claude Code zu installieren: ```powershell irm https://claude.ai/install.ps1 | iex ``` Wechsle nach der Installation in deinen Projektordner. Gib dann `claude` in die `powershell` ein, um zu beginnen.

cd /path/to/your/project
claude

{% endtab %} {% endtabs %} ### :detective:90 % langsamere Inferenz in Claude Code beheben {% 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 um 90 % langsamer wird**. {% endhint %} Die Attribution ist eine Zeile, die dem **Anfang des System-Prompts hinzu** (`x-anthropic-billing-header: cc_version=...; cch=...;` vorangestellt wird und deren Wert sich bei jeder Anfrage ändert, sodass der gesamte Prompt-Präfix bei jedem Durchlauf den KV-Cache verfehlt. Die einfachste Lösung besteht darin, 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` -Variante oben (oder die Einstellungsdatei unten) die zuverlässige Wahl. {% endhint %} Um das 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 (wenn eingefügt, drücke ENTER und dann STRG+D, um es zu speichern). Wenn du bereits eine `~/.claude/settings.json` Datei hast, füge einfach `"CLAUDE_CODE_ATTRIBUTION_HEADER" : "0"` zum "env"-Abschnitt 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 spezielle 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 Hosten von LLMs auf deinen Geräten mit Mac, Linux und Windows sind. Unsloth hat außerdem einzigartige selbstheilende [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 %} Claude Code verbinden 🦥 Unsloth-Tutorial llama.cpp-Tutorial ## 🦥 Unsloth-Tutorial Für dieses Tutorial werden wir lokale Modelle über eine UI an Claude Code anbinden/mit ihm verbinden, 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- + GPU-Inferenz über llama.cpp * [LLMs trainieren](/docs/de/neu/studio.md#no-code-training) 2x schneller mit 70 % weniger VRAM Siehe unten die Installationsanweisungen: {% endcolumn %} {% column %}

Beispiel für Qwen3.6 2-bit, das in Unsloth läuft.

{% 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 * [Download für macOS](https://unsloth.ai/download/mac) * [Download für Windows](https://unsloth.ai/download/windows) * [Download für Linux](https://unsloth.ai/download/linux) Oder, wenn Sie eine 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 das Unsloth-Installationsprogramm (`.dmg`, `.exe` Dateien) 2. Ziehen Sie Unsloth unter macOS 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ähle ein Modell Öffnen Sie das Dropdown „Select model“ oben oder die Registerkarte „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 mit dem Chatten beginnen – 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/api/claude-code.md), [Codex](/docs/de/grundlagen/api/codex.md), Websuche, [MCP](/docs/de/desktop/mcp.md) und mehr * **Modelle trainieren:** Feinabstimmung von Text, Diffusion, Embeddings und mehr * **Medien generieren:** Bilder, Videos und TTS lokal erstellen und trainieren

{% endstep %} {% endstepper %} ### Leitfaden zum Laden von Modellen + API {% stepper %} {% step %} #### Modell auswählen Bevor Sie die API verwenden, laden Sie ein Modell über das **Select model** Dropdown-Menü in der oberen linken Ecke 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 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 mittel ``` {% 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 %} Wenn ein Modell in Unsloth Studio geladen ist, öffnen Sie Ihren Projektordner und führen Sie 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 Sitzungs-Speicher, daher `--persist` ist nicht nötig. 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 → Settings → API (oder aus der Konsole, wenn du es mit `unsloth run`startest, 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` angezeigt wird (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 → 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 %} ### Claude Code starten Starte Claude Code mit dem Modell, das derzeit 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 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.

{% 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 %} Versuche diesen Prompt, um hochwertige SFT-Datensätze zu recherchieren und zu ranken: {% 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 bei deiner Recherche, warum jeder Datensatz für SFT relevant ist. Erstelle dann sft_report.md als ausgefeilten Markdown-Bericht mit dem Rang, dem Datensatznamen, dem Ersteller, 3–5 relevanten Tags, einer kurzen Zusammenfassung in einfachem Englisch 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 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 finalen 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 Folge-Prompts beantwortest. {% endhint %} Nach Abschluss wird die generierte `sft_report.md` etwa so aussehen.

{% hint style="warning" %} Wenn du siehst `Verbindung zur API nicht möglich (ConnectionRefused)` denke daran, `ANTHROPIC_BASE_URL` über `unset ANTHROPIC_BASE_URL` Wenn dir auffällt, dass offene Modelle 90 % langsamer sind, [sieh dir zuerst hier an](#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 verkleinern, um schnellere Antworten und eine bessere KV-Cache-Wiederverwendung zu erhalten, 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 machinespezifische Abschnitte aus dem Prompt-Präfix. Beides verkleinert den Prompt und verbessert die KV-Cache-Wiederverwendung, wodurch lokale Modelle spürbar schneller werden. Sie sind optional und ändern die oben beschriebene Verbindungs-einrichtung 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: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, die die Tool-Aufrufe des Agents schlucken, sodass Claude Code antwortet, aber nie Dateien bearbeitet. `--disable-tools` schaltet auf Passthrough um, 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 in deinem lokalen Netzwerk freigeben unsloth run \ --model unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL \ -H 0.0.0.0 \ -p 8888 ``` Dadurch startet der Server auf `0.0.0.0:8888`, sodass sich andere Geräte in deinem lokalen Netzwerk verbinden 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 Telefone, Laptops oder andere Geräte in deinem Netzwerk sich verbinden können. Für eine erweiterte Laufzeitkonfiguration siehe die Haupt- [API-Abstimmung](https://unsloth.ai/docs/basics/api#unsloth-run-command) Abschnitt. ## 🦙 Llama.cpp-Tutorial Bevor wir beginnen, müssen wir zuerst die Einrichtung für das spezielle Modell abschließen, das du verwenden wirst. Wir verwenden `llama.cpp` das ist ein Open-Source-Framework zum Ausführen von LLMs auf deinen Mac-, Linux-, Windows- usw\.-Geräten. Llama.cpp enthält `llama-server` das es dir 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, präzise Coding-Aufgaben verwenden. Wenn du nicht genug VRAM hast und ein **intelligenteres** model, **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 nicht genug VRAM hast. Es wird jedoch etwa 2x langsamer sein als 35B-A3B. Oder du kannst [**Qwen3-Coder-Next**](/docs/de/modelle/tutorials/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 bzw. zu serven, 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 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 über `huggingface_hub` in Python herunter (nach der Installation über `pip install huggingface_hub hf_transfer`). Wir verwenden den **UD-Q4\_K\_XL** Quant für das beste Verhältnis von Größe und Genauigkeit. Du findest alle Unsloth-GGUF-Uploads in unserem [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*" # Verwenden Sie "*UD-Q2_K_XL*" für dynamisches 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/tutorials/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 [von Qwen 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 Nicht-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) (verwendet 23 GB)** `--fit on` wird ebenfalls automatisch ausgelagert, aber wenn du eine schlechte Leistung feststellst, reduziere `--ctx-size` . {% hint style="info" %} Wir haben `--cache-type-k q8_0 --cache-type-v q8_0` für KV-Cache-Quantisierung, um weniger VRAM zu verwenden. Für volle Präzision verwende `--cache-type-k bf16 --cache-type-v bf16` . Hinweis: Der bf16-KV-Cache kann auf einigen 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 bei Qwen3.5 auch deaktivieren, was die Leistung bei agentischem Coding verbessern kann. Um das Thinking mit llama.cpp zu deaktivieren, füge dies dem 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 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 zu beheben, dass offene Modelle wegen der KV-Cache-Invalidierung 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 jegliche Genehmigungen ausgeführt werden, tue **(ACHTUNG: Dadurch wird Claude Code Code nach Belieben ausführen und ausführen, ohne jegliche Genehmigungen!)** {% 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 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 (hol es und lies es). Führe dann einen einfachen Unsloth-Finetuning-Lauf durch, der in https://github.com/unslothai/unsloth beschrieben ist. Du hast Zugriff auf 1 GPU. ``` {% endcode %}

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

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