Assistant IA LobeChat

Déployez LobeChat sur Clore.ai — une interface de chat IA superbe et riche en fonctionnalités avec support multi-fournisseurs, base de connaissances et plugins fonctionnant sur des serveurs cloud soutenus par GPU abordables.

Aperçu

LobeChat est un cadre de chat IA moderne et open-source avec plus de 55K étoiles sur GitHub, connu pour son interface soignée et son ensemble de fonctionnalités étendues. Il prend en charge pratiquement tous les principaux fournisseurs de LLM — OpenAI, Anthropic Claude, Google Gemini, Mistral, et des modèles locaux via Ollama — le tout depuis une interface auto-hébergée unique.

Pourquoi exécuter LobeChat sur Clore.ai ?

• Aucun GPU requis — LobeChat lui-même est une application web légère. Les instances Clore.ai uniquement CPU ou avec GPU minimal sont parfaitement suffisantes pour l’interface.

• Associer à des LLM locaux — Lancez Ollama ou vLLM sur le même serveur Clore.ai et configurez LobeChat pour l’utiliser afin d’obtenir une inférence entièrement locale et privée.

• Hébergement abordable — Une instance Clore.ai basique coûte une fraction des fournisseurs VPS traditionnels, et vous pouvez l’arrêter lorsque vous ne l’utilisez pas.

• Propriété complète des données — Le mode base de données stocke toutes les conversations, fichiers et embeddings dans votre propre instance PostgreSQL sur le serveur.

LobeChat fonctionne en deux modes distincts :

Mode	Description	Idéal pour
Autonome	Conteneur Docker unique, paramètres stockés dans le navigateur	Tests rapides, usage personnel
Base de données	Stack complet (PostgreSQL + MinIO + Auth + App)	Équipes, historique persistant, base de connaissances

---

Exigences

Spécifications du serveur

Composant	Minimum	Recommandé	Remarques
GPU	Aucun requis	RTX 3090 (si exécution de LLM locaux)	Nécessaire uniquement pour le backend Ollama/vLLM
VRAM	—	24 Go (RTX 3090)	Pour l’inférence de modèles locaux
CPU	2 vCPU	4+ vCPU	LobeChat lui-même est léger
RAM	2 Go	8 Go	4+ Go si vous utilisez le mode base de données
Stockage	10 Go	50+ Go	Plus si vous stockez des fichiers téléchargés ou des modèles

Référence de tarification Clore.ai

Type de serveur	Coût approximatif	Cas d'utilisation
Instance uniquement CPU	~0,05–0,10 $/h	Uniquement LobeChat autonome
RTX 3090 (24 Go VRAM)	~0,20 $/h	LobeChat + Ollama LLMs locaux
RTX 4090 (24 Go VRAM)	~0,35 $/h	LobeChat + inférence locale plus rapide
A100 80 Go	~1,10 $/h	LobeChat + grands modèles (70B+)

💡 Conseil : Pour une utilisation via API uniquement (connexion à OpenAI, Anthropic, etc.), n’importe quelle petite instance fonctionne. Un serveur GPU n’a de sens que si vous souhaitez également exécuter des LLM locaux. Voir Guide de comparaison GPU pour les détails.

Prérequis

• Compte Clore.ai avec un serveur déployé

• Accès SSH à votre serveur

• Docker et Docker Compose (préinstallés sur les serveurs Clore.ai)

• Pilotes NVIDIA (préinstallés ; pertinents uniquement si vous utilisez un backend LLM local)

• Au moins une clé API (OpenAI, Anthropic, etc.) ou une instance Ollama locale

---

Démarrage rapide

Option A : Mode autonome (recommandé pour commencer)

Le mode autonome exécute LobeChat en tant que conteneur unique. Les paramètres et l’historique des conversations sont stockés dans le stockage local du navigateur — aucune base de données requise.

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

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

Étape 2 : Récupérer et exécuter LobeChat

docker run -d \
  --name lobechat \
  --restart unless-stopped \
  -p 3210:3210 \
  -e OPENAI_API_KEY=sk-votre-cle-openai-ici \
  -e OPENAI_PROXY_URL=https://api.openai.com/v1 \
  lobehub/lobe-chat

