Banc 3 modeles — PC de jeu d'Evan

import threading
import time
from collections import deque

class RateLimiter:
    def __init__(self, max_calls: int, period_seconds: float):
        if max_calls <= 0:
            raise ValueError("max_calls must be positive")
        if period_seconds <= 0:
            raise ValueError("period_seconds must be positive")
        self.max_calls = max_calls
        self.period = period_seconds
        self._lock = threading.Lock()
        self._calls = deque()  # Stores timestamps of allowed calls

    def allow(self, timestamp: float) -> bool:
        """Return True if the call is allowed at this timestamp, False otherwise.
        Uses sliding window log algorithm. Thread-safe."""
        with self._lock:
            now = timestamp
            # Remove timestamps that are outside the current window
            while self._calls and (now - self._calls[0] > self.period):
                self._calls.popleft()

            # If we have fewer than max_calls calls in the window, allow
            if len(self._calls) < self.max_calls:
                self._calls.append(now)
                return True

            # Otherwise, reject
            return False

import threading
import time
from collections import deque

class RateLimiter:
    def __init__(self, max_calls: int, period_seconds: float):
        """
        Initialise le limiteur de débit.
        
        Args:
            max_calls: Nombre maximum d'appels autorisés dans la fenêtre.
            period_seconds: Durée de la fenêtre de glissement en secondes.
        """
        self.max_calls = max_calls
        self.period_seconds = period_seconds
        self.timestamps = deque()
        self._lock = threading.Lock()

    def allow(self, timestamp: float) -> bool:
        """
        Vérifie si l'appel est autorisé à l'instant donné.
        
        Args:
            timestamp: Le temps actuel (ou fourni) pour lequel vérifier la limite.
            
        Returns:
            True si l'appel est autorisé, False sinon.
        """
        with self._lock:
            # 1. Nettoyer la fenêtre glissante : enlever les timestamps trop anciens
            # Les timestamps restants doivent être >= (timestamp - period_seconds)
            cutoff = timestamp - self.period_seconds
            while self.timestamps and self.timestamps[0] < cutoff:
                self.timestamps.popleft()

            # 2. Gérer les timestamps hors ordre (optionnel mais demandé)
            # Si on fournit un timestamp passé par rapport au temps réel,
            # on doit s'assurer qu'il est cohérent avec la logique de la fenêtre.
            # Cependant, pour un algorithme strict basé sur un timestamp fourni,
            # nous traitons ce timestamp comme la "réalité" pour cette vérification.
            # Si timestamp < self.timestamps[0], cela signifie que le temps "rebrousse",
            # mais la logique de nettoyage ci-dessus gère cela dynamiquement.
            
            # 3. Vérifier si la limite est atteinte
            current_count = len(self.timestamps)
            
            if current_count < self.max_calls:
                # Autoriser l'appel et ajouter le timestamp
                self.timestamps.append(timestamp)
                return True
            else:
                # Refuser l'appel
                return False

import threading


class RateLimiter:
    def __init__(self, max_calls: int, period_seconds: float):
        self.max_calls = max_calls
        self.period_seconds = period_seconds
        self.timestamps: list[float] = []
        self.lock = threading.Lock()

    def allow(self, timestamp: float) -> bool:
        with self.lock:
            # Remove timestamps outside the current window
            window_start = timestamp - self.period_seconds
            self.timestamps = [t for t in self.timestamps if t > window_start]

            if len(self.timestamps) < self.max_calls:
                self.timestamps.append(timestamp)
                return True
            else:
                return False

**Note technique : Authentification SSO unique vs authentification par service pour un homelab personnel exposé publiquement (400-600 mots)**

**Contexte**
Un homelab personnel est généralement constitué d’un ou plusieurs services mutualisés sur un seul serveur Linux, souvent exposé publiquement via un nom de domaine ou une adresse IP publique (par exemple, via un reverse proxy ou un DNS dynamique). Les services concernés peuvent inclure un dashboard de supervision (ex: Prometheus + Grafana), un serveur web personnel, un outil de gestion de notes, un dépôt Git, ou un accès SSH. L’objectif principal est de sécuriser l’accès sans sacrifier trop de simplicité, tout en respectant les bonnes pratiques de sécurité pour un environnement en exposé public (c’est-à-dire accessible depuis Internet sans pare-feu strict, mais avec un contrôle d’accès minimal). L’authentification via un système SSO unique (ex: Authelia, Keycloak, ou un simple reverse proxy avec gestion centralisée des credentials) est souvent proposée comme alternative à l’authentification par service (chaque service gère son propre login/mot de passe ou utilise son propre système d’authentification).

