AnythingLLM en entreprise : guide complet d'installation, RAG et multi-utilisateurs

Qu'est-ce qu'AnythingLLM ?

AnythingLLM est une application open-source développée par Mintplex Labs, publiée sous licence MIT depuis 2023. Sa proposition de valeur est unique dans l'écosystème LLM local : regrouper en un seul produit tout ce dont une équipe d'entreprise a besoin pour utiliser l'IA sur ses propres données, sans avoir à assembler et maintenir une stack de 5 à 7 outils distincts.

Là où d'autres solutions vous demandent de combiner Ollama + une base vectorielle (ChromaDB, Qdrant) + un framework RAG (LangChain, LlamaIndex) + une interface web + un système d'authentification + une couche d'administration, AnythingLLM intègre tout cela nativement dans un seul conteneur Docker.

Ce choix d'intégration a un coût en flexibilité pour les cas avancés, mais représente un gain de temps et de fiabilité considérable pour les organisations qui n'ont pas les ressources pour maintenir une stack complexe. C'est le compromis fondateur d'AnythingLLM, et c'est le bon compromis pour la majorité des PME.

Les composants intégrés nativement

Composant	Ce qu'il fait dans AnythingLLM	Équivalent externe séparé
Connecteur LLM	Connexion à Ollama, LiteLLM, OpenAI, Anthropic, Groq…	Ollama / LiteLLM
Base vectorielle	LanceDB (défaut), ChromaDB, Pinecone, Qdrant, Weaviate	ChromaDB / Qdrant standalone
Pipeline RAG	Chunking, embedding, retrieval sémantique automatiques	LangChain / LlamaIndex
Interface chat	Web responsive, historique, multi-turn, streaming	Open WebUI
Gestion utilisateurs	Rôles admin/manager/user, espaces de travail isolés	Keycloak + custom
Ingestion documents	PDF, Word, Excel, CSV, TXT, URL, YouTube, GitHub	Apache Tika + custom parsers
Agents IA	Recherche web, exécution code, outils personnalisés	LangGraph / AutoGen

Architecture technique d'AnythingLLM

AnythingLLM suit une architecture à trois couches bien séparées et hébergées dans un seul conteneur Docker :

1. Frontend React : interface SPA (Single Page Application) servie en HTTPS, accessible via navigateur. Légère, responsive, utilisable sur mobile et tablette.
2. Backend Node.js/Express : API REST qui orchestre l'ensemble — authentification et sessions, gestion des workspaces, pipeline RAG (chunking, embedding, retrieval), communication avec le LLM backend, gestion des fichiers importés.
3. Couche de stockage : base SQLite pour les métadonnées, les utilisateurs et l'historique des conversations ; base vectorielle LanceDB (embarquée) ou ChromaDB (externe) pour les embeddings documentaires.

La communication avec le moteur LLM est entièrement externalisée : AnythingLLM n'embarque aucun moteur d'inférence. Il parle à Ollama via HTTP REST, ce qui permet de séparer physiquement l'interface (serveur léger, 8 Go RAM) du moteur GPU (serveur puissant, 24+ Go VRAM).

Prérequis matériels détaillés

Configuration pour AnythingLLM uniquement (interface + RAG)

Composant	Minimum (10 users)	Recommandé (50 users)	Production (200 users)
CPU	4 cœurs	8 cœurs	16 cœurs
RAM	8 Go	16 Go	32 Go
Stockage documents	50 Go SSD	200 Go SSD NVMe	1 To SSD NVMe
GPU (pour AnythingLLM)	Non requis	Non requis	Non requis
OS	Ubuntu 22.04 LTS	Ubuntu 22.04 LTS	Ubuntu 22.04/24.04 LTS
Docker	24.x	26.x + Compose v2	26.x + Compose v2

Configuration pour Ollama (moteur LLM, sur même machine ou séparée)

Modèle cible	VRAM GPU minimale	GPU recommandé	CPU fallback (lent)
Mistral 7B Q4	4 Go VRAM	RTX 3060 12 Go	32 Go RAM, lent
Llama 3.1 8B Q4	5 Go VRAM	RTX 3070 / 4060	32 Go RAM, lent
Mistral 7B Q8	8 Go VRAM	RTX 3080 / 4070	64 Go RAM, très lent
Mixtral 8x7B Q4	26 Go VRAM	RTX 4090 ou dual GPU	Non recommandé
Llama 3.1 70B Q4	40 Go VRAM	A100 40 Go	Non recommandé

