feat(vwb): Intégration UI-DETR-1 + Toggle mode Basique/Intelligent/Debug

- Toggle 3 modes dans le header: Basique (coords fixes), Intelligent (vision IA), Debug (overlay)
- Service UI-DETR-1 pour détection d'éléments UI (510MB model, ~800ms/image)
- API endpoints: /api/ui-detection/detect, /preload, /status, /find-element
- Overlay des bboxes détectées en mode Debug (miniature + plein écran)
- Clic sur élément détecté pour le sélectionner comme ancre
- Document de vision produit: docs/VISION_RPA_INTELLIGENT.md
- Configuration CORS étendue pour ports locaux

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Dom
2026-01-23 14:13:32 +01:00
parent 483653a0b4
commit d8d086dac5
11 changed files with 1456 additions and 19 deletions

View File

@@ -0,0 +1,242 @@
# RPA Vision - Architecture et Vision Produit
> Document de référence - Janvier 2026
## Vision Globale
RPA Vision n'est **pas** un simple enregistreur de macros. C'est un **agent RPA apprenant** qui fonctionne comme un stagiaire :
1. **Il observe** - Capture les démonstrations humaines
2. **Il apprend** - Stocke les patterns visuels (embeddings CLIP)
3. **Il essaie** - Exécute avec supervision
4. **Il se trompe** - Détecte ses erreurs
5. **On le corrige** - Feedback humain
6. **Il devient autonome** - Généralise à de nouveaux cas
## Architecture Technique
### Machine Cible
- **CPU** : Ryzen 9 9050X
- **RAM** : 128 Go DDR5 4040 MHz
- **GPU** : NVIDIA RTX 5090 12 Go
Cette configuration permet de tout faire tourner en local (pas de cloud).
### Composants Principaux
```
rpa_vision_v3/
├── core/
│ ├── learning/ # Mémoire + apprentissage continu
│ ├── embedding/ # Représentation visuelle (CLIP)
│ ├── healing/ # Auto-correction (self-healing)
│ └── workflow/ # Orchestration
├── agent_v0/ # Agents autonomes (produit final)
├── web_dashboard/ # Interface de supervision (produit final)
└── visual_workflow_builder/ # VWB (outil transitoire)
```
### Pipeline de Détection (Hybride)
```
┌─────────────────────────────────────────────────────────────────┐
│ ÉCRAN CAPTURÉ │
└─────────────────────────────────────────────────────────────────┘
┌───────────────────────────────┐
│ MODE 1: UI MAP JSON │
│ (OmniParser / UI-DETR-1) │
│ → Liste de bboxes + scores │
└───────────────────────────────┘
┌───────────────────────────────┐
│ DÉCIDEUR (LLM local) │
│ Choisit ID élément │
│ (pas de coords libres) │
└───────────────────────────────┘
┌─────────┴─────────┐
│ │
Élément trouvé? UI map bruitée?
│ │
▼ ▼
┌─────────────────┐ ┌─────────────────┐
│ REFINE │ │ MODE 2: GROUND │
│ (crop + Moondream│ │ (SeeClick) │
│ ou OpenCV) │ │ → (x,y) direct │
└─────────────────┘ └─────────────────┘
│ │
└─────────┬─────────┘
┌───────────────────────────────┐
│ VERIFY │
│ L'action a-t-elle eu effet? │
└───────────────────────────────┘
```
### Modèles Utilisés
| Fonction | Modèle | Licence |
|----------|--------|---------|
| UI Map (détection) | UI-DETR-1 ou OmniParser | OK commercial |
| Grounding (fallback) | SeeClick | OK commercial |
| Embeddings visuels | CLIP | MIT |
| Décideur | LLM local (Mistral/LLaMA 7-13B) | Apache/LLaMA |
### Terrain de jeu
- Desktop natif Windows/Linux
- Citrix / VDI (images compressées)
- Petites icônes (cas difficile)
---
## Rôle de VWB (Visual Workflow Builder)
VWB est un **outil transitoire**, pas le produit final.
### Utilité
| Fonction | Description |
|----------|-------------|
| **Démo commerciale** | Interface visuelle impressionnante pour prospects |
| **Bootstrap** | Créer rapidement des exemples d'apprentissage |
| **Correction** | Humain corrige les erreurs de l'agent via UI |
| **Accélérateur** | Génère des données d'entraînement validées |
### Évolution prévue
| Aujourd'hui (VWB) | Demain (Produit final) |
|-------------------|------------------------|
| Interface drag & drop | Instructions texte/vocal |
| Workflows manuels | Workflows générés par l'agent |
| Humain dessine le chemin | Agent déduit le chemin |
| VWB + Dashboard | Dashboard + Agents seuls |
---
## Modes d'Exécution VWB
### Toggle Global (3 modes)
```
┌─────────────────────────────────────────────┐
│ ○ Basique │ ● Intelligent │ ○ Debug │
└─────────────────────────────────────────────┘
```
### Comparaison des modes
| Fonction | Basique | Intelligent | Debug |
|----------|---------|-------------|-------|
| Localisation | Coordonnées fixes | UI-DETR + CLIP | UI-DETR + CLIP |
| Décision | Séquentiel strict | LLM choisit | LLM choisit |
| Self-healing | OFF | ON | ON |
| Vérification | Aucune | Après chaque action | Après chaque action |
| Overlay visuel | Aucun | Aucun | Bboxes + scores |
| Vitesse | Rapide | Plus lent | Plus lent |
| Usage | Démo simple | Démo "magie" | Debug interne |
---
## Scénario de Démo Type
### Acte 1 : "Le robot classique"
**[Mode: BASIQUE]**
- Montrer un workflow simple : login → recherche → export
- Exécution fluide, rapide, prévisible
- Message : "Voici ce que font les RPA classiques"
### Acte 2 : "Le problème"
**[Mode: BASIQUE]**
- Modifier légèrement l'interface (bouton déplacé, thème différent)
- Relancer le workflow
- **ÇA CASSE**
- Message : "Voilà pourquoi les RPA coûtent cher en maintenance"
### Acte 3 : "La magie"
**[Mode: INTELLIGENT]**
- Même workflow, même interface modifiée
- L'agent cherche, trouve, s'adapte
- **ÇA MARCHE**
- Message : "Notre système apprend et s'adapte"
### Acte 4 : "Le futur"
- Montrer le dashboard avec les agents
- Message : "À terme, plus besoin de dessiner. Vous lui dites ce que vous voulez."
---
## Compréhension des Intentions
Le système utilise une approche **hybride** :
1. **Matching sémantique** : Compare l'instruction avec les workflows connus (embeddings)
2. **Planification LLM** : Si pas de match direct, le LLM local décompose l'instruction en étapes
```
Instruction: "Créer une facture pour le client Dupont"
┌───────────────────────────────┐
│ Matching workflows connus │
│ "créer facture" → 85% match │
└───────────────────────────────┘
Match trouvé?
│ │
OUI NON
│ │
▼ ▼
Exécuter LLM planifie
workflow nouvelles étapes
existant (généralisation)
```
---
## Données d'Apprentissage
VWB génère des données pour entraîner le moteur principal :
### Format d'export
```json
{
"screenshot_before": "base64...",
"action": {
"type": "click_anchor",
"target_description": "Bouton Valider",
"anchor_embedding": [0.12, -0.34, ...],
"coordinates": {"x": 450, "y": 230}
},
"screenshot_after": "base64...",
"success": true,
"human_validated": true
}
```
### Boucle d'apprentissage
1. Agent propose une action
2. Humain valide/corrige via VWB
3. Correction stockée dans learning repository
4. Modèle s'améliore (fine-tuning incrémental)
---
## Prochaines Étapes
1. [x] Frontend VWB v4 avec React Flow
2. [ ] Toggle Mode Basique/Intelligent/Debug
3. [ ] Intégration UI-DETR-1 pour détection
4. [ ] Intégration SeeClick en fallback
5. [ ] Overlay Debug (affichage bboxes)
6. [ ] Export données d'apprentissage
7. [ ] Connexion au moteur principal
---
*Document créé le 23 janvier 2026*