**Arguments en faveur d’une authentification SSO unique (ex: Authelia)**
1. **Centralisation et réduction de la surface d’attaque** : Avec un SSO unique, un seul point d’authentification est géré et sécurisé. Si un service est vulnérable (ex: une faille d’authentification dans un vieux script web), l’attaquant n’a pas besoin de récupérer les credentials de chaque service indépendamment. Authelia, par exemple, peut agir comme un reverse proxy central qui authentifie les utilisateurs avant de les rediriger vers les services internes, offrant ainsi une couche unique de contrôle.
2. **Gestion simplifiée des credentials** : L’utilisateur n’a qu’un seul mot de passe (ou un seul identifiant + secret, ex: via un gestionnaire de mots de passe ou un OTP) à retenir. Cela améliore l’expérience utilisateur et réduit le risque de réutilisation de mots de passe faibles ou mal gérés. Authelia supporte aussi l’authentification multifacteur (MFA viaTOTP, WebAuthn, etc.).
3. **Politiques d’accès cohérentes et évolutives** : On peut définir des règles centralisées (ex: "accès Grafana uniquement via MFA", "accès au dépôt Git uniquement pour les utilisateurs du groupe 'dev'"), ce qui évite les configurations redondantes ou incohérentes entre services. Cela est particulièrement utile si l’on ajoute progressivement de nouveaux services.
4. **Meilleure traçabilité et audit** : Toutes les tentatives d’authentification passent par le proxy central, ce qui facilite la journalisation (logs), la détection d’anomalies (ex: nombre anormal de tentatives) et la réponse aux incidents.

**Arguments contre l’authentification SSO unique**
1. **Complexité de mise en œuvre et de maintenance** : Pour un homelab personnel, configurer un système SSO central (ex: Authelia) nécessite de configurer correctement le reverse proxy, les règles d’accès, les intégrations avec les services (Grafana, Git, etc.), et surtout de gérer les secrets (ex: clés JWT, tokens). Si le serveur tombe en panne ou si la configuration est mal sauvegardée, l’accès à tous les services peut être bloqué. La maintenance (mise à jour de Authelia, gestion des certificats TLS) ajoute une charge supplémentaire, surtout si l’utilisateur n’est pas à l’aise avec les détails d’infrastructure.
2. **Point de défaillance unique** : Si le proxy d’authentification (Authelia) est compromis ou inaccessible (ex: crash, problème réseau), tous les services deviennent temporairement inaccessibles, même si leurs propres mécanismes d’authentification seraient fonctionnels. Pour un homelab personnel, la résilience et la simplicité d’accès sont souvent prioritaires.
3. **Surcharge pour des services très simples** : Certains services (ex: un petit site statique avec un formulaire de contact sans besoin d’accès authentifié) n’ont pas besoin d’une authentification complexe. Forcer l’authentification via un SSO pour un tel service ajoute une couche inutile de configuration et de login, sans apporter de valeur significative pour la sécurité (le risque est déjà minimal si le service est public mais non interactif).
4. **Risque de sur-sécurisation** : Imposer une authentification unique pour tous les services peut conduire à une configuration trop stricte pour des cas d’usage simples, entraînant des frustrations (ex: besoin de MFA pour lire une page statique).

**Recommandation tronquée avec conditions**
Pour un homelab personnel avec un seul serveur Linux exposé publiquement, **il est recommandé d’adopter une authentification SSO unique (via un reverse proxy central comme Authelia) uniquement pour les services sensibles ou interactifs**, et non pour tous les services de manière systématique.

- **Quand utiliser le SSO unique** :
- Tous les services nécessitant un accès authentifié par un utilisateur (ex: Grafana, interface de gestion de notes, dépôt Git avec push/pull, accès SSH via le proxy), surtout si l’on souhaite utiliser MFA.
- Tous les services publics mais nécessitant un contrôle d’accès (ex: un formulaire de contact avec validation d’email, ou un dashboard partagé avec des rôles limités).
- Lorsque l’on veut centraliser la politique d’accès et faciliter la gestion des credentials (ex: éviter de retenir plusieurs mots de passe).

