> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/plateformes-et-agents-ia/anythingllm.md).

# Plateforme RAG AnythingLLM

## Aperçu

[AnythingLLM](https://github.com/Mintplex-Labs/anything-llm) 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**

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

**Étape 2 : Configurer le répertoire de stockage**

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

**Étape 3 : Exécuter AnythingLLM**

```bash
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**

```bash
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 :

1. Créer un compte administrateur
2. Choisir un fournisseur LLM
3. Choisir un modèle d'embedding
4. 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**

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

**Étape 2 : Créer `docker-compose.yml`**

```bash
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**

```bash
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**

```bash
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 :

```bash
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 :**

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

**Anthropic Claude :**

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

**Google Gemini :**

```bash
-e LLM_PROVIDER=gemini
-e GEMINI_API_KEY=votre-cle
-e GEMINI_LLM_MODEL_PREF=gemini-1.5-pro
```

**Ollama (local) :**

```bash
-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) :**

```bash
-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      |

```bash
# 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

| BD         | 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 :

```bash
# 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 :

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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 :

```bash
# 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

```bash
# 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

```bash
# 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](https://docs.anythingllm.com) — guide d'installation complet et référence API
* [AnythingLLM GitHub](https://github.com/Mintplex-Labs/anything-llm) — code source, issues, feuille de route
* [AnythingLLM Docker Hub](https://hub.docker.com/r/mintplexlabs/anythingllm) — tags d'images
* [Exécuter Ollama sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/ollama.md) — backend LLM local pour AnythingLLM
* [Exécuter vLLM sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/vllm.md) — inférence haute performance
* [Guide de comparaison GPU](/guides/guides_v2-fr/prise-en-main/gpu-comparison.md) — choisir le bon niveau Clore.ai
* [Documentation MCP](https://modelcontextprotocol.io) — Model Context Protocol pour étendre les agents
* [Référence API AnythingLLM](https://docs.anythingllm.com/api-reference) — API REST pour l'automatisation


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/plateformes-et-agents-ia/anythingllm.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.