> 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/codex.md). # OpenAI Codex Verwenden Sie offene Modelle mit OpenAI Codex lokal auf Ihrem Gerät. Diese Schritt-für-Schritt-Anleitung zeigt dir, wie du offene LLMs und APIs mit OpenAI Codex verbindest **vollständig lokal**, inklusive Screenshots. Codex benötigt nur einen lokalen Endpunkt, der die OpenAI Responses API spricht. Ausführen 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) ermöglicht es dir, LLMs unter macOS, Linux und Windows auszuführen/zu hosten. Du kannst jedes andere Modell verwenden; aktualisiere einfach die Modellnamen in deinen Skripten und der Codex-Konfiguration. Codex einrichten📖 Tutorial: Lokales Modell einrichten Für Modell-Quants verwenden wir Unsloth [**Dynamic GGUFs**](/docs/de/grundlagen/dynamic-3.0-ggufs.md) damit du quantisierte GGUF-Modelle mit möglichst hoher Genauigkeit ausführen kannst. {% hint style="info" %} Codex hat sich seit Jan. 2026 ziemlich stark verändert. Es verwendet jetzt 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. {% endhint %} ### :openai: Codex einrichten [Codex](https://github.com/openai/codex) ist OpenAIs offizieller Coding-Agent, der lokal ausgeführt wird. Obwohl er für ChatGPT entwickelt wurde, unterstützt er **benutzerdefinierte API-Endpunkte**, wodurch er mit lokalen LLMs funktioniert. Später zeigen wir auf den `/v1/responses` Endpunkt von Unsloth Studio, sobald Unsloth läuft. {% tabs %} {% tab title="Linux / WSL" %} In Ihrem Terminal ausführen: ```bash apt update sudo apt install nodejs npm -y npm install -g @openai/codex ``` {% endtab %} {% tab title="Windows" %} Unter Windows PowerShell ausführen: ```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?** PowerShell als Administrator öffnen, `wsl --install`ausführen, neu starten und dann im Ubuntu-System den Linux-Tab oben befolgen. Du brauchst einen kleinen Netzwerk-Trick, um Unsloth auf dem Windows-Host zu erreichen – siehe den WSL-Hinweis in Codex mit Unsloth verbinden. {% endhint %} {% endtab %} {% tab title="MacOS" %} In Ihrem Terminal ausführen: 
bash brew install --cask codex
{% endtab %} {% endtabs %} Das war’s mit der Installation - **nicht ausführen `codex` noch**. Wenn du es nackt startest, landest du im OpenAI-Auswahldialog „Mit ChatGPT anmelden“ (das ist modal - es gibt keinen Ausweg). Sobald wir ein lokales Profil verbunden 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`. Starte zuerst den lokalen Modellserver und dann Codex dagegen. ## 📖 Schnellstart-Tutorials Bevor wir beginnen, müssen wir zuerst die Einrichtung für das spezielle 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 Hosten von LLMs auf deinen Geräten mit Mac, Linux und Windows sind. {% 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 %} 🦥 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) Parameter-Tuning (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 * :apple: [Download für macOS](https://unsloth.ai/download/mac) * :windows: [Download für Windows](https://unsloth.ai/download/windows) * :linux: [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. Wenn du Unsloth headless mit `unsloth run`startest, wird der Schlüssel auch in der Konsole ausgegeben als `sk-unsloth-...`.
Behandeln Sie Ihren API-Schlüssel wie ein Passwort und vermeiden Sie es, ihn in Screenshots oder Repositories offenzulegen. {% endstep %} {% endstepper %} ### Optional: Laufzeiteinstellungen anpassen Du kannst beim Starten eines Modells mit `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` wenn 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 Agents weitergeleitet und als Tool-Aufrufe an den Agenten zurückgegeben werden, damit er sie ausführt, statt dass Unsloth die eingebauten Tools serverseitig ausführt. {% endhint %} Für eine erweiterte Laufzeitkonfiguration siehe die Haupt- [API-Abstimmung](https://unsloth.ai/docs/basics/api#unsloth-run-command) Abschnitt. ## ⚙️ Codex verbinden Jetzt, da wir das lokale LLM für Codex eingerichtet haben, konfigurieren wir Codex nun so, dass es mit deinem Tool funktioniert. Du kannst dich entweder einfach mit `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 \ --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 GGUF-Modell in Unsloth Studio 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 unangetastet. Der Codex-Status 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, verbunden mit einem lokalen GGUF-Modell über den Responses-Endpunkt von Unsloth Studio.

