> 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/claude-code.md).

# Comment exécuter des LLM locaux avec Claude Code

Ce guide étape par étape vous montre comment connecter des LLMs ouverts et des API à Claude Code entièrement en local, avec captures d’écran. Exécutez-le avec n’importe quel modèle ouvert comme Qwen3.6, DeepSeek et Gemma.

{% columns %}
{% column width="58.333333333333336%" %}
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 puissants modèles agentiques et de codage (fonctionne sur un appareil avec 24 Go de RAM/mémoire unifiée).

Pour l’inférence, nous allons utiliser [application Unsloth Desktop](https://github.com/unslothai/unsloth) et [`llama.cpp`](https://github.com/ggml-org/llama.cpp) qui vous permet d’exécuter/servir des LLMs sur macOS, Linux et Windows. Vous pouvez utiliser n’importe quel autre modèle. Pour les quantifications de modèles, nous utilisons Unsloth [Dynamic GGUF](/docs/fr/bases/dynamic-3.0-ggufs.md) pour exécuter n’importe quel LLM quantifié, tout en conservant la précision.
{% endcolumn %}

{% column width="41.666666666666664%" %}

<figure><img src="/files/fbc0a7d72b9926bcc48344f2a6975b19548007b1" alt=""><figcaption><p>Claude Code exécuté localement avec Qwen3.5.</p></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

<a href="/pages/6c4a155ae35df476974e25b66af4db620dffaf2c#claude-code-setup" class="button primary" data-icon="claude">Configuration de Claude Code</a><a href="/pages/6c4a155ae35df476974e25b66af4db620dffaf2c#quickstart-tutorials" class="button primary">📖 Tutoriel de configuration d’un modèle local</a>

## <i class="fa-claude">:claude:</i> Configuration de Claude Code

Avant de configurer notre LLM local, nous devons installer Claude Code. Claude Code est un agent de codage basé sur le terminal qui comprend votre base de code et gère des workflows Git complexes en utilisant le langage naturel.

{% tabs %}
{% tab title="macOS, Linux, WSL" %}

#### **Installer Claude Code :**

Collez ceci dans votre terminal pour installer Claude Code :

```bash
curl -fsSL https://claude.ai/install.sh | bash
```

Après l’installation, naviguez vers le dossier de votre projet. Puis tapez `claude` dans le `shell` pour commencer.

```bash
cd ~/projects/my-project 
claude
```

{% endtab %}

{% tab title="Windows" %}

#### **Installer Claude Code :**

Entrez dans `PowerShell` pour installer Claude Code :

```powershell
irm https://claude.ai/install.ps1 | iex
```

Après l’installation, naviguez vers le dossier de votre projet. Puis tapez `claude` dans le `powershell` pour commencer.

<pre class="language-powershell"><code class="lang-powershell"><strong>cd /path/to/your/project
</strong>claude
</code></pre>

<div data-with-frame="true"><figure><img src="/files/403bda08aa75e78e9f472a4424b85371322415a6" alt="" width="563"><figcaption></figcaption></figure></div>
{% endtab %}
{% endtabs %}

### :detective:Corriger une inférence 90 % plus lente dans Claude Code

{% hint style="warning" %}
Claude Code ajoute récemment un en-tête d’attribution Claude Code au début, ce qui **invalide le cache KV, rendant l’inférence 90 % plus lente avec les modèles locaux**.
{% endhint %}

L’attribution est une ligne ajoutée au début du **début du prompt système** (`x-anthropic-billing-header: cc_version=...; cch=...;`) dont la valeur change à chaque requête, donc tout le préfixe du prompt rate le cache KV à chaque tour.

La solution la plus simple consiste à le désactiver en ligne de commande lorsque vous lancez Claude Code, afin qu’il n’y ait aucun fichier à modifier :

{% code overflow="wrap" %}

```bash
claude --settings '{"env":{"CLAUDE_CODE_ATTRIBUTION_HEADER":"0","CLAUDE_CODE_ENABLE_TELEMETRY":"0"}}' --model unsloth/gemma-4-26B-A4B-it-GGUF
```

{% endcode %}

{% hint style="info" %}
Les versions récentes de Claude Code prennent aussi en charge `export CLAUDE_CODE_ATTRIBUTION_HEADER=0`; les anciennes versions ignoraient la variable du shell, donc la `--settings` forme ci-dessus (ou le fichier de paramètres ci-dessous) est le choix fiable.
{% endhint %}

Pour le rendre permanent, ajoutez `CLAUDE_CODE_ATTRIBUTION_HEADER` défini à 0 dans `"env"` dans `~/.claude/settings.json`. Par exemple, faites `cat > ~/.claude/settings.json` puis ajoutez ce qui suit (une fois collé, appuyez sur ENTRÉE puis CTRL+D pour l’enregistrer). Si vous avez déjà un `~/.claude/settings.json` fichier précédent, ajoutez simplement `"CLAUDE_CODE_ATTRIBUTION_HEADER" : "0"` à la section "env", et laissez le reste du fichier de configuration inchangé.

<pre class="language-json"><code class="lang-json">{
  "promptSuggestionEnabled": false,
  "env": {
    "CLAUDE_CODE_ENABLE_TELEMETRY": "0",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
    <a data-footnote-ref href="#user-content-fn-1">"CLAUDE_CODE_ATTRIBUTION_HEADER" : "0"</a>
  },
  "attribution": {
    "commit": "",
    "pr": ""
  },
  "plansDirectory" : "./plans",
  "prefersReducedMotion" : true,
  "terminalProgressBarEnabled" : false,
  "effortLevel" : "high"
}
</code></pre>

## 📖 Tutoriels de démarrage rapide

{% columns %}
{% column %}
Avant de commencer, nous devons d’abord terminer la configuration du modèle spécifique que vous allez utiliser. Nous utilisons [avatar 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 %}

<div data-with-frame="true"><figure><img src="/files/1a2d152a014c5c542c774dac8c97d657a9f4124f" alt=""><figcaption></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

<a href="/pages/6c4a155ae35df476974e25b66af4db620dffaf2c#connect-claude-code" class="button primary" data-icon="claude">Connecter Claude Code</a><a href="/pages/6c4a155ae35df476974e25b66af4db620dffaf2c#unsloth-tutorial" class="button primary">🦥 Tutoriel Unsloth</a><a href="https://unsloth.ai/docs/basics/claude-code#llama.cpp-tutorial" class="button primary"> Tutoriel llama.cpp</a>

## 🦥 Tutoriel Unsloth

Pour ce tutoriel, nous servirons/relierons des modèles locaux à Claude Code via une interface en utilisant [avatar 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) sélection 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 %}

