Plateforme RAG AnythingLLM

Déployez AnythingLLM sur Clore.ai — une application RAG tout-en-un et une plateforme d'agents IA avec chat documentaire intégré, constructeur d'agents no-code et prise en charge MCP, fonctionnant sur des serveurs cloud GPU économiques.

Aperçu

AnythingLLM est un espace de travail IA open source, complet, avec plus de 40 k étoiles sur GitHub. Il combine le RAG basé sur les documents (Retrieval-Augmented Generation), des agents IA et un générateur d’agents sans code dans une seule application auto-hébergée — le tout géré via une interface utilisateur claire et intuitive qui ne nécessite aucune programmation pour être configurée.

Pourquoi exécuter AnythingLLM sur Clore.ai ?

• Pipeline RAG complet prêt à l’emploi — Téléversez des PDF, des documents Word, des sites web et des transcriptions YouTube. AnythingLLM les segmente, les vectorise et les stocke automatiquement pour la recherche sémantique.

• Aucun GPU requis pour l’application — AnythingLLM utilise par défaut un encodage basé sur le CPU. Associez-le à un serveur GPU Clore.ai exécutant Ollama ou vLLM pour l’inférence locale.

• Agents IA avec de vrais outils — Les agents intégrés peuvent naviguer sur le web, écrire et exécuter du code, gérer des fichiers et appeler des API externes — le tout orchestré via une interface graphique.

• Compatibilité MCP — S’intègre à l’écosystème du Model Context Protocol pour une connectivité étendue aux outils.

• Isolation des espaces de travail — Créez des espaces de travail distincts avec différentes bases de connaissances et paramètres LLM pour différents projets ou équipes.

Vue d’ensemble de l’architecture

┌─────────────────────────────────────────────┐
│            AnythingLLM (Port 3001)          │
│                                             │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │ RAG/Docs │  │  Agents  │  │  Users   │  │
│  └────┬─────┘  └────┬─────┘  └──────────┘  │
│       │             │                       │
│  ┌────▼─────────────▼───────┐               │
│  │    Routeur du fournisseur LLM   │               │
│  └──────────────┬───────────┘               │
└─────────────────┼───────────────────────────┘
                  │
     ┌────────────┼────────────┐
     ▼            ▼            ▼
  OpenAI       Anthropic    Ollama (local)
  Claude        Gemini      vLLM (local)

---

Exigences

Spécifications du serveur

Composant	Minimum	Recommandé	Remarques
GPU	Aucun requis	RTX 3090 (si vous utilisez des LLM locaux)	Pour le backend Ollama/vLLM uniquement
VRAM	—	24 Go	Pour l’inférence de modèles locaux
CPU	2 vCPU	4 vCPU	L’encodage s’exécute sur le CPU
RAM	4 Go	8 Go	Plus = index de documents plus volumineux en mémoire
Stockage	10 Go	50+ Go	Stockage des documents, base de données vectorielle, cache des modèles

Référence tarifaire Clore.ai

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

💡 Conseil de pro : L’encodage intégré d’AnythingLLM (LanceDB + encodeur local sur CPU) fonctionne sans GPU. Pour le backend LLM, vous pouvez utiliser des fournisseurs d’API gratuits comme OpenRouter ou Groq afin de réduire au minimum les coûts.

Prérequis

• Serveur Clore.ai avec accès SSH

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

• Au moins une clé API LLM ou backend local Ollama/vLLM

---

Démarrage rapide

Méthode 1 : Conteneur Docker unique (recommandé)

Le déploiement officiel en conteneur unique inclut tout : l’interface web, le magasin vectoriel LanceDB et le processeur de documents.

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

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

Étape 2 : Configurer le répertoire de stockage

export STORAGE_LOCATION=$HOME/anythingllm
mkdir -p $STORAGE_LOCATION
touch "$STORAGE_LOCATION/.env"

Étape 3 : Exécuter AnythingLLM

docker run -d \
  --name anythingllm \\
  --restart unless-stopped \\
  -p 3001:3001 \\
  --cap-add SYS_ADMIN \\
  -v ${STORAGE_LOCATION}:/app/server/storage \\
  -v ${STORAGE_LOCATION}/.env:/app/server/.env \\
  -e STORAGE_DIR="/app/server/storage" \\
  mintplexlabs/anythingllm

