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

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

É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éfinissez 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=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 :

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

Étape 4 : démarrer la pile

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

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 :

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

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 :

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

# Dans .env
ALLOW_REGISTRATION=false

Puis redémarrez : docker compose restart LibreChat

Activer 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 du téléversement de fichiers

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

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

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

  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

---

Conseils et bonnes pratiques

Gestion des coûts sur Clore.ai

# 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

# 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

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

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

# 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

# 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

# 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

# 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

# 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

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

---

Pour aller plus loin

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

• GitHub de LibreChat — code source, tickets, journal des modifications

• LibreChat Docker Hub — tags d'image

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

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

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

• Référence du fichier de configuration LibreChat — librechat.yaml schéma