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

# 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](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 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](https://github.com/janhq/cortex.cpp) , 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 à 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

{% hint style="warning" %}
**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](https://clore.ai/bare-metal) sur demande. Consultez [Tarifs et disponibilité des GPU](/guides/guides_v2-fr/premiers-pas/pricing.md) avant de dimensionner un déploiement.
{% endhint %}

### 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](https://clore.ai/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](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'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

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

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

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

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

```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"]
      interval: 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 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

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

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

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

Ou pour dédier des GPU spécifiques :

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

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

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

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

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

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

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

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

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

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

# 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

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

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

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

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

```bash
# 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](https://jan.ai/docs) — Documentation complète de la plateforme
* [Dépôt GitHub de Jan](https://github.com/janhq/jan) — Code source et problèmes
* [Jan Server / Jan API](https://github.com/janhq/jan-server) — Documentation spécifique au serveur
* [Moteur Cortex.cpp](https://github.com/janhq/cortex.cpp) — Le moteur d'inférence sous-jacent
* [Prise en main de Clore.ai](/guides/guides_v2-fr/premiers-pas/getting-started.md) — Bases de la plateforme
* [Guide de comparaison des GPU](/guides/guides_v2-fr/premiers-pas/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 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](/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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.