Pourquoi --cap-add SYS_ADMIN? AnythingLLM utilise Chromium pour le scraping des pages web et le rendu des PDF, ce qui nécessite des capacités de conteneur élevées.

Étape 4 : Vérifier le démarrage

docker logs anythingllm --tail 30 -f
# Attendez : "Serveur à l’écoute sur le port 3001"

Étape 5 : Terminer l’assistant de configuration

Ouvrez dans le navigateur :

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

L’assistant de configuration initial vous guide à travers :

1. Créer un compte administrateur

2. Choisir le fournisseur LLM

3. Choisir le modèle d’embedding

4. Configurer votre premier espace de travail

---

Méthode 2 : Docker Compose (multiservice)

Pour des déploiements de production avec des services séparés et une gestion plus simple :

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

mkdir -p ~/anythingllm && cd ~/anythingllm
mkdir -p storage
touch storage/.env

Étape 2 : créez docker-compose.yml

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

services:
  anythingllm:
    image: mintplexlabs/anythingllm:latest
    container_name: anythingllm
    restart: unless-stopped
    ports:
      - "3001:3001"
    cap_add:
      - SYS_ADMIN
    environment :
      STORAGE_DIR: "/app/server/storage"
      # Fournisseur LLM (configurer un seul)
      LLM_PROVIDER: openai
      OPEN_AI_KEY: ${OPENAI_API_KEY}
      OPEN_MODEL_PREF: gpt-4o-mini
      # Intégration
      EMBEDDING_ENGINE: native
      # Base de données vectorielle
      VECTOR_DB: lancedb
      # Authentification
      AUTH_TOKEN: ${ANYTHINGLLM_AUTH_TOKEN}
      JWT_SECRET: ${JWT_SECRET}
    volumes:
      - ./storage:/app/server/storage
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3001/api/ping"]
      interval: 30s
      timeout: 10s
      retries: 3

volumes:
  anythingllm_storage:
EOF

Étape 3 : Créer .env fichier

cat > .env << 'EOF'
OPENAI_API_KEY=sk-your-openai-key-here
ANYTHINGLLM_AUTH_TOKEN=your-instance-password-here
JWT_SECRET=votre-secret-aléatoire-de-64-caractères-ici
EOF

Étape 4 : Démarrer

docker compose up -d
docker compose logs anythingllm -f

---

Méthode 3 : Avec des variables d’environnement préconfigurées

Pour un déploiement automatisé sans l’assistant de configuration :

export STORAGE_LOCATION=$HOME/anythingllm
mkdir -p $STORAGE_LOCATION && touch "$STORAGE_LOCATION/.env"

docker run -d \
  --name anythingllm \\
  --restart unless-stopped \\
  -p 3001:3001 \\
  --cap-add SYS_ADMIN \\
  -v ${STORAGE_LOCATION}:/app/server/storage \\
  -v ${STORAGE_LOCATION}/.env:/app/server/.env \\
  -e STORAGE_DIR="/app/server/storage" \\
  -e LLM_PROVIDER=openai \\
  -e OPEN_AI_KEY=sk-your-key \\
  -e OPEN_MODEL_PREF=gpt-4o-mini \\
  -e EMBEDDING_ENGINE=native \\
  -e VECTOR_DB=lancedb \\
  -e AUTH_TOKEN=your-password \\
  -e JWT_SECRET=$(openssl rand -hex 32) \\
  mintplexlabs/anythingllm

---

Configuration

Options du fournisseur LLM

AnythingLLM prend en charge un large éventail de backends LLM. À définir dans l’interface utilisateur sous Paramètres → Préférence LLM, ou via des variables d’environnement :

OpenAI :

-e LLM_PROVIDER=openai
-e OPEN_AI_KEY=sk-your-key
-e OPEN_MODEL_PREF=gpt-4o

Claude d’Anthropic :

-e LLM_PROVIDER=anthropic
-e ANTHROPIC_API_KEY=sk-ant-your-key
-e ANTHROPIC_MODEL_PREF=claude-sonnet-4-5

Google Gemini :

-e LLM_PROVIDER=gemini
-e GEMINI_API_KEY=your-key
-e GEMINI_LLM_MODEL_PREF=gemini-1.5-pro

