> 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-ia-et-agents/gpt4all.md).

# LLM local GPT4All

Déployez GPT4All sur Clore.ai — exécutez des LLM locaux axés sur la confidentialité avec un serveur API compatible OpenAI utilisant Docker, prenant en charge les modèles GGUF avec accélération CUDA optionnelle pour des performances maximales.

## 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 de grands modèles de langage 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 aussi une **bibliothèque Python** (`gpt4all` (package) et un **serveur API compatible OpenAI intégré** 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 y 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 de l’alternative LocalAI](#alternative-localai-docker-image) — LocalAI est conçu d’abord pour Docker et prend en charge le même format de modèle.

**Fonctionnalités clés :**

* 🔒 100 % hors ligne — toute l’inférence s’exécute localement
* 🤖 API REST compatible OpenAI (port 4891)
* 📚 LocalDocs — RAG sur vos propres documents
* 🧩 Prend en charge tous les formats de modèle GGUF populaires
* 🐍 API Python complète avec `pip install gpt4all`
* 💬 Belle interface de bureau (sans intérêt pour le serveur, mais utile pour les tests locaux)

***

## Exigences

### Configuration matérielle requise

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

> **Remarque :** Le support GPU de GPT4All utilise CUDA via llama.cpp en arrière-plan. Contrairement à vLLM, il **pas** n’exige pas de capacité de calcul CUDA spécifique — les RTX 10xx et plus récentes fonctionnent généralement.

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

| Modèle                | Taille sur le disque | VRAM    | GPU minimal |
| --------------------- | -------------------- | ------- | ----------- |
| 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 80 Go  |
| 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. Filtre : **Docker activé**, **GPU**: RTX 3090 (pour les modèles 7B–13B)
3. Déployer avec l’image : `nvidia/cuda:12.8.1-runtime-ubuntu22.04`
4. Ouvrir les ports : **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 afficher votre GPU avec la version du pilote
```

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

Comme il n’existe pas d’image Docker officielle de GPT4All, nous allons en créer une :

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

cat > Dockerfile << 'EOF'
FROM nvidia/cuda:12.8.1-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 la version par 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 prise en charge de CUDA
RUN pip install --upgrade pip && \
    pip install gpt4all>=2.8.0 fastapi uvicorn aiofiles pydantic

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

WORKDIR /app

# Copier le script du serveur (sera monté ou intégré à l’image)
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 pour 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écharge depuis le hub GPT4All si absent
        verbose=True
    )
    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 de l’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="Modèle non chargé")

    # Mettre les messages au format d’une seule requête
    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="Modèle non chargé")

    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échargez d’abord un modèle (facultatif — le serveur peut aussi le 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 prise en charge du 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 journaux
docker logs -f gpt4all-server
```

### Étape 6 — Tester l’API

```bash
# Vérification de santé
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, prêt pour la production et exécutant les **mêmes modèles GGUF** que GPT4All, LocalAI est le choix recommandé. Il dispose d’une image Docker officielle, de la prise en charge de CUDA, et est activement maintenu :

```bash
# Récupérer LocalAI avec prise en charge de 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": "Hello!"}]
  }'
```

***

## 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 du 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 du 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"]
      interval: 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 du GPU

La bibliothèque Python GPT4All utilise `llama.cpp` en arrière-plan avec prise en charge de CUDA :

```bash
# Vérifier l’utilisation de la VRAM du 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('GPU disponibles :', devices)
"
```

### Sélection des couches GPU

Le `gpu_layers` (ou `n_gpu_layers`) contrôle la part du modèle qui s’exécute sur le GPU par rapport au 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 additionnels de llama.cpp transmis :
    # n_gpu_layers=99  # Toutes les couches sur le 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 secours CPU

Si aucun GPU n’est disponible (par ex. : serveur Clore.ai réservé au 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 CPU est **10 à 50× plus lente** que le GPU. Pour les serveurs CPU uniquement, utilisez de petits modèles (Phi-3 Mini, TinyLlama) et attendez-vous à 2–5 jetons/s.

***

## 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 de 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("Expliquez l’informatique GPU en termes simples", max_tokens=200)
    print(response)

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

client = OpenAI(
    base_url="http://localhost:4891/v1",
    api_key="not-needed"
)

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

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

```bash
# RTX 3090 à 0,07–0,21 $/h — à utiliser pour les modèles 7B (meilleur rapport qualité-prix)
# Débit attendu : ~40 jetons/s pour Mistral 7B Q4
# Coût par 1 M de jetons générés : ~0,005 $ (extrêmement peu cher comparé à OpenAI)

# RTX 4090 à 0,14–0,42 $/h — à utiliser pour les modèles 13B ou lorsque la vitesse compte
# Débit attendu : ~60 jetons/s pour Mistral 7B Q4

# Pour le traitement par lots : chargez le modèle à l’avance, traitez toutes les requêtes, puis arrêtez
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'Traité {len(results)} requêtes')
"
```

***

## Dépannage

### Échec du chargement du modèle — fichier introuvable

```bash
# Vérifiez que le fichier du 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 obtenu avec 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 : aucune image de noyau pour cette architecture

```bash
# Votre GPU n’est peut-être pas compatible avec la version de CUDA
# Vérifiez 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érifiez les journaux de démarrage
docker logs gpt4all-server | head -50

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

# Vérifiez si le fichier du 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)
"
```

### Le port 4891 n’est pas accessible depuis l’extérieur

```bash
# Vérifiez la liaison du port
docker ps | grep 4891
# Doit afficher : 0.0.0.0:4891->4891/tcp

# Vérifiez 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 सूची?

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

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

***

## Pour aller plus loin

* [GitHub de GPT4All](https://github.com/nomic-ai/gpt4all) — Dépôt principal
* [Documentation Python de GPT4All](https://docs.gpt4all.io/) — Référence de l’API Python
* [Explorateur de modèles GPT4All](https://gpt4all.io/models/gguf/) — Parcourez 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 Docker de LLM plus simple
* [vLLM sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/vllm.md) — Serveur d’inférence pour la production
* [Guide de comparaison des GPU](/guides/guides_v2-fr/premiers-pas/gpu-comparison.md) — Choisissez 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 sur le format des modèles

> 💡 **Recommandation :** Si vous voulez le déploiement Docker le plus simple pour des LLM locaux, envisagez [Ollama](/guides/guides_v2-fr/modeles-de-langage/ollama.md) à la place — il dispose d’une image Docker officielle, d’une prise en charge GPU intégrée, et est spécialement conçu pour le déploiement côté serveur. Le point fort de GPT4All est sa superbe 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, and the optional `goal` query parameter:

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

`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.