- **Quand utiliser l’authentification par service (ou aucune authentification pour les services publics simples)** :
- Pour les services entièrement statiques ou publics sans interaction utilisateur (ex: site web simple sans login, documentation publique), on peut laisser l’accès libre via HTTPS (sans authentification), ou utiliser uniquement un mot de passe HTTP minimal si nécessaire. Aucun

**Note Technique : Stratégie d'authentification pour un Homelab Linux Unique**

**Contexte**
Dans l'écosystème des homelab personnels, où l'objectif est souvent de maîtriser l'infrastructure et d'apprendre plutôt que de garantir une conformité industrielle stricte, l'architecture de sécurité évolue rapidement. Pour un seul serveur Linux exposé publiquement, deux approches dominent : la décentralisation, consistant en une authentification native par service (SSH, interfaces web locales), et la centralisation via un fournisseur d'identité unique (SSO) placé en face des services, tel qu'Authelia. Cette note évalue ces modèles pour déterminer la configuration optimale.

**Arguments en faveur de l'authentification SSO unique (Authelia)**
L'adoption d'un SSO comme Authelia offre une centralisation critique de la gestion des identités. Dans une architecture unique, chaque nouveau service déployé (Jellyfin, Nextcloud, Home Assistant) nécessite normalement la configuration de ses propres comptes utilisateurs et mots de passe. Avec Authelia, la gestion des identités est abstraite : un utilisateur créé dans Authelia est automatiquement disponible sur tous les services configurés pour le proxy. Cela simplifie drastiquement la vie de l'administrateur, évitant la prolifération de "comptes racine" ou de mots de passe ad-hoc.

De plus, l'exposition publique amplifie la surface d'attaque. L'utilisation de SSO permet de mettre en œuvre des mécanismes de sécurité avancés de manière uniforme : limitation de la taille des mots de passe, blocage des forces brutes (Brute-force protection), gestion des sessions et journalisation centralisée des tentatives d'accès. Ces contrôles sont souvent absents ou mal configurés dans les applications web grand public lorsqu'elles sont déployées isolément.

Surtout, en plaçant Authelia devant les services, il devient le seul point de contact authentifié. Le serveur backend peut être configuré pour rejeter les connexions non authentifiées, transformant le serveur en un "coffre-fort" où l'accès direct aux applications est impossible sans passer par la porte d'entrée sécurisée.

**Arguments contre (ou limites pratiques)**
Le principal argument contre le SSO résidant dans la complexité opérationnelle et la dépendance. L'installation et la configuration d'Authelia (et de ses dépendances comme Traefik ou Nginx) représentent une courbe d'apprentissage significative pour un utilisateur novice. Une erreur de configuration peut entraîner une coupure totale de tous les services, rendant l'administration impossible tant que l'authentification n'est pas rétablie.

Par ailleurs, certains services propriétaires ou très spécifiques ne supportent pas nativement la connexion via OAuth2 ou l'intégration directe avec Authelia. Dans ces cas, l'utilisateur est obligé de contourner le SSO ou de maintenir un compte secondaire, ce qui fragmente partiellement la sécurité. Enfin, si le serveur unique tombe en panne ou si la configuration d'Authelia est corrompue, la perte de tous les accès simultanément est un risque systémique plus élevé que dans une architecture décentralisée où la perte d'un mot de passe n'affecte qu'un service.

**Recommandation tranchée avec conditions**

Pour un homelab personnel consistant en **un seul serveur Linux exposé publiquement**, la recommandation est tranchée : **privilégier impérativement une authentification SSO unique via Authelia (ou équivalent).**

La sécurité par l'isolement (authentification par service) est inadéquate pour une machine exposée sur Internet, car elle multiplie les vecteurs d'attaque et oblige à gérer des centaines de mots de passe potentiels. Le risque d'une compromission d'un service faible (par exemple, un admin panel mal sécurisé) n'ayant pas de protection SSO, compromettrait l'intégrité globale de la machine.