Ollama (local) :

-e LLM_PROVIDER=ollama
-e OLLAMA_BASE_PATH=http://172.17.0.1:11434
-e OLLAMA_MODEL_PREF=llama3.2

OpenRouter (accès à plus de 100 modèles) :

-e LLM_PROVIDER=openrouter
-e OPENROUTER_API_KEY=sk-or-your-key
-e OPENROUTER_MODEL_PREF=meta-llama/llama-3.1-8b-instruct:free

Configuration de l’intégration

Moteur	Backend	GPU requis	Qualité
native	CPU (intégré)	Non	Bon
openai	API OpenAI	Non	Excellente
ollama	Ollama local	Facultatif	Bon à excellent
localai	LocalAI	Facultatif	Variable

# Utilisez les embeddings OpenAI pour la meilleure qualité
-e EMBEDDING_ENGINE=openai
-e OPEN_AI_KEY=sk-your-key
-e EMBEDDING_MODEL_PREF=text-embedding-3-small

# Utilisez les embeddings Ollama pour un pipeline entièrement local
-e EMBEDDING_ENGINE=ollama
-e OLLAMA_BASE_PATH=http://172.17.0.1:11434
-e EMBEDDING_MODEL_PREF=nomic-embed-text

Options de base de données vectorielle

BD	Description	Idéal pour
lancedb	Intégré, sans configuration	Par défaut, ensembles de données petits à moyens
chroma	ChromaDB (externe)	Ensembles de données moyens, flexibilité
pinecone	Pinecone cloud	Ensembles de données volumineux, production
weaviate	Weaviate (auto-hébergé)	Cas d’usage avancés

Configuration des espaces de travail

Les espaces de travail AnythingLLM sont des environnements isolés avec leurs propres :

• Base de connaissances documentaire

• Paramètres LLM (peuvent remplacer les paramètres globaux)

• Historique des conversations

• Configurations des agents

Créez des espaces de travail via l’interface ou l’API :

# Créer un espace de travail via l’API
curl -X POST http://localhost:3001/api/v1/workspace/new \\
  -H "Authorization: Bearer your-api-key" \\
  -H "Content-Type: application/json" \
  -d '{"name": "Mon projet", "similarityThreshold": 0.7}'

Ingestion de documents

Téléversez des documents via l’interface ou l’API :

# Téléverser un document via l’API
curl -X POST http://localhost:3001/api/v1/document/upload \\
  -H "Authorization: Bearer your-api-key" \\
  -F "file=@/path/to/document.pdf"

# Déplacer le document vers l’espace de travail
curl -X POST http://localhost:3001/api/v1/workspace/my-project/update-embeddings \\
  -H "Authorization: Bearer your-api-key" \\
  -H "Content-Type: application/json" \
  -d '{"adds": ["custom-documents/document.pdf-chunk-1.json"]}'

---

Accélération GPU

AnythingLLM s’exécute lui-même sur le CPU. L’accélération GPU s’applique au backend d’inférence LLM.

Exécution d’Ollama sur le même serveur Clore.ai

# Démarrer Ollama avec prise en charge GPU
docker run -d \
  --name ollama \\
  --gpus all \
  --restart unless-stopped \\
  -p 11434:11434 \
  -v ollama_data:/root/.ollama \\
  ollama/ollama

# Télécharger les modèles pour AnythingLLM
docker exec ollama ollama pull llama3.2          # 2B, rapide
docker exec ollama ollama pull llama3.1:8b       # 8B, équilibré
docker exec ollama ollama pull nomic-embed-text  # pour les embeddings
docker exec ollama ollama pull mxbai-embed-large # meilleurs embeddings

# Redémarrer AnythingLLM avec la configuration Ollama
docker stop anythingllm && docker rm anythingllm

docker run -d \
  --name anythingllm \\
  --restart unless-stopped \\
  -p 3001:3001 \\
  --cap-add SYS_ADMIN \\
  -v $HOME/anythingllm:/app/server/storage \\
  -v $HOME/anythingllm/.env:/app/server/.env \\
  -e STORAGE_DIR="/app/server/storage" \\
  -e LLM_PROVIDER=ollama \\
  -e OLLAMA_BASE_PATH=http://172.17.0.1:11434 \\
  -e OLLAMA_MODEL_PREF=llama3.1:8b \\
  -e EMBEDDING_ENGINE=ollama \\
  -e EMBEDDING_MODEL_PREF=nomic-embed-text \\
  mintplexlabs/anythingllm

