# Prochaines Étapes - RPA Vision V3

**Date:** 22 Novembre 2024  
**Phase Actuelle:** Phase 3 ✅ Complète  
**Prochaine Phase:** Phase 4 - Construction de Workflow Graphs

## État Actuel

### ✅ Phases Complétées

**Phase 1 : Fondations - Structures de Données**
- Modèles de données (RawSession, ScreenState, UIElement, StateEmbedding, WorkflowGraph)
- Sérialisation JSON
- Tests unitaires

**Phase 2 : Système d'Embeddings et FAISS**
- FusionEngine (fusion multi-modale)
- FAISSManager (indexation et recherche)
- Calculs de similarité
- StateEmbeddingBuilder

**Phase 3 : Détection UI Sémantique** ✅ VIENT D'ÊTRE COMPLÉTÉE
- UIDetector hybride (OpenCV + VLM)
- Classification de types et rôles
- Extraction de features visuelles
- Système opérationnel et testé

## 🎯 Prochaine Étape : Phase 4

### Phase 4 : Construction et Matching de Workflow Graphs

**Objectif:** Construire automatiquement des graphes de workflows depuis les sessions enregistrées et matcher les états en temps réel.

### Tâches Principales

#### 5.1 GraphBuilder - Construction Automatique
**Priorité:** HAUTE  
**Durée estimée:** 2-3 jours

Créer le système qui construit automatiquement des workflow graphs depuis les RawSessions.

**Sous-tâches:**
- Créer classe `GraphBuilder`
- Implémenter `build_from_session()`
- Créer ScreenStates depuis RawSession
- Calculer State Embeddings pour tous les états

**Fichier:** `rpa_vision_v3/core/graph/graph_builder.py`

#### 5.2 Pattern Detection - Détection de Répétitions
**Priorité:** HAUTE  
**Durée estimée:** 2-3 jours

Détecter automatiquement les patterns répétés dans les sessions.

**Sous-tâches:**
- Implémenter clustering sur embeddings (DBSCAN ou K-means)
- Identifier transitions récurrentes
- Détecter séquences avec 3+ répétitions

**Algorithme suggéré:**
```python
# 1. Calculer embeddings de tous les états
# 2. Clustering (DBSCAN avec distance cosinus)
# 3. Identifier transitions fréquentes entre clusters
# 4. Extraire séquences répétées
```

#### 5.3 Node Construction - Création de Templates
**Priorité:** HAUTE  
**Durée estimée:** 2 jours

Créer des WorkflowNodes depuis les patterns détectés.

**Sous-tâches:**
- Créer ScreenTemplate depuis cluster d'états
- Calculer embedding prototype (moyenne)
- Extraire contraintes (fenêtre, texte, UI requis)

#### 5.4 Edge Construction - Transitions
**Priorité:** HAUTE  
**Durée estimée:** 2 jours

Créer des WorkflowEdges depuis les transitions observées.

**Sous-tâches:**
- Identifier actions entre états
- Créer TargetSpec avec rôles sémantiques
- Définir pre/post-conditions

#### 5.5 NodeMatcher - Matching en Temps Réel
**Priorité:** HAUTE  
**Durée estimée:** 2-3 jours

Matcher l'état actuel contre les nodes du workflow.

**Sous-tâches:**
- Créer classe `NodeMatcher`
- Calculer State Embedding de l'état actuel
- Chercher dans FAISS les prototypes similaires
- Valider contraintes (fenêtre, texte, UI)

**Algorithme:**
```python
# 1. Capturer état actuel
# 2. Calculer embedding
# 3. Recherche FAISS (top-k similaires)
# 4. Valider contraintes pour chaque candidat
# 5. Retourner meilleur match avec confiance
```

### Ordre d'Implémentation Recommandé

