> 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 le fine-tuning des LLM sans écrire de code. Elle encapsule 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éesExporterChat #### Configurer Unsloth Studio Tout d'abord, lancez Unsloth Studio soit via une installation locale, soit via 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 fournit désormais une manière sécurisée de lancer Unsloth en HTTPS via 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** documents, images et audio dans vos prompts * [**Ajuster** inférence](#generation-settings) des réglages tels que : 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 des modèles Avant d'utiliser l'API, vous devez **charger le modèle** que vous souhaitez utiliser dans **Unsloth.** Ouvrez l’ **menu déroulant Sélectionner un modèle** menu déroulant 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 un 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 et exportés localement peuvent être chargés depuis l'onglet \`Fine-tuned\`. {% 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électionnez 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échargement et son chargement. Après avoir sélectionné une variante de modèle, 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 à être utilisé. 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 préremplies * **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 état 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, commutables via un sélecteur en pastilles : | Méthode | Description | VRAM | | ----------------------- | ---------------------------------------------------- | -------------- | | **QLoRA** | Modèle de base quantifié en 4 bits + adaptateur LoRA | La plus faible | | **LoRA** | Modèle de base en pleine précision + adaptateur LoRA | Moyen | | **Fine-tuning complet** | Tous les poids sont entraînés | La plus élevée | Saisissez n'importe quel nom de modèle Hugging Face ou recherchez directement sur le Hub depuis la liste déroulante. 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 %} Basculez entre deux onglets pour choisir d'où proviennent vos données : * **Hub Hugging Face** - recherche en direct sur le Hub. La date de dernière mise à jour est affichée pour chaque résultat. * **Local** - glissez-déposez ou cliquez pour téléverser un fichier, qu'il soit non structuré ou structuré, 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 l'utiliser | | ---------- | -------------------------------------------------- | | `auto` | Laissez Unsloth détecter automatiquement le format | | `alpaca` | `instruction` / `input` / `output` colonnes | | `chatml` | style OpenAI `messages` tableau | | `sharegpt` | Conversations de type ShareGPT | **Partitions et découpage** * **Sous-ensemble** - renseigné automatiquement à partir de la fiche du jeu de données. * **Partition d'entraînement / partition d'évaluation** - choisissez quelles partitions utiliser. Le fait de définir une partition d'évaluation active le **Perte d'évaluation** graphique pendant l'entraînement. * **Tranche du jeu de données** - restreignez éventuellement l'entraînement à une plage de lignes (index de début / index 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'attribuer chaque colonne à `instruction`, `input`, `output`, `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 max. d'étapes** | `0` | `0` signifie qu'il faut utiliser des époques à la place | | **Longueur de 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. Affiner : | 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 du lot | 4 | | Accumulation des gradients | 8 | | Décroissance des poids | 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 d'Unsloth | unsloth | | Graine aléatoire | 3407 | | Étapes de sauvegarde | 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 d'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 la VRAM par rapport à l'option PyTorch standard. C'est le paramètre par défaut recommandé. {% endhint %} ### 4. Entraînement et configuration La carte en bas à droite comporte trois boutons de gestion de 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 au format 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é tant qu'un modèle et un jeu de données ne sont pas tous deux configurés. Les erreurs de validation s'affichent en ligne — par exemple, définir des étapes d'évaluation sans choisir une 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**, une superposition plein écran apparaît pendant que le backend prépare tout.
{% endcolumn %} {% column %} La superposition 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 à l'aide du **×** bouton dans le coin. Une boîte de dialogue de confirmation s'affichera avant tout arrêt. {% endcolumn %} {% endcolumns %} ### Progression et observabilité de l'entraînement Une fois la première étape d'entraînement lancée, la superposition disparaît et la vue d'entraînement en direct apparaît. Le fine-tuning est terminé lorsque les étapes atteignent 100 % sur la barre de progression. Vous pouvez voir 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 un pourcentage * **Métriques clés**: * **Perte** - perte d'entraînement à 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 temporelle** - 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 donne deux choix : * **Arrêter et enregistrer** - enregistre un checkpoint avant l'arrêt * **Annuler** - arrête immédiatement sans checkpoint {% 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 EMA et une ligne de référence de moyenne glissante 2. **Taux d'apprentissage** - la courbe de planification du 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 possède des 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 brut | Sur | | Afficher lissé | Sur | | Afficher la ligne moyenne | Sur | | Échelle (par série) | Linéaire / Log | | Troncature des valeurs aberrantes | Aucune troncature / 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 ... logging: report_to: none ... ``` {% endcode %} Cela permet de reproduire facilement les exécutions, de partager les configurations ou de gérer vos expériences via un système de contrôle de version. ## :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 jeux de données utilisables. Créez et modifiez visuellement des jeux de données via un workflow de graphe de nœuds. La page des recettes est le point d’entrée principal. Les recettes sont stockées localement dans le navigateur, ce qui vous permet de retrouver plus tard votre travail enregistré. À partir de là, vous pouvez créer une recette vierge ou ouvrir une recette d’apprentissage guidée.
Data Recipes suit le même parcours de base. Vous ouvrez la page des recettes, créez ou choisissez une recette, construisez le workflow dans l'éditeur, le validez, lancez un aperçu, puis exécutez le jeu de données complet une fois que le résultat est correct. Ajoutez des données de départ et des blocs de génération, validez le workflow, prévisualisez un exemple de sortie, puis lancez la génération complète du jeu de données. Unsloth Data Recipes est propulsé par NVIDIA [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 jeu de données. 4. Cliquez sur **Validez** pour détecter rapidement les problèmes de configuration. 5. Lancez un aperçu pour examiner rapidement des lignes d’exemple. 6. Lancez une génération complète du jeu de données lorsque la recette est prête. 7. Suivez la progression et la sortie en direct dans le graphe ou dans **Exécutions** vue pour plus de détails. 8. Sélectionnez le jeu de données résultant dans **Unsloth** et affinez un modèle. ## :box-isometric: Export - 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 checkpoint 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 Le CLI Unsloth (`cli.py`) fournit les commandes suivantes : ``` Utilisation : cli.py [COMMANDE] Commandes : train Affiner un modèle inference Exécuter l'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 CLI ├── cli/ # Commandes CLI Typer │ └── commands/ │ ├── train.py │ ├── inference.py │ ├── export.py │ ├── ui.py │ └── studio.py ├── setup.sh # Script d'initialisation (Linux / WSL / Colab) ├── setup.ps1 # Script d'initialisation (Windows natif) ├── setup.bat # Wrapper pour lancer setup.ps1 par double-clic ├── install_python_stack.py # Installateur de dépendances Python multiplateforme └── 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 de requête/réponse Pydantic │ ├── 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 suivi de l'entraînement │ │ │ ├── studio/ # Espace de travail principal du studio │ │ │ ├── chat/ # Interface de chat pour l'inférence │ │ │ ├── export/ # Flux d'export du modèle │ │ │ └── onboarding/# Assistant d'intégration │ │ ├── components/ # Composants UI partagés (shadcn) │ │ ├── hooks/ # Hooks React personnalisés │ │ ├── stores/ # Stores d'état Zustand │ │ └── types/ # Définitions de types TypeScript │ ├── package.json │ └── vite.config.ts └── tests/ # Suite de tests backend ``` {% endcode %} ### Référence de l'API Tous les points de terminaison nécessitent un JWT valide `Autorisation : Bearer ` en-tête (sauf `/api/auth/*` et `/api/health`). | Méthode | Point de terminaison | Description | | ------- | --------------------- | -------------------------------------------------------------------------- | | `GET` | `/api/health` | Vérification de l'état | | `GET` | `/api/system` | Informations système (GPU, CPU, mémoire) | | `POST` | `/api/auth/signup` | Créer un compte (nécessite un jeton de configuration au 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 | | `POST` | `/api/train/reset` | Réinitialiser l'état d'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, taux d'apprentissage, é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 jeux 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.