# RPA Vision V3 - Roadmap Mise à Jour

**Date:** 22 Novembre 2024  
**Status:** Phase 3 Complétée, Phase 2 à finaliser

---

## 📊 État Actuel

### ✅ Phase 1 : Modèles de Base - COMPLÉTÉ
- [x] RawSession, ScreenState, UIElement, StateEmbedding, WorkflowGraph
- [x] Sérialisation/désérialisation JSON
- [x] Tests unitaires de base

### ⏳ Phase 2 : Système d'Embeddings - À COMPLÉTER
**Status:** Structures créées, embedders réels manquants

#### Fait
- [x] FusionEngine (fusion pondérée)
- [x] FAISSManager (indexation)
- [x] Similarity (calculs)
- [x] StateEmbeddingBuilder (structure)

#### À Faire 🎯
- [ ] **2.8 Implémenter vrais embedders CLIP** ← PROCHAINE TÂCHE
  - Copier/adapter depuis geniusia2/core/embedders/
  - Créer `rpa_vision_v3/core/embedding/clip_embedder.py`
  - Charger OpenCLIP
  - Implémenter `embed_image()` et `embed_text()`
  
- [ ] **2.9 Intégrer CLIP dans StateEmbeddingBuilder**
  - Remplacer vecteurs aléatoires par vrais embeddings
  - Configurer embedders
  - Tester avec screenshots réels

- [ ] **2.10 Tests d'intégration**
  - Valider pipeline complet
  - Benchmarks de performance

### ✅ Phase 3 : UI Detection avec VLM - COMPLÉTÉ (22 Nov 2024)
- [x] OllamaClient (qwen3-vl:8b)
- [x] UIDetector hybride (OpenCV + VLM)
- [x] Tests complets sur screenshots réels
- [x] Documentation complète
- [x] Précision: 88%, Vitesse: 0.8s/élément

### 🚀 Phase 3.5 : Optimisation Asynchrone - PROCHAINE
**Objectif:** Gain de vitesse 3-5x (40s → 8-12s pour 50 éléments)

#### À Faire
- [ ] **3.5.1 AsyncOllamaClient**
  - Refactoriser avec asyncio/aiohttp
  - Batch processing (5-10 éléments parallèles)
  - Gestion concurrence avec semaphore

- [ ] **3.5.2 AsyncUIDetector**
  - Intégrer AsyncOllamaClient
  - Traitement parallèle des régions
  - Tests de performance

- [ ] **3.5.3 Cache Intelligent**
  - Cache basé sur hash visuel
  - Détection de similarité
  - Hit rate > 30%

- [ ] **3.5.4 Monitoring**
  - Métriques temps réel
  - Resource management
  - Dashboard simple

### ⏳ Phase 4 : Construction de Workflow Graphs - EN ATTENTE
**Dépend de:** Phase 2 complétée

#### À Faire
- [ ] **4.1 GraphBuilder**
  - Construction depuis RawSession
  - Détection de patterns
  - Clustering d'états

- [ ] **4.2 NodeMatcher**
  - Matching par similarité
  - Validation de contraintes
  - Recherche FAISS

- [ ] **4.3 Tests d'intégration**
  - Pipeline complet
  - Validation sur données réelles

### ⏳ Phase 5-9 : Exécution, Apprentissage, etc. - EN ATTENTE

---

## 🎯 Plan d'Action Recommandé

### Option A : Finir Phase 2 d'abord (Recommandé)
```
1. Implémenter CLIP embedders (2-3h)
2. Intégrer dans StateEmbeddingBuilder (1h)
3. Tester avec données réelles (1h)
4. Puis Phase 3.5 (Async) (4-6h)
5. Puis Phase 4 (Workflow Graphs) (8-12h)
```

**Avantages:**
- Système complet et cohérent
- Embeddings réels pour Phase 4
- Pas de refactoring plus tard

### Option B : Async d'abord, Phase 2 après
```
1. Phase 3.5 (Async) (4-6h)
2. Phase 2 (CLIP) (4h)
3. Phase 4 (Workflow Graphs) (8-12h)
```

**Avantages:**
- Gain de vitesse immédiat
- Phase 3 optimisée rapidement

---

## 📋 Tâches Détaillées Phase 2

### Task 2.8 : Implémenter CLIP Embedders
**Priorité:** Haute  
**Estimation:** 2-3h  
**Dépendances:** Aucune

**Fichiers à créer:**
- `rpa_vision_v3/core/embedding/clip_embedder.py`
- `rpa_vision_v3/core/embedding/base_embedder.py` (interface)

