Plateforme RAG AnythingLLM

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

Aperçu

AnythingLLM est un espace de travail IA complet et open-source avec plus de 40K étoiles sur GitHub. Il combine la RAG (génération augmentée par récupération) basée sur des documents, des agents IA et un constructeur d'agents sans code en une seule application auto-hébergée — le tout géré via une interface propre et intuitive qui ne nécessite aucune compétence en codage 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 segmente automatiquement, crée des embeddings et les stocke pour la recherche sémantique.
Aucun GPU requis pour l'application — AnythingLLM utilise par défaut des embeddings basés 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 Model Context Protocol pour une connectivité d'outils étendue.
Isolation des espaces de travail — Créez des espaces de travail distincts avec des bases de connaissances et des paramètres de LLM différents pour différents projets ou équipes.

Vue d'ensemble de l'architecture

┌─────────────────────────────────────────────┐
│            AnythingLLM (Port 3001)          │
│                                             │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │ RAG/Docs │  │  Agents  │  │  Users   │  │
│  └────┬─────┘  └────┬─────┘  └──────────┘  │
│       │             │                       │
│  ┌────▼─────────────▼───────┐               │
│  │    LLM Provider Router   │               │
│  └──────────────┬───────────┘               │
└─────────────────┼───────────────────────────┘
                  │
     ┌────────────┼────────────┐
     ▼            ▼            ▼
  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 backend Ollama/vLLM uniquement

VRAM

—

24 Go

Pour l’inférence de modèles locaux

CPU

2 vCPU

4 vCPU

Les embeddings s'exécutent sur le CPU

RAM

4 Go

8 Go

Plus = index de documents plus grand en mémoire

Stockage

10 Go

50+ Go

Stockage de documents, base de données de vecteurs, cache de modèles

Référence de tarification Clore.ai

Type de serveur

Coût approximatif

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

~0,20 $/h

AnythingLLM + LLMs locaux Ollama

RTX 4090 (24 Go VRAM)

~0,35 $/h

AnythingLLM + inférence locale plus rapide

A100 80 Go

~1,10 $/h

AnythingLLM + grands modèles 70B+

💡 Astuce pro : L'embedding intégré d'AnythingLLM (LanceDB + embedder CPU local) fonctionne sans GPU. Pour le backend LLM, vous pouvez utiliser des fournisseurs d'API avec offre gratuite comme OpenRouter ou Groq pour limiter 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 store de vecteurs LanceDB et le processeur de documents.

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

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

É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 de pages web et le rendu de PDF, ce qui nécessite des capacités supplémentaires pour le conteneur.

Étape 4 : Vérifier le démarrage

docker logs anythingllm --tail 30 -f
# Attendre : "Server listening on port 3001"

Étape 5 : Compléter l'assistant de configuration

Ouvrez dans le navigateur :

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

L'assistant de configuration initial vous guide à travers :

Créer un compte administrateur
Choisir un fournisseur LLM
Choisir un modèle d'embedding
Configurer votre premier espace de travail

Méthode 2 : Docker Compose (Multi-service)

Pour des déploiements en production avec des services séparés et une gestion facilitée :

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

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

Étape 2 : Créer 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
      # Embedding
      EMBEDDING_ENGINE : native
      # Base de données de vecteurs
      VECTOR_DB : lancedb
      # Auth
      AUTH_TOKEN : ${ANYTHINGLLM_AUTH_TOKEN}
      JWT_SECRET : ${JWT_SECRET}
    volumes :
      - ./storage:/app/server/storage
    healthcheck :
      test : ["CMD", "curl", "-f", "http://localhost:3001/api/ping"]
      intervalle : 30s
      timeout : 10s
      retries : 3

volumes :
  anythingllm_storage :
EOF

Étape 3 : Créer .env fichier

cat > .env << 'EOF'
OPENAI_API_KEY=sk-votre-cle-openai-ici
ANYTHINGLLM_AUTH_TOKEN=mot-de-passe-de-votre-instance-ici
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 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-votre-cle \
  -e OPEN_MODEL_PREF=gpt-4o-mini \
  -e EMBEDDING_ENGINE=native \
  -e VECTOR_DB=lancedb \
  -e AUTH_TOKEN=votre-mot-de-passe \
  -e JWT_SECRET=$(openssl rand -hex 32) \
  mintplexlabs/anythingllm

Configuration

Options de fournisseur LLM

AnythingLLM prend en charge une large gamme de backends LLM. À définir dans l'UI sous Paramètres → Préférence LLM, ou via des variables d'environnement :

