> 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/notions-de-base/codex.md). # Comment exécuter des LLM locaux avec OpenAI Codex Utilisez des modèles ouverts avec OpenAI Codex sur votre appareil en local. Ce guide étape par étape vous montre comment connecter des LLM open source et des API à OpenAI Codex **entièrement en local**, avec captures d'écran incluses. 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 plus encore. Pour ce tutoriel, nous utiliserons les modèles ouverts : [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 remplacer le modèle par n'importe quel autre, il suffit de mettre à jour les noms de modèle dans vos scripts et la configuration de Codex. Configurer Codex📖 Tutoriel de configuration du modèle local Pour les modèles quantifiés, nous utiliserons les [**GGUF dynamiques**](/docs/fr/notions-de-base/dynamic-3.0-ggufs.md) afin que vous puissiez exécuter des modèles GGUF quantifiés tout en conservant un maximum de précision. {% hint style="info" %} Codex a pas mal 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 des Chat Completions a été dépréciée. [Unsloth Studio](#unsloth-tutorial) prend en charge les deux, donc nous utiliserons `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 localement. Bien qu'il soit 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 `/v1/responses` d'Unsloth Studio une fois Unsloth lancé. {% 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 PowerShell sous Windows : ```powershell winget install --id OpenAI.Codex ``` {% hint style="info" %} **Vous préférez l'application de bureau Codex ?** Installez-la 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'appliquera 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'indication 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**. L'exécuter nu vous amène au sélecteur « Se connecter avec ChatGPT » d'OpenAI (qui est modal - il n'y a pas d'issue de secours). 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 du 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 servir 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 servir des LLM sur vos appareils Mac, Linux et Windows. Unsloth dispose aussi d'une fonction unique d'auto-réparation [appels d'outils](/docs/fr/nouveau/studio/chat.md#auto-healing-tool-calling) et [recherche web](/docs/fr/nouveau/studio/chat.md#code-execution) fonctionnalités. Voir à droite Claude Code connecté à Unsloth : {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} 🦥 Tutoriel Unsloth🦙 Tutoriel llama.cpp ## 🦥 Tutoriel Unsloth Pour ce tutoriel, nous allons servir/connecter des modèles locaux à Claude Code via une interface utilisateur en utilisant [Unsloth](https://github.com/unslothai/unsloth). Unsloth fonctionne sous 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** appels 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) réglage 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 d'un Qwen3.6 2 bits exécuté dans Unsloth.

