Assistant hors ligne Jan.ai

Déployez Jan.ai Server sur Clore.ai — un serveur LLM entièrement hors ligne, compatible OpenAI, avec hub de modèles, gestion des conversations et inférence accélérée par GPU propulsée par le moteur Cortex.

Aperçu

Jan.ai est une alternative open source à ChatGPT, axée sur la confidentialité, avec plus de 40 000 étoiles sur GitHub. Bien que Jan soit surtout connu comme application de bureau, son composant serveur — Jan Server — expose une API REST entièrement compatible avec OpenAI, pouvant être déployée sur une infrastructure GPU cloud comme Clore.ai.

Jan Server est construit sur le moteur d'inférence Cortex.cpp , un runtime haute performance qui prend en charge llama.cpp, TensorRT-LLMet les backends ONNX. Sur Clore.ai, vous pouvez louer un serveur GPU à partir de $0.20/hr, exécuter Jan Server avec Docker Compose, charger n'importe quel modèle GGUF ou GPTQ, et le servir via une API compatible OpenAI — le tout sans que vos données quittent la machine.

Fonctionnalités clés :

• 🔒 100 % hors ligne — aucune donnée ne quitte jamais votre serveur

• 🤖 API compatible OpenAI (/v1/chat/completions, /v1/models, etc.)

• 📦 Hub de modèles avec téléchargements en une commande

• 🚀 Accélération GPU via CUDA (backends llama.cpp + TensorRT-LLM)

• 💬 Gestion des conversations intégrée et historique des fils de discussion

• 🔌 Remplacement direct d'OpenAI dans les applications existantes

---

Exigences

Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai. Les plus grosses machines répertoriées aujourd’hui sont 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est proposée en bare metal sur demande. Consultez bare metal sur demande. Consultez Tarifs et disponibilité des GPU avant de dimensionner un déploiement.

Configuration matérielle requise

Niveau	GPU	VRAM	RAM	Stockage	Prix Clore.ai
Minimum	RTX 3060 12 Go	12 Go	16 Go	SSD 50 Go	$0.03–0.07/hr
Recommandé	RTX 3090	24 Go	32 Go	SSD 100 Go	0,07–0,21 $/h
Haut de gamme	RTX 4090	24 Go	64 Go	SSD 200 Go	0,14–0,42 $/h
Grands modèles	A100 80 Go	80 Go	128 Go	SSD 500 Go	bare metal

Référence VRAM des modèles

Modèle	VRAM requise	GPU recommandé
Llama 3.1 8B (Q4)	~5 Go	RTX 3060
Llama 3.1 8B (FP16)	~16 Go	RTX 3090
Llama 3.3 70B (Q4)	~40 Go	A100 40 Go
Llama 3.1 405B (Q4)	~220 Go	4× A100 80 Go
Mistral 7B (Q4)	~4 Go	RTX 3060
Qwen2.5 72B (Q4)	~45 Go	A100 80 Go

Prérequis logiciels

• Compte Clore.ai avec portefeuille approvisionné

• Connaissances de base de Docker

• (Facultatif) Client OpenSSH pour le transfert de port

---

Démarrage rapide

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

1. Accédez à clore.ai et connectez-vous

2. Filtrer les serveurs : Type de GPU → RTX 3090 ou mieux, Docker → activé

3. Sélectionnez un serveur et choisissez l'option de Docker déploiement

4. Utilisez l'image de base officielle nvidia/cuda:12.8.1-devel-ubuntu22.04 ou toute image CUDA

5. Ouvrir les ports : 1337 (API Jan Server), 39281 (API Cortex), 22 (SSH)

Étape 2 — Connexion à votre serveur

# Connexion SSH à votre serveur Clore.ai
ssh -p <CLORE_SSH_PORT> root@<CLORE_SERVER_IP>

# Vérifier que le GPU est disponible
nvidia-smi

