> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/plateformes-et-agents-ia/gpt4all.md).

# GPT4All LLM local

## Aperçu

[GPT4All](https://github.com/nomic-ai/gpt4all) de Nomic AI est l’un des projets LLM locaux open-source les plus populaires, avec plus de **72 000 étoiles GitHub**. Il vous permet d’exécuter des modèles de langage de grande taille entièrement hors ligne sur votre propre matériel — aucune connexion Internet requise, aucune donnée envoyée à des tiers.

GPT4All est surtout connu pour son application de bureau soignée, mais il inclut également une **bibliothèque Python** (`gpt4all` package) et un **serveur API compatible OpenAI** fonctionnant sur le port **4891**. Sur Clore.ai, vous pouvez déployer GPT4All dans un conteneur Docker sur un GPU loué, le servir via HTTP et connecter n’importe quel client compatible OpenAI.

> **Remarque Docker :** GPT4All ne publie pas d’image Docker officielle pour le composant serveur. Ce guide utilise une configuration Docker personnalisée avec le `gpt4all` package Python. Pour une alternative Docker plus prête pour la production qui exécute les **mêmes fichiers de modèle GGUF**, voir la [section alternative LocalAI](#alternative-localai-docker-image) — LocalAI est axé Docker et prend en charge le même format de modèle.

**Fonctionnalités clés :**

* 🔒 100 % hors ligne — toutes les inférences s’exécutent localement
* 🤖 API REST compatible OpenAI (port 4891)
* 📚 LocalDocs — RAG sur vos propres documents
* 🧩 Prend en charge tous les formats de modèles GGUF populaires
* 🐍 API Python complète avec `pip install gpt4all`
* 💬 Superbe interface de bureau (non pertinente pour le serveur, mais utile pour les tests locaux)

***

## Exigences

### Exigences matérielles

| Niveau             | GPU           | VRAM  | RAM   | Stockage   | Prix Clore.ai            |
| ------------------ | ------------- | ----- | ----- | ---------- | ------------------------ |
| **CPU uniquement** | Aucune        | —     | 16 Go | 50 Go SSD  | \~0,02 $/h (serveur CPU) |
| **GPU d’entrée**   | RTX 3060 12GB | 12 Go | 16 Go | 50 Go SSD  | \~0,10 $/h               |
| **Recommandé**     | RTX 3090      | 24 Go | 32 Go | 100 Go SSD | \~0,20 $/h               |
| **Haut de gamme**  | RTX 4090      | 24 Go | 64 Go | 200 Go SSD | \~0,35 $/h               |

> **Remarque :** La prise en charge GPU de GPT4All utilise CUDA via llama.cpp en coulisses. Contrairement à vLLM, elle **ne** exige une capacité de calcul CUDA spécifique — les RTX 10xx et plus récentes fonctionnent généralement.

### Exigences VRAM du modèle (GGUF Q4\_K\_M)

| Modèle                | Taille sur disque | VRAM    | GPU min     |
| --------------------- | ----------------- | ------- | ----------- |
| Phi-3 Mini 3.8B       | \~2,4 Go          | \~3 Go  | RTX 3060    |
| Mistral 7B Instruct   | \~4,1 Go          | \~5 Go  | RTX 3060    |
| Llama 3.1 8B Instruct | \~4,7 Go          | \~6 Go  | RTX 3060    |
| Llama 3 70B Instruct  | ≈40 Go            | \~45 Go | A100 80GB   |
| Mixtral 8x7B          | \~26 Go           | \~30 Go | 2× RTX 3090 |

***

## Démarrage rapide

### Étape 1 — Louer un serveur GPU sur Clore.ai

1. Connectez-vous à [clore.ai](https://clore.ai)
2. Filtrer : **Docker activé**, **GPU**: RTX 3090 (pour les modèles 7B–13B)
3. Déployer avec l’image : `nvidia/cuda:12.1.0-runtime-ubuntu22.04`
4. Ports ouverts : **4891** (API GPT4All), **22** (SSH)
5. Allouez au moins **50 Go** d’espace disque

### Étape 2 — Se connecter via SSH

```bash
ssh -p <CLORE_SSH_PORT> root@<CLORE_SERVER_IP>

# Vérifier le GPU
nvidia-smi
# Devrait lister votre GPU avec la version du pilote
```

### Étape 3 — Construire l’image Docker GPT4All

Comme il n’existe pas d’image Docker GPT4All officielle, nous allons en construire une :

```bash
mkdir -p /workspace/gpt4all-server && cd /workspace/gpt4all-server

cat > Dockerfile << 'EOF'
FROM nvidia/cuda:12.1.0-runtime-ubuntu22.04

ENV DEBIAN_FRONTEND=noninteractive
ENV PYTHONUNBUFFERED=1

# Installer Python et les dépendances système
RUN apt-get update && apt-get install -y \
    python3.11 \
    python3.11-dev \
    python3-pip \
    curl \
    wget \
    git \
    libgomp1 \
    && rm -rf /var/lib/apt/lists/*

# Faire de python3.11 le défaut
RUN update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.11 1 \
    && update-alternatives --install /usr/bin/python python python3.11 1

# Installer GPT4All avec le support CUDA
RUN pip install --upgrade pip && \
    pip install gpt4all>=2.8.0 fastapi uvicorn aiofiles pydantic

# Créer des répertoires
RUN mkdir -p /models /workspace /app

WORKDIR /app

# Copier le script serveur (sera monté ou inclus)
COPY server.py .

EXPOSE 4891

CMD ["python", "server.py"]
EOF
```

### Étape 4 — Créer le script du serveur API

```bash
cat > /workspace/gpt4all-server/server.py << 'PYEOF'
#!/usr/bin/env python3
"""
Serveur API GPT4All compatible OpenAI
S’exécute sur le port 4891 (par défaut GPT4All)
"""

import os
import time
import json
import asyncio
from typing import Optional, List, Dict, Any
from pathlib import Path

from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
import uvicorn
from gpt4all import GPT4All

# Configuration
MODEL_NAME = os.environ.get("MODEL_NAME", "Mistral 7B Instruct v0.1 Q4_0")
MODEL_PATH = os.environ.get("MODEL_PATH", "/models")
API_HOST = os.environ.get("API_HOST", "0.0.0.0")
API_PORT = int(os.environ.get("API_PORT", "4891"))
DEVICE = os.environ.get("DEVICE", "gpu")  # 'gpu', 'cpu', 'metal'
N_CTX = int(os.environ.get("N_CTX", "4096"))

app = FastAPI(title="GPT4All API Server", version="1.0.0")

# Instance globale du modèle
model = None

def load_model():
    global model
    print(f"Chargement du modèle : {MODEL_NAME}")
    print(f"Chemin du modèle : {MODEL_PATH}")
    print(f"Périphérique : {DEVICE}")
    model = GPT4All(
        model_name=MODEL_NAME,
        model_path=MODEL_PATH,
        device=DEVICE,
        n_ctx=N_CTX,
        allow_download=True,  # Téléchargements depuis le hub GPT4All si non présent
        verbose=True
    )
    print("Modèle chargé avec succès !")

# --- Modèles Pydantic ---

class Message(BaseModel):
    role: str
    content: str

class ChatCompletionRequest(BaseModel):
    model: str
    messages: List[Message]
    temperature: float = 0.7
    max_tokens: int = 512
    top_p: float = 0.95
    top_k: int = 40
    stream: bool = False

class CompletionRequest(BaseModel):
    model: str
    prompt: str
    temperature: float = 0.7
    max_tokens: int = 512
    stream: bool = False

# --- Routes API ---

@app.get("/health")
async def health():
    return {"status": "ok", "model": MODEL_NAME, "device": DEVICE}

@app.get("/v1/models")
async def list_models():
    return {
        "object": "list",
        "data": [{
            "id": MODEL_NAME,
            "object": "model",
            "created": int(time.time()),
            "owned_by": "gpt4all",
        }]
    }

@app.post("/v1/chat/completions")
async def chat_completions(request: ChatCompletionRequest):
    if model is None:
        raise HTTPException(status_code=503, detail="Model not loaded")

    # Formater les messages en une seule invite
    prompt_parts = []
    for msg in request.messages:
        if msg.role == "system":
            prompt_parts.append(f"### System:\n{msg.content}")
        elif msg.role == "user":
            prompt_parts.append(f"### Human:\n{msg.content}")
        elif msg.role == "assistant":
            prompt_parts.append(f"### Assistant:\n{msg.content}")
    prompt_parts.append("### Assistant:")
    full_prompt = "\n\n".join(prompt_parts)

    with model.chat_session():
        response_text = model.generate(
            full_prompt,
            max_tokens=request.max_tokens,
            temp=request.temperature,
            top_p=request.top_p,
            top_k=request.top_k,
        )

    return {
        "id": f"chatcmpl-{int(time.time())}",
        "object": "chat.completion",
        "created": int(time.time()),
        "model": request.model,
        "choices": [{
            "index": 0,
            "message": {"role": "assistant", "content": response_text},
            "finish_reason": "stop"
        }],
        "usage": {
            "prompt_tokens": len(full_prompt.split()),
            "completion_tokens": len(response_text.split()),
            "total_tokens": len(full_prompt.split()) + len(response_text.split())
        }
    }

@app.post("/v1/completions")
async def completions(request: CompletionRequest):
    if model is None:
        raise HTTPException(status_code=503, detail="Model not loaded")

    response_text = model.generate(
        request.prompt,
        max_tokens=request.max_tokens,
        temp=request.temperature,
    )

    return {
        "id": f"cmpl-{int(time.time())}",
        "object": "text_completion",
        "created": int(time.time()),
        "model": request.model,
        "choices": [{
            "text": response_text,
            "index": 0,
            "finish_reason": "stop"
        }]
    }

if __name__ == "__main__":
    load_model()
    uvicorn.run(app, host=API_HOST, port=API_PORT, log_level="info")
PYEOF
```

### Étape 5 — Construire et exécuter

```bash
cd /workspace/gpt4all-server

# Construire l’image Docker
docker build -t gpt4all-server:latest .

# Télécharger un modèle d’abord (optionnel — le serveur peut aussi télécharger automatiquement)
mkdir -p /workspace/models
wget -O /workspace/models/mistral-7b-instruct-v0.1.Q4_0.gguf \
  https://gpt4all.io/models/gguf/mistral-7b-instruct-v0.1.Q4_0.gguf

# Exécuter avec le support GPU
docker run -d \
  --name gpt4all-server \
  --gpus all \
  --restart unless-stopped \
  -p 4891:4891 \
  -v /workspace/models:/models \
  -v /workspace/gpt4all-server/server.py:/app/server.py \
  -e MODEL_NAME="mistral-7b-instruct-v0.1.Q4_0.gguf" \
  -e MODEL_PATH="/models" \
  -e DEVICE="gpu" \
  -e N_CTX="4096" \
  gpt4all-server:latest

# Suivre les logs
docker logs -f gpt4all-server
```

### Étape 6 — Tester l’API

```bash
# Vérification de l’état
curl http://localhost:4891/health

# Lister les modèles
curl http://localhost:4891/v1/models

# Complétion de chat
curl http://localhost:4891/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-7b-instruct-v0.1.Q4_0.gguf",
    "messages": [
      {"role": "user", "content": "Quelle est la capitale de la France ?"}
    ],
    "temperature": 0.7,
    "max_tokens": 256
  }'
```

***

## Alternative : image Docker LocalAI

Pour un déploiement Docker plus robuste et prêt pour la production qui exécute les **mêmes modèles GGUF** que GPT4All, LocalAI est le choix recommandé. Il dispose d’une image Docker officielle, du support CUDA et est activement maintenu :

```bash
# Récupérer LocalAI avec le support CUDA
docker pull localai/localai:latest-aio-gpu-nvidia-cuda-12

# Créer le répertoire des modèles et télécharger un modèle GGUF
mkdir -p /workspace/localai-models
wget -O /workspace/localai-models/mistral-7b.gguf \
  https://huggingface.co/TheBloke/Mistral-7B-Instruct-v0.1-GGUF/resolve/main/mistral-7b-instruct-v0.1.Q4_K_M.gguf

# Créer la configuration du modèle
cat > /workspace/localai-models/mistral-7b.yaml << 'EOF'
name: mistral-7b
parameters :
  model: mistral-7b.gguf
  temperature: 0.7
  top_p: 0.95
  top_k: 40
  max_tokens: 2048
context_size: 4096
f16: true
gpu_layers: 35
threads: 8
EOF

# Exécuter LocalAI
docker run -d \
  --name localai \
  --gpus all \
  --restart unless-stopped \
  -p 8080:8080 \
  -v /workspace/localai-models:/build/models \
  -e DEBUG=true \
  localai/localai:latest-aio-gpu-nvidia-cuda-12

# Tester LocalAI (même API compatible OpenAI)
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-7b",
    "messages": [{"role": "user", "content": "Bonjour !"}]
  }'
```

***

## Configuration

### Variables d’environnement pour le serveur GPT4All

| Variable     | Par défaut               | Description                                    |
| ------------ | ------------------------ | ---------------------------------------------- |
| `MODEL_NAME` | `mistral-7b-instruct...` | Nom de fichier du modèle ou nom du hub GPT4All |
| `MODEL_PATH` | `/models`                | Répertoire contenant les fichiers de modèle    |
| `DEVICE`     | `gpu`                    | `gpu`, `cpu`, ou `metal` (macOS)               |
| `N_CTX`      | `4096`                   | Taille de la fenêtre de contexte (tokens)      |
| `API_HOST`   | `0.0.0.0`                | Adresse de liaison                             |
| `API_PORT`   | `4891`                   | Port pour le serveur API                       |

### Configuration Docker Compose

```yaml
# /workspace/gpt4all-server/docker-compose.yml
version : '3.8'

services :
  gpt4all-server :
    build: .
    container_name : gpt4all-server
    restart : unless-stopped
    ports :
      - "4891:4891"
    volumes :
      - /workspace/models:/models
      - ./server.py:/app/server.py
    environment :
      - MODEL_NAME=mistral-7b-instruct-v0.1.Q4_0.gguf
      - MODEL_PATH=/models
      - DEVICE=gpu
      - N_CTX=4096
      - API_PORT=4891
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    healthcheck :
      test: ["CMD", "curl", "-f", "http://localhost:4891/health"]
      intervalle : 30s
      timeout : 10s
      retries : 3
      start_period : 120s
```

```bash
docker compose up -d
docker compose logs -f
```

***

## Accélération GPU

### Vérification de l’utilisation GPU

La bibliothèque Python GPT4All utilise `llama.cpp` en coulisses avec le support CUDA :

```bash
# Vérifier l’utilisation de la VRAM GPU après le chargement du modèle
watch -n 2 nvidia-smi

# Vérifier dans le conteneur que CUDA est disponible
docker exec gpt4all-server python3 -c "
from gpt4all import GPT4All
devices = GPT4All.list_gpus()
print('GPUs disponibles :', devices)
"
```

### Sélection des couches GPU

Le `gpu_layers` (ou `n_gpu_layers`) paramètre contrôle la part du modèle exécutée sur GPU vs CPU :

```python
# Dans server.py — forcer toutes les couches sur le GPU
model = GPT4All(
    model_name=MODEL_NAME,
    model_path=MODEL_PATH,
    device="gpu",
    n_ctx=N_CTX,
    # Paramètres supplémentaires de llama.cpp transmis :
    # n_gpu_layers=99  # Toutes les couches sur GPU
)
```

```bash
# Reconstruire et redémarrer avec le nombre maximal de couches GPU
docker stop gpt4all-server && docker rm gpt4all-server
docker run -d \
  --name gpt4all-server \
  --gpus all \
  -p 4891:4891 \
  -v /workspace/models:/models \
  -e DEVICE=gpu \
  -e MODEL_NAME=mistral-7b-instruct-v0.1.Q4_0.gguf \
  gpt4all-server:latest
```

### Mode de repli CPU

Si aucun GPU n’est disponible (par ex., serveur Clore.ai uniquement CPU pour les tests) :

```bash
docker run -d \
  --name gpt4all-server-cpu \
  -p 4891:4891 \
  -v /workspace/models:/models \
  -e DEVICE=cpu \
  -e MODEL_NAME=Phi-3-mini-4k-instruct.Q4_0.gguf \
  gpt4all-server:latest
```

> ⚠️ L’inférence sur CPU est **10–50× plus lente** que sur GPU. Pour les serveurs uniquement CPU, utilisez des modèles petits (Phi-3 Mini, TinyLlama) et attendez-vous à 2–5 tokens/sec.

***

## Conseils et bonnes pratiques

### 📥 Pré-téléchargement des modèles

Au lieu de compter sur le téléchargement automatique au démarrage, pré-téléchargez les modèles pour des redémarrages plus rapides :

```bash
# Télécharger les modèles GPT4All populaires
mkdir -p /workspace/models

# Mistral 7B (le plus populaire, bonne qualité)
wget -q -O /workspace/models/mistral-7b-instruct-v0.1.Q4_0.gguf \
  "https://gpt4all.io/models/gguf/mistral-7b-instruct-v0.1.Q4_0.gguf"

# Phi-3 Mini (le plus rapide, le plus petit)
wget -q -O /workspace/models/Phi-3-mini-4k-instruct.Q4_0.gguf \
  "https://gpt4all.io/models/gguf/Phi-3-mini-4k-instruct.Q4_0.gguf"

# Llama 3 (meilleure qualité dans la gamme 8B)
wget -q -O /workspace/models/Meta-Llama-3-8B-Instruct.Q4_0.gguf \
  "https://gpt4all.io/models/gguf/Meta-Llama-3-8B-Instruct.Q4_0.gguf"

ls -lh /workspace/models/
```

### 🔌 Utilisation avec des applications Python

```python
# Utilisation directe en Python (sans l’API Docker)
from gpt4all import GPT4All

model = GPT4All(
    model_name="mistral-7b-instruct-v0.1.Q4_0.gguf",
    model_path="/workspace/models",
    device="gpu"
)

# Génération simple
with model.chat_session():
    response = model.generate("Expliquer le calcul GPU en termes simples", max_tokens=200)
    print(response)

# Utilisation du serveur API avec un client OpenAI
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:4891/v1",
    api_key="non-nécessaire"
)

completion = client.chat.completions.create(
    model="mistral-7b-instruct-v0.1.Q4_0.gguf",
    messages=[{"role": "user", "content": "Bonjour !"}]
)
print(completion.choices[0].message.content)
```

### 💰 Optimisation des coûts sur Clore.ai

```bash
# RTX 3090 @ 0,20 $/h — à utiliser pour les modèles 7B (meilleur rapport qualité/prix)
# Débit attendu : ~40 tokens/sec pour Mistral 7B Q4
# Coût pour 1M de tokens générés : ~0,005 $ (extrêmement bon marché par rapport à OpenAI)

# RTX 4090 @ 0,35 $/h — à utiliser pour les modèles 13B ou lorsque la vitesse compte
# Débit attendu : ~60 tokens/sec pour Mistral 7B Q4

# Pour le traitement par lots : précharger le modèle, traiter toutes les invites, arrêter
docker run --rm \
  --gpus all \
  -v /workspace/models:/models \
  -v /workspace/prompts:/prompts \
  gpt4all-server:latest \
  python3 -c "
from gpt4all import GPT4All
import json

model = GPT4All('mistral-7b-instruct-v0.1.Q4_0.gguf', '/models', device='gpu')
prompts = open('/prompts/batch.txt').readlines()
results = []
for p in prompts:
    with model.chat_session():
        results.append(model.generate(p.strip(), max_tokens=256))
json.dump(results, open('/prompts/results.json', 'w'))
print(f'Traitement de {len(results)} invites')
"
```

***

## Dépannage

### Le modèle ne se charge pas — fichier introuvable

```bash
# Vérifier que le fichier modèle existe et porte le bon nom
ls -lh /workspace/models/
docker exec gpt4all-server ls /models/

# GPT4All est sensible à la casse pour les noms de modèles
# Utilisez le nom de fichier exact issu de la sortie ls comme MODEL_NAME
docker stop gpt4all-server && docker rm gpt4all-server
docker run -d --gpus all -p 4891:4891 \
  -v /workspace/models:/models \
  -e MODEL_NAME=mistral-7b-instruct-v0.1.Q4_0.gguf \
  gpt4all-server:latest
```

### Erreur CUDA : pas d’image de noyau pour cette architecture

```bash
# Votre GPU peut ne pas être compatible avec la version de CUDA
# Vérifier la capacité de calcul du GPU
nvidia-smi --query-gpu=compute_cap --format=csv,noheader

# Si < 6.0, utilisez le mode CPU
docker run -d --gpus all -p 4891:4891 \
  -v /workspace/models:/models \
  -e DEVICE=cpu \
  -e MODEL_NAME=Phi-3-mini-4k-instruct.Q4_0.gguf \
  gpt4all-server:latest
```

### L’API renvoie 503 — modèle non chargé

```bash
# Vérifier les logs de démarrage
docker logs gpt4all-server | head -50

# Le chargement du modèle peut prendre 30–120 secondes
# Attendre et réessayer :
sleep 60 && curl http://localhost:4891/health

# Vérifier si le fichier modèle est corrompu
python3 -c "
from gpt4all import GPT4All
m = GPT4All('mistral-7b-instruct-v0.1.Q4_0.gguf', '/workspace/models')
print('Modèle OK :', m)
"
```

### Port 4891 non accessible depuis l’extérieur

```bash
# Vérifier le binding du port
docker ps | grep 4891
# Devrait afficher : 0.0.0.0:4891->4891/tcp

# Vérifier si Clore.ai a des règles de pare-feu
# Dans les paramètres du serveur Clore.ai, assurez-vous que le port 4891 est répertorié comme ouvert

# Tester en interne :
curl http://127.0.0.1:4891/health

# Remarque : Clore.ai mappe les ports aléatoirement — utilisez le port affiché dans le tableau de bord de votre serveur
```

***

## Lectures complémentaires

* [GPT4All GitHub](https://github.com/nomic-ai/gpt4all) — Dépôt principal
* [Docs Python GPT4All](https://docs.gpt4all.io/) — Référence de l’API Python
* [Explorateur de modèles GPT4All](https://gpt4all.io/models/gguf/) — Parcourir les modèles disponibles
* [Documentation LocalAI](https://localai.io/) — Alternative adaptée à Docker
* [Ollama sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/ollama.md) — Déploiement LLM Docker plus facile
* [vLLM sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/vllm.md) — Serveur d’inférence pour la production
* [Guide de comparaison GPU](/guides/guides_v2-fr/prise-en-main/gpu-comparison.md) — Choisir le bon GPU Clore.ai
* [TheBloke sur HuggingFace](https://huggingface.co/TheBloke) — Des milliers de quantifications GGUF
* [Format GGUF expliqué](https://github.com/ggerganov/ggml/blob/master/docs/gguf.md) — Documentation du format de modèle

> 💡 **Recommandation :** Si vous voulez le déploiement Docker le plus simple pour les LLM locaux, envisagez [composant Ollama](/guides/guides_v2-fr/modeles-de-langage/ollama.md) à la place — il dispose d’une image Docker officielle, d’un support GPU intégré et est spécialement conçu pour le déploiement côté serveur. La force de GPT4All réside dans sa belle interface de bureau et ses fonctionnalités LocalDocs (RAG), qui ne sont pas disponibles en mode serveur.


---

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

```
GET https://docs.clore.ai/guides/guides_v2-fr/plateformes-et-agents-ia/gpt4all.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.