> 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/codex.md). # So führst du lokale LLMs mit OpenAI Codex aus Diese Schritt-für-Schritt-Anleitung zeigt dir, wie du offene LLMs und APIs mit OpenAI Codex verbindest **vollständig lokal**, inklusive Screenshots. Codex braucht nur einen lokalen Endpunkt, der die OpenAI Responses API spricht. Ausführung mit jedem offenen Modell wie Qwen, DeepSeek, Gemma und mehr. 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 Studio](https://github.com/unslothai/unsloth) und [`llama.cpp`](https://github.com/ggml-org/llama.cpp) damit kannst du LLMs unter macOS, Linux und Windows ausführen/bereitstellen. Du kannst jedes andere Modell einsetzen; aktualisiere dazu einfach die Modellnamen in deinen Skripten und der Codex-Konfiguration. Codex einrichten📖 Anleitung zur Einrichtung eines lokalen Modells Für Modell-Quants verwenden wir Unsloth [**Dynamic GGUFs**](/docs/de/grundlagen/dynamic-3.0-ggufs.md) damit du quantisierte GGUF-Modelle ausführen kannst und dabei möglichst viel Genauigkeit behältst. {% hint style="info" %} Codex hat sich seit Januar 2026 stark verändert. Es verwendet jetzt ausschließlich die [**OpenAI Responses API**](https://platform.openai.com/docs/api-reference/responses) **ausschließlich**und die Unterstützung für Chat Completions wurde eingestellt. [Unsloth Studio](#unsloth-tutorial) unterstützt beides, daher verwenden wir `wire_api = "responses"` in dieser Anleitung durchgehend. {% endhint %} ### :openai: Codex einrichten [Codex](https://github.com/openai/codex) ist OpenAIs offizieller Coding-Agent, der lokal läuft. Obwohl er für ChatGPT entwickelt wurde, unterstützt er **benutzerdefinierte API-Endpunkte**, wodurch er mit lokalen LLMs funktioniert. Später verweisen wir ihn auf den `/v1/responses` Endpunkt von Unsloth Studio, sobald Unsloth läuft. {% tabs %} {% tab title="Linux / WSL" %} Führe in deinem Terminal aus: ```bash apt update sudo apt install nodejs npm -y npm install -g @openai/codex ``` {% endtab %} {% tab title="Windows" %} Führe in der Windows PowerShell aus: ```powershell winget install --id OpenAI.Codex ``` {% hint style="info" %} **Bevorzugst du die Codex-Desktop-App?** Aus dem Microsoft Store installieren: ```powershell winget install --id 9PLM9XGG6VKS --source msstore ``` Oder über den [Microsoft app Store](https://apps.microsoft.com/detail/9plm9xgg6vks). Die App liest dieselbe `%USERPROFILE%\.codex\config.toml`, daher gilt die Provider-Konfiguration, die wir später einrichten, in beiden Fällen. {% endhint %} {% hint style="info" %} **Bevorzugst du WSL?** Öffne PowerShell als Administrator und führe `wsl --install`aus, starte neu und folge dann im Ubuntu-Terminal dem Linux-Tab oben. Du brauchst einen kleinen Netzwerk-Trick, um Unsloth auf dem Windows-Host zu erreichen – siehe den WSL-Hinweis unter Codex mit Unsloth verbinden. {% endhint %} {% endtab %} {% tab title="MacOS" %} Führe in deinem Terminal aus: 
bash brew install --cask codex
{% endtab %} {% endtabs %} Das war es mit der Installation – **führe `codex` noch nicht**aus. Beim bloßen Start landest du im Auswahldialog von OpenAIs „Mit ChatGPT anmelden“ (der modal ist – es gibt keinen Ausweg). Sobald wir ein lokales Profil eingerichtet haben,\ `codex --oss --profile unsloth_api` oder `codex --oss --profile llama_cpp` überspringt diesen Bildschirm vollständig, weil benutzerdefinierte Provider standardmäßig `requires_openai_auth = false`verwenden. Starte zuerst den lokalen Modellserver und starte dann Codex dagegen. ## 📖 Schnellstart-Tutorials Bevor wir beginnen, müssen wir zunächst die Einrichtung für das konkrete Modell abschließen, das du verwenden wirst. Wir verwenden [Unsloth](https://unsloth.ai/docs/new/studio) (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. {% 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 %}
{% endcolumn %} {% endcolumns %} 🦥 Unsloth-Tutorial🦙 llama.cpp-Tutorial ## 🦥 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** * [**Codeausführung**](/docs/de/neu/studio.md#run-models-locally) (Python, Bash) * [Automatisches Tuning der Inferenz-](https://unsloth.ai/docs/desktop#feature-deep-dive) Parameter (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 %}

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