Étape 3 — Installer Docker Compose (si ce n'est pas déjà fait)

# Vérifier si Docker Compose est disponible
docker compose version

# Installer s'il manque (Ubuntu/Debian)
apt-get update && apt-get install -y docker-compose-plugin

# Vérifier
docker compose version

Étape 4 — Déployer Jan Server avec Docker Compose

# Créer le répertoire de travail
mkdir -p /workspace/jan-server && cd /workspace/jan-server

# Télécharger le docker-compose.yml officiel de Jan Server
curl -fsSL https://raw.githubusercontent.com/janhq/jan-server/main/docker-compose.yml \
  -o docker-compose.yml

# Vérifier et modifier la configuration
cat docker-compose.yml

Si le fichier compose en amont n'est pas disponible ou si vous voulez un contrôle total, créez-le manuellement :

# /workspace/jan-server/docker-compose.yml
version: '3.8'

services:
  jan-server:
    image: ghcr.io/janhq/cortex:latest
    container_name: jan-server
    restart: unless-stopped
    ports:
      - "1337:1337"
      - "39281:39281"
    volumes:
      - jan-data:/root/jan
      - jan-models:/root/cortex/models
    environment :
      - CUDA_VISIBLE_DEVICES=0
      - JAN_API_HOST=0.0.0.0
      - JAN_API_PORT=1337
      - CORTEX_API_PORT=39281
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:1337/health"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 60s

volumes:
  jan-data:
    driver: local
  jan-models:
    driver: local

# Démarrer Jan Server
docker compose up -d

# Suivre les logs de démarrage (attendre le message "Server started")
docker compose logs -f jan-server

Étape 5 — Vérifier que le serveur fonctionne

# Vérifier l'état du serveur
curl http://localhost:1337/health

# Lister les modèles disponibles (vide au départ)
curl http://localhost:1337/v1/models

# Réponse attendue :
# {"object":"list","data":[]}

Étape 6 — Télécharger votre premier modèle

# Télécharger Llama 3.2 3B (bon pour débuter, ~2 Go)
curl -X POST http://localhost:1337/v1/models/pull \
  -H "Content-Type: application/json" \
  -d '{"model": "llama3.2:3b-gguf-q4-km"}'

# Ou télécharger Mistral 7B Instruct Q4
curl -X POST http://localhost:1337/v1/models/pull \
  -H "Content-Type: application/json" \
  -d '{"model": "mistral:7b-instruct-v0.3-gguf-q4-km"}'

# Surveiller la progression du téléchargement
curl http://localhost:1337/v1/models

Étape 7 — Démarrer le modèle et discuter

# Démarrer le modèle (le charge dans la VRAM du GPU)
curl -X POST http://localhost:1337/v1/models/start \
  -H "Content-Type: application/json" \
  -d '{"model": "llama3.2:3b-gguf-q4-km"}'

# Envoyer votre première requête de chat
curl http://localhost:1337/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama3.2:3b-gguf-q4-km",
    "messages": [
      {"role": "system", "content": "Vous êtes un assistant utile."},
      {"role": "user", "content": "Bonjour ! En quoi pouvez-vous m'aider ?"}
    ],
    "temperature": 0.7,
    "max_tokens": 512,
    "stream": false
  }'

---

Configuration

Variables d’environnement

Variable	Par défaut	Description
JAN_API_HOST	0.0.0.0	Hôte sur lequel l'API doit écouter
JAN_API_PORT	1337	Port de l'API Jan Server
CORTEX_API_PORT	39281	Port interne du moteur Cortex
CUDA_VISIBLE_DEVICES	all	Quels GPU exposer (indices séparés par des virgules)
JAN_DATA_FOLDER	/root/jan	Chemin vers le dossier de données Jan
CORTEX_MODELS_PATH	/root/cortex/models	Chemin de stockage des modèles

Configuration multi-GPU

Pour les serveurs avec plusieurs GPU (par ex. 2× RTX 3090 sur Clore.ai) :

environment :
  - CUDA_VISIBLE_DEVICES=0,1  # Utiliser les deux GPU

Ou pour dédier des GPU spécifiques :

# Exécuter Jan Server uniquement sur le GPU 0
docker run -d \
  --name jan-server \
  --gpus '"device=0"' \
  -p 1337:1337 \
  -v jan-data:/root/jan \
  -v jan-models:/root/cortex/models \
  ghcr.io/janhq/cortex:latest

Configuration personnalisée du modèle

# Lister tous les modèles téléchargés
curl http://localhost:1337/v1/models | jq '.data[].id'

# Obtenir les détails du modèle
curl http://localhost:1337/v1/models/llama3.2:3b-gguf-q4-km

# Arrêter un modèle en cours d'exécution (libérer la VRAM)
curl -X POST http://localhost:1337/v1/models/stop \
  -H "Content-Type: application/json" \
  -d '{"model": "llama3.2:3b-gguf-q4-km"}'

# Supprimer un modèle (libérer de l'espace disque)
curl -X DELETE http://localhost:1337/v1/models/llama3.2:3b-gguf-q4-km

Sécuriser l'API avec un jeton

Jan Server n'inclut pas d'authentification par défaut. Utilisez Nginx comme proxy inverse :

apt-get install -y nginx apache2-utils