Étape 3 : Vérifiez qu’il fonctionne

docker ps
docker logs lobechat --tail 20

Étape 4 : Accédez à l’interface

Ouvrez votre navigateur et rendez-vous sur :

http://<votre-ip-serveur-clore>:3210

⚠️ Remarque sur la sécurité : Les serveurs Clore.ai sont accessibles publiquement. Envisagez de définir ACCESS_CODE pour protéger par mot de passe votre instance (voir la section Configuration ci-dessous).

---

Option B : Mode autonome avec plusieurs fournisseurs

Passez plusieurs clés API pour prendre en charge différents fournisseurs simultanément :

docker run -d \
  --name lobechat \
  --restart unless-stopped \
  -p 3210:3210 \
  -e OPENAI_API_KEY=sk-votre-cle-openai \
  -e ANTHROPIC_API_KEY=sk-ant-votre-cle-anthropic \
  -e GOOGLE_API_KEY=votre-cle-google-gemini \
  -e MISTRAL_API_KEY=votre-cle-mistral \
  -e ACCESS_CODE=votre-mot-de-passe-secret \
  lobehub/lobe-chat

---

Option C : Avec backend Ollama local

Si vous avez Ollama en cours d’exécution sur le même serveur Clore.ai (voir Guide Ollama):

# Tout d’abord, démarrez Ollama
docker run -d \
  --name ollama \
  --restart unless-stopped \
  --gpus all \
  -p 11434:11434 \
  -v ollama:/root/.ollama \
  ollama/ollama

# Récupérer un modèle
docker exec ollama ollama pull llama3.2

# Démarrer LobeChat en pointant vers Ollama
docker run -d \
  --name lobechat \
  --restart unless-stopped \
  -p 3210:3210 \
  -e OLLAMA_PROXY_URL=http://host-gateway:11434 \
  --add-host=host-gateway:host-gateway \
  lobehub/lobe-chat

Sur Linux, remplacez host-gateway par l’IP réelle du pont Docker, typiquement 172.17.0.1:

-e OLLAMA_PROXY_URL=http://172.17.0.1:11434

---

Option D : Mode base de données (Docker Compose)

Le mode base de données permet un historique de conversation persistant, la prise en charge multi-utilisateur, les téléchargements de fichiers vers un stockage compatible S3, et une base de connaissances complète.

Étape 1 : Créer le répertoire du projet

mkdir -p ~/lobechat && cd ~/lobechat

Étape 2 : Créer docker-compose.yml

cat > docker-compose.yml << 'EOF'
version : '3.8'

services :
  postgresql :
    image : pgvector/pgvector:pg16
    container_name : lobe-postgres
    restart : unless-stopped
    environment :
      POSTGRES_DB : lobechat
      POSTGRES_USER : lobechat
      POSTGRES_PASSWORD : changeme_strong_password
    volumes :
      - postgres_data:/var/lib/postgresql/data
    healthcheck :
      test : ["CMD-SHELL", "pg_isready -U lobechat -d lobechat"]
      intervalle : 10s
      timeout : 5s
      retries : 5

  minio :
    image : minio/minio
    container_name : lobe-minio
    restart : unless-stopped
    environment :
      MINIO_ROOT_USER : minioadmin
      MINIO_ROOT_PASSWORD : changeme_minio_password
    command : server /data --console-address ":9001"
    volumes :
      - minio_data:/data
    ports :
      - "9000:9000"
      - "9001:9001"

  lobechat :
    image : lobehub/lobe-chat-database
    container_name : lobe-chat
    restart : unless-stopped
    depends_on :
      postgresql :
        condition : service_healthy
    ports :
      - "3210:3210"
    environment :
      # Base de données
      DATABASE_URL : postgresql://lobechat:changeme_strong_password@postgresql:5432/lobechat
      # Stockage S3 (MinIO)
      S3_ENDPOINT : http://minio:9000
      S3_BUCKET : lobechat
      S3_ACCESS_KEY_ID : minioadmin
      S3_SECRET_ACCESS_KEY : changeme_minio_password
      S3_PUBLIC_DOMAIN : http://<votre-ip-serveur>:9000
      # Auth (NextAuth)
      NEXTAUTH_SECRET : votre-secret-aléatoire-32-caractères-ici
      NEXTAUTH_URL : http://<votre-ip-serveur>:3210
      # Fournisseurs LLM
      OPENAI_API_KEY : sk-votre-cle-openai
      ANTHROPIC_API_KEY : sk-ant-votre-cle
      # App
      APP_URL : http://<votre-ip-serveur>:3210