Installation Docker pas à pas

Étape 1 — Préparer l'environnement serveur

# Mettre à jour Ubuntu
sudo apt update && sudo apt upgrade -y

# Installer Docker Engine (méthode officielle)
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER
newgrp docker

# Vérifier Docker Compose v2
docker compose version
# Doit afficher : Docker Compose version v2.x.x

# Créer les répertoires de données persistantes
sudo mkdir -p /opt/anythingllm/storage
sudo chown -R $USER:$USER /opt/anythingllm

# Créer le fichier d'environnement
cat > /opt/anythingllm/.env << 'EOF'
STORAGE_DIR=/app/server/storage
JWT_SECRET=$(openssl rand -hex 32)
AUTH_TOKEN=$(openssl rand -hex 16)
NODE_OPTIONS=--max-old-space-size=4096
EOF

cat /opt/anythingllm/.env  # Vérifier les valeurs générées

Étape 2 — Fichier docker-compose.yml recommandé pour production

# /opt/anythingllm/docker-compose.yml
version: '3.8'

services:
  anythingllm:
    image: mintplexlabs/anythingllm:latest
    container_name: anythingllm
    restart: unless-stopped
    ports:
      - "127.0.0.1:3001:3001"  # Exposer uniquement en local, Nginx fera le proxy
    volumes:
      - /opt/anythingllm/storage:/app/server/storage
    env_file:
      - .env
    networks:
      - llm-network
    extra_hosts:
      - "host.docker.internal:host-gateway"  # Pour accéder à Ollama sur l'hôte
    deploy:
      resources:
        limits:
          memory: 4G
          cpus: '2'

networks:
  llm-network:
    driver: bridge

Étape 3 — Lancer et vérifier

# Démarrer AnythingLLM
cd /opt/anythingllm
docker compose up -d

# Suivre les logs au démarrage
docker logs anythingllm -f
# Attendre : "Server running on http://0.0.0.0:3001"

# Tester que l'API répond
curl -s http://localhost:3001/api/ping
# Réponse attendue : {"online":true}

# Accéder à l'interface
echo "Interface : http://$(hostname -I | awk '{print $1}'):3001"

Étape 4 — Configuration initiale via l'interface

Au premier accès, un assistant de configuration guide en 5 étapes :

1. Compte admin : créer l'email administrateur et un mot de passe fort (minimum 12 caractères)
2. Provider LLM : sélectionner Ollama, saisir l'URL http://host.docker.internal:11434, choisir le modèle
3. Modèle d'embedding : sélectionner le modèle pour le RAG (recommandé : nomic-embed-text via Ollama)
4. Base vectorielle : LanceDB par défaut (embarquée, sans configuration), ChromaDB ou Qdrant pour les volumes importants
5. Mode multi-utilisateurs : activer pour permettre à plusieurs collaborateurs de se connecter

Connexion aux modèles LLM

Connexion à Ollama local

Dans Paramètres (icône engrenage) → Préférences IA → LLM, sélectionnez Ollama et configurez :

# URL Ollama selon la configuration réseau

# Cas 1 : Ollama sur la même machine que Docker
http://host.docker.internal:11434

# Cas 2 : Ollama sur un serveur séparé (IP réseau local)
http://192.168.1.100:11434

# Cas 3 : Ollama dans un autre conteneur Docker sur le même réseau
http://ollama:11434

Après validation de l'URL, AnythingLLM interroge Ollama et affiche la liste des modèles disponibles dans un menu déroulant. Sélectionnez le modèle de chat (ex : mistral) et le modèle d'embedding (ex : nomic-embed-text).

Connexion à LiteLLM (proxy API unifié)

Si votre organisation utilise LiteLLM comme proxy central — ce qui est recommandé pour les DSI — configurez AnythingLLM en mode API OpenAI-compatible :

# Dans AnythingLLM : LLM Provider → "Generic OpenAI"
# Base URL : http://SERVEUR_LITELLM:4000
# API Key  : sk-cle-anythingllm-equipe
# Model    : mistral-souverain  (nom défini dans config LiteLLM)

Modèles recommandés selon les besoins en français