OpenAI :

-e LLM_PROVIDER=openai
-e OPEN_AI_KEY=sk-votre-cle
-e OPEN_MODEL_PREF=gpt-4o

Anthropic Claude :

-e LLM_PROVIDER=anthropic
-e ANTHROPIC_API_KEY=sk-ant-votre-cle
-e ANTHROPIC_MODEL_PREF=claude-sonnet-4-5

Google Gemini :

-e LLM_PROVIDER=gemini
-e GEMINI_API_KEY=votre-cle
-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 à 100+ modèles) :

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

Configuration des embeddings

Moteur

Backend

GPU requis

Qualité

native

CPU (intégré)

Non

Bon

openai

API OpenAI

Non

Excellent

ollama

Ollama local

Optionnel

Bon-Excellent

localai

LocalAI

Optionnel

Variable

# Utiliser les embeddings OpenAI pour une meilleure qualité
-e EMBEDDING_ENGINE=openai
-e OPEN_AI_KEY=sk-votre-cle
-e EMBEDDING_MODEL_PREF=text-embedding-3-small

# Utiliser 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 de vecteurs

Description

Idéal pour

lancedb

Intégré, sans configuration

Par défaut, jeux de données petits à moyens

chroma

ChromaDB (externe)

Jeux de données moyens, flexibilité

pinecone

Pinecone cloud

Jeux de données volumineux, production

weaviate

Weaviate (auto-hébergé)

Cas d'utilisation avancés

Configuration de l'espace de travail

Les espaces de travail AnythingLLM sont des environnements isolés avec leur propre :

Base de connaissances de documents
Paramètres LLM (peuvent remplacer le global)
Historique de chat
Configurations d'agents

Créer des espaces de travail via l'UI 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 votre-cle-api" \
  -H "Content-Type: application/json" \
  -d '{"name": "Mon Projet", "similarityThreshold": 0.7}'

Ingestion de documents

Téléversez des documents via l'UI ou l'API :

# Téléverser un document via l'API
curl -X POST http://localhost:3001/api/v1/document/upload \
  -H "Authorization: Bearer votre-cle-api" \
  -F "file=@/chemin/vers/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 votre-cle-api" \
  -H "Content-Type: application/json" \
  -d '{"adds": ["custom-documents/document.pdf-chunk-1.json"]}'

Accélération GPU

AnythingLLM lui-même fonctionne sur CPU. L'accélération GPU s'applique au backend d'inférence LLM.

Exécuter Ollama sur le même serveur Clore.ai

# Démarrez Ollama avec le support GPU
docker run -d \
  --name ollama \
  --gpus all \
  --restart unless-stopped \
  -p 11434:11434 \
  -v ollama_data:/root/.ollama \
  ollama/ollama

# Télécharger des 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

Performance des modèles GPU sur Clore.ai

Modèle

GPU

VRAM

Vitesse d'embedding

Vitesse d'inférence

Coût / h

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

40 Go

Moyen

20–35 tok/s

~$1.10

Conseils et bonnes pratiques

Bonnes pratiques pour l'ingestion de documents

# Pour de grands ensembles de documents, augmentez la mémoire 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 chunk 1000, recouvrement 200
# Juridique/contrats : taille de chunk 500, recouvrement 100
# Livres/articles : taille de chunk 1500, recouvrement 300

Pré-traitez les gros PDFs — Les scans lourds en OCR ralentissent l'ingestion. Utilisez pdftotext ou Adobe OCR au préalable.
Organisez par espace de travail — Créez des espaces de travail séparés par projet/domaine pour une meilleure précision de récupération.
Utilisez des requêtes spécifiques — La RAG fonctionne mieux avec des questions spécifiques, pas des demandes larges.

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 de chat
Configurations d'agents

Configuration multi-utilisateurs

# Activez le mode multi-utilisateurs dans l'UI :
# 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 activation du 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 des agents IA

Les agents AnythingLLM peuvent accomplir des tâches réelles. Activez les outils dans Paramètres → Agents:

Navigation Web — Récupère et lit des pages web
Recherche Google — Recherche sur Google (nécessite une clé API)
Interpréteur de code — Exécute du Python dans un sandbox
GitHub — Lit des dépôts
Connecteur SQL — Interroge des bases de données

