> 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/fr/bases/codex.md). # Comment exécuter des LLM locaux avec OpenAI Codex Ce guide étape par étape vous montre comment connecter des LLM ouverts et des API à OpenAI Codex **entièrement en local**, avec captures d’écran à l’appui. Codex a seulement besoin d’un point de terminaison local qui parle l’API OpenAI Responses. Exécutez-le avec n’importe quel modèle ouvert comme Qwen, DeepSeek, Gemma, et bien d’autres. Pour ce tutoriel, nous utiliserons les modèles ouverts suivants : [Gemma 4](/docs/fr/modeles/gemma-4.md) et [Qwen3.5](/docs/fr/modeles/qwen3.5.md) qui sont de solides modèles agentiques et de codage (fonctionnent sur un appareil avec 24 Go de RAM/mémoire unifiée). Pour l’inférence, nous utiliserons [Unsloth Studio](https://github.com/unslothai/unsloth) et [`llama.cpp`](https://github.com/ggml-org/llama.cpp) vous permet d’exécuter/diffuser des LLM sur macOS, Linux et Windows. Vous pouvez le remplacer par n’importe quel autre modèle ; il suffit de mettre à jour les noms des modèles dans vos scripts et la configuration de Codex. Configurer Codex📖 Tutoriel de configuration d’un modèle local Pour les quantifications de modèle, nous utiliserons Unsloth [**Dynamic GGUF**](/docs/fr/bases/dynamic-3.0-ggufs.md) afin de pouvoir exécuter des modèles GGUF quantifiés tout en conservant un maximum de précision. {% hint style="info" %} Codex a beaucoup changé depuis janvier 2026. Il utilise désormais [**l’API OpenAI Responses**](https://platform.openai.com/docs/api-reference/responses) **exclusivement**et la prise en charge de Chat Completions est obsolète. [Unsloth Studio](#unsloth-tutorial) prend en charge les deux, nous utiliserons donc `wire_api = "responses"` tout au long de ce guide. {% endhint %} ### :openai: Configurer Codex [Codex](https://github.com/openai/codex) est l’agent de codage officiel d’OpenAI qui s’exécute en local. Bien que conçu pour ChatGPT, il prend en charge **des points de terminaison API personnalisés**ce qui le rend compatible avec les LLM locaux. Nous le pointerons plus tard vers le point de terminaison `/v1/responses` une fois qu’Unsloth sera prêt. {% tabs %} {% tab title="Linux / WSL" %} Exécutez dans votre terminal : ```bash apt update sudo apt install nodejs npm -y npm install -g @openai/codex ``` {% endtab %} {% tab title="Windows" %} Exécutez dans Windows PowerShell : ```powershell winget install --id OpenAI.Codex ``` {% hint style="info" %} **Vous préférez l’application de bureau Codex ?** Installez depuis le Microsoft Store : ```powershell winget install --id 9PLM9XGG6VKS --source msstore ``` Ou via le [Microsoft app Store](https://apps.microsoft.com/detail/9plm9xgg6vks). L’application lit le même `%USERPROFILE%\.codex\config.toml`donc la configuration du fournisseur que nous mettons en place plus tard s’applique dans les deux cas. {% endhint %} {% hint style="info" %} **Vous préférez WSL ?** Ouvrez PowerShell en tant qu’administrateur, exécutez `wsl --install`, redémarrez, puis suivez l’onglet Linux ci-dessus dans Ubuntu. Vous aurez besoin d’une petite astuce réseau pour atteindre Unsloth sur l’hôte Windows — voir l’astuce WSL dans Connecter Codex à Unsloth. {% endhint %} {% endtab %} {% tab title="macOS" %} Exécutez dans votre terminal : 
bash brew install --cask codex
{% endtab %} {% endtabs %} C’est tout pour l’installation — **n’exécutez pas `codex` encore**. En le lançant sans rien, vous arrivez sur le sélecteur « Se connecter avec ChatGPT » d’OpenAI (il est modal — il n’y a pas de sortie). Une fois que nous aurons configuré un profil local,\ `codex --oss --profile unsloth_api` ou `codex --oss --profile llama_cpp` ignore complètement cet écran, car les fournisseurs personnalisés ont par défaut `requires_openai_auth = false`. Démarrez d’abord le serveur de modèle local, puis lancez Codex dessus. ## 📖 Tutoriels de démarrage rapide Avant de commencer, nous devons d’abord terminer la configuration du modèle spécifique que vous allez utiliser. Nous utilisons [Unsloth](https://unsloth.ai/docs/new/studio) (une interface web) et llama.cpp, qui sont des frameworks open source pour exécuter et diffuser des LLM sur vos appareils Mac, Linux et Windows. {% columns %} {% column %} Avant de commencer, nous devons d’abord terminer la configuration du modèle spécifique que vous allez utiliser. Nous utilisons [Unsloth](/docs/fr/nouveau/studio.md) (une interface web) et llama.cpp, qui sont des frameworks open source pour exécuter et diffuser des LLM sur vos appareils Mac, Linux et Windows. Unsloth dispose aussi d’un système unique d’auto-réparation [d’appel d’outils](/docs/fr/nouveau/studio/chat.md#auto-healing-tool-calling) et [recherche Web](/docs/fr/nouveau/studio/chat.md#code-execution) capacités. Voir à droite Claude Code connecté à Unsloth : {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} 🦥 Tutoriel Unsloth🦙 Tutoriel llama.cpp ## 🦥 Tutoriel Unsloth Pour ce tutoriel, nous servirons/relierons des modèles locaux à Claude Code via une interface en utilisant [Unsloth](https://github.com/unslothai/unsloth). Unsloth fonctionne sur Windows, WSL, Linux et macOS. {% columns %} {% column %} * Rechercher, télécharger, [exécuter des GGUF](/docs/fr/nouveau/studio.md#run-models-locally) et des modèles safetensor * [**Auto-réparation** appel d’outils](/docs/fr/nouveau/studio.md#execute-code--heal-tool-calling) + **recherche Web** * [**Exécution de code**](/docs/fr/nouveau/studio.md#run-models-locally) (Python, Bash) * [Inférence automatique](https://unsloth.ai/docs/desktop#feature-deep-dive) ajustement des paramètres (temp, top-p, etc.) * Inférence rapide CPU + GPU via llama.cpp * [Entraîner des LLM](/docs/fr/nouveau/studio.md#no-code-training) 2x plus rapide avec 70 % de VRAM en moins Voir ci-dessous pour les instructions d’installation : {% endcolumn %} {% column %}