Modèle Ollama	VRAM	Qualité français	Vitesse	Cas d'usage idéal
mistral:7b-instruct-q4_K_M	4 Go	Très bonne	Rapide	Chat, résumé, Q&A, extraction
llama3.1:8b	5 Go	Bonne	Rapide	Code, analyse, raisonnement
mistral:7b-instruct-q8_0	8 Go	Excellente	Moyenne	Rédaction juridique, contractuelle
mixtral:8x7b-instruct-q4_K_M	26 Go	Excellente	Lente	Tâches complexes, multi-documents
qwen2.5:14b	9 Go	Très bonne	Moyenne	Multilingue, technique, sciences
phi4:14b	9 Go	Bonne	Moyenne	Raisonnement, synthèse structurée

Import de documents et RAG : le cœur d'AnythingLLM

Le RAG (Retrieval-Augmented Generation) est la fonctionnalité qui distingue AnythingLLM d'un simple client de chat. Il permet au modèle de répondre en s'appuyant sur vos documents internes, pas uniquement sur ses connaissances d'entraînement figées à la date de coupure.

Le pipeline RAG d'AnythingLLM : fonctionnement détaillé

1. Ingestion : le document uploadé est parsé (texte extrait du PDF, des cellules Excel, du HTML…)
2. Chunking : le texte est découpé en blocs (chunks) de taille paramétrable, avec chevauchement (overlap) configurable
3. Embedding : chaque chunk est transformé en vecteur numérique par le modèle d'embedding sélectionné (nomic-embed-text, all-minilm, mxbai-embed-large…)
4. Indexation : les vecteurs sont stockés dans LanceDB (ou ChromaDB) associés à leur workspace
5. Requête : la question de l'utilisateur est vectorisée, et les chunks les plus proches sémantiquement sont récupérés par similarité cosinus
6. Génération : les chunks pertinents sont injectés dans le contexte du LLM qui génère la réponse avec citations des sources

Formats de documents supportés

Format	Support	Notes importantes
PDF (texte natif)	Natif	Extraction texte directe, haute qualité
PDF (scanné, image)	Via OCR optionnel	Configurer Tesseract ou Azure OCR dans les paramètres
Word (.docx, .doc)	Natif	Préserve la structure, titres reconnus
Excel (.xlsx, .xls)	Natif	Feuille par feuille, données tabulaires incluses
PowerPoint (.pptx)	Natif	Texte des diapositives extrait
TXT / Markdown (.md)	Natif	Import direct, structure Markdown respectée
CSV	Natif	Idéal pour données structurées et tableaux
URL web	Natif	Scraping automatique du contenu textuel
YouTube	Natif	Transcription automatique via l'API YouTube
GitHub (dépôt)	Via connecteur	Import de l'arborescence de fichiers texte
Confluence	Via connecteur	Import d'espaces Confluence via API

Paramètres d'optimisation du RAG

Plusieurs paramètres influencent directement la qualité des réponses sur vos documents :

• Taille des chunks : 512 tokens par défaut. Augmentez à 1024 pour des documents longs avec contexte étendu (rapports, contrats), réduisez à 256 pour des FAQ ou des documents courts avec informations denses.
• Overlap : un chevauchement de 10 à 15% entre chunks évite de couper des phrases importantes à la frontière. Augmentez à 20% si vos documents ont de nombreuses listes ou tableaux.
• Top-K : nombre de chunks injectés dans le contexte du LLM (4 par défaut). Augmentez à 6-8 pour des sujets transversaux sur plusieurs documents, réduisez à 2-3 pour des Q&A simples sur documents courts.
• Score minimum de similarité : filtrez les chunks peu pertinents. Un seuil de 0.65 à 0.75 évite d'injecter des passages hors sujet qui dégradent la réponse.
• Mode de réponse : choisissez entre Chat (conversationnel, mémoire des échanges précédents) et Query (chaque question indépendante, meilleur pour des interrogations pures sur documents).

# Ces paramètres sont accessibles dans :
# Workspace (icône crayon) → Paramètres du workspace → Préférences vectorielles
# Chaque workspace peut avoir ses propres paramètres RAG

Gestion multi-utilisateurs et workspaces

AnythingLLM propose un système de rôles à trois niveaux et une organisation par workspaces (espaces de travail isolés). C'est le mécanisme central de gouvernance pour les équipes.

Rôles et permissions