**Cependant, cette recommandation est conditionnée par trois facteurs :**
1. **Compétence technique :** L'opérateur doit posséder une maîtrise suffisante de l'orchestration web (Nginx/Traefik) pour configurer le reverse proxy correctement.
2. **Maturation du projet :** Cette stratégie est idéale pour un homelab stabilisé (>10 services). Pour un projet de test ponctuel ou très éphémère, la surcharge administrative peut être contre-productive.
3. **Redondance :** En étant le seul point de contrôle, Authelia doit être configuré avec une sauvegarde automatique de la base de données et des logs rotatifs. Une panne de configuration ne doit pas signifier la perte de l'administration totale.

En conclusion, le gain en sécurité et en ergonomie justifie la complexité accrue. L'authentification SSO transforme le serveur unique d'une collection de services vulnérables en une infrastructure cohérente et défendable.

**Objet : Analyse comparative des stratégies d’authentification pour un Homelab mono-serveur**

**Contexte**
Dans un environnement homelab domestique reposant sur une architecture simplifiée — un unique serveur Linux hébergeant plusieurs services (Nextcloud, Home Assistant, Pi-hole, etc.) et exposé via un reverse proxy — la gestion de l’identité devient un point critique pour la sécurité et l’expérience utilisateur. Deux approches s’opposent : l’implémentation d’une passerelle d’authentification centralisée (Single Sign-On ou SSO) comme Authelia, ou le maintien d’authentications natives et isolées par service. Ce choix impacte directement la complexité de maintenance, la surface d’attaque et la fluidité d’accès.

**Arguments en faveur du SSO centralisé (Authelia)**
La principale force du SSO réside dans la centralisation du contrôle d’accès. Avec Authelia, l’utilisateur n’effectue une seule connexion pour accéder à l’ensemble de l’écosystème. Cela simplifie considérablement la gestion des mots de passe : plus besoin de mémoriser ou de synchroniser des identifiants distincts pour chaque application. De plus, l’authentification multifacteur (MFA) est appliquée de manière uniforme et robuste à la porte d’entrée du réseau privé. Si un mot de passe principal est compromis, la MFA agit comme une barrière efficace. Enfin, la mise à jour de la politique de sécurité (par exemple, changer la politique de MFA ou bloquer une IP suspecte) se fait en un seul point de configuration, réduisant la charge cognitive de l’administrateur et minimisant les risques de configuration erronée sur des services individuels.

**Arguments contre le SSO et pour l’authentification par service**
L’approche par service natif offre une isolation de la panne. Si Authelia tombe en panne ou rencontre une erreur de configuration, tous les services deviennent inaccessibles, créant un point de défaillance unique (SPOF) critique. En revanche, avec une authentification par service, la chute de l’un ne bloque pas l’accès aux autres. De plus, certains services sont conçus pour une utilisation domestique locale simple (comme un dashboard ou un outil de monitoring) où l’ajout d’une couche SSO semble excessif et alourdit inutilement l’infrastructure. L’authentification par service permet également de granulariser finement les accès : un invité peut avoir accès à un service spécifique sans avoir besoin d’un compte global complet. Enfin, pour un homelab strictement personnel, la friction ajoutée par une seconde étape d’authentification (TOTP ou email) peut être perçue comme une nuisance inutile si la confiance au sein du foyer est totale.

**Recommandation tranchée**
Pour un homelab personnel exposé publiquement, il est fortement recommandé de privilégier **l’authentification SSO centralisée via Authelia ou une solution similaire (comme Authelia ou Keycloak)**.

Cette recommandation s’applique sous deux conditions strictes :
1. **Exposition publique effective** : Si le serveur est accessible depuis internet, la surface d’attaque augmente exponentiellement. Le SSO permet d’imposer une MFA forte à tous les services simultanément, ce qui est indispensable pour protéger les données personnelles sensibles contre le brute-force et les attaques automatisées.
2. **Acceptation de la complexité initiale** : L’utilisateur doit accepter la courbe d’apprentissage initiale pour configurer le reverse proxy et les règles de sécurité, ainsi que la gestion des dépendances.

L’avantage de la sécurité unifiée et de la gestion centralisée des identités l’emporte largement sur la simplicité d’une authentification par service dispersée, surtout lorsque la menace externe est présente. L’isolation de la panne peut être mitigée par un monitorage actif d’Authelia et des sauvegardes régulières de sa configuration, rendant cette approche bien plus résiliente à long terme pour un utilisateur exposé.