Exemple de Qwen3.6 2 bits en cours d’exécution dans Unsloth.

{% endcolumn %} {% endcolumns %} {% stepper %} {% step %} #### Télécharger Unsloth La façon la plus simple de commencer est d’installer l’application [Unsloth Desktop](/docs/fr/desktop.md) . Elle prend en charge [macOS](/docs/fr/commencer/install/mac.md), Linux, [Windows](/docs/fr/commencer/install/windows-installation.md), [NVIDIA](/docs/fr/commencer/install/pip-install.md), [AMD](/docs/fr/commencer/install/amd.md), Intel et les configurations CPU. Télécharger Unsloth * :apple: [Télécharger pour macOS](https://unsloth.ai/download/mac) * :windows: [Télécharger pour Windows](https://unsloth.ai/download/windows) * :linux: [Télécharger pour Linux](https://unsloth.ai/download/linux) Ou, si vous préférez une installation manuelle : **macOS, Linux, WSL :** ```bash curl -fsSL https://unsloth.ai/install.sh | sh ``` **Windows PowerShell :** ```bash irm https://unsloth.ai/install.ps1 | iex ``` {% endstep %} {% step %} #### Installer 1. Ouvrez le programme d'installation d'Unsloth (`.dmg`, `.exe` fichiers) 2. Faites glisser Unsloth vers Applications sur Mac ou terminez la configuration sur Windows. 3. Lancez l'application et attendez la fin de l'installation {% endstep %} {% step %} #### Choisissez un modèle Ouvrez le menu déroulant « Select model » en haut ou l'onglet « Model hub », choisissez un modèle et une quantification adaptés à votre appareil, puis téléchargez-le. Une fois le téléchargement terminé, commencez à discuter - aucune configuration requise.
{% endstep %} {% step %} #### Unsloth est maintenant prêt Pour commencer à discuter, tapez un message et appuyez sur Entrée. * **Connectez des outils :** [Claude Code](/docs/fr/bases/claude-code.md), [Codex](/docs/fr/bases/codex.md), recherche web, [MCP](/docs/fr/bases/mcp.md) et plus encore * **Entraînez des modèles :** Ajuster du texte, de la diffusion, des embeddings, et plus encore * **Générez des médias :** Créer et entraîner localement des images, des vidéos, de la synthèse vocale
{% endstep %} {% endstepper %} ### Guide de chargement du modèle + API {% stepper %} {% step %} #### Sélectionner le modèle Avant d’utiliser l’API, chargez un modèle depuis le **Sélectionner un modèle** menu déroulant dans le coin supérieur gauche de la page Chat.
Dans ce guide, nous utiliserons : `unsloth/gemma-4-26B-A4B-it-GGUF` avec la quantification recommandée `UD-Q4_K_XL` quantification. {% endstep %} {% step %} #### Tester le modèle Avant d’utiliser le client, envoyez un message rapide :
{% hint style="info" %} Cela confirme que le modèle a été chargé correctement et qu’il est prêt à répondre. {% endhint %} {% endstep %} {% step %} #### **Clé API Unsloth** Dans Unsloth, ouvrez **Paramètres → API** pour afficher ou créer votre clé API. Si vous démarrez Unsloth en mode sans interface avec `la commande unsloth run`, la clé est aussi affichée dans la console sous la forme `sk-unsloth-...`.
Traitez votre clé API comme un mot de passe et évitez de l’exposer dans des captures d’écran ou des dépôts. {% endstep %} {% endstepper %} ### Facultatif : ajuster les paramètres d’exécution Vous pouvez transmettre des options d’exécution supplémentaires lors du lancement d’un modèle avec `la commande unsloth run`. ```bash # Activer le raisonnement et utiliser une fenêtre de contexte plus grande unsloth run \ --model unsloth/gemma-4-26B-A4B-it-GGUF \ --reasoning on \\ -c 131072 ``` Les modèles capables de raisonnement peuvent être lancés avec `--reasoning on` ou `--reasoning off`. Le `-c` indicateur contrôle la fenêtre de contexte disponible. ```bash # Servir pour un agent de codage sur un port personnalisé unsloth run \ --model unsloth/gemma-4-26B-A4B-it-GGUF \ --disable-tools \ -p 8888 ``` Utilisez `-p` si vous avez besoin que l’API s’exécute sur un autre port. {% hint style="info" %} Lorsque vous pilotez un agent de codage externe, ajoutez `--disable-tools`. Cela bascule Unsloth Studio en mode passthrough afin que les propres outils de l’agent soient transmis et renvoyés sous forme d’appels d’outils pour que l’agent les exécute, au lieu qu’Unsloth exécute ses outils intégrés côté serveur. {% endhint %} Pour une configuration d'exécution plus avancée, consultez la section principale [Optimisation de l'API](https://unsloth.ai/docs/basics/api#unsloth-run-command) . ## ⚙️ Connecter Codex Maintenant que nous avons configuré le LLM local pour Codex, nous configurons Codex pour fonctionner avec votre outil. Vous pouvez vous connecter facilement avec `commande unsloth start` ci-dessous ou le faire [manuellement](#connect-manually). ### ⚡ Exécuter OpenAI Codex avec `commande unsloth start` Pour lancer Codex directement avec un modèle, exécutez : ```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 sélectionne automatiquement les paramètres corrects à utiliser, mais vous pouvez toujours les modifier. Avec un modèle GGUF chargé dans Unsloth Studio, ouvrez votre dossier de projet et exécutez : ```bash unsloth start codex ``` Unsloth crée un répertoire Codex isolé et un fournisseur Responses pris en charge par Unsloth pour ce lancement. Votre `~/.codex` configuration habituelle reste inchangée. L’état de Codex est temporaire par défaut. Utilisez `--persist` quand vous voulez conserver sa configuration et ses sessions gérées par Unsloth : ```bash unsloth start codex --persist unsloth start codex --persist resume --last ```
OpenAI Codex running with a local GGUF model through Unsloth Studio

