> 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/librechat.md).

# LibreChat multi-fournisseurs

Déployez LibreChat sur Clore.ai — une puissante alternative auto-hébergée à ChatGPT avec prise en charge IA multi-fournisseurs, branches de conversation et écosystème de plugins sur une infrastructure cloud GPU abordable.

## Aperçu

[LibreChat](https://github.com/danny-avila/LibreChat) est une interface de type ChatGPT améliorée et open source, avec plus de 22 000 étoiles sur GitHub. Elle réimagine fidèlement l'expérience ChatGPT tout en ajoutant des fonctionnalités que l'original n'a pas — changement de fournisseur au sein de la même conversation, branchement/fork de conversations, un riche système de plugins, le téléversement de fichiers avec vision, et un bac à sable complet pour l'interpréteur de code.

**Pourquoi exécuter LibreChat sur Clore.ai ?**

* **Vrai multi-fournisseur dans une seule interface** — Passez de GPT-4, Claude 3.5, Gemini Pro, Mistral et des modèles Ollama locaux en cours de session.
* **Aucun GPU nécessaire pour l'application** — LibreChat est une application Node.js ; elle n'a besoin de calcul pour l'inférence que si vous lui connectez un backend LLM local.
* **Auto-hébergement économique** — La tarification de Clore.ai commence à une fraction de centime par minute, idéal pour faire tourner un hub IA personnel.
* **Conversations persistantes** — MongoDB stocke tout votre historique de chat côté serveur, contrairement aux solutions locales au navigateur.
* **Adapté aux équipes** — Prise en charge multi-utilisateur avec gestion individuelle des clés API.

### Caractéristiques clés

| Fonctionnalité               | Description                                                         |
| ---------------------------- | ------------------------------------------------------------------- |
| Multi-fournisseur            | OpenAI, Anthropic, Google, Azure, Mistral, Ollama, OpenRouter       |
| Branchement de conversations | Dupliquer et explorer des réponses alternatives                     |
| Plugins                      | Recherche Bing, Zapier, WolframAlpha, outils personnalisés          |
| Téléversement de fichiers    | Images, PDF, documents avec analyse visuelle                        |
| Interpréteur de code         | Exécuter Python dans un bac à sable isolé                           |
| Artefacts                    | Rendre des sorties HTML, React et Markdown                          |
| Préréglages                  | Enregistrer et partager des configurations de modèle personnalisées |

***

## Exigences

### Spécifications du serveur

| Composant    | Minimum      | Recommandé                        | Remarques                                            |
| ------------ | ------------ | --------------------------------- | ---------------------------------------------------- |
| **GPU**      | Aucun requis | RTX 3090 (si vous ajoutez Ollama) | Uniquement pour l'inférence LLM locale               |
| **VRAM**     | —            | 24 Go                             | Pour les modèles locaux via Ollama                   |
| **CPU**      | 2 vCPU       | 4 vCPU                            | Node.js + MongoDB                                    |
| **RAM**      | 4 Go         | 8 Go                              | MongoDB bénéficie de davantage de RAM                |
| **Stockage** | 20 Go        | 50+ Go                            | Téléversements de fichiers, cache de modèle si local |

### Référence tarifaire Clore.ai

| Type de serveur                      | Coût approx.                              | Cas d’utilisation                       |
| ------------------------------------ | ----------------------------------------- | --------------------------------------- |
| Axé sur le CPU (4 vCPU, 8 Go de RAM) | \~0,05–0,10 $/h                           | LibreChat + fournisseurs d'API externes |
| RTX 3090 (24 Go de VRAM)             | 0,07–0,21 $/h                             | LibreChat + inférence locale Ollama     |
| RTX 4090 (24 Go de VRAM)             | 0,14–0,42 $/h                             | LibreChat + Ollama/vLLM plus rapide     |
| A100 80 Go                           | [bare metal](https://clore.ai/bare-metal) | LibreChat + grands modèles 70B+         |

> 💡 **Astuce coût :** Si vous utilisez LibreChat uniquement pour router les appels d'API vers OpenAI/Anthropic/Google, vous ne payez que le calcul du serveur Clore.ai (peu coûteux), pas le matériel d'inférence. Prévoyez environ 0,05 à 0,15 $/h pour un hôte LibreChat fiable.

### Prérequis

* Serveur Clore.ai avec accès SSH
* Docker + Docker Compose (préinstallés sur Clore.ai)
* Git (préinstallé sur Clore.ai)
* Au moins une clé API LLM **ou** un backend Ollama/vLLM local

***

## Démarrage rapide

### Méthode 1 : Docker Compose (officielle — recommandée)

Le déploiement officiel de LibreChat utilise Docker Compose avec MongoDB et MeiliSearch pour une fonctionnalité complète.

**Étape 1 : connectez-vous à votre serveur Clore.ai**

```bash
ssh root@<your-clore-server-ip> -p <ssh-port>
```

**Étape 2 : cloner le dépôt**

```bash
git clone https://github.com/danny-avila/LibreChat.git
cd LibreChat
```

**Étape 3 : configurer l'environnement**

```bash
cp .env.example .env
nano .env
```

Définissez au minimum :

```bash
# Dans .env — paramètres critiques
MONGO_URI=mongodb://mongodb:27017/LibreChat
JWT_SECRET=votre-secret-aléatoire-de-64-caractères-ici
JWT_REFRESH_SECRET=autre-secret-aléatoire-de-64-caractères-ici
CREDS_KEY=votre-clé-aléatoire-de-32-caractères-ici
CREDS_IV=votre-iv-aléatoire-de-16-caractères-ici

# Clés API (ajoutez celles que vous utilisez)
OPENAI_API_KEY=sk-votre-clé-openai
ANTHROPIC_API_KEY=sk-ant-votre-clé-anthropic
GOOGLE_KEY=votre-clé-google-gemini
```

Générez rapidement les secrets :

```bash
# Générer des secrets aléatoires
node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
```

**Étape 4 : démarrer la pile**

```bash
docker compose up -d
```

Cela démarre :

* `LibreChat` — application principale sur le port 3080
* `MongoDB` — stockage des conversations et des utilisateurs
* `MeiliSearch` — recherche rapide dans les conversations

**Étape 5 : vérifier et accéder**

```bash
docker compose ps
docker compose logs librechat --tail 30
```

Ouvrez dans le navigateur :

```
http://<votre-ip-du-serveur-clore>:3080
```

Créez un nouveau compte sur la page de connexion.

***

### Méthode 2 : image Docker préconstruite (la plus rapide)

Si vous voulez éviter de construire à partir du code source :

```bash
mkdir -p ~/librechat && cd ~/librechat

# Télécharger uniquement les fichiers docker-compose
curl -o docker-compose.yml https://raw.githubusercontent.com/danny-avila/LibreChat/main/docker-compose.yml
curl -o .env https://raw.githubusercontent.com/danny-avila/LibreChat/main/.env.example

# Modifier la configuration
nano .env

# Démarrer
docker compose up -d
```

***

### Méthode 3 : test rapide en conteneur unique

Pour une preuve de concept rapide sans MongoDB (fonctionnalités limitées) :

```bash
docker run -d \
  --name librechat \\
  --restart unless-stopped \\
  -p 3080:3080 \\
  -e OPENAI_API_KEY=sk-your-key \\
  -e JWT_SECRET=votre-secret-jwt-ici \\
  -e MONGO_URI=mongodb://host-gateway:27017/LibreChat \\
  --add-host=host-gateway:host-gateway \\
  ghcr.io/danny-avila/librechat-dev:latest
```

> ⚠️ Cette méthode nécessite une instance MongoDB séparée. Utilisez la méthode 1 pour une configuration complète.

***

## Configuration

### Ajouter des fournisseurs d'IA

Modifier `librechat.yaml` (créez-le à la racine du projet) pour une configuration avancée des fournisseurs :

```bash
cat > librechat.yaml << 'EOF'
version: 1.1.5
cache: true

endpoints:
  openAI:
    models:
      default: ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-3.5-turbo"]
      fetch: true

  anthropic:
    models:
      default: ["claude-opus-4-5", "claude-sonnet-4-5", "claude-3-haiku-20240307"]
      fetch: false

  google:
    models:
      default: ["gemini-1.5-pro", "gemini-1.5-flash", "gemini-pro"]
      fetch: false

  ollama:
    # Pointe vers Ollama exécuté sur le même serveur Clore.ai
    baseURL: http://host-gateway:11434/v1
    apiKey: ollama
    models:
      default: ["llama3.2", "mistral", "codellama"]
      fetch: true

  custom:
    - name: "OpenRouter"
      apiKey: "${OPENROUTER_API_KEY}"
      baseURL: "https://openrouter.ai/api/v1"
      models:
        default: ["meta-llama/llama-3.1-8b-instruct:free"]
        fetch: true
      titleConvo: true
      titleModel: "meta-llama/llama-3.1-8b-instruct:free"
EOF
```

Montez ce fichier dans votre `docker-compose.yml`:

```yaml
services:
  LibreChat :
    volumes:
      - ./librechat.yaml:/app/librechat.yaml
```

### Référence des variables d'environnement

| Variable             | Description                                  | Exemple                             |
| -------------------- | -------------------------------------------- | ----------------------------------- |
| `MONGO_URI`          | Chaîne de connexion MongoDB                  | `mongodb://mongodb:27017/LibreChat` |
| `JWT_SECRET`         | Secret de signature JWT (64+ caractères)     | Chaîne hexadécimale aléatoire       |
| `OPENAI_API_KEY`     | Clé OpenAI                                   | `sk-...`                            |
| `ANTHROPIC_API_KEY`  | Clé Anthropic                                | `sk-ant-...`                        |
| `GOOGLE_KEY`         | Clé Google Gemini                            | `IA...`                             |
| `ALLOW_REGISTRATION` | Activer l'inscription publique               | `true` / `false`                    |
| `ALLOW_EMAIL_LOGIN`  | Activer la connexion par e-mail/mot de passe | `true`                              |
| `DEBUG_LOGGING`      | Journaux détaillés                           | `true`                              |
| `SEARCH`             | Activer MeiliSearch                          | `true`                              |
| `MEILI_MASTER_KEY`   | Clé API MeiliSearch                          | Chaîne aléatoire                    |

### Restreindre l'inscription

Pour un usage privé, désactivez l'inscription publique après avoir créé votre compte :

```bash
# Dans .env
ALLOW_REGISTRATION=false
```

Puis redémarrez : `docker compose restart LibreChat`

### Activer l'interpréteur de code

```bash
# Dans .env
CODE_INTERPRETER_ENABLED=true
```

L'interpréteur de code exécute Python dans un conteneur Docker isolé. Assurez-vous que le socket Docker est accessible.

### Configuration du téléversement de fichiers

```bash
# Dans .env
# Taille maximale des fichiers en Mo
FILE_UPLOAD_SIZE_LIMIT=100

# Activer le téléversement d'images pour les modèles de vision
VISION_ENABLED=true
```

***

## Accélération GPU

LibreChat n **pas** utilise pas directement le GPU — c'est une couche de routage. L'accélération GPU s'applique à tout backend d'inférence local que vous y connectez.

### Connexion à Ollama (même serveur)

Si vous exécutez Ollama sur le même serveur Clore.ai (voir [Guide Ollama](/guides/guides_v2-fr/modeles-de-langage/ollama.md)):

```bash
# Démarrer Ollama avec prise en charge GPU
docker run -d \
  --name ollama \\
  --gpus all \
  --restart unless-stopped \\
  -p 11434:11434 \
  -v ollama_models:/root/.ollama \\
  ollama/ollama

# Télécharger les modèles
docker exec ollama ollama pull llama3.2
docker exec ollama ollama pull codellama:13b

# Dans librechat.yaml, définissez :
# baseURL: http://172.17.0.1:11434/v1
```

### Connexion à vLLM (haut débit)

Pour les déploiements à forte concurrence (voir [Guide vLLM](/guides/guides_v2-fr/modeles-de-langage/vllm.md)):

```bash
# Démarrer vLLM sur une instance Clore.ai A100
docker run -d \
  --name vllm \\
  --gpus all \
  --restart unless-stopped \\
  -p 8000:8000 \
  -v hf_cache:/root/.cache/huggingface \\
  -e HF_TOKEN=votre-token-hf \\
  vllm/vllm-openai:latest \
  --model meta-llama/Llama-3.1-70B-Instruct \\
  --tensor-parallel-size 2 \
  --max-model-len 8192
```

Dans `librechat.yaml`:

```yaml
  custom:
    - name: "Local vLLM"
      apiKey: "pas_necessaire"
      baseURL: "http://172.17.0.1:8000/v1"
      models:
        default: ["meta-llama/Llama-3.1-70B-Instruct"]
        fetch: true
```

### Dimensionnement GPU pour les modèles locaux

| Taille du modèle | VRAM minimale | GPU Clore recommandé | Coût approx.                              |
| ---------------- | ------------- | -------------------- | ----------------------------------------- |
| 7–8B (Q4)        | 6 Go          | RTX 3090             | 0,07–0,21 $/h                             |
| 13B (Q4)         | 10 Go         | RTX 3090             | 0,07–0,21 $/h                             |
| 34B (Q4)         | 24 Go         | RTX 4090             | 0,14–0,42 $/h                             |
| 70B (Q4)         | 48 Go         | 2× RTX 3090          | 0,14–0,42 $/h                             |
| 70B (FP16)       | 80 Go         | A100 80 Go           | [bare metal](https://clore.ai/bare-metal) |

***

## Conseils et bonnes pratiques

### Gestion des coûts sur Clore.ai

```bash
# Sauvegardez votre configuration avant d'arrêter le serveur
docker compose exec mongodb mongodump --out /tmp/backup
docker cp librechat-mongodb-1:/tmp/backup ./mongo-backup-$(date +%Y%m%d)

# Arrêter tous les conteneurs lorsqu'ils ne sont pas utilisés
docker compose stop

# Ou réduisez le coût à zéro en mettant en pause l'instance Clore.ai depuis le tableau de bord
```

### Stratégie de sauvegarde

```bash
# Script de sauvegarde automatique quotidienne
cat > /root/backup-librechat.sh << 'EOF'
#!/bin/bash
cd ~/LibreChat
docker compose exec -T mongodb mongodump --archive | \\
  gzip > ~/backups/librechat-$(date +%Y%m%d-%H%M).mongo.gz
# Conserver uniquement les 7 derniers jours
find ~/backups -name "*.mongo.gz" -mtime +7 -delete
EOF

chmod +x /root/backup-librechat.sh
# Ajouter au crontab : 0 2 * * * /root/backup-librechat.sh
```

### Restauration à partir d'une sauvegarde

```bash
# Restaurer le dump MongoDB
gunzip < ~/backups/librechat-20240101-0200.mongo.gz | \\
  docker compose exec -T mongodb mongorestore --archive
```

### Sécuriser LibreChat

* Définissez toujours des valeurs fortes et uniques pour `JWT_SECRET` et `CREDS_KEY`
* Désactivez l'inscription après la création du premier utilisateur : `ALLOW_REGISTRATION=false`
* Utilisez un proxy inverse (nginx/Caddy) avec HTTPS pour la production
* Mettez régulièrement à jour l'image Docker : `docker compose pull && docker compose up -d`

### Proxy inverse Nginx (facultatif)

```bash
cat > /etc/nginx/sites-available/librechat << 'EOF'
server {
    listen 80;
    server_name votre-domaine.com;

    location / {
        proxy_pass http://localhost:3080;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        client_max_body_size 100M;
    }
}
EOF
ln -s /etc/nginx/sites-available/librechat /etc/nginx/sites-enabled/
nginx -t && systemctl reload nginx
```

***

## Dépannage

### Le port 3080 n'est pas accessible

```bash
# Vérifier si le conteneur est en cours d'exécution
docker compose ps

# Vérifier l’association du port
ss -tlnp | grep 3080

# Afficher les journaux de l'application
docker compose logs librechat --tail 50 -f

# Vérifiez le pare-feu Clore.ai — assurez-vous que le port 3080 figure dans votre mappage de ports
```

### Connexion MongoDB refusée

```bash
# Vérifier l'état de MongoDB
docker compose ps mongodb
docker compose logs mongodb --tail 20

# Vérifiez que MONGO_URI dans .env correspond au nom du service
# Doit être : mongodb://mongodb:27017/LibreChat (pas localhost)

# Tester la connexion manuellement
docker compose exec LibreChat node -e "
const mongoose = require('mongoose');
mongoose.connect(process.env.MONGO_URI)
  .then(() => console.log('Connecté !'))
  .catch(e => console.error(e));
"
```

### Erreurs JWT / d'authentification

```bash
# Régénérer les secrets dans .env
node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"

# Mettre à jour JWT_SECRET et JWT_REFRESH_SECRET
# Puis redémarrer : docker compose restart LibreChat
```

### Les modèles Ollama n'apparaissent pas

```bash
# Tester l'API Ollama depuis le conteneur LibreChat
docker compose exec LibreChat \\
  curl -s http://172.17.0.1:11434/v1/models | python3 -m json.tool

# Assurez-vous qu'Ollama écoute sur 0.0.0.0, et pas seulement sur localhost
docker exec ollama ollama serve  # Vérifiez l'adresse de liaison dans les journaux de démarrage
```

### Espace disque insuffisant

```bash
# Vérifier l'utilisation du disque
df -h
docker system df

# Nettoyer les ressources Docker
docker system prune -f
docker volume prune -f  # AVERTISSEMENT : supprime les volumes inutilisés

# Vérifier le répertoire de téléversement de LibreChat
du -sh ~/LibreChat/client/public/uploads
```

### Mettre à jour vers la dernière version

```bash
cd ~/LibreChat
git pull origin main
docker compose pull
docker compose up -d --build
```

***

## Pour aller plus loin

* [Documentation LibreChat](https://docs.librechat.ai) — référence complète de configuration
* [GitHub de LibreChat](https://github.com/danny-avila/LibreChat) — code source, tickets, journal des modifications
* [LibreChat Docker Hub](https://ghcr.io/danny-avila/librechat-dev) — tags d'image
* [Exécuter Ollama sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/ollama.md) — backend LLM local
* [Exécuter vLLM sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/vllm.md) — inférence à haut débit
* [Guide de comparaison des GPU](/guides/guides_v2-fr/premiers-pas/gpu-comparison.md) — choisir le bon niveau de GPU
* [Référence du fichier de configuration LibreChat](https://docs.librechat.ai/install/configuration/librechat_yaml.html) — `librechat.yaml` schéma


---

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