> 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/modelle/tutorials/qwen3-coder-how-to-run-locally.md). # Qwen3-Coder: So wird es lokal ausgeführt Qwen3-Coder ist Qwens neue Reihe von Coding-Agent-Modellen, verfügbar in 30B (**Qwen3-Coder-Flash**) und 480B Parametern. **Qwen3-480B-A35B-Instruct** erreicht eine SOTA-Coding-Performance und konkurriert mit Claude Sonnet-4, GPT-4.1 und [Kimi K2](/docs/de/modelle/tutorials/kimi-k2-thinking-how-to-run-locally.md), mit 61,8 % auf Aider Polygot und Unterstützung für einen 256K- (auf 1M erweiterbaren) Token-Kontext. Wir haben Qwen3-Coder außerdem mit nativer **1M-Kontextlänge** hochskaliert mit YaRN sowie vollständigen 8-Bit- und 16-Bit-Versionen hochgeladen. [Unsloth](https://github.com/unslothai/unsloth) unterstützt jetzt auch Fine-Tuning und [RL](/docs/de/loslegen/reinforcement-learning-rl-guide.md) von Qwen3-Coder. {% hint style="success" %} [**UPDATE:** Wir haben das Tool-Calling für Qwen3-Coder behoben! ](#tool-calling-fixes)Ihr könnt Tool-Calling jetzt nahtlos in llama.cpp, Ollama, LMStudio, Open WebUI, Jan usw. verwenden. Dieses Problem war universell und betraf alle Uploads (nicht nur Unsloth), und wir haben die Qwen-Team über unsere Korrekturen informiert! [Mehr lesen](#tool-calling-fixes) {% endhint %} 30B-A3B ausführen480B-A35B ausführen {% hint style="success" %} **Funktionieren** [**Unsloth Dynamic Quants**](/docs/de/grundlagen/unsloth-dynamic-2.0-ggufs.md) **sie?** Ja, und zwar sehr gut. In unabhängigen Tests auf dem Aider-Polyglot-Benchmark kam die **UD-Q4\_K\_XL (276GB)** dynamische Quantisierung **vollständigen bf16 (960GB)** des Qwen3-Coder-Modells nahezu gleich und erreichte 60,9 % gegenüber 61,8 %. [Weitere Details hier.](https://huggingface.co/unsloth/Qwen3-Coder-480B-A35B-Instruct-GGUF/discussions/8) {% endhint %} #### **Qwen3 Coder - Unsloth Dynamic 2.0 GGUFs**: | Dynamic 2.0 GGUF (zum Ausführen) | 1M Context Dynamic 2.0 GGUF | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | | | ## 🖥️ **Qwen3-Coder ausführen** Unten sind Anleitungen für die [**30B-A3B**](#run-qwen3-coder-30b-a3b-instruct) und [**480B-A35B**](#run-qwen3-coder-480b-a35b-instruct) Varianten des Modells. ### :gear: Empfohlene Einstellungen Qwen empfiehlt für beide Modelle diese Inferenz-Einstellungen: `temperature=0.7`, `top_p=0.8`, `top_k=20`, `repetition_penalty=1.05` * **Temperatur von 0,7** * Top\_K von 20 * Min\_P von 0,00 (optional, aber 0,01 funktioniert gut; der Standardwert in llama.cpp ist 0,1) * Top\_P von 0,8 * **Wiederholungsstrafe von 1,05** * Chat-Vorlage: ``` <|im_start|>user Hey da!<|im_end|> <|im_start|>assistant Was ist 1+1?<|im_end|> <|im_start|>user 2<|im_end|> <|im_start|>assistant ``` * Empfohlene Kontextausgabe: 65.536 Tokens (kann erhöht werden). Details hier. **Chat-Vorlage/Prompt-Format mit nicht gerenderten Zeilenumbrüchen** {% code overflow="wrap" %} ``` <|im_start|>user\nHey da!<|im_end|>\n<|im_start|>assistant\nWas ist 1+1?<|im_end|>\n<|im_start|>user\n2<|im_end|>\n<|im_start|>assistant\n ``` {% endcode %} **Chat-Vorlage für Tool-Calling** (Aktuelle Temperatur für San Francisco abrufen). Weitere Details dazu, wie Tool-Aufrufe formatiert werden. ``` <|im_start|>user Wie hoch ist die Temperatur in San Francisco jetzt? Und morgen?<|im_end|> <|im_start|>assistant \n\n\nSan Francisco, CA, USA \n\n<|im_end|> <|im_start|>user {"temperature": 26.1, "location": "San Francisco, CA, USA", "unit": "celsius"} \n<|im_end|> ``` {% hint style="info" %} Zur Erinnerung: Dieses Modell unterstützt nur den Nicht-Denkmodus und erzeugt keine `` Blöcke in seiner Ausgabe. Inzwischen ist das Angeben von `enable_thinking=False` nicht mehr erforderlich. {% endhint %} ### Qwen3-Coder-30B-A3B-Instruct ausführen: Um Inferenzgeschwindigkeiten von 6+ Tokens pro Sekunde für unsere dynamische 4-Bit-Quantisierung zu erreichen, solltet ihr mindestens **18 GB Unified Memory** (kombinierter VRAM und RAM) oder **18 GB Systemspeicher** allein haben. Als Faustregel gilt: Euer verfügbarer Speicher sollte der Größe des verwendeten Modells entsprechen oder sie übertreffen. Z. B. benötigt die UD\_Q8\_K\_XL-Quantisierung (volle Präzision), die 32,5 GB groß ist, mindestens **33 GB Unified Memory** (VRAM + RAM) oder **33 GB RAM** für optimale Leistung. **HINWEIS:** Das Modell kann mit weniger Speicher als seiner Gesamtgröße ausgeführt werden, aber das verlangsamt die Inferenz. Der maximale Speicher wird nur für die höchste Geschwindigkeit benötigt. Da dies ein Nicht-Denk-Modell ist, muss man `thinking=False` nicht setzen, und das Modell erzeugt keine ` ` Blöcke. {% hint style="info" %} Befolgt die [**oben genannten Best Practices**](#recommended-settings). Sie sind dieselben wie beim 480B-Modell. {% endhint %} #### 🦙 Ollama: Tutorial zum Ausführen von Qwen3-Coder-30B-A3B-Instruct 1. Installieren `ollama` falls ihr das noch nicht getan habt! Ihr könnt nur Modelle bis zu einer Größe von 32B ausführen. ```bash apt-get update apt-get install pciutils -y curl -fsSL https://ollama.com/install.sh | sh ``` 2. Führt das Modell aus! Beachtet, dass ihr `ollama serve`in einem anderen Terminal aufrufen könnt, falls es fehlschlägt! Wir enthalten alle unsere Korrekturen und vorgeschlagenen Parameter (Temperatur usw.) in `params` in unserem Hugging-Face-Upload! ```bash ollama run hf.co/unsloth/Qwen3-Coder-30B-A3B-Instruct-GGUF:UD-Q4_K_XL ``` #### :sparkles: Llama.cpp: Tutorial zum Ausführen von Qwen3-Coder-30B-A3B-Instruct 1. Erhalten Sie das neueste `llama.cpp` standardmäßig [GitHub hier](https://github.com/ggml-org/llama.cpp). Sie können auch die Build-Anweisungen unten befolgen. Ändern Sie `-DGGML_CUDA=ON` auf `-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 üblich fort - Metal-Unterstützung ist standardmäßig aktiviert. ```bash apt-get update apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y git clone https://github.com/ggml-org/llama.cpp cmake llama.cpp -B llama.cpp/build \ -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-gguf-split cp llama.cpp/build/bin/llama-* llama.cpp ``` 2. Ihr könnt direkt von HuggingFace ziehen über: ```bash ./llama.cpp/llama-cli \ -hf unsloth/Qwen3-Coder-30B-A3B-Instruct-GGUF:Q4_K_XL \ --jinja -ngl 99 --ctx-size 32768 \ --temp 0.7 --min-p 0.0 --top-p 0.80 --top-k 20 --repeat-penalty 1.05 ``` 3. Ladet das Modell herunter über (nach der Installation von `pip install huggingface_hub hf_transfer` ). Ihr könnt UD\_Q4\_K\_XL oder andere quantisierte Versionen auswählen. Falls Downloads hängen bleiben, siehe [Hugging Face Hub, XET-Debugging](/docs/de/grundlagen/troubleshooting-and-faqs/hugging-face-hub-xet-debugging.md) ```python # !pip install huggingface_hub hf_transfer import os os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1" from huggingface_hub import snapshot_download snapshot_download( repo_id = "unsloth/Qwen3-Coder-30B-A3B-Instruct-GGUF", local_dir = "unsloth/Qwen3-Coder-30B-A3B-Instruct-GGUF", allow_patterns = ["*UD-Q4_K_XL*"], ) ``` ### Qwen3-Coder-480B-A35B-Instruct ausführen: Um Inferenzgeschwindigkeiten von 6+ Tokens pro Sekunde für unsere 1-Bit-Quantisierung zu erreichen, empfehlen wir mindestens **150 GB Unified Memory** (kombinierter VRAM und RAM) oder **150 GB Systemspeicher** allein. Als Faustregel gilt: Euer verfügbarer Speicher sollte der Größe des verwendeten Modells entsprechen oder sie übertreffen. Z. B. benötigt die Q2\_K\_XL-Quantisierung, die 180 GB groß ist, mindestens **180 GB Unified Memory** (VRAM + RAM) oder **180 GB RAM** für optimale Leistung. **HINWEIS:** Das Modell kann mit weniger Speicher als seiner Gesamtgröße ausgeführt werden, aber das verlangsamt die Inferenz. Der maximale Speicher wird nur für die höchste Geschwindigkeit benötigt. {% hint style="info" %} Befolgt die [**oben genannten Best Practices**](#recommended-settings). Sie sind dieselben wie beim 30B-Modell. {% endhint %} #### 📖 Llama.cpp: Tutorial zum Ausführen von Qwen3-Coder-480B-A35B-Instruct Für Coder-480B-A35B verwenden wir speziell Llama.cpp für optimierte Inferenz und eine Fülle von Optionen. {% hint style="success" %} Wenn ihr eine **vollständige unquantisierte Version in voller Präzision**möchtet, verwendet unsere `Q8_K_XL, Q8_0` oder `BF16` Versionen! {% endhint %} 1. Erhalten Sie das neueste `llama.cpp` standardmäßig [GitHub hier](https://github.com/ggml-org/llama.cpp). Sie können auch die Build-Anweisungen unten befolgen. Ändern Sie `-DGGML_CUDA=ON` auf `-DGGML_CUDA=OFF` wenn Sie keine GPU haben oder nur CPU-Inferenz möchten. ```bash apt-get update apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y git clone https://github.com/ggml-org/llama.cpp cmake llama.cpp -B llama.cpp/build \ -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-gguf-split cp llama.cpp/build/bin/llama-* llama.cpp ``` 2. Ihr könnt llama.cpp direkt verwenden, um das Modell herunterzuladen, aber ich empfehle normalerweise die Verwendung von `huggingface_hub` Um llama.cpp direkt zu verwenden, macht Folgendes: ```bash ./llama.cpp/llama-cli \ -hf unsloth/Qwen3-Coder-480B-A35B-Instruct-GGUF:Q2_K_XL \ --ctx-size 16384 \ --n-gpu-layers 99 \\ -ot ".ffn_.*_exps.=CPU" \ --temp 0.7 \ --min-p 0.0 \ --top-p 0.8 \ --top-k 20 \ --repeat-penalty 1.05 ``` 3. Oder ladet das Modell herunter über (nach der Installation von `pip install huggingface_hub hf_transfer` ). Ihr könnt UD-Q2\_K\_XL oder andere quantisierte Versionen auswählen.. ```python # !pip install huggingface_hub hf_transfer import os os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0" # Kann manchmal zu Rate-Limits führen, daher auf 0 setzen, um es zu deaktivieren from huggingface_hub import snapshot_download snapshot_download( repo_id = "unsloth/Qwen3-Coder-480B-A35B-Instruct-GGUF", local_dir = "unsloth/Qwen3-Coder-480B-A35B-Instruct-GGUF", allow_patterns = ["*UD-Q2_K_XL*"], ) ``` 4. Führt das Modell im Gesprächsmodus aus und probiert irgendeinen Prompt aus. 5. Bearbeiten Sie `--threads -1` für die Anzahl der CPU-Threads, `--ctx-size` 262114 für die Kontextlänge, `--n-gpu-layers 99` für GPU-Offloading, wie viele Schichten. Versucht, dies anzupassen, falls euer GPU-Speicher voll läuft. Entfernt es außerdem, wenn ihr nur CPU-Inferenz habt. {% hint style="success" %} Verwenden Sie `-ot ".ffn_.*_exps.=CPU"` um alle MoE-Schichten auf die CPU auszulagern! Dadurch könnt ihr effektiv alle Nicht-MoE-Schichten auf 1 GPU unterbringen und die Generierungsgeschwindigkeiten verbessern. Ihr könnt den Regex-Ausdruck anpassen, um mehr Schichten auszulagern, wenn ihr mehr GPU-Kapazität habt. Weitere Optionen werden diskutiert [hier](#improving-generation-speed). {% endhint %} {% code overflow="wrap" %} ```bash ./llama.cpp/llama-cli \ --model unsloth/Qwen3-Coder-480B-A35B-Instruct-GGUF/UD-Q2_K_XL/Qwen3-Coder-480B-A35B-Instruct-UD-Q2_K_XL-00001-of-00004.gguf \ --ctx-size 16384 \ --n-gpu-layers 99 \\ -ot ".ffn_.*_exps.=CPU" \ --temp 0.7 \ --min-p 0.0 \ --top-p 0.8 \ --top-k 20 \ --repeat-penalty 1.05 ``` {% endcode %} {% hint style="success" %} Vergesst auch das neue Qwen3-Update nicht. Führt [**Qwen3-235B-A22B-Instruct-2507**](/docs/de/modelle/tutorials/qwen3-next.md) lokal mit llama.cpp aus. {% endhint %} #### :tools: Die Generierungsgeschwindigkeit verbessern Wenn ihr mehr VRAM habt, könnt ihr versuchen, mehr MoE-Schichten auszulagern oder ganze Schichten selbst auszulagern. Normalerweise `-ot ".ffn_.*_exps.=CPU"` werden alle MoE-Schichten auf die CPU ausgelagert! Dadurch könnt ihr effektiv alle Nicht-MoE-Schichten auf 1 GPU unterbringen und die Generierungsgeschwindigkeiten verbessern. Ihr könnt den Regex-Ausdruck anpassen, um mehr Schichten auszulagern, wenn ihr mehr GPU-Kapazität habt. Wenn ihr etwas mehr GPU-Speicher habt, versucht `-ot ".ffn_(up|down)_exps.=CPU"` Dies lagert die Up- und Down-Projektions-MoE-Schichten aus. Versucht `-ot ".ffn_(up)_exps.=CPU"` wenn ihr noch mehr GPU-Speicher habt. Dies lagert nur die Up-Projektions-MoE-Schichten aus. Ihr könnt den Regex auch anpassen, zum Beispiel `-ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU"` bedeutet, Gate-, Up- und Down-MoE-Schichten auszulagern, aber nur ab der 6. Schicht. Der [neueste llama.cpp-Version](https://github.com/ggml-org/llama.cpp/pull/14363) führt auch einen Hochdurchsatzmodus ein. Verwendet `llama-parallel`. Lest mehr darüber [hier](https://github.com/ggml-org/llama.cpp/tree/master/examples/parallel). Ihr könnt auch **den KV-Cache auf 4 Bit quantisieren** zum Beispiel, um die VRAM-/RAM-Bewegung zu reduzieren, was den Generierungsprozess ebenfalls beschleunigen kann. #### :triangular\_ruler:So passt langer Kontext hinein (256K bis 1M) Um längeren Kontext unterzubringen, könnt ihr **KV-Cache-Quantisierung** verwenden, um die K- und V-Caches auf niedrigere Bitbreiten zu quantisieren. Dies kann auch die Generierungsgeschwindigkeit erhöhen, da weniger RAM-/VRAM-Datenbewegung anfällt. Die zulässigen Optionen für die K-Quantisierung (Standard ist `f16`) umfassen die folgenden. `--cache-type-k f32, f16, bf16, q8_0, q4_0, q4_1, iq4_nl, q5_0, q5_1` Ihr solltet die `_1` Varianten verwenden, um etwas höhere Genauigkeit zu erhalten, auch wenn es etwas langsamer ist. Zum Beispiel `q4_1, q5_1` Ihr könnt auch den V-Cache quantisieren, aber dafür müsst ihr **llama.cpp mit Unterstützung für Flash Attention kompilieren** über `-DGGML_CUDA_FA_ALL_QUANTS=ON`, und verwendet `--flash-attn` aktivieren. Wir haben über YaRN-Scaling außerdem GGUFs mit 1 Million Kontextlänge hochgeladen [hier](https://huggingface.co/unsloth/Qwen3-Coder-480B-A35B-Instruct-1M-GGUF). ## :toolbox: Korrekturen für Tool-Calling Wir haben Tool-Calling über `llama.cpp --jinja` speziell für das Bereitstellen über `llama-server`reparieren können! Wenn ihr unsere 30B-A3B-Quantisierungen herunterladet, müsst ihr euch keine Sorgen machen, da diese unsere Korrekturen bereits enthalten. Für das 480B-A35B-Modell bitte: 1. Ladet die erste Datei unter für UD-Q2\_K\_XL herunter und ersetzt eure aktuelle Datei 2. Verwenden Sie `snapshot_download` wie gewohnt wie in , wodurch die alten Dateien automatisch überschrieben werden 3. Verwendet die neue Chat-Vorlage über `--chat-template-file`. Siehe [GGUF-Chat-Vorlage](https://huggingface.co/unsloth/Qwen3-Coder-480B-A35B-Instruct-GGUF?chat_template=default) oder [chat\_template.jinja](https://huggingface.co/unsloth/Qwen3-Coder-480B-A35B-Instruct/raw/main/chat_template.jinja) 4. Als Zusatz haben wir auch eine einzelne 150GB große UD-IQ1\_M-Datei erstellt (damit Ollama funktioniert) unter Das sollte Probleme wie dieses lösen: ### Tool-Calling verwenden Um die Prompts für Tool-Calling zu formatieren, zeigen wir es an einem Beispiel. Ich habe eine Python-Funktion erstellt namens `get_current_temperature` die die aktuelle Temperatur für einen Ort abrufen soll. Derzeit haben wir eine Platzhalterfunktion erstellt, die immer 21,6 Grad Celsius zurückgibt. Das solltet ihr in eine echte Funktion ändern!! {% code overflow="wrap" %} ```python def get_current_temperature(location: str, unit: str = "celsius"): """Aktuelle Temperatur an einem Ort abrufen. Args: location: Der Ort, für den die Temperatur abgerufen werden soll, im Format "Stadt, Bundesstaat, Land". unit: Die Einheit, in der die Temperatur zurückgegeben wird. Standardmäßig "celsius". (Auswahl: ["celsius", "fahrenheit"]) Returns: die Temperatur, der Ort und die Einheit in einem Dict """ return { "temperature": 26.1, # VORKONFIGURIERT -> das müsst ihr ändern! "location": location, "unit": unit, } ``` {% endcode %} Dann verwendet den Tokenizer, um den gesamten Prompt zu erstellen: {% code overflow="wrap" %} ```python from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("unsloth/Qwen3-Coder-480B-A35B-Instruct") messages = [ {'role': 'user', 'content': "Wie hoch ist die Temperatur in San Francisco jetzt? Und morgen?"}, {'content': "", 'role': 'assistant', 'function_call': None, 'tool_calls': [ {'id': 'ID', 'function': {'arguments': {"location": "San Francisco, CA, USA"}, 'name': 'get_current_temperature'}, 'type': 'function'}, ]}, {'role': 'tool', 'content': '{"temperature": 26.1, "location": "San Francisco, CA, USA", "unit": "celsius"}', 'tool_call_id': 'ID'}, ] prompt = tokenizer.apply_chat_template(messages, tokenize = False) ``` {% endcode %} ## :bulb:Leistungs-Benchmarks {% hint style="info" %} Diese offiziellen Benchmarks gelten für den vollständigen BF16-Checkpoint. Um dies zu verwenden, nutzt einfach die `Q8_K_XL, Q8_0, BF16` Checkpoints, die wir hochgeladen haben - ihr könnt für diese Versionen ebenfalls weiterhin Tricks wie MoE-Offloading verwenden! {% endhint %} Hier sind die Benchmarks für das 480B-Modell: #### Agentisches Programmieren
BenchmarkQwen3‑Coder 480B‑A35B‑InstructKimi‑K2DeepSeek‑V3-0324Claude 4 SonnetGPT‑4.1
Terminal‑Bench37.530.02.535.525.3
SWE‑bench Verified mit OpenHands (500 Turns)69.6––70.4–
SWE‑bench Verified mit OpenHands (100 Turns)67.065.438.868.048.6
SWE‑bench Verified mit Private Scaffolding–65.8–72.763.8
SWE‑bench Live26.322.313.027.7–
SWE‑bench Multilingual54.747.313.053.331.5
Multi‑SWE‑bench mini25.819.87.524.8–
Multi‑SWE‑bench flash27.020.7–25.0–
Aider‑Polyglot61.860.056.956.452.4
Spider231.125.212.831.116.5
#### Agentische Browser‑Nutzung
BenchmarkQwen3‑Coder 480B‑A35B‑InstructKimi‑K2DeepSeek‑V3 0324Claude Sonnet‑4GPT‑4.1
WebArena49.947.440.051.144.3
Mind2Web55.842.736.047.449.6
#### Agentische Tool‑Nutzung
BenchmarkQwen3‑Coder 480B‑A35B‑InstructKimi‑K2DeepSeek‑V3 0324Claude Sonnet‑4GPT‑4.1
BFCL‑v368.765.256.973.362.9
TAU‑Bench Einzelhandel77.570.759.180.5–
TAU‑Bench Fluggesellschaft60.053.540.060.0–
--- # 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: ``` GET https://unsloth.ai/docs/de/modelle/tutorials/qwen3-coder-how-to-run-locally.md?ask= ``` The question should be specific, self-contained, and written in natural language. 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.