Codex connecté à un modèle GGUF local via le point de terminaison Responses d’Unsloth Studio.

> Codex nécessite actuellement un modèle GGUF servi via le `llama-server` backend. Voir la référence complète `commande unsloth start` référence pour le chargement du modèle, la persistance et toutes les options du wrapper. Le reste de ce guide couvre une configuration entièrement manuelle du fournisseur Codex. #### 🔌 Connecter manuellement Cette section concerne la configuration manuelle ; elle est identique que vous utilisiez Unsloth Studio, llama.cpp ou un autre serveur local compatible OpenAI. Codex a besoin de trois valeurs : la **clé API**, la **URL de base**, et le **nom du modèle**. L’exemple ci-dessous utilise Unsloth Studio ; pour llama.cpp, utilisez la même structure avec le `llama_cpp` profil dans la section llama.cpp. {% stepper %} {% step %} #### **Configurer le fournisseur Unsloth** Codex cherche `~/.codex/config.toml` sur macOS/Linux/WSL ou `%USERPROFILE%\.codex\config.toml` sur Windows. Créez-le ou modifiez-le : {% code title="\~/.codex/config.toml" overflow="wrap" %} ```toml # Fournisseur local par défaut utilisé avec `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 %} Ensuite, créez un profil Codex pour 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" %} `Le modèle` doit correspondre à l’identifiant que votre serveur renvoie à `GET http://localhost:8888/v1/models`. Unsloth Studio expose l’identifiant complet du dépôt (par exemple `unsloth/gemma-4-26B-A4B-it-GGUF`). La section llama.cpp ci-dessous utilise `--alias "unsloth/gemma-4-26B-A4B"`donc utilisez cet identifiant plus court lorsque vous pointez Codex vers llama-server à la place. {% endhint %} {% hint style="info" %} Cette configuration enregistre un `unsloth_api` fournisseur de modèle Codex, le pointe vers Unsloth Studio, et définit `unsloth_api` comme fournisseur local par défaut pour `codex --oss`. Le profil séparé `unsloth_api` sélectionne le fournisseur et le modèle Unsloth uniquement lorsque vous lancez Codex avec `--profile unsloth_api`, donc votre configuration Codex habituelle n’est pas modifiée. Codex lit la clé API depuis une variable d’environnement nommée `UNSLOTH_STUDIO_AUTH_TOKEN`. Vous définirez la vraie clé à l’étape suivante. {% endhint %} | Champ | Ce qu’elle fait | | ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | | `base_url` | Le point de terminaison de votre serveur local + `/v1` | | `env_key` | **Nom** de la variable d’environnement à partir de laquelle Codex lit votre clé API. Ce n’est pas la clé elle-même. | | `wire_api` | `responses`. Codex utilise désormais exclusivement l’API Responses d’OpenAI. | | `requires_openai_auth` | `false` fait que Codex ignore l’écran « Se connecter avec ChatGPT » pour ce fournisseur. La valeur par défaut est déjà `false`, mais soyez explicite. | | `Le modèle` | L’identifiant du modèle exposé par votre serveur. Appelez `GET /models` pour confirmer la chaîne exacte. | | `oss_provider` |

