wiki/Catalogue-Self-Hosted/apps/app-secureai-tools.md

---
title: SecureAI Tools
created: 2026-06-07
updated: 2026-06-07
type: app
tags: [catalogue, artificial-intelligence, secureai-tools, privacy, chat, rag, ollama, openai, typescript, agpl-3]
confidence: high
contested: false
sources:
  - https://selfh.st/apps/?tag=Artificial%20Intelligence
  - https://github.com/SecureAI-Tools/SecureAI-Tools
---

# 🛡️ SecureAI Tools

> Suite d'outils IA **privacy-first** (chat + RAG documentaire) écrite en TypeScript, auto-hébergeable, compatible **Ollama local** et **API OpenAI distantes** — conçue pour offrir une expérience « ChatGPT maison » sans fuite de données vers le cloud.

## 📋 Informations Générales

| Métadonnée | Valeur |
| :--- | :--- |
| **Site web** | https://github.com/SecureAI-Tools/SecureAI-Tools |
| **GitHub** | https://github.com/SecureAI-Tools/SecureAI-Tools |
| **License** | AGPL-3.0 |
| **Langage** | TypeScript (97 %) / SQL / Shell |
| **Étoiles** | ⭐ 87 |
| **Dernière MAJ** | 2026-06-06 |
| **Catégorie** | [[cat-artificial-intelligence]] |

## 📝 Description

**SecureAI Tools** est une plateforme d'IA « clé en main » pensée pour les particuliers, familles et petites équipes qui veulent bénéficier d'un assistant conversationnel et d'un moteur de **RAG (Retrieval-Augmented Generation)** sans confier leurs conversations ni leurs documents à un service tiers. Le projet se distingue par sa prise en charge **native d'Ollama** (100+ modèles open source) tout en restant compatible avec les API OpenAI / Claude / Mistral.

Côté architecture, l'application est un **monorepo TypeScript** (Node.js 20+ / React / Postgres / RabbitMQ / Redis) avec plusieurs services distincts : `frontend` (UI React), `backend` (API Node), `inference` (worker Ollama), `background-jobs` et `rabbitmq` (broker de messages). L'authentification par email/mot de passe est intégrée nativement, un **gestionnaire d'utilisateurs** permet de partager l'instance en famille ou entre collègues, et un système de **collections de documents réutilisables** évite de réindexer les mêmes PDF à chaque conversation.