# Activez les capacités des agents via l'environnement
-e AGENT_SEARCH_PROVIDER=google
-e AGENT_GSX_GOOGLE_SEARCH_ENGINE_ID=votre-cx-id
-e AGENT_GSX_GOOGLE_SEARCH_KEY=votre-cle-api

Optimisation des performances

# Pour des charges de traitement de documents lourdes
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érer la dernière image
docker pull mintplexlabs/anythingllm:latest

# Sauvegarder 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, sûres)
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'UI n'est pas accessible

# Vérifier que le conteneur fonctionne
docker ps | grep anythingllm

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

# Vérifier le binding du port
ss -tlnp | grep 3001

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

Échec du téléversement de document

# Vérifier 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 solutions :

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

# 2. Augmenter le top-K des résultats
# Paramètres → Espace de travail → Base de données vectorielle → Max Context Snippets : 10

# 3. Améliorer la taille des chunks (ré-ingérer les documents après modification)
# Paramètres → Espace de travail → Scindeur de texte → Taille de chunk : 1000, Recouvrement : 200

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

La connexion Ollama échoue 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'IP réelle du bridge Docker
ip route | grep docker
# Utilisez cette IP dans OLLAMA_BASE_PATH

# Alternative : utiliser le réseau host
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érez de la mémoire en réduisant le cache LanceDB
# Ou passez à une instance Clore.ai avec plus de RAM

# Redémarrer avec limites mémoire et 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

Lectures complémentaires

Documentation AnythingLLM — guide d'installation complet et référence API
AnythingLLM GitHub — code source, issues, feuille de route
AnythingLLM Docker Hub — tags d'images
Exécuter Ollama sur Clore.ai — backend LLM local pour AnythingLLM
Exécuter vLLM sur Clore.ai — inférence haute performance
Guide de comparaison GPU — choisir le bon niveau Clore.ai
Documentation MCP — Model Context Protocol pour étendre les agents
Référence API AnythingLLM — API REST pour l'automatisation

PrécédentLibreChat Multi-fournisseur SuivantAssistant hors ligne Jan.ai

Mis à jour il y a 23 heures

Ce contenu vous a-t-il été utile ?

hashtagAperçu

hashtagVue d'ensemble de l'architecture

hashtagExigences

hashtagSpécifications du serveur

hashtagRéférence de tarification Clore.ai

hashtagPrérequis

hashtagDémarrage rapide

hashtagMéthode 1 : Conteneur Docker unique (Recommandé)

hashtagMéthode 2 : Docker Compose (Multi-service)

hashtagMéthode 3 : Avec variables d'environnement préconfigurées

hashtagConfiguration

hashtagOptions de fournisseur LLM

hashtagConfiguration des embeddings

hashtagOptions de base de données de vecteurs

hashtagConfiguration de l'espace de travail

hashtagIngestion de documents

hashtagAccélération GPU

hashtagExécuter Ollama sur le même serveur Clore.ai

hashtagPerformance des modèles GPU sur Clore.ai

hashtagConseils et bonnes pratiques

hashtagBonnes pratiques pour l'ingestion de documents

hashtagGestion des coûts sur Clore.ai

hashtagConfiguration multi-utilisateurs

hashtagConfiguration des agents IA

hashtagOptimisation des performances

hashtagMise à jour d'AnythingLLM

hashtagDépannage

hashtagLe conteneur démarre mais l'UI n'est pas accessible

hashtagÉchec du téléversement de document

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

hashtagLa connexion Ollama échoue depuis AnythingLLM

hashtagManque de mémoire / crash du conteneur

hashtagLectures complémentaires

Aperçu

Vue d'ensemble de l'architecture

Exigences

Spécifications du serveur

Référence de tarification Clore.ai

Prérequis

Démarrage rapide

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

Méthode 2 : Docker Compose (Multi-service)

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

Configuration

Options de fournisseur LLM

Configuration des embeddings

Options de base de données de vecteurs

Configuration de l'espace de travail

Ingestion de documents

Accélération GPU

Exécuter Ollama sur le même serveur Clore.ai

Performance des modèles GPU sur Clore.ai

Conseils et bonnes pratiques

Bonnes pratiques pour l'ingestion de documents

Gestion des coûts sur Clore.ai

Configuration multi-utilisateurs

Configuration des agents IA

Optimisation des performances

Mise à jour d'AnythingLLM

Dépannage

Le conteneur démarre mais l'UI n'est pas accessible

Échec du téléversement de document

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

La connexion Ollama échoue depuis AnythingLLM

Manque de mémoire / crash du conteneur

Lectures complémentaires