> 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). # Lokale LLMs mit OpenAI Codex ausführen 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 vollständig lokal mit OpenAI Codex verbindest **vollständig lokal**, inklusive Screenshots. Codex benötigt nur einen lokalen Endpunkt, der die OpenAI Responses API unterstützt. Verwende beliebige offene Modelle 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/bereitzustellen. Du kannst jedes andere Modell verwenden; aktualisiere einfach die Modellnamen in deinen Skripten und der Codex-Konfiguration. Codex einrichten📖 Tutorial zur Einrichtung eines lokalen Modells Für Modell-Quantisierungen verwenden wir Unsloths [**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 ziemlich stark verändert. Es verwendet jetzt die [**OpenAI Responses API**](https://platform.openai.com/docs/api-reference/responses) **ausschließlich**; die Unterstützung für Chat Completions wurde eingestellt. [Unsloth Studio](#unsloth-tutorial) unterstützt beides, also 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 ausgeführt wird. Obwohl er für ChatGPT entwickelt wurde, unterstützt er **benutzerdefinierte API-Endpunkte**; dadurch funktioniert er auch mit lokalen LLMs. Später werden wir ihn auf den `/v1/responses` Endpunkt von Unsloth Studio verweisen, sobald Unsloth läuft. {% tabs %} {% tab title="Linux / WSL" %} Führe dies in deinem Terminal aus: ```bash apt update sudo apt install nodejs npm -y npm install -g @openai/codex ``` {% endtab %} {% tab title="Windows" %} Führe dies in Windows PowerShell aus: ```powershell winget install --id OpenAI.Codex ``` {% hint style="info" %} **Bevorzugst du die Codex-Desktop-App?** Installiere sie aus dem Microsoft Store: ```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`; die später eingerichtete Provider-Konfiguration gilt also in beiden Fällen. {% endhint %} {% hint style="info" %} **Bevorzugst du WSL?** Öffne PowerShell als Administrator und führe aus `wsl --install`, 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 dies in deinem Terminal aus: 
bash brew install --cask codex
{% endtab %} {% endtabs %} Das war’s mit der Installation – **führe `codex` noch nicht**aus. Wenn du es direkt startest, landest du im OpenAI-Auswahlfenster „Mit ChatGPT anmelden“ (es ist modal – 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, da 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 zuerst die Einrichtung für das spezifische 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 zuerst die Einrichtung für das spezifische 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 einzigartiges selbstheilendes [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 mit Claude Code verbinden/bereitstellen, 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) Parameterabstimmung (Temp, Top-P usw.) * Schnelle CPU- und GPU-Inferenz über llama.cpp * [LLMs trainieren](/docs/de/neu/studio.md#no-code-training) 2x schneller mit 70 % weniger VRAM Siehe unten für die Installationsanweisungen: {% endcolumn %} {% column %}

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

{% 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: [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 das Unsloth-Installationsprogramm (`.dmg`, `.exe` -Dateien) 2. Ziehen Sie Unsloth auf dem Mac in den Ordner „Programme“ oder schließen Sie die Einrichtung unter Windows ab. 3. Starten Sie die App und warten Sie, bis die Installation abgeschlossen ist {% endstep %} {% step %} #### Wählen Sie ein Modell Öffnen Sie das Dropdown-Menü „Modell auswählen“ oben 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 generieren:** Bilder, Videos und TTS lokal erstellen und trainieren
{% endstep %} {% endstepper %} ### Leitfaden zum Laden von Modellen + API {% stepper %} {% step %} #### Modell auswählen Bevor du die API verwendest, lade ein Modell aus dem **Modell auswählen** Dropdown-Menü oben links auf der Chat-Seite.
In dieser Anleitung verwenden wir: `unsloth/gemma-4-26B-A4B-it-GGUF` mit der empfohlenen `UD-Q4_K_XL` Quantisierung. {% endstep %} {% step %} #### Modell testen Bevor 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 ohne Benutzeroberfläche 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: 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-Funktion 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 ``` Verwenden Sie `-p` verwenden, 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 wechselt Unsloth Studio in den Passthrough-Modus, sodass die eigenen Tools des Agenten weitergeleitet und als Tool-Calls an den Agenten zurückgegeben werden, damit der Agent sie ausführt, statt dass Unsloth seine integrierten Tools serverseitig ausführt. {% endhint %} Für eine erweiterte Laufzeitkonfiguration siehe den Abschnitt [API-Tuning](https://unsloth.ai/docs/basics/api#unsloth-run-command) . ## ⚙️ Codex verbinden Jetzt, da wir das lokale LLM für Codex eingerichtet haben, konfigurieren wir Codex für die Arbeit mit deinem Tool. Du kannst es 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 medium ``` {% 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 unberührt. Der Codex-Status ist standardmäßig temporär. Verwende `--persist` wenn du seine von Unsloth verwaltete Konfiguration und seine Sitzungen beibehalten 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 benötigt 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 ein vollständig manuelles Setup des Codex-Providers. #### 🔌 Manuell verbinden Dieser Abschnitt ist für das manuelle Einrichten gedacht; es ist dasselbe, 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 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-Lokalanbieter, 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 unter `GET http://localhost:8888/v1/models`meldet. Unsloth Studio gibt die vollständige Repo-ID aus (zum Beispiel `unsloth/gemma-4-26B-A4B-it-GGUF`). Der folgende llama.cpp-Abschnitt verwendet `--alias "unsloth/gemma-4-26B-A4B"`; verwende also stattdessen diese kürzere ID, wenn du Codex auf llama-server verweist. {% endhint %} {% hint style="info" %} Diese Konfiguration registriert einen `unsloth_api` Codex-Modellanbieter, verweist ihn auf Unsloth Studio und setzt `unsloth_api` als Standard-Lokalanbieter für `codex --oss`fest. 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 unverändert bleibt. Codex liest den API-Schlüssel aus einer Umgebungsvariable namens `UNSLOTH_STUDIO_AUTH_TOKEN`. Den tatsächlichen Schlüssel legst du im nächsten Schritt fest. {% endhint %} | Feld | Was es macht | | ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | | `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 gib es explizit an. | | `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-Lokalanbieter, wenn Codex mit
--oss.

| | `requires_openai_auth` | `false` gestartet wird, und lässt Codex den Bildschirm „Mit ChatGPT anmelden“ für diesen Provider überspringen. | {% hint style="warning" %} OpenAI hat `wire_api = "chat"` unterstützung entfernt. Verwende immer `wire_api = "responses"`. Wenn du `wire_api = "chat"`festlegst, 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, eine für jedes Unsloth-Modell, zwischen dem du wechselst. Starte das gewünschte mit `codex --profile `. {% endhint %} {% endstep %} {% step %} #### API-Schlüssel-Umgebungsvariable festlegen Verwende denselben Namen für die Umgebungsvariable, den du in `env_key`angegeben hast. Im obigen Unsloth-Studio-Beispiel lautet `env_key = "UNSLOTH_STUDIO_AUTH_TOKEN"`also setze `UNSLOTH_STUDIO_AUTH_TOKEN` im selben Terminal, aus dem du Codex ausführen wirst: {% code title="MacOS / Linux / WSL" %} ```bash export UNSLOTH_STUDIO_AUTH_TOKEN=DEIN_TOKEN ``` {% endcode %} {% code title="Windows PowerShell" %} ```powershell $env:UNSLOTH_STUDIO_AUTH_TOKEN = "DEIN_TOKEN" ``` {% endcode %} Wenn du `env_key`umbenannt hast, benenne die Variable auch in den Befehlen 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 speichern: * **MacOS / Linux / WSL:** füge die `export` Zeile zu `~/.bashrc` (bash) oder `~/.zshrc` (zsh) hinzu. * **Windows:** führe `setx UNSLOTH_STUDIO_AUTH_TOKEN "DEIN_TOKEN"` einmal aus oder füge die `$env:` Zeile zu deiner PowerShell `$PROFILE`. {% hint style="warning" %} **Codex in WSL mit Unsloth unter Windows ausführen?** WSL ist ein separater Netzwerk-Namensraum, daher erreicht `localhost` aus WSL heraus Unsloth nicht. Bearbeite deine `config.toml` stattdessen so, dass die Windows-Host-IP verwendet wird: ```bash # Die Windows-Host-IP aus WSL heraus abrufen ip route | grep default | awk '{print $3}' ``` Setze dann `base_url = "http://:8888/v1"`. Wenn du WSL2 mit gespiegeltter Netzwerkkonfiguration aktiviert 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 vertrauensbezogene Aufforderung pro Arbeitsverzeichnis, nicht der ChatGPT-Login (der wird wegen \`requires\_openai\_auth = false\` übersprungen). Weitere Starts im selben Verzeichnis überspringen diese Aufforderung. {% endhint %}
{% hint style="info" %} **Angezeigte `Modellmetadaten für` unsloth/gemma-4-26B-A4B `nicht gefunden. Es werden Standard-Fallback-Metadaten verwendet`?** Codex wird mit einer integrierten Tabelle für Kontextfenster, Tool-Unterstützung und Eingabemodalitäten für OpenAIs eigene Modelle ausgeliefert. Für alles andere greift es auf sichere Standardwerte zurück. Die Warnung wird pro Sitzung einmal für jeden Nicht-OpenAI-Slug ausgegeben. Alles funktioniert weiterhin; du kannst sie ignorieren. **So behebst du es:** füge `model_context_window = 131072` oben zu `~/.codex/config.toml` hinzu, damit Codex Gemma 4s echte 128K-Kontextlänge verwendet statt seiner Fallback-Schätzung. Für vollständige Kontrolle auch über Tool-Unterstü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 %} Die `--profile unsloth_api` Das Flag weist Codex an, zu laden `~/.codex/unsloth_api.config.toml`, wodurch der Anbieter und das Modell von Unsloth Studio ausgewählt werden. Füge `--oss` hinzu, um den lokalen OSS-Anbieterfluss 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 Genehmigungsaufforderungen zu umgehen **(ACHTUNG: Dadurch wird Codex Code ausführen und ausführen, wie es ihm gefällt, 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 diese Eingabeaufforderung aus, um ein einfaches Unsloth-Finetuning zu installieren und auszuführen: {% code overflow="wrap" %} ``` Du kannst nur im Verzeichnis 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 zur Vorgehensweise (öffne es und lies es). Führe dann einen einfachen Unsloth-Finetuning-Lauf aus, beschrieben in https://github.com/unslothai/unsloth. Du hast Zugriff auf 1 GPU. ``` {% endcode %} und wenn wir etwas länger warten, wirst du ein erfolgreich mit Unsloth feinabgestimmtes Modell sehen!
### Trennen oder zurücksetzen Starte Codex ohne `-p unsloth_api` und es wird den Standardanbieter verwenden. 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 herunterfahren. Es fängt nichts ab, wenn es gestoppt ist. ### Fehlerbehebung | Symptom | Wahrscheinliche Ursache | Behebung | | ---------------------------------------------------- | ------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------- | | `Modellmetadaten für ... nicht gefunden` | Nicht-OpenAI-Slug, keine integrierten Metadaten | Unbedenkliche Warnung. Um die Nebenwirkungen zu unterdrücken, setze `model_context_window = 131072` in `~/.codex/config.toml`oder verweise auf | | Codex sagt, es sei GPT | Codex fügt eine auf OpenAI verweisende Systemaufforderung ein; lokale Modelle spiegeln sie | Kein Routing-Fehler. Überprüfe es über das Aktivitätsfenster von Unsloth. Überschreibe die Systemaufforderung, um die Selbstangabe zu ändern. | | `Verbindung abgelehnt` | Unsloth läuft nicht oder falscher Port | Bestätige, dass Unsloth auf `http://localhost:8888`läuft; 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 eine kleinere Quantisierung | | Codex zeigt den Auswahldialog "Mit ChatGPT anmelden" |

Nur gestartet codex (kein
--oss)

| Beenden (Strg+C), dann erneut starten mit `codex --oss --profile unsloth_api`. Benutzerdefinierte Anbieter überspringen das | | Werkzeugaufrufe unzuverlässig | Selbstheilenden Fallback benötigen | Unsloths [selbstheilende Werkzeugaufrufe](file:///1382377/new/studio/#execute-code--heal-tool-calling) sind standardmäßig aktiviert | | WSL: `Verbindung abgelehnt` zu `localhost` | WSL-Netzwerk-Namensraum | Verwende die Windows-Host-IP in `base_url`oder aktiviere das gespiegelte WSL2-Netzwerk | ## 🦙 Llama.cpp-Tutorial Wir können auch `llama.cpp` direkt verwenden. Wir müssen `llama-server` bereitstellen, ein Open-Source-Framework, um LLMs effizient auf Mac-, Linux- und Windows-Geräten auszuführen und bereitzustellen. Das Modell wird auf **Port 8001** bereitgestellt, wobei alle Agenten-Werkzeugaufrufe über diesen einen OpenAI-kompatiblen Endpunkt geleitet werden. {% hint style="info" %} Der llama.cpp-Endpunkt wird auf **Port 8001** statt `8888` liegen (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 die Verwendung in Codex bereitzustellen/zu bedienen. 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 das `hf` CLI (`pip install huggingface_hub hf_transfer`). Wir verwenden die **UD-Q4\_K\_XL** Quantisierung für das beste Verhältnis von Größe und Genauigkeit. Du findest alle Unsloth-GGUF-Uploads in unserer [Sammlung hier](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-Projector herunterzuladen, dann übergib `--mmproj unsloth/gemma-4-26B-A4B-it-GGUF/mmproj-BF16.gguf` zu `llama-server`. Codex selbst ist nur textbasiert, also ist dies optional. {% endhint %} {% hint style="success" %} Wir haben `unsloth/gemma-4-26B-A4B-it-GGUF`verwendet, aber du kannst alles verwenden wie `unsloth/Qwen3.6-35B-A3B-GGUF` - siehe [Qwen3.6-35B-A3B](/docs/de/modelle/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 wenden Googles empfohlene Sampling-Parameter an (`temp 1.0`, `top_p 0.95`, `top_k 64`) und aktivieren `--jinja` für ordentliche Unterstützung bei Werkzeugaufrufen. 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 \~18 GB. `--fit auf` wird ebenfalls automatisch auslagern, aber wenn du schlechte Leistung siehst, 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 siehst, verwende `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ü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 %} #### **Verweise Codex auf Port 8001** 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 alles 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/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.