Assistant IA LobeChat

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

Aperçu

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

Pourquoi exécuter LobeChat sur Clore.ai ?

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

• Associer à des LLM locaux — Lancez Ollama ou vLLM sur le même serveur Clore.ai et pointez LobeChat vers celui-ci pour une inférence locale et privée complète.

• Hébergement abordable — Une instance de base Clore.ai coûte une fraction du prix des fournisseurs VPS traditionnels, et vous pouvez l’arrêter lorsqu’elle n’est pas utilisée.

• 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	Un seul conteneur Docker, paramètres stockés dans le navigateur	Tests rapides, usage personnel
Base de données	Pile complète (PostgreSQL + MinIO + Auth + application)	Équipes, historique persistant, base de connaissances

---

Exigences

Spécifications du serveur

Composant	Minimum	Recommandé	Remarques
GPU	Aucun requis	RTX 3090 (si vous exécutez des LLM locaux)	Uniquement nécessaire 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	Davantage si vous stockez des fichiers téléversés ou des modèles

Référence tarifaire Clore.ai

Type de serveur	Coût approx.	Cas d’utilisation
Instance CPU uniquement	~0,05–0,10 $/h	LobeChat autonome uniquement
RTX 3090 (24 Go de VRAM)	0,07–0,21 $/h	LobeChat + LLM locaux Ollama
RTX 4090 (24 Go de VRAM)	0,14–0,42 $/h	LobeChat + inférence locale plus rapide
A100 80 Go	bare metal	LobeChat + grands modèles (70B+)

💡 Astuce : Pour une utilisation via API uniquement (connexion à OpenAI, Anthropic, etc.), n'importe quelle petite instance convient. Un serveur GPU n'a de sens que si vous souhaitez également exécuter des LLM locaux. Voir Guide de comparaison des GPU pour plus de 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 dans un seul conteneur. Les paramètres et l'historique des conversations sont stockés dans le stockage local du navigateur — aucune base de données n'est requise.

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

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

Étape 2 : récupérez et lancez LobeChat

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

Étape 3 : vérifiez qu'il s'exécute

docker ps
docker logs lobechat --tail 20

Étape 4 : accédez à l'interface

Ouvrez votre navigateur et rendez-vous sur :

http://<your-clore-server-ip>:3210

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

---

Option B : mode autonome avec plusieurs fournisseurs

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

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

---

Option C : avec un backend Ollama local

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

# 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érez un modèle
docker exec ollama ollama pull llama3.2

# Démarrez 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

Sous Linux, remplacez host-gateway par l'adresse IP réelle du pont Docker, généralement 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 persistant des conversations, la prise en charge multi-utilisateur, le téléversement de fichiers vers un stockage compatible S3 et une base de connaissances complète.

Étape 1 : créez le répertoire du projet

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

Étape 2 : créez 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"]
      interval: 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://<your-server-ip>:9000
      # Auth (NextAuth)
      NEXTAUTH_SECRET: your-random-32-char-secret-here
      NEXTAUTH_URL: http://<your-server-ip>:3210
      # Fournisseurs LLM
      OPENAI_API_KEY: sk-your-openai-key
      ANTHROPIC_API_KEY: sk-ant-your-key
      # Application
      APP_URL: http://<your-server-ip>:3210

volumes:
  postgres_data:
  minio_data:
EOF

Étape 3 : démarrez la pile

docker compose up -d
docker compose logs -f lobechat

Étape 4 : créez le bucket MinIO

# Installez 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 l'instance Ollama locale	—
ACCESS_CODE	Mot de passe pour protéger l'interface	—
DEFAULT_AGENT_CONFIG	Configuration JSON du 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=your-bing-search-key

Activer la synthèse vocale :

-e AZURE_TTS_API_KEY=your-azure-key \\
-e AZURE_TTS_REGION=eastus

Définir une invite système personnalisée pour l'agent par défaut :

-e DEFAULT_AGENT_CONFIG='{"systemRole":"Vous êtes un assistant utile."}'

Mise à jour de LobeChat

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

# Arrêtez et supprimez l'ancien conteneur
docker stop lobechat && docker rm lobechat

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

Pour Docker Compose :

docker compose pull
docker compose up -d

---

Accélération GPU

LobeChat lui-même ne pas nécessite pas de 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 Guide vLLM pour la configuration complète. Intégration rapide :

# Démarrez 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émarrez 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 jetons/s sur une 3090
Ollama (Llama 3.1 8B)	~6 Go	40–60 jetons/s sur une 3090
vLLM (Llama 3.1 8B)	~16 GB	80–150 jetons/s sur une 3090
vLLM (Llama 3.1 70B)	~80 Go	20–40 jetons/s sur une A100 80 Go

---

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 que vous n'ayez besoin d'une prise en charge multi-utilisateur ou d'un historique persistant côté serveur, le mode autonome évite la surcharge de PostgreSQL et MinIO.

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

Sécurité

# Définissez toujours un code d'accès sur les IP publiques Clore.ai
-e ACCESS_CODE=your-strong-password-here

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

• N'exposez jamais 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 tourner les clés API si vous soupçonnez une fuite.

Performances

# Augmentez le tas Node.js si le mode base de données est utilisé avec de nombreux utilisateurs
-e NODE_OPTIONS="--max-old-space-size=4096"

• Pour le mode base de données avec plus de 10 utilisateurs simultanés, assurez-vous d'avoir au moins 8 Go de RAM sur l'hôte.

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

Persistance entre les sessions Clore.ai

Étant donné que les serveurs Clore.ai peuvent être arrêtés :

# Créez un volume Docker pour les exportations de conversations en mode autonome
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 des données dans l'interface.

---

Dépannage

Le conteneur ne démarre pas

# Vérifier les journaux
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 est en cours d'exécution
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 l'état 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 les migrations manuellement si nécessaire
docker exec lobe-chat npx prisma migrate deploy

Les images/fichiers ne se téléversent pas (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 la bonne adresse IP du serveur

Erreurs de mémoire insuffisante

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

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

---

Pour aller plus loin

• Documentation de LobeChat — documentation officielle, développement de plugins, guides de déploiement

• GitHub de LobeChat — code source, problèmes, discussions

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

• Exécuter vLLM sur Clore.ai — inférence haute performance compatible OpenAI

• Guide de comparaison des GPU — choisir le bon GPU Clore.ai

• LobeChat Docker Hub — tags et versions des images

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