# Implementation Plan - RPA Vision V3

## Vue d'Ensemble

Plan d'implémentation complet pour RPA Vision V3 avec architecture en 5 couches.

**Principe** : Implémentation incrémentale avec tests à chaque étape. Focus sur le RPA 100% Vision avec workflows sémantiques.

## État Actuel

- ✅ **Phase 1** : Modèles de base (structures créées)
- ⏳ **Phase 2** : Système d'embeddings (structures créées, embedders à implémenter)
- ✅ **Phase 3** : UI Detection avec VLM (COMPLÉTÉ - 22 Nov 2024)
- ⏳ **Phase 3.5** : Optimisation Asynchrone (à faire)
- ⏳ **Phase 4** : Construction de Workflow Graphs (à faire)
- ⏳ **Phase 5-9** : Exécution, Apprentissage, Robustesse, etc.

## Résumé des Phases

- **Phase 1**: Modèles de base ✅ COMPLÉTÉ
- **Phase 2**: Système d'embedding ⏳ À COMPLÉTER (embedders réels)
- **Phase 3**: UI Detection avec VLM ✅ COMPLÉTÉ (22 Nov 2024)
- **Phase 3.5**: Optimisation Asynchrone 🚀 PROCHAINE
- **Phase 4**: Construction de Workflow Graphs ⏳ EN ATTENTE
- **Phase 5**: Exécution et Apprentissage ⏳ EN ATTENTE
- **Phase 6-9**: Robustesse, Persistence, Optimisation ⏳ EN ATTENTE

---

## Tasks

- [ ] 1. Phase 1 : Fondations - Structures de Données
  - Créer les classes de base pour toutes les couches
  - Implémenter sérialisation/désérialisation JSON
  - _Requirements: 1.4, 1.5, 2.6, 7.6, 12.1, 12.4, 12.5_

- [ ] 1.1 Créer modèle RawSession avec sérialisation JSON
  - Implémenter classe `RawSession` dans `geniusia2/core/models/raw_session.py`
  - Implémenter classes `Event` et `Screenshot`
  - Implémenter méthodes `to_json()` et `from_json()`
  - Valider schéma "rawsession_v1"
  - _Requirements: 1.4, 1.5_

- [ ]* 1.2 Écrire tests unitaires pour RawSession
  - Tester sérialisation/désérialisation
  - Tester ajout d'événements et screenshots
  - Tester validation de schéma
  - **Property 1: RawSession Serialization Round Trip**
  - **Validates: Requirements 1.4, 1.5**

- [ ] 1.3 Créer modèle ScreenState avec 4 niveaux
  - Implémenter classe `ScreenState` dans `geniusia2/core/models/screen_state.py`
  - Implémenter classes `RawLevel`, `PerceptionLevel`, `ContextLevel`
  - Implémenter méthodes `to_json()` et `from_json()`
  - _Requirements: 2.1, 2.2, 2.3, 2.4, 2.5, 2.6_

- [ ]* 1.4 Écrire tests unitaires pour ScreenState
  - Tester création des 4 niveaux
  - Tester sérialisation/désérialisation
  - **Property 2: ScreenState Multi-Level Consistency**
  - **Validates: Requirements 2.1, 2.2, 2.3, 2.4, 2.5**

- [ ] 1.5 Créer modèle UIElement avec embeddings duaux
  - Implémenter classe `UIElement` dans `geniusia2/core/models/ui_element.py`
  - Implémenter classes `UIElementEmbeddings`, `VisualFeatures`
  - Implémenter méthodes `to_json()` et `from_json()`
  - _Requirements: 3.7_

- [ ]* 1.6 Écrire tests unitaires pour UIElement
  - Tester création avec tous les attributs
  - Tester sérialisation/désérialisation
  - **Property 3: UIElement Detection Confidence Bounds**
  - **Validates: Requirements 3.6**

- [ ] 1.7 Créer modèle StateEmbedding
  - Implémenter classe `StateEmbedding` dans `geniusia2/core/models/state_embedding.py`
  - Implémenter méthode `get_vector()` pour charger .npy
  - Implémenter méthode `compute_similarity()`
  - _Requirements: 4.7, 4.8_

