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

# Assistant hors ligne Jan.ai

## Aperçu

[Jan.ai](https://github.com/janhq/jan) 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](https://github.com/janhq/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](https://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

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

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

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

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

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

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

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

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

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

Ou pour dédier des GPU spécifiques :

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

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

```bash
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 :

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

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

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

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

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

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

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

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

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

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

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

```bash
# 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](https://jan.ai/docs) — Docs complètes de la plateforme
* [Référentiel GitHub de Jan](https://github.com/janhq/jan) — Code source et issues
* [Jan Server / Jan API](https://github.com/janhq/jan-server) — Docs spécifiques au serveur
* [Moteur Cortex.cpp](https://github.com/janhq/cortex.cpp) — Le moteur d'inférence sous-jacent
* [Clore.ai Démarrage](/guides/guides_v2-fr/prise-en-main/getting-started.md) — Bases de la plateforme
* [Guide de comparaison GPU](/guides/guides_v2-fr/prise-en-main/gpu-comparison.md) — Choisir le bon GPU
* [Exécuter Ollama sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/ollama.md) — Serveur LLM alternatif
* [Exécuter vLLM sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/vllm.md) — Serveur d'inférence à haut débit
* [Hugging Face Model Hub](https://huggingface.co/models?library=gguf) — 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](/guides/guides_v2-fr/modeles-de-langage/vllm.md)) sur une A100.


---

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

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

The question should be specific, self-contained, and written in natural language.
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.