<div data-with-frame="true"><figure><img src="/files/c1e3c98db9ff7047858e3dac518d5347113d27aa" alt=""><figcaption><p>Exemple de Qwen3.6 2 bits en cours d’exécution dans Unsloth.</p></figcaption></figure></div>
{% 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.

<a href="https://unsloth.ai/download" class="button primary" data-icon="down-to-bracket">Télécharger Unsloth</a>

* <i class="fa-apple">:apple:</i> [Télécharger pour macOS](https://unsloth.ai/download/mac)
* <i class="fa-windows">:windows:</i> [Télécharger pour Windows](https://unsloth.ai/download/windows)
* <i class="fa-linux">:linux:</i> [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 Unsloth (`.dmg`, `.exe` fichiers)
2. Faites glisser Unsloth vers Applications sur Mac ou terminez la configuration pour 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ée à votre appareil, puis téléchargez-le. Une fois terminé, commencez à discuter - aucune configuration requise.

<figure><img src="/files/7d958cdf531f0258b53aad7d5d1606f0c0104da3" alt="" width="563"><figcaption></figcaption></figure>
{% endstep %}

{% step %}

#### Unsloth est maintenant prêt

Pour commencer à discuter, tapez un message et appuyez sur Entrée.

* **Connecter 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îner des modèles :** Ajuster du texte, de la diffusion, des embeddings, et plus encore
* **Générer des médias :** Créer et entraîner localement des images, des vidéos, de la synthèse vocale

<figure><img src="/files/72464cc7d14358590f32529a470d358e2652fd88" alt="" width="563"><figcaption></figcaption></figure>
{% 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 **Sélectionner un modèle** menu déroulant dans le coin supérieur gauche de la page Chat.

<figure><img src="/files/20a3e3fe38cf2dfd454794201dd3cc499546d855" alt=""><figcaption></figcaption></figure>

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 :

<div data-with-frame="true"><figure><img src="/files/55ba6f6b98ba57615a8791e0bec949b1a8cc9795" alt="" width="563"><figcaption></figcaption></figure></div>

{% 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.

<figure><img src="/files/4cfccdbce7d628cd17ae882bafd9d2a1c70743a3" alt=""><figcaption></figcaption></figure>

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 %}

## ⚙️ Connecter Claude Code

Maintenant que nous avons configuré le LLM local pour Claude Code, nous configurons maintenant Claude Code pour fonctionner avec votre outil. Vous pouvez soit le connecter facilement avec `commande unsloth start` ci-dessous ou le faire [manuellement](#connect-manually).

### ⚡ Exécuter Claude Code avec `commande unsloth start`

Pour lancer Claude directement avec un modèle, exécutez :

```bash
unsloth start claude \
    --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 chargé dans Unsloth Studio, ouvrez le dossier de votre projet et exécutez :

```bash
unsloth start claude
```

<figure><img src="/files/3a59eb274b17f3de3ad9dba1af4d3aec98d46172" alt="Claude Code connected to a local model through Unsloth Studio"><figcaption><p>Claude Code exécuté avec le modèle chargé dans Unsloth Studio.</p></figcaption></figure>

Unsloth définit l’endpoint local, la clé API, le modèle et la longueur de contexte pour ce lancement. Votre configuration Claude Code habituelle reste inchangée.

Claude Code conserve déjà les conversations dans son stockage de session normal, donc `--persist` n’est pas nécessaire. Reprenez votre dernière session avec :

```bash
unsloth start claude --continue
```

Voir la référence complète `commande unsloth start` référence pour charger un modèle depuis la ligne de commande, les serveurs Unsloth distants et les options avancées.

Le reste de ce guide couvre la `llama.cpp` configuration manuelle.

#### 🔌 Connecter manuellement

Si vous préférez le configurer manuellement, vous pouvez commencer par définir les variables d’environnement suivantes. Par défaut, ces variables ne seront pas conservées entre les sessions.

{% tabs %}
{% tab title="MacOS, Linux, WSL" %}
**Configuration :** Définissez l’URL locale de l’API :

```bash
export ANTHROPIC_BASE_URL="http://localhost:8888"
```

Copiez votre clé depuis Unsloth Studio → Settings → API (ou depuis la console lorsque vous le démarrez avec `unsloth run`, où elle est affichée comme `sk-unsloth-...`), puis définissez-la.

{% code overflow="wrap" %}

```bash
export ANTHROPIC_AUTH_TOKEN="sk-unsloth-xxxxxxxxxxxx"
```

{% endcode %}

Définissez aussi une valeur vide pour `ANTHROPIC_API_KEY` afin que Claude Code ne vous demande pas de clé cloud :

```bash
export ANTHROPIC_API_KEY=""
```

Optionnel : utilisez par défaut le nom du modèle actuellement chargé dans Unsloth.

```bash
export ANTHROPIC_MODEL="unsloth/gemma-4-26B-A4B-it-GGUF"
```

Utilisez l’identifiant complet du modèle exactement tel qu’il apparaît dans `GET http://localhost:8888/v1/models` (la même chaîne que celle que vous passez à `claude --model`).
{% endtab %}

{% tab title="Windows" %}
**Configuration :** Définissez l’URL locale de l’API dans Powershell :

```powershell
$env:ANTHROPIC_BASE_URL = "http://localhost:8888"
```

Copiez votre clé depuis **Unsloth Studio → Settings → API**, puis définissez-la :

```powershell
$env:ANTHROPIC_AUTH_TOKEN = "sk-unsloth-xxxxxxxxxxxx"
```

**Optionnel :** Utilisez le nom du modèle actuellement chargé dans Unsloth comme valeur par défaut.

```powershell
$env:ANTHROPIC_MODEL = "gemma-4-26B-A4B-it-GGUF"
```

{% hint style="info" %}
Le nom du modèle doit être celui qui est actuellement chargé dans Unsloth Studio.
{% endhint %}
{% endtab %}
{% endtabs %}

### Démarrer Claude Code

Démarrez Claude Code avec le modèle qui est actuellement chargé dans Unsloth.

Nous allons utiliser `gemma-4-26B-A4B-it-GGUF`, mais vous pouvez utiliser n’importe quel modèle compatible avec Unsloth.

```shellscript
claude --model unsloth/gemma-4-26B-A4B-it-GGUF
```

{% hint style="info" %}
Pour un gain de vitesse supplémentaire sur les modèles locaux, vous pouvez aussi lancer avec `--bare --exclude-dynamic-system-prompt-sections`. Voir ci-dessous Optionnel : réduire le prompt système.
{% endhint %}

Claude Code devrait ouvrir et afficher le modèle sélectionné.

<figure><img src="/files/0f755e162fb2a232dc5daae94537bb94d2e5d414" alt=""><figcaption></figcaption></figure>

{% hint style="warning" %}
Voir [#fixing-90-slower-inference-in-claude-code](#fixing-90-slower-inference-in-claude-code "mention") d’abord pour corriger les modèles ouverts qui sont 90 % plus lents à cause de l’invalidation du cache KV.
{% endhint %}

Essayez cette requête pour rechercher et classer des jeux de données SFT de haute qualité :

{% code overflow="wrap" %}

```
Vous ne pouvez travailler que dans project/. Ne cherchez pas CLAUDE.md — c’est ici. Utilisez la recherche web pour trouver 10 vrais jeux de données d’instructions/chat/SFT sur Hugging Face, résumez brièvement vos conclusions et expliquez pourquoi chaque jeu de données est pertinent pour le SFT au fil de votre recherche, puis créez sft_report.md comme un rapport markdown soigné contenant le rang, le nom du jeu de données, le créateur, 3 à 5 tags pertinents, un court résumé en langage simple et pourquoi il est utile pour le SFT. Gardez tout concis et lisible, sans énormes vidages de métadonnées, descriptions brutes collées, listes de tags surdimensionnées ou jeux de données hors sujet. La tâche est terminée une fois que sft_report.md contient 10 entrées de jeu de données propres et bien rédigées, et terminez par : « Successfully finetuned a model with Unsloth! »,
```

{% endcode %}

Après avoir soumis la requête, l’agent recherchera sur le web, évaluera les résultats et rédigera le rapport final. Cela peut prendre quelques minutes.

Certains workflows peuvent nécessiter que vous approuviez des actions ou répondiez à des invites de suivi.

<figure><img src="/files/056631f2dab57a7d03f88950d5c1cf436905b257" alt="" width="563"><figcaption></figcaption></figure>

{% hint style="info" %}
Certains workflows peuvent nécessiter que vous approuviez des actions ou répondiez à des questions de suivi.
{% endhint %}

Une fois terminé, le fichier généré `sft_report.md` ressemble à ceci.

<figure><img src="/files/2dd86a47977f66371be2ffbd658fc36ad45673df" alt="" width="375"><figcaption></figcaption></figure>

{% hint style="warning" %}
Si vous voyez `Impossible de se connecter à l’API (ConnectionRefused)` , rappelez-vous de désactiver `ANTHROPIC_BASE_URL` via `unset ANTHROPIC_BASE_URL`

Si vous trouvez que les modèles ouverts sont 90 % plus lents, [voir ici d’abord](#fixing-90-slower-inference-in-claude-code) pour corriger l’invalidation du cache KV.
{% endhint %}

### Optionnel : réduire le prompt système

Claude Code a été conçu pour les modèles hébergés d’Anthropic, donc son prompt système par défaut est volumineux. Sur les modèles locaux, vous pouvez le réduire pour obtenir des réponses plus rapides et une meilleure réutilisation du cache KV en ajoutant deux options au lancement :

{% code overflow="wrap" %}

```shellscript
claude --model unsloth/gemma-4-26B-A4B-it-GGUF --bare --exclude-dynamic-system-prompt-sections
```

{% endcode %}

{% hint style="info" %}
`--bare` ignore l’auto-détection des hooks, skills, plugins, serveurs MCP et de CLAUDE.md (Claude conserve Bash et la lecture/édition de fichiers), et `--exclude-dynamic-system-prompt-sections` déplace les sections spécifiques à la machine hors du préfixe du prompt. Les deux réduisent le prompt et améliorent la réutilisation du cache KV, ce qui rend les modèles locaux nettement plus rapides. Elles sont facultatives et ne modifient pas la configuration de connexion ci-dessus.
{% endhint %}

### Facultatif : ajustez le serveur Unsloth

Claude Code utilise le modèle exécuté dans Unsloth. Vous pouvez personnaliser le comportement du serveur lors de son lancement.

```bash
# Servir pour un agent de codage : --disable-tools transmet les propres outils de l’agent
unsloth run \
  --model unsloth/gemma-4-26B-A4B-it-GGUF \
  --disable-tools \
  --reasoning off \
  -p 8888
```

{% hint style="warning" %}
Utilisez `--disable-tools` lors de l’utilisation de Claude Code (ou de tout autre agent de codage externe). Par défaut, Unsloth Studio exécute ses propres outils côté serveur, ce qui intercepte les appels d’outils de l’agent, donc Claude Code répond mais n’édite jamais les fichiers. `--disable-tools` bascule en mode passthrough, de sorte que les outils Write/Edit/Bash de Claude Code sont utilisés.
{% endhint %}

Utilisez `--reasoning off` pour désactiver la réflexion, ou `--reasoning on` pour l'activer pour les modèles qui prennent en charge le raisonnement.

```bash
# Exposer l’API sur votre réseau local
unsloth run \
  --model unsloth/gemma-4-26B-A4B-it-GGUF \
  -H 0.0.0.0 \
  -p 8888
```

Cela démarre le serveur sur `0.0.0.0:8888`, ce qui permet à d'autres appareils sur votre réseau local de se connecter.

Utilisez `-p` pour changer le port sur lequel le serveur s’exécute. Utilisez `-H 0.0.0.0` si vous voulez que des téléphones, ordinateurs portables ou autres appareils de votre réseau se connectent.

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) .

## 🦙 Tutoriel Llama.cpp

Avant de commencer, nous devons d’abord terminer la configuration du modèle spécifique que vous allez utiliser. Nous utilisons `llama.cpp` qui est un framework open source pour exécuter des LLMs sur vos appareils Mac, Linux, Windows, etc. Llama.cpp contient `llama-server` qui vous permet de servir et de déployer efficacement des LLMs. Le modèle sera servi sur le port 8001, avec tous les outils de l’agent routés via un seul endpoint compatible OpenAI.

#### Tutoriel Qwen3.5

Nous allons utiliser [Qwen3.5](/docs/fr/modeles/qwen3.5.md)-35B-A3B et des paramètres spécifiques pour des tâches de codage rapides et précises. Si vous n’avez pas assez de VRAM et que vous voulez un **plus intelligent** modèle, **Qwen3.5-27B** est un excellent choix, mais il sera environ 2 fois plus lent, ou vous pouvez utiliser d’autres variantes Qwen3.5 comme 9B, 4B ou 2B.

{% hint style="info" %}
Utilisez Qwen3.5-27B si vous voulez un **plus intelligent** modèle ou si vous n’avez pas assez de VRAM. Il sera cependant environ 2 fois plus lent que le 35B-A3B. Ou vous pouvez utiliser [**Qwen3-Coder-Next**](/docs/fr/modeles/qwen3-coder-next.md) qui est fantastique si vous avez suffisamment de VRAM.
{% endhint %}

{% stepper %}
{% step %}

#### Installer llama.cpp

Nous devons installer `llama.cpp` pour déployer/servir des LLMs locaux à utiliser dans Claude Code, etc. Nous suivons les instructions de compilation officielles pour obtenir un bon raccordement GPU et des performances maximales. Modifiez `-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
```

<figure><img src="/files/8489c41d22962d53d645e04de3e77d0fdb8c5ead" alt="" width="563"><figcaption></figcaption></figure>
{% endstep %}

{% step %}

#### Télécharger et utiliser les modèles localement

Téléchargez le modèle via `huggingface_hub` en Python (après installation via `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](/docs/fr/commencer/unsloth-model-catalog.md). Si les téléchargements restent bloqués, voir [Dépannage de Hugging Face Hub, XET](/docs/fr/bases/troubleshooting-and-faqs/hugging-face-hub-xet-debugging.md)

```bash
hf download unsloth/Qwen3.5-35B-A3B-GGUF \
    --local-dir unsloth/Qwen3.5-35B-A3B-GGUF \
    --include "*UD-Q4_K_XL*" # Utilisez "*UD-Q2_K_XL*" pour Dynamic 2bit
```

<figure><img src="/files/0cf557e44436ae2657d5f79daa7252bb5fb2ad3f" alt=""><figcaption></figcaption></figure>

{% hint style="success" %}
Nous avons utilisé `unsloth/Qwen3.5-35B-A3B-GGUF` , mais vous pouvez utiliser une autre variante comme 27B ou tout autre modèle comme `unsloth/`[`Qwen3-Coder-Next`](/docs/fr/modeles/qwen3-coder-next.md)`-GGUF`.
{% endhint %}

<figure><img src="/files/9635896c595b463b0affa4ee51fec4b7d35107d4" alt="" width="563"><figcaption></figcaption></figure>
{% endstep %}

{% step %}

#### Démarrer le serveur Llama

Pour déployer Qwen3.5 pour des charges agentiques, nous utilisons `llama-server`. Nous appliquons [les paramètres d’échantillonnage recommandés par Qwen](/docs/fr/modeles/qwen3.5.md#recommended-settings) pour le mode de réflexion : `temp 0.6`, `top_p 0.95` , `top-k 20`. Gardez à l’esprit que ces valeurs changent si vous utilisez le mode non-réflexion ou d’autres tâches.

Exécutez cette commande dans un nouveau terminal (utilisez `tmux` ou ouvrez un nouveau terminal). Ce qui suit devrait **tient parfaitement dans un GPU de 24 Go (RTX 4090) (utilise 23 Go)** `--fit on` effectuera également un déchargement automatique, mais si vous constatez de mauvaises performances, réduisez `--ctx-size` .

{% 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 VRAM. Pour la précision maximale, utilisez `--cache-type-k bf16 --cache-type-v bf16` . Notez que le cache KV bf16 peut être légèrement plus lent sur certaines machines.
{% endhint %}

```bash
./llama.cpp/llama-server \
    --model unsloth/Qwen3.5-35B-A3B-GGUF/Qwen3.5-35B-A3B-UD-Q4_K_XL.gguf \
    --alias "unsloth/Qwen3.5-35B-A3B" \
    --temp 0.6 \
    --top-p 0.95 \
    --top-k 20 \
    --min-p 0.00 \
    --port 8001 \
    --kv-unified \
    --cache-type-k q8_0 --cache-type-v q8_0
```

{% hint style="success" %}
Vous pouvez aussi désactiver la réflexion pour Qwen3.5, ce qui peut améliorer les performances pour les tâches de codage agentique. Pour désactiver la réflexion avec llama.cpp, ajoutez ceci à la commande llama-server :

`--chat-template-kwargs "{\"enable_thinking\": false}"`

<img src="/files/af2da0988740ecad8c97e69623c6b1aad14e64dd" alt="" data-size="original">
{% endhint %}
{% endstep %}
{% endstepper %}

### Démarrer Claude Code avec llama-server

{% hint style="success" %}
Nous avons utilisé `unsloth/GLM-4.7-Flash-GGUF` , mais vous pouvez utiliser n’importe quoi comme `unsloth/Qwen3.6-27B-GGUF`.
{% endhint %}

{% hint style="warning" %}
Voir [#fixing-90-slower-inference-in-claude-code](#fixing-90-slower-inference-in-claude-code "mention") d’abord pour corriger les modèles ouverts qui sont 90 % plus lents à cause de l’invalidation du cache KV.
{% endhint %}

Naviguez vers le dossier de votre projet (`mkdir project ; cd project`) et exécutez :

```bash
claude --model unsloth/GLM-4.7-Flash
```

Pour utiliser Qwen3.6-35B-A3B, remplacez simplement par :

```bash
claude --model unsloth/Qwen3.6-35B-A3B
```

<div data-with-frame="true"><figure><img src="/files/5c0dabaa7de19c125f865e83bf0492727b9be965" alt="" width="563"><figcaption></figcaption></figure></div>

Pour configurer Claude Code afin d’exécuter les commandes sans aucune approbation, faites **(ATTENTION cela fera que Claude Code fera et exécutera le code comme bon lui semble, sans aucune approbation !)**

{% code overflow="wrap" %}

```bash
claude --model unsloth/GLM-4.7-Flash --dangerously-skip-permissions
```

{% endcode %}

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 courant project/. Ne cherchez pas CLAUDE.md - c’est ici. Installez Unsloth via un environnement virtuel avec uv. Utilisez `python -m venv unsloth_env` puis `source unsloth_env/bin/activate` si possible. Voir https://unsloth.ai/docs/get-started/install/pip-install pour savoir comment faire (récupérez-le et lisez-le). Ensuite, effectuez une simple exécution de finetuning Unsloth décrite dans https://github.com/unslothai/unsloth. Vous avez accès à 1 GPU.
```

{% endcode %}

<div data-with-frame="true"><figure><img src="/files/73f08ccb37b4fa132c66093b45e8591af4cfabe1" alt="" width="563"><figcaption></figcaption></figure></div>

Après avoir attendu un peu, Unsloth sera installé dans un venv via uv, et chargé :

<div data-with-frame="true"><figure><img src="/files/b26dbca2e26dcb0548949abc4a3f6c327e459775" alt="" width="563"><figcaption></figcaption></figure></div>

et enfin vous verrez un modèle finetuné avec succès avec Unsloth !

<div data-with-frame="true"><figure><img src="/files/6219f850d6cac0c3b7fe7dddc64638e56c8e0052" alt="" width="563"><figcaption></figcaption></figure></div>

{% hint style="warning" %}
Si vous voyez `Impossible de se connecter à l’API (ConnectionRefused)` , rappelez-vous de désactiver `ANTHROPIC_BASE_URL` via `unset ANTHROPIC_BASE_URL`

Si vous trouvez que les modèles ouverts sont 90 % plus lents, [voir ici d’abord](#fixing-90-slower-inference-in-claude-code) pour corriger l’invalidation du cache KV.
{% endhint %}

[^1]: Doit être utilisé !


---

# 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/claude-code.md?ask=<question>&goal=<endgoal>
```

`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.