- [ ]* 1.8 Écrire tests unitaires pour StateEmbedding
  - Tester chargement de vecteur
  - Tester calcul de similarité
  - **Property 4: State Embedding Normalization**
  - **Property 5: State Embedding Similarity Symmetry**
  - **Property 6: State Embedding Similarity Bounds**
  - **Validates: Requirements 4.6, 4.7**

- [ ] 1.9 Créer modèles Workflow Graph (Node, Edge, Workflow)
  - Implémenter classes dans `geniusia2/core/models/workflow_graph.py`
  - Implémenter `WorkflowNode`, `WorkflowEdge`, `Workflow`
  - Implémenter classes de support (ScreenTemplate, Action, etc.)
  - Implémenter méthodes `to_json()` et `from_json()`
  - _Requirements: 5.6, 6.7, 7.6_

- [ ]* 1.10 Écrire tests unitaires pour Workflow Graph
  - Tester création de nodes et edges
  - Tester sérialisation/désérialisation
  - **Property 12: Workflow Graph Structural Validity**
  - **Property 18: Workflow JSON Serialization Round Trip**
  - **Validates: Requirements 7.2, 7.6, 12.4, 12.5**



- [ ] 2. Phase 2 : Système d'Embeddings et FAISS
  - Implémenter fusion multi-modale
  - Implémenter gestion FAISS
  - Optimiser performances
  - _Requirements: 4.1, 4.2, 4.3, 4.4, 4.5, 4.6, 4.8, 12.3, 12.6, 15.1, 15.2_

- [ ] 2.1 Implémenter FusionEngine pour fusion pondérée
  - Créer classe `FusionEngine` dans `geniusia2/core/embedding/fusion_engine.py`
  - Implémenter méthode `fuse()` avec fusion pondérée
  - Implémenter normalisation des vecteurs
  - Configurer poids par défaut (image: 0.5, text: 0.3, title: 0.1, ui: 0.1)
  - _Requirements: 4.5, 4.6_

- [ ]* 2.2 Écrire tests unitaires pour FusionEngine
  - Tester fusion pondérée
  - Tester normalisation
  - **Property 17: State Embedding Component Weights Sum**
  - **Validates: Requirements 4.5**

- [ ] 2.3 Implémenter FAISSManager pour indexation
  - Créer classe `FAISSManager` dans `geniusia2/core/embedding/faiss_manager.py`
  - Implémenter méthode `add_embedding()`
  - Implémenter méthode `search_similar()`
  - Implémenter sauvegarde/chargement d'index
  - Gérer metadata_store pour mappings
  - _Requirements: 4.8, 12.3, 12.6_

- [ ]* 2.4 Écrire tests unitaires pour FAISSManager
  - Tester ajout d'embeddings
  - Tester recherche de similarité
  - Tester sauvegarde/chargement
  - **Property 11: FAISS Index Consistency**
  - **Validates: Requirements 4.8, 12.3, 12.6**

- [ ] 2.5 Implémenter calculs de similarité
  - Créer module `geniusia2/core/embedding/similarity.py`
  - Implémenter similarité cosinus
  - Implémenter distance euclidienne
  - Implémenter normalisation L2
  - _Requirements: 4.7_

- [ ]* 2.6 Écrire tests de performance pour embeddings
  - Benchmarker temps de fusion (cible: <100ms)
  - Benchmarker temps de recherche FAISS (cible: <50ms)
  - **Property 19: Performance Constraint - State Embedding**
  - **Validates: Requirements 15.1, 15.2**

- [ ] 2.7 Implémenter StateEmbeddingBuilder
  - Créer classe pour construire State Embeddings complets
  - Intégrer FusionEngine
  - Calculer embeddings pour image, texte, titre, UI
  - Sauvegarder vecteurs en .npy
  - _Requirements: 4.1, 4.2, 4.3, 4.4, 4.5, 4.6_

- [ ]* 2.8 Écrire tests d'intégration pour StateEmbeddingBuilder
  - Tester construction complète depuis ScreenState
  - Tester sauvegarde de vecteurs
  - Vérifier normalisation finale

- [ ] 3. Checkpoint - Vérifier que tous les tests passent
  - Ensure all tests pass, ask the user if questions arise.

- [ ] 4. Phase 3 : Détection UI Sémantique
  - Intégrer VLM pour détection
  - Classifier types et rôles
  - Générer embeddings duaux
  - _Requirements: 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 15.3_

