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

# Comment utiliser Unsloth comme point de terminaison d'API

Vous pouvez exécuter **des LLM locaux** avec des outils comme [Claude Code](https://unsloth.ai/docs/fr/notions-de-base/claude-code.md) et [Codex](https://unsloth.ai/docs/fr/notions-de-base/codex.md) en connectant ces outils au point de terminaison d’API compatible avec OpenAI d’Unsloth **point de terminaison d’API compatible avec OpenAI**. Cela vous permet d’exécuter des modèles comme [Qwen](https://unsloth.ai/docs/fr/modeles/qwen3.6.md) et [Gemma](https://unsloth.ai/docs/fr/modeles/gemma-4.md) localement pour le codage agentique. Unsloth propose également des fonctionnalités utiles, comme l’appel d’outils avec auto-réparation **appel d’outils**, **exécution de code**, et la **recherche sur le Web**.

Unsloth facilite le déploiement d’un point de terminaison d’inférence API rapide qui offre :

* [**Appel d’outils avec auto-réparation**](https://unsloth.ai/docs/fr/nouveau/studio/chat.md#auto-healing-tool-calling), qui contribue à réduire de 50 % les appels d’outils défectueux ou mal formés
* [**Exécution de code**](https://unsloth.ai/docs/fr/nouveau/studio/chat.md#code-execution) prise en charge, permettant l’exécution de Bash et de Python pour produire du code plus précis.
* **Recherche sur le Web** [**avancée**](https://unsloth.ai/docs/fr/nouveau/studio/chat.md#advanced-web-search) qui consulte et lit réellement les pages Web pour recueillir des informations détaillées.
* [**Paramètres d’inférence** automatiques](https://unsloth.ai/docs/fr/nouveau/studio/chat.md#auto-parameter-tuning) pour les modèles GGUF (température, top-k, etc.)

{% columns %}
{% column %}
Les modèles chargés dans Unsloth (y compris les modèles GGUF) sont exposés sous la forme d’une **API authentifiée** via `llama-server`. Une longue clé API est générée pour des raisons de sécurité, comme le fait OpenAI.

Vos **modèles locaux** peuvent ensuite être utilisés directement dans l’agent d’IA, le SDK ou le client de chat de votre choix. Unsloth prend en charge deux dialectes sur le même port. Les deux prennent en charge le streaming, l’appel d’outils (OpenAI `tools` / Anthropic `tools`), ainsi que les entrées visuelles :
{% endcolumn %}

{% column %}

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FgCthbL3uUmrNgxFBePK5%2Fimage.png?alt=media&amp;token=060dbc41-6fd5-496d-ba00-0ba13fde86ff" alt=""><figcaption></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

Que votre modèle s’exécute via l’inférence d’Unsloth ou votre propre point de terminaison distant compatible avec OpenAI, vous pouvez lui donner accès à toute la suite d’outils d’Unsloth, notamment la recherche sur le Web, l’exécution de code, la recherche approfondie et bien plus encore.

* **Compatible avec Anthropic `/v1/messages`**  pour Claude Code, OpenClaw, le SDK Anthropic et tout client qui attend l’API Messages.
* **Compatible avec OpenAI `/v1/chat/completions`** et **`/v1/responses`** pour le SDK OpenAI, OpenCode, Cursor, Continue, Cline, Open WebUI, SillyTavern et tout outil compatible avec OpenAI.

### ⚡ Démarrage rapide

{% stepper %}
{% step %}

#### Télécharger Unsloth

Le plus simple pour commencer consiste à installer le [Application Unsloth Desktop](https://unsloth.ai/docs/fr/desktop.md)  Elle prend en charge [macOS](https://unsloth.ai/docs/fr/commencer/install/mac.md), Linux, [Windows](https://unsloth.ai/docs/fr/commencer/install/windows-installation.md), [NVIDIA](https://unsloth.ai/docs/fr/commencer/install/pip-install.md), [AMD](https://unsloth.ai/docs/fr/commencer/install/amd.md), Intel et les configurations avec processeur.

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

#### Installation

1. Ouvrez le programme d’installation d’Unsloth (`.dmg`, `.exe` )
2. Faites glisser Unsloth dans Applications sur Mac, ou terminez l’installation 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 le téléchargement terminé, commencez à discuter : aucune configuration n’est nécessaire.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FNCEVgKLJI0goPqjgcg9B%2Fmodel%20hub%20models.png?alt=media&amp;token=533b5e3c-a901-4b33-963e-4a703cc9d5a6" alt="" width="563"><figcaption></figcaption></figure>
{% endstep %}

{% step %}

#### Unsloth est prêt

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

* **Créer une clé API.** Cliquez sur votre **Unsloth** avatar en bas à gauche → **Paramètres** → **API** → saisissez un nom de clé → **Créer**. Copiez la valeur `sk-unsloth-…` qui s’affiche. Unsloth ne l’affiche qu’une seule fois.
* **Configurez votre client pour utiliser Unsloth.** Utilisez `http://localhost:PORT` comme URL de base et votre clé `sk-unsloth-…` pour l’authentification. Consultez ci-dessous les instructions correspondant à votre outil.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FpAGvwjGD0iVMZKBoyu7m%2Fgreeennn.png?alt=media&amp;token=d17a5528-8375-444c-9aff-f9e9f7903bcd" alt="" width="563"><figcaption></figcaption></figure>
{% endstep %}
{% endstepper %}

### 🔑 Créer une clé API

1. Ouvrez la barre latérale, puis cliquez sur votre **Unsloth** avatar en bas à gauche.
2. Accédez à **Paramètres** → **API** (icône de globe :globe\_with\_meridians: ).
3. Saisissez un nom convivial (par exemple, `claude-code-macbook`). Définissez une date d’expiration (facultatif)
4. Cliquez sur **Créer**.
5. **Copiez la clé.** Unsloth ne stocke qu’un hachage, et vous ne pourrez plus consulter la clé.

<div data-with-frame="true"><figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FR7fhygHCl5RwG4P1MSoS%2Fimage.png?alt=media&amp;token=e2781a00-7fe5-4831-9fdb-a57234843b34" alt="" width="563"><figcaption></figcaption></figure></div>

Toutes les clés commencent par le préfixe `sk-unsloth-` . Vous pouvez révoquer une clé à tout moment depuis la même page. Les requêtes effectuées avec une clé révoquée échoueront avec l’erreur `401 Unauthorized`.

{% hint style="warning" %}
Traitez votre clé API comme un mot de passe. Toute personne disposant de la clé et d’un accès réseau à votre instance Unsloth peut envoyer des requêtes au modèle chargé.
{% endhint %}

### ⏳ Chargement du modèle

{% stepper %}
{% step %}

#### Sélectionner un modèle

Avant d’utiliser l’API, chargez un modèle à partir de la liste déroulante **Sélectionner un modèle** située dans le coin supérieur gauche de la page Chat.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FuZqd6tcZ5LgMSh4ZND5x%2Fexport-1778505117710-24fps.gif?alt=media&amp;token=9defec95-5404-4654-9c33-67be967c9820" 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` .
{% endstep %}

{% step %}

#### Tester le modèle

Avant d’utiliser le client, envoyez un bref message :

<div data-with-frame="true"><figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2F2Ivilke0aJX8AHWDwSmr%2Fimage.png?alt=media&amp;token=9f9380b9-f963-4861-a17b-fd0fe16684d4" alt="" width="563"><figcaption></figcaption></figure></div>

{% hint style="info" %}
Cela confirme que le modèle s’est chargé correctement et qu’il est prêt à répondre.
{% endhint %}
{% endstep %}

{% step %}

#### **Clé API Unsloth**

Dans Unsloth, ouvrez **Paramètres → API** pour consulter ou créer votre clé API.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FAZwaRmBVPpXA2SFhMGW9%2Fexport-1778506924396-30fps.gif?alt=media&amp;token=96f3f1a7-fce4-4508-b1b0-e8b6294dc423" 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 %}

### <i class="fa-terminal">:terminal:</i> Commande d’exécution Unsloth

1. **Installez ou mettez à jour Unsloth Studio.** Les versions antérieures ne proposent pas l’API externe. Consultez la section Installation.
2. **Chargez un modèle GGUF.** chargez un modèle GGUF à l’aide de la commande run. Celle-ci lancera également l’interface utilisateur sur le port par défaut. L’URL du point de terminaison et la clé API seront affichées dans la console ; vous pourrez les utiliser avec le client de votre choix.

   ```bash
   unsloth run --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"}'
   ```

Ajustez les paramètres selon vos besoins.

#### Charger un modèle depuis l’interface en ligne de commande

Vous pouvez charger un modèle et faire créer automatiquement une clé API en utilisant la commande `unsloth` Outil CLI. Une fois le chargement du modèle terminé, l’URL du point de terminaison et la clé API s’affichent dans votre console. Copiez-les dans le client de votre choix et vous êtes prêt à commencer.

#### Avant de commencer

Assurez-vous d’utiliser une version récente d’Unsloth Studio, car les versions antérieures n’exposent pas l’API externe. Consultez la page [d’installation](https://unsloth.ai/docs/fr/nouveau/studio/install.md).

#### La méthode rapide

Ouvrez un terminal et chargez un modèle GGUF :

```bash
unsloth run --model unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL
```

Cette commande démarre le serveur sur le port par défaut, charge l’interface utilisateur et affiche l’URL de votre point de terminaison ainsi que votre clé API.

#### Comment fonctionne le nom du modèle

Vous pouvez référencer un modèle de plusieurs façons. Choisissez celle qui vous convient le mieux :

```bash
# Combiné : dépôt et variante de quantification dans une seule chaîne (recommandé — plus court)
unsloth run --model unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL

# Séparés : dépôt et variante sous forme de deux options (ancienne syntaxe, toujours fonctionnelle)
unsloth run --model unsloth/gemma-4-26B-A4B-it-GGUF --gguf-variant UD-Q4_K_XL

# Avec -hf / --hf-repo (correspond à la syntaxe de llama.cpp, pratique si vous l’utilisez déjà)
unsloth run -hf unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL
```

### Paramétrer l’exécution (facultatif)

Vous n’avez besoin d’aucun de ces paramètres pour un chargement de base, mais `unsloth run` prend en charge de nombreuses options d’exécution de llama-server permettant de personnaliser les performances, l’utilisation de la mémoire, la longueur du contexte, le comportement de génération, le réseau et l’accès aux outils.

Les options supplémentaires sont transmises directement au serveur d’inférence sous-jacent, et vos valeurs remplacent les valeurs par défaut d’Unsloth. Si aucune option de configuration ou d’échantillonnage n’est définie, Unsloth sélectionne automatiquement les paramètres optimaux ou recommandés pour le modèle, notamment la longueur du contexte, la température, etc.

#### Contrôler le comportement de raisonnement

Certains modèles capables de raisonner prennent en charge des options supplémentaires permettant de contrôler la réflexion et le raisonnement.

```bash
# Désactiver la sortie de raisonnement / réflexion
unsloth run \
  --model unsloth/Qwen3.8-27B-GGUF:UD-Q4_K_XL \
  --reasoning on  \
  --reasoning-effort medium
```

Les options et le niveau d’effort de raisonnement dépendent des capacités du modèle.

#### Ajuster le comportement de génération

Les paramètres d’échantillonnage contrôlent le degré de créativité, de précision ou de déterminisme du modèle pendant la génération.

```bash
# Réduire le caractère aléatoire et améliorer la reproductibilité
unsloth run \
  --model unsloth/Qwen3-1.7B-GGUF \
  --temp 0.6 \
  --seed 42
```

Des valeurs de température plus basses produisent généralement des résultats plus stables, tandis que les paramètres top-p, top-k, min-p et de pénalité de répétition permettent d’affiner la sélection des jetons et les répétitions.

```bash
# Ajuster la sélection des jetons et les répétitions
unsloth run \
  --model unsloth/Qwen3-1.7B-GGUF \
  --top-p 0.95 \
  --top-k 20 \
  --min-p 0.05 \
  --repeat-penalty 1.1
```

#### Augmenter la longueur du contexte et le nombre de threads du processeur

Utile si vous travaillez sur de grands projets, de longues conversations ou des flux de travail d’agents nécessitant davantage de mémoire.

```bash
# Utiliser une fenêtre de contexte plus grande et davantage de threads du processeur
unsloth run \
  --model unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL \
  -c 131072 \
  --threads 32
```

#### Exposer l’API sur votre réseau local

Par défaut, Unsloth ne fonctionne que localement sur votre machine. Vous pouvez rendre l’API accessible aux autres appareils de votre réseau en la liant à `0.0.0.0`.

```bash
# Autoriser les appareils du réseau local à se connecter
unsloth run \
  --model unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL \
  -H 0.0.0.0 \
  -p 8888
```

#### Activer ou désactiver les outils côté serveur

Contrôlez si le serveur d’inférence expose des outils comme la recherche sur le Web et l’exécution de code.

```bash
# Activer explicitement les outils
unsloth run \
  --model unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL \
  --enable-tools
```

```bash
# Désactiver explicitement les outils
unsloth run \
  --model unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL \
  --disable-tools
```

Unsloth prend en charge la plupart des options d’exécution de llama-server, notamment le réglage de la taille du contexte, des couches GPU, du multithreading, de l’échantillonnage, du réseau et des outils.

Consultez la [llama-server](https://github.com/ggml-org/llama.cpp/tree/master/tools/server) documentation pour obtenir la liste complète des options d’exécution prises en charge.

#### **Politique des outils côté serveur**

Les outils côté serveur exécutent des recherches sur le Web, du code Python et des commandes de terminal sur l’hôte. Les adresses de liaison n’ont aucune incidence sur la politique des outils.

**Valeurs par défaut (sans options) :**

* `unsloth run` / `unsloth studio run`: outils activés, y compris sur `0.0.0.0`. Les requêtes peuvent les désactiver avec `"enable_tools": false`, comme le fait l’interface lorsque les options des outils sont désactivées.
* `unsloth studio` / Desktop : par requête, `enable_tools` contrôle l’accès ; si ce paramètre est omis, l’accès est désactivé.

**Options (pour les deux commandes) :**

* `--enable-tools`: force l’activation des outils pour les requêtes compatibles avec OpenAI, même si `"enable_tools": false`.
* `--disable-tools`: force la désactivation des outils sur tous les points de terminaison ; les requêtes ne peuvent pas passer outre. À utiliser lorsque vous exposez Unsloth ou autorisez des agents externes à exécuter leurs propres outils.
* `--yes` / `-y`: uniquement pour assurer la compatibilité. La politique des outils ne déclenche jamais d’invite.

**Compatible avec Anthropic** `/v1/messages` : nécessite `"enable_tools": true` ou un outil serveur intégré, tel que `web_search`. Ni les valeurs par défaut de la CLI ni `--enable-tools` ne suffisent à l’activer. `--disable-tools` ou `"enable_tools": false` le désactive.

{% hint style="warning" %}
Ces outils exécutent du code avec les droits de votre utilisateur. Gardez votre clé API secrète : toute personne disposant de la clé et d’un accès réseau peut utiliser les outils activés. Utilisez `--disable-tools` lorsque vous exposez Unsloth.
{% endhint %}

<div data-with-frame="true"><figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FZcUxtSPiIJ4cXqe3zCYg%2Funsloth_run_model.lossless.webp?alt=media" alt=""><figcaption></figcaption></figure></div>

### 🌐 Points de terminaison

Unsloth expose son API sur le port utilisé au démarrage, généralement `http://localhost:8000` ou `http://localhost:8888`.

Authentifiez-vous avec un `Authorization: Bearer sk-unsloth-…` dans chaque requête. La disponibilité des points de terminaison dépend de votre version d’Unsloth, du backend et du modèle.

**Chat et texte**

| Point de terminaison        | Fonction                                                                                               |
| --------------------------- | ------------------------------------------------------------------------------------------------------ |
| `POST /v1/chat/completions` | Complétions de chat compatibles avec OpenAI, avec prise en charge du streaming et des appels d’outils. |
| `POST /v1/responses`        | API Responses compatible avec OpenAI pour Codex et d’autres clients compatibles.                       |
| `POST /v1/messages`         | API Messages compatible avec Anthropic pour Claude Code, OpenClaw et d’autres clients compatibles.     |
| `POST /v1/completions`      | Complétions de texte sans formatage de chat. Nécessite un modèle GGUF ou MLX.                          |

Pour les requêtes Responses, envoyez l’historique de la conversation dans `input`. L’historique géré par le serveur via `previous_response_id` ou `conversation` n’est pas pris en charge.

**Modèles, embeddings et comptage des jetons**

| Point de terminaison             | Fonction                                                                                                                       |
| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| `GET /v1/models`                 | Répertorier les modèles chargés et disponibles localement. Vérifiez `loaded` pour repérer les modèles actuellement en mémoire. |
| `GET /v1/models/{model_id}`      | Obtenir les métadonnées d’un modèle.                                                                                           |
| `GET /v1/props`                  | Lire les propriétés du serveur compatibles avec llama-server.                                                                  |
| `POST /v1/embeddings`            | Générer des embeddings à l’aide d’un modèle d’embeddings GGUF chargé ou du modèle d’embeddings configuré dans Unsloth.         |
| `POST /v1/chat/count_tokens`     | Compter les jetons de l’invite pour les messages au format OpenAI.                                                             |
| `POST /v1/messages/count_tokens` | Compter les jetons d’entrée pour les messages au format Anthropic.                                                             |

**Images**

| Point de terminaison          | Fonction                                                                                   |
| ----------------------------- | ------------------------------------------------------------------------------------------ |
| `POST /v1/images/generations` | Générer des images à partir d’une invite à l’aide d’un modèle de diffusion pris en charge. |

**Audio**

| Point de terminaison            | Fonction                                                                                                                                         |
| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| `POST /v1/audio/speech`         | Synthèse vocale compatible avec OpenAI.                                                                                                          |
| `POST /v1/audio/generate`       | Générer de la parole à partir de messages au format chat ; renvoie un audio WAV encodé en base64.                                                |
| `POST /v1/audio/transcriptions` | Transcrire un fichier audio importé.                                                                                                             |
| `POST /v1/audio/translations`   | Traduire en anglais la parole contenue dans un fichier audio importé.                                                                            |
| `POST /v1/audio/inputs`         | Téléversez un fichier audio pour le réutiliser. Envoyez l’audio dans le corps brut de la requête.                                                |
| `POST /v1/audio/run`            | Exécutez un workflow audio, par exemple pour cloner, modifier, convertir ou séparer un fichier audio, ou générer de la musique, selon le modèle. |

Les fichiers audio stockés sont accessibles via `GET /v1/audio/inputs/{input_id}/file` et `DELETE /v1/audio/inputs/{input_id}`.

Gérez les voix enregistrées via `GET` ou `POST /v1/audio/voices`, `PATCH` ou `DELETE /v1/audio/voices/{voice_id}`, et `GET /v1/audio/voices/{voice_id}/file`.

**Vidéo**

| Point de terminaison                | Fonction                                         |
| ----------------------------------- | ------------------------------------------------ |
| `POST /v1/videos`                   | Créez une tâche de génération vidéo.             |
| `GET /v1/videos`                    | Listez les tâches vidéo.                         |
| `GET /v1/videos/{video_id}`         | Récupérez l’état et les métadonnées d’une tâche. |
| `GET /v1/videos/{video_id}/content` | Téléchargez une vidéo terminée.                  |
| `DELETE /v1/videos/{video_id}`      | Supprimez une tâche vidéo.                       |

La génération d’images, d’audio et de vidéos nécessite des modèles prenant en charge la tâche demandée.

**Décisions structurées**

| Point de terminaison | Fonction                                                         |
| -------------------- | ---------------------------------------------------------------- |
| `POST /v1/systemone` | Répondez à des questions structurées à l’aide de l’API Decision. |

Activez l’API Decision dans **Settings → API** et sélectionnez d’abord un modèle de décision. Les requêtes utilisent `state` et des `questions`nommées, avec les types de question `noul`, `choice`ou `score`.

**Explorez votre API locale**

Ouvrez `http://localhost:8888/docs` pour consulter la référence API interactive générée par Unsloth, ou `/openapi.json` pour son schéma lisible par machine. Remplacez `8888` par le port Unsloth que vous utilisez.

Cette référence correspond à la version que vous avez installée et inclut les routes internes d’Unsloth. Certaines routes de compatibilité sont masquées, et les schémas des corps de requête analysés manuellement peuvent être incomplets.

Voir [Curl et HTTP](https://unsloth.ai/docs/integrations/connect-curl-and-http-to-unsloth) pour des exemples de requêtes.

### 🖇️ Connecter votre client

Unsloth vous permet d’exécuter des LLM localement avec la plupart des frameworks, notamment [Claude Code](https://unsloth.ai/docs/fr/notions-de-base/claude-code.md), [Codex](https://unsloth.ai/docs/fr/notions-de-base/codex.md), [OpenClaw](https://unsloth.ai/docs/fr/integrations/openclaw.md), [OpenCode](https://unsloth.ai/docs/fr/integrations/opencode.md) et bien d’autres. Cliquez sur l’outil concerné ci-dessous pour consulter un guide :

{% columns %}
{% column width="50%" %}
{% content-ref url="/pages/6c4a155ae35df476974e25b66af4db620dffaf2c" %}
[Claude Code](https://unsloth.ai/docs/fr/notions-de-base/claude-code.md)
{% endcontent-ref %}

{% content-ref url="/pages/0bb2f0a13e244fd2f0ea640c96c4e297bf83db93" %}
[OpenAI Codex](https://unsloth.ai/docs/fr/notions-de-base/codex.md)
{% endcontent-ref %}

{% content-ref url="/pages/ecc958b339a16f14a987b979d96c3f7d2c0086d1" %}
[Curl & HTTP](https://unsloth.ai/docs/fr/integrations/connecter-curl-et-http-a-unsloth.md)
{% endcontent-ref %}
{% endcolumn %}

{% column width="50%" %}
{% content-ref url="/pages/fc0726cf8f72aecd0706033ae732e8e31cb48fcf" %}
[OpenClaw](https://unsloth.ai/docs/fr/integrations/openclaw.md)
{% endcontent-ref %}

{% content-ref url="/pages/5ed7fe5ad328b9ea2064f629be46409a5616379c" %}
[OpenCode](https://unsloth.ai/docs/fr/integrations/opencode.md)
{% endcontent-ref %}

{% content-ref url="/pages/46b648652a387a143566a8cd8b635a0b50c00204" %}
[Python SDK](https://unsloth.ai/docs/fr/integrations/connecter-le-sdk-python-a-unsloth.md)
{% endcontent-ref %}
{% endcolumn %}
{% endcolumns %}

Pour accéder à ce point de terminaison depuis une autre machine, lancez `unsloth studio --secure`. Unsloth reste lié à localhost et se publie sur une URL HTTPS Cloudflare disponible ; utilisez cette URL à la place de `http://127.0.0.1:8888` comme URL de base de votre client. Notez que les événements envoyés par le serveur ne sont pas pris en charge par un tunnel rapide Cloudflare ; définissez donc `stream: false` lorsque vous effectuez un appel via ce tunnel.

### 🧰 Appels d’outils

Les deux points de terminaison prennent en charge les appels de fonctions et d’outils dans leur format natif, ainsi qu’une syntaxe abrégée propre à Unsloth pour ses outils intégrés.

**Outils au format OpenAI :** envoyez `tools` et `tool_choice` à `/v1/chat/completions` exactement comme vous le feriez avec OpenAI. Claude Code (via `/v1/messages`), opencode, Cursor, Continue et Cline fonctionnent immédiatement.

**Outils au format Anthropic :** envoyez `tools` (avec `input_schema`) et `tool_choice` à `/v1/messages` exactement comme vous le feriez avec Claude.

Outils côté serveur Unsloth : Unsloth peut exécuter Python, effectuer des recherches sur le Web et lancer des commandes bash *côté serveur* et renvoyer les résultats sous forme d’événements `tool_result` . Pour les activer, ajoutez ces champs supplémentaires à l’un ou l’autre des points de terminaison :

```json
{
  "messages": [{"role": "user", "content": "What is 123 * 456? Use Python."}],
  "stream": true,
  "enable_tools": true,
  "enabled_tools": ["python", "web_search","terminal"],
  "session_id": "my-session"
}
```

Le modèle reçoit la sortie de chaque outil au tour suivant. Pour en savoir plus (schémas, événements de flux, chaînage), consultez .

{% hint style="info" %}
Si vous utilisez le point de terminaison Anthropic `/v1/messages` , `tool_choice` se convertit facilement : Anthropic `auto` → OpenAI `auto`, Anthropic `any` → OpenAI `required`, Anthropic `{type: "tool", name: "x"}` → OpenAI `{type: "function", function: {name: "x"}}`, Anthropic `none` → OpenAI `none`.
{% endhint %}

### 📈 Moniteur d’API

Chaque appel effectué via ce point de terminaison est répertorié en temps réel dans Unsloth, à deux endroits :

Le panneau latéral du moniteur d’API s’ouvre automatiquement dans un coin dès que du trafic utilisant une clé API arrive. Il récapitule le modèle actif, les requêtes en temps réel, les erreurs et la latence moyenne.

<div data-with-frame="true"><figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FqbcbkrU9tnkg5VCnDzCz%2Fimage.png?alt=media&amp;token=733b2b37-4e57-48c6-b826-9f356d648344" alt=""><figcaption></figcaption></figure></div>

Cliquez sur « Développer pour afficher le moniteur complet » ou accédez à Paramètres>Moniteur d’API pour ouvrir la page complète **API** , où le moniteur affiche le chargement du modèle, les invites, les réponses, le nombre de jetons, le délai avant le premier jeton, le débit et les messages d’erreur.

<div data-with-frame="true"><figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FfjIh57Mb278c072g27nk%2Fimage.png?alt=media&amp;token=3a236c7c-1f00-430b-92f3-42799346aa3c" alt="" width="563"><figcaption></figcaption></figure></div>

### ❔ Dépannage

**`401 Unauthorized`**  : soit l’en-tête `Authorization` est absent, soit la clé est incorrecte. Les clés doivent être transmises sous la forme `Authorization: Bearer sk-unsloth-…`. Si vous avez perdu la clé, créez-en une nouvelle dans **Paramètres → API.** Unsloth n’affiche pas les anciennes clés après leur création.

**`Lost connection to the model server`**  : Unsloth n’a pas pu joindre le serveur llama.cpp sous-jacent. En général, le chargement du modèle est terminé, mais celui-ci a planté, ou l’onglet du modèle a été fermé dans Unsloth. Rechargez le modèle depuis **Nouvelle discussion** et réessayez.

**Claude Code affiche le modèle Anthropic par défaut au lieu de mon modèle local**  : vérifiez que les trois variables d’environnement sont exportées dans le **même** shell que celui où vous exécutez `claude`:

```bash
echo $ANTHROPIC_BASE_URL
echo $ANTHROPIC_AUTH_TOKEN
echo $ANTHROPIC_MODEL
```

Exécutez ensuite `/model` dans Claude Code pour vérifier. Sous Windows PowerShell, utilisez `$env:ANTHROPIC_BASE_URL` etc.

**`stream: true` renvoie un seul bloc JSON au lieu d’un flux SSE**  : vérifiez que vous utilisez le bon chemin (`/v1/messages` ou `/v1/chat/completions`) et que votre client HTTP consomme bien la réponse sous forme de flux, au lieu de la mettre en mémoire tampon.

**Je ne trouve pas le nom du modèle à ajouter à opencode (ou à OpenClaw, ou à un autre client)** : demandez directement à Unsloth. `GET /v1/models` renvoie l’ID exact du modèle à saisir dans le champ « Model ID » du client :

```bash
curl http://localhost:8888/v1/models \
  -H "Authorization: Bearer sk-unsloth-xxxxxxxxxxxx"
```

Vous obtiendrez une réponse JSON de la forme `{"data": [{"id": "gemma-4-26B-A4B-it-GGUF", ...}]}`. Copiez la valeur `id`  : c’est ce qu’attend le champ **Model ID** (colonne de gauche) d’opencode et celui qu’attend OpenClaw dans `models[].id` . Le nom affiché à droite est libre : choisissez celui que vous voulez montrer aux utilisateurs.

**Les appels d’outils ne sont pas exécutés** : le modèle doit prendre en charge l’appel d’outils pour les outils côté client (`tools` / `tool_choice`). Pour les outils intégrés d’Unsloth, pensez à définir `enable_tools: true` **et à** indiquer ceux que vous souhaitez utiliser dans `enabled_tools` (par ex. `["python", "web_search"]`).

* **Mon client signale une erreur de connexion.** Ouvrez le moniteur d’API. Si aucun appel n’apparaît, il n’est jamais parvenu à Unsloth. Comparez l’URL de base de votre client à l’ **URL de base** affichée en haut de cette page.
* **La réponse est tronquée.** Vérifiez la valeur **Contexte utilisé** pour la requête dans le moniteur d’API. Une valeur proche de 100 %, ou une raison d’arrêt égale à `length`, signifie que la fenêtre de contexte est saturée, et non que le modèle a échoué.


---

# 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/fr/notions-de-base/api.md?ask=<question>&goal=<user_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.