Performances du modèle GPU sur Clore.ai

Modèle	GPU	VRAM	Vitesse d’encodage	Vitesse d’inférence	Coût/heure
Llama 3.2 3B	RTX 3090	2 Go	Rapide	60–80 tok/s	~$0.20
Llama 3.1 8B	RTX 3090	6 Go	Rapide	40–60 tok/s	~$0.20
Mistral 7B	RTX 3090	5 Go	Rapide	45–65 tok/s	~$0.20
Llama 3.1 70B	A100 80 Go	40 Go	Moyen	20–35 tok/s	~$1.10

---

Conseils et bonnes pratiques

Bonnes pratiques pour l’ingestion de documents

# Pour les grands ensembles de documents, augmentez la mémoire de Node.js
-e NODE_OPTIONS="--max-old-space-size=4096"

# Paramètres de découpage recommandés pour différents types de documents
# Docs techniques : taille de segment 1000, chevauchement 200
# Contrats/juridique : taille de segment 500, chevauchement 100
# Livres/articles : taille de segment 1500, chevauchement 300

• Prétraiter les gros PDF — Les scans avec beaucoup d’OCR ralentissent l’ingestion. Utilisez pdftotext ou Adobe OCR au préalable.

• Organiser par espace de travail — Créez des espaces de travail distincts par projet/domaine pour une meilleure précision de récupération.

• Utilisez des requêtes spécifiques — Le RAG fonctionne mieux avec des questions précises, pas avec des demandes générales.

Gestion des coûts sur Clore.ai

# Sauvegardez votre stockage avant d’arrêter une instance Clore.ai
tar -czf anythingllm-backup-$(date +%Y%m%d).tar.gz ~/anythingllm/

# Pour reprendre sur une nouvelle instance Clore.ai, restaurez la sauvegarde
tar -xzf anythingllm-backup-20240101.tar.gz -C ~/

Comme les instances Clore.ai sont éphémères, sauvegardez toujours le répertoire de stockage. Il contient :

• Embeddings vectoriels (LanceDB)

• Documents téléversés

• Historique des conversations

• Configurations des agents

Configuration multi-utilisateur

# Activer le mode multi-utilisateur dans l’interface :
# Paramètres → Sécurité → Activer le mode multi-utilisateur

# Ou via l’environnement :
-e MULTI_USER_MODE=true

# Créer un utilisateur via l’API après avoir activé le mode multi-utilisateur
curl -X POST http://localhost:3001/api/v1/admin/users/new \\
  -H "Authorization: Bearer admin-api-key" \\
  -H "Content-Type: application/json" \
  -d '{"username": "alice", "password": "securepass", "role": "default"}'

Configuration de l’agent IA

Les agents AnythingLLM peuvent effectuer des tâches du monde réel. Activez les outils dans Paramètres → Agents:

• Navigation web — Récupère et lit les pages web

• Recherche Google — Recherche sur Google (clé API requise)

• Interpréteur de code — Exécute du Python dans un bac à sable

• GitHub — Lit des dépôts

• Connecteur SQL — Interroge des bases de données

# Activer les capacités des agents via l’environnement
-e AGENT_SEARCH_PROVIDER=google
-e AGENT_GSX_GOOGLE_SEARCH_ENGINE_ID=your-cx-id
-e AGENT_GSX_GOOGLE_SEARCH_KEY=your-api-key

Réglage des performances

# Pour les charges de travail lourdes de traitement de documents
docker run -d \
  --name anythingllm \\
  --restart unless-stopped \\
  --cpus="4" \\
  --memory="8g" \\
  -p 3001:3001 \\
  --cap-add SYS_ADMIN \\
  -v $HOME/anythingllm:/app/server/storage \\
  -v $HOME/anythingllm/.env:/app/server/.env \\
  -e STORAGE_DIR="/app/server/storage" \\
  mintplexlabs/anythingllm

Mise à jour d’AnythingLLM

# Récupérez la dernière image
docker pull mintplexlabs/anythingllm:latest