Définit unsloth\_api comme fournisseur local par défaut lors du lancement de Codex avec
--oss.

| | `requires_openai_auth` | `false` fait que Codex ignore l’écran « Se connecter avec ChatGPT » pour ce fournisseur. | {% hint style="warning" %} OpenAI a supprimé `wire_api = "chat"` la prise en charge. Utilisez toujours `wire_api = "responses"`. Si vous définissez `wire_api = "chat"`, Codex refuse de démarrer avec `` `wire_api = "chat"` n’est plus pris en charge. Comment corriger : définissez `wire_api = "responses"` dans la configuration de votre fournisseur. `` {% endhint %} {% hint style="info" %} Vous pouvez créer plusieurs fichiers de profil, un pour chaque modèle Unsloth entre lesquels vous basculez. Lancez celui que vous voulez avec `codex --profile `. {% endhint %} {% endstep %} {% step %} #### Définissez la variable d’environnement de la clé API Utilisez le même nom de variable d’environnement que celui que vous avez écrit dans `env_key`. Dans l’exemple Unsloth Studio ci-dessus, `env_key = "UNSLOTH_STUDIO_AUTH_TOKEN"`, donc définissez `UNSLOTH_STUDIO_AUTH_TOKEN` dans le même terminal depuis lequel vous exécuterez Codex : {% 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 %} Si vous avez renommé `env_key`, renommez aussi la variable dans les commandes. Par exemple, un profil llama.cpp qui utilise `env_key = "LLAMA_CPP_API_KEY"` a besoin de `LLAMA_CPP_API_KEY`, et non `UNSLOTH_STUDIO_AUTH_TOKEN`. **Session vs persistance :** les commandes ci-dessus ne s’appliquent qu’au terminal actuel. Pour les rendre persistantes : * **macOS / Linux / WSL :** ajoutez la ``ligne `export` à`` à `~/.bashrc` (bash) ou `~/.zshrc` (zsh). * **Windows :** exécutez `setx UNSLOTH_STUDIO_AUTH_TOKEN "YOUR_TOKEN"` une fois, ou ajoutez la ``ligne `$env:` à votre`` PowerShell `$PROFILE`. {% hint style="warning" %} **Vous exécutez Codex dans WSL avec Unsloth sur Windows ?** WSL est un espace de noms réseau séparé, donc `localhost` depuis WSL n’atteint pas Unsloth. Modifiez votre `config.toml` pour utiliser à la place l’adresse IP de l’hôte Windows : ```bash # Obtenir l’adresse IP de l’hôte Windows depuis WSL ip route | grep default | awk '{print $3}' ``` Puis définissez `base_url = "http://:8888/v1"`. Si vous avez activé le réseau miroir WSL2 (`.wslconfig` → `networkingMode=mirrored`), `localhost` fonctionne comme sur Windows natif. {% endhint %} {% endstep %} {% step %} #### **Lancer Codex** ```bash mkdir my-project && cd my-project codex --oss --profile unsloth_api ``` {% hint style="info" %} **Premier lancement dans un nouveau répertoire** Codex demande *« Faites-vous confiance au contenu de ce répertoire ? »* - choisissez *Oui, continuer.* C’est l’invite de confiance par répertoire actuel, pas la connexion ChatGPT (celle-ci est ignorée grâce à \`requires\_openai\_auth = false\`). Les lancements suivants dans le même répertoire ignorent cette invite. {% endhint %}
{% hint style="info" %} **Vous voyez `Métadonnées du modèle pour` unsloth/gemma-4-26B-A4B `introuvables. Utilisation des métadonnées de secours par défaut`?** Codex est livré avec un tableau intégré des fenêtres de contexte, de la prise en charge des outils et des modalités d’entrée pour les propres modèles d’OpenAI. Pour tout autre modèle, il revient à des valeurs sûres par défaut. L’avertissement apparaît une fois par session pour chaque identifiant non OpenAI. Tout continue de fonctionner, vous pouvez l’ignorer. **Pour corriger cela :** ajoutez `model_context_window = 131072` en haut de `~/.codex/config.toml` afin que Codex utilise la vraie fenêtre de contexte 128K de Gemma 4 au lieu de son estimation de secours. Pour avoir aussi un contrôle total sur la prise en charge des outils et les modalités d’entrée, pointez `model_catalog_json` dans `[profiles.unsloth_api]` vers un fichier JSON contenant une entrée `ModelInfo` personnalisée pour votre identifiant. {% endhint %} Le `--profile unsloth_api` L’indicateur signale à Codex de charger `~/.codex/unsloth_api.config.toml`, ce qui sélectionne le fournisseur et le modèle Unsloth Studio. Ajoutez `--oss` pour passer par le flux du fournisseur OSS local de Codex. Le nom du modèle apparaît dans la barre d’état de Codex.
Ajoutez `--search` pour activer la recherche web : ```bash codex --oss --profile unsloth_api --search ``` Pour contourner toutes les invites d’approbation **(ATTENTION : cela permettra à Codex de faire et d’exécuter du code comme bon lui semble, sans aucune approbation !)**: {% code overflow="wrap" %} ```bash codex --oss --profile unsloth_api --search --dangerously-bypass-approvals-and-sandbox ``` {% endcode %} {% endstep %} {% endstepper %} ### Essayez une vraie tâche Essayez cette invite pour installer et exécuter un finetuning simple d’Unsloth : {% code overflow="wrap" %} ``` Vous ne pouvez travailler que dans le répertoire cwd project/. Ne cherchez pas AGENTS.md — c’est celui-ci. Installez Unsloth via un environnement virtuel avec uv. Voir https://unsloth.ai/docs/get-started/install/pip-install pour la procédure (allez-y et lisez). Puis effectuez une exécution simple de finetuning Unsloth décrite dans https://github.com/unslothai/unsloth. Vous avez accès à 1 GPU. ``` {% endcode %} et si nous attendons un peu plus longtemps, vous verrez un modèle finetuné avec succès grâce à Unsloth !
### Déconnecter ou rétablir Lancer Codex sans `-p unsloth_api` et il utilisera son fournisseur par défaut. Ou supprimez les `[profiles.unsloth_api]` et `[model_providers.unsloth_api]` blocs de `~/.codex/config.toml`. ```bash unset UNSLOTH_STUDIO_AUTH_TOKEN ``` Vous pouvez laisser Unsloth Studio en cours d’exécution ou l’arrêter. Il n’intercepte rien lorsqu’il est arrêté. ### Dépannage | Symptôme | Cause probable | Correctif | | ------------------------------------------------------ | ------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- | | `Métadonnées du modèle pour ... introuvables` | slug non-OpenAI, pas de métadonnées intégrées | Avertissement sans gravité. Pour neutraliser les effets secondaires, définissez `model_context_window = 131072` dans `~/.codex/config.toml`, ou pointez | | Codex dit que c’est GPT | Codex injecte une invite système faisant référence à OpenAI ; les modèles locaux la reproduisent | Ce n’est pas un bug de routage. Vérifiez via le panneau d’activité d’Unsloth. Remplacez l’invite système pour modifier l’auto-déclaration. | | `Connexion refusée` | Unsloth ne s’exécute pas ou le port est incorrect | Confirmez qu’Unsloth est actif à `http://localhost:8888`; vérifiez `base_url` dans `config.toml` | | `wire_api = "chat" n’est plus pris en charge` | Hérité `wire_api = "chat"` dans la configuration | Passez à `wire_api = "responses"` | | `modèle introuvable` | Erreur dans l’ID du modèle | `GET http://localhost:8888/v1/models` et copiez l’ID exact | | OOM en milieu de génération | Contexte trop grand pour la VRAM | Réduisez le contexte dans Unsloth **Paramètres → Inférence**, ou utilisez une quantification plus petite | | Codex affiche le sélecteur "Se connecter avec ChatGPT" |