{% endcolumn %} {% endcolumns %} {% stepper %} {% step %} #### Télécharger Unsloth La manière la plus simple de commencer est d'installer l' [Unsloth Desktop](/docs/fr/desktop.md) application. 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), les configurations Intel et 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 %} #### Choisir 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ée à votre appareil, puis téléchargez-le. Une fois terminé, commencez à discuter - aucune configuration requise.
{% endstep %} {% step %} #### Unsloth est maintenant prêt Pour commencer à discuter, tapez un message et appuyez sur Entrée. * **Connecter les outils :** [Claude Code](/docs/fr/notions-de-base/claude-code.md), [Codex](/docs/fr/notions-de-base/codex.md), recherche web, [MCP](/docs/fr/notions-de-base/mcp.md) et plus encore * **Entraîner des modèles :** Ajuster finement du texte, de la diffusion, des embeddings, et plus encore * **Générer des médias :** Créer et entraîner des images, des vidéos, TTS localement
{% endstep %} {% endstepper %} ### Guide de chargement du modèle + API {% stepper %} {% step %} #### Sélectionner un modèle Avant d'utiliser l'API, chargez un modèle depuis le **menu déroulant Sélectionner un modèle** dans le coin supérieur gauche de la page de discussion.
Dans ce guide, nous utiliserons : `unsloth/gemma-4-26B-A4B-it-GGUF` avec la `UD-Q4_K_XL` quantification recommandée. {% endstep %} {% step %} #### Tester le modèle Avant d'utiliser le client, envoyez un bref message :
{% 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 `unsloth run`, la clé est également affichée dans la console sous `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 démarrage d'un modèle avec `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 démarrés avec `--reasoning on` ou `--reasoning off`. Le `-c` commutateur 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 ``` Utiliser `-p` si vous avez besoin que l'API s'exécute sur un port différent. {% 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 que l'agent doit exécuter, 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 maintenant Codex pour fonctionner avec votre outil. Vous pouvez soit 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 \ --reasoning-effort medium ``` {% hint style="success" %} Si aucun indicateur de réglage/d'échantillonnage n'est défini, Unsloth sélectionne automatiquement les meilleurs/réglages recommandés pour le modèle, y compris la longueur de contexte, la température, etc. {% endhint %} Avec un modèle GGUF chargé dans Unsloth Studio, ouvrez le dossier de votre projet et exécutez : ```bash unsloth start codex ``` Unsloth crée un environnement Codex isolé et un fournisseur Responses soutenu par Unsloth pour le lancement. Votre configuration `~/.codex` habituelle est laissée intacte. L'état de Codex est temporaire par défaut. Utilisez `--persist` lorsque vous souhaitez 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 manuelle complète du fournisseur Codex. #### 🔌 Connexion manuelle Cette section concerne la configuration manuelle ; c'est la même chose que vous ayez utilisé Unsloth Studio, llama.cpp ou un autre serveur local compatible OpenAI. Codex a besoin de trois valeurs : la **clé API**, l' **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 recherche `~/.codex/config.toml` sur macOS/Linux/WSL ou `%USERPROFILE%\\.codex\\config.toml` sous 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` 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"`, utilisez donc 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 `unsloth_api` profil séparé 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 à partir d'une variable d'environnement nommée `UNSLOTH_STUDIO_AUTH_TOKEN`. Vous définirez la vraie clé à l'étape suivante. {% endhint %} | Champ | Ce que cela 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` permet à Codex de passer l'écran « Se connecter avec ChatGPT » pour ce fournisseur. La valeur par défaut est déjà `false`, mais soyez explicite. | | `Le` | L'identifiant du modèle exposé par votre serveur. Interrogez `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` permet à Codex de passer l'écran « Se connecter avec ChatGPT » pour ce fournisseur. | {% hint style="warning" %} OpenAI a supprimé la prise en charge de `wire_api = "chat"` . 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éfinir la variable d'environnement de la clé API Utilisez le même nom de variable d'environnement 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"` nécessite `LLAMA_CPP_API_KEY`, pas `UNSLOTH_STUDIO_AUTH_TOKEN`. **Session vs persistant :** les commandes ci-dessus s'appliquent uniquement au terminal actuel. Pour persister : * **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 `$env:` ligne à 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 # Obtenez 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 de WSL2 (`.wslconfig` → `networkingMode=mirrored`), `localhost` fonctionne comme sous Windows natif. {% endhint %} {% endstep %} {% step %} #### **Lancer Codex** ```bash mkdir my-project && cd my-project codex --oss --profile unsloth_api ``` {% hint style="info" %} **Lancez d'abord dans un nouveau répertoire** Codex demande *"Faites-vous confiance au contenu de ce répertoire ?"* - choisissez *Oui, continuer.* Il s'agit de l'invite de confiance par répertoire de travail, pas de la connexion ChatGPT (celle-ci est ignorée à cause de \`requires\_openai\_auth = false\`). Les lancements suivants dans le même répertoire ignorent cette invite. {% endhint %}
{% hint style="info" %} **Voir `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 une table intégrée des fenêtres de contexte, de la prise en charge des outils et des modalités d'entrée pour les modèles d'OpenAI. Pour tout autre modèle, il revient à des valeurs par défaut sûres. L'avertissement apparaît une fois par session pour chaque slug non OpenAI. Tout fonctionne quand même, vous pouvez l'ignorer. **Pour le corriger :** ajoutez `model_context_window = 131072` en haut de `~/.codex/config.toml` pour que Codex utilise la vraie fenêtre de contexte de 128K de Gemma 4 au lieu de son estimation de secours. Pour un contrôle complet aussi 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 slug. {% endhint %} Le `--profile unsloth_api` Le commutateur indique à Codex de charger `~/.codex/unsloth_api.config.toml`, qui sélectionne le fournisseur et le modèle Unsloth Studio. Ajoutez `--oss` pour passer par le flux du fournisseur local OSS 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 fera que Codex exécutera et lancera 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 simple fine-tuning Unsloth : {% code overflow="wrap" %} ``` Vous ne pouvez travailler que dans le projet cwd/. Ne cherchez pas AGENTS.md - c’est ici. Installez Unsloth via un environnement virtuel avec uv. Voir https://unsloth.ai/docs/get-started/install/pip-install pour la procédure (récupérez-la et lisez-la). Ensuite, effectuez une simple exécution de fine-tuning 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 fine-tuné avec succès grâce à Unsloth !
### Déconnecter ou revenir en arrière Lancez 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 inoffensif. Pour supprimer les effets de bord, 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 fonctionne pas ou mauvais port | Vérifiez qu’Unsloth est actif sur `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 de saisie de 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 un quant plus petit | | Codex affiche le sélecteur « Se connecter avec ChatGPT » |

Lancé sans configuration codex (pas de
--oss)

| Quittez (Ctrl+C), puis relancez avec `codex --oss --profile unsloth_api`. Les fournisseurs personnalisés sautent cela | | Appel d’outils peu fiable | Besoin d’un repli autoréparateur | Les appels d’outils [autoréparateurs d’Unsloth](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’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` (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 de compilation officielles pour des liaisons GPU correctes et des performances maximales. Remplacez `-DGGML_CUDA=ON` vers `-DGGML_CUDA=OFF` si vous n’avez pas de GPU ou souhaitez simplement une inférence CPU. **Pour les appareils Apple Mac / Metal**, définissez `-DGGML_CUDA=OFF` puis continuez normalement - la prise en charge de 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 des modèles localement** Téléchargez le modèle via le `hf` CLI (`pip install huggingface_hub hf_transfer`). Nous utilisons le **UD-Q4\_K\_XL** quant pour le meilleur équilibre taille/précision. Vous pouvez trouver tous les téléchargements Unsloth GGUF dans notre [Collection ici](file:///1382377/get-started/unsloth-model-catalog.md). Si les téléchargements se bloquent, 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 est de toute façon limité au texte, 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 Llama-server** 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 de l’appel 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)** avec \~18 Go. `--fit on` s’adaptera aussi automatiquement, 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 chat - 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 n’a pas besoin d’une vraie clé, vous pouvez définir le jeton d’authentification à 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/notions-de-base/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.