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

# LibreChat multi-fournisseurs

## Aperçu

[LibreChat](https://github.com/danny-avila/LibreChat) est une interface améliorée et open-source de type ChatGPT 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 — basculement multi-fournisseurs au sein de la même conversation, branchement/fork de conversation, un riche système de plugins, téléversements de fichiers avec vision et un bac à sable complet pour interpréter du code.

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

* **Véritable multi-fournisseur dans une seule interface** — Basculez entre 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 raccordez un backend LLM local.
* **Auto-hébergement économique** — Les tarifs Clore.ai commencent à des fractions de centime par minute, idéal pour exécuter un hub IA personnel.
* **Conversations persistantes** — MongoDB stocke l'intégralité de votre historique de chat côté serveur, contrairement aux solutions stockées localement dans le navigateur.
* **Convivial pour les équipes** — Prise en charge multi-utilisateurs avec gestion individuelle des clés API.

### Principales caractéristiques

| Fonction                    | Description                                                         |
| --------------------------- | ------------------------------------------------------------------- |
| Multi-fournisseur           | OpenAI, Anthropic, Google, Azure, Mistral, Ollama, OpenRouter       |
| Branchement de conversation | Forkez et explorez 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écutez Python dans un bac à sable isolé                           |
| Artefacts                   | Rendez des sorties HTML, React et Markdown                          |
| Préréglages                 | Enregistrez et partagez 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 de LLM local              |
| **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 plus de RAM                      |
| **Stockage** | 20 Go        | 50+ Go                            | Téléversements de fichiers, cache de modèles si local |

### Référence de tarification Clore.ai

| Type de serveur                      | Coût approximatif | 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 VRAM)                | \~0,20 $/h        | LibreChat + inférence locale Ollama     |
| RTX 4090 (24 Go VRAM)                | \~0,35 $/h        | LibreChat + Ollama/vLLM plus rapides    |
| A100 80 Go                           | \~1,10 $/h        | LibreChat + grands modèles 70B+         |

> 💡 **Conseil sur les coûts :** Si vous utilisez LibreChat uniquement pour router des appels API vers OpenAI/Anthropic/Google, vous ne payez que le calcul serveur Clore.ai (bon marché), 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 (Officiel — Recommandé)

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@<votre-ip-serveur-clore> -p <port-ssh>
```

**É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éfinir 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=un-autre-secret-aléatoire-de-64-caractères-ici
CREDS_KEY=votre-cle-aleatoire-de-32-caracteres-ici
CREDS_IV=votre-iv-aléatoire-de-16-caracteres-ici

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

Générez rapidement des secrets :

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

**Étape 4 : Démarrer la stack**

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

Ceci démarre :

* `LibreChat` — application principale sur le port 3080
* `MongoDB` — stockage des conversations et des utilisateurs
* `MeiliSearch` — recherche rapide de 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-serveur-clore> :3080
```

Enregistrez un nouveau compte sur la page de connexion.

***

### Méthode 2 : Image Docker pré-construite (Plus rapide)

Si vous voulez éviter de construire à partir des sources :

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

# Téléchargez 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

# Éditer 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é limitée) :

```bash
docker run -d \
  --name librechat \
  --restart unless-stopped \
  -p 3080:3080 \
  -e OPENAI_API_KEY=sk-votre-cle \
  -e JWT_SECRET=votre-jwt-secret-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 IA

Éditer `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`      | Logs verbeux                                 | `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`

### Activation de 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 des téléversements de fichiers

```bash
# Dans .env
# Taille maximale de fichier en Mo
FILE_UPLOAD_SIZE_LIMIT=100

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

***

## Accélération GPU

LibreChat n'utilise **ne** pas le GPU directement — 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émarrez Ollama avec le support GPU
docker run -d \
  --name ollama \
  --gpus all \
  --restart unless-stopped \
  -p 11434:11434 \
  -v ollama_models:/root/.ollama \
  ollama/ollama

# Récupérer 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 des déploiements à haute concurrence (voir [- Débit le plus élevé](/guides/guides_v2-fr/modeles-de-langage/vllm.md)):

```bash
# Démarrez vLLM sur une instance A100 Clore.ai
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: "not-needed"
      baseURL: "http://172.17.0.1:8000/v1"
      models :
        default: ["meta-llama/Llama-3.1-70B-Instruct"]
        fetch: true
```

### Dimensionnement GPU pour modèles locaux

| Taille du modèle | VRAM min | GPU Clore recommandé | Coût approximatif |
| ---------------- | -------- | -------------------- | ----------------- |
| 7–8B (Q4)        | 6 Go     | RTX 3090             | \~0,20 $/h        |
| 13B (Q4)         | 10 Go    | RTX 3090             | \~0,20 $/h        |
| 34B (Q4)         | 24 Go    | RTX 4090             | \~0,35 $/h        |
| 70B (Q4)         | 48 Go    | 2× RTX 3090          | \~0,40 $/h        |
| 70B (FP16)       | 80 Go    | A100 80GB            | \~1,10 $/h        |

***

## Conseils et bonnes pratiques

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

```bash
# Faites un snapshot de 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êtez tous les conteneurs lorsqu'ils ne sont pas utilisés
docker compose stop

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

### Stratégie de sauvegarde

```bash
# Script de sauvegarde quotidien automatisé
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
# Ne conservez que les 7 derniers jours
find ~/backups -name "*.mongo.gz" -mtime +7 -delete
EOF

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

### Restauration depuis une sauvegarde

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

### Sécurisation de LibreChat

* Définissez toujours des valeurs fortes et uniques pour `JWT_SECRET` et `CREDS_KEY`
* Désactiver l'inscription après la création initiale d'un 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 (optionnel)

```bash
cat > /etc/nginx/sites-available/librechat << 'EOF'
server {
    listen 80;
    server_name your-domain.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érifiez si le conteneur est en cours d'exécution
docker compose ps

# Vérifiez l'association de ports
ss -tlnp | grep 3080

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

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

### Connexion MongoDB refusée

```bash
# Vérifiez 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
# Devrait être : mongodb://mongodb:27017/LibreChat (pas localhost)

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

### Erreurs JWT / Authentification

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

# Mettez à jour JWT_SECRET et JWT_REFRESH_SECRET
# Puis redémarrez : docker compose restart LibreChat
```

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

```bash
# Testez 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, pas seulement localhost
docker exec ollama ollama serve  # Vérifiez les logs de démarrage pour l'adresse de liaison
```

### Espace disque insuffisant

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

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

# Vérifiez le répertoire des téléversements 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
```

***

## Lectures complémentaires

* [Documentation LibreChat](https://docs.librechat.ai) — référence complète de configuration
* [LibreChat GitHub](https://github.com/danny-avila/LibreChat) — source, issues, changelog
* [LibreChat Docker Hub](https://ghcr.io/danny-avila/librechat-dev) — tags d'images
* [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 GPU](/guides/guides_v2-fr/prise-en-main/gpu-comparison.md) — choisir le bon niveau de GPU
* [Fichier de configuration LibreChat - Référence](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:

```
GET https://docs.clore.ai/guides/guides_v2-fr/plateformes-et-agents-ia/librechat.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.