**Architecture d’un "Life Center" personnel (max 500 mots)**

*Objectif :* Une seule app mobile/web centrale pour mails, agenda et todo, avec une interface de saisie libre en langage naturel (ex: *"Ajoute le 8 octobre l'anniversaire de X, fais-moi penser à Y demain, prépare une réponse à Z en brouillon"*), qui interprète correctement et déclenche les actions associées.

**Modèles principaux & frontières claires :**

1. **Frontière UX → Intent Parser (module dédié)**
L'utilisateur tape un texte libre. L'app ne traite pas directement : le *Intent Parser* reçoit uniquement le texte brut (sans interprétation métier). Il utilise un petit modèle de NLU léger (ex: fine-tuné sur des phrases similaires, pas GPT lourd) entraîné sur des exemples concrets du style de l'utilisateur. Il ne génère pas d'actions ; il extrait :
- *Entités* (dates explicites/relatives, noms de personnes, objets comme "réponse", "préparation"),
- *Intents* clairs (ex: "ajouter événement", "rappeler", "créer brouillon"),
- *Relations* entre entités (ex: "rappeler Y demain" → relation "rappel lié à Y avec délai relatif").
*Frontière :* Seulement le texte brut → sortie JSON structurée `{intent: "ajouter_et_rappeler", entities: [{type: "date", value: "8 oct", relative: "octobre"}, {type: "person", value: "X"}, {type: "task", value: "penser à Y", relative: "demain"}, {type: "task", value: "préparer réponse", value: "Z", type: "draft"}], relations: [("task Y", "relative": "demain")]}`. Aucun accès à l'agenda/todo directement.