> Codex erfordert derzeit ein GGUF-Modell, das über das `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 Codex-Provider-Einrichtung. #### 🔌 Manuell verbinden Dieser Abschnitt ist für die manuelle Einrichtung; er ist derselbe, 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 **Base-URL**, und den **Modellnamen**. Das folgende Beispiel verwendet Unsloth Studio; für llama.cpp verwende dieselbe Struktur mit dem `llama_cpp` Profil im Abschnitt zu llama.cpp. {% 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 es: {% 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 %} Erstelle als Nächstes 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 bei `GET http://localhost:8888/v1/models`meldet. Unsloth Studio stellt die vollständige Repo-ID bereit (zum Beispiel `unsloth/gemma-4-26B-A4B-it-GGUF`). Der Abschnitt zu llama.cpp unten verwendet `--alias "unsloth/gemma-4-26B-A4B"`, also verwende diese kürzere ID, wenn du Codex stattdessen auf llama-server ausrichtest. {% endhint %} {% hint style="info" %} Diese Konfiguration registriert einen `unsloth_api` Codex-Modellanbieter, verweist ihn 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 verändert wird. Codex liest den API-Schlüssel aus einer Umgebungsvariable mit dem Namen `UNSLOTH_STUDIO_AUTH_TOKEN`. Den echten Schlüssel setzt du im nächsten Schritt. {% endhint %} | Feld | Was es tut | | ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- | | `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 die OpenAI Responses API. | | `requires_openai_auth` | `false` veranlasst Codex, für diesen Provider den Bildschirm „Mit ChatGPT anmelden“ zu ü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` veranlasst Codex, für diesen Provider den Bildschirm „Mit ChatGPT anmelden“ zu überspringen. | {% hint style="warning" %} OpenAI hat `wire_api = "chat"` entfernt. Verwende immer `wire_api = "responses"`. Wenn du `wire_api = "chat"`setzt, startet Codex nicht mit `` `wire_api = "chat"` wird nicht mehr unterstützt. So behebst du es: 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 %} #### Umgebungsvariable für den API-Schlüssel setzen Verwende denselben Namen der Umgebungsvariable, den du in `env_key`geschrieben hast. Im obigen Unsloth-Studio-Beispiel `env_key = "UNSLOTH_STUDIO_AUTH_TOKEN"`, also setze `UNSLOTH_STUDIO_AUTH_TOKEN` im selben Terminal, von dem aus 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 auch in den Befehlen um. Zum Beispiel ein llama.cpp-Profil, das `env_key = "LLAMA_CPP_API_KEY"` 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 `exportieren` Zeile zu `~/.bashrc` (bash) oder `~/.zshrc` (zsh) hinzu. * **Windows:** ausführen `setx UNSLOTH_STUDIO_AUTH_TOKEN "YOUR_TOKEN"` einmal ausführen oder die `$env:` Zeile zu deiner PowerShell- `$PROFILE`. {% hint style="warning" %} **Codex in WSL mit Unsloth unter Windows ausführen?** WSL ist ein eigener Netzwerk-Namespace, daher `localhost` aus WSL heraus Unsloth nicht erreicht. Bearbeite deine `config.toml` so, dass stattdessen die Windows-Host-IP verwendet wird: ```bash # Die Windows-Host-IP aus WSL heraus abrufen ip route | grep default | awk '{print $3}' ``` Dann setze `base_url = "http://:8888/v1"`. Wenn du aktiviertes WSL2-Mirror-Networking hast (`.wslconfig` → `networkingMode=mirrored`), `localhost` funktioniert 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" %} **Siehst du `Modellmetadaten für` unsloth/gemma-4-26B-A4B `nicht gefunden. Auf Fallback-Metadaten wird zurückgegriffen`?** Codex wird mit einer integrierten Tabelle für Kontextfenster, Werkzeugunterstützung und Eingabemodalitäten für OpenAIs eigene Modelle ausgeliefert. Für alles andere wird auf sichere Standardwerte zurückgegriffen. Die Warnung wird für jeden Nicht-OpenAI-Slug einmal pro Sitzung ausgelöst. Alles funktioniert trotzdem; du kannst sie ignorieren. **So behebst du es:** fügen Sie `model_context_window = 131072` an den Anfang von `~/.codex/config.toml` hinzufügen, damit Codex Gemma 4s echten 128K-Kontext statt seiner Fallback-Schätzung verwendet. Für vollständige Kontrolle auch über Werkzeugunterstützung und Eingabemodalitäten verweise `model_catalog_json` innerhalb von `[profiles.unsloth_api]` auf eine JSON-Datei mit einem benutzerdefinierten `ModelInfo` Eintrag für deinen Slug. {% endhint %} Der `--profile unsloth_api` Schalter weist Codex an, `~/.codex/unsloth_api.config.toml`, wodurch der Unsloth-Studio-Provider und das Modell ausgewählt werden. Füge `--oss` hinzu, um den lokalen OSS-Provider-Flow von Codex zu verwenden. Der Modellname erscheint in der Statusleiste von Codex.
Füge `--search` hinzu, um die Websuche zu aktivieren: ```bash codex --oss --profile unsloth_api --search ``` Um alle Genehmigungsabfragen zu umgehen **(ACHTUNG: Dadurch kann Codex Code nach Belieben ausführen und ausführen, ohne jegliche Genehmigungen!)**: {% code overflow="wrap" %} ```bash codex --oss --profile unsloth_api --search --dangerously-bypass-approvals-and-sandbox ``` {% endcode %} {% endstep %} {% endstepper %} ### Probiere eine echte Aufgabe aus Probiere diesen Prompt aus, um ein einfaches Unsloth-Finetuning zu installieren und auszuführen: {% code overflow="wrap" %} ``` Du darfst nur im cwd-Projekt arbeiten/. Nicht nach AGENTS.md suchen - das ist es. Installiere Unsloth über eine virtuelle Umgebung mit uv. 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, 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 ``` Du kannst Unsloth Studio weiterlaufen lassen oder es herunterfahren. Es fängt nichts ab, wenn es gestoppt ist. ### Fehlerbehebung | Symptom | Wahrscheinliche Ursache | Beheben | | ---------------------------------------------------- | -------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | | `Modellmetadaten für ... nicht gefunden` | Nicht-OpenAI-Slug, keine integrierten Metadaten | Unschädliche Warnung. Um die Nebeneffekte zu unterdrücken, setze `model_context_window = 131072` in `~/.codex/config.toml`, oder verweise | | Codex sagt, es sei GPT | Codex fügt eine OpenAI-bezogene Systemanweisung ein; lokale Modelle spiegeln sie wider | Kein Routing-Fehler. Überprüfe es über das Aktivitätsfenster von Unsloth. Überschreibe die Systemanweisung, um die Eigenangabe zu ändern. | | `Verbindung abgelehnt` | Unsloth läuft nicht oder der Port ist falsch | Bestätige, dass Unsloth läuft unter `http://localhost:8888`; prüfe `base_url` in `config.toml` | | `wire_api = "chat" wird nicht mehr unterstützt` | Veraltet `wire_api = "chat"` in der Konfiguration | Wechsle zu `wire_api = "responses"` | | `Modell nicht gefunden` | Tippfehler bei der Modell-ID | `GET http://localhost:8888/v1/models` und kopiere die exakte ID | | OOM mitten in der Generierung | Kontext zu groß für VRAM | Reduziere den Kontext in Unsloth **Einstellungen → Inferenz**, oder verwende einen kleineren Quant | | Codex zeigt den Auswahldialog „Mit ChatGPT anmelden“ |