```
1. GraphBuilder (5.1)
   ↓
2. Pattern Detection (5.2)
   ↓
3. Node Construction (5.3)
   ↓
4. Edge Construction (5.4)
   ↓
5. NodeMatcher (5.5)
   ↓
6. Tests d'intégration
```

## Améliorations Optionnelles Phase 3

Avant de passer à la Phase 4, tu peux optionnellement améliorer la Phase 3 :

### Option A : Mode Asynchrone (Recommandé)
**Impact:** Gain de vitesse 3-5x  
**Effort:** 1-2 jours  
**Priorité:** MOYENNE

Implémenter le traitement asynchrone des classifications VLM.

**Bénéfices:**
- Temps de détection : 40s → 8-12s
- Meilleure utilisation des ressources
- Expérience utilisateur améliorée

**Fichiers à modifier:**
- `core/detection/ui_detector.py` - Ajouter méthode async
- `core/detection/ollama_client.py` - Ajouter client async

### Option B : Détection Spécialisée Checkboxes
**Impact:** Meilleure détection petits éléments  
**Effort:** 1 jour  
**Priorité:** BASSE

Améliorer la détection des checkboxes et radio buttons.

### Option C : Cache Intelligent
**Impact:** Vitesse sur frames similaires  
**Effort:** 1 jour  
**Priorité:** BASSE

Cacher les classifications pour éléments similaires.

## Recommandation

### 🎯 Recommandation Principale

**Passer directement à la Phase 4** pour compléter le système de bout en bout.

**Raisons:**
1. Phase 3 est fonctionnelle et testée
2. Phase 4 est critique pour le système complet
3. Les optimisations Phase 3 peuvent attendre
4. Mieux vaut avoir un système complet qu'un système partiel optimisé

### 📋 Plan d'Action

**Semaine 1-2:**
- Implémenter GraphBuilder (5.1)
- Implémenter Pattern Detection (5.2)
- Tests unitaires

**Semaine 3:**
- Implémenter Node Construction (5.3)
- Implémenter Edge Construction (5.4)
- Tests unitaires

**Semaine 4:**
- Implémenter NodeMatcher (5.5)
- Tests d'intégration
- Documentation

**Après Phase 4:**
- Revenir aux optimisations Phase 3 si nécessaire
- Implémenter Phase 5 (Exécution d'Actions)

## Dépendances Techniques

### Pour Phase 4, tu auras besoin de:

✅ **Déjà disponible:**
- UIDetector (Phase 3)
- StateEmbeddingBuilder (Phase 2)
- FAISSManager (Phase 2)
- Modèles de données (Phase 1)

❓ **À vérifier:**
- Bibliothèque de clustering (scikit-learn)
- Algorithme de détection de séquences

### Installation Requise

```bash
# Clustering
pip install scikit-learn

# Optionnel : Visualisation
pip install matplotlib seaborn
```

## Questions à Considérer

Avant de commencer la Phase 4 :

1. **Algorithme de clustering:** DBSCAN ou K-means ?
   - DBSCAN : Meilleur pour patterns de taille variable
   - K-means : Plus simple, nécessite nombre de clusters

2. **Seuil de similarité:** Quelle valeur pour matcher les nodes ?
   - Recommandé : 0.85-0.90
   - À ajuster selon les tests

3. **Nombre de répétitions:** Combien pour détecter un pattern ?
   - Recommandé : 3+ répétitions
   - Configurable

4. **Stockage des workflows:** Format et organisation ?
   - JSON par workflow
   - Index FAISS séparé par workflow

## Conclusion

✅ **Phase 3 complète et opérationnelle**  
🎯 **Prochaine étape : Phase 4 - Construction de Workflow Graphs**  
⏱️ **Durée estimée Phase 4 : 3-4 semaines**  
🚀 **Objectif : Système RPA Vision V3 complet**

---

**Prêt à commencer la Phase 4 ?**

Dis-moi quand tu veux démarrer et je t'aiderai à implémenter le GraphBuilder !