LibreChat Multi-fournisseur

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

Aperçu

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

ssh root@<votre-ip-serveur-clore> -p <port-ssh>

Étape 2 : Cloner le dépôt

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

Étape 3 : Configurer l'environnement

cp .env.example .env
nano .env

Définir au minimum :

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

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

Étape 4 : Démarrer la stack

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

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 :

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

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 :

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:

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 :

# Dans .env
ALLOW_REGISTRATION=false

Puis redémarrez : docker compose restart LibreChat

Activation de l'interpréteur de code

# 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

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

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

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

  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

# 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

# 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

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

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

# 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

# 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

# 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

# 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

# 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

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

---

Lectures complémentaires

• Documentation LibreChat — référence complète de configuration

• LibreChat GitHub — source, issues, changelog

• LibreChat Docker Hub — tags d'images

• Exécuter Ollama sur Clore.ai — backend LLM local

• Exécuter vLLM sur Clore.ai — inférence à haut débit

• Guide de comparaison GPU — choisir le bon niveau de GPU

• Fichier de configuration LibreChat - Référence — librechat.yaml schéma