Assistant IA LobeChat

Déployez LobeChat sur Clore.ai — une interface de chat IA superbe et riche en fonctionnalités avec prise en charge de plusieurs fournisseurs, base de connaissances et plugins, exécutée sur des serveurs cloud abordables alimentés par GPU.

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