Assistant hors ligne Jan.ai

Déployez Jan.ai Server sur Clore.ai — un serveur LLM entièrement hors ligne et 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 OpenAI qui peut être déployée sur une infrastructure GPU cloud comme Clore.ai.

Jan Server est construit sur le Cortex.cpp moteur d'inférence, un runtime haute performance qui prend en charge llama.cpp, TensorRT-LLM, et les backends ONNX. Sur Clore.ai, vous pouvez louer un serveur GPU pour aussi peu que $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échargement des modèles en une commande

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

• 💬 Gestion de conversation intégrée et historique des threads

• 🔌 Remplacement plug-and-play pour OpenAI dans les applications existantes

---

Exigences

Exigences matérielles

Niveau	GPU	VRAM	RAM	Stockage	Prix Clore.ai
Minimum	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
Grands modèles	A100 80GB	80 Go	128 Go	500 Go SSD	~1,10 $/h

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 40GB
Llama 3.1 405B (Q4)	~220 Go	4× A100 80GB
Mistral 7B (Q4)	~4 Go	RTX 3060
Qwen2.5 72B (Q4)	~45 Go	A100 80GB

Prérequis logiciels

• Compte Clore.ai avec portefeuille approvisionné

• Connaissances de base en Docker

• (Optionnel) 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' Docker option de déploiement

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

5. Ports ouverts : 1337 (API Jan Server), 39281 (API Cortex), 22 (SSH)

Étape 2 — Connectez-vous à votre serveur

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

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

Étape 3 — Installez Docker Compose (si absent)

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

# Installer si manquant (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

# Revoir et modifier la configuration
cat docker-compose.yml

Si le fichier compose upstream est indisponible ou si vous voulez le 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"]
      intervalle : 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 la santé du serveur
curl http://localhost:1337/health

# Lister les modèles disponibles (initialement vide)
curl http://localhost:1337/v1/models

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

Étape 6 — Récupérer votre premier modèle

# Récupérer Llama 3.2 3B (bon modèle de départ, ~2GB)
curl -X POST http://localhost:1337/v1/models/pull \
  -H "Content-Type: application/json" \
  -d '{"model": "llama3.2:3b-gguf-q4-km"}'

# Ou récupérer 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 chatter

# Démarrer le modèle (le charge dans la VRAM 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 serviable."},
      {"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 auquel l'API doit se lier
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 de Jan
CORTEX_MODELS_PATH	/root/cortex/models	Chemin vers le 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 seulement 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 récupérés
curl http://localhost:1337/v1/models | jq '.data[].id'

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

# Arrêter un modèle en cours (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écurisation de l'API avec un token

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

apt-get install -y nginx apache2-utils

# Créer le fichier de mots 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érification de l'accélération CUDA

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

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

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

Changement de backend d'inférence

Cortex prend en charge plusieurs backends :

# Vérifier quels backends sont disponibles à l'intérieur du 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 de 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 GPU)	Définir sur 99 pour saturer le GPU
ctx_len	Taille de la fenêtre de contexte	4096–32768 selon la VRAM
n_batch	Taille de lot pour le traitement des prompts	512 pour RTX 3090, 256 pour les plus petits
n_parallel	Emplacements de requêtes concurrentes	4–8 pour une utilisation en serveur API

---

Conseils et bonnes pratiques

🎯 Sélection de modèle en fonction des budgets Clore.ai

# Palier budget (~0,10 $/h, RTX 3060 12GB) :
# Utiliser des quantifications Q4_K_M des modèles 7B
curl -X POST http://localhost:1337/v1/models/pull \
  -d '{"model": "mistral:7b-instruct-v0.3-gguf-q4-km"}'

# Palier standard (~0,20 $/h, RTX 3090 24GB) :
# Utiliser des quantifications Q5_K_M des modèles 13B ou Q4 des 30B
curl -X POST http://localhost:1337/v1/models/pull \
  -d '{"model": "llama3.1:8b-instruct-gguf-q5-km"}'

# Palier haut de gamme (~1,10 $/h, A100 80GB) :
# Exécuter des modèles 70B complets 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

Étant donné que les instances Clore.ai sont éphémères, envisagez de monter un stockage externe :

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

# Pour un stockage réellement persistant entre les instances,
# téléversez les modèles sur un stockage d'objets et récupérez-les au démarrage :
cat > /workspace/startup.sh << 'EOF'
#!/bin/bash
docker compose up -d
sleep 30
# Pré-récupérer vos modèles fréquemment 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 plug-in OpenAI

# Python — utiliser 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'auth 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)

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

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

# Vérifier les temps de chargement des modèles
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 l'accès au GPU directement
docker run --rm --gpus all nvidia/cuda:12.1.0-base-ubuntu22.04 nvidia-smi

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

Téléchargement du modèle bloqué ou échoue

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

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

# Réessayer le pull
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 tous les modèles en cours d'abord
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 plus fortement quantifié (Q3 ou Q4 au lieu de Q8)
# Q4_K_M utilise typiquement ~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é à toutes les interfaces
docker ps --format "table {{.Names}}\t{{.Ports}}"
# Devrait afficher : 0.0.0.0:1337->1337/tcp

# Vérifier les règles de pare-feu Clore.ai — ouvrir le port 1337 dans les paramètres du serveur
# Tester localement d'abord :
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 (repli sur CPU)

# Confirmer que CUDA est utilisé (et non le CPU)
docker exec jan-server cortex ps
# Devrait montrer la mémoire GPU 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}'

---

Lectures complémentaires

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

• Référentiel GitHub de Jan — Code source et issues

• Jan Server / Jan API — Docs spécifiques au serveur

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

• Clore.ai Démarrage — Bases de la plateforme

• Guide de comparaison 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 sur les coûts : Un RTX 3090 sur Clore.ai (~0,20 $/h) peut exécuter Llama 3.1 8B à ~50 tokens/seconde — suffisant pour un usage personnel ou des API à faible trafic. Pour des charges de production, envisagez vLLM (voir guide vLLM) sur une A100.