- [ ] 4.1 Créer UIDetector avec intégration VLM
  - Créer classe `UIDetector` dans `geniusia2/core/detection/ui_detector.py`
  - Intégrer client VLM (Qwen 2.5-VL via Ollama)
  - Implémenter détection de régions d'intérêt
  - _Requirements: 3.1_

- [ ] 4.2 Implémenter classification de types UI
  - Ajouter méthode `classify_type()` dans UIDetector
  - Supporter types: button, text_input, checkbox, radio, dropdown, tab, link, icon, table_row, menu_item
  - Utiliser VLM pour classification
  - _Requirements: 3.2_

- [ ] 4.3 Implémenter classification de rôles sémantiques
  - Ajouter méthode `classify_role()` dans UIDetector
  - Supporter rôles: primary_action, cancel, submit, form_input, search_field, etc.
  - Utiliser contexte visuel et textuel
  - _Requirements: 3.3_

- [ ] 4.4 Implémenter extraction de features visuelles
  - Ajouter méthode `extract_visual_features()`
  - Extraire couleur dominante, forme, taille
  - Détecter présence d'icônes
  - _Requirements: 3.4_

- [ ] 4.5 Implémenter génération d'embeddings duaux
  - Intégrer OpenCLIP pour embeddings
  - Générer embedding image (crop de l'élément)
  - Générer embedding texte (label détecté)
  - Sauvegarder embeddings en .npy
  - _Requirements: 3.5_

- [ ] 4.6 Implémenter calcul de confiance de détection
  - Combiner confiance VLM + confiance classification
  - Filtrer éléments sous seuil (0.7)
  - _Requirements: 3.6_

- [ ]* 4.7 Écrire tests unitaires pour UIDetector
  - Tester détection avec screenshots de test
  - Tester classification de types et rôles
  - Tester génération d'embeddings
  - **Property 13: UIElement Role Uniqueness Per Type**
  - **Validates: Requirements 3.3**

- [ ]* 4.8 Écrire tests de performance pour détection UI
  - Benchmarker temps de détection (cible: <200ms)
  - Tester avec screenshots de différentes tailles
  - **Validates: Requirements 15.3**



- [ ] 5. Phase 4 : Construction et Matching de Workflow Graphs
  - Construire graphes depuis sessions
  - Matcher ScreenStates contre nodes
  - Détecter patterns répétés
  - _Requirements: 5.1, 5.2, 5.3, 5.4, 5.5, 9.1, 9.2, 9.3, 9.4, 9.5, 9.6, 9.7, 11.1, 11.2, 11.3, 11.4, 11.5, 11.6, 11.7_

- [ ] 5.1 Implémenter GraphBuilder pour construction automatique
  - Créer classe `GraphBuilder` dans `geniusia2/core/graph/graph_builder.py`
  - Implémenter méthode `build_from_session()`
  - Créer ScreenStates depuis RawSession
  - Calculer State Embeddings pour tous les états
  - _Requirements: 11.1, 11.2, 11.3_

- [ ] 5.2 Implémenter détection de patterns répétés
  - Ajouter méthode `_detect_patterns()` dans GraphBuilder
  - Utiliser clustering sur embeddings (DBSCAN ou K-means)
  - Identifier transitions récurrentes entre clusters
  - Détecter séquences avec 3+ répétitions
  - _Requirements: 11.4, 11.5, 11.6, 11.7_

- [ ]* 5.3 Écrire tests pour détection de patterns
  - Tester avec sessions simulées
  - Vérifier détection de répétitions
  - **Property 16: Pattern Detection Minimum Repetitions**
  - **Validates: Requirements 11.7**

- [ ] 5.4 Implémenter construction de WorkflowNodes depuis patterns
  - Ajouter méthode `_build_nodes()` dans GraphBuilder
  - Créer ScreenTemplate depuis cluster d'états
  - Calculer embedding prototype (moyenne des embeddings)
  - Extraire contraintes de fenêtre et texte requis
  - Identifier éléments UI requis
  - _Requirements: 5.1, 5.2, 5.3, 5.4, 5.5_

- [ ]* 5.5 Écrire tests pour construction de nodes
  - Tester création de templates
  - Tester calcul de prototypes
  - **Property 14: Embedding Prototype Sample Count**
  - **Validates: Requirements 5.4**

- [ ] 5.6 Implémenter construction de WorkflowEdges depuis transitions
  - Ajouter méthode `_build_edges()` dans GraphBuilder
  - Identifier actions entre états (depuis événements RawSession)
  - Créer TargetSpec avec rôles sémantiques
  - Définir pre-conditions et post-conditions
  - _Requirements: 6.1, 6.2, 6.3, 6.4, 6.5, 6.6_

- [ ]* 5.7 Écrire tests pour construction d'edges
  - Tester identification d'actions
  - Tester création de TargetSpec
  - Vérifier contraintes

- [ ] 5.8 Implémenter NodeMatcher pour matching en temps réel
  - Créer classe `NodeMatcher` dans `geniusia2/core/graph/node_matcher.py`
  - Implémenter méthode `match()`
  - Calculer State Embedding du ScreenState actuel
  - Chercher dans FAISS les prototypes similaires
  - Valider contraintes (fenêtre, texte, UI)
  - _Requirements: 9.1, 9.2, 9.3, 9.4, 9.5, 9.6, 9.7_

- [ ]* 5.9 Écrire tests pour NodeMatcher
  - Tester matching avec différents seuils
  - Tester validation de contraintes
  - Tester cas où aucun node ne match
  - **Property 7: WorkflowNode Matching Consistency**
  - **Validates: Requirements 9.1, 9.2, 9.3, 9.4, 9.5, 9.6**

- [ ] 5.10 Implémenter méthode WorkflowNode.matches()
  - Ajouter logique de matching dans WorkflowNode
  - Vérifier contraintes de fenêtre
  - Vérifier texte requis présent
  - Vérifier éléments UI requis présents
  - Vérifier similarité embedding > seuil
  - Retourner (match: bool, confidence: float)
  - _Requirements: 5.1, 5.2, 5.3, 5.4, 5.5_

- [ ]* 5.11 Écrire tests d'intégration pour workflow complet
  - Tester construction depuis session → matching
  - Vérifier graphe construit correctement
  - Vérifier matching fonctionne sur nouveaux états

- [ ] 6. Checkpoint - Vérifier que tous les tests passent
  - Ensure all tests pass, ask the user if questions arise.



- [ ] 7. Phase 5 : Exécution d'Actions et Apprentissage Progressif
  - Exécuter actions par rôle sémantique
  - Gérer états d'apprentissage
  - Implémenter transitions automatiques
  - _Requirements: 8.1, 8.2, 8.3, 8.4, 8.5, 8.6, 10.1, 10.2, 10.3, 10.4, 10.5, 10.6, 10.7, 15.4_

- [ ] 7.1 Implémenter ActionExecutor pour exécution d'actions
  - Créer classe `ActionExecutor` dans `geniusia2/core/graph/action_executor.py`
  - Implémenter méthode `execute_edge()`
  - Vérifier pre-conditions avant exécution
  - _Requirements: 10.5_

- [ ] 7.2 Implémenter recherche d'éléments par rôle sémantique
  - Ajouter méthode `_find_target_element()` dans ActionExecutor
  - Chercher UIElements par rôle dans ScreenState
  - Appliquer selection_policy (first, last, by_similarity)
  - Implémenter fallback strategies
  - _Requirements: 10.1_

- [ ] 7.3 Implémenter exécution d'actions mouse_click
  - Ajouter méthode `_execute_click()` dans ActionExecutor
  - Cliquer au centre de l'UIElement trouvé
  - Appliquer click_offset si configuré
  - Attendre wait_after_ms
  - _Requirements: 10.2_

- [ ] 7.4 Implémenter exécution d'actions text_input
  - Ajouter méthode `_execute_text_input()` dans ActionExecutor
  - Taper texte dans l'UIElement trouvé
  - Gérer caractères spéciaux
  - _Requirements: 10.3_

- [ ] 7.5 Implémenter exécution d'actions compound
  - Ajouter méthode `_execute_compound()` dans ActionExecutor
  - Exécuter séquence d'actions
  - Gérer repeat policies (all, until_success)
  - _Requirements: 10.4_

- [ ] 7.6 Implémenter vérification de post-conditions
  - Ajouter méthode `_wait_for_postconditions()` dans ActionExecutor
  - Attendre changement de fenêtre si requis
  - Attendre nouveaux éléments UI si requis
  - Vérifier transition vers node attendu
  - Timeout si post-conditions non satisfaites
  - _Requirements: 10.6_

- [ ]* 7.7 Écrire tests unitaires pour ActionExecutor
  - Tester recherche d'éléments par rôle
  - Tester exécution de chaque type d'action
  - Tester vérification de post-conditions
  - **Property 8: WorkflowEdge Pre-Condition Validation**
  - **Property 15: Action Execution Timeout**
  - **Validates: Requirements 10.5, 10.6**

- [ ]* 7.8 Écrire tests de performance pour exécution
  - Benchmarker temps d'exécution (cible: <50ms)
  - **Validates: Requirements 15.4**

- [ ] 7.9 Implémenter LearningManager pour états d'apprentissage
  - Créer classe `LearningManager` dans `geniusia2/core/graph/learning_manager.py`
  - Gérer dictionnaire de workflows
  - Implémenter méthode `update_workflow_stats()`
  - _Requirements: 8.5_

- [ ] 7.10 Implémenter transitions d'états d'apprentissage
  - Ajouter méthode `_check_state_transition()` dans LearningManager
  - Implémenter `_can_transition_to_coaching()` (5 observations, similarité >0.90)
  - Implémenter `_can_transition_to_auto_candidate()` (10 assists, succès >0.90)
  - Implémenter `_can_transition_to_auto_confirmed()` (20 exécutions, succès >0.95)
  - Logger toutes les transitions avec raison
  - _Requirements: 8.1, 8.2, 8.3, 8.4, 8.5_

- [ ] 7.11 Implémenter rollback automatique
  - Ajouter méthode `_should_rollback()` dans LearningManager
  - Détecter confiance < 0.90 en mode AUTO_CONFIRMÉ
  - Rétrograder vers COACHING
  - Logger le rollback
  - _Requirements: 8.6_

- [ ]* 7.12 Écrire tests pour LearningManager
  - Tester transitions d'états
  - Tester calcul de métriques
  - Tester rollback
  - **Property 9: Learning State Monotonic Progression**
  - **Property 10: Learning State Rollback Condition**
  - **Validates: Requirements 8.1, 8.2, 8.3, 8.4, 8.6**

- [ ]* 7.13 Écrire tests d'intégration pour apprentissage complet
  - Simuler 5 observations → COACHING
  - Simuler 10 assists → AUTO_CANDIDATE
  - Simuler 20 exécutions → AUTO_CONFIRMÉ
  - Simuler baisse de confiance → rollback

- [ ] 8. Checkpoint - Vérifier que tous les tests passent
  - Ensure all tests pass, ask the user if questions arise.



- [ ] 9. Phase 6 : Gestion des Erreurs et Robustesse
  - Gérer échecs de matching
  - Gérer échecs de détection
  - Gérer violations de post-conditions
  - Détecter changements d'UI
  - _Requirements: 14.1, 14.2, 14.3, 14.4, 14.5, 14.6_

- [ ] 9.1 Implémenter gestion d'échecs de matching
  - Ajouter logging détaillé dans NodeMatcher
  - Logger ScreenState non matché avec screenshot
  - Calculer similarité avec tous les nodes
  - Suggérer mise à jour ou création de node
  - _Requirements: 14.1_

- [ ] 9.2 Implémenter stratégies de fallback pour détection UI
  - Ajouter fallback par visual similarity dans ActionExecutor
  - Ajouter fallback par position approximative
  - Logger tentatives de fallback
  - _Requirements: 14.2_

- [ ] 9.3 Implémenter gestion de violations de post-conditions
  - Logger violations avec détails (attendu vs réel)
  - Attendre timeout configuré
  - Marquer exécution comme échec si timeout
  - Incrémenter compteur d'échecs pour edge
  - Marquer edge comme problématique si échecs répétés (>3)
  - _Requirements: 14.3_

- [ ] 9.4 Implémenter détection de changements d'UI
  - Ajouter méthode `detect_ui_change()` dans NodeMatcher
  - Comparer similarité actuelle vs prototype
  - Détecter changement si similarité < 0.70
  - Capturer screenshot pour analyse
  - Mettre en pause exécution automatique
  - Notifier utilisateur
  - _Requirements: 14.4_

- [ ] 9.5 Implémenter système de rollback
  - Ajouter méthode `rollback()` dans ActionExecutor
  - Stocker historique des 3 dernières actions
  - Implémenter inverse pour chaque type d'action
  - Logger tentatives de rollback
  - _Requirements: 14.5_

- [ ]* 9.6 Écrire tests pour gestion d'erreurs
  - Tester échec de matching
  - Tester échec de détection UI
  - Tester violation de post-conditions
  - Tester détection de changement UI
  - Tester rollback

- [ ] 10. Phase 7 : Persistence et Storage
  - Implémenter sauvegarde structurée
  - Implémenter chargement avec validation
  - Organiser fichiers par date et workflow
  - _Requirements: 12.1, 12.2, 12.3, 12.4, 12.5, 12.6, 12.7_

- [ ] 10.1 Implémenter StorageManager pour gestion de fichiers
  - Créer classe `StorageManager` dans `geniusia2/core/persistence/storage_manager.py`
  - Implémenter méthode `save_raw_session()`
  - Implémenter méthode `save_screen_state()`
  - Implémenter méthode `save_workflow()`
  - Organiser par date (YYYY-MM-DD)
  - _Requirements: 12.1, 12.2, 12.4, 12.7_

- [ ] 10.2 Implémenter sauvegarde d'embeddings
  - Ajouter méthode `save_embedding()` dans StorageManager
  - Sauvegarder vecteurs en .npy
  - Ajouter à FAISS index
  - Sauvegarder métadonnées
  - _Requirements: 12.2, 12.3_

- [ ] 10.3 Implémenter chargement avec validation
  - Ajouter méthode `load_workflow()` dans StorageManager
  - Valider schéma JSON
  - Charger FAISS index
  - Charger métadonnées
  - Reconstruire objets Python
  - _Requirements: 12.5, 12.6_

- [ ]* 10.4 Écrire tests pour persistence
  - Tester sauvegarde/chargement de tous les types
  - Tester organisation de fichiers
  - Tester validation de schémas

- [ ] 11. Phase 8 : Optimisation et Performance
  - Optimiser embeddings (batching, caching)
  - Optimiser FAISS (IVF index)
  - Optimiser détection UI (ROI)
  - Mesurer et valider performances
  - _Requirements: 15.1, 15.2, 15.3, 15.4, 15.5_

- [ ] 11.1 Implémenter batch processing pour embeddings
  - Ajouter méthode `compute_embeddings_batch()` dans FusionEngine
  - Traiter multiples images en parallèle
  - Optimiser utilisation GPU si disponible

- [ ] 11.2 Implémenter caching d'embeddings
  - Ajouter cache LRU pour prototypes
  - Mettre en cache derniers State Embeddings
  - Invalider cache intelligemment

- [ ] 11.3 Optimiser FAISS avec index IVF
  - Migrer vers index IVF pour >10k embeddings
  - Optimiser périodiquement l'index
  - Utiliser GPU si disponible

- [ ] 11.4 Optimiser détection UI avec ROI
  - Limiter résolution des screenshots (max 1920x1080)
  - Détecter régions d'intérêt avant traitement complet
  - Mettre en cache résultats pour frames similaires

- [ ]* 11.5 Écrire tests de performance complets
  - Benchmarker toutes les opérations
  - Valider contraintes de temps
  - **Property 19: Performance Constraint - State Embedding**
  - **Property 20: Performance Constraint - End-to-End**
  - **Validates: Requirements 15.1, 15.2, 15.3, 15.4, 15.5**

- [ ] 12. Checkpoint Final - Vérifier que tous les tests passent
  - Ensure all tests pass, ask the user if questions arise.

- [ ] 13. Phase 9 : Tests End-to-End et Documentation
  - Tests de bout en bout complets
  - Documentation utilisateur
  - Guide de déploiement

- [ ] 13.1 Créer tests end-to-end pour workflow complet
  - Tester capture → construction → matching → exécution
  - Tester apprentissage progressif complet
  - Tester robustesse aux changements UI
  - Tester multi-workflows

- [ ]* 13.2 Écrire tests de validation de qualité
  - Tester qualité des embeddings
  - **Property 13: UIElement Role Uniqueness Per Type**
  - **Validates: Requirements 13.1, 13.2, 13.3, 13.4, 13.5**

- [ ] 13.3 Créer documentation utilisateur
  - Guide de démarrage rapide
  - Guide d'utilisation des 5 couches
  - Exemples de workflows
  - FAQ et troubleshooting

- [ ] 13.4 Créer guide de déploiement
  - Instructions d'installation
  - Configuration requise
  - Configuration des modèles
  - Optimisation de production