Nackt gestartet codex (kein
--oss)

| Beenden (Ctrl+C), dann erneut starten mit `codex --oss --profile unsloth_api`. Benutzerdefinierte Provider überspringen das | | Tool-Aufrufe unzuverlässig | Selbstheilenden Fallback benötigt | 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 | Verwende die Windows-Host-IP in `base_url`oder aktiviere WSL2-Mirror-Networking | ## 🦙 Llama.cpp-Tutorial Wir können auch `llama.cpp` direkt verwenden. Wir müssen `llama-server` bereitstellen, ein Open-Source-Framework für das effiziente Ausführen und Hosten von LLMs auf Mac-, Linux- und Windows-Geräten. Das Modell wird auf **Port 8001** bereitgestellt, wobei alle Agent-Tool-Aufrufe über diesen einzelnen OpenAI-kompatiblen Endpunkt geleitet werden. {% hint style="info" %} Der llama.cpp-Endpunkt wird auf **Port 8001** anstatt `8888` (Standard von Unsloth Studio). Passe deinen Codex `base_url` entsprechend in `~/.codex/config.toml`. {% endhint %} {% stepper %} {% step %} #### **llama.cpp installieren** Wir müssen `llama.cpp` installieren, um lokale LLMs für Codex bereitzustellen/zu hosten. 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 die `hf` CLI (`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](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" %} **Möchtest du Vision-Unterstützung?** Füge `--include "*mmproj-BF16*"` um auch den Vision-Projektor herunterzuladen, dann übergeben `--mmproj unsloth/gemma-4-26B-A4B-it-GGUF/mmproj-BF16.gguf` zu `llama-server`. Codex selbst ist nur Text, daher ist dies optional. {% endhint %} {% hint style="success" %} Wir haben `unsloth/gemma-4-26B-A4B-it-GGUF`, aber du kannst etwas wie `unsloth/Qwen3.6-35B-A3B-GGUF` - siehe [Qwen3.6-35B-A3B](/docs/de/modelle/tutorials/qwen3.6.md). {% endhint %} {% endstep %} {% step %} #### **Starte den Llama-Server** Um Gemma-4-26B-A4B für agentische Workloads bereitzustellen, verwenden wir `llama-server`. Wir verwenden die von Google empfohlenen Sampling-Parameter (`temp 1.0`, `top_p 0.95`, `top_k 64`) und aktivieren `--jinja` für ordnungsgemäße Unterstützung von Tool-Aufrufen. Führe diesen Befehl in einem neuen Terminal aus (verwende `tmux` oder öffne ein neues Terminal). Das Folgende sollte **bequem in eine 24-GB-GPU (RTX 4090) passen** bei etwa 18 GB. `--fit on` wird ebenfalls automatisch ausgelagert, aber wenn du eine schlechte Leistung feststellst, reduziere `--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 du eine verringerte Qualität feststellst, verwende `bf16` stattdessen (`--cache-type-k bf16 --cache-type-v bf16`), aber der VRAM verdoppelt sich. {% endhint %} {% hint style="success" %} **Denken deaktivieren** kann die Leistung für agentische Coding-Aufgaben verbessern. Gemma 4 aktiviert das Denken standardmäßig über das Chat-Template – um es zu deaktivieren, füge 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 %} #### **Richte Codex auf Port 8001 aus** Bearbeite deine `~/.codex/config.toml` um den llama-server-Port 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 %} Dann starte mit dem neuen Profil: ```bash codex --oss llama_cpp ``` Da llama-server keinen echten Schlüssel benötigt, kannst du 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 by asking a question. Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters: ``` GET https://unsloth.ai/docs/de/grundlagen/api/codex.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case. 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.