**Étapes:**
1. Copier `geniusia2/core/embedders/base.py` → `base_embedder.py`
2. Copier `geniusia2/core/embedders/clip_embedder.py` → `clip_embedder.py`
3. Adapter imports et chemins
4. Tester chargement du modèle
5. Tester génération d'embeddings

**Critères d'acceptation:**
- [ ] Modèle OpenCLIP charge correctement
- [ ] `embed_image()` génère vecteur 512D normalisé
- [ ] `embed_text()` génère vecteur 512D normalisé
- [ ] Tests unitaires passent

### Task 2.9 : Intégrer CLIP dans StateEmbeddingBuilder
**Priorité:** Haute  
**Estimation:** 1-2h  
**Dépendances:** 2.8

**Fichiers à modifier:**
- `rpa_vision_v3/core/embedding/state_embedding_builder.py`

**Étapes:**
1. Importer CLIPEmbedder
2. Initialiser dans `__init__` avec embedders dict
3. Remplacer `np.random.randn()` par vrais embeddings
4. Tester avec screenshot réel
5. Valider dimensions et normalisation

**Critères d'acceptation:**
- [ ] Vecteurs aléatoires remplacés par CLIP
- [ ] Embeddings image/texte/titre fonctionnels
- [ ] Vecteur fusionné normalisé (L2 norm = 1)
- [ ] Tests d'intégration passent

### Task 2.10 : Tests et Validation
**Priorité:** Moyenne  
**Estimation:** 1h  
**Dépendances:** 2.9

**Fichiers à créer:**
- `rpa_vision_v3/tests/integration/test_embedding_pipeline.py`
- `rpa_vision_v3/examples/test_embeddings.py`

**Critères d'acceptation:**
- [ ] Pipeline complet testé (screenshot → embedding)
- [ ] Similarité entre états similaires > 0.8
- [ ] Similarité entre états différents < 0.5
- [ ] Performance < 200ms par état

---

## 📋 Tâches Détaillées Phase 3.5

### Task 3.5.1 : AsyncOllamaClient
**Priorité:** Haute  
**Estimation:** 2h  
**Dépendances:** Aucune

**Fichiers à créer:**
- `rpa_vision_v3/core/detection/async_ollama_client.py`

**Critères d'acceptation:**
- [ ] Client async avec aiohttp
- [ ] Batch processing 5-10 éléments
- [ ] Semaphore pour limitation concurrence
- [ ] Gestion erreurs par élément
- [ ] Tests de performance

### Task 3.5.2 : AsyncUIDetector
**Priorité:** Haute  
**Estimation:** 1.5h  
**Dépendances:** 3.5.1

**Fichiers à créer:**
- `rpa_vision_v3/core/detection/async_ui_detector.py`

**Critères d'acceptation:**
- [ ] Détection async complète
- [ ] Gain de vitesse ≥ 3x mesuré
- [ ] Précision maintenue ≥ 85%
- [ ] Tests d'intégration

### Task 3.5.3 : Cache Intelligent
**Priorité:** Moyenne  
**Estimation:** 2h  
**Dépendances:** 3.5.2

**Fichiers à créer:**
- `rpa_vision_v3/core/detection/region_cache.py`

**Critères d'acceptation:**
- [ ] Cache basé sur hash visuel
- [ ] Hit rate ≥ 30%
- [ ] TTL configurable
- [ ] Tests unitaires

### Task 3.5.4 : Monitoring
**Priorité:** Basse  
**Estimation:** 2h  
**Dépendances:** 3.5.2

**Fichiers à créer:**
- `rpa_vision_v3/core/detection/performance_monitor.py`
- `rpa_vision_v3/core/detection/resource_manager.py`

**Critères d'acceptation:**
- [ ] Métriques temps réel
- [ ] Adaptation dynamique batch size
- [ ] Logs structurés
- [ ] Dashboard optionnel

---

## 🎯 Recommandation Finale

**Je recommande Option A : Finir Phase 2 d'abord**

**Raison:**
1. Phase 2 est presque finie (juste embedders manquants)
2. Phase 4 a besoin d'embeddings réels
3. Évite refactoring plus tard
4. Système cohérent et complet

**Plan:**
```
Jour 1 : Phase 2 (4h)
  - Matin : Implémenter CLIP (2-3h)
  - Après-midi : Intégrer + tester (1-2h)

Jour 2 : Phase 3.5 (6h)
  - Matin : AsyncOllamaClient + AsyncUIDetector (3-4h)
  - Après-midi : Cache + Monitoring (2-3h)

Jour 3+ : Phase 4 (8-12h)
  - GraphBuilder
  - NodeMatcher
  - Tests
```

**Qu'en pensez-vous ?** 🤔