Fonctionnalités

Un workspace (tenant) regroupe des membres et des RagSpaces ; chaque RagSpace porte ses documents, chunks et sa configuration LLM/embeddings.

Suppression logique d’un espace (deleted_at) ; purge définitive sur DELETE.

Le rag_space est dupliqué sur chaque Chunk et filtré par double clause SQL ; accès re-vérifié avant tout appel Core ; anti-énumération (404).

Le cloisonnement par propriétaire à l’intérieur d’un workspace est optionnel (voir « portées de propriétaire »).

Comptes créés par invitation (lien à usage unique, hash SHA-256) ou par bootstrap admin ; réinitialisation de mot de passe anti-énumération ; aucune inscription publique.

L’envoi de courriels exige une configuration SMTP ; par défaut, les messages sont écrits dans la console.

Second facteur TOTP (django-otp) obligatoire pour tout compte, non désactivable ; verrouillage django-axes, anti-rejeu, jetons de secours, admin Django protégé par OTP.

TOTP et jetons de secours statiques uniquement ; ni WebAuthn ni SMS.

Rôles owner/admin/member/viewer ; viewer en lecture seule ; owner/admin gèrent membres, RagSpaces, réglages LLM et audit ; superuser orthogonal (corpus métier, config).

Le dernier propriétaire ne peut pas être retiré ; un administrateur ne peut pas retirer un propriétaire.