Rôle	Peut faire	Ne peut pas faire
Admin	Tout : créer/supprimer des workspaces, gérer tous les utilisateurs, configurer le LLM, voir tous les logs	—
Manager	Gérer les membres d'un workspace, importer des documents, modifier les paramètres RAG du workspace	Changer la config LLM globale, créer de nouveaux workspaces, voir les workspaces d'autres équipes
Utilisateur	Chatter dans les workspaces auxquels il est invité, voir l'historique de ses propres conversations	Importer des documents, voir les configurations, accéder aux workspaces non autorisés

Organisation par workspaces — exemple d'une PME juridique

• Workspace Contrats : CGV, contrats types, modèles — accès équipe juridique uniquement
• Workspace RH : règlement intérieur, fiches de poste, convention collective, accords d'entreprise — accès DRH + direction
• Workspace Commercial : fiches produit, argumentaires, catalogue, FAQ client — accès équipe commerciale
• Workspace Technique : documentation IT, runbooks, procédures support — accès équipe IT
• Workspace Direction : rapports stratégiques, analyses concurrentielles — accès direction uniquement

L'isolation est forte et garantie par le design : un utilisateur du workspace Commercial ne peut pas voir les documents ni l'historique du workspace Juridique, même s'il est connecté à la même instance AnythingLLM.

Création d'utilisateurs par API

# Créer un utilisateur via l'API admin
curl -X POST http://localhost:3001/api/admin/users/new \
  -H "Authorization: Bearer VOTRE_TOKEN_ADMIN" \
  -H "Content-Type: application/json" \
  -d '{
    "username": "marie.dupont@entreprise.fr",
    "password": "MotDePasseTemporaire123!",
    "role": "default"
  }'

# Réponse : {"user": {"id": 5, "username": "...", "role": "default"}, ...}

# Inviter l'utilisateur dans un workspace
curl -X POST http://localhost:3001/api/admin/workspaces/WORKSPACE_ID/update-users \
  -H "Authorization: Bearer VOTRE_TOKEN_ADMIN" \
  -H "Content-Type: application/json" \
  -d '{"userIds": [5], "allowedUserIds": [5]}'

Sécurité et contrôle des accès

Mise en place du reverse proxy HTTPS avec Nginx

# Installer Nginx et Certbot
sudo apt install -y nginx certbot python3-certbot-nginx

# Créer la configuration Nginx
sudo tee /etc/nginx/sites-available/anythingllm << 'EOF'
server {
    listen 80;
    server_name llm.votre-domaine.local;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name llm.votre-domaine.local;

    ssl_certificate /etc/ssl/certs/votre-cert.pem;
    ssl_certificate_key /etc/ssl/private/votre-key.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-RSA-AES256-GCM-SHA512:DHE-RSA-AES256-GCM-SHA512;

    # En-têtes de sécurité
    add_header X-Frame-Options DENY;
    add_header X-Content-Type-Options nosniff;
    add_header X-XSS-Protection "1; mode=block";
    add_header Referrer-Policy no-referrer;

    location / {
        proxy_pass http://127.0.0.1:3001;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_cache_bypass $http_upgrade;
        proxy_read_timeout 300s;   # Important pour les réponses LLM longues
        proxy_send_timeout 300s;
        client_max_body_size 100M; # Pour l'upload de gros fichiers PDF
    }
}
EOF

sudo ln -s /etc/nginx/sites-available/anythingllm /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx

Script de sauvegarde automatique

#!/bin/bash
# /opt/scripts/backup-anythingllm.sh

BACKUP_DIR="/backup/anythingllm"
DATE=$(date +%Y%m%d_%H%M)
DATA_DIR="/opt/anythingllm/storage"
RETENTION_DAYS=30

# Créer le répertoire de backup
mkdir -p "$BACKUP_DIR"

# Arrêter le conteneur proprement (flush des écritures)
docker stop anythingllm

# Sauvegarder le volume de données
tar -czf "$BACKUP_DIR/anythingllm-$DATE.tar.gz" \
    -C "$(dirname $DATA_DIR)" \
    "$(basename $DATA_DIR)"

# Redémarrer
docker start anythingllm

# Nettoyer les anciens backups
find "$BACKUP_DIR" -name "*.tar.gz" -mtime +$RETENTION_DAYS -delete

# Log
echo "$(date) - Backup OK : anythingllm-$DATE.tar.gz ($(du -sh $BACKUP_DIR/anythingllm-$DATE.tar.gz | cut -f1))" \
    >> /var/log/backup-anythingllm.log

