🛡️ 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 :

# 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

10 KiB Raw Blame History