volumes :
  postgres_data :
  minio_data :
EOF

Étape 3 : Démarrer la stack

docker compose up -d
docker compose logs -f lobechat

Étape 4 : Créer le bucket MinIO

# Installer le client MinIO
docker exec lobe-minio mc alias set local http://localhost:9000 minioadmin changeme_minio_password
docker exec lobe-minio mc mb local/lobechat
docker exec lobe-minio mc anonymous set download local/lobechat

---

Configuration

Référence des variables d'environnement

Variable	Description	Par défaut
OPENAI_API_KEY	Clé API OpenAI	—
OPENAI_PROXY_URL	Point de terminaison personnalisé compatible OpenAI	https://api.openai.com/v1
ANTHROPIC_API_KEY	Clé API Anthropic Claude	—
GOOGLE_API_KEY	Clé API Google Gemini	—
MISTRAL_API_KEY	Clé API Mistral AI	—
OLLAMA_PROXY_URL	URL vers une instance Ollama locale	—
ACCESS_CODE	Mot de passe pour protéger l’interface	—
DEFAULT_AGENT_CONFIG	Configuration JSON pour le comportement par défaut de l’assistant	—
FEATURE_FLAGS	Activer/désactiver des fonctionnalités spécifiques	—

Activation de fonctionnalités spécifiques

Activer le plugin de recherche web :

-e BING_API_KEY=votre-cle-de-recherche-bing

Activer la synthèse vocale :

-e AZURE_TTS_API_KEY=votre-cle-azure \
-e AZURE_TTS_REGION=eastus

Définir un prompt système personnalisé pour l’agent par défaut :

-e DEFAULT_AGENT_CONFIG='{"systemRole":"You are a helpful assistant."}'

Mise à jour de LobeChat

# Récupérer la dernière image
docker pull lobehub/lobe-chat

# Arrêter et supprimer l’ancien conteneur
docker stop lobechat && docker rm lobechat

# Démarrer le nouveau conteneur avec les mêmes paramètres
docker run -d \
  --name lobechat \
  --restart unless-stopped \
  -p 3210:3210 \
  -e OPENAI_API_KEY=sk-votre-cle \
  lobehub/lobe-chat

Pour Docker Compose :

docker compose pull
docker compose up -d

---

Accélération GPU

LobeChat lui-même ne nécessite un GPU. Cependant, lorsqu’il est associé à un backend accéléré par GPU sur Clore.ai, vous obtenez une inférence LLM locale et privée :

Association avec vLLM (Inférence haute performance)

Voir le - Débit le plus élevé pour la configuration complète. Intégration rapide :

# Démarrer le serveur vLLM (sur le même hôte)
docker run -d \
  --name vllm \
  --gpus all \
  --restart unless-stopped \
  -p 8000:8000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  vllm/vllm-openai:latest \
  --model meta-llama/Llama-3.1-8B-Instruct \
  --served-model-name llama3.1-8b

# Démarrer LobeChat en pointant vers vLLM (API compatible OpenAI)
docker run -d \
  --name lobechat \
  --restart unless-stopped \
  -p 3210:3210 \
  -e OPENAI_API_KEY=not-needed \
  -e OPENAI_PROXY_URL=http://172.17.0.1:8000/v1 \
  lobehub/lobe-chat

Utilisation des ressources

Backend	VRAM GPU utilisée	Débit approximatif
Ollama (Llama 3.2 3B)	~2 Go	50–80 tokens/sec sur 3090
Ollama (Llama 3.1 8B)	~6 Go	40–60 tokens/sec sur 3090
vLLM (Llama 3.1 8B)	~16 Go	80–150 tokens/sec sur 3090
vLLM (Llama 3.1 70B)	~80 Go	20–40 tokens/sec sur A100 80GB

