# 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

### Fait ✅
1. [x] Frontend VWB v4 avec React Flow
2. [x] Toggle Mode Basique/Intelligent/Debug
3. [x] Intégration UI-DETR-1 pour détection
4. [x] Overlay Debug (affichage bboxes en temps réel)
5. [x] Exécution intelligente (template matching)
6. [x] Sélection de zone de détection sur capture fixe
7. [x] Intégration SeeClick en fallback (grounding) - 24 janvier 2026
8. [x] Self-healing interactif (proposer alternatives quand échec) - 24 janvier 2026
9. [x] Dashboard confiance (scores en temps réel) - 24 janvier 2026

### À faire
10. [ ] Export données d'apprentissage (format JSON)
11. [ ] Apprentissage des corrections (feedback loop)
12. [ ] Connexion au moteur principal (agents autonomes)

---

*Document créé le 23 janvier 2026*
*Mis à jour le 24 janvier 2026*