# Planifier le backup quotidien à 2h du matin
chmod +x /opt/scripts/backup-anythingllm.sh
(crontab -l 2>/dev/null; echo "0 2 * * * /opt/scripts/backup-anythingllm.sh") | crontab -

Mesures de durcissement complémentaires

• Restreindre l'accès au port 3001 uniquement depuis 127.0.0.1 (déjà fait dans le docker-compose) — Nginx est le seul point d'entrée public
• Isoler le serveur AnythingLLM dans un VLAN dédié, accessible uniquement via VPN pour les accès distants
• Activer les en-têtes HSTS dans Nginx pour forcer HTTPS sur les sous-domaines futurs
• Journaliser les connexions Nginx vers votre SIEM interne pour détection d'anomalies
• Renouveler régulièrement le JWT_SECRET (invalide toutes les sessions actives)
• Maintenir AnythingLLM à jour : docker pull mintplexlabs/anythingllm:latest && docker compose up -d après test en staging

Cas d'usage concrets validés en entreprise

Base de connaissance RH — gain de temps mesurable

Importez la convention collective applicable, le règlement intérieur, les fiches de poste, les procédures RH et les accords d'entreprise dans un workspace dédié à l'équipe RH. Les collaborateurs posent leurs questions en langage naturel depuis n'importe quel navigateur : « Quel est le délai de préavis pour un cadre en CDI ? », « La prime vacances est-elle due aux CDD ? », « Quelle est la procédure de signalement en cas de harcèlement ? ». Le modèle cite précisément les articles sources. Gain typique observé : 40 à 60% du temps de traitement des questions RH répétitives.

Assistance contractuelle et juridique

Importez les modèles de contrats, les CGV en vigueur, les décisions de jurisprudence pertinentes, les guides de la CNIL et les référentiels RGPD. L'équipe juridique interroge sa base documentaire sans fouiller des PDF manuellement, et obtient des réponses contextualisées avec références précises aux clauses. Utile pour les revues contractuelles rapides et la vérification de conformité.

Support technique interne — réduction des tickets

Importez les runbooks, la documentation technique, les procédures de résolution des incidents, les tickets JIRA ou ServiceNow résolus (export CSV). Les techniciens de niveau 1 posent leurs questions et obtiennent directement les procédures de résolution connues. Réduction mesurée des escalades de niveau 1 vers niveau 2 de 25 à 35% sur des infrastructures bien documentées.

Veille et analyse de marché

Importez des rapports sectoriels, des articles de presse (via URL directe), des notes d'analystes, des fiches produit concurrentes, des appels d'offres. Posez des questions comparatives transversales : « Quelles sont les différences de positionnement tarifaire entre nos trois concurrents principaux ? », « Quels sont les critères d'attribution récurrents dans les AO de ce secteur ? ».

Limites et alternatives à connaître

Limites identifiées d'AnythingLLM

• Scalabilité : au-delà de 100 utilisateurs simultanément actifs, les performances de l'interface peuvent se dégrader. Pas de clustering ni de déploiement multi-nœuds natif.
• RAG avancé : les techniques modernes de RAG hybride (BM25 lexical + vectoriel sémantique), HyDE (Hypothetical Document Embeddings), ou RAG multi-hop ne sont pas disponibles nativement. Pour des cas de recherche complexes, LlamaIndex ou Haystack offrent plus de contrôle.
• Connecteurs temps réel limités : pas de synchronisation automatique avec SharePoint, Confluence, Notion ou Google Drive. L'import est manuel ou via export périodique.
• Pas de SSO natif : l'authentification est interne (login/password). Pour LDAP/Active Directory ou SAML/OAuth2, il faut passer par un proxy d'authentification comme Authelia ou Authentik en frontal.
• Gestion de versions des documents : pas de versionning natif — si un document est mis à jour, il faut le réimporter et réindexer manuellement.

Quand choisir une alternative ?

Besoin spécifique	Alternative recommandée
RAG haute précision, tuning fin du pipeline	LlamaIndex Cloud ou Haystack + Qdrant
Plus de 200 utilisateurs simultanés	Open WebUI + LiteLLM + vLLM
Synchronisation SharePoint/Confluence automatique	Danswer, Quivr, ou Guru on-premise
Chat uniquement, pas de RAG	Open WebUI directement sur Ollama
Gouvernance API multi-équipes avancée	LiteLLM comme couche centrale + Open WebUI
Agents IA complexes et orchestrés	n8n + LangGraph + Ollama