Gouvernance cross-workspace (/api/v1/platform/*, écran /platform-admin) : utilisateurs, workspaces, owners, diagnostics ; aucun accès au contenu ; admin Django sous OTP.

Le superutilisateur n’a aucun accès implicite aux contenus.

Écrans /workspace-admin (membres, RagSpaces, invitations), /admin-core (config Core, capacités documentaires), /ragatm-admin (corpus métier).

Les sondes de la passerelle depuis la console sont désactivées par défaut.

Couche documentaire partagée entre workspaces (tables domain_corpus_*), administrée par le superuser, ingestion synchrone, retrieval bi-source avec étanchéité conservée.

Le corpus partagé ne participe pas par défaut aux réponses (admission calibrée).

Dépôt via /api/v1/documents/upload/ avec détection par contenu ; formats actifs par défaut : PDF, DOCX, PPTX, XLSX, CSV, TXT, MD, HTML, images JPEG/PNG/TIFF/WEBP ; limite 50 Mo ; dédup sha256.

Les images sont acceptées à l’import mais échouent à l’extraction dans Compact (pas d’OCR). Limite d’envoi : 50 Mo dans Compact (25 Mo par défaut ailleurs dans la documentation).

Ingestion via worker Celery/Redis ; Compact force RAG_INGEST_ASYNC_DEFAULT=1 ; OCR/Excel/PPTX/DXF/IFC forcent l’async ; broker indisponible → 503 dependency_unavailable.

Un seul worker, concurrence 2 dans Compact.

Déduplication par (rag_space, sha256) hors FAILED ; un doublon ne crée ni fichier ni tâche ; le même fichier peut être importé dans un autre espace.

Aucune limite particulière relevée.

Suppression dure et immédiate d’un document (409 si ingestion en cours) ; DELETE d’un RagSpace = purge irréversible (documents, chunks, vecteurs, fils) en conservant ActionAuditEvent.

Pas de corbeille.

Jobs de réindexation par RagSpace sur la file reindex, reprise des documents en erreur, stratégies auto / force_ocr / extended_timeout ; aucune réindexation implicite lors d’un changement de modèle.

Changer de modèle d’embeddings impose une réindexation explicite.

Document : filename, content_type (sniffé), size, sha256, document_date, status, meta JSON, embedding_provider/model, reindex_required… ; Chunk : chunk_index, page_number, pipeline_id/family, meta (locators par format).

Le champ « confidentialité » du document est inerte (lu par aucun code).

pypdf (+pdfminer/pdfplumber fallbacks), DOCX via stdlib, python-pptx, openpyxl, csv/html stdlib ; PDF scanné sans OCR → échec explicite pdf_scanned_requires_ocr.

DOCX : en-têtes, pieds de page, notes, commentaires et zones de texte non extraits ; moteur PyMuPDF absent (AGPL).

Découpage déterministe par page : 2500 car./recouvrement 250 ; espaces gouvernés (Gateway) : budget min(2500, plafond modèle) → 1200/180 avec Granite ; stratégies dédiées Excel (40 lignes) et PPTX (1 slide = 1 unité).

La limite de 1 200 caractères du modèle d’embeddings borne la taille des fragments.

Provider unique ai_gateway ; modèle logique fr-en-retrieval (granite-embedding:278m, 768 dims) ; identité (pipeline_id, digest, identity_verified) vérifiée ; checks E101/E102 ; refus d’indexer/interroger avec un pipeline différent.

Profil granite qualifié « expérimental » ; l’ancien profil 768 (nomic) n’est pas installé dans Compact.

Leg vectoriel pgvector (cosine) filtré par rag_space et pipeline_family, soumis au seuil RAG_MIN_SCORE.

Seuil de similarité hérité d’un autre modèle : il peut vider la branche vectorielle avec granite (voir seuil de retrieval).

FTS to_tsvector/ts_rank, config simple par défaut, plan de requêtes de la plus sélective à la plus large ; vecteur lexical stocké activable par flag (off).

Le chemin « vecteur stocké » exige une migration et RAG_FTS_CONFIG=french.

merge_hybrid fusionne FTS et vectoriel par Reciprocal Rank Fusion (K=60) avec renfort lexical conditionnel sur identifiants forts ; RAG_HYBRID_ENABLED=1 par défaut.

Aucune limite particulière relevée.

Pool candidate_k ×3, max 2 par groupe (document), avant décision ; activé par défaut.

Aucune limite particulière relevée.

Reranking des passages via POST /v1/rerank (TEI bge-reranker-v2-m3 derrière la Gateway) ; OFF dans le code, ON en Compact (pool 20, timeout 20 s) ; en échec, repli compté sur l’ordre RRF canonique (fail_open_rrf).

Repli = ordre RRF hybride (pas un reranking lexical) ; latence CPU ≈ 1,5 s par paire ; deux réglages de reranking mutuellement exclusifs.

should_answer : min_sources, seuil lexical, seuil vectoriel RAG_MIN_SCORE (défaut code 0.76, calibré nomic) ; refus dur seulement si aucun chunk, sinon mode partial/low_confidence.

Divergence documentaire sur la valeur par défaut (0,20 vs 0,76) ; 0,76 non calibré pour granite.

Toute génération passe par POST /v1/generate de la Gateway (modèle logique compact-generation-8 = qwen2.5:1.5b-instruct en Compact) ; modèle par RagSpace ; chemin Ollama direct réservé aux tests.

Le modèle de 1,5 B démontre le chemin, pas la qualité des réponses ; modèles non enregistrés ou non installés refusés.

Le chat /chat/stream/ émet du SSE (meta → sources → token(s) → done, + error) ; avec AI_GATEWAY_STREAMING_ENABLED=1 (Compact) les fragments viennent de /v1/generate/stream (NDJSON) ; à 0, pseudo-stream en un bloc.

Certaines pages de documentation disent encore « pas de vrai streaming » : dérive documentaire, la configuration Compact active le flux natif.

Sources v1 (rank, document_id, chunk_id, score, filename, page_number, snippet ≤200) ; contrat de réponse distinguant sources retrouvées / transmises / réellement citées ; ligne « Sources: » seulement pour les citations réelles.

La justesse des citations dépend du respect des marqueurs [n] par le modèle.

Garde-fous de citation en tête de prompt ; no_answer sans LLM si aucune source ; Mode B « hors documents » désactivé ; détection d’abstention FR/EN ; aucune réponse fabriquée en cas de panne (erreurs typées).

Mesure d’« answerability » par cross-encoder présente mais non promue ; relance anti-abstention évaluée, non implémentée.

ChatThread/ChatMessage persistés, privés à leur auteur ; mémoire hiérarchique (fenêtre 12 messages, résumé au-delà de 18) injectée dans le prompt seulement ; recherche de fils bornée (3 s).

Le résumé de mémoire utilise le modèle global, pas celui de l’espace (limite connue).

Résumé court synchrone / long en Celery map-reduce, persisté comme ChatMessage ; résumé de documents de corpus métier activé par défaut (non qualifié).

Résumés de corpus non qualifiés.

CorpusAnalysisJob asynchrone (file analytics) avec cycle de vie, progression, annulation ; accès RagSpace re-vérifié à chaque opération.

Aucune limite particulière relevée.

Aide produit statique, garde analytique Excel (refus déterministe), listing documentaire : court-circuitent le RAG sans LLM.

Aucune limite particulière relevée.

Prévisualisation routée par preview_kind : pdf (iframe #page=N), spreadsheet, document (DOCX), presentation (PPTX), text, unsupported ; toujours actif.

CSV volontairement non pris en charge par le visualiseur.

Pouce vers le bas → incident diagnosticable (lot 1 actif) ; export/import d’incidents et pseudonymisation par flags (off).

Aucune limite particulière relevée.

RagQueryLog (90 j), ActionAuditEvent (365 j), LlmEgressAuditEvent / EgressPolicyChangeLog (365 j, plancher protégé par system check), LlmSettingsChangeLog ; purge périodique.

Le journal des requêtes RAG stocke question et réponse en clair (données conversationnelles).

manage.py check (checks llm_router.*, config.*, rag_core.*), diagnose.sh (non inférentiel), retrieval-diagnostic.sh, contract_check.py, resilience_check.py, offline-check.sh, e2e_qualification.py.

Les sondes inférentielles de la passerelle ne sont jamais appelées automatiquement.

backup.sh (pg_dump custom, archive media, configs, manifeste modèles, SHA256SUMS) et restore.sh dans une instance isolée ; secrets, Redis et poids de modèles exclus.

Les documents en cours d’ingestion au moment de la sauvegarde doivent être réindexés après restauration ; secrets à sauvegarder séparément.

next-intl sans préfixe de route ; locales fr (défaut) et en ; cookie ragatm_locale + préférence de compte ; 21 namespaces symétriques testés.

Généralisation aux écrans applicatifs en cours selon la documentation.

~128 routes DRF sous /api/v1/ (auth, bootstrap, capabilities, workspaces, invitations, rag-spaces, documents, chat, analyses, prompts, audit, core, admin, platform, tabular) ; contrat shared/contracts/openapi.yaml 1.0.0 ; auth cookie token + CSRF ou Authorization: Token.

Contrat OpenAPI maintenu à la main, non vérifié automatiquement contre le code.

DRF UserRateThrottle/AnonRateThrottle en production : user 120/min, anon 30/min, auth 20/min, mfa 10/min, feedback 10/min, recherche de fils 60/min, invitations 20/10 par min.

Compartiment anonyme partagé par tous les clients derrière le proxy Next (limite connue).

prod.py : HSTS 1 an + subdomains + preload, nosniff, X-Frame-Options SAMEORIGIN, Referrer-Policy same-origin, cookies Secure/HttpOnly/SameSite=Strict ; TLS attendu au reverse-proxy.

Pas de TLS dans la pile Compact ; aucune Content-Security-Policy dans les réglages examinés.

Middleware : relaie un X-Request-ID conforme ([A-Za-z0-9._:-]{1,128}) sinon génère un UUID4 ; propagé à la Gateway (génération, embeddings, rerank) et aux flux SSE ; présent dans toutes les réponses.

Aucune limite particulière relevée.

503 ai_gateway_unavailable (+Retry-After, retryable) ; 502 ai_gateway_error (non retryable) ; 503 dependency_unavailable (redis|broker) ; même charge utile dans l’événement SSE error ; jamais de réponse fabriquée.

Aucune limite particulière relevée.

max_document_count et max_document_bytes copiés depuis les défauts plateforme ; usage agrégé à la demande ; enforcement activé par défaut.

Pas de mode illimité.

Écran superuser en lecture seule exposant l’état réel de chaque capacité (ACTIVE/DISABLED/UNAVAILABLE/UNKNOWN) ; sondes /health/* de la Gateway fermées par défaut.

États des services affichés « UNKNOWN » tant que les sondes sont désactivées.

Trace structurée de chaque query_rag (dégradations observables), compteurs ops bornés (rag_reranker_*), route /ops/metrics hors /api/ avec jeton optionnel, /api/health/ non inférentiel.

Aucune limite particulière relevée.

Tout appel LLM exige un LlmExecutionContext avec politique résolue ; tout provider non local refusé ; allow_external_fallback tracé mais sans provider externe existant.

Granularité limitée à l’espace documentaire ; champ de confidentialité inerte.

Cloisonnement de plusieurs owners dans un même workspace et ACL par RagSpace ; implémenté de bout en bout mais désactivé par défaut.

Non activé dans Compact ; le transfert de portée depuis la console plateforme est en prévisualisation.

Préférence answer_language (auto/fr/en) pilotant la langue des réponses, distincte de la langue d’interface ; flag off dans le code.

Désactivé par défaut dans le code Open ; Compact ne le règle pas.

Détection d’actions par le chat (apps.actions) ; mutations jamais déclenchables par phrase ; désactivé par défaut.

Aucune limite particulière relevée.

Moteur DuckDB calculant sur le fichier source xlsx/csv (jamais le LLM, jamais les chunks) ; schéma fermé, bornes de lignes/colonnes/temps ; désactivé par défaut et en Compact.

Planificateur et narration par LLM non branchés.

Overrides de configuration stockés en base, inertes par défaut ; édition et prise en compte runtime sous flags stricts (off).

Aucune limite particulière relevée.

Ingestion .eml avec pièces jointes, activable par flag et bornée par espace (off) ; .msg Outlook non pris en charge dans l’édition Open (parseur GPL écarté, code msg_unsupported_in_open_edition).

Pièces jointes : pas de vision ni d’extraction structurée ; IFC/DWG non pris en charge.

Réécriture/keywordisation de requête en mode explicatif ; réécriture LLM désactivée par mesure A/B (gain nul, P95 doublé).

Aucune limite particulière relevée.

Rerank historique chargeant un modèle dans le processus (extra rerank/torch) ; off ; jamais verrouillé pour l’image Compact.

Exclusif avec le reranking via la passerelle.

Aucun connecteur de messagerie dans l’édition Open (mention explicite dans le code).

Aucune limite particulière relevée.

Les trois URL Gateway (génération, embeddings, rerank) pointent sur http://ai-gateway:8100 ; AI_GATEWAY_POOL_HOSTS vide ⇒ route direct ; profil nominal Compact.

Aucune limite particulière relevée.

Compact : db (pgvector), redis, backend (gunicorn 2×4), worker (Celery), beat, frontend (Next), ai-gateway, ollama, reranker (TEI) sur 5 réseaux dont 4 internes ; budgets mémoire par service.

Un seul hôte ; aucun déploiement multi-machines vérifié.

Files publiques celery, reindex, maintenance, analytics consommées par un worker (concurrence 2, max-tasks-per-child 50) ; files dédiées ingest_visual/audio/ifc/dwg définies mais sans consommateur dans Compact.

Ingestion séquentielle à l’échelle d’un poste.

Gateway 2 générations concurrentes (503 au-delà), Ollama NUM_PARALLEL=1 / 2 modèles chargés, worker concurrence 2, gunicorn 2 workers × 4 threads, timeout 600 s ; aucune file côté Gateway.

Charge au-delà d’une génération concurrente non vérifiée.

Les originaux sont écrits sur un volume local (media) : stockage lié à un hôte unique.

Pas de stockage objet ni partagé.

Routeur HTTP autonome relayant les 19 routes gateway-api/1.0 vers 1..N Gateways (SINGLE_NODE, WEIGHTED_ROUND_ROBIN, LEAST_INFLIGHT), registre de nœuds avec allowlist, gouvernance de modèle (pas de substitution, identité par digest) ; absent de Compact ; bascule tout-ou-rien (llm_router.E008).

ASR/vision non qualifiés via le Pool ; RAG complet via le Pool non démontré dans les dépôts.

max_inflight par nœud → AT_CAPACITY (refus, pas de file) ; disjoncteur CLOSED/OPEN/HALF_OPEN sur pannes de transport ; suspension douce sur 503+Retry-After ; basculement seulement avant tout octet envoyé (connect errors) ; compteurs par processus.

État local au processus, sans coordination distribuée ; ni file d’attente, ni priorités, ni limitation de débit.

Store d’affinité job→nœud (none/memory/sqlite/redis) pour les jobs ASR asynchrones ; Redis = seul usage de Redis par le Pool ; backend none en Compact (routes audio refusées).

Aucune limite particulière relevée.

README : charge au-delà d’une génération concurrente non vérifiée ; Pool : débit en forte concurrence non remesuré ; ingestion séquentielle.

Aucune limite particulière relevée.

Configuration multi-nœuds préparée (exemple EXAMPLE_ONLY) ; MULTINODE_HARDWARE_QUALIFIED = NO ; LIVE_MULTI_GPU NOT_EXECUTED.

Aucune limite particulière relevée.

Aucune fonction d’autoscaling ni de coordination multi-réplicas : Pool mono-processus, états par processus ; seule l’affinité ASR est partagée.

Aucune limite particulière relevée.