# Sauvegarde d’abord
cp -r $HOME/anythingllm $HOME/anythingllm-backup-$(date +%Y%m%d)

# Arrêter et supprimer l’ancien conteneur (les données sont dans le volume, sans risque)
docker stop anythingllm && docker rm anythingllm

# Redémarrer avec la même commande
docker run -d \
  --name anythingllm \\
  --restart unless-stopped \\
  -p 3001:3001 \\
  --cap-add SYS_ADMIN \\
  -v $HOME/anythingllm:/app/server/storage \\
  -v $HOME/anythingllm/.env:/app/server/.env \\
  -e STORAGE_DIR="/app/server/storage" \\
  mintplexlabs/anythingllm

---

Dépannage

Le conteneur démarre, mais l’interface n’est pas accessible

# Vérifier que le conteneur est en cours d'exécution
docker ps | grep anythingllm

# Vérifier les logs pour les erreurs de démarrage
docker logs anythingllm --tail 50

# Vérifiez la liaison du port
ss -tlnp | grep 3001

# Vérifiez si le serveur Clore.ai a le port 3001 dans le mappage des ports
# (ajoutez-le dans les paramètres de déploiement Clore.ai)

Échec du téléversement du document

# Vérifiez l'espace disque disponible
df -h

# Inspecter les logs du processeur de documents
docker logs anythingllm 2>&1 | grep -i "error\|fail\|upload"

# Vérifier que la capacité SYS_ADMIN est définie (requise pour Chromium)
docker inspect anythingllm | grep -A5 CapAdd

Les réponses RAG sont de mauvaise qualité / hallucinent

Causes courantes et correctifs :

# 1. Ajuster le seuil de similarité (plus bas = plus de documents récupérés)
# Paramètres → Espace de travail → Base de données vectorielle → Seuil de similarité : 0.5

# 2. Augmenter le nombre de résultats top-K
# Paramètres → Espace de travail → Base de données vectorielle → Nombre maximal d’extraits de contexte : 10

# 3. Améliorer la taille des segments (réingérez les documents après modification)
# Paramètres → Espace de travail → Séparateur de texte → Taille de segment : 1000, chevauchement : 200

# 4. Passer à un meilleur modèle d’embeddings
-e EMBEDDING_ENGINE=openai
-e EMBEDDING_MODEL_PREF=text-embedding-3-large

Échec de la connexion à Ollama depuis AnythingLLM

# Tester depuis le conteneur AnythingLLM
docker exec anythingllm curl -s http://172.17.0.1:11434/api/tags

# Si cela échoue, trouvez l’adresse IP réelle du pont Docker
ip route | grep docker
# Utilisez cette IP dans OLLAMA_BASE_PATH

# Alternative : utiliser le réseau de l’hôte
docker run -d \
  --name anythingllm \\
  --network host \
  --cap-add SYS_ADMIN \\
  -v $HOME/anythingllm:/app/server/storage \\
  -v $HOME/anythingllm/.env:/app/server/.env \\
  -e STORAGE_DIR="/app/server/storage" \\
  -e OLLAMA_BASE_PATH=http://localhost:11434 \\
  mintplexlabs/anythingllm

Manque de mémoire / crash du conteneur

# Vérifier l'utilisation de la mémoire
docker stats anythingllm

# Libérer de la mémoire en réduisant le cache LanceDB
# Ou passez à une instance Clore.ai avec plus de RAM

# Redémarrer avec des limites de mémoire et un swap
docker run -d \
  --name anythingllm \\
  --memory=6g \\
  --memory-swap=8g \\
  -p 3001:3001 \\
  --cap-add SYS_ADMIN \\
  -v $HOME/anythingllm:/app/server/storage \\
  -v $HOME/anythingllm/.env:/app/server/.env \\
  -e STORAGE_DIR="/app/server/storage" \\
  mintplexlabs/anythingllm

---

Pour aller plus loin

• Documentation AnythingLLM — configuration complète et référence de l’API

• AnythingLLM GitHub — code source, problèmes, feuille de route

• AnythingLLM Docker Hub — tags d'image

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

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

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

• Documentation MCP — protocole de contexte du modèle pour étendre les agents

• Référence de l’API AnythingLLM — API REST pour l’automatisation