Lancé sans configuration codex (sans
--oss)

| Quittez (Ctrl+C), puis relancez avec `codex --oss --profile unsloth_api`. Les fournisseurs personnalisés sautent cette étape | | Appel d’outil peu fiable | Besoin d’un repli avec auto-réparation | Les [appels d’outils avec auto-réparation](file:///1382377/new/studio/#execute-code--heal-tool-calling) sont activés par défaut | | WSL : `Connexion refusée` vers `localhost` | l’espace de noms réseau WSL | Utilisez l’adresse IP de l’hôte Windows dans `base_url`, ou activez le réseau miroir WSL2 | ## 🦙 Tutoriel Llama.cpp Nous pouvons aussi utiliser `llama.cpp` directement. Nous devons déployer `llama-server` qui est un framework open source pour exécuter et servir efficacement des LLM sur les appareils Mac, Linux et Windows. Le modèle sera servi sur **le port 8001** avec tous les appels d’outils de l’agent acheminés via ce seul point de terminaison compatible OpenAI. {% hint style="info" %} Le point de terminaison llama.cpp sera sur **le port 8001** au lieu de `8888` (valeur par défaut d’Unsloth Studio). Ajustez votre Codex `base_url` en conséquence dans `~/.codex/config.toml`. {% endhint %} {% stepper %} {% step %} #### **Installer llama.cpp** Nous devons installer `llama.cpp` pour déployer/servir des LLM locaux à utiliser dans Codex. Nous suivons les instructions officielles de compilation pour obtenir les bons bindings GPU et des performances maximales. Remplacez `-DGGML_CUDA=ON` vers `-DGGML_CUDA=OFF` si vous n’avez pas de GPU ou si vous voulez simplement une inférence CPU. **Pour les appareils Apple Mac / Metal**, définissez `-DGGML_CUDA=OFF` puis continuez normalement - la prise en charge Metal est activée par défaut. ```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 %} #### **Télécharger et utiliser les modèles localement** Téléchargez le modèle via le `hf` CLI (`pip install huggingface_hub hf_transfer`). Nous utilisons la **UD-Q4\_K\_XL** quantification pour obtenir le meilleur équilibre entre taille et précision. Vous pouvez trouver tous les uploads GGUF d’Unsloth dans notre [collection ici](file:///1382377/get-started/unsloth-model-catalog.md). Si les téléchargements restent bloqués, voir [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" %} **Vous voulez la prise en charge de la vision ?** Ajoutez `--include "*mmproj-BF16*"` pour récupérer aussi le projecteur de vision, puis passez `--mmproj unsloth/gemma-4-26B-A4B-it-GGUF/mmproj-BF16.gguf` vers `llama-server`. Codex lui-même est en mode texte uniquement, donc c’est facultatif. {% endhint %} {% hint style="success" %} Nous avons utilisé `unsloth/gemma-4-26B-A4B-it-GGUF`, mais vous pouvez utiliser n’importe quoi comme `unsloth/Qwen3.6-35B-A3B-GGUF` - voir [Qwen3.6-35B-A3B](/docs/fr/modeles/qwen3.6.md). {% endhint %} {% endstep %} {% step %} #### **Démarrer le serveur Llama** Pour déployer Gemma-4-26B-A4B pour des charges de travail agentiques, nous utilisons `llama-server`. Nous appliquons les paramètres d’échantillonnage recommandés par Google (`temp 1.0`, `top_p 0.95`, `top_k 64`) et activons `--jinja` pour une prise en charge correcte des appels d’outils. Exécutez cette commande dans un nouveau terminal (utilisez `tmux` ou ouvrez un nouveau terminal). Ce qui suit devrait **tenir confortablement dans un GPU de 24 Go (RTX 4090)** à environ 18 Go. `--fit on` effectuera également un déchargement automatique, mais si vous constatez de mauvaises performances, réduisez `--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" %} Nous avons utilisé `--cache-type-k q8_0 --cache-type-v q8_0` pour la quantification du cache KV afin de réduire l’utilisation de la VRAM. Si vous constatez une qualité réduite, utilisez `bf16` à la place (`--cache-type-k bf16 --cache-type-v bf16`), mais la VRAM double. {% endhint %} {% hint style="success" %} **Désactiver le raisonnement** peut améliorer les performances pour les tâches de codage agentique. Gemma 4 active le raisonnement par défaut via le modèle de conversation - pour le désactiver, ajoutez l’indicateur suivant à la commande llama-server : **macOS / Linux / WSL :** `--chat-template-kwargs '{"enable_thinking":false}'` **Windows PowerShell :** `--chat-template-kwargs "{\"enable_thinking\":false}"` {% endhint %} {% endstep %} {% step %} #### **Pointez Codex vers le port 8001** Modifiez votre `~/.codex/config.toml` pour utiliser le port de llama-server : {% 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 %} Puis lancez avec le nouveau profil : ```bash codex --oss llama_cpp ``` Comme llama-server ne nécessite pas de vraie clé, vous pouvez définir le jeton d’authentification sur n’importe quelle valeur : {% 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/fr/bases/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.