2. **Intent Router (module central)**
Reçoit le JSON du Parser. Vérifie la cohérence basique (ex: "demain" n'est pas dans le passé), normalise les dates relatives (via le calendrier local), et route chaque *intent* au bon module :
- `ajouter_et_rappeler` → Agenda Service + Reminder Service,
- `créer_brouillon` → Draft Manager Service.
*Frontière :* Seul le JSON structuré → décision de routage + appel aux services concernés. Aucun traitement de texte.

3. **Services métier (isolés)**
- *Agenda Service* : Gère l'agenda (ajout d'événement, détection de conflits), expose `addEvent(date, title, relatedTask?)`.
- *Reminder Service* : Gère les rappels (création de rappel avec délai relatif "demain"), utilise le calendrier natif ou push local.
- *Draft Manager Service* : Gère les brouillons (création d'un brouillon associé à un mail/contact, stockage temporaire, suggestion de début de texte basée sur le contexte).
*Frontière :* Chaque service ne connaît que ses propres API (ex: Agenda Service ne connaît pas le Draft Manager). Le Router ne les invoque qu'avec des arguments simples (date, titre, ID mail si besoin).

4. **Store centralisé (synchronisé)**
Un store unique (locale + optionnel cloud chiffré) stocke agenda, todo et brouillons. Les services lisent/écrivent via des méthodes bien définies du store (ex: `getEvents()`, `addTodo()`), garantissant cohérence. Le Parser n'accède pas directement au store.

**Route du texte libre → action :**
`"Ajoute le 8 octobre l anniversaire de X, fais-moi penser à Y demain, prepare une reponse à Z en brouillon"` →
1. UX envoie texte brut au Parser → Parser extrait `{intent: "ajouter_et_rappeler", entities: [...], relations: [...]}`.
2. Parser renvoie JSON au Router → Router identifie `ajouter_et_rappeler` → appelle Agenda Service (`addEvent("8 oct", "Anniversaire X")`) et Reminder Service (`createReminder("penser à Y", "demain")`).
3. Router appelle Draft Manager (`createDraft("réponse à Z", contexte: mail Z)`).
4. Services utilisent le store pour persister. L'app affiche un résumé simple : *"Anniversaire X ajouté le 8 oct. Rappel 'penser à Y' prévu demain. Brouillon 'réponse à Z' créé."*

**3 pièges techniques probables & anticipation :**

1. **Vocabulaire personnel & ambiguïté des dates relatives**
*Exemple :* "demain" peut être mal interprété si l'utilisateur

Voici une architecture pour le « Life Center », conçue comme un système réactif centré sur l'intention utilisateur.

### Architecture Modulaire

L'application repose sur une **Couchette d'État Centralisée** (Single Source of Truth), un graphe de données unifié où les entités (contacts, événements, tâches) sont liées sémantiquement plutôt que stockées silo par silo.

Les modules principaux sont :
1. **L'Interface de Capture (Ingestion Layer)** : Une zone de texte unique (type chat ou command vocal) recevant tout input, quelle que soit la forme.
2. **Le Moteur d'Intentions (NLP Core)** : Un pipeline d'IA hybride (Modèle LLM + Règles métier) qui analyse le contexte, identifie l'entité (`DATE`, `PERSONNE`, `ACTION`) et détermine la classe d'action (`CREATE_EVENT`, `SEND_EMAIL`, `CREATE_TASK`).
3. **Les Exécutants Spécialisés (Action Workers)** : Des microservices isolés par domaine (Outreach pour l'email, Calendar Sync pour l'agenda, Task Manager pour les TODO). Chaque worker reçoit uniquement la payload structurée nécessaire à son exécution.
4. **Le Système de Notification** : Un orchestrateur qui décide du canal de feedback (push, email, son) basé sur l'urgence et le contexte de l'action.

### Frontières et Routage du Texte Libre

La frontière critique se situe entre le **Module d'Intentions** et les **Exécutants**. L'application ne contient pas de logique métier complexe dans l'interface ; elle n'est qu'un terminal de commande.

Le routage du langage naturel suit ce flux :
1. **Tokenisation & Normalisation** : Le texte brut est nettoyé (dates, noms propres).
2. **Classification Sémantique** : Le LLM génère une « Commande Structurée » (JSON) standardisée.
* *Exemple Input :* « Ajoute l'anniversaire de X le 8 oct, fais-moi penser à Y demain, prépare une réponse à Z. »
* *Exemple Output :* `[{"type": "EVENT", "details": {...}}, {"type": "REMINDER", "details": {...}}, {"type": "DRAFT_EMAIL", "details": {...}}]`
3. **Dispatching** : Ce JSON est envoyé via une file d'attente asynchrone. Un routeur interne lit le champ `type` et déclenche uniquement le worker correspondant. Cette séparation garantit que si le service d'emails tombe en panne, la création d'un événement dans l'agenda n'est pas impactée.

### Les 3 Pièges Techniques

1. **La Hallucination de l'IA et la Perda de Données**
Un LLM peut « inventer » des dates ou mal interpréter une entité (confondre un nom de contact avec un lieu).
*Anticipation :* Implémenter une boucle de **validation humaine implicite** (confirmation rapide via une notification) et des règles de contrainte strictes (ex: le format de la date doit être absolu ISO8601). Le système doit refuser l'exécution si la confiance du modèle est basse.

2. **La Collision de Contexte et l'État Distribué**
Gérer plusieurs actions simultanées (ex: « Envoie à X mais annule la réunion de Y ») crée des conflits d'état si les workers agissent en parallèle sans coordination.
*Anticipation :* Utiliser une **Transaction Idempotente** globale. Toutes les actions d'un tour de phrase doivent être traitées comme un bloc atomique ou séquencées dans un ordre déterministe défini par le moteur d'intentions, avec des verrous (locks) pour éviter les écrasements de données.

3. **La Dépendance au Fournisseur de Modèle (Vendor Lock-in)**
Le cœur du système repose sur un modèle tiers coûteux et changeant. Une rupture de service ou une hausse de prix bloque tout le « Life Center ».
*Anticipation :* Adopter une architecture **hybride avec fallback**. Utiliser un modèle local pour les règles simples et le routage, et un modèle cloud uniquement pour la compréhension complexe. Prévoir une dégradation gracieuse : si l'IA échoue, le système propose une correction manuelle dans l'interface plutôt que de bloquer l'utilisateur.

Cette architecture assure robustesse, extensibilité et une expérience utilisateur fluide, transformant le chaos du langage naturel en actions précises.

Voici l’architecture technique proposée pour le "Life Center" personnel, structurée autour d’un noyau décisionnel intelligent.

### 1. Modules Fondamentaux
L’architecture repose sur quatre microservices interconnectés, isolés pour garantir la maintenance et la sécurité :

* **Noyau de Gestion de Contexte (Core Kernel)** : C’est la base de données unifiée (ex: PostgreSQL avec extensions JSONB). Il centralise les entités : Contacts, Événements, Tâches, et Brouillons de mails. Il gère les relations (ex: un contact lié à un événement et à une tâche).
* **Ingestion Multimédia (Ingestion Layer)** : Module spécialisé dans le traitement des emails et fichiers externes (PDF, notes vocales). Il extrait le texte brut et les métadonnées avant envoi vers le moteur NLP.
* **Moteur d’Intent et d’Extraction (NLP Engine)** : Cœur de l’intelligence. Il utilise un LLM (Large Language Model) fine-tuné ou une approche hybride (NER + Classificateur). Son rôle est double : classifier l’intention (créer tâche, créer event, rédiger mail) et extraire les entités temporelles et contextuelles.
* **Adaptateurs d’Action (Action Handlers)** : Une série de connecteurs standardisés qui exécutent les écritures dans le Noyau de Gestion. Chaque action (CRUD) passe par ce module pour validation et sécurité.

### 2. Frontières et Flux de Données
La séparation des responsabilités est stricte :
* **Ingestion → NLP** : Le texte brut est nettoyé (suppression du bruit contextuel non pertinent) et envoyé au Moteur NLP.
* **NLP → Core Kernel** : Le Moteur NLP ne doit jamais écrire directement dans la base. Il retourne une structure de données standardisée (JSON) contenant l’intention, les arguments et la date de déclenchement.
* **Action Handlers → Core Kernel** : Les adaptateurs reçoivent cette structure, vérifient les permissions (ex: l’utilisateur a-t-il accès à ce calendrier ?) et effectuent l’opération SQL.

### 3. Routage du Texte Libre (La "Gare de Tri")
Le routage utilise un pipeline en deux étapes pour équilibrer vitesse et précision :

1. **Pré-classement Rapide (Fast Track)** : Un petit modèle léger (ou règles heuristiques) analyse la syntaxe. Si "rappel", "penser à", "todo" sont détectés → route vers *Handler Tâche*. Si "anniversaire", "réunion", "le 8 octobre" → route vers *Handler Événement*.
2. **Extraction et Validation (Deep Analysis)** : Pour les intents complexes ou ambigus, le LLM intervient. Il applique le *Prompt Engineering* pour extraire les champs clés : `target` (qui ?), `datetime` (quand ?), `content` (quoi ?).
* *Exemple* : "Fais-moi penser à Y demain" → Intention: `CREATE_TASK`, Target: `Y`, Deadline: `Now + 1 day`.
* *Exemple* : "Réponse à Z en brouillon" → Intention: `CREATE_DRAFT`, Target: `Z`, Status: `DRAFT`.

### 4. Les 3 Pièges Techniques Majeurs à Anticiper

1. **L’Ambiguïté Temporelle et Contextuelle**
Le langage naturel est imprécis. "Demain" dépend de l’heure actuelle, mais "la semaine prochaine" peut varier selon le fuseau horaire ou les jours travaillés de l’utilisateur.
* *Solution* : Implémenter un contexte utilisateur persistant (fuseau horaire, jours fériés, habitudes) que le LLM interroge avant de calculer les dates absolues. Utiliser des normes ISO 8601 pour la stockage.

2. **La Surchauffe des Intentions (False Positives)**
L’utilisateur peut dicter une note informelle contenant des dates ou des noms qui ressemblent à des actions ("Tu sais, X est parti le 5 mai, c’était triste"). Le système ne doit pas créer une tâche "Se souvenir que X est parti".
* *Solution* : Introduire un seuil de confiance. Si la probabilité que ce soit une instruction directe est faible, le système ne crée pas l’action mais propose une "note" dans un journal personnel, ou demande confirmation. Ne jamais agir sans confirmation pour les actions irréversibles.

3. **La Fragmentation du Contexte (State Loss)**
Une commande longue comme "Prépare une réponse à Z pour le 8 octobre, mais utilise ton ton habituel et copie le mail de la semaine dernière" nécessite de maintenir l’état de plusieurs sous-tâches.
* *Solution* : Utiliser une architecture d’orchestration (type LangChain ou AutoGen) où le premier LLM décompose la demande en sous-tâches atomiques, chacune exécutée par un agent spécialisé, puis agrégées avant l’écriture finale.