# Créer un fichier de mot de passe
htpasswd -c /etc/nginx/.htpasswd admin

# Configurer Nginx
cat > /etc/nginx/sites-available/jan-server << 'EOF'
server {
    listen 80;
    server_name _;

    location / {
        auth_basic "Jan Server";
        auth_basic_user_file /etc/nginx/.htpasswd;
        proxy_pass http://127.0.0.1:1337;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_read_timeout 300s;
    }
}
EOF

ln -s /etc/nginx/sites-available/jan-server /etc/nginx/sites-enabled/
nginx -t && systemctl restart nginx

---

Accélération GPU

Vérifier l'accélération CUDA

Le moteur Cortex de Jan Server détecte automatiquement CUDA. Vérifiez qu'il utilise bien le GPU :

# Vérifier l'utilisation de la mémoire GPU après avoir chargé un modèle
nvidia-smi

# Doit montrer le processus cortex consommant de la VRAM
# Exemple de sortie :
# | Processes:                                                            |
# |  GPU   GI   CI        PID   Type   Process name            GPU Memory |
# |    0    N/A  N/A    12345    C   /usr/local/bin/cortex    8192MiB |

Changer de backend d'inférence

Cortex prend en charge plusieurs backends :

# Vérifier quels backends sont disponibles dans le conteneur
docker exec jan-server cortex engines list

# Utiliser le backend TensorRT-LLM pour les GPU NVIDIA (plus rapide, nécessite plus de configuration)
docker exec jan-server cortex engines install tensorrt-llm

# Utiliser le backend llama.cpp (par défaut, le plus compatible)
docker exec jan-server cortex engines install llama-cpp

Ajustement de la fenêtre de contexte et de la taille du lot

# Personnaliser les paramètres du modèle pour les performances GPU
curl -X POST http://localhost:1337/v1/models/start \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama3.2:3b-gguf-q4-km",
    "ctx_len": 8192,
    "ngl": 99,
    "n_batch": 512,
    "n_parallel": 4,
    "cpu_threads": 8
  }'

Paramètre	Description	Recommandation
ngl	Couches GPU (plus élevé = plus d'utilisation du GPU)	Définir à 99 pour exploiter au maximum le GPU
ctx_len	Taille de la fenêtre de contexte	4096–32768 selon la VRAM
n_batch	Taille du lot pour le traitement du prompt	512 pour RTX 3090, 256 pour les plus petites
n_parallel	Emplacements de requêtes concurrentes	4–8 pour l'utilisation d'un serveur API

---

Conseils et bonnes pratiques

🎯 Sélection de modèles pour les budgets Clore.ai

# Niveau budget ($0.03–0.07/h, RTX 3060 12 Go) :
# Utiliser des quants Q4_K_M de modèles 7B
curl -X POST http://localhost:1337/v1/models/pull \
  -d '{"model": "mistral:7b-instruct-v0.3-gguf-q4-km"}'

# Niveau standard ($0.07–0.21/h, RTX 3090 24 Go) :
# Utiliser des quants Q5_K_M de modèles 13B ou du Q4 pour les 30B
curl -X POST http://localhost:1337/v1/models/pull \
  -d '{"model": "llama3.1:8b-instruct-gguf-q5-km"}'

# Niveau haut de gamme ([bare metal](https://clore.ai/bare-metal), A100 80 Go) :
# Exécuter des modèles complets 70B en haute précision
curl -X POST http://localhost:1337/v1/models/pull \
  -d '{"model": "llama3.3:70b-instruct-gguf-q4-km"}'

💾 Stockage persistant des modèles

Comme les instances Clore.ai sont éphémères, envisagez de monter un stockage externe :

# Utiliser un volume nommé (persistant avec Docker)
docker compose down
# Les modèles persistent dans le volume nommé 'jan-models'

# Pour un stockage vraiment persistant entre les instances,
# téléchargez les modèles vers un stockage objet et récupérez-les au démarrage :
cat > /workspace/startup.sh << 'EOF'
#!/bin/bash
docker compose up -d
sleep 30
# Pré-téléchargez vos modèles les plus utilisés
curl -X POST http://localhost:1337/v1/models/pull \
  -H "Content-Type: application/json" \
  -d '{"model": "mistral:7b-instruct-v0.3-gguf-q4-km"}'
EOF
chmod +x /workspace/startup.sh

🔗 Utiliser Jan Server comme substitut OpenAI

# Python — utilisez les bibliothèques clientes OpenAI existantes
from openai import OpenAI

client = OpenAI(
    base_url="http://<CLORE_IP>:1337/v1",
    api_key="not-required"  # Jan Server n'a pas d'authentification par défaut
)

response = client.chat.completions.create(
    model="llama3.2:3b-gguf-q4-km",
    messages=[{"role": "user", "content": "Expliquez l'informatique quantique"}],
    temperature=0.7
)
print(response.choices[0].message.content)

# Prise en charge du streaming
curl http://localhost:1337/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama3.2:3b-gguf-q4-km",
    "messages": [{"role": "user", "content": "Écris un haïku sur les GPU"}],
    "stream": true
  }'