{% 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 * :apple: [Für macOS herunterladen](https://unsloth.ai/download/mac) * :windows: [Für Windows herunterladen](https://unsloth.ai/download/windows) * :linux: [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 unter macOS in den Ordner „Applications“ 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 „Select model“ 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 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/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
{% 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.
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. Wenn du Unsloth headless mit `unsloth run`startest, wird der Schlüssel auch in der Konsole als `sk-unsloth-...`.
Behandle deinen API-Schlüssel wie ein Passwort und vermeide, ihn in Screenshots oder Repositories offenzulegen. {% endstep %} {% endstepper %} ### Optional: Laufzeit-Einstellungen anpassen Du kannst beim Starten eines Modells mit zusätzlichen Laufzeitoptionen übergeben `unsloth run`. ```bash # Reasoning aktivieren und ein größeres Kontextfenster verwenden unsloth run \ --model unsloth/gemma-4-26B-A4B-it-GGUF \ --reasoning on \\ -c 131072 ``` Modelle mit Reasoning-Fähigkeit können mit `--reasoning on` oder `--reasoning off`gestartet werden. Der `-c` Schalter steuert das verfügbare Kontextfenster. ```bash # Für einen Coding-Agenten auf einem benutzerdefinierten Port bereitstellen unsloth run \ --model unsloth/gemma-4-26B-A4B-it-GGUF \ --disable-tools \ -p 8888 ``` Verwende `-p` falls die API auf einem anderen Port laufen soll. {% hint style="info" %} Wenn du einen externen Coding-Agenten steuerst, füge `--disable-tools`hinzu. Dadurch schaltet Unsloth Studio auf Passthrough um, sodass die eigenen Tools des Agenten weitergeleitet und als Tool-Aufrufe an den Agenten zurückgegeben werden, statt dass Unsloth seine eingebauten Tools serverseitig ausführt. {% endhint %} Für eine weitergehende Laufzeitkonfiguration siehe den Hauptabschnitt [API-Abstimmung](https://unsloth.ai/docs/basics/api#unsloth-run-command) Abschnitt. ## ⚙️ Codex verbinden Nachdem wir nun das lokale LLM für Codex eingerichtet haben, konfigurieren wir Codex so, dass es mit deinem Tool funktioniert. Du kannst dich entweder ganz einfach über `unsloth start` unten verbinden oder es [manuell](#connect-manually). ### ⚡ OpenAI Codex ausführen mit `unsloth start` Um Codex direkt mit einem Modell zu starten, führe aus: ```bash unsloth start Code \\ --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. Wenn in Unsloth Studio ein GGUF-Modell geladen ist, öffne deinen Projektordner und führe aus: ```bash unsloth start codex ``` Unsloth erstellt für den Start ein isoliertes Codex-Home und einen von Unsloth unterstützten Responses-Provider. Deine normale `~/.codex` Konfiguration bleibt unverändert. Der Codex-Zustand ist standardmäßig temporär. Verwende `--persist` wenn du seine von Unsloth verwaltete Konfiguration und Sitzungen behalten möchtest: ```bash unsloth start codex --persist unsloth start codex --persist resume --last ```
OpenAI Codex running with a local GGUF model through Unsloth Studio

Codex ist über den Responses-Endpunkt von Unsloth Studio mit einem lokalen GGUF-Modell verbunden.

> Codex benötigt derzeit ein GGUF-Modell, das über den `llama-server` Backend bereitgestellt wird. Siehe die vollständige `unsloth start` Referenz für das Laden von Modellen, Persistenz und alle Wrapper-Optionen. Der Rest dieser Anleitung behandelt eine vollständig manuelle Einrichtung des Codex-Providers. #### 🔌 Manuell verbinden Dieser Abschnitt ist für die manuelle Einrichtung gedacht; er ist identisch, egal ob du Unsloth Studio, llama.cpp oder einen anderen OpenAI-kompatiblen lokalen Server verwendet hast. Codex benötigt drei Werte: den **API-Schlüssel**, die **Basis-URL**, und den **Modellnamen**. Das folgende Beispiel verwendet Unsloth Studio; für llama.cpp verwende dieselbe Struktur mit dem `llama_cpp` Profil im llama.cpp-Abschnitt. {% stepper %} {% step %} #### **Den Unsloth-Provider konfigurieren** Codex sucht nach `~/.codex/config.toml` unter macOS/Linux/WSL oder `%USERPROFILE%\.codex\config.toml` unter Windows. Erstelle oder bearbeite sie: {% code title="\~/.codex/config.toml" overflow="wrap" %} ```toml # Standard-Lokal-Provider, verwendet mit `codex --oss` oss_provider = "unsloth_api" [model_providers.unsloth_api] name = "Unsloth Studio" base_url = "http://localhost:8888/v1" env_key = "UNSLOTH_STUDIO_AUTH_TOKEN" wire_api = "responses" requires_openai_auth = false ``` {% endcode %} Als Nächstes erstelle ein Codex-Profil für Unsloth: {% code title="\~/.codex/unsloth\_api.config.toml" overflow="wrap" %} ```toml model_provider = "unsloth_api" model = "unsloth/gemma-4-26B-A4B-it-GGUF" ``` {% endcode %} {% hint style="info" %} `modell` muss mit der ID übereinstimmen, die dein Server unter `GET http://localhost:8888/v1/models`. Unsloth Studio stellt die vollständige Repo-ID bereit (zum Beispiel `unsloth/gemma-4-26B-A4B-it-GGUF`). Der untenstehende llama.cpp-Abschnitt verwendet `--alias "unsloth/gemma-4-26B-A4B"`, also verwende diese kürzere ID stattdessen, wenn du Codex auf den llama-server richtest. {% endhint %} {% hint style="info" %} Diese Konfiguration registriert einen `unsloth_api` Codex-Modell-Provider, verweist auf Unsloth Studio und setzt `unsloth_api` als Standard-Lokal-Provider für `codex --oss`. Das separate `unsloth_api` Profil wählt den Unsloth-Provider und das Modell nur aus, wenn du Codex mit `--profile unsloth_api`startest, sodass deine normale Codex-Einrichtung nicht geändert wird. Codex liest den API-Schlüssel aus einer Umgebungsvariablen namens `UNSLOTH_STUDIO_AUTH_TOKEN`. Den echten Schlüssel setzt du im nächsten Schritt. {% endhint %} | Feld | Was es bewirkt | | ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ | | `base_url` | Dein lokaler Server-Endpunkt + `/v1` | | `env_key` | **Name** der Umgebungsvariable, aus der Codex deinen API-Schlüssel liest. Das ist nicht der Schlüssel selbst. | | `wire_api` | `responses`. Codex verwendet jetzt ausschließlich OpenAIs Responses API. | | `requires_openai_auth` | `false` lässt Codex den Bildschirm „Mit ChatGPT anmelden“ für diesen Provider überspringen. Der Standard ist bereits `false`, aber sei explizit. | | `modell` | Die Modell-ID, die dein Server bereitstellt. Rufe `GET /models` auf, um die genaue Zeichenfolge zu bestätigen. | | `oss_provider` |

Setzt unsloth\_api als Standard-Lokal-Provider beim Starten von Codex mit
--oss.

| | `requires_openai_auth` | `false` lässt Codex den Bildschirm „Mit ChatGPT anmelden“ für diesen Provider überspringen. | {% hint style="warning" %} OpenAI hat `wire_api = "chat"` entfernt. Verwende immer `wire_api = "responses"`. Wenn du `wire_api = "chat"`setzt, verweigert Codex den Start mit `` `wire_api = "chat"` wird nicht mehr unterstützt. So behebst du das: Setze `wire_api = "responses"` in deiner Provider-Konfiguration. `` {% endhint %} {% hint style="info" %} Du kannst mehrere Profildateien erstellen, jeweils eine für jedes Unsloth-Modell, zwischen dem du wechselst. Starte die gewünschte mit `codex --profile `. {% endhint %} {% endstep %} {% step %} #### Setze die Umgebungsvariable für den API-Schlüssel Verwende denselben Namen der Umgebungsvariablen, den du in `env_key`angegeben hast. Im obigen Unsloth-Studio-Beispiel `env_key = "UNSLOTH_STUDIO_AUTH_TOKEN"`, also setze `UNSLOTH_STUDIO_AUTH_TOKEN` im selben Terminal, aus dem du Codex starten wirst: {% code title="macOS / Linux / WSL" %} ```bash export UNSLOTH_STUDIO_AUTH_TOKEN=YOUR_TOKEN ``` {% endcode %} {% code title="Windows PowerShell" %} ```powershell $env:UNSLOTH_STUDIO_AUTH_TOKEN = "YOUR_TOKEN" ``` {% endcode %} Wenn du `env_key`umbenannt hast, benenne die Variable in den Befehlen ebenfalls um. Ein llama.cpp-Profil, das `env_key = "LLAMA_CPP_API_KEY"` verwendet, benötigt `LLAMA_CPP_API_KEY`, nicht `UNSLOTH_STUDIO_AUTH_TOKEN`. **Sitzung vs. dauerhaft:** Die obigen Befehle gelten nur für das aktuelle Terminal. Um sie dauerhaft zu machen: * **macOS / Linux / WSL:** füge die `export` Zeile zu `~/.bashrc` (bash) oder `~/.zshrc` (zsh) hinzu. * **Windows:** führe `setx UNSLOTH_STUDIO_AUTH_TOKEN "YOUR_TOKEN"` einmal aus oder füge die `$env:` Zeile zu deinem PowerShell- `$PROFILE`. {% hint style="warning" %} **Führst du Codex in WSL mit Unsloth unter Windows aus?** WSL ist ein separater Netzwerk-Namespace, daher erreicht `localhost` von innerhalb von WSL aus Unsloth nicht. Bearbeite deine `config.toml` und verwende stattdessen die Windows-Host-IP: ```bash # Windows-Host-IP aus WSL ermitteln ip route | grep default | awk '{print $3}' ``` Dann setze `base_url = "http://:8888/v1"`. Wenn du WSL2 mit gespiegelt aktivem Netzwerkmodus hast (`.wslconfig` → `networkingMode=mirrored`), `localhost` funktioniert es wie unter nativem Windows. {% endhint %} {% endstep %} {% step %} #### **Codex starten** ```bash mkdir my-project && cd my-project codex --oss --profile unsloth_api ``` {% hint style="info" %} **Erster Start in einem neuen Verzeichnis** Codex fragt *„Vertraust du dem Inhalt dieses Verzeichnisses?“* - wähle *Ja, fortfahren.* Dies ist die Vertrauensabfrage pro Arbeitsverzeichnis, nicht der ChatGPT-Login (der wird wegen \`requires\_openai\_auth = false\` übersprungen). Weitere Starts im selben Verzeichnis überspringen diese Abfrage. {% endhint %}
{% hint style="info" %} **Es wird angezeigt `Modell-Metadaten für` unsloth/gemma-4-26B-A4B `nicht gefunden. Es werden die Fallback-Metadaten verwendet`?** Codex wird mit einer integrierten Tabelle für Kontextfenster, Tool-Unterstützung und Eingabemodalitäten für die eigenen Modelle von OpenAI ausgeliefert. Für alles andere fällt es auf sichere Standardwerte zurück. Die Warnung wird pro Sitzung einmal für jeden Nicht-OpenAI-Slug ausgelöst. Alles funktioniert trotzdem, du kannst sie ignorieren. **So behebst du es:** füge `model_context_window = 131072` oben zu `~/.codex/config.toml` hinzu, damit Codex Gemma 4s echten 128K-Kontext statt seiner Fallback-Schätzung verwendet. Für volle Kontrolle über Tool-Unterstützung und Eingabemodalitäten kannst du außerdem `model_catalog_json` in `[profiles.unsloth_api]` auf eine JSON-Datei verweisen, die einen benutzerdefinierten `ModelInfo` Eintrag für deinen Slug enthält. {% endhint %} Das `--profile unsloth_api` Der Schalter weist Codex an, `~/.codex/unsloth_api.config.toml`zu laden, wodurch der Unsloth-Studio-Provider und das Modell ausgewählt werden. Füge `--oss` hinzu, um über den lokalen OSS-Provider-Flow von Codex auszuführen. Der Modellname erscheint in Codex' Statusleiste.
Füge `--search` hinzu, um die Websuche zu aktivieren: ```bash codex --oss --profile unsloth_api --search ``` Um alle Bestätigungsabfragen zu umgehen **(ACHTUNG: Dadurch wird Codex Code ausführen und bearbeiten, wie es will, ganz ohne jegliche Bestätigungen!)**: {% code overflow="wrap" %} ```bash codex --oss --profile unsloth_api --search --dangerously-bypass-approvals-and-sandbox ``` {% endcode %} {% endstep %} {% endstepper %} ### Probiere eine echte Aufgabe 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 AGENTS.md – das ist es. Installiere Unsloth über eine virtuelle Umgebung mit uv. Siehe https://unsloth.ai/docs/get-started/install/pip-install dazu (hol es dir und lies es). Führe dann einen einfachen Unsloth-Finetuning-Lauf aus, wie in https://github.com/unslothai/unsloth beschrieben. Du hast Zugriff auf 1 GPU. ``` {% endcode %} und wenn wir noch ein wenig länger warten, wirst du ein erfolgreich feinabgestimmtes Modell mit Unsloth sehen!
### Trennen oder zurücksetzen Starte Codex ohne `-p unsloth_api` und es verwendet seinen Standard-Provider. Oder lösche die `[profiles.unsloth_api]` und `[model_providers.unsloth_api]` Blöcke aus `~/.codex/config.toml`. ```bash unset UNSLOTH_STUDIO_AUTH_TOKEN ``` Sie können Unsloth Studio weiterlaufen lassen oder es herunterfahren. Wenn es gestoppt ist, fängt es nichts ab. ### Fehlerbehebung | Symptom | Wahrscheinliche Ursache | Behebung | | ----------------------------------------------------- | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- | | `Modellmetadaten für ... nicht gefunden` | Nicht-OpenAI-Slug, keine integrierten Metadaten | Unbedenkliche Warnung. Um die Nebeneffekte zu unterdrücken, setzen Sie `model_context_window = 131072` in `~/.codex/config.toml`, oder verweisen Sie | | Codex sagt, es sei GPT | Codex fügt eine auf OpenAI verweisende Systemaufforderung ein; lokale Modelle spiegeln sie | Kein Routing-Bug. Überprüfen Sie dies über das Aktivitätsfenster von Unsloth. Überschreiben Sie die Systemaufforderung, um die Selbstmeldung zu ändern. | | `Verbindung abgelehnt` | Unsloth läuft nicht oder falscher Port | Bestätigen Sie, dass Unsloth unter `http://localhost:8888`; prüfen Sie `base_url` in `config.toml` | | `wire_api = "chat" wird nicht mehr unterstützt` | Veraltet `wire_api = "chat"` in der Konfiguration | Wechseln Sie zu `wire_api = "responses"` | | `Modell nicht gefunden` | Tippfehler in der Modell-ID | `GET http://localhost:8888/v1/models` und kopieren Sie die genaue ID | | OOM während der Generierung | Kontext zu groß für den VRAM | Kontext in Unsloth reduzieren **Einstellungen → Inferenz**, oder verwenden Sie eine kleinere Quantisierung | | Codex zeigt den Auswahl-Dialog „Mit ChatGPT anmelden“ |

Ohne Zusatzparameter gestartet codex (kein
--oss)

| Beenden (Strg+C), dann neu starten mit `codex --oss --profile unsloth_api`. Benutzerdefinierte Anbieter überspringen das | | Tool-Calling unzuverlässig | Benötigt selbstheilenden Fallback | Unsloths [selbstheilende Tool-Aufrufe](file:///1382377/new/studio/#execute-code--heal-tool-calling) sind standardmäßig aktiviert | | WSL: `Verbindung abgelehnt` zu `localhost` | WSL-Netzwerk-Namespace | Verwenden Sie die Windows-Host-IP in `base_url`, oder aktivieren Sie das gespiegelte Netzwerk von WSL2 | ## 🦙 Llama.cpp-Tutorial Wir können auch `llama.cpp` direkt verwenden. Wir müssen `llama-server` bereitstellen, das ein Open-Source-Framework zum effizienten Ausführen und Bereitstellen von LLMs auf Mac-, Linux- und Windows-Geräten ist. Das Modell wird auf **Port 8001** bereitgestellt, wobei alle Agenten-Tool-Aufrufe über diesen einen OpenAI-kompatiblen Endpunkt geleitet werden. {% hint style="info" %} Der llama.cpp-Endpunkt wird auf **Port 8001** anstelle von `8888` (Standard von Unsloth Studio). Passen Sie Ihr Codex `base_url` entsprechend in `~/.codex/config.toml`. {% endhint %} {% stepper %} {% step %} #### **llama.cpp installieren** Wir müssen `llama.cpp` installieren, um lokale LLMs bereitzustellen/zu serven, die in Codex verwendet werden. Wir folgen den offiziellen Build-Anweisungen für korrekte GPU-Bindings und maximale Leistung. Ändern Sie `-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 ``` {% endstep %} {% step %} #### **Modelle lokal herunterladen und verwenden** Laden Sie das Modell über die `hf` CLI (`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](file:///1382377/get-started/unsloth-model-catalog.md). Wenn Downloads hängen bleiben, siehe [https://hugging-face-hub-xet-debugging.md](https://hugging-face-hub-xet-debugging.md "mention"). ```bash hf download unsloth/gemma-4-26B-A4B-it-GGUF \\ --local-dir unsloth/gemma-4-26B-A4B-it-GGUF \\ --include "*UD-Q4_K_XL*" ``` {% hint style="info" %} **Sie möchten Vision-Unterstützung?** Füge `--include "*mmproj-BF16*"` um auch den Vision-Projektor herunterzuladen, und übergeben Sie dann `--mmproj unsloth/gemma-4-26B-A4B-it-GGUF/mmproj-BF16.gguf` zu `llama-server`. Codex selbst ist nur textbasiert, daher ist das optional. {% endhint %} {% hint style="success" %} Wir haben `unsloth/gemma-4-26B-A4B-it-GGUF`, aber Sie können auch etwas wie `unsloth/Qwen3.6-35B-A3B-GGUF` - siehe [Qwen3.6-35B-A3B](/docs/de/modelle/qwen3.6.md). {% endhint %} {% endstep %} {% step %} #### **Starten Sie den Llama-Server** Um Gemma-4-26B-A4B für agentische Workloads bereitzustellen, verwenden wir `llama-server`. Wir wenden die von Google empfohlenen Sampling-Parameter an (`temp 1.0`, `top_p 0.95`, `top_k 64`) und aktivieren `--jinja` für ordnungsgemäße Unterstützung beim Tool-Calling. Führen Sie diesen Befehl in einem neuen Terminal aus (verwenden Sie `tmux` oder öffnen Sie ein neues Terminal). Das Folgende sollte **bequem auf eine 24-GB-GPU (RTX 4090) passen** bei \~18 GB. `--fit auf` wird ebenfalls automatisch auslagern, aber wenn Sie schlechte Leistung sehen, reduzieren Sie `--ctx-size`. ```bash ./llama.cpp/llama-server \\ --model unsloth/gemma-4-26B-A4B-it-GGUF/gemma-4-26B-A4B-it-UD-Q4_K_XL.gguf \\ --alias "unsloth/gemma-4-26B-A4B" \\ --temp 1.0 \ --top-p 0.95 \ --top-k 64 \\ --port 8001 \\ --kv-unified \\ --cache-type-k q8_0 --cache-type-v q8_0 \\ --batch-size 4096 --ubatch-size 1024 ``` {% hint style="info" %} Wir haben `--cache-type-k q8_0 --cache-type-v q8_0` für die KV-Cache-Quantisierung, um den VRAM-Verbrauch zu reduzieren. Wenn Sie eine geringere Qualität feststellen, verwenden Sie `bf16` stattdessen (`--cache-type-k bf16 --cache-type-v bf16`), aber der VRAM verdoppelt sich. {% endhint %} {% hint style="success" %} **Das Deaktivieren von Thinking** kann die Leistung bei agentischen Coding-Aufgaben verbessern. Gemma 4 aktiviert Thinking standardmäßig über die Chat-Vorlage – um es zu deaktivieren, fügen Sie dem llama-server-Befehl das folgende Flag hinzu: **macOS / Linux / WSL:** `--chat-template-kwargs '{"enable_thinking":false}'` **Windows PowerShell:** `--chat-template-kwargs "{\\"enable_thinking\\":false}"` {% endhint %} {% endstep %} {% step %} #### **Richten Sie Codex auf Port 8001 aus** Bearbeiten Sie Ihre `~/.codex/config.toml` um den Port von llama-server zu verwenden: {% code title="\~/.codex/config.toml" %} ```toml [model_providers.llama_cpp] name = "llama.cpp" base_url = "http://localhost:8001/v1" env_key = "LLAMA_CPP_API_KEY" wire_api = "responses" ``` {% endcode %} Starten Sie dann mit dem neuen Profil: ```bash codex --oss llama_cpp ``` Da llama-server keinen echten Schlüssel benötigt, können Sie das Auth-Token auf irgendetwas setzen: {% code title="macOS / Linux / WSL" %} ```bash export LLAMA_CPP_API_KEY=sk-no-key-required ``` {% endcode %} {% code title="Windows PowerShell" %} ```powershell $env:LLAMA_CPP_API_KEY = "sk-no-key-required" ``` {% endcode %} {% endstep %} {% endstepper %} --- # 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/codex.md?ask=&goal= ``` `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.