> 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/modeles/inkling-2-mini.md).

# Guide pour exécuter Inkling 2 Mini en local

Découvrez comment exécuter localement Inkling 2 Mini de Thinking Machines Lab avec Unsloth et llama.cpp.

**Inkling 2 Mini** est le modèle de Thinking Machines Lab **MoE de 26,4 milliards de paramètres (5,4 milliards actifs)** destiné au codage, aux agents et aux tâches de **vision**  . Publié sous licence Apache 2.0 et basé sur une variante de Looped Transformers, il dispose d’un **contexte de 1 million de tokens** et obtient **48,2 % sur DeepSWE v1.1** et **77,9 % sur SWEBench Pro v2 (Hard)**, ce qui en fait le modèle le plus performant de sa catégorie, devant Qwen3.8-27B. Il est à égalité avec Qwen3.8-27B sur Terminal Bench 4.0, avec un score de **5.6%**.

{% columns %}
{% column %}
Ce guide explique comment exécuter Inkling 2 Mini sur un Mac ou un appareil NVIDIA ou AMD avec Unsloth Desktop, qui utilise moins de mémoire et offre une inférence plus rapide pour le modèle.

Exécution avec 16 Go de RAM ou **24 Go de RAM** en **précision intégrale**. GGUF : [**GGUF d’Inkling 2 Mini**](https://huggingface.co/unsloth/Inkling-2-Mini-GGUF)

<a href="https://unsloth.ai/docs/fr/modeles/inkling-2-mini.md#run-inkling-2-mini-guide" class="button primary">Guide d’exécution d’Inkling 2</a><a href="https://unsloth.ai/download" class="button secondary">Télécharger Unsloth</a>
{% endcolumn %}

{% column %}

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fbnhx2GlFHFh3fjMdbN26%2Fgta%20example.gif?alt=media&amp;token=6f9605aa-3c77-4796-a014-96214063f1b0" alt="" width="563"><figcaption><p>Exemple d’Inkling Mini en 4 bits exécuté dans Unsloth</p></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

### ⚙️ Guide d’utilisation

#### Configuration requise pour Inkling 2 Mini

**`UD-Q8_K_XL`** est en **précision intégrale**. La quantification recommandée est **`UD-Q4_K_XL` (17,6 Go).**

**Tableau : configuration matérielle requise** (RAM + VRAM, ou mémoire unifiée)

| 1 bit | 2 bits     | 3 bits     | 4 bits     | 8 bits (sans perte) |
| ----- | ---------- | ---------- | ---------- | ------------------- |
| 9 Go  | 10 à 11 Go | 13 à 15 Go | 17 à 18 Go | 24 Go               |

Consultez [l’analyse de la quantification](#quantization-analysis) pour connaître toutes les tailles et tous les résultats des fichiers GGUF.

{% hint style="success" %}
Utilisez ces plages comme point de départ. Les contextes plus longs, les images en entrée et les autres applications peuvent nécessiter davantage de mémoire. Le fichier `mmproj-F16.gguf` du projecteur de vision ajoute 639 Mo au téléchargement.
{% endhint %}

#### Paramètres recommandés

| Température | Top-p | Top-k | Min-p |
| ----------- | ----- | ----- | ----- |
| `1.0`       | `1.0` | `0`   | `0.0` |

## Guide rapide pour exécuter Inkling 2 Mini

Utilisez une version d’Unsloth ou de llama.cpp prenant en charge les **couches bouclées** et les **échelles NVFP4 par expert**. [Fiche du modèle Inkling 2 Mini](https://huggingface.co/unsloth/Inkling-2-Mini-GGUF)

<a href="https://unsloth.ai/docs/fr/modeles/inkling-2-mini.md#run-inkling-2-mini-in-unsloth-desktop" class="button primary">Exécuter dans Unsloth Desktop</a><a href="https://unsloth.ai/docs/fr/modeles/inkling-2-mini.md#run-inkling-2-mini-in-llama-cpp" class="button secondary">Exécuter dans llama.cpp</a>

<div><figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fc9F8coH46gJj7gxZEhRU%2Fsnow-fall.webp?alt=media&amp;token=2ede2108-5204-405d-9e6a-57d1a903c5f0" alt=""><figcaption></figcaption></figure> <figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FXRbHGqQn9DJR1prbs4w5%2Flighthouse.webp?alt=media&amp;token=e17bd9b1-d5d4-4659-b532-8373188e3811" alt=""><figcaption></figcaption></figure></div>

### 🦥 Exécuter Inkling 2 Mini dans Unsloth Desktop <a href="#run-inkling-2-mini-in-unsloth-desktop" id="run-inkling-2-mini-in-unsloth-desktop"></a>

{% stepper %}
{% step %}

#### Installer Unsloth

Téléchargez et lancez l’application [Unsloth Desktop](https://unsloth.ai/docs/fr/desktop.md) pour macOS, Windows ou Linux.

<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 :

{% tabs %}
{% tab title="Installation native" %}
**MacOS, Linux, WSL :**

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

**Windows :**

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

{% endtab %}

{% tab title="Docker" %}
Le [L'image Docker Unsloth](https://hub.docker.com/r/unsloth/unsloth) `unsloth/unsloth` est disponible sur Docker. [Lire le guide.](https://unsloth.ai/docs/get-started/install/docker)
{% endtab %}

{% tab title="Homebrew" %}
Installer Unsloth Desktop :

{% code collapsedlinecount="10" %}

```bash
brew install --cask unsloth
```

{% endcode %}

Mettre à jour Unsloth Desktop :

```bash
brew upgrade --cask unsloth
```

{% endtab %}

{% tab title="WinGet" %}
Installer Unsloth Desktop :

```powershell
winget install --id UnslothAI.Unsloth -e
```

Mettre à jour Unsloth Desktop :

```powershell
winget upgrade --id UnslothAI.Unsloth -e
```

{% endtab %}
{% endtabs %}
{% endstep %}

{% step %}

#### Rechercher et télécharger Inkling 2 Mini

Dans **Discussion**, ouvrez **Sélectionner un modèle**, ou accédez au **Catalogue de modèles**. Recherchez **Inkling 2 Mini**, sélectionnez [**unsloth/Inkling-2-Mini-GGUF**](https://huggingface.co/unsloth/Inkling-2-Mini-GGUF) et téléchargez la quantification adaptée à votre appareil. Une fois le téléchargement terminé, sélectionnez le modèle dans Discussion et démarrez une conversation. Vous pouvez également charger un fichier Mini GGUF compatible depuis vos fichiers locaux.
{% endstep %}

{% step %}

#### Exécuter et héberger Inkling 2 Mini avec l’API Unsloth

Cet exemple utilise la quantification 4 bits `UD-Q4_K_XL` (17.63 Go). Modifiez le suffixe après les deux-points pour sélectionner une autre quantification du dépôt.

{% code overflow="wrap" %}

```bash
unsloth run --model unsloth/Inkling-2-Mini-GGUF:UD-Q4_K_XL \
    --temp 1.0 --top-p 1.0 --top-k 0 --min-p 0.0
```

{% endcode %}

Utilisez l’URL du point de terminaison et la clé API affichées dans le terminal pour connecter votre client. [Guide de l’API Unsloth](https://unsloth.ai/docs/fr/notions-de-base/api.md)
{% endstep %}
{% endstepper %}

### 🦙 Exécuter Inkling 2 Mini dans llama.cpp <a href="#run-inkling-2-mini-in-llama-cpp" id="run-inkling-2-mini-in-llama-cpp"></a>

{% stepper %}
{% step %}

#### Installer llama.cpp

Les fichiers GGUF à la racine du dépôt utilisent la disposition en couches bouclées d’Unsloth ; utilisez donc notre [b12588-mix-c0c3de8](https://github.com/unslothai/llama.cpp/releases/tag/b12588-mix-c0c3de8) version, qui prend également en charge DSpark. La version amont de llama.cpp lit une disposition différente : pour llama.cpp principal, utilisez les fichiers [Mainline\_Support](https://huggingface.co/unsloth/Inkling-2-Mini-GGUF/tree/main/Mainline_Support) . Exécutez ces commandes depuis le dossier dans lequel vous téléchargerez le fichier GGUF. Chacune extrait `llama-server` dans un dossier `llama.cpp` dossier, afin que les étapes suivantes fonctionnent telles quelles. [Téléchargements précompilés](https://github.com/unslothai/llama.cpp/releases/tag/b12588-mix-c0c3de8)

{% tabs %}
{% tab title="Apple" %}
{% code overflow="wrap" %}

```bash
curl -L -o llama.tar.gz https://github.com/unslothai/llama.cpp/releases/download/b12588-mix-c0c3de8/llama-b12588-mix-c0c3de8-bin-macos-arm64.tar.gz
mkdir -p llama.cpp
tar -xzf llama.tar.gz -C llama.cpp --strip-components=1
./llama.cpp/llama-server --version
```

{% endcode %}
{% endtab %}

{% tab title="NVIDIA" %}
**CUDA 12** compilation pour la plupart des GPU NVIDIA : séries RTX 20 à RTX 50, V100, T4, A100, H100 et B200. Installez d’abord le [kit de développement CUDA](https://developer.nvidia.com/cuda-downloads) . Avec CUDA 13, remplacez `cuda12-portable` par `cuda13-portable`. Pour les séries GTX 10 et les modèles antérieurs, utilisez `cuda12-legacy`.

{% code overflow="wrap" %}

```bash
curl -L -o llama.tar.gz https://github.com/unslothai/llama.cpp/releases/download/b12588-mix-c0c3de8/app-b12588-mix-c0c3de8-linux-x64-cuda12-portable.tar.gz
mkdir -p llama.cpp
tar -xzf llama.tar.gz -C llama.cpp
./llama.cpp/llama-server --version
```

{% endcode %}
{% endtab %}

{% tab title="AMD" %}
**ROCm** compilation pour les Radeon RX 9000 (`gfx120X`). Les bibliothèques ROCm sont incluses, il n’est donc pas nécessaire d’installer ROCm au complet. Pour les autres GPU, remplacez `gfx120X` par `gfx1151` (Ryzen AI Max), `gfx1150` (Ryzen AI 300), `gfx110X` (RX 7000), `gfx103X` (RX 6000), `gfx90a` (MI200) ou `gfx908` (MI100). Pour tout autre GPU AMD, utilisez la compilation `vulkan` .

{% code overflow="wrap" %}

```bash
curl -L -o llama.tar.gz https://github.com/unslothai/llama.cpp/releases/download/b12588-mix-c0c3de8/app-b12588-mix-c0c3de8-linux-x64-rocm-gfx120X.tar.gz
mkdir -p llama.cpp
tar -xzf llama.tar.gz -C llama.cpp
./llama.cpp/llama-server --version
```

{% endcode %}
{% endtab %}

{% tab title="Windows" %}
**CUDA 12** compilation pour les GPU NVIDIA. Installez d’abord le [kit de développement CUDA](https://developer.nvidia.com/cuda-downloads) , puis exécutez ces commandes dans PowerShell. Avec CUDA 13, remplacez `cuda12-portable` par `cuda13-portable`. Pour AMD, remplacez-le par `rocm-gfx120X` ou la version compilée pour votre GPU dans l’onglet AMD. Utilisez `vulkan` pour les autres GPU ou `cpu` pour utiliser uniquement le processeur.

{% code overflow="wrap" %}

```powershell
curl.exe -L -o llama.zip https://github.com/unslothai/llama.cpp/releases/download/b12588-mix-c0c3de8/app-b12588-mix-c0c3de8-windows-x64-cuda12-portable.zip
Expand-Archive llama.zip -DestinationPath llama.cpp
.\llama.cpp\llama-server.exe --version
```

{% endcode %}
{% endtab %}

{% tab title="DGX Spark" %}
{% code overflow="wrap" %}

```bash
curl -L -o llama.tar.gz https://github.com/unslothai/llama.cpp/releases/download/b12588-mix-c0c3de8/app-b12588-mix-c0c3de8-linux-arm64-cuda13-portable.tar.gz
mkdir -p llama.cpp
tar -xzf llama.tar.gz -C llama.cpp
./llama.cpp/llama-server --version
```

{% endcode %}
{% endtab %}
{% endtabs %}

Pour les Mac Intel, l’utilisation du processeur uniquement, Vulkan ou Linux ARM64, choisissez le fichier correspondant sur la [page des versions](https://github.com/unslothai/llama.cpp/releases/tag/b12588-mix-c0c3de8). Gardez `llama-server` et les bibliothèques qui l’accompagnent ensemble dans `llama.cpp`.
{% endstep %}

{% step %}

#### Télécharger le GGUF

Téléchargez le modèle 4 bits `UD-Q4_K_XL` au format GGUF, le projecteur de vision F16 et le modèle drafter DSpark Q8\_0. Pour une autre quantification, utilisez le nom de fichier correspondant dans le dépôt. [Fichiers GGUF](https://huggingface.co/unsloth/Inkling-2-Mini-GGUF/tree/main)

{% code overflow="wrap" collapsedlinecount="10" %}

```bash
pip install -U huggingface_hub
hf download unsloth/Inkling-2-Mini-GGUF \
    Inkling-2-Mini-UD-Q4_K_XL.gguf mmproj-F16.gguf dspark-Inkling-2-Mini-Q8_0.gguf \
    --local-dir Inkling-2-Mini-GGUF
```

{% endcode %}
{% endstep %}

{% step %}

#### Exécuter Inkling 2 Mini

Démarrez le serveur de chat local avec le binaire précompilé.

{% tabs %}
{% tab title="macOS, Linux ou WSL" %}
{% code overflow="wrap" collapsedlinecount="10" %}

```bash
./llama.cpp/llama-server \
    --model Inkling-2-Mini-GGUF/Inkling-2-Mini-UD-Q4_K_XL.gguf \
    --mmproj Inkling-2-Mini-GGUF/mmproj-F16.gguf \
    --model-draft Inkling-2-Mini-GGUF/dspark-Inkling-2-Mini-Q8_0.gguf \
    --spec-type draft-dspark --spec-draft-n-max 3 --n-gpu-layers-draft 99 \
    --temp 1.0 --top-p 1.0 --top-k 0 --min-p 0.0 \
    --host 127.0.0.1 --port 8080
```

{% endcode %}
{% endtab %}

{% tab title="Windows PowerShell" %}
{% code overflow="wrap" collapsedlinecount="10" %}

```powershell
.\llama.cpp\llama-server.exe `
    --model Inkling-2-Mini-GGUF/Inkling-2-Mini-UD-Q4_K_XL.gguf `
    --mmproj Inkling-2-Mini-GGUF/mmproj-F16.gguf `
    --model-draft Inkling-2-Mini-GGUF/dspark-Inkling-2-Mini-Q8_0.gguf `
    --spec-type draft-dspark --spec-draft-n-max 3 --n-gpu-layers-draft 99 `
    --temp 1.0 --top-p 1.0 --top-k 0 --min-p 0.0 `
    --host 127.0.0.1 --port 8080
```

{% endcode %}
{% endtab %}
{% endtabs %}

Ouvrez <http://127.0.0.1:8080> pour discuter ou envoyer une image. Les options `--model-draft` et `--spec-type draft-dspark` activent le décodage spéculatif DSpark avec le modèle drafter de 0,4 Go, et l’option `--spec-draft-n-max 3` est une bonne valeur par défaut. Pour l’exécuter sans, retirez le drafter du téléchargement et les lignes `--model-draft` et `--spec-type` de la commande du serveur. Pour un chat texte uniquement, omettez le projecteur du téléchargement et retirez `--mmproj` de la commande du serveur. Si la mémoire est limitée, réduisez `--ctx-size` ou `--n-gpu-layers`. Pour une inférence uniquement sur CPU, définissez `--n-gpu-layers 0` et `--n-gpu-layers-draft 0`.
{% endstep %}
{% endstepper %}

### :play\_pause:Architecture de transformeur à couches répétées

Inkling-2-Mini utilise une architecture de transformeur à couches répétées modifiée, dans laquelle les couches 6 à 17 sont répétées 3 fois. Combinée aux embeddings, elle n’active que 5,4 milliards de paramètres. Cela diffère des autres architectures de LLM, où chaque couche du décodeur n’est exécutée qu’une seule fois : Inkling-2-Mini exécute essentiellement les couches 6 à 17 trois fois, ce qui réduit efficacement son espace disque et son empreinte pendant l’entraînement.

La rumeur **veut** que la classe de modèles GPT-6 Astra puisse également utiliser une variante de l’architecture de transformeur à couches répétées, et Inkling-2-Mini est l’un des premiers modèles ouverts puissants à mettre en œuvre une variante de ce mécanisme.

### 📊 Analyse de la quantification <a href="#quantization-analysis" id="quantization-analysis"></a>

Nous comparons chaque GGUF à `UD-Q8_K_XL` dans sept domaines, avec des paramètres llama.cpp identiques. La référence conserve les poids experts NVFP4 d’origine et stocke les poids restants en BF16. UD-Q4\_K\_XL est également presque sans perte, avec les poids MXFP8 déquantifiés en Q8\_0. UD-Q8\_K\_XL convertit MXFP8 en BF16, de sorte que KLD = 0.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FqWPOI9paCJed36b9qV1x%2Fsize_vs_top1(7).png?alt=media&amp;token=186fd174-4199-4d66-949e-fc851aa614ef" alt="" width="563"><figcaption></figcaption></figure>

La quantification 4 bits `UD-Q4_K_XL` obtient **une KLD moyenne de 0,0107** et **un accord de 98,0 % sur le jeton le mieux classé** pour **17,63 Go**. La quantification 2 bits `UD-IQ2_XXS` réduit le téléchargement à **8,49 Go** avec un **accord de 90,6 %**.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FObpB27Pzg7eddzGOefoK%2Fsize_vs_kld(4).png?alt=media&amp;token=b388d982-caaa-402f-bc8f-f49938036713" alt="" width="563"><figcaption></figcaption></figure>

| Quantification | Taille (Go) | KLD moyenne par rapport à UD-Q8\_K\_XL | Même jeton le mieux classé |
| -------------- | ----------- | -------------------------------------- | -------------------------- |
| UD-IQ1\_S      | 7.76        | 0.0911                                 | 89.4%                      |
| UD-IQ1\_M      | 8.02        | 0.0867                                 | 90.2%                      |
| UD-IQ2\_XXS    | 8.49        | 0.0726                                 | 90.6%                      |
| UD-Q2\_K\_XL   | 9.14        | 0.0595                                 | 91.6%                      |
| UD-IQ3\_XXS    | 11.66       | 0.0269                                 | 94.7%                      |
| UD-Q3\_K\_XL   | 13.63       | 0.0174                                 | 96.3%                      |
| UD-IQ4\_XS     | 15.73       | 0.0109                                 | 97.7%                      |
| UD-Q4\_K\_M    | 16.61       | 0.0108                                 | 97.9%                      |
| UD-Q4\_K\_XL   | 17.63       | 0.0107                                 | 98.0%                      |
| UD-Q8\_K\_XL   | 22.87       | référence                              |                            |

### 📊 Benchmarks

Dans les évaluations de Thinking Machines Lab, Mini devance les trois modèles de taille similaire ci-dessous sur les benchmarks de génie logiciel et de recherche indiqués. Mini obtient un score **supérieur de 6,0 points de pourcentage à celui de Qwen3.8-27B sur DeepSWE v1.1** et **supérieur de 4,1 points à celui-ci sur SWEBench Pro v2 (Hard)**.

<details>

<summary>Cliquez pour afficher le tableau complet des benchmarks</summary>

| Benchmark                                 | Inkling 2 Mini   | Gemma 4 31B  | Muse Glimmer | Qwen3.8-27B  | Nemotron 3.5 Super VL |
| ----------------------------------------- | ---------------- | ------------ | ------------ | ------------ | --------------------- |
| Paramètres (actifs / total, en milliards) | 5 / 26           | 31 / 31      | 30 / 30      | 27 / 27      | 12 / 125              |
| SWE-bench Verified                        | **79.2%**        | 46.1%        | 76.0%        | 77.8%        | 71.1%                 |
| DeepSWE v1.1                              | **48.2%**        | 0.3%         | 4.4%         | 42.2%        | 24.7%                 |
| Terminal Bench v4.0                       | **5.6%**         | 0.0%         | 0.5%         | **5.6%**     | 0.0%                  |
| AA Index v5.0                             | **20.1**         | 4.4          | 6.3          | **20.1**     | 13.6                  |
| Vals Index v2.2                           | **46.5%**        | –            | –            | –            | 29.8%                 |
| SWE-bench Pro (Hard)                      | **77.9%**        | 14.2%        | 44.3%        | 73.8%        | 44.1%                 |
| Terminal Bench v2.1                       | 71.6%            | 43.4%        | 51.7%        | **73.0%**    | 60.7%                 |
| BrowseComp                                | **79.0%**        | 37.0%        | 63.9%        | 61.6%        | 78.9%                 |
| DeepSearchQA                              | **85.3%**        | 61.7%        | 74.6%        | 79.7%        | 77.7%                 |
| GDPVal-AA v2.1                            | 1319             | 627          | 792          | **1427**     | 1162                  |
| AutomationBench-AA                        | 41.8%            | 4.9%         | 6.8%         | **48.2%**    | 14.8%                 |
| JobBench                                  | **49.6%**        | 8.2%         | 16.1%        | 33.4%        | 36.5%                 |
| MMMU Pro                                  | 74.9%            | 73.4%        | 74.3%        | **76.3%**    | 72.3%                 |
| OmniDocBench v1.6                         | **92.8%**        | 82.5%        | 90.4%        | 91.5%        | 77.9%                 |
| ScreenSpot Pro (original / Python)        | **76.5 / 87.7%** | 5.9 / –      | 75.4 / –     | 57.6 / 78.9% | 43.5 / –              |
| Chartography (original / Python)          | **22.1 / 72.5%** | 12.0 / 11.8% | 17.4 / 25.1% | 12.2 / 52.1% | 9.7 / 29.3%           |
| HLE-Diamond                               | 15.2%            | 7.2%         | 9.1%         | **15.3%**    | 8.8%                  |
| ARC-AGI (v1 / v2)                         | **84.5 / 49.3%** | –            | –            | 87.5 / 42.4% | 22.7 / 1.5%           |
| LongBench v2                              | **66.9%**        | 52.9%        | 33.1%        | 52.3%        | 62.1%                 |
| AA-Omniscience (score)                    | -8.6             | -48.5        | -32.2        | -6.4         | **-2.9**              |
| AA-Omniscience (absence d’hallucinations) | 63.4%            | 14.5%        | 16.4%        | **71.4%**    | 69.5%                 |
| FORTRESS (adversarial)                    | 89.5%            | 67.8%        | **90.3%**    | 78.8%        | 79.6%                 |
| FORTRESS (bénin)                          | 96.4%            | 97.6%        | 89.1%        | **97.8%**    | 92.7%                 |
| StrongREJECT                              | 97.8%            | 98.1%        | 99.0%        | 99.0%        | **99.4%**             |

</details>


---

# 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/modeles/inkling-2-mini.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.