Fonctionnalités phares : **chat multi-modèles** (Mistral, Llama, Qwen via Ollama ou GPT-4o, Claude, Gemini via API), **chat avec documents** (PDF pour l'instant, Docx/Markdown en roadmap), **collections persistantes** indexées en local, **intégration Paperless-ngx** et **Google Drive** pour importer automatiquement les documents à indexer, **traitement 100 % local** (chiffrement at rest, aucune télémétrie), et un script d'installation en moins de 5 minutes (`set-up.sh`). La roadmap évoque le partage de conversations, une UI mobile et une bibliothèque de *prompt templates*.

Cas d'usage type : « je veux un ChatGPT familial, j'ai un Mac M2 et un vieux PC Linux, je veux que mes documents confidentiels (fiches de paie, scans) restent chez moi, et que ma femme puisse aussi l'utiliser avec son propre compte ».

## 🚀 Installation

### Option 1 : Docker Compose (recommandé)

Le dépôt fournit un script d'initialisation qui télécharge un `docker-compose.yml` prêt à l'emploi et génère un `.env` avec des valeurs par défaut sûres. Voici une version reconstituée et réaliste :

```yaml
# docker-compose.yml
version: "3.8"

services:
  frontend:
    image: ghcr.io/secureai-tools/secureai-tools-frontend:latest
    container_name: secureai-frontend
    restart: unless-stopped
    ports:
      - "28669:3000"
    environment:
      BACKEND_URL: http://backend:3000
    depends_on:
      - backend

  backend:
    image: ghcr.io/secureai-tools/secureai-tools-backend:latest
    container_name: secureai-backend
    restart: unless-stopped
    environment:
      DATABASE_URL: postgresql://CHANGE_ME_DB_USER:CHANGE_ME_DB_PASSWORD@postgres:5432/secureai
      REDIS_URL: redis://redis:6379
      RABBITMQ_URL: amqp://rabbitmq:5672
      INFERENCE_URL: http://inference:11434
      JWT_SECRET: changez-moi-en-production-64-chars-minimum
    volumes:
      - ./data/backend:/app/data
    depends_on:
      - postgres
      - redis
      - rabbitmq
      - inference

  inference:
    image: ollama/ollama:latest
    container_name: secureai-inference
    restart: unless-stopped
    # Décommenter pour GPU Nvidia :
    # deploy:
    #   resources:
    #     reservations:
    #       devices:
    #         - driver: nvidia
    #           count: 1
    #           capabilities: [gpu]
    volumes:
      - ./data/ollama:/root/.ollama

  postgres:
    image: postgres:16-alpine
    container_name: secureai-db
    restart: unless-stopped
    environment:
      POSTGRES_USER: CHANGE_ME_DB_USER
      POSTGRES_PASSWORD: CHANGE_ME_DB_PASSWORD
      POSTGRES_DB: secureai
    volumes:
      - ./data/db:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    container_name: secureai-redis
    restart: unless-stopped

  rabbitmq:
    image: rabbitmq:3-management-alpine
    container_name: secureai-rabbit
    restart: unless-stopped
```

Premier lancement : `docker compose up -d`, puis se connecter à `http://localhost:28669/log-in` avec les identifiants par défaut `bruce@wayne-enterprises.com` / `SecureAIToolsFTW!` — **changer immédiatement le mot de passe**, puis configurer le modèle IA dans `/-/settings?tab=ai`.

### Option 2 : Installation manuelle

Cloner le monorepo, installer **Node 20+**, **pnpm 9** et **Docker** (pour Postgres/Redis/RabbitMQ en local). Lancer `pnpm install` à la racine, puis dans chaque paquet (`frontend`, `backend`, `inference`, `background-jobs`) : `pnpm build && pnpm start`. En production, servir le bundle `frontend` derrière **Nginx** (ou Caddy) et le backend derrière **systemd** ou **PM2**. Prévoir 8-16 Go de RAM si vous faites tourner un LLM 7B en local, ou un GPU Nvidia (M1/M2/M3 Macs : inférence excellente en CPU+Metal).

## ⚙️ Configuration

SecureAI Tools se configure via **variables d'environnement** dans un fichier `.env` à la racine du compose. Paramètres clés :

- `MODEL_PROVIDER_CONFIGS` : **JSON array** décrivant chaque provider (`OPENAI`, `OLLAMA`, etc.), son `apiBaseUrl`, sa clé API et le `embeddingsModel` (ex. `text-embedding-3-large`).
- `JWT_SECRET` : **obligatoire**, ≥ 32 caractères aléatoires (`openssl rand -hex 32`).
- `PAPERLESS_URL` + `PAPERLESS_TOKEN` : active l'intégration Paperless-ngx.
- `GOOGLE_DRIVE_*` : active l'import depuis Google Drive (OAuth).
- `INFERENCE_URL` : URL du worker Ollama (par défaut `http://inference:11434`).
- `NUM_GPU_LAYERS` : nombre de couches déchargées sur le GPU (paramètre Ollama).

L'UI web propose un **wizard de premier lancement** : login admin, sélection du provider, choix du modèle, import de documents. Toute la configuration se modifie ensuite dans `Settings → AI` (provider, modèles, embeddings) et `Settings → Organization` (invitations utilisateurs, OAuth).

## 🔄 Alternatives

**Open Source / Self-Hosted :**

- [[app-open-webui]] — UI très populaire pour Ollama, plus simple mais moins orientée RAG documentaire.
- [[app-librechat]] — Interface multi-provider unifiée, plus modulaire mais sans RAG intégré.
- [[app-jan]] — Client IA 100 % local en Rust/Web, axé desktop.
- **AnythingLLM** — Concurrent direct sur le créneau RAG + multi-provider, plus mature côté entreprise.
- **PrivateGPT** — Référence historique du RAG local, plus minimaliste.
- **Paperless-AI** — Spécialisé dans l'auto-tagging Paperless-ngx (sous-domaine couvert par SecureAI Tools).
- **Ollama** seul — Le moteur d'inférence sous-jacent, sans UI conversationnelle.

**Propriétaire :**

- **ChatGPT Plus** — La référence, mais conversations et documents envoyés à OpenAI.
- **Claude.ai Pro** — Excellent sur les longs documents, mais cloud Anthropique obligatoire.
- **Microsoft Copilot** — Intégré à l'écosystème M365, données hébergées chez Microsoft.
- **Notion AI** — Pratique pour les docs Notion, verrouillé dans la suite.

## 🔒 Sécurité

- **Reverse proxy HTTPS obligatoire** (Traefik, Caddy) — le port 28669 n'est pas chiffré en natif.
- **JWT_SECRET robuste** : 64 caractères aléatoires, régénérer à chaque installation, **ne jamais** commiter le `.env`.
- **Identifiants par défaut** : `bruce@wayne-enterprises.com` / `SecureAIToolsFTW!` — **changer dès le premier login** (c'est documenté mais facile à oublier).
- **Postgres / Redis / RabbitMQ** : ne pas exposer leurs ports (5432/6379/5672) sur l'interface réseau hôte, **uniquement** via le réseau Docker interne.
- **Clés API** : stocker dans le `.env` ou un secret manager (Vault, Infisical) — éviter de les passer via `docker run -e`.
- **Documents uploadés** : restent sur le filesystem local du conteneur `backend` (volume `./data/documents`), **chiffrer le disque** si la machine est exposée.
- **GPU partagé** : si vous mutualisez le GPU avec d'autres workloads, surveiller la consommation via `nvidia-smi` pour éviter les OOM.
- **Mises à jour** : suivre les releases GitHub (le projet est jeune, v0.0.x au moment de la rédaction) — tester en staging avant prod.
- **Sauvegardes** : `pg_dump` régulier + le dossier `./data` (base, cache embeddings, documents indexés).

## 📚 Ressources

- Repository : https://github.com/SecureAI-Tools/SecureAI-Tools
- Documentation : https://github.com/SecureAI-Tools/SecureAI-Tools/wiki
- Discord : https://discord.gg/YTyPGHcYP9
- Démo vidéo : https://www.youtube.com/watch?v=Br2D3G9O47s
- Issue tracker : https://github.com/SecureAI-Tools/SecureAI-Tools/issues
- Ollama (modèles supportés) : https://ollama.ai/library
- Intégration Paperless-ngx : https://github.com/paperless-ngx/paperless-ngx/discussions/7284

## 🔗 Pages Liées

- [[cat-artificial-intelligence]] — Catégorie parente
- [[app-open-webui]] — Concurrent principal sur Ollama
- [[app-librechat]] — Alternative multi-provider plus modulaire
- [[app-jan]] — Client IA desktop 100 % local
- [[app-paperless-ngx]] — Intégration documentaire mise en avant
- [[recettes-docker-compose]] — Templates Docker Compose
- [[securisation-home-lab]] — Bonnes pratiques sécurité
- [[app-traefik]] — Reverse proxy HTTPS recommandé
- [[app-ollama]] — Moteur d'inférence local