> 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/nouveau/studio/start.md). # Commencez avec Unsloth Studio Unsloth Studio est une interface graphique locale, basée sur le navigateur, pour affiner des LLM sans écrire de code. Elle enveloppe le pipeline d'entraînement dans une interface claire qui gère le chargement du modèle, le formatage du jeu de données, la configuration des hyperparamètres et le suivi en direct de l'entraînement. UnslothRecette de donnéesExporterle chat #### Configurer Unsloth Studio **Installez avec Unsloth Desktop.** La façon la plus simple d'installer Unsloth Studio est d'utiliser l'application native Desktop. Téléchargez-la pour votre système d'exploitation : * :apple: [Télécharger pour macOS](https://unsloth.ai/download/mac) * :windows: [Télécharger pour Windows](https://unsloth.ai/download/windows) * :linux: [Télécharger pour Linux](https://unsloth.ai/download/linux) Tout d'abord, lancez Unsloth Studio en utilisant soit une installation locale, soit une option cloud. Suivez le [les instructions d'installation](/docs/fr/nouveau/studio/install.md) pour votre configuration, ou utilisez notre [Colab gratuit](/docs/fr/nouveau/studio.md#google-colab-notebook) notebook. Pour une configuration locale, exécutez : ```bash unsloth studio -H 0.0.0.0 -p 8888 ``` {% columns %} {% column width="50%" %} Ouvrez le navigateur de votre choix et rendez-vous sur `http://127.0.0.1:8888`. Vous devrez créer un nouveau mot de passe. **Lancez Unsloth en toute sécurité avec HTTPS et Cloudflare.** Unsloth propose désormais une manière sécurisée de lancer Unsloth via HTTPS à l'aide d'un tunnel Cloudflare gratuit. Utilisez ce qui suit (fonctionne sous Windows, Mac et Linux) : ```bash unsloth studio --secure ``` {% endcolumn %} {% column width="50%" %}
{% endcolumn %} {% endcolumns %} ## :comment-dots: Chat - Démarrage rapide [Chat d'Unsloth Studio](/docs/fr/nouveau/studio/chat.md) vous permet d'exécuter des modèles à 100 % hors ligne sur votre ordinateur. Exécutez des formats de modèles comme GGUF et safetensors depuis Hugging Face ou depuis vos fichiers locaux. * **Télécharger + exécuter** n'importe quel modèle comme des GGUF, des adaptateurs fine-tunés, des safetensors, etc. * [**Comparer** modèle différent](#model-arena) sorties côte à côte * **Téléverser** des documents, des images et de l'audio dans vos prompts * [**Ajuster** l'inférence](#generation-settings) des paramètres comme : température, top-p, top-k et prompt système
Vous pouvez lire notre tutoriel / guide détaillé sur l'exécution de modèles avec Unsloth Studio ici : {% content-ref url="/pages/02de109936ce31121bffae3333822baa85a115f0" %} [Studio Chat](/docs/fr/nouveau/studio/chat.md) {% endcontent-ref %} ### Guide de chargement du modèle Avant d'utiliser l'API, vous devez **charger le modèle** que vous souhaitez utiliser dans **Unsloth.** Ouvrez la **Sélectionner un modèle** liste déroulante dans le coin supérieur gauche de la page de chat.
{% hint style="info" %} Sur une autre page ? Utilisez la barre latérale gauche et cliquez sur `Nouveau chat` pour revenir à la page de chat. {% endhint %} {% columns %} {% column width="50%" %} #### Sélectionner le modèle Utilisez la barre de recherche pour trouver le modèle que vous souhaitez charger dans Unsloth. Parcourez les modèles recommandés, recherchez directement des modèles Hugging Face, ou définissez un répertoire de modèle personnalisé. Les modèles entraînés localement et exportés peuvent être chargés depuis l'onglet \`Ajusté finement\`. {% endcolumn %} {% column width="50%" %}
{% endcolumn %} {% endcolumns %} {% columns %} {% column %} #### Sélection GGUF Les dépôts de modèles contiennent plusieurs quantifications. Sélectionnez la quantification la plus adaptée à votre RAM / VRAM disponible.\n\nDans ce guide, nous utiliserons `unsloth/gemma-4-26B-A4B-it-GGUF` et sélectionnerons la `UD-Q4_K_XL` variante {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} #### Téléchargement du modèle {% columns %} {% column %} Recherchez le modèle que vous souhaitez utiliser, puis **cliquez dessus** pour commencer à le télécharger et à le charger. Une fois une variante de modèle sélectionnée, Unsloth commencera à télécharger et à charger le modèle en mémoire. Une fois le chargement terminé, vous verrez la confirmation suivante : {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} Le modèle est chargé et prêt à l'emploi. Vous pouvez maintenant discuter directement avec le modèle dans Unsloth ou le connecter à des outils tels que [Claude Code](/docs/fr/bases/claude-code.md) et [Codex](/docs/fr/bases/codex.md).
## :bolt: Unsloth - Démarrage rapide La page d'accueil d'Unsloth Studio comporte 4 zones principales : [Modèle](#id-1.-select-model-and-method), [Jeu de données](#id-2.-dataset), [Paramètres](#id-3.-hyperparameters), et [Entraînement/Configuration](#id-4.-training-and-config) * **Configuration facile des modèles et des données** depuis Hugging Face ou des fichiers locaux * **Choix d'entraînement flexibles** comme QLoRA, LoRA ou le fine-tuning complet, avec des valeurs par défaut déjà renseignées * **Outils de configuration utiles** pour les partitions, le mappage des colonnes, les hyperparamètres et les configurations YAML * **Excellente visibilité sur l'entraînement** avec progression en direct, statistiques GPU, graphiques et statut de démarrage
### 1. Sélectionnez le modèle et la méthode #### **Type de modèle** Sélectionnez la modalité qui correspond à votre cas d'utilisation : | Type | Cas d'utilisation | | -------------- | --------------------------------------- | | **Texte** | Chat, suivi d'instructions, complétion | | **Vision** | Image + texte (VLM) | | **Audio** | Compréhension de la parole / de l'audio | | **Embeddings** | Embeddings de phrases, recherche | #### **Méthode d'entraînement** Trois méthodes sont disponibles, activées à l'aide d'un sélecteur en pilule : | Méthode | Description | VRAM | | ----------------------- | ---------------------------------------------------- | -------------- | | **QLoRA** | Modèle de base quantifié en 4 bits + adaptateur LoRA | Le plus faible | | **LoRA** | Modèle de base en pleine précision + adaptateur LoRA | Moyen | | **Fine-tuning complet** | Tous les poids sont entraînés | Le plus élevé | Saisissez n'importe quel nom de modèle Hugging Face ou recherchez directement dans le Hub depuis la zone combinée. Les modèles locaux stockés dans `~/.unsloth/studio/models` et votre cache Hugging Face apparaissent également dans la liste. {% hint style="warning" %} Les modèles au format GGUF sont exclus de l'entraînement - ils sont réservés à l'inférence. {% endhint %} Lorsque vous choisissez un modèle, Unsloth récupère automatiquement sa configuration depuis le backend et préremplit des valeurs par défaut pertinentes pour tous les hyperparamètres. **Jeton Hugging Face** Collez ici votre jeton d'accès Hugging Face si le modèle est protégé (par ex. Llama, Gemma). Le jeton est validé en temps réel et une erreur s'affiche en ligne s'il est invalide. ### 2. Jeu de données {% columns %} {% column %} Passez d'un onglet à l'autre pour choisir l'origine de vos données : * **Hub Hugging Face** - recherche en direct dans le Hub. La date de dernière mise à jour est affichée pour chaque résultat. * **Local** - glisser-déposer ou cliquer pour téléverser un fichier non structuré ou des fichiers structurés comme : `PDF`, `DOCX`, `JSONL`, `JSON`, `CSV`, ou `Parquet` format. Les jeux de données téléversés précédemment apparaissent dans une liste qui se rafraîchit automatiquement. Vous pouvez consulter notre [guide des jeux de données ici](/docs/fr/commencer/fine-tuning-llms-guide/datasets-guide.md). Indiquez à Unsloth comment interpréter et formater vos données : {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} | Format | Quand utiliser | | ---------- | -------------------------------------------------- | | `auto` | Laissez Unsloth détecter automatiquement le format | | `alpaca` | `instruction` / `entrée` / `sortie` colonnes | | `chatml` | de style OpenAI `messages` tableau | | `sharegpt` | conversations de style ShareGPT | **Partitions et découpage** * **Sous-ensemble** - rempli automatiquement à partir de la fiche du jeu de données. * **Partition d'entraînement / partition d'évaluation** - choisissez quelles partitions utiliser. Définir une partition d'évaluation active le **Perte d'évaluation** graphique pendant l'entraînement. * **Tranche de jeu de données** - restreindre éventuellement l'entraînement à une plage de lignes (indice de début / indice de fin) pour des expériences rapides. **Mappage des colonnes** Si Unsloth ne peut pas mapper automatiquement les colonnes de votre jeu de données vers les bons rôles, une **boîte de dialogue d'aperçu du jeu de données** s'ouvre. Elle affiche des lignes d'exemple et vous permet d'assigner chaque colonne à `instruction`, `entrée`, `sortie`, `image`, etc. Les mappages suggérés sont préremplis lorsque c'est possible. ### 3. Hyperparamètres Les paramètres sont regroupés en sections repliables. Vous pouvez consulter notre [guide des hyperparamètres LoRA](/docs/fr/commencer/fine-tuning-llms-guide/lora-hyperparameters-guide.md) ici : {% content-ref url="/pages/f4254d24125c1e7ad4d5ad30f1a9c8f7d36e7c4d" %} [Hyperparameters Guide](/docs/fr/commencer/fine-tuning-llms-guide/lora-hyperparameters-guide.md) {% endcontent-ref %} | Paramètre | Par défaut | Notes | | --------------------------- | ---------- | ---------------------------------------------- | | **Nombre maximal d'étapes** | `0` | `0` signifie d'utiliser les époques à la place | | **Longueur du contexte** | `2048` | Options : 512 → 32768 | | **Taux d'apprentissage** | `2e-4` | | **Paramètres LoRA** *(Masqué lorsque le fine-tuning complet est sélectionné)* | Paramètre | Par défaut | Notes | | ------------------ | ----------- | --------------------------------------------------------------------------- | | **Rang** | `16` | Curseur 4–128 | | **Alpha** | `32` | Curseur 4–256 | | **Dropout** | `0.05` | | | **Variante LoRA** | `LoRA` | `LoRA` / `RS-LoRA` / `LoftQ` | | **Modules cibles** | Tout activé | `q_proj`, `k_proj`, `v_proj`, `o_proj`, `gate_proj`, `up_proj`, `down_proj` | Pour **Vision** pour les modèles avec un jeu de données d'images, quatre cases à cocher supplémentaires apparaissent. Affinez : | Couches de vision | Couches de langage | Modules d'attention | Modules MLP | | ----------------- | ------------------ | ------------------- | ----------- | **Hyperparamètres d'entraînement** Organisés en trois onglets : {% tabs %} {% tab title="Optimisation" %} | Paramètre | Par défaut | | -------------------------- | ------------ | | Époques | 3 | | Taille de lot | 4 | | Accumulation des gradients | 8 | | Décroissance pondérale | 0.01 | | Optimiseur | AdamW 8 bits | {% endtab %} {% tab title="Planification" %} | Paramètre | Par défaut | | ------------------------------------- | ---------- | | Planificateur du taux d'apprentissage | linéaire | | Étapes de préchauffage | 5 | | Checkpointing des gradients | unsloth | | Graine aléatoire | 3407 | | Étapes d'enregistrement | 0 | | Étapes d'évaluation | 0 | | Empaquetage | false | | Entraîner sur les complétions | false | | {% endtab %} | | {% tab title="Journalisation" %} | Paramètre | Par défaut | | --------------------------- | -------------- | | Activer W\&B | false | | Projet W\&B | llm-finetuning | | Activer TensorBoard | false | | Répertoire TensorBoard | runs | | Fréquence de journalisation | 10 | | {% endtab %} | | | {% endtabs %} | | {% hint style="info" %} [**Checkpointing des gradients Unsloth**](/docs/fr/blog/500k-context-length-fine-tuning.md#unsloth-gradient-checkpointing-enhancements)**: `unsloth`** utilise l'implémentation personnalisée d'Unsloth, économe en mémoire, qui peut réduire considérablement l'utilisation de VRAM par rapport à l'option PyTorch standard. C'est la valeur par défaut recommandée. {% endhint %} ### 4. Entraînement et configuration La carte en bas à droite comporte trois boutons de gestion de la configuration et le **Démarrer l'entraînement** bouton. | Bouton | Action | | ----------------- | ------------------------------------------------------------- | | **Téléverser** | Charger un `.yaml` fichier de configuration | | **Enregistrer** | Exporter la configuration actuelle en YAML | | **Réinitialiser** | Rétablir tous les paramètres aux valeurs par défaut du modèle | Le bouton Démarrer l'entraînement reste désactivé jusqu'à ce qu'un modèle et un jeu de données soient tous deux configurés. Les erreurs de validation s'affichent en ligne - par exemple, définir des étapes d'évaluation sans choisir de partition d'évaluation, ou associer un modèle texte uniquement à un jeu de données visuel. #### Écran de chargement {% columns %} {% column %} Après avoir cliqué sur **Démarrer l'entraînement**, un calque plein écran apparaît pendant que le backend prépare tout.
{% endcolumn %} {% column %} Le calque affiche un terminal animé avec des mises à jour de phase en direct : * Bleu : téléchargement du modèle / jeu de données * Ambre : chargement du modèle / jeu de données * Bleu : configuration * Vert : entraînement Vous pouvez annuler à tout moment en utilisant le **×** bouton dans le coin. Une boîte de dialogue de confirmation apparaîtra avant tout arrêt. {% endcolumn %} {% endcolumns %} ### Progression de l'entraînement et observabilité Une fois la première étape d'entraînement atteinte, le calque disparaît et la vue d'entraînement en direct apparaît. Le processus de fine-tuning est terminé lorsque les étapes atteignent 100 % sur la barre de progression. Vous pouvez consulter le temps écoulé et les jetons.
{% columns %} {% column %} #### Panneau d'état La colonne de gauche affiche : * **Époque** - époque fractionnaire actuelle (par ex. `Époque 1.23`) * **Barre de progression** - basée sur les étapes, avec pourcentage * **Métriques clés**: * **Perte** - perte d'entraînement avec 4 décimales * **LR** - taux d'apprentissage actuel en notation scientifique * **Norme du gradient** - norme du gradient * **Modèle** - le modèle en cours d'entraînement * **Méthode** - `QLoRA` / `LoRA` / `Complet` * **Ligne de temps** - temps écoulé, ETA, étapes par seconde et nombre total de jetons traités {% endcolumn %} {% column %} #### Moniteur GPU La colonne de droite affiche des statistiques GPU en direct relevées toutes les quelques secondes : * **Utilisation** - barre de pourcentage * **Température** - barre en °C * **VRAM** - Go utilisés / total * **Puissance** - consommation / limite en watts #### Arrêt de l'entraînement Utilisez le **Arrêter l'entraînement** bouton en haut à droite de la carte de progression. Une boîte de dialogue vous offre deux choix : * **Arrêter et enregistrer** - enregistre un point de contrôle avant l'arrêt * **Annuler** - s'arrête immédiatement sans point de contrôle {% endcolumn %} {% endcolumns %} {% columns %} {% column %} #### Graphiques Quatre graphiques en direct se mettent à jour au fur et à mesure de l'entraînement : 1. **Perte d'entraînement** - valeurs brutes, plus une courbe lissée par EMA et une courbe de référence de moyenne glissante 2. **Taux d'apprentissage** - la courbe du planificateur de LR 3. **Norme du gradient** - norme du gradient au fil des étapes 4. **Perte d'évaluation** - affiché uniquement lorsque vous avez configuré une partition d'évaluation {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} {% columns %} {% column %} Chaque graphique dispose de paramètres (icône d'engrenage) avec : | Option | Par défaut | | ------------------------------- | ------------------------------ | | Fenêtre d'affichage | Curseur des N dernières étapes | | Lissage EMA | `0.6` | | Afficher les données brutes | Activé | | Afficher la version lissée | Activé | | Afficher la ligne de moyenne | Activé | | Échelle (par série) | Linéaire / Log | | Écrêtage des valeurs aberrantes | Aucun écrêtage / p99 / p95 | | {% endcolumn %} | | {% column %}
{% endcolumn %} {% endcolumns %} #### Fichiers de configuration {% columns %} {% column %} Toutes les configurations d'entraînement peuvent être enregistrées et rechargées sous forme de fichiers YAML. Les fichiers sont nommés automatiquement comme suit : ``` {model}_{method}_{dataset}_{timestamp}.yaml ``` {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} Le YAML est structuré en trois sections : {% code expandable="true" %} ```yaml training: max_steps: 0 num_train_epochs: 3 per_device_train_batch_size: 4 ... lora: r: 16 lora_alpha: 32 ... journalisation : envoyer_vers : aucun ... ``` {% endcode %} Cela facilite la reproduction des exécutions, le partage des configurations ou le versionnement de vos expériences. ## :hat-chef: Recettes de données - Démarrage rapide [Recettes de données Unsloth](/docs/fr/nouveau/studio/data-recipe.md) vous permet de téléverser des documents comme des PDF ou des fichiers CSV et de les transformer en ensembles de données utilisables. Créez et modifiez visuellement des ensembles de données via un flux de travail en nœuds graphiques. La page des recettes est le point d’entrée principal. Les recettes sont stockées localement dans le navigateur, vous pouvez donc revenir plus tard au travail enregistré. À partir d’ici, vous pouvez créer une recette vierge ou ouvrir une recette d’apprentissage guidé.
Les Recettes de données suivent le même parcours de base. Vous ouvrez la page des recettes, créez ou choisissez une recette, construisez le flux de travail dans l’éditeur, le validez, exécutez un aperçu, puis lancez l’ensemble de données complet une fois que le résultat semble correct. Ajoutez des données d’amorçage et des blocs de génération, validez le flux de travail, prévisualisez un exemple de sortie, puis lancez la création d’un ensemble de données complet. Unsloth Data Recipes est propulsé par NVIDIA DataDesigner [DataDesigner](https://github.com/NVIDIA-NeMo/DataDesigner). À première vue, un flux de travail habituel devrait ressembler à ceci : 1. Ouvrez la page des recettes. 2. Créez une nouvelle recette ou ouvrez-en une existante. 3. Ajoutez des blocs pour définir le flux de travail de votre ensemble de données. 4. Cliquez sur **Valider** pour détecter rapidement les problèmes de configuration. 5. Exécutez un aperçu pour inspecter rapidement des lignes d’exemple. 6. Lancez une création complète de l’ensemble de données lorsque la recette est prête. 7. Suivez la progression et la sortie en direct dans le graphe ou dans la vue **Exécutions** pour plus de détails. 8. Sélectionnez l’ensemble de données résultant dans **Unsloth** et ajustez finement un modèle. ## :box-isometric: Exportation - Démarrage rapide Utilisez « Export » dans Unsloth Studio pour exporter, enregistrer ou convertir des modèles en GGUF, Safetensors ou LoRA pour le déploiement, le partage ou l’inférence locale dans Unsloth, llama.cpp, Ollama, vLLM, et plus encore. Exportez un point de contrôle entraîné ou convertissez n’importe quel modèle existant.
Vous pouvez lire notre tutoriel / guide détaillé sur l’exportation de modèles avec Unsloth Studio ici : {% content-ref url="/pages/817a1275219e1e8d86fe100d223ac4b0862ab3a1" %} [Model Export](/docs/fr/nouveau/studio/export.md) {% endcontent-ref %} ## :video: Tutoriel vidéo {% hint style="warning" %} Les versions d’Unsloth Studio montrées dans les vidéos sont anciennes et ne reflètent pas la version actuelle. {% endhint %} {% columns %} {% column %} {% embed url="" %} Voici un tutoriel vidéo créé par NVIDIA pour vous aider à démarrer avec Unsloth : {% endcolumn %} {% column %} {% embed url="" %} Tutoriel vidéo d’installation d’Unsloth Studio {% endcolumn %} {% endcolumns %} ## Paramètres avancés ### Commandes CLI L’interface en ligne de commande Unsloth (`cli.py`) fournit les commandes suivantes : ``` Utilisation : cli.py [COMMANDE] Commandes : train Ajuster finement un modèle inference Exécuter une inférence sur un modèle entraîné export Exporter un adaptateur entraîné list-checkpoints Lister les points de contrôle enregistrés ui Lancer l’interface web d’Unsloth Studio studio Lancer le studio (alias) ``` ### Structure du projet {% code expandable="true" %} ``` new-ui-prototype/ ├── cli.py # Point d’entrée de l’interface en ligne de commande ├── cli/ # Commandes CLI Typer │ └── commands/ │ ├── train.py │ ├── inference.py │ ├── export.py │ ├── ui.py │ └── studio.py ├── setup.sh # Script d’amorçage (Linux / WSL / Colab) ├── setup.ps1 # Script d’amorçage (Windows natif) ├── setup.bat # Wrapper pour lancer setup.ps1 par double-clic ├── install_python_stack.py # Installateur multiplateforme des dépendances Python └── studio/ ├── backend/ │ ├── main.py # Application FastAPI et middleware │ ├── run.py # Lanceur du serveur (uvicorn) │ ├── auth/ # Stockage de l’authentification et logique JWT │ ├── routes/ # Gestionnaires des routes API │ │ ├── training.py │ │ ├── models.py │ │ ├── inference.py │ │ ├── datasets.py │ │ └── auth.py │ ├── models/ # Schémas Pydantic de requête/réponse │ ├── core/ # Moteur d’entraînement et configuration │ ├── utils/ # Détection du matériel, utilitaires │ └── requirements.txt ├── frontend/ │ ├── src/ │ │ ├── features/ # Modules de fonctionnalités │ │ │ ├── auth/ # Flux de connexion / inscription │ │ │ ├── training/ # Configuration et surveillance de l’entraînement │ │ │ ├── studio/ # Espace de travail principal du studio │ │ │ ├── chat/ # Interface de chat d’inférence │ │ │ ├── export/ # Flux d’exportation du modèle │ │ │ └── onboarding/# Assistant d’intégration │ │ ├── components/ # Composants UI partagés (shadcn) │ │ ├── hooks/ # Hooks React personnalisés │ │ ├── stores/ # Magasins d’état Zustand │ │ └── types/ # Définitions de types TypeScript │ ├── package.json │ └── vite.config.ts └── tests/ # Suite de tests du backend ``` {% endcode %} ### Référence de l’API Tous les points de terminaison nécessitent un JWT valide `Authorization: Bearer ` en-tête (sauf `/api/auth/*` et `/api/health`). | Méthode | Point de terminaison | Description | | ------- | --------------------- | ------------------------------------------------------------------------------- | | `GET` | `/api/health` | Vérification de santé | | `GET` | `/api/system` | Informations système (GPU, CPU, mémoire) | | `POST` | `/api/auth/signup` | Créer un compte (nécessite un jeton de configuration lors du premier lancement) | | `POST` | `/api/auth/login` | Se connecter et recevoir des jetons JWT | | `POST` | `/api/auth/refresh` | Actualiser un jeton d’accès expiré | | `GET` | `/api/auth/status` | Vérifier si l’authentification est initialisée | | `POST` | `/api/train/start` | Démarrer une tâche d’entraînement | | `POST` | `/api/train/stop` | Arrêter une tâche d’entraînement en cours d’exécution | | `POST` | `/api/train/reset` | Réinitialiser l’état de l’entraînement | | `GET` | `/api/train/status` | Obtenir l’état actuel de l’entraînement | | `GET` | `/api/train/metrics` | Obtenir les métriques d’entraînement (perte, LR, étapes) | | `GET` | `/api/train/stream` | Flux SSE de la progression de l’entraînement en temps réel | | `GET` | `/api/models/` | Lister les modèles disponibles | | `POST` | `/api/inference/chat` | Envoyer un message de chat pour l’inférence | | `GET` | `/api/datasets/` | Lister / gérer les ensembles de données | --- # 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/nouveau/studio/start.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.