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

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

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 :

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

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

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

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

# 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

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

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 :

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

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

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

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 :

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

# 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

# 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

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

# 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

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

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

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

• Documentation LocalAI — Alternative adaptée à Docker

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

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

• Guide de comparaison GPU — Choisir le bon GPU Clore.ai

• TheBloke sur HuggingFace — Des milliers de quantifications GGUF

• Format GGUF expliqué — Documentation du format de modèle

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