📊 Surveillance de l'utilisation des ressources

# Surveiller l'utilisation du GPU en temps réel
watch -n 1 nvidia-smi

# Vérifier l'utilisation des ressources du conteneur
docker stats jan-server

# Afficher les logs détaillés
docker compose logs --tail=100 jan-server

# Vérifier les temps de chargement du modèle
docker compose logs jan-server | grep -E "(loaded|started|error)"

---

Dépannage

Le conteneur ne démarre pas — GPU introuvable

# Vérifier que le runtime NVIDIA Docker est configuré
docker info | grep -i nvidia

# Tester directement l'accès au GPU
docker run --rm --gpus all nvidia/cuda:12.8.1-base-ubuntu22.04 nvidia-smi

# Si cela échoue, vérifiez la configuration du démon Docker
cat /etc/docker/daemon.json
# Doit contenir : {"runtimes": {"nvidia": {...}}}

Le téléchargement du modèle est bloqué ou échoue

# Vérifier l'espace disque
df -h /root

# Vérifier les logs du conteneur pour les erreurs
docker compose logs jan-server | tail -50

# Relancer le téléchargement
curl -X POST http://localhost:1337/v1/models/pull \
  -H "Content-Type: application/json" \
  -d '{"model": "mistral:7b-instruct-v0.3-gguf-q4-km"}'

Plus de VRAM (CUDA out of memory)

# Vérifier l'utilisation actuelle de la VRAM
nvidia-smi --query-gpu=memory.used,memory.free --format=csv

# Arrêter d'abord tous les modèles en cours d'exécution
curl http://localhost:1337/v1/models | jq -r '.data[].id' | while read model; do
  curl -X POST http://localhost:1337/v1/models/stop \
    -H "Content-Type: application/json" \
    -d "{\"model\": \"$model\"}"
done

# Utiliser un modèle davantage quantifié (Q3 ou Q4 au lieu de Q8)
# Q4_K_M utilise généralement environ 50 % de la VRAM requise par Q8

Impossible de se connecter à l'API depuis l'extérieur du conteneur

# S'assurer que le port 1337 est lié sur toutes les interfaces
docker ps --format "table {{.Names}}\t{{.Ports}}"
# Doit afficher : 0.0.0.0:1337->1337/tcp

# Vérifier les règles du pare-feu Clore.ai — ouvrez le port 1337 dans les paramètres du serveur
# Tester d'abord localement :
curl http://127.0.0.1:1337/health

# Puis tester depuis l'extérieur :
curl http://<CLORE_SERVER_IP>:<MAPPED_PORT>/health

Inférence lente (retour au CPU)

# Confirmer que CUDA est utilisé (et non le CPU)
docker exec jan-server cortex ps
# Doit montrer que de la mémoire GPU est allouée

# Forcer les couches GPU au démarrage du modèle
curl -X POST http://localhost:1337/v1/models/start \
  -H "Content-Type: application/json" \
  -d '{"model": "mistral:7b-instruct-v0.3-gguf-q4-km", "ngl": 99}'

---

Pour aller plus loin

• Documentation officielle de Jan.ai — Documentation complète de la plateforme

• Dépôt GitHub de Jan — Code source et problèmes

• Jan Server / Jan API — Documentation spécifique au serveur

• Moteur Cortex.cpp — Le moteur d'inférence sous-jacent

• Prise en main de Clore.ai — Bases de la plateforme

• Guide de comparaison des GPU — Choisir le bon GPU

• Exécuter Ollama sur Clore.ai — Serveur LLM alternatif

• Exécuter vLLM sur Clore.ai — Serveur d'inférence à haut débit

• Hugging Face Model Hub — Trouver des modèles GGUF

💡 Conseil de coût : Une RTX 3090 sur Clore.ai ($0.07–0.21/h) peut exécuter Llama 3.1 8B à ~50 jetons/seconde — suffisant pour un usage personnel ou des API à faible trafic. Pour des charges de production, envisagez vLLM (voir guide vLLM) sur une A100.