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

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

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 :

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

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

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

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

# 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

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

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 :

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

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

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

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 :

# 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

# 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

# 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

# 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

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

# 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

# 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 — Dépôt principal

• Documentation Python de GPT4All — Référence de l’API Python

• Explorateur de modèles GPT4All — Parcourez les modèles disponibles

• Documentation LocalAI — Alternative adaptée à Docker

• Ollama sur Clore.ai — Déploiement Docker de LLM plus simple

• vLLM sur Clore.ai — Serveur d’inférence pour la production

• Guide de comparaison des GPU — Choisissez le bon GPU Clore.ai

• TheBloke sur HuggingFace — Des milliers de quantifications GGUF

• Format GGUF expliqué — Documentation sur le format des modèles

💡 Recommandation : Si vous voulez le déploiement Docker le plus simple pour des LLM locaux, envisagez Ollama à 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.