> 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](/docs/fr/notions-de-base/claude-code.md) et [Codex](/docs/fr/notions-de-base/codex.md) en connectant ces outils au **point de terminaison d’API compatible avec OpenAI**. Cela vous permet d’exécuter des modèles comme [Qwen](/docs/fr/modeles/qwen3.6.md) et [Gemma](/docs/fr/modeles/gemma-4.md) localement pour le codage agentique. Unsloth dispose également de fonctionnalités utiles telles que l’auto-réparation de **l’appel d’outils**, **l’exécution de code**, et **la recherche web**.

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

* [**Appel d’outils auto-réparateur**](/docs/fr/nouveau/studio/chat.md#auto-healing-tool-calling), ce qui aide à réduire de 50 % les appels d’outils cassés ou mal formés
* [**Exécution de code**](/docs/fr/nouveau/studio/chat.md#code-execution) support, permettant l’exécution de Bash et Python pour des sorties de code plus précises.
* **Avancé** [**Recherche web**](/docs/fr/nouveau/studio/chat.md#advanced-web-search) qui visite et lit réellement les pages web pour recueillir des informations approfondies.
* [**Inférence automatique** paramètres](/docs/fr/nouveau/studio/chat.md#auto-parameter-tuning) pour les modèles GGUF (temp, top-k, etc.)

{% columns %}
{% column %}
Les modèles chargés dans Unsloth (y compris les GGUF) sont exposés comme 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 votre agent IA, SDK ou client de chat préféré. Unsloth parle deux dialectes sur le même port. Les deux prennent en charge le streaming, l’appel d’outils (OpenAI `outils` / Anthropic `outils`), 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 via votre propre point de terminaison distant compatible avec OpenAI, vous pouvez lui donner accès à l’ensemble des outils d’Unsloth, y compris la recherche 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

La manière 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 l’installeur Unsloth (`.dmg`, `.exe` fichiers)
2. Faites glisser Unsloth vers 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és à votre appareil, puis téléchargez-les. Une fois terminé, commencez à discuter — aucune configuration requise.

<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 maintenant prêt

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

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

<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éation d’une clé API

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

<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é depuis la même page à tout moment. Les requêtes effectuées avec une clé révoquée échoueront avec `401 Unauthorized`.

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

### ⏳ Chargement du modèle

{% stepper %}
{% step %}

#### Sélectionner un modèle

Avant d’utiliser l’API, chargez un modèle depuis le **Select model** menu déroulant 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` recommandée.
{% 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 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="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 n’exposent pas l’API externe. Voir Installation.
2. **Chargez un modèle GGUF.** chargez un modèle GGUF à l’aide de la commande run. Cela chargera également l’interface sur le port par défaut. L’URL du point de terminaison et la clé API seront affichées dans la console, prêtes à être utilisées 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 si nécessaire.

#### Chargement d’un modèle depuis la CLI

Vous pouvez charger un modèle et faire créer automatiquement une clé API pour vous à l’aide de l’outil `unsloth` CLI. Lorsque le modèle a fini de se charger, l’URL du point de terminaison et la clé API sont affichées dans votre console. Copiez-les dans le client de votre choix et vous êtes prêt.

#### 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. Voir [installation](/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
```

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

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

Vous pouvez désigner un modèle de plusieurs façons. Choisissez celle qui vous semble la plus simple :

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

# Séparé : dépôt et variante comme deux options (ancienne méthode, fonctionne toujours)
unsloth run --model unsloth/gemma-4-26B-A4B-it-GGUF --gguf-variant UD-Q4_K_XL

# Utilisation de -hf / --hf-repo (correspond à l’orthographe de llama.cpp, pratique si vous venez de là)
unsloth run -hf unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL
```

### Ajuster l’exécution (facultatif)

Vous n’avez besoin d’aucun de ces éléments pour un chargement basique, mais `unsloth run` prend en charge de nombreux drapeaux d’exécution de llama-server pour personnaliser les performances, l’utilisation 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 paramètres par défaut d’Unsloth. Si aucun paramètre/option d’échantillonnage n’est défini, Unsloth sélectionne automatiquement les meilleurs paramètres recommandés pour le modèle, y compris la longueur du contexte, la température, etc.

#### Contrôler le comportement de raisonnement

Certains modèles capables de raisonnement prennent en charge des options supplémentaires pour contrôler la réflexion et le comportement de 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
```

L’effort de raisonnement et les options dépendent de ce que le modèle prend en charge.

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

Les paramètres d’échantillonnage contrôlent à quel point le modèle est créatif, ciblé ou déterministe pendant la génération.

```bash
# Réduire l’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 sorties plus stables, tandis que les paramètres top-p, top-k, min-p et repeat penalty contrôlent davantage la sélection des jetons et les répétitions.

```bash
# Ajuster la sélection des jetons et le comportement de répétition
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 les threads CPU

Utile si vous travaillez sur de grands projets, de longues discussions ou des flux de travail agentiques nécessitant plus de mémoire.

```bash
# Utiliser une fenêtre de contexte plus grande et davantage de threads CPU
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 s’exécute que localement sur votre machine. Vous pouvez exposer l’API à d’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 des outils comme la recherche web et l’exécution de code sont exposés par le serveur d’inférence.

```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, y compris le dimensionnement du contexte, les couches GPU, le threading, l’échantillonnage, le réseau et la configuration des outils.

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

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

`unsloth run` contrôle si les outils côté serveur (recherche web, exécution de code, etc.) sont exposés par le serveur d’inférence. Les valeurs par défaut dépendent de l’adresse de liaison :

* **`127.0.0.1` (localhost)** — outils **activés** par défaut. Seule votre machine peut atteindre le serveur.
* **`0.0.0.0` ou toute adresse non loopback** — outils **désactivés** par défaut. Une clé API divulguée sur un serveur exposé au réseau signifie une exécution de code arbitraire sur l’hôte.

**Options :**

* `--enable-tools` / `--disable-tools` — forcer l’activation ou la désactivation. Activé `0.0.0.0`, `--enable-tools` affiche une invite de sécurité y/N.
* `--yes` / `-y` — ignorer l’invite (pour l’automatisation).

La politique résolue est une surcouche stricte au niveau du processus — les requêtes individuelles ne peuvent pas la contourner via `enable_tools=true` dans le corps de la requête.

<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%2FeIJIvZl7HvOCjtVPm3en%2Funsloth_run_model.png?alt=media&amp;token=84c45c38-78a9-4b55-b9b7-08bad9dc6238" alt=""><figcaption></figcaption></figure></div>

### 🌐 Points de terminaison

Unsloth expose son API sur le port sur lequel il a démarré, généralement `http://localhost:8000` ou `http://localhost:8888`.

Authentifiez-vous avec un en-tête `Authorization: Bearer sk-unsloth-…` sur 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        | Objectif                                                                                    |
| --------------------------- | ------------------------------------------------------------------------------------------- |
| `POST /v1/chat/completions` | Achèvements de chat compatibles OpenAI, avec streaming et appel d’outils.                   |
| `POST /v1/responses`        | API Responses compatible OpenAI pour Codex et autres clients compatibles.                   |
| `POST /v1/messages`         | API Messages compatible Anthropic pour Claude Code, OpenClaw et autres clients compatibles. |
| `POST /v1/completions`      | Achèvements de texte sans formatage de chat. Nécessite un modèle GGUF ou MLX.               |

Pour les requêtes Responses, envoyez l’historique de 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 de jetons**

| Point de terminaison             | Objectif                                                                                                                    |
| -------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
| `GET /v1/models`                 | Liste les modèles chargés et disponibles localement. Vérifiez `chargé` pour identifier 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érez des embeddings à l’aide d’un GGUF d’embedding chargé ou du modèle d’embedding configuré d’Unsloth.                  |
| `POST /v1/chat/count_tokens`     | Compte les jetons de prompt pour les messages au format OpenAI.                                                             |
| `POST /v1/messages/count_tokens` | Compte les jetons d’entrée pour les messages au format Anthropic.                                                           |

**Images**

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

**Audio**

| Point de terminaison            | Objectif                                                                                                                                 |
| ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| `POST /v1/audio/speech`         | Synthèse vocale compatible OpenAI.                                                                                                       |
| `POST /v1/audio/generate`       | Génère de la parole à partir de messages au format chat ; renvoie un audio WAV en base64.                                                |
| `POST /v1/audio/transcriptions` | Transcrit un fichier audio téléversé.                                                                                                    |
| `POST /v1/audio/translations`   | Traduit en anglais la parole contenue dans un fichier audio téléversé.                                                                   |
| `POST /v1/audio/inputs`         | Téléversez un audio pour réutilisation. Envoyez l’audio en tant que corps brut de la requête.                                            |
| `POST /v1/audio/run`            | Exécutez un flux de travail audio, comme le clonage, l’édition, la conversion, la génération musicale ou la séparation, selon le modèle. |

Prise en charge des entrées audio stockées `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                | Objectif                                          |
| ----------------------------------- | ------------------------------------------------- |
| `POST /v1/videos`                   | Créez une tâche de génération vidéo.              |
| `GET /v1/videos`                    | Liste les tâches vidéo.                           |
| `GET /v1/videos/{video_id}`         | Obtenir le statut 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éo nécessite des modèles prenant en charge la tâche demandée.

**Décisions structurées**

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

Activez l’API Decision dans **Paramètres → API** et sélectionnez d’abord un modèle de décision. Les requêtes utilisent `état` et nommés `questions`, avec les types de questions `nul`, `choix`, ou `score`.

**Explorez votre API locale**

Ouvrez `http://localhost:8888/docs` pour 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 de votre instance Unsloth.

Cette référence reflète votre version installée et inclut les routes internes d’Unsloth. Certaines routes de compatibilité sont masquées, et les corps de requête analysés manuellement peuvent ne pas avoir de schémas complets.

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

### 🖇️ Connexion de votre client

Unsloth vous permet d'exécuter des LLM locaux via la plupart des frameworks, notamment [Claude Code](/docs/fr/notions-de-base/claude-code.md), [Codex](/docs/fr/notions-de-base/codex.md), [OpenClaw](/docs/fr/integrations/openclaw.md), [OpenCode](/docs/fr/integrations/opencode.md) et bien d’autres. Cliquez sur les outils spécifiques ci-dessous pour obtenir un guide :

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

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

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

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

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

{% content-ref url="/pages/46b648652a387a143566a8cd8b635a0b50c00204" %}
[Python SDK](/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 avec `unsloth studio --secure`. Unsloth reste lié à localhost et se publie sur une URL HTTPS Cloudflare gratuite ; 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 survivent pas à un tunnel rapide Cloudflare, donc définissez `stream: false` lors d’un appel via celui-ci.

### 🧰 Appel d’outils

Les deux points de terminaison prennent en charge l’appel de fonctions / d’outils dans leur format natif, ainsi qu’un raccourci spécifique à Unsloth pour les outils intégrés d’Unsloth.

**Outils de style OpenAI :** envoyer `outils` et `tool_choice` à `/v1/chat/completions` exactement comme avec OpenAI. Claude Code (via `/v1/messages`) , opencode, Cursor, Continue et Cline fonctionnent tous immédiatement.

**Outils de style Anthropic :** envoyer `outils` (avec `input_schema`) et `tool_choice` à `/v1/messages` exactement comme avec Claude.

Outils côté serveur d’Unsloth : Unsloth peut exécuter Python, des recherches web et bash *côté serveur* et diffuser les résultats en retour sous forme d’ `tool_result` événements. Activez cette option en ajoutant ces champs supplémentaires à l’un ou l’autre point de terminaison :

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

Le modèle voit la sortie de chaque outil à son tour suivant. Pour une couverture plus approfondie (schémas, événements de streaming, chaînage), voir .

{% hint style="info" %}
Si vous utilisez l’Anthropic `/v1/messages` point de terminaison, `tool_choice` se mappe proprement : Anthropic `auto` → OpenAI `auto`, Anthropic `n’importe lequel` → OpenAI `obligatoire`, Anthropic `{type: "tool", name: "x"}` → OpenAI `{type: "function", function: {name: "x"}}`, Anthropic `aucun` → OpenAI `aucun`.
{% endhint %}

### 📈 Moniteur d’API

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

Le panneau latéral du moniteur d’API s’ouvre dans le coin dès que du trafic avec clé API arrive. Il résume le modèle actif, les requêtes en direct, 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>

Appuyez sur "Expand to full monitor" ou allez dans Paramètres>Moniteur API pour accéder à la page complète **API** où le chargement du modèle, les prompts, les réponses, les comptes de jetons, le délai jusqu’au premier jeton, le débit et les messages d’erreur sont affichés dans le moniteur.

<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 le `Authorization` header est manquant ou la clé est incorrecte. Les clés doivent être transmises sous forme de `Authorization: Bearer sk-unsloth-…`. Si vous avez perdu la clé, créez-en une nouvelle depuis **Paramètres → API.** Unsloth n’affiche pas les anciennes clés après leur création.

**`Connexion perdue avec le serveur de modèle`**  : Unsloth n’a pas pu joindre le serveur llama.cpp sous-jacent. En général, le modèle a fini de se charger mais a planté, ou l’onglet du modèle a été fermé dans Unsloth. Rechargez le modèle depuis **Nouveau chat** et réessayez.

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

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

Puis exécutez `/model` dans Claude Code pour confirmer. Sous Windows PowerShell, utilisez `$env:ANTHROPIC_BASE_URL` etc.

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

**Je ne trouve pas le nom du modèle à ajouter à opencode (ou OpenClaw / tout autre client)**  : demandez directement à Unsloth. `GET /v1/models` renvoie l’identifiant exact du modèle que vous devez renseigner dans le champ "Model ID" du client :

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

Vous obtiendrez une charge utile JSON de la forme `{"data": [{"id": "gemma-4-26B-A4B-it-GGUF", ...}]}`. Copiez la `id` valeur, c’est la chaîne que le **Model ID** champ (colonne de gauche) et celui d’OpenClaw `models[].id` attendent. Le nom affiché à droite est 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 (`outils` / `tool_choice`). Pour les outils intégrés d’Unsloth, n’oubliez pas de définir `enable_tools: true` **et** listez ceux que vous voulez dans `enabled_tools` (p. ex. `["python", "web_search"]`).

* **Mon client signale une erreur de connexion.** Ouvrez le moniteur d’API. S’il n’y a aucune ligne pour l’appel, cela signifie qu’il n’a jamais atteint Unsloth ; comparez l’URL de base de votre client avec la **Base URL** affichée en haut de cette page.
* **La réponse est tronquée.** Vérifiez **Contexte utilisé** dans la requête dans le moniteur d’API. À près de 100 %, ou une raison d’arrêt `length`, signifie que la fenêtre de contexte est pleine plutôt que le modèle ait é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.