---

Conseils et bonnes pratiques

Optimisation des coûts

• Arrêtez votre serveur lorsqu’il est inactif. Clore.ai facture à l’heure — utilisez le tableau de bord pour mettre en pause les instances que vous n’utilisez pas activement.

• Mode autonome pour usage personnel. À moins d’avoir besoin du support multi-utilisateur ou d’un historique persistant côté serveur, le mode autonome évite la charge de PostgreSQL et MinIO.

• Utilisez des fournisseurs d’API pour les grands modèles. Acheminer les requêtes vers Claude ou GPT-4 via des API externes est moins cher que de louer une H100 pour des requêtes occasionnelles.

Sécurité

# Toujours définir un code d’accès sur les IP Clore.ai publiques
-e ACCESS_CODE=votre-mot-de-passe-fort-ici

# Restreindre à une origine spécifique (optionnel)
-e NEXT_PUBLIC_SERVICE_MODE=server

• Ne jamais exposer LobeChat sans un ACCESS_CODE sur une IP publique.

• Envisagez d’utiliser un proxy inverse Nginx avec HTTPS si vous l’exécutez à long terme.

• Faites pivoter les clés API si vous suspectez une exposition.

Performances

# Augmenter le tas Node.js si vous exécutez le mode base de données avec de nombreux utilisateurs
-e NODE_OPTIONS="--max-old-space-size=4096"

• Pour le mode base de données avec 10+ utilisateurs concurrents, assurez-vous d’au moins 8 Go de RAM sur l’hôte.

• MinIO fonctionne mieux avec un stockage sur SSD (instances Clore.ai NVMe).

Persistance entre les sessions Clore.ai

Puisque les serveurs Clore.ai peuvent être terminés :

# Créez un volume Docker pour les exportations de conversations autonomes
docker run -d \
  --name lobechat \
  -p 3210:3210 \
  -v lobechat_data:/app/data \
  lobehub/lobe-chat

Exportez régulièrement les conversations depuis Paramètres → Exportation de données dans l’interface.

---

Dépannage

Le conteneur ne démarre pas

# Vérifiez les logs
docker logs lobechat --tail 50

# Vérifiez que le port n’est pas utilisé
ss -tlnp | grep 3210

# Vérifiez que le démon Docker fonctionne
systemctl status docker

Impossible de se connecter à Ollama depuis LobeChat

# Testez la connectivité depuis le conteneur LobeChat
docker exec lobechat curl -s http://172.17.0.1:11434/api/tags

# Si cela échoue, vérifiez qu’Ollama écoute sur toutes les interfaces
docker exec ollama ollama serve --host 0.0.0.0

Erreurs de connexion à la base de données (mode base de données)

# Vérifiez la santé de PostgreSQL
docker exec lobe-postgres pg_isready -U lobechat

# Vérifiez le format de DATABASE_URL
# postgresql://user:password@host:port/dbname

# Exécutez manuellement les migrations si nécessaire
docker exec lobe-chat npx prisma migrate deploy

Images/fichiers non téléchargés (mode base de données)

# Vérifiez que MinIO est accessible
curl -s http://localhost:9000/minio/health/live

# Vérifiez que le bucket existe
docker exec lobe-minio mc ls local/

# Vérifiez que S3_PUBLIC_DOMAIN est défini sur l’IP correcte du serveur

Erreurs de mémoire insuffisante

# Vérifiez l’utilisation actuelle de la mémoire
docker stats lobechat

# Augmentez la limite de mémoire du conteneur
docker run -d \
  --name lobechat \
  --memory=2g \
  -p 3210:3210 \
  lobehub/lobe-chat

---

Lectures complémentaires

• Documentation LobeChat — docs officielles, développement de plugins, guides de déploiement

• LobeChat GitHub — code source, issues, discussions

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

• Exécuter vLLM sur Clore.ai — inférence hautes performances compatible OpenAI

• Guide de comparaison GPU — choisir le GPU Clore.ai approprié

• LobeChat Docker Hub — tags d’images et versions

• Variables d’environnement LobeChat — référence complète des variables