v1.0 - Version stable: multi-PC, détection UI-DETR-1, 3 modes exécution

- Frontend v4 accessible sur réseau local (192.168.1.40)
- Ports ouverts: 3002 (frontend), 5001 (backend), 5004 (dashboard)
- Ollama GPU fonctionnel
- Self-healing interactif
- Dashboard confiance

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

capture_element_cible_vwb_20260109_151052/README.md

@@ -0,0 +1,26 @@
+# Capture d'Élément Cible VWB - Diagnostic
+Auteur : Dom, Alice, Kiro - 09 janvier 2026
+
+## Problème identifié
+La capture d'élément cible ne fonctionne pas via l'API Flask mais fonctionne en direct.
+
+## Fichiers clés
+- visual_workflow_builder/backend/app_lightweight.py : Backend Flask principal
+- visual_workflow_builder/frontend/src/components/VisualSelector/index.tsx : Composant frontend
+- tests/integration/test_capture_element_cible_vwb_09jan2026.py : Test principal
+- tests/integration/test_backend_vwb_simple_09jan2026.py : Test direct backend
+
+## Tests à exécuter
+1. Test direct : python3 tests/integration/test_backend_vwb_simple_09jan2026.py
+2. Test complet : python3 tests/integration/test_capture_element_cible_vwb_09jan2026.py
+
+## Environnement requis
+- Environnement virtuel venv_v3 avec mss, pyautogui, torch, open_clip_torch
+- Python 3.8+
+- Écran disponible pour capture
+
+## Symptômes
+- ✅ Fonctions backend directes : OK
+- ❌ Endpoints Flask /api/screen-capture : Erreur 500
+- ✅ ScreenCapturer avec venv : OK
+- ❌ ScreenCapturer via serveur Flask : Échec

capture_element_cible_vwb_20260109_151052/core/capture/__init__.py

@@ -0,0 +1,4 @@
+"""Screen capture module"""
+from .screen_capturer import ScreenCapturer
+
+__all__ = ['ScreenCapturer']

capture_element_cible_vwb_20260109_151052/core/capture/screen_capturer.py

@@ -0,0 +1,480 @@
+"""
+Screen Capture Module - Capture d'écran continue pour RPA Vision V3
+
+Fonctionnalités:
+- Capture unique ou continue
+- Buffer circulaire pour historique
+- Détection de changement d'écran
+- Support multi-moniteur
+- Optimisation mémoire
+"""
+import numpy as np
+from typing import Optional, Dict, List, Callable, Tuple
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+import threading
+import time
+import logging
+import hashlib
+from PIL import Image
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class CaptureFrame:
+    """Un frame capturé avec métadonnées"""
+    image: np.ndarray
+    timestamp: datetime
+    frame_id: int
+    hash: str
+    window_info: Optional[Dict] = None
+    changed_from_previous: bool = True
+
+
+@dataclass
+class CaptureStats:
+    """Statistiques de capture"""
+    total_captures: int = 0
+    captures_per_second: float = 0.0
+    unchanged_frames_skipped: int = 0
+    average_capture_time_ms: float = 0.0
+    buffer_size: int = 0
+    memory_usage_mb: float = 0.0
+
+
+class ScreenCapturer:
+    """
+    Capturer d'écran avancé avec mode continu.
+    
+    Modes:
+    - Single: Capture unique à la demande
+    - Continuous: Capture en boucle avec callback
+    - Buffered: Maintient un historique des N derniers frames
+    
+    Example:
+        >>> capturer = ScreenCapturer(buffer_size=10)
+        >>> # Capture unique
+        >>> frame = capturer.capture()
+        >>> # Mode continu
+        >>> capturer.start_continuous(callback=on_frame, interval_ms=500)
+        >>> # ... plus tard ...
+        >>> capturer.stop_continuous()
+    """
+    
+    def __init__(
+        self,
+        buffer_size: int = 10,
+        detect_changes: bool = True,
+        change_threshold: float = 0.02,
+        monitor_index: int = 1
+    ):
+        """
+        Initialiser le capturer.
+        
+        Args:
+            buffer_size: Nombre de frames à garder en mémoire
+            detect_changes: Détecter si l'écran a changé
+            change_threshold: Seuil de changement (0-1)
+            monitor_index: Index du moniteur (1=principal)
+        """
+        self.buffer_size = buffer_size
+        self.detect_changes = detect_changes
+        self.change_threshold = change_threshold
+        self.monitor_index = monitor_index
+        
+        # Buffer circulaire
+        self._buffer: List[CaptureFrame] = []
+        self._frame_counter = 0
+        self._last_hash: Optional[str] = None
+        
+        # Mode continu
+        self._continuous_running = False
+        self._continuous_thread: Optional[threading.Thread] = None
+        self._continuous_callback: Optional[Callable[[CaptureFrame], None]] = None
+        self._continuous_interval_ms = 500
+        self._lock = threading.Lock()
+        
+        # Stats
+        self._stats = CaptureStats()
+        self._capture_times: List[float] = []
+        
+        # Initialiser le backend de capture
+        self._init_capture_backend()
+        
+        logger.info(f"ScreenCapturer initialized (buffer={buffer_size}, changes={detect_changes})")
+    
+    def _init_capture_backend(self) -> None:
+        """Initialiser le backend de capture (mss ou pyautogui)."""
+        self.sct = None
+        self.pyautogui = None
+        self.method = None
+        
+        try:
+            import mss
+            self.sct = mss.mss()
+            self.method = "mss"
+            logger.info("Using mss for screen capture")
+        except ImportError:
+            try:
+                import pyautogui
+                self.pyautogui = pyautogui
+                self.method = "pyautogui"
+                logger.info("Using pyautogui for screen capture")
+            except ImportError:
+                raise ImportError("Neither mss nor pyautogui available for screen capture")
+    
+    # =========================================================================
+    # Capture unique
+    # =========================================================================
+    
+    def capture(self) -> Optional[np.ndarray]:
+        """
+        Capture unique de l'écran.
+        
+        Returns:
+            Screenshot as numpy array (H, W, 3) RGB ou None si erreur
+        """
+        try:
+            start_time = time.time()
+            
+            if self.method == "mss":
+                img = self._capture_mss()
+            else:
+                img = self._capture_pyautogui()
+            
+            # Stats
+            capture_time = (time.time() - start_time) * 1000
+            self._capture_times.append(capture_time)
+            if len(self._capture_times) > 100:
+                self._capture_times.pop(0)
+            self._stats.total_captures += 1
+            self._stats.average_capture_time_ms = sum(self._capture_times) / len(self._capture_times)
+            
+            return img
+            
+        except Exception as e:
+            logger.error(f"Capture failed: {e}")
+            return None
+    
+    def capture_frame(self) -> Optional[CaptureFrame]:
+        """
+        Capture avec métadonnées complètes.
+        
+        Returns:
+            CaptureFrame avec image, timestamp, hash, etc.
+        """
+        img = self.capture()
+        return self._create_frame(img)
+    
+    def _capture_frame_threaded(self, thread_sct) -> Optional[CaptureFrame]:
+        """
+        Capture avec instance mss thread-local.
+        
+        Args:
+            thread_sct: Instance mss créée dans le thread
+        
+        Returns:
+            CaptureFrame ou None
+        """
+        try:
+            start_time = time.time()
+            
+            if self.method == "mss" and thread_sct:
+                monitor_idx = self.monitor_index if len(thread_sct.monitors) > self.monitor_index else 0
+                monitor = thread_sct.monitors[monitor_idx]
+                sct_img = thread_sct.grab(monitor)
+                img = np.array(sct_img)
+                img = img[:, :, :3][:, :, ::-1]  # BGRA to RGB
+            else:
+                img = self._capture_pyautogui()
+            
+            # Stats
+            capture_time = (time.time() - start_time) * 1000
+            self._capture_times.append(capture_time)
+            if len(self._capture_times) > 100:
+                self._capture_times.pop(0)
+            self._stats.total_captures += 1
+            self._stats.average_capture_time_ms = sum(self._capture_times) / len(self._capture_times)
+            
+            return self._create_frame(img)
+            
+        except Exception as e:
+            logger.error(f"Threaded capture failed: {e}")
+            return None
+    
+    def _create_frame(self, img: Optional[np.ndarray]) -> Optional[CaptureFrame]:
+        """Créer un CaptureFrame à partir d'une image."""
+        if img is None:
+            return None
+        
+        # Calculer le hash pour détecter les changements
+        img_hash = self._compute_hash(img)
+        changed = True
+        
+        if self.detect_changes and self._last_hash:
+            changed = img_hash != self._last_hash
+            if not changed:
+                self._stats.unchanged_frames_skipped += 1
+        
+        self._last_hash = img_hash
+        self._frame_counter += 1
+        
+        frame = CaptureFrame(
+            image=img,
+            timestamp=datetime.now(),
+            frame_id=self._frame_counter,
+            hash=img_hash,
+            window_info=self.get_active_window(),
+            changed_from_previous=changed
+        )
+        
+        # Ajouter au buffer
+        self._add_to_buffer(frame)
+        
+        return frame
+    
+    def capture_screen(self) -> Optional[Image.Image]:
+        """
+        Capture et retourne une PIL Image (compatibilité avec ExecutionLoop).
+        
+        Returns:
+            PIL Image ou None
+        """
+        img = self.capture()
+        if img is None:
+            return None
+        return Image.fromarray(img)
+    
+    def _capture_mss(self) -> np.ndarray:
+        """Capture using mss."""
+        monitor_idx = self.monitor_index if len(self.sct.monitors) > self.monitor_index else 0
+        monitor = self.sct.monitors[monitor_idx]
+        sct_img = self.sct.grab(monitor)
+        
+        img = np.array(sct_img)
+        # Convert BGRA to RGB
+        img = img[:, :, :3][:, :, ::-1]
+        
+        if img.size == 0 or img.shape[0] == 0 or img.shape[1] == 0:
+            raise ValueError("Captured image has invalid dimensions")
+        
+        return img
+    
+    def _capture_pyautogui(self) -> np.ndarray:
+        """Capture using pyautogui."""
+        screenshot = self.pyautogui.screenshot()
+        img = np.array(screenshot)
+        
+        if img.size == 0 or img.shape[0] == 0 or img.shape[1] == 0:
+            raise ValueError("Captured image has invalid dimensions")
+        
+        return img
+    
+    # =========================================================================
+    # Mode continu
+    # =========================================================================
+    
+    def start_continuous(
+        self,
+        callback: Callable[[CaptureFrame], None],
+        interval_ms: int = 500,
+        skip_unchanged: bool = True
+    ) -> bool:
+        """
+        Démarrer la capture continue.
+        
+        Args:
+            callback: Fonction appelée pour chaque frame
+            interval_ms: Intervalle entre captures (ms)
+            skip_unchanged: Ne pas appeler callback si écran inchangé
+        
+        Returns:
+            True si démarré avec succès
+        """
+        with self._lock:
+            if self._continuous_running:
+                logger.warning("Continuous capture already running")
+                return False
+            
+            self._continuous_callback = callback
+            self._continuous_interval_ms = interval_ms
+            self._skip_unchanged = skip_unchanged
+            self._continuous_running = True
+            
+            self._continuous_thread = threading.Thread(
+                target=self._continuous_loop,
+                daemon=True
+            )
+            self._continuous_thread.start()
+            
+            logger.info(f"Started continuous capture (interval={interval_ms}ms)")
+            return True
+    
+    def stop_continuous(self) -> None:
+        """Arrêter la capture continue."""
+        with self._lock:
+            self._continuous_running = False
+        
+        if self._continuous_thread:
+            self._continuous_thread.join(timeout=2.0)
+            self._continuous_thread = None
+        
+        logger.info("Stopped continuous capture")
+    
+    def is_continuous_running(self) -> bool:
+        """Vérifier si la capture continue est active."""
+        return self._continuous_running
+    
+    def _continuous_loop(self) -> None:
+        """Boucle de capture continue (thread)."""
+        last_capture_time = 0
+        captures_in_second = 0
+        second_start = time.time()
+        
+        # Créer une nouvelle instance mss pour ce thread (requis pour X11)
+        thread_sct = None
+        if self.method == "mss":
+            import mss
+            thread_sct = mss.mss()
+        
+        while self._continuous_running:
+            try:
+                # Capturer avec l'instance thread-local
+                frame = self._capture_frame_threaded(thread_sct)
+                
+                if frame:
+                    # Calculer FPS
+                    captures_in_second += 1
+                    if time.time() - second_start >= 1.0:
+                        self._stats.captures_per_second = captures_in_second
+                        captures_in_second = 0
+                        second_start = time.time()
+                    
+                    # Appeler callback si changement ou si on ne skip pas
+                    if self._continuous_callback:
+                        if frame.changed_from_previous or not self._skip_unchanged:
+                            try:
+                                self._continuous_callback(frame)
+                            except Exception as e:
+                                logger.error(f"Callback error: {e}")
+                
+                # Attendre l'intervalle
+                elapsed = (time.time() - last_capture_time) * 1000
+                sleep_time = max(0, self._continuous_interval_ms - elapsed) / 1000.0
+                if sleep_time > 0:
+                    time.sleep(sleep_time)
+                last_capture_time = time.time()
+                
+            except Exception as e:
+                logger.error(f"Continuous capture error: {e}")
+                time.sleep(0.1)
+        
+        # Cleanup thread-local mss
+        if thread_sct:
+            try:
+                thread_sct.close()
+            except Exception:
+                pass
+    
+    # =========================================================================
+    # Buffer et historique
+    # =========================================================================
+    
+    def _add_to_buffer(self, frame: CaptureFrame) -> None:
+        """Ajouter un frame au buffer circulaire."""
+        with self._lock:
+            self._buffer.append(frame)
+            if len(self._buffer) > self.buffer_size:
+                self._buffer.pop(0)
+            self._stats.buffer_size = len(self._buffer)
+            
+            # Calculer utilisation mémoire
+            if self._buffer:
+                frame_size = self._buffer[0].image.nbytes / (1024 * 1024)
+                self._stats.memory_usage_mb = frame_size * len(self._buffer)
+    
+    def get_buffer(self) -> List[CaptureFrame]:
+        """Obtenir une copie du buffer."""
+        with self._lock:
+            return list(self._buffer)
+    
+    def get_last_frame(self) -> Optional[CaptureFrame]:
+        """Obtenir le dernier frame capturé."""
+        with self._lock:
+            return self._buffer[-1] if self._buffer else None
+    
+    def get_frame_by_id(self, frame_id: int) -> Optional[CaptureFrame]:
+        """Obtenir un frame par son ID."""
+        with self._lock:
+            for frame in self._buffer:
+                if frame.frame_id == frame_id:
+                    return frame
+            return None
+    
+    def clear_buffer(self) -> None:
+        """Vider le buffer."""
+        with self._lock:
+            self._buffer.clear()
+            self._stats.buffer_size = 0
+    
+    # =========================================================================
+    # Utilitaires
+    # =========================================================================
+    
+    def _compute_hash(self, img: np.ndarray) -> str:
+        """Calculer un hash rapide de l'image pour détecter les changements."""
+        # Sous-échantillonner pour un hash rapide
+        small = img[::20, ::20, :].tobytes()
+        return hashlib.md5(small).hexdigest()
+    
+    def get_active_window(self) -> Optional[Dict]:
+        """Obtenir les infos de la fenêtre active."""
+        try:
+            import pygetwindow as gw
+            active = gw.getActiveWindow()
+            if active:
+                return {
+                    'title': active.title,
+                    'x': active.left,
+                    'y': active.top,
+                    'width': active.width,
+                    'height': active.height,
+                    'app': getattr(active, '_app', 'unknown')
+                }
+        except Exception as e:
+            logger.debug(f"Could not get active window: {e}")
+        return None
+    
+    def get_screen_resolution(self) -> Tuple[int, int]:
+        """Obtenir la résolution de l'écran."""
+        if self.method == "mss":
+            monitor = self.sct.monitors[self.monitor_index]
+            return (monitor['width'], monitor['height'])
+        else:
+            size = self.pyautogui.size()
+            return (size.width, size.height)
+    
+    def get_stats(self) -> CaptureStats:
+        """Obtenir les statistiques de capture."""
+        return self._stats
+    
+    def save_frame(self, frame: CaptureFrame, path: str) -> bool:
+        """Sauvegarder un frame sur disque."""
+        try:
+            img = Image.fromarray(frame.image)
+            img.save(path)
+            return True
+        except Exception as e:
+            logger.error(f"Failed to save frame: {e}")
+            return False
+    
+    def __del__(self):
+        """Cleanup."""
+        self.stop_continuous()
+        if self.sct:
+            try:
+                self.sct.close()
+            except (AttributeError, RuntimeError, OSError):
+                pass

capture_element_cible_vwb_20260109_151052/core/embedding/__init__.py

@@ -0,0 +1,96 @@
+"""
+Embedding Module - Fusion Multi-Modale et Gestion FAISS
+
+Ce module gère la fusion d'embeddings multi-modaux et l'indexation FAISS
+pour la recherche de similarité rapide.
+"""
+
+from .fusion_engine import (
+    FusionEngine,
+    FusionConfig,
+    create_default_fusion_engine,
+    normalize_vector,
+    validate_weights
+)
+
+from .faiss_manager import (
+    FAISSManager,
+    SearchResult,
+    create_flat_index,
+    create_ivf_index
+)
+
+from .similarity import (
+    cosine_similarity,
+    euclidean_distance,
+    manhattan_distance,
+    dot_product,
+    normalize_l2,
+    normalize_l1,
+    angular_distance,
+    jaccard_similarity,
+    hamming_distance,
+    batch_cosine_similarity,
+    pairwise_cosine_similarity,
+    similarity_to_distance,
+    distance_to_similarity,
+    is_normalized,
+    compute_centroid,
+    compute_variance
+)
+
+from .state_embedding_builder import (
+    StateEmbeddingBuilder,
+    create_builder,
+    build_from_screen_state
+)
+
+from .base_embedder import EmbedderBase
+
+from .clip_embedder import (
+    CLIPEmbedder,
+    create_clip_embedder,
+    get_default_embedder
+)
+
+from .embedding_cache import (
+    EmbeddingCache,
+    PrototypeCache
+)
+
+__all__ = [
+    'FusionEngine',
+    'FusionConfig',
+    'create_default_fusion_engine',
+    'normalize_vector',
+    'validate_weights',
+    'FAISSManager',
+    'SearchResult',
+    'create_flat_index',
+    'create_ivf_index',
+    'cosine_similarity',
+    'euclidean_distance',
+    'manhattan_distance',
+    'dot_product',
+    'normalize_l2',
+    'normalize_l1',
+    'angular_distance',
+    'jaccard_similarity',
+    'hamming_distance',
+    'batch_cosine_similarity',
+    'pairwise_cosine_similarity',
+    'similarity_to_distance',
+    'distance_to_similarity',
+    'is_normalized',
+    'compute_centroid',
+    'compute_variance',
+    'StateEmbeddingBuilder',
+    'create_builder',
+    'build_from_screen_state',
+    'EmbedderBase',
+    'CLIPEmbedder',
+    'create_clip_embedder',
+    'get_default_embedder',
+    'EmbeddingCache',
+    'PrototypeCache'
+]

capture_element_cible_vwb_20260109_151052/core/embedding/base_embedder.py

@@ -0,0 +1,136 @@
+"""
+Abstract base class for embedding models.
+
+This module defines the interface that all embedding models must implement,
+ensuring consistency across different model implementations (CLIP, etc.).
+"""
+
+from abc import ABC, abstractmethod
+from typing import List
+from PIL import Image
+import numpy as np
+
+
+class EmbedderBase(ABC):
+    """
+    Abstract base class for image and text embedding models.
+    
+    All embedding models must implement this interface to ensure
+    compatibility with the state embedding system.
+    """
+    
+    @abstractmethod
+    def embed_image(self, image: Image.Image) -> np.ndarray:
+        """
+        Generate an embedding vector for a single image.
+        
+        Args:
+            image: PIL Image to embed
+            
+        Returns:
+            np.ndarray: Normalized embedding vector of shape (dimension,)
+                       The vector should be L2-normalized for cosine similarity
+                       
+        Raises:
+            ValueError: If image is invalid or cannot be processed
+            RuntimeError: If model inference fails
+        """
+        pass
+    
+    @abstractmethod
+    def embed_text(self, text: str) -> np.ndarray:
+        """
+        Generate an embedding vector for text.
+        
+        Args:
+            text: Text string to embed
+            
+        Returns:
+            np.ndarray: Normalized embedding vector of shape (dimension,)
+                       The vector should be L2-normalized for cosine similarity
+                       
+        Raises:
+            ValueError: If text is invalid
+            RuntimeError: If model inference fails
+        """
+        pass
+    
+    @abstractmethod
+    def get_dimension(self) -> int:
+        """
+        Get the dimensionality of embeddings produced by this model.
+        
+        Returns:
+            int: Embedding dimension (e.g., 512 for CLIP ViT-B/32)
+        """
+        pass
+    
+    @abstractmethod
+    def get_model_name(self) -> str:
+        """
+        Get a unique identifier for this model.
+        
+        Returns:
+            str: Model name (e.g., "clip-vit-b32")
+        """
+        pass
+    
+    def embed_image_batch(self, images: List[Image.Image]) -> np.ndarray:
+        """
+        Generate embeddings for multiple images.
+        
+        Default implementation processes images one by one.
+        Subclasses can override this for optimized batch processing.
+        
+        Args:
+            images: List of PIL Images to embed
+            
+        Returns:
+            np.ndarray: Array of embeddings with shape (len(images), dimension)
+                       Each row is a normalized embedding vector
+                       
+        Raises:
+            ValueError: If any image is invalid
+            RuntimeError: If model inference fails
+        """
+        if not images:
+            return np.array([]).reshape(0, self.get_dimension())
+        
+        embeddings = []
+        for img in images:
+            embedding = self.embed_image(img)
+            embeddings.append(embedding)
+        
+        return np.array(embeddings)
+    
+    def embed_text_batch(self, texts: List[str]) -> np.ndarray:
+        """
+        Generate embeddings for multiple texts.
+        
+        Default implementation processes texts one by one.
+        Subclasses can override this for optimized batch processing.
+        
+        Args:
+            texts: List of text strings to embed
+            
+        Returns:
+            np.ndarray: Array of embeddings with shape (len(texts), dimension)
+                       Each row is a normalized embedding vector
+                       
+        Raises:
+            ValueError: If any text is invalid
+            RuntimeError: If model inference fails
+        """
+        if not texts:
+            return np.array([]).reshape(0, self.get_dimension())
+        
+        embeddings = []
+        for text in texts:
+            embedding = self.embed_text(text)
+            embeddings.append(embedding)
+        
+        return np.array(embeddings)
+    
+    def __repr__(self) -> str:
+        """String representation of the embedder."""
+        return f"{self.__class__.__name__}(model={self.get_model_name()}, dim={self.get_dimension()})"

capture_element_cible_vwb_20260109_151052/core/embedding/clip_embedder.py

@@ -0,0 +1,292 @@
+"""
+CLIP-based embedder implementation for RPA Vision V3.
+
+This module provides a wrapper around OpenCLIP for generating image and text embeddings
+using the CLIP (Contrastive Language-Image Pre-training) model.
+"""
+
+import torch
+import numpy as np
+from PIL import Image
+from typing import List, Optional
+import logging
+
+try:
+    import open_clip
+except ImportError:
+    open_clip = None
+
+from .base_embedder import EmbedderBase
+
+
+logger = logging.getLogger(__name__)
+
+
+class CLIPEmbedder(EmbedderBase):
+    """
+    CLIP-based image and text embedder using OpenCLIP.
+    
+    This embedder uses the ViT-B/32 architecture by default, which produces
+    512-dimensional embeddings. It automatically handles GPU/CPU device selection.
+    
+    The embeddings are L2-normalized for cosine similarity calculations.
+    """
+    
+    def __init__(
+        self,
+        model_name: str = "ViT-B-32",
+        pretrained: str = "openai",
+        device: Optional[str] = None
+    ):
+        """
+        Initialize the CLIP embedder.
+        
+        Args:
+            model_name: CLIP model architecture (default: ViT-B-32)
+                       Options: ViT-B-32, ViT-B-16, ViT-L-14, etc.
+            pretrained: Pretrained weights to use (default: openai)
+            device: Device to use ('cuda', 'cpu', or None for auto-detect)
+                   Defaults to CPU to save GPU memory for VLM models
+                   
+        Raises:
+            ImportError: If open_clip is not installed
+            RuntimeError: If model loading fails
+        """
+        if open_clip is None:
+            raise ImportError(
+                "OpenCLIP is not installed. "
+                "Install it with: pip install open-clip-torch"
+            )
+        
+        # Default to CPU to save GPU for vision models (Qwen3-VL, etc.)
+        if device is None:
+            device = "cpu"
+        
+        self.model_name = model_name
+        self.pretrained = pretrained
+        self.device = device
+        self._embedding_dim = None
+        
+        # Load model
+        try:
+            logger.info(f"Loading CLIP model: {model_name} ({pretrained}) on {device}...")
+            
+            self.model, _, self.preprocess = open_clip.create_model_and_transforms(
+                model_name,
+                pretrained=pretrained,
+                device=device
+            )
+            self.model.eval()
+            
+            # Get tokenizer for text
+            self.tokenizer = open_clip.get_tokenizer(model_name)
+            
+            # Determine embedding dimension
+            with torch.no_grad():
+                dummy_image = torch.zeros(1, 3, 224, 224).to(self.device)
+                dummy_embedding = self.model.encode_image(dummy_image)
+                self._embedding_dim = dummy_embedding.shape[-1]
+            
+            logger.info(
+                f"✓ CLIP embedder loaded: {model_name} on {device}, "
+                f"dimension={self._embedding_dim}"
+            )
+            
+        except Exception as e:
+            raise RuntimeError(f"Failed to load CLIP model: {e}")
+    
+    def embed_image(self, image: Image.Image) -> np.ndarray:
+        """
+        Generate embedding for a single image.
+        
+        Args:
+            image: PIL Image to embed
+            
+        Returns:
+            np.ndarray: Normalized embedding vector of shape (dimension,)
+            
+        Raises:
+            ValueError: If image is invalid
+            RuntimeError: If embedding generation fails
+        """
+        if not isinstance(image, Image.Image):
+            raise ValueError("Input must be a PIL Image")
+        
+        try:
+            # Preprocess image
+            image_tensor = self.preprocess(image).unsqueeze(0).to(self.device)
+            
+            # Generate embedding
+            with torch.no_grad():
+                embedding = self.model.encode_image(image_tensor)
+                # L2 normalize for cosine similarity
+                embedding = embedding / embedding.norm(dim=-1, keepdim=True)
+            
+            return embedding.cpu().numpy().flatten()
+            
+        except Exception as e:
+            raise RuntimeError(f"Failed to generate image embedding: {e}")
+    
+    def embed_text(self, text: str) -> np.ndarray:
+        """
+        Generate embedding for text.
+        
+        Args:
+            text: Text string to embed
+            
+        Returns:
+            np.ndarray: Normalized embedding vector of shape (dimension,)
+            
+        Raises:
+            ValueError: If text is invalid
+            RuntimeError: If embedding generation fails
+        """
+        if not isinstance(text, str):
+            raise ValueError("Input must be a string")
+        
+        if not text.strip():
+            # Return zero vector for empty text
+            return np.zeros(self.get_dimension(), dtype=np.float32)
+        
+        try:
+            # Tokenize text
+            text_tokens = self.tokenizer([text]).to(self.device)
+            
+            # Generate embedding
+            with torch.no_grad():
+                embedding = self.model.encode_text(text_tokens)
+                # L2 normalize for cosine similarity
+                embedding = embedding / embedding.norm(dim=-1, keepdim=True)
+            
+            return embedding.cpu().numpy().flatten()
+            
+        except Exception as e:
+            raise RuntimeError(f"Failed to generate text embedding: {e}")
+    
+    def embed_image_batch(self, images: List[Image.Image]) -> np.ndarray:
+        """
+        Generate embeddings for multiple images (optimized batch processing).
+        
+        Args:
+            images: List of PIL Images to embed
+            
+        Returns:
+            np.ndarray: Array of embeddings with shape (len(images), dimension)
+            
+        Raises:
+            ValueError: If any image is invalid
+            RuntimeError: If embedding generation fails
+        """
+        if not images:
+            return np.array([]).reshape(0, self.get_dimension())
+        
+        # Validate all images
+        for i, img in enumerate(images):
+            if not isinstance(img, Image.Image):
+                raise ValueError(f"Image at index {i} is not a PIL Image")
+        
+        try:
+            # Preprocess all images
+            image_tensors = torch.stack([
+                self.preprocess(img) for img in images
+            ]).to(self.device)
+            
+            # Generate embeddings in batch
+            with torch.no_grad():
+                embeddings = self.model.encode_image(image_tensors)
+                # L2 normalize for cosine similarity
+                embeddings = embeddings / embeddings.norm(dim=-1, keepdim=True)
+            
+            return embeddings.cpu().numpy()
+            
+        except Exception as e:
+            raise RuntimeError(f"Failed to generate batch image embeddings: {e}")
+    
+    def embed_text_batch(self, texts: List[str]) -> np.ndarray:
+        """
+        Generate embeddings for multiple texts (optimized batch processing).
+        
+        Args:
+            texts: List of text strings to embed
+            
+        Returns:
+            np.ndarray: Array of embeddings with shape (len(texts), dimension)
+            
+        Raises:
+            ValueError: If any text is invalid
+            RuntimeError: If embedding generation fails
+        """
+        if not texts:
+            return np.array([]).reshape(0, self.get_dimension())
+        
+        # Validate all texts
+        for i, text in enumerate(texts):
+            if not isinstance(text, str):
+                raise ValueError(f"Text at index {i} is not a string")
+        
+        try:
+            # Handle empty texts
+            processed_texts = [text if text.strip() else " " for text in texts]
+            
+            # Tokenize all texts
+            text_tokens = self.tokenizer(processed_texts).to(self.device)
+            
+            # Generate embeddings in batch
+            with torch.no_grad():
+                embeddings = self.model.encode_text(text_tokens)
+                # L2 normalize for cosine similarity
+                embeddings = embeddings / embeddings.norm(dim=-1, keepdim=True)
+            
+            return embeddings.cpu().numpy()
+            
+        except Exception as e:
+            raise RuntimeError(f"Failed to generate batch text embeddings: {e}")
+    
+    def get_dimension(self) -> int:
+        """
+        Get the dimensionality of embeddings.
+        
+        Returns:
+            int: Embedding dimension (512 for ViT-B/32)
+        """
+        return self._embedding_dim
+    
+    def get_model_name(self) -> str:
+        """
+        Get model identifier.
+        
+        Returns:
+            str: Model name (e.g., "clip-vit-b32")
+        """
+        return f"clip-{self.model_name.lower().replace('/', '-')}"
+
+
+# ============================================================================
+# Factory functions
+# ============================================================================
+
+def create_clip_embedder(
+    model_name: str = "ViT-B-32",
+    device: Optional[str] = None
+) -> CLIPEmbedder:
+    """
+    Create a CLIP embedder with default configuration.
+    
+    Args:
+        model_name: CLIP model architecture (default: ViT-B-32)
+        device: Device to use (default: CPU)
+    
+    Returns:
+        CLIPEmbedder: Configured CLIP embedder
+    """
+    return CLIPEmbedder(model_name=model_name, device=device)
+
+
+def get_default_embedder() -> CLIPEmbedder:
+    """
+    Get the default CLIP embedder (ViT-B/32 on CPU).
+    
+    Returns:
+        CLIPEmbedder: Default embedder
+    """
+    return CLIPEmbedder()

capture_element_cible_vwb_20260109_151052/core/embedding/embedding_cache.py

@@ -0,0 +1,284 @@
+"""
+Embedding Cache - Cache LRU pour embeddings
+
+Implémente un cache LRU (Least Recently Used) pour stocker
+les embeddings en mémoire et éviter les recalculs coûteux.
+"""
+
+import logging
+from typing import Optional, Dict, Any
+from collections import OrderedDict
+import numpy as np
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+
+class EmbeddingCache:
+    """
+    Cache LRU pour embeddings.
+    
+    Stocke les embeddings les plus récemment utilisés en mémoire
+    pour éviter les recalculs et chargements depuis disque.
+    
+    Features:
+    - LRU eviction policy
+    - Taille maximale configurable
+    - Statistiques de cache (hits/misses)
+    - Invalidation sélective
+    """
+    
+    def __init__(self, max_size: int = 1000, max_memory_mb: float = 500.0):
+        """
+        Initialiser le cache.
+        
+        Args:
+            max_size: Nombre maximum d'embeddings à garder en cache
+            max_memory_mb: Mémoire maximale en MB (approximatif)
+        """
+        self.max_size = max_size
+        self.max_memory_mb = max_memory_mb
+        self.cache: OrderedDict[str, np.ndarray] = OrderedDict()
+        self.metadata: Dict[str, Dict[str, Any]] = {}
+        
+        # Statistiques
+        self.hits = 0
+        self.misses = 0
+        self.evictions = 0
+        
+        logger.info(
+            f"EmbeddingCache initialized: max_size={max_size}, "
+            f"max_memory_mb={max_memory_mb:.1f}"
+        )
+    
+    def get(self, key: str) -> Optional[np.ndarray]:
+        """
+        Récupérer un embedding du cache.
+        
+        Args:
+            key: Clé de l'embedding (embedding_id)
+            
+        Returns:
+            Vecteur numpy si trouvé, None sinon
+        """
+        if key in self.cache:
+            # Déplacer à la fin (most recently used)
+            self.cache.move_to_end(key)
+            self.hits += 1
+            logger.debug(f"Cache HIT: {key}")
+            return self.cache[key]
+        
+        self.misses += 1
+        logger.debug(f"Cache MISS: {key}")
+        return None
+    
+    def put(
+        self,
+        key: str,
+        vector: np.ndarray,
+        metadata: Optional[Dict[str, Any]] = None
+    ):
+        """
+        Ajouter un embedding au cache.
+        
+        Args:
+            key: Clé de l'embedding
+            vector: Vecteur numpy
+            metadata: Métadonnées optionnelles
+        """
+        # Si déjà présent, mettre à jour et déplacer à la fin
+        if key in self.cache:
+            self.cache.move_to_end(key)
+            self.cache[key] = vector
+            if metadata:
+                self.metadata[key] = metadata
+            return
+        
+        # Vérifier si on doit évict
+        if len(self.cache) >= self.max_size:
+            self._evict_oldest()
+        
+        # Ajouter le nouvel embedding
+        self.cache[key] = vector
+        if metadata:
+            self.metadata[key] = metadata
+        
+        logger.debug(f"Cache PUT: {key} (size: {len(self.cache)})")
+    
+    def _evict_oldest(self):
+        """Évict l'embedding le moins récemment utilisé."""
+        if not self.cache:
+            return
+        
+        # Retirer le premier élément (oldest)
+        oldest_key, _ = self.cache.popitem(last=False)
+        self.metadata.pop(oldest_key, None)
+        self.evictions += 1
+        
+        logger.debug(f"Cache EVICT: {oldest_key} (evictions: {self.evictions})")
+    
+    def invalidate(self, key: str):
+        """
+        Invalider un embedding spécifique.
+        
+        Args:
+            key: Clé de l'embedding à invalider
+        """
+        if key in self.cache:
+            del self.cache[key]
+            self.metadata.pop(key, None)
+            logger.debug(f"Cache INVALIDATE: {key}")
+    
+    def invalidate_pattern(self, pattern: str):
+        """
+        Invalider tous les embeddings dont la clé contient le pattern.
+        
+        Args:
+            pattern: Pattern à rechercher dans les clés
+        """
+        keys_to_remove = [k for k in self.cache.keys() if pattern in k]
+        for key in keys_to_remove:
+            del self.cache[key]
+            self.metadata.pop(key, None)
+        
+        if keys_to_remove:
+            logger.info(f"Cache INVALIDATE PATTERN '{pattern}': {len(keys_to_remove)} entries")
+    
+    def clear(self):
+        """Vider complètement le cache."""
+        size_before = len(self.cache)
+        self.cache.clear()
+        self.metadata.clear()
+        logger.info(f"Cache CLEAR: {size_before} entries removed")
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """
+        Obtenir les statistiques du cache.
+        
+        Returns:
+            Dict avec statistiques
+        """
+        total_requests = self.hits + self.misses
+        hit_rate = self.hits / total_requests if total_requests > 0 else 0.0
+        
+        # Estimer la mémoire utilisée
+        memory_mb = 0.0
+        for vector in self.cache.values():
+            # Taille en bytes = nombre d'éléments * taille d'un float32
+            memory_mb += vector.nbytes / (1024 * 1024)
+        
+        return {
+            "size": len(self.cache),
+            "max_size": self.max_size,
+            "hits": self.hits,
+            "misses": self.misses,
+            "evictions": self.evictions,
+            "hit_rate": hit_rate,
+            "memory_mb": memory_mb,
+            "max_memory_mb": self.max_memory_mb,
+            "memory_usage_pct": (memory_mb / self.max_memory_mb * 100) if self.max_memory_mb > 0 else 0.0
+        }
+    
+    def __len__(self) -> int:
+        """Retourne le nombre d'embeddings en cache."""
+        return len(self.cache)
+    
+    def __contains__(self, key: str) -> bool:
+        """Vérifie si une clé est dans le cache."""
+        return key in self.cache
+
+
+class PrototypeCache:
+    """
+    Cache spécialisé pour les prototypes de WorkflowNodes.
+    
+    Les prototypes sont utilisés fréquemment pour le matching,
+    donc on les garde en cache avec une politique différente.
+    """
+    
+    def __init__(self, max_size: int = 100):
+        """
+        Initialiser le cache de prototypes.
+        
+        Args:
+            max_size: Nombre maximum de prototypes à garder
+        """
+        self.max_size = max_size
+        self.cache: Dict[str, np.ndarray] = {}
+        self.access_count: Dict[str, int] = {}
+        self.last_access: Dict[str, datetime] = {}
+        
+        logger.info(f"PrototypeCache initialized: max_size={max_size}")
+    
+    def get(self, node_id: str) -> Optional[np.ndarray]:
+        """
+        Récupérer un prototype du cache.
+        
+        Args:
+            node_id: ID du WorkflowNode
+            
+        Returns:
+            Vecteur prototype si trouvé, None sinon
+        """
+        if node_id in self.cache:
+            self.access_count[node_id] = self.access_count.get(node_id, 0) + 1
+            self.last_access[node_id] = datetime.now()
+            return self.cache[node_id]
+        
+        return None
+    
+    def put(self, node_id: str, prototype: np.ndarray):
+        """
+        Ajouter un prototype au cache.
+        
+        Args:
+            node_id: ID du WorkflowNode
+            prototype: Vecteur prototype
+        """
+        # Si cache plein, évict le moins utilisé
+        if len(self.cache) >= self.max_size and node_id not in self.cache:
+            self._evict_least_used()
+        
+        self.cache[node_id] = prototype
+        self.access_count[node_id] = self.access_count.get(node_id, 0) + 1
+        self.last_access[node_id] = datetime.now()
+    
+    def _evict_least_used(self):
+        """Évict le prototype le moins utilisé."""
+        if not self.cache:
+            return
+        
+        # Trouver le moins utilisé
+        least_used = min(self.access_count.items(), key=lambda x: x[1])
+        node_id = least_used[0]
+        
+        del self.cache[node_id]
+        del self.access_count[node_id]
+        del self.last_access[node_id]
+        
+        logger.debug(f"PrototypeCache EVICT: {node_id}")
+    
+    def invalidate(self, node_id: str):
+        """Invalider un prototype spécifique."""
+        if node_id in self.cache:
+            del self.cache[node_id]
+            self.access_count.pop(node_id, None)
+            self.last_access.pop(node_id, None)
+    
+    def clear(self):
+        """Vider le cache."""
+        self.cache.clear()
+        self.access_count.clear()
+        self.last_access.clear()
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Obtenir les statistiques du cache."""
+        total_accesses = sum(self.access_count.values())
+        avg_accesses = total_accesses / len(self.cache) if self.cache else 0.0
+        
+        return {
+            "size": len(self.cache),
+            "max_size": self.max_size,
+            "total_accesses": total_accesses,
+            "avg_accesses_per_prototype": avg_accesses
+        }

capture_element_cible_vwb_20260109_151052/core/embedding/faiss_manager.py

@@ -0,0 +1,692 @@
+"""
+FAISSManager - Gestion d'Index FAISS pour Recherche de Similarité
+
+Gère l'indexation et la recherche rapide d'embeddings avec FAISS.
+Supporte sauvegarde/chargement d'index et métadonnées.
+"""
+
+import logging
+from typing import List, Dict, Optional, Tuple, Any
+from pathlib import Path
+from dataclasses import dataclass
+import numpy as np
+import json
+import pickle
+
+logger = logging.getLogger(__name__)
+
+try:
+    import faiss
+    FAISS_AVAILABLE = True
+except ImportError:
+    FAISS_AVAILABLE = False
+    logger.warning("FAISS not installed. Install with: pip install faiss-cpu")
+
+
+@dataclass
+class SearchResult:
+    """Résultat d'une recherche de similarité"""
+    embedding_id: str
+    similarity: float  # Similarité cosinus
+    distance: float  # Distance L2
+    metadata: Dict[str, Any]
+
+
+class FAISSManager:
+    """
+    Gestionnaire d'index FAISS
+    
+    Gère l'ajout, la recherche et la persistence d'embeddings avec FAISS.
+    Maintient un mapping entre IDs FAISS et métadonnées.
+    
+    Features d'optimisation:
+    - Migration automatique Flat → IVF pour >10k embeddings
+    - Entraînement automatique de l'index IVF
+    - Support GPU si disponible
+    - Optimisation périodique de l'index
+    """
+    
+    def __init__(self, 
+                 dimensions: int,
+                 index_type: str = "Flat",
+                 metric: str = "cosine",
+                 nlist: Optional[int] = None,
+                 nprobe: int = 8,
+                 use_gpu: bool = False,
+                 auto_optimize: bool = True):
+        """
+        Initialiser le gestionnaire FAISS
+        
+        Args:
+            dimensions: Nombre de dimensions des vecteurs
+            index_type: Type d'index FAISS ("Flat", "IVF", "HNSW")
+            metric: Métrique de distance ("cosine", "l2", "ip")
+            nlist: Nombre de clusters pour IVF (auto si None)
+            nprobe: Nombre de clusters à visiter lors de la recherche IVF
+            use_gpu: Utiliser GPU si disponible
+            auto_optimize: Migrer automatiquement vers IVF si >10k embeddings
+        
+        Raises:
+            ImportError: Si FAISS n'est pas installé
+        """
+        if not FAISS_AVAILABLE:
+            raise ImportError(
+                "FAISS is required but not installed. "
+                "Install with: pip install faiss-cpu"
+            )
+        
+        self.dimensions = dimensions
+        self.index_type = index_type
+        self.metric = metric
+        self.nlist = nlist
+        self.nprobe = nprobe
+        self.use_gpu = use_gpu
+        self.auto_optimize = auto_optimize
+        
+        # Mapping ID FAISS -> métadonnées
+        self.metadata_store: Dict[int, Dict[str, Any]] = {}
+        
+        # Compteur pour IDs FAISS
+        self.next_id = 0
+        
+        # Vecteurs pour entraînement IVF (si nécessaire)
+        self.training_vectors: List[np.ndarray] = []
+        self.is_trained = (index_type == "Flat")  # Flat n'a pas besoin d'entraînement
+        
+        # Seuil pour migration automatique
+        self.migration_threshold = 10000
+        
+        # GPU resources
+        self.gpu_resources = None
+        if use_gpu:
+            self._setup_gpu()
+        
+        # Créer l'index FAISS (après avoir initialisé tous les attributs)
+        self.index = self._create_index()
+    
+    def _setup_gpu(self):
+        """Configurer les ressources GPU si disponibles"""
+        try:
+            # Vérifier si GPU est disponible
+            ngpus = faiss.get_num_gpus()
+            if ngpus > 0:
+                self.gpu_resources = faiss.StandardGpuResources()
+                logger.info(f"FAISS GPU enabled: {ngpus} GPU(s) available")
+            else:
+                logger.warning("FAISS GPU requested but no GPU available, using CPU")
+                self.use_gpu = False
+        except Exception as e:
+            logger.warning(f"FAISS GPU setup failed: {e}, using CPU")
+            self.use_gpu = False
+    
+    def _calculate_nlist(self, n_vectors: int) -> int:
+        """
+        Calculer le nombre optimal de clusters pour IVF
+        
+        Règle empirique: nlist = sqrt(n_vectors)
+        Minimum: 100, Maximum: 65536
+        
+        Args:
+            n_vectors: Nombre de vecteurs dans l'index
+            
+        Returns:
+            Nombre optimal de clusters
+        """
+        if self.nlist is not None:
+            return self.nlist
+        
+        # Règle empirique
+        nlist = int(np.sqrt(n_vectors))
+        
+        # Contraintes
+        nlist = max(100, min(nlist, 65536))
+        
+        return nlist
+    
+    def _create_index(self) -> 'faiss.Index':
+        """Créer un index FAISS selon la configuration"""
+        if self.metric == "cosine":
+            # Pour cosine similarity, normaliser et utiliser inner product
+            if self.index_type == "Flat":
+                index = faiss.IndexFlatIP(self.dimensions)
+            elif self.index_type == "IVF":
+                # Calculer nlist optimal
+                nlist = self._calculate_nlist(max(1000, self.migration_threshold))
+                quantizer = faiss.IndexFlatIP(self.dimensions)
+                index = faiss.IndexIVFFlat(quantizer, self.dimensions, nlist)
+                # Configurer nprobe
+                index.nprobe = self.nprobe
+                # Activer DirectMap pour permettre reconstruct()
+                index.make_direct_map()
+            elif self.index_type == "HNSW":
+                index = faiss.IndexHNSWFlat(self.dimensions, 32)
+            else:
+                raise ValueError(f"Unknown index type: {self.index_type}")
+        
+        elif self.metric == "l2":
+            if self.index_type == "Flat":
+                index = faiss.IndexFlatL2(self.dimensions)
+            elif self.index_type == "IVF":
+                # Calculer nlist optimal
+                nlist = self._calculate_nlist(max(1000, self.migration_threshold))
+                quantizer = faiss.IndexFlatL2(self.dimensions)
+                index = faiss.IndexIVFFlat(quantizer, self.dimensions, nlist)
+                # Configurer nprobe
+                index.nprobe = self.nprobe
+                # Activer DirectMap pour permettre reconstruct()
+                index.make_direct_map()
+            elif self.index_type == "HNSW":
+                index = faiss.IndexHNSWFlat(self.dimensions, 32)
+            else:
+                raise ValueError(f"Unknown index type: {self.index_type}")
+        
+        elif self.metric == "ip":  # Inner product
+            if self.index_type == "Flat":
+                index = faiss.IndexFlatIP(self.dimensions)
+            else:
+                raise ValueError(f"Inner product only supports Flat index")
+        
+        else:
+            raise ValueError(f"Unknown metric: {self.metric}")
+        
+        # Migrer vers GPU si demandé
+        if self.use_gpu and self.gpu_resources is not None:
+            try:
+                index = faiss.index_cpu_to_gpu(self.gpu_resources, 0, index)
+            except Exception as e:
+                logger.warning(f"Failed to move index to GPU: {e}, using CPU")
+        
+        return index
+    
+    def add_embedding(self,
+                     embedding_id: str,
+                     vector: np.ndarray,
+                     metadata: Optional[Dict[str, Any]] = None) -> int:
+        """
+        Ajouter un embedding à l'index
+        
+        Args:
+            embedding_id: ID unique de l'embedding
+            vector: Vecteur d'embedding (dimensions doivent correspondre)
+            metadata: Métadonnées associées (optionnel)
+        
+        Returns:
+            ID FAISS assigné
+        
+        Raises:
+            ValueError: Si dimensions ne correspondent pas
+        """
+        if vector.shape[0] != self.dimensions:
+            raise ValueError(
+                f"Vector dimensions mismatch: expected {self.dimensions}, "
+                f"got {vector.shape[0]}"
+            )
+        
+        # Convertir en float32 d'abord
+        vector_float32 = vector.astype(np.float32)
+        
+        # Normaliser si métrique cosine
+        if self.metric == "cosine":
+            norm = np.linalg.norm(vector_float32)
+            if norm > 0:
+                vector_float32 = vector_float32 / norm
+        
+        # Reshape pour FAISS
+        vector_reshaped = vector_float32.reshape(1, -1)
+        
+        # Pour IVF, stocker vecteurs pour entraînement si pas encore entraîné
+        if self.index_type == "IVF" and not self.is_trained:
+            self.training_vectors.append(vector_float32)  # Stocker le vecteur normalisé
+            
+            # Entraîner si on a assez de vecteurs
+            if len(self.training_vectors) >= 100:
+                self._train_ivf_index()
+                # Les vecteurs d'entraînement ont déjà été ajoutés dans _train_ivf_index
+                # Ne pas ajouter à nouveau
+        elif self.is_trained:
+            # Ajouter à l'index (seulement si entraîné pour IVF ou si Flat)
+            self.index.add(vector_reshaped)
+        
+        # Stocker métadonnées
+        faiss_id = self.next_id
+        self.metadata_store[faiss_id] = {
+            "embedding_id": embedding_id,
+            "metadata": metadata or {}
+        }
+        
+        self.next_id += 1
+        
+        # Vérifier si migration automatique nécessaire
+        if self.auto_optimize and self.index_type == "Flat":
+            if self.index.ntotal >= self.migration_threshold:
+                self._migrate_to_ivf()
+        
+        return faiss_id
+    
+    def _train_ivf_index(self):
+        """Entraîner l'index IVF avec les vecteurs collectés"""
+        if self.is_trained or self.index_type != "IVF":
+            return
+        
+        if len(self.training_vectors) < 100:
+            logger.warning(f" Training IVF with only {len(self.training_vectors)} vectors")
+        
+        # Convertir en array numpy
+        training_data = np.array(self.training_vectors, dtype=np.float32)
+        
+        logger.info(f"Training IVF index with {len(self.training_vectors)} vectors...")
+        
+        # Entraîner l'index
+        self.index.train(training_data)
+        self.is_trained = True
+        
+        # Ajouter tous les vecteurs d'entraînement à l'index
+        self.index.add(training_data)
+        
+        # Libérer mémoire
+        self.training_vectors.clear()
+        
+        logger.info(f"IVF index trained successfully with nlist={self.index.nlist}")
+    
+    def _migrate_to_ivf(self):
+        """
+        Migrer automatiquement de Flat vers IVF
+        
+        Appelé automatiquement quand l'index Flat dépasse le seuil.
+        """
+        if self.index_type != "Flat":
+            return
+        
+        logger.info(f"Migrating from Flat to IVF (current size: {self.index.ntotal})...")
+        
+        # Extraire tous les vecteurs de l'index Flat
+        n_vectors = self.index.ntotal
+        vectors = np.zeros((n_vectors, self.dimensions), dtype=np.float32)
+        
+        for i in range(n_vectors):
+            vectors[i] = self.index.reconstruct(int(i))
+        
+        # Calculer nlist optimal
+        nlist = self._calculate_nlist(n_vectors)
+        
+        # Créer nouvel index IVF
+        if self.metric == "cosine":
+            quantizer = faiss.IndexFlatIP(self.dimensions)
+            new_index = faiss.IndexIVFFlat(quantizer, self.dimensions, nlist)
+        else:  # l2
+            quantizer = faiss.IndexFlatL2(self.dimensions)
+            new_index = faiss.IndexIVFFlat(quantizer, self.dimensions, nlist)
+        
+        new_index.nprobe = self.nprobe
+        new_index.make_direct_map()  # Activer DirectMap
+        
+        # Entraîner avec tous les vecteurs
+        new_index.train(vectors)
+        
+        # Ajouter tous les vecteurs
+        new_index.add(vectors)
+        
+        # Remplacer l'index
+        self.index = new_index
+        self.index_type = "IVF"
+        self.is_trained = True
+        
+        logger.info(f"Migration complete: IVF index with nlist={nlist}, nprobe={self.nprobe}")
+    
+    def optimize_index(self):
+        """
+        Optimiser l'index périodiquement
+        
+        Pour IVF: Recalculer nlist optimal et réentraîner si nécessaire
+        """
+        if self.index_type != "IVF" or not self.is_trained:
+            return
+        
+        n_vectors = self.index.ntotal
+        if n_vectors < 100:
+            return
+        
+        # Calculer nlist optimal pour la taille actuelle
+        optimal_nlist = self._calculate_nlist(n_vectors)
+        
+        # Si nlist actuel est très différent, reconstruire
+        current_nlist = self.index.nlist
+        if abs(optimal_nlist - current_nlist) / current_nlist > 0.5:
+            logger.info(f"Optimizing IVF index: {current_nlist} → {optimal_nlist} clusters")
+            
+            # Extraire tous les vecteurs
+            vectors = np.zeros((n_vectors, self.dimensions), dtype=np.float32)
+            for i in range(n_vectors):
+                vectors[i] = self.index.reconstruct(int(i))
+            
+            # Créer nouvel index avec nlist optimal
+            if self.metric == "cosine":
+                quantizer = faiss.IndexFlatIP(self.dimensions)
+                new_index = faiss.IndexIVFFlat(quantizer, self.dimensions, optimal_nlist)
+            else:
+                quantizer = faiss.IndexFlatL2(self.dimensions)
+                new_index = faiss.IndexIVFFlat(quantizer, self.dimensions, optimal_nlist)
+            
+            new_index.nprobe = self.nprobe
+            new_index.make_direct_map()  # Activer DirectMap
+            
+            # Entraîner et ajouter
+            new_index.train(vectors)
+            new_index.add(vectors)
+            
+            # Remplacer
+            self.index = new_index
+            
+            logger.info("Index optimized successfully")
+    
+    def search_similar(self,
+                      query_vector: np.ndarray,
+                      k: int = 5,
+                      min_similarity: Optional[float] = None) -> List[SearchResult]:
+        """
+        Rechercher les k embeddings les plus similaires
+        
+        Args:
+            query_vector: Vecteur de requête
+            k: Nombre de résultats à retourner
+            min_similarity: Similarité minimale (optionnel, pour cosine)
+        
+        Returns:
+            Liste de SearchResult triés par similarité décroissante
+        
+        Raises:
+            ValueError: Si dimensions ne correspondent pas
+        """
+        if query_vector.shape[0] != self.dimensions:
+            raise ValueError(
+                f"Query vector dimensions mismatch: expected {self.dimensions}, "
+                f"got {query_vector.shape[0]}"
+            )
+        
+        if self.index.ntotal == 0:
+            return []  # Index vide
+        
+        # Normaliser si métrique cosine
+        if self.metric == "cosine":
+            norm = np.linalg.norm(query_vector)
+            if norm > 0:
+                query_vector = query_vector / norm
+        
+        # Convertir en float32 et reshape
+        query_vector = query_vector.astype(np.float32).reshape(1, -1)
+        
+        # Rechercher
+        k = min(k, self.index.ntotal)  # Ne pas demander plus que disponible
+        distances, indices = self.index.search(query_vector, k)
+        
+        # Convertir en SearchResults
+        results = []
+        for dist, idx in zip(distances[0], indices[0]):
+            if idx == -1:  # Pas de résultat
+                continue
+            
+            # Récupérer métadonnées
+            meta = self.metadata_store.get(int(idx), {})
+            
+            # Convertir distance en similarité
+            if self.metric == "cosine":
+                # Pour inner product avec vecteurs normalisés, distance = similarité
+                similarity = float(dist)
+            elif self.metric == "l2":
+                # Convertir distance L2 en similarité approximative
+                similarity = 1.0 / (1.0 + float(dist))
+            else:
+                similarity = float(dist)
+            
+            # Filtrer par similarité minimale
+            if min_similarity is not None and similarity < min_similarity:
+                continue
+            
+            results.append(SearchResult(
+                embedding_id=meta.get("embedding_id", f"unknown_{idx}"),
+                similarity=similarity,
+                distance=float(dist),
+                metadata=meta.get("metadata", {})
+            ))
+        
+        return results
+    
+    def remove_embedding(self, faiss_id: int) -> bool:
+        """
+        Supprimer un embedding de l'index
+        
+        Note: FAISS ne supporte pas la suppression directe.
+        Cette méthode supprime juste les métadonnées.
+        Pour vraiment supprimer, il faut reconstruire l'index.
+        
+        Args:
+            faiss_id: ID FAISS de l'embedding
+        
+        Returns:
+            True si supprimé, False si non trouvé
+        """
+        if faiss_id in self.metadata_store:
+            del self.metadata_store[faiss_id]
+            return True
+        return False
+    
+    def get_metadata(self, faiss_id: int) -> Optional[Dict[str, Any]]:
+        """Récupérer les métadonnées d'un embedding"""
+        return self.metadata_store.get(faiss_id)
+    
+    def save(self, index_path: Path, metadata_path: Path) -> None:
+        """
+        Sauvegarder l'index et les métadonnées
+        
+        Args:
+            index_path: Chemin pour sauvegarder l'index FAISS
+            metadata_path: Chemin pour sauvegarder les métadonnées
+        """
+        # Créer répertoires si nécessaire
+        index_path.parent.mkdir(parents=True, exist_ok=True)
+        metadata_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Si GPU, ramener sur CPU avant sauvegarde
+        index_to_save = self.index
+        if self.use_gpu:
+            try:
+                index_to_save = faiss.index_gpu_to_cpu(self.index)
+            except (RuntimeError, AttributeError):
+                pass  # Déjà sur CPU ou pas de GPU
+        
+        # Sauvegarder index FAISS
+        faiss.write_index(index_to_save, str(index_path))
+        
+        # Sauvegarder métadonnées
+        metadata = {
+            "dimensions": self.dimensions,
+            "index_type": self.index_type,
+            "metric": self.metric,
+            "next_id": self.next_id,
+            "metadata_store": self.metadata_store,
+            "nlist": self.nlist,
+            "nprobe": self.nprobe,
+            "is_trained": self.is_trained,
+            "auto_optimize": self.auto_optimize
+        }
+        
+        with open(metadata_path, 'wb') as f:
+            pickle.dump(metadata, f)
+    
+    @classmethod
+    def load(cls, index_path: Path, metadata_path: Path, use_gpu: bool = False) -> 'FAISSManager':
+        """
+        Charger un index et ses métadonnées
+        
+        Args:
+            index_path: Chemin de l'index FAISS
+            metadata_path: Chemin des métadonnées
+            use_gpu: Charger sur GPU si disponible
+        
+        Returns:
+            FAISSManager chargé
+        """
+        # Charger métadonnées
+        with open(metadata_path, 'rb') as f:
+            metadata = pickle.load(f)
+        
+        # Créer instance
+        manager = cls(
+            dimensions=metadata["dimensions"],
+            index_type=metadata["index_type"],
+            metric=metadata["metric"],
+            nlist=metadata.get("nlist"),
+            nprobe=metadata.get("nprobe", 8),
+            use_gpu=use_gpu,
+            auto_optimize=metadata.get("auto_optimize", True)
+        )
+        
+        # Charger index FAISS
+        manager.index = faiss.read_index(str(index_path))
+        
+        # Migrer vers GPU si demandé
+        if use_gpu and manager.gpu_resources is not None:
+            try:
+                manager.index = faiss.index_cpu_to_gpu(manager.gpu_resources, 0, manager.index)
+            except Exception as e:
+                logger.warning(f"Failed to move loaded index to GPU: {e}")
+        
+        # Restaurer métadonnées
+        manager.next_id = metadata["next_id"]
+        manager.metadata_store = metadata["metadata_store"]
+        manager.is_trained = metadata.get("is_trained", True)
+        
+        return manager
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Récupérer statistiques de l'index"""
+        stats = {
+            "dimensions": self.dimensions,
+            "index_type": self.index_type,
+            "metric": self.metric,
+            "total_vectors": self.index.ntotal,
+            "metadata_count": len(self.metadata_store),
+            "is_trained": self.is_trained,
+            "use_gpu": self.use_gpu
+        }
+        
+        # Ajouter stats spécifiques IVF
+        if self.index_type == "IVF" and self.is_trained:
+            stats["nlist"] = self.index.nlist
+            stats["nprobe"] = self.index.nprobe
+            
+            # Calculer nlist optimal pour comparaison
+            if self.index.ntotal > 0:
+                optimal_nlist = self._calculate_nlist(self.index.ntotal)
+                stats["optimal_nlist"] = optimal_nlist
+                stats["nlist_efficiency"] = min(1.0, self.index.nlist / optimal_nlist)
+        
+        return stats
+    
+    def clear(self) -> None:
+        """
+        Vider complètement l'index + reset état d'entraînement.
+        
+        Auteur : Dom, Alice Kiro - 22 décembre 2025
+        
+        Amélioration pour FAISS Rebuild Propre:
+        - Reset complet de l'état IVF training
+        - Réinitialisation des training_vectors
+        - Gestion correcte du flag is_trained selon le type d'index
+        """
+        self.index = self._create_index()
+        self.metadata_store.clear()
+        self.next_id = 0
+        
+        # IMPORTANT: reset IVF training state
+        self.training_vectors.clear()
+        self.is_trained = (self.index_type == "Flat")
+    
+    def reindex(self, items, force_train_ivf: bool = True) -> int:
+        """
+        Reconstruit l'index à partir d'une source canonique (vecteurs).
+        
+        Auteur : Dom, Alice Kiro - 22 décembre 2025
+        
+        Stratégie FAISS Rebuild Propre: "1 prototype = 1 entrée"
+        - Clear complet avant reconstruction
+        - Ajout sécurisé avec validation des vecteurs
+        - Force training IVF même pour petits volumes
+        - Retour du nombre d'éléments indexés
+        
+        Args:
+            items: Iterable[(embedding_id: str, vector: np.ndarray, metadata: dict)]
+            force_train_ivf: Forcer l'entraînement IVF même avec peu de vecteurs
+        
+        Returns:
+            Nombre d'items indexés avec succès
+        """
+        logger.info(f"FAISS reindex started with force_train_ivf={force_train_ivf}")
+        
+        # Clear complet avant reconstruction
+        self.clear()
+        
+        count = 0
+        for embedding_id, vector, metadata in items:
+            if vector is None:
+                logger.debug(f"Skipping None vector for {embedding_id}")
+                continue
+            
+            try:
+                self.add_embedding(embedding_id, vector, metadata or {})
+                count += 1
+            except Exception as e:
+                logger.warning(f"Failed to add embedding {embedding_id}: {e}")
+                continue
+        
+        # Si IVF + petit volume, add_embedding ne déclenche pas forcément l'entraînement
+        if (self.index_type == "IVF" and force_train_ivf and 
+            (not self.is_trained) and self.training_vectors):
+            logger.info(f"Force training IVF with {len(self.training_vectors)} vectors")
+            self._train_ivf_index()
+        
+        logger.info(f"FAISS reindex completed: {count} items indexed")
+        return count
+    
+    def rebuild_index(self) -> None:
+        """
+        Reconstruire l'index depuis les métadonnées
+        
+        Utile après suppressions pour compacter l'index.
+        Note: Nécessite d'avoir les vecteurs originaux.
+        """
+        # TODO: Implémenter si nécessaire
+        # Nécessiterait de stocker les vecteurs dans metadata_store
+        raise NotImplementedError("Rebuild not yet implemented")
+
+
+# ============================================================================
+# Fonctions utilitaires
+# ============================================================================
+
+def create_flat_index(dimensions: int, metric: str = "cosine") -> FAISSManager:
+    """
+    Créer un index FAISS Flat (recherche exhaustive)
+    
+    Args:
+        dimensions: Nombre de dimensions
+        metric: Métrique ("cosine", "l2", "ip")
+    
+    Returns:
+        FAISSManager configuré
+    """
+    return FAISSManager(dimension=dimensions, index_type="Flat", metric=metric)
+
+
+def create_ivf_index(dimensions: int, metric: str = "cosine") -> FAISSManager:
+    """
+    Créer un index FAISS IVF (recherche approximative rapide)
+    
+    Args:
+        dimensions: Nombre de dimensions
+        metric: Métrique ("cosine", "l2")
+    
+    Returns:
+        FAISSManager configuré
+    """
+    return FAISSManager(dimension=dimensions, index_type="IVF", metric=metric)

capture_element_cible_vwb_20260109_151052/core/embedding/fusion_engine.py

@@ -0,0 +1,613 @@
+"""
+FusionEngine - Fusion Multi-Modale d'Embeddings
+
+Fusionne plusieurs embeddings (image, texte, titre, UI) en un seul vecteur
+avec pondération configurable et normalisation L2.
+
+Tâche 5.2: Lazy loading des embeddings avec WeakValueDictionary.
+"""
+
+from typing import Dict, List, Optional
+import numpy as np
+from dataclasses import dataclass
+import weakref
+import logging
+from pathlib import Path
+
+from ..models.state_embedding import (
+    StateEmbedding,
+    EmbeddingComponent,
+    DEFAULT_FUSION_WEIGHTS
+)
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class FusionConfig:
+    """Configuration de la fusion"""
+    method: str = "weighted"  # weighted ou concat_projection
+    normalize: bool = True  # Normaliser le vecteur final
+    weights: Dict[str, float] = None  # Poids personnalisés
+    
+    def __post_init__(self):
+        if self.weights is None:
+            self.weights = DEFAULT_FUSION_WEIGHTS.copy()
+        
+        # Valider que les poids somment à 1.0 pour weighted
+        if self.method == "weighted":
+            total = sum(self.weights.values())
+            if not (0.99 <= total <= 1.01):
+                raise ValueError(
+                    f"Weights must sum to 1.0 for weighted fusion, got {total}"
+                )
+
+
+class FusionEngine:
+    """
+    Moteur de fusion multi-modale avec lazy loading optimisé
+    
+    Fusionne des embeddings de différentes modalités (image, texte, UI)
+    en un seul vecteur représentant l'état complet de l'écran.
+    
+    Tâche 5.2: Implémente lazy loading avec WeakValueDictionary pour
+    éviter les rechargements multiples tout en permettant le garbage collection.
+    """
+    
+    def __init__(self, config: Optional[FusionConfig] = None):
+        """
+        Initialiser le moteur de fusion avec lazy loading
+        
+        Args:
+            config: Configuration de fusion (utilise config par défaut si None)
+        """
+        self.config = config or FusionConfig()
+        
+        # Tâche 5.2: Cache lazy loading avec WeakValueDictionary
+        # Permet le garbage collection automatique des embeddings non utilisés
+        self._embedding_cache: weakref.WeakValueDictionary = weakref.WeakValueDictionary()
+        self._cache_stats = {
+            'hits': 0,
+            'misses': 0,
+            'loads': 0,
+            'evictions': 0
+        }
+    
+    def fuse(self, 
+             embeddings: Dict[str, np.ndarray],
+             weights: Optional[Dict[str, float]] = None) -> np.ndarray:
+        """
+        Fusionner plusieurs embeddings en un seul vecteur
+        
+        Args:
+            embeddings: Dict {modalité: vecteur}
+                       e.g., {"image": vec1, "text": vec2, "title": vec3, "ui": vec4}
+            weights: Poids personnalisés (optionnel, utilise config par défaut)
+        
+        Returns:
+            Vecteur fusionné (normalisé si config.normalize=True)
+        
+        Raises:
+            ValueError: Si les dimensions ne correspondent pas ou poids invalides
+        """
+        if not embeddings:
+            raise ValueError("No embeddings provided for fusion")
+        
+        # Utiliser poids de config ou poids fournis
+        fusion_weights = weights or self.config.weights
+        
+        # Vérifier que toutes les modalités ont le même nombre de dimensions
+        dimensions = None
+        for modality, vector in embeddings.items():
+            if dimensions is None:
+                dimensions = vector.shape[0]
+            elif vector.shape[0] != dimensions:
+                raise ValueError(
+                    f"All embeddings must have same dimensions. "
+                    f"Expected {dimensions}, got {vector.shape[0]} for {modality}"
+                )
+        
+        if self.config.method == "weighted":
+            fused = self._fuse_weighted(embeddings, fusion_weights)
+        elif self.config.method == "concat_projection":
+            fused = self._fuse_concat_projection(embeddings, fusion_weights)
+        else:
+            raise ValueError(f"Unknown fusion method: {self.config.method}")
+        
+        # Normaliser si demandé
+        if self.config.normalize:
+            fused = self._normalize_l2(fused)
+        
+        return fused
+    
+    def _fuse_weighted(self,
+                      embeddings: Dict[str, np.ndarray],
+                      weights: Dict[str, float]) -> np.ndarray:
+        """
+        Fusion pondérée simple : somme pondérée des vecteurs
+        
+        fused = w1*v1 + w2*v2 + w3*v3 + w4*v4
+        """
+        # Initialiser vecteur résultat
+        first_vector = next(iter(embeddings.values()))
+        fused = np.zeros_like(first_vector, dtype=np.float32)
+        
+        # Somme pondérée
+        for modality, vector in embeddings.items():
+            weight = weights.get(modality, 0.0)
+            fused += weight * vector
+        
+        return fused
+    
+    def _fuse_concat_projection(self,
+                                embeddings: Dict[str, np.ndarray],
+                                weights: Dict[str, float]) -> np.ndarray:
+        """
+        Fusion par concaténation + projection
+        
+        Concatène tous les vecteurs puis projette vers dimension cible.
+        Note: Pour l'instant, on fait une simple moyenne pondérée.
+        TODO: Implémenter vraie projection avec matrice apprise.
+        """
+        # Pour l'instant, utiliser fusion pondérée
+        # Dans une version future, on pourrait apprendre une matrice de projection
+        return self._fuse_weighted(embeddings, weights)
+    
+    def _normalize_l2(self, vector: np.ndarray) -> np.ndarray:
+        """
+        Normaliser un vecteur avec norme L2
+        
+        normalized = vector / ||vector||_2
+        """
+        norm = np.linalg.norm(vector)
+        if norm < 1e-10:  # Éviter division par zéro
+            return vector
+        return vector / norm
+    
+    def create_state_embedding(self,
+                              embedding_id: str,
+                              embeddings: Dict[str, np.ndarray],
+                              vector_save_path: str,
+                              weights: Optional[Dict[str, float]] = None,
+                              metadata: Optional[Dict] = None) -> StateEmbedding:
+        """
+        Créer un StateEmbedding complet depuis des embeddings individuels
+        
+        Args:
+            embedding_id: ID unique pour cet embedding
+            embeddings: Dict {modalité: vecteur}
+            vector_save_path: Chemin où sauvegarder le vecteur fusionné
+            weights: Poids personnalisés (optionnel)
+            metadata: Métadonnées additionnelles
+        
+        Returns:
+            StateEmbedding avec vecteur fusionné sauvegardé
+        """
+        # Fusionner les embeddings
+        fused_vector = self.fuse(embeddings, weights)
+        
+        # Créer les composants
+        fusion_weights = weights or self.config.weights
+        components = {}
+        
+        for modality, vector in embeddings.items():
+            # Pour l'instant, on ne sauvegarde pas les vecteurs individuels
+            # On pourrait les sauvegarder si nécessaire
+            components[modality] = EmbeddingComponent(
+                weight=fusion_weights.get(modality, 0.0),
+                vector_id=f"{vector_save_path}_{modality}.npy",
+                source_text=None
+            )
+        
+        # Créer StateEmbedding
+        dimensions = fused_vector.shape[0]
+        state_emb = StateEmbedding(
+            embedding_id=embedding_id,
+            vector_id=vector_save_path,
+            dimensions=dimensions,
+            fusion_method=self.config.method,
+            components=components,
+            metadata=metadata or {}
+        )
+        
+        # Sauvegarder le vecteur fusionné
+        state_emb.save_vector(fused_vector)
+        
+        return state_emb
+    
+    def compute_similarity(self,
+                          emb1: StateEmbedding,
+                          emb2: StateEmbedding) -> float:
+        """
+        Calculer similarité cosinus entre deux StateEmbeddings
+        
+        Args:
+            emb1: Premier embedding
+            emb2: Deuxième embedding
+        
+        Returns:
+            Similarité cosinus dans [-1, 1]
+        """
+        return emb1.compute_similarity(emb2)
+    
+    def batch_fuse(self,
+                   batch_embeddings: List[Dict[str, np.ndarray]],
+                   weights: Optional[Dict[str, float]] = None) -> List[np.ndarray]:
+        """
+        Fusionner un batch d'embeddings en parallèle
+        
+        Args:
+            batch_embeddings: Liste de dicts {modalité: vecteur}
+            weights: Poids personnalisés (optionnel)
+        
+        Returns:
+            Liste de vecteurs fusionnés
+        """
+        return [self.fuse(embs, weights) for embs in batch_embeddings]
+    
+    def get_config(self) -> FusionConfig:
+        """Récupérer la configuration actuelle"""
+        return self.config
+    
+    def set_weights(self, weights: Dict[str, float]) -> None:
+        """
+        Mettre à jour les poids de fusion
+        
+        Args:
+            weights: Nouveaux poids
+        
+        Raises:
+            ValueError: Si les poids ne somment pas à 1.0 (pour weighted)
+        """
+        if self.config.method == "weighted":
+            total = sum(weights.values())
+            if not (0.99 <= total <= 1.01):
+                raise ValueError(
+                    f"Weights must sum to 1.0 for weighted fusion, got {total}"
+                )
+        
+        self.config.weights = weights.copy()
+
+
+# ============================================================================
+# Fonctions utilitaires
+# ============================================================================
+
+def create_default_fusion_engine() -> FusionEngine:
+    """Créer un FusionEngine avec configuration par défaut"""
+    return FusionEngine(FusionConfig())
+
+
+def normalize_vector(vector: np.ndarray) -> np.ndarray:
+    """
+    Normaliser un vecteur avec norme L2
+    
+    Args:
+        vector: Vecteur à normaliser
+    
+    Returns:
+        Vecteur normalisé
+    """
+    norm = np.linalg.norm(vector)
+    if norm < 1e-10:
+        return vector
+    return vector / norm
+
+
+def validate_weights(weights: Dict[str, float], 
+                    method: str = "weighted") -> bool:
+    """
+    Valider que les poids sont corrects
+    
+    Args:
+        weights: Poids à valider
+        method: Méthode de fusion
+    
+    Returns:
+        True si valides, False sinon
+    """
+    if method == "weighted":
+        total = sum(weights.values())
+        return 0.99 <= total <= 1.01
+    return True
+
+    def fuse_batch(
+        self,
+        embeddings_batch: List[Dict[str, np.ndarray]],
+        weights: Optional[Dict[str, float]] = None
+    ) -> np.ndarray:
+        """
+        Fusionner un batch d'embeddings en parallèle pour efficacité.
+        
+        Args:
+            embeddings_batch: Liste de dicts {modalité: vecteur}
+            weights: Poids personnalisés (optionnel)
+            
+        Returns:
+            Array numpy de shape (batch_size, embedding_dim) avec vecteurs fusionnés
+            
+        Note:
+            Cette méthode est optimisée pour traiter plusieurs embeddings
+            en une seule opération vectorisée, ce qui est plus rapide que
+            de fusionner un par un.
+        """
+        if not embeddings_batch:
+            raise ValueError("Empty batch provided")
+        
+        batch_size = len(embeddings_batch)
+        fusion_weights = weights or self.config.weights
+        
+        # Déterminer les dimensions depuis le premier élément
+        first_emb = embeddings_batch[0]
+        first_vector = next(iter(first_emb.values()))
+        embedding_dim = first_vector.shape[0]
+        
+        # Préparer le résultat
+        fused_batch = np.zeros((batch_size, embedding_dim), dtype=np.float32)
+        
+        # Traiter chaque modalité pour tout le batch
+        for modality in first_emb.keys():
+            weight = fusion_weights.get(modality, 0.0)
+            if weight == 0.0:
+                continue
+            
+            # Collecter tous les vecteurs de cette modalité
+            modality_vectors = []
+            for emb_dict in embeddings_batch:
+                if modality in emb_dict:
+                    modality_vectors.append(emb_dict[modality])
+                else:
+                    # Si modalité manquante, utiliser vecteur zéro
+                    modality_vectors.append(np.zeros(embedding_dim, dtype=np.float32))
+            
+            # Convertir en array numpy (batch_size, embedding_dim)
+            modality_batch = np.array(modality_vectors, dtype=np.float32)
+            
+            # Ajouter contribution pondérée
+            fused_batch += weight * modality_batch
+        
+        # Normaliser si demandé
+        if self.config.normalize:
+            # Normalisation L2 pour chaque vecteur du batch
+            norms = np.linalg.norm(fused_batch, axis=1, keepdims=True)
+            # Éviter division par zéro
+            norms = np.where(norms < 1e-10, 1.0, norms)
+            fused_batch = fused_batch / norms
+        
+        return fused_batch
+    
+    def create_state_embeddings_batch(
+        self,
+        embedding_ids: List[str],
+        embeddings_batch: List[Dict[str, np.ndarray]],
+        vector_save_paths: List[str],
+        weights: Optional[Dict[str, float]] = None,
+        metadata_batch: Optional[List[Dict]] = None
+    ) -> List[StateEmbedding]:
+        """
+        Créer un batch de StateEmbeddings de manière optimisée.
+        
+        Args:
+            embedding_ids: Liste des IDs uniques
+            embeddings_batch: Liste de dicts {modalité: vecteur}
+            vector_save_paths: Liste des chemins de sauvegarde
+            weights: Poids personnalisés (optionnel)
+            metadata_batch: Liste de métadonnées (optionnel)
+            
+        Returns:
+            Liste de StateEmbeddings créés
+            
+        Note:
+            Cette méthode est ~3-5x plus rapide que de créer les embeddings
+            un par un grâce au traitement vectorisé.
+        """
+        if not (len(embedding_ids) == len(embeddings_batch) == len(vector_save_paths)):
+            raise ValueError("All input lists must have the same length")
+        
+        batch_size = len(embedding_ids)
+        
+        # Fusionner tout le batch en une seule opération
+        fused_vectors = self.fuse_batch(embeddings_batch, weights)
+        
+        # Créer les StateEmbeddings
+        state_embeddings = []
+        fusion_weights = weights or self.config.weights
+        
+        for i in range(batch_size):
+            embedding_id = embedding_ids[i]
+            embeddings = embeddings_batch[i]
+            vector_save_path = vector_save_paths[i]
+            metadata = metadata_batch[i] if metadata_batch else None
+            fused_vector = fused_vectors[i]
+            
+            # Créer les composants
+            components = {}
+            for modality, vector in embeddings.items():
+                components[modality] = EmbeddingComponent(
+                    weight=fusion_weights.get(modality, 0.0),
+                    vector_id=f"{vector_save_path}_{modality}.npy",
+                    source_text=None
+                )
+            
+            # Créer StateEmbedding
+            dimensions = fused_vector.shape[0]
+            state_emb = StateEmbedding(
+                embedding_id=embedding_id,
+                vector_id=vector_save_path,
+                dimensions=dimensions,
+                fusion_method=self.config.method,
+                components=components,
+                metadata=metadata or {}
+            )
+            
+            # Sauvegarder le vecteur fusionné
+            state_emb.save_vector(fused_vector)
+            
+            state_embeddings.append(state_emb)
+        
+        return state_embeddings
+    
+    def compute_similarity_batch(
+        self,
+        query_embedding: StateEmbedding,
+        candidate_embeddings: List[StateEmbedding]
+    ) -> np.ndarray:
+        """
+        Calculer la similarité entre un embedding query et un batch de candidats.
+        
+        Args:
+            query_embedding: Embedding de requête
+            candidate_embeddings: Liste d'embeddings candidats
+            
+        Returns:
+            Array numpy de similarités (batch_size,)
+            
+        Note:
+            Utilise des opérations vectorisées pour calculer toutes les
+            similarités en une seule opération matricielle.
+        """
+        # Charger le vecteur query
+        query_vector = query_embedding.get_vector()
+        
+        # Charger tous les vecteurs candidats
+        candidate_vectors = []
+        for emb in candidate_embeddings:
+            candidate_vectors.append(emb.get_vector())
+        
+        # Convertir en matrice (batch_size, embedding_dim)
+        candidates_matrix = np.array(candidate_vectors, dtype=np.float32)
+        
+        # Calcul vectorisé : similarité cosinus = dot product (si normalisés)
+        # similarities = candidates_matrix @ query_vector
+        similarities = np.dot(candidates_matrix, query_vector)
+        
+        return similarities
+    
+    def load_embedding_lazy(self, embedding_path: str, force_reload: bool = False) -> Optional[np.ndarray]:
+        """
+        Charger un embedding avec lazy loading et cache.
+        
+        Tâche 5.2: Lazy loading des embeddings avec cache WeakValueDictionary.
+        Chargement à la demande depuis le disque avec éviction automatique.
+        
+        Args:
+            embedding_path: Chemin vers le fichier embedding (.npy)
+            force_reload: Forcer le rechargement depuis le disque
+            
+        Returns:
+            Array numpy de l'embedding ou None si erreur
+        """
+        if not embedding_path:
+            return None
+        
+        # Vérifier le cache d'abord (sauf si force_reload)
+        if not force_reload and embedding_path in self._embedding_cache:
+            self._cache_stats['hits'] += 1
+            logger.debug(f"Embedding cache hit: {Path(embedding_path).name}")
+            return self._embedding_cache[embedding_path]
+        
+        # Cache miss - charger depuis le disque
+        self._cache_stats['misses'] += 1
+        
+        try:
+            if not Path(embedding_path).exists():
+                logger.warning(f"Embedding file not found: {embedding_path}")
+                return None
+            
+            logger.debug(f"Loading embedding from disk: {Path(embedding_path).name}")
+            embedding = np.load(embedding_path)
+            
+            # Valider le format
+            if not isinstance(embedding, np.ndarray) or embedding.ndim != 1:
+                logger.error(f"Invalid embedding format in {embedding_path}")
+                return None
+            
+            # Ajouter au cache (WeakValueDictionary gère l'éviction automatique)
+            self._embedding_cache[embedding_path] = embedding
+            self._cache_stats['loads'] += 1
+            
+            logger.debug(f"Embedding loaded: {embedding.shape} from {Path(embedding_path).name}")
+            return embedding
+            
+        except Exception as e:
+            logger.error(f"Error loading embedding from {embedding_path}: {e}")
+            return None
+    
+    def fuse_with_lazy_loading(self,
+                              embedding_paths: Dict[str, str],
+                              weights: Optional[Dict[str, float]] = None) -> Optional[np.ndarray]:
+        """
+        Fusionner des embeddings avec lazy loading depuis les chemins de fichiers.
+        
+        Tâche 5.2: Version optimisée qui charge les embeddings à la demande.
+        
+        Args:
+            embedding_paths: Dict {modalité: chemin_fichier}
+            weights: Poids personnalisés (optionnel)
+            
+        Returns:
+            Vecteur fusionné ou None si erreur
+        """
+        if not embedding_paths:
+            logger.warning("No embedding paths provided for lazy fusion")
+            return None
+        
+        # Charger les embeddings avec lazy loading
+        embeddings = {}
+        for modality, path in embedding_paths.items():
+            embedding = self.load_embedding_lazy(path)
+            if embedding is not None:
+                embeddings[modality] = embedding
+            else:
+                logger.warning(f"Failed to load embedding for modality '{modality}' from {path}")
+        
+        if not embeddings:
+            logger.error("No embeddings could be loaded for fusion")
+            return None
+        
+        # Fusionner normalement
+        return self.fuse(embeddings, weights)
+    
+    def get_cache_stats(self) -> Dict[str, int]:
+        """
+        Obtenir les statistiques du cache d'embeddings.
+        
+        Returns:
+            Dict avec hits, misses, loads, cache_size
+        """
+        return {
+            **self._cache_stats,
+            'cache_size': len(self._embedding_cache)
+        }
+    
+    def clear_embedding_cache(self) -> None:
+        """
+        Vider le cache d'embeddings.
+        
+        Utile pour libérer la mémoire ou forcer le rechargement.
+        """
+        cache_size = len(self._embedding_cache)
+        self._embedding_cache.clear()
+        self._cache_stats['evictions'] += cache_size
+        logger.info(f"Cleared embedding cache ({cache_size} entries)")
+    
+    def preload_embeddings(self, embedding_paths: List[str]) -> int:
+        """
+        Précharger des embeddings dans le cache.
+        
+        Utile pour optimiser les performances en chargeant
+        les embeddings fréquemment utilisés à l'avance.
+        
+        Args:
+            embedding_paths: Liste des chemins à précharger
+            
+        Returns:
+            Nombre d'embeddings préchargés avec succès
+        """
+        loaded_count = 0
+        for path in embedding_paths:
+            if self.load_embedding_lazy(path) is not None:
+                loaded_count += 1
+        
+        logger.info(f"Preloaded {loaded_count}/{len(embedding_paths)} embeddings")
+        return loaded_count

capture_element_cible_vwb_20260109_151052/core/embedding/similarity.py

@@ -0,0 +1,388 @@
+"""
+Similarity - Calculs de Similarité et Distance
+
+Fonctions pour calculer différentes métriques de similarité et distance
+entre vecteurs d'embeddings.
+"""
+
+import numpy as np
+from typing import Union, List
+
+
+def cosine_similarity(vec1: np.ndarray, vec2: np.ndarray) -> float:
+    """
+    Calculer similarité cosinus entre deux vecteurs
+    
+    similarity = (vec1 · vec2) / (||vec1|| * ||vec2||)
+    
+    Args:
+        vec1: Premier vecteur
+        vec2: Deuxième vecteur
+    
+    Returns:
+        Similarité cosinus dans [-1, 1]
+        1 = identiques, 0 = orthogonaux, -1 = opposés
+    
+    Raises:
+        ValueError: Si dimensions ne correspondent pas
+    """
+    if vec1.shape != vec2.shape:
+        raise ValueError(
+            f"Vectors must have same shape: {vec1.shape} vs {vec2.shape}"
+        )
+    
+    # Produit scalaire
+    dot_product = np.dot(vec1, vec2)
+    
+    # Normes
+    norm1 = np.linalg.norm(vec1)
+    norm2 = np.linalg.norm(vec2)
+    
+    # Éviter division par zéro
+    if norm1 == 0 or norm2 == 0:
+        return 0.0
+    
+    # Similarité cosinus
+    similarity = dot_product / (norm1 * norm2)
+    
+    # Clamp dans [-1, 1] pour éviter erreurs numériques
+    similarity = np.clip(similarity, -1.0, 1.0)
+    
+    return float(similarity)
+
+
+def euclidean_distance(vec1: np.ndarray, vec2: np.ndarray) -> float:
+    """
+    Calculer distance euclidienne (L2) entre deux vecteurs
+    
+    distance = ||vec1 - vec2||_2 = sqrt(sum((vec1 - vec2)^2))
+    
+    Args:
+        vec1: Premier vecteur
+        vec2: Deuxième vecteur
+    
+    Returns:
+        Distance euclidienne (>= 0)
+    
+    Raises:
+        ValueError: Si dimensions ne correspondent pas
+    """
+    if vec1.shape != vec2.shape:
+        raise ValueError(
+            f"Vectors must have same shape: {vec1.shape} vs {vec2.shape}"
+        )
+    
+    return float(np.linalg.norm(vec1 - vec2))
+
+
+def manhattan_distance(vec1: np.ndarray, vec2: np.ndarray) -> float:
+    """
+    Calculer distance de Manhattan (L1) entre deux vecteurs
+    
+    distance = sum(|vec1 - vec2|)
+    
+    Args:
+        vec1: Premier vecteur
+        vec2: Deuxième vecteur
+    
+    Returns:
+        Distance de Manhattan (>= 0)
+    
+    Raises:
+        ValueError: Si dimensions ne correspondent pas
+    """
+    if vec1.shape != vec2.shape:
+        raise ValueError(
+            f"Vectors must have same shape: {vec1.shape} vs {vec2.shape}"
+        )
+    
+    return float(np.sum(np.abs(vec1 - vec2)))
+
+
+def dot_product(vec1: np.ndarray, vec2: np.ndarray) -> float:
+    """
+    Calculer produit scalaire entre deux vecteurs
+    
+    dot = vec1 · vec2 = sum(vec1 * vec2)
+    
+    Args:
+        vec1: Premier vecteur
+        vec2: Deuxième vecteur
+    
+    Returns:
+        Produit scalaire
+    
+    Raises:
+        ValueError: Si dimensions ne correspondent pas
+    """
+    if vec1.shape != vec2.shape:
+        raise ValueError(
+            f"Vectors must have same shape: {vec1.shape} vs {vec2.shape}"
+        )
+    
+    return float(np.dot(vec1, vec2))
+
+
+def normalize_l2(vector: np.ndarray, epsilon: float = 1e-10) -> np.ndarray:
+    """
+    Normaliser un vecteur avec norme L2
+    
+    normalized = vector / ||vector||_2
+    
+    Args:
+        vector: Vecteur à normaliser
+        epsilon: Valeur minimale pour éviter division par zéro
+    
+    Returns:
+        Vecteur normalisé (norme L2 = 1.0)
+    """
+    norm = np.linalg.norm(vector)
+    if norm < epsilon:
+        return vector
+    return vector / norm
+
+
+def normalize_l1(vector: np.ndarray, epsilon: float = 1e-10) -> np.ndarray:
+    """
+    Normaliser un vecteur avec norme L1
+    
+    normalized = vector / sum(|vector|)
+    
+    Args:
+        vector: Vecteur à normaliser
+        epsilon: Valeur minimale pour éviter division par zéro
+    
+    Returns:
+        Vecteur normalisé (norme L1 = 1.0)
+    """
+    norm = np.sum(np.abs(vector))
+    if norm < epsilon:
+        return vector
+    return vector / norm
+
+
+def batch_cosine_similarity(vectors: List[np.ndarray],
+                            query: np.ndarray) -> np.ndarray:
+    """
+    Calculer similarité cosinus entre une requête et un batch de vecteurs
+    
+    Args:
+        vectors: Liste de vecteurs
+        query: Vecteur de requête
+    
+    Returns:
+        Array de similarités
+    """
+    # Convertir en matrice
+    matrix = np.array(vectors)
+    
+    # Normaliser
+    matrix_norm = matrix / (np.linalg.norm(matrix, axis=1, keepdims=True) + 1e-10)
+    query_norm = query / (np.linalg.norm(query) + 1e-10)
+    
+    # Produit matriciel
+    similarities = np.dot(matrix_norm, query_norm)
+    
+    # Clamp
+    similarities = np.clip(similarities, -1.0, 1.0)
+    
+    return similarities
+
+
+def pairwise_cosine_similarity(vectors: List[np.ndarray]) -> np.ndarray:
+    """
+    Calculer matrice de similarité cosinus entre tous les vecteurs
+    
+    Args:
+        vectors: Liste de vecteurs
+    
+    Returns:
+        Matrice de similarité (n x n)
+    """
+    # Convertir en matrice
+    matrix = np.array(vectors)
+    
+    # Normaliser
+    matrix_norm = matrix / (np.linalg.norm(matrix, axis=1, keepdims=True) + 1e-10)
+    
+    # Produit matriciel
+    similarity_matrix = np.dot(matrix_norm, matrix_norm.T)
+    
+    # Clamp
+    similarity_matrix = np.clip(similarity_matrix, -1.0, 1.0)
+    
+    return similarity_matrix
+
+
+def angular_distance(vec1: np.ndarray, vec2: np.ndarray) -> float:
+    """
+    Calculer distance angulaire entre deux vecteurs
+    
+    distance = arccos(cosine_similarity) / π
+    
+    Args:
+        vec1: Premier vecteur
+        vec2: Deuxième vecteur
+    
+    Returns:
+        Distance angulaire dans [0, 1]
+    """
+    similarity = cosine_similarity(vec1, vec2)
+    angle = np.arccos(np.clip(similarity, -1.0, 1.0))
+    return float(angle / np.pi)
+
+
+def jaccard_similarity(vec1: np.ndarray, vec2: np.ndarray) -> float:
+    """
+    Calculer similarité de Jaccard pour vecteurs binaires
+    
+    similarity = |intersection| / |union|
+    
+    Args:
+        vec1: Premier vecteur binaire
+        vec2: Deuxième vecteur binaire
+    
+    Returns:
+        Similarité de Jaccard dans [0, 1]
+    """
+    if vec1.shape != vec2.shape:
+        raise ValueError(
+            f"Vectors must have same shape: {vec1.shape} vs {vec2.shape}"
+        )
+    
+    intersection = np.sum(np.logical_and(vec1, vec2))
+    union = np.sum(np.logical_or(vec1, vec2))
+    
+    if union == 0:
+        return 0.0
+    
+    return float(intersection / union)
+
+
+def hamming_distance(vec1: np.ndarray, vec2: np.ndarray) -> float:
+    """
+    Calculer distance de Hamming pour vecteurs binaires
+    
+    distance = nombre de positions différentes
+    
+    Args:
+        vec1: Premier vecteur binaire
+        vec2: Deuxième vecteur binaire
+    
+    Returns:
+        Distance de Hamming
+    """
+    if vec1.shape != vec2.shape:
+        raise ValueError(
+            f"Vectors must have same shape: {vec1.shape} vs {vec2.shape}"
+        )
+    
+    return float(np.sum(vec1 != vec2))
+
+
+# ============================================================================
+# Fonctions de conversion
+# ============================================================================
+
+def similarity_to_distance(similarity: float, 
+                          method: str = "cosine") -> float:
+    """
+    Convertir similarité en distance
+    
+    Args:
+        similarity: Valeur de similarité
+        method: Méthode ("cosine", "angular")
+    
+    Returns:
+        Distance correspondante
+    """
+    if method == "cosine":
+        # distance = 1 - similarity (pour cosine dans [0, 1])
+        return 1.0 - similarity
+    elif method == "angular":
+        # distance angulaire
+        angle = np.arccos(np.clip(similarity, -1.0, 1.0))
+        return float(angle / np.pi)
+    else:
+        raise ValueError(f"Unknown method: {method}")
+
+
+def distance_to_similarity(distance: float,
+                          method: str = "euclidean") -> float:
+    """
+    Convertir distance en similarité
+    
+    Args:
+        distance: Valeur de distance
+        method: Méthode ("euclidean", "manhattan")
+    
+    Returns:
+        Similarité correspondante dans [0, 1]
+    """
+    if method in ["euclidean", "manhattan"]:
+        # similarity = 1 / (1 + distance)
+        return 1.0 / (1.0 + distance)
+    else:
+        raise ValueError(f"Unknown method: {method}")
+
+
+# ============================================================================
+# Fonctions utilitaires
+# ============================================================================
+
+def is_normalized(vector: np.ndarray, 
+                 norm_type: str = "l2",
+                 tolerance: float = 1e-6) -> bool:
+    """
+    Vérifier si un vecteur est normalisé
+    
+    Args:
+        vector: Vecteur à vérifier
+        norm_type: Type de norme ("l2" ou "l1")
+        tolerance: Tolérance pour la vérification
+    
+    Returns:
+        True si normalisé, False sinon
+    """
+    if norm_type == "l2":
+        norm = np.linalg.norm(vector)
+    elif norm_type == "l1":
+        norm = np.sum(np.abs(vector))
+    else:
+        raise ValueError(f"Unknown norm type: {norm_type}")
+    
+    return abs(norm - 1.0) < tolerance
+
+
+def compute_centroid(vectors: List[np.ndarray]) -> np.ndarray:
+    """
+    Calculer le centroïde (moyenne) d'un ensemble de vecteurs
+    
+    Args:
+        vectors: Liste de vecteurs
+    
+    Returns:
+        Vecteur centroïde
+    """
+    if not vectors:
+        raise ValueError("Cannot compute centroid of empty list")
+    
+    matrix = np.array(vectors)
+    return np.mean(matrix, axis=0)
+
+
+def compute_variance(vectors: List[np.ndarray]) -> float:
+    """
+    Calculer la variance d'un ensemble de vecteurs
+    
+    Args:
+        vectors: Liste de vecteurs
+    
+    Returns:
+        Variance totale
+    """
+    if not vectors:
+        raise ValueError("Cannot compute variance of empty list")
+    
+    matrix = np.array(vectors)
+    return float(np.var(matrix))

capture_element_cible_vwb_20260109_151052/core/embedding/state_embedding_builder.py

@@ -0,0 +1,395 @@
+"""
+StateEmbeddingBuilder - Construction de State Embeddings Complets
+
+Construit des State Embeddings en fusionnant les embeddings de toutes les modalités
+(image, texte, titre, UI) depuis un ScreenState.
+
+Utilise OpenCLIP pour générer de vrais embeddings au lieu de vecteurs aléatoires.
+"""
+
+from typing import Dict, Optional, Any
+from pathlib import Path
+import logging
+import numpy as np
+from datetime import datetime
+from PIL import Image
+
+logger = logging.getLogger(__name__)
+
+from ..models.screen_state import ScreenState
+from ..models.state_embedding import StateEmbedding, EmbeddingComponent
+from .fusion_engine import FusionEngine, FusionConfig
+from .clip_embedder import CLIPEmbedder
+
+
+class StateEmbeddingBuilder:
+    """
+    Constructeur de State Embeddings
+    
+    Prend un ScreenState et génère un State Embedding complet en :
+    1. Calculant les embeddings pour chaque modalité (image, texte, titre, UI)
+    2. Fusionnant ces embeddings avec le FusionEngine
+    3. Sauvegardant le résultat
+    """
+    
+    def __init__(self,
+                 fusion_engine: Optional[FusionEngine] = None,
+                 embedders: Optional[Dict[str, Any]] = None,
+                 output_dir: Optional[Path] = None,
+                 use_clip: bool = True):
+        """
+        Initialiser le builder
+        
+        Args:
+            fusion_engine: Moteur de fusion (crée un par défaut si None)
+            embedders: Dict d'embedders pour chaque modalité
+                      {"image": ImageEmbedder, "text": TextEmbedder, ...}
+            output_dir: Répertoire de sortie pour les vecteurs
+            use_clip: Si True, utilise OpenCLIP pour les embeddings (recommandé)
+        """
+        self.fusion_engine = fusion_engine or FusionEngine()
+        self.output_dir = output_dir or Path("data/embeddings")
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Initialiser OpenCLIP si demandé
+        self.clip_embedder = None
+        if use_clip:
+            try:
+                logger.info("Initialisation OpenCLIP pour embeddings...")
+                self.clip_embedder = CLIPEmbedder()
+                logger.info("✓ OpenCLIP initialisé")
+            except Exception as e:
+                logger.warning(f"Impossible d'initialiser OpenCLIP: {e}")
+                logger.info("Utilisation des embedders fournis ou vecteurs par défaut")
+        
+        # Utiliser embedders fournis ou créer avec CLIP
+        if embedders:
+            self.embedders = embedders
+        elif self.clip_embedder:
+            # Utiliser CLIP pour toutes les modalités
+            self.embedders = {
+                "image": self.clip_embedder,
+                "text": self.clip_embedder,
+                "title": self.clip_embedder,
+                "ui": self.clip_embedder
+            }
+        else:
+            self.embedders = {}
+    
+    def build(self,
+             screen_state: ScreenState,
+             embedding_id: Optional[str] = None,
+             compute_embeddings: bool = True) -> StateEmbedding:
+        """
+        Construire un State Embedding depuis un ScreenState
+        
+        Args:
+            screen_state: État d'écran à embedder
+            embedding_id: ID unique (généré si None)
+            compute_embeddings: Si False, utilise des embeddings pré-calculés
+        
+        Returns:
+            StateEmbedding complet avec vecteur fusionné
+        """
+        # Générer ID si nécessaire
+        if embedding_id is None:
+            embedding_id = self._generate_embedding_id(screen_state)
+        
+        # Calculer ou récupérer embeddings pour chaque modalité
+        if compute_embeddings:
+            embeddings = self._compute_all_embeddings(screen_state)
+        else:
+            embeddings = self._load_precomputed_embeddings(screen_state)
+        
+        # Chemin de sauvegarde du vecteur fusionné
+        vector_path = self.output_dir / f"{embedding_id}.npy"
+        
+        # Créer State Embedding avec fusion
+        state_embedding = self.fusion_engine.create_state_embedding(
+            embedding_id=embedding_id,
+            embeddings=embeddings,
+            vector_save_path=str(vector_path),
+            metadata={
+                "screen_state_id": screen_state.screen_state_id,
+                "timestamp": screen_state.timestamp.isoformat(),
+                "window_title": getattr(screen_state.window, 'title', ''),
+                "created_at": datetime.now().isoformat()
+            }
+        )
+        
+        # Sauvegarder métadonnées
+        metadata_path = self.output_dir / f"{embedding_id}_metadata.json"
+        state_embedding.save_to_file(metadata_path)
+        
+        return state_embedding
+    
+    def _compute_all_embeddings(self,
+                                screen_state: ScreenState) -> Dict[str, np.ndarray]:
+        """
+        Calculer embeddings pour toutes les modalités
+        
+        Args:
+            screen_state: État d'écran
+        
+        Returns:
+            Dict {modalité: vecteur}
+        """
+        embeddings = {}
+        
+        # Image embedding (screenshot complet)
+        if "image" in self.embedders and hasattr(screen_state, 'raw'):
+            image_emb = self._compute_image_embedding(screen_state)
+            if image_emb is not None:
+                embeddings["image"] = image_emb
+        
+        # Text embedding (texte détecté)
+        if "text" in self.embedders and hasattr(screen_state, 'perception'):
+            text_emb = self._compute_text_embedding(screen_state)
+            if text_emb is not None:
+                embeddings["text"] = text_emb
+        
+        # Title embedding (titre de fenêtre)
+        if "title" in self.embedders and hasattr(screen_state, 'window'):
+            title_emb = self._compute_title_embedding(screen_state)
+            if title_emb is not None:
+                embeddings["title"] = title_emb
+        
+        # UI embedding (éléments UI)
+        if "ui" in self.embedders and hasattr(screen_state, 'ui_elements'):
+            ui_emb = self._compute_ui_embedding(screen_state)
+            if ui_emb is not None:
+                embeddings["ui"] = ui_emb
+        
+        # Si aucun embedding calculé, créer des vecteurs par défaut
+        if not embeddings:
+            # Utiliser dimensions par défaut (512)
+            default_dim = 512
+            embeddings = {
+                "image": np.random.randn(default_dim).astype(np.float32),
+                "text": np.random.randn(default_dim).astype(np.float32),
+                "title": np.random.randn(default_dim).astype(np.float32),
+                "ui": np.random.randn(default_dim).astype(np.float32)
+            }
+        
+        return embeddings
+    
+    def _compute_image_embedding(self, screen_state: ScreenState) -> Optional[np.ndarray]:
+        """Calculer embedding de l'image (screenshot) avec OpenCLIP"""
+        if "image" not in self.embedders:
+            return None
+        
+        try:
+            embedder = self.embedders["image"]
+            screenshot_path = screen_state.raw.screenshot_path
+            
+            # Charger l'image
+            image = Image.open(screenshot_path)
+            
+            # Utiliser OpenCLIP si disponible
+            if isinstance(embedder, CLIPEmbedder):
+                return embedder.embed_image(image)
+            
+            # Sinon, essayer les méthodes standard
+            if hasattr(embedder, 'embed_image'):
+                return embedder.embed_image(screenshot_path)
+            elif hasattr(embedder, 'encode_image'):
+                return embedder.encode_image(screenshot_path)
+            elif callable(embedder):
+                return embedder(screenshot_path)
+        except Exception as e:
+            logger.warning(f"Failed to compute image embedding: {e}")
+            logger.debug("Traceback:", exc_info=True)
+        
+        return None
+    
+    def _compute_text_embedding(self, screen_state: ScreenState) -> Optional[np.ndarray]:
+        """Calculer embedding du texte détecté avec OpenCLIP"""
+        if "text" not in self.embedders:
+            return None
+        
+        try:
+            embedder = self.embedders["text"]
+            
+            # Concaténer tous les textes détectés
+            texts = []
+            if hasattr(screen_state.perception, 'detected_texts'):
+                texts = screen_state.perception.detected_texts
+            
+            combined_text = " ".join(texts) if texts else ""
+            
+            if not combined_text:
+                return None
+            
+            # Utiliser OpenCLIP si disponible
+            if isinstance(embedder, CLIPEmbedder):
+                return embedder.embed_text(combined_text)
+            
+            # Sinon, essayer les méthodes standard
+            if hasattr(embedder, 'embed_text'):
+                return embedder.embed_text(combined_text)
+            elif hasattr(embedder, 'encode_text'):
+                return embedder.encode_text(combined_text)
+            elif callable(embedder):
+                return embedder(combined_text)
+        except Exception as e:
+            logger.warning(f"Failed to compute text embedding: {e}")
+        
+        return None
+    
+    def _compute_title_embedding(self, screen_state: ScreenState) -> Optional[np.ndarray]:
+        """Calculer embedding du titre de fenêtre avec OpenCLIP"""
+        if "title" not in self.embedders:
+            return None
+        
+        try:
+            embedder = self.embedders["title"]
+            title = getattr(screen_state.window, 'title', '')
+            
+            if not title:
+                return None
+            
+            # Utiliser OpenCLIP si disponible
+            if isinstance(embedder, CLIPEmbedder):
+                return embedder.embed_text(title)
+            
+            # Sinon, essayer les méthodes standard
+            if hasattr(embedder, 'embed_text'):
+                return embedder.embed_text(title)
+            elif hasattr(embedder, 'encode_text'):
+                return embedder.encode_text(title)
+            elif callable(embedder):
+                return embedder(title)
+        except Exception as e:
+            logger.warning(f"Failed to compute title embedding: {e}")
+        
+        return None
+    
+    def _compute_ui_embedding(self, screen_state: ScreenState) -> Optional[np.ndarray]:
+        """Calculer embedding moyen des éléments UI"""
+        if "ui" not in self.embedders:
+            return None
+        
+        try:
+            embedder = self.embedders["ui"]
+            ui_elements = screen_state.ui_elements
+            
+            if not ui_elements:
+                return None
+            
+            # Calculer embedding pour chaque élément UI
+            ui_embeddings = []
+            for element in ui_elements:
+                # Utiliser embedding image de l'élément si disponible
+                if hasattr(element, 'embeddings') and element.embeddings:
+                    if hasattr(element.embeddings, 'image_embedding_id'):
+                        # Charger embedding pré-calculé
+                        emb_path = Path(element.embeddings.image_embedding_id)
+                        if emb_path.exists():
+                            ui_embeddings.append(np.load(emb_path))
+            
+            # Si pas d'embeddings pré-calculés, calculer depuis labels
+            if not ui_embeddings:
+                for element in ui_elements:
+                    label = getattr(element, 'label', '')
+                    if label and hasattr(embedder, 'embed_text'):
+                        ui_embeddings.append(embedder.embed_text(label))
+            
+            # Moyenne des embeddings UI
+            if ui_embeddings:
+                return np.mean(ui_embeddings, axis=0)
+        except Exception as e:
+            logger.warning(f"Failed to compute UI embedding: {e}")
+        
+        return None
+    
+    def _load_precomputed_embeddings(self,
+                                    screen_state: ScreenState) -> Dict[str, np.ndarray]:
+        """Charger embeddings pré-calculés"""
+        # TODO: Implémenter chargement depuis cache
+        # Pour l'instant, calculer à la volée
+        return self._compute_all_embeddings(screen_state)
+    
+    def _generate_embedding_id(self, screen_state: ScreenState) -> str:
+        """Générer un ID unique pour l'embedding"""
+        timestamp = screen_state.timestamp.strftime("%Y%m%d_%H%M%S_%f")
+        return f"state_emb_{screen_state.screen_state_id}_{timestamp}"
+    
+    def batch_build(self,
+                   screen_states: list[ScreenState],
+                   compute_embeddings: bool = True) -> list[StateEmbedding]:
+        """
+        Construire plusieurs State Embeddings en batch
+        
+        Args:
+            screen_states: Liste de ScreenStates
+            compute_embeddings: Si False, utilise embeddings pré-calculés
+        
+        Returns:
+            Liste de StateEmbeddings
+        """
+        return [
+            self.build(state, compute_embeddings=compute_embeddings)
+            for state in screen_states
+        ]
+    
+    def set_embedder(self, modality: str, embedder: Any) -> None:
+        """
+        Définir un embedder pour une modalité
+        
+        Args:
+            modality: Nom de la modalité ("image", "text", "title", "ui")
+            embedder: Embedder à utiliser
+        """
+        self.embedders[modality] = embedder
+    
+    def get_embedder(self, modality: str) -> Optional[Any]:
+        """Récupérer l'embedder d'une modalité"""
+        return self.embedders.get(modality)
+    
+    def set_output_dir(self, output_dir: Path) -> None:
+        """Définir le répertoire de sortie"""
+        self.output_dir = output_dir
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+
+# ============================================================================
+# Fonctions utilitaires
+# ============================================================================
+
+def create_builder(embedders: Optional[Dict[str, Any]] = None,
+                  output_dir: Optional[Path] = None,
+                  use_clip: bool = True) -> StateEmbeddingBuilder:
+    """
+    Créer un StateEmbeddingBuilder avec configuration par défaut
+    
+    Args:
+        embedders: Dict d'embedders optionnel
+        output_dir: Répertoire de sortie optionnel
+        use_clip: Si True, utilise OpenCLIP (recommandé)
+    
+    Returns:
+        StateEmbeddingBuilder configuré avec OpenCLIP
+    """
+    return StateEmbeddingBuilder(
+        embedders=embedders,
+        output_dir=output_dir,
+        use_clip=use_clip
+    )
+
+
+def build_from_screen_state(screen_state: ScreenState,
+                           embedders: Dict[str, Any],
+                           output_dir: Path) -> StateEmbedding:
+    """
+    Fonction helper pour construire rapidement un State Embedding
+    
+    Args:
+        screen_state: État d'écran
+        embedders: Dict d'embedders
+        output_dir: Répertoire de sortie
+    
+    Returns:
+        StateEmbedding
+    """
+    builder = StateEmbeddingBuilder(embedders=embedders, output_dir=output_dir)
+    return builder.build(screen_state)

capture_element_cible_vwb_20260109_151052/docs/IMPLEMENTATION_CAPTURE_ECRAN_EMBEDDING_VWB_09JAN2026.md

@@ -0,0 +1,146 @@
+# Implémentation Capture d'Écran et Embedding Visuel - VWB
+
+**Auteur : Dom, Alice, Kiro - 09 janvier 2026**
+
+## Résumé
+
+Cette documentation décrit l'implémentation des endpoints de capture d'écran et de création d'embeddings visuels pour le Visual Workflow Builder (VWB).
+
+## Fonctionnalités Implémentées
+
+### 1. Endpoint `/api/screen-capture` (POST)
+
+Capture l'écran actuel et retourne l'image en base64.
+
+**Request Body (optionnel):**
+```json
+{
+  "format": "png",
+  "quality": 90
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "screenshot": "base64_encoded_image...",
+  "width": 1920,
+  "height": 1080,
+  "timestamp": "2026-01-09T13:41:18.123456"
+}
+```
+
+### 2. Endpoint `/api/visual-embedding` (POST)
+
+Crée un embedding visuel à partir d'une capture d'écran et d'une zone sélectionnée.
+
+**Request Body:**
+```json
+{
+  "screenshot": "base64_encoded_image...",
+  "boundingBox": {
+    "x": 100,
+    "y": 200,
+    "width": 150,
+    "height": 50
+  },
+  "stepId": "step_123"
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "embedding": [0.1, 0.2, ...],
+  "embedding_id": "emb_step_123_20260109_134118",
+  "dimension": 512,
+  "reference_image": "emb_step_123_..._ref.png",
+  "bounding_box": {
+    "x": 100,
+    "y": 200,
+    "width": 150,
+    "height": 50
+  }
+}
+```
+
+### 3. Endpoint `/api/visual-embedding/<embedding_id>` (GET)
+
+Récupère un embedding existant par son ID.
+
+### 4. Endpoint `/api/visual-embedding/<embedding_id>/image` (GET)
+
+Récupère l'image de référence d'un embedding.
+
+## Architecture Technique
+
+### Services Utilisés
+
+1. **ScreenCapturer** (`core/capture/screen_capturer.py`)
+   - Capture d'écran via `mss` ou `pyautogui`
+   - Support multi-moniteur
+   - Buffer circulaire pour historique
+
+2. **CLIPEmbedder** (`core/embedding/clip_embedder.py`)
+   - Modèle ViT-B/32 OpenAI
+   - Embeddings de dimension 512
+   - Exécution sur CPU pour économiser la mémoire GPU
+
+### Stockage des Données
+
+Les embeddings et images de référence sont stockés dans :
+```
+data/visual_embeddings/
+├── emb_step_xxx_YYYYMMDD_HHMMSS.npy      # Embedding numpy
+└── emb_step_xxx_YYYYMMDD_HHMMSS_ref.png  # Image de référence
+```
+
+## Intégration Frontend
+
+Le composant `VisualSelector` (`visual_workflow_builder/frontend/src/components/VisualSelector/index.tsx`) utilise ces endpoints pour :
+
+1. **Étape 1 - Capture** : Appel à `/api/screen-capture`
+2. **Étape 2 - Sélection** : Interface canvas pour sélectionner une zone
+3. **Étape 3 - Confirmation** : Appel à `/api/visual-embedding` pour créer l'embedding
+
+## Tests
+
+Les tests sont disponibles dans :
+- `tests/integration/test_vwb_screen_capture_api.py`
+
+### Exécution des Tests
+
+```bash
+python3 -c "
+import sys
+sys.path.insert(0, '.')
+sys.path.insert(0, 'visual_workflow_builder/backend')
+from app_lightweight import capture_screen_to_base64, create_visual_embedding
+
+# Test capture
+result = capture_screen_to_base64()
+print(f'Capture: {result[\"success\"]}')
+
+# Test embedding
+if result['success']:
+    bbox = {'x': 100, 'y': 100, 'width': 200, 'height': 100}
+    emb = create_visual_embedding(result['screenshot'], bbox, 'test')
+    print(f'Embedding: {emb[\"success\"]}')
+"
+```
+
+## Résultats de Validation
+
+- ✅ Capture d'écran fonctionnelle (1920x1080)
+- ✅ Création d'embeddings CLIP (dimension 512)
+- ✅ Sauvegarde des embeddings en fichiers .npy
+- ✅ Sauvegarde des images de référence en PNG
+- ✅ Intégration avec le frontend VisualSelector
+
+## Prochaines Étapes
+
+1. Tests d'intégration avec le frontend en conditions réelles
+2. Optimisation du temps de chargement du modèle CLIP
+3. Ajout de la recherche par similarité dans les embeddings existants

capture_element_cible_vwb_20260109_151052/scripts/start_vwb_backend.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""
+Script de démarrage du backend VWB avec environnement virtuel.
+
+Auteur : Dom, Alice, Kiro - 09 janvier 2026
+
+Ce script démarre le backend VWB en s'assurant que l'environnement virtuel
+est correctement configuré pour les dépendances de capture d'écran.
+"""
+
+import os
+import sys
+import subprocess
+from pathlib import Path
+
+def main():
+    """Démarre le backend VWB avec l'environnement virtuel."""
+    print("🚀 Démarrage du backend VWB avec environnement virtuel...")
+    
+    # Répertoire racine
+    root_dir = Path(__file__).parent.parent
+    
+    # Chemin vers l'environnement virtuel
+    venv_dir = root_dir / "venv_v3"
+    venv_python = venv_dir / "bin" / "python3"
+    
+    # Script backend
+    backend_script = root_dir / "visual_workflow_builder" / "backend" / "app_lightweight.py"
+    
+    # Vérifications
+    if not venv_dir.exists():
+        print("❌ Environnement virtuel non trouvé dans venv_v3/")
+        return False
+    
+    if not venv_python.exists():
+        print("❌ Python de l'environnement virtuel non trouvé")
+        return False
+    
+    if not backend_script.exists():
+        print("❌ Script backend non trouvé")
+        return False
+    
+    # Variables d'environnement
+    env = os.environ.copy()
+    env['PYTHONPATH'] = str(root_dir)
+    env['PORT'] = '5002'
+    
+    print(f"🐍 Python: {venv_python}")
+    print(f"📁 Script: {backend_script}")
+    print(f"🌐 Port: 5002")
+    print("")
+    
+    try:
+        # Démarrer le serveur
+        subprocess.run([
+            str(venv_python),
+            str(backend_script)
+        ], env=env, cwd=str(root_dir))
+        
+    except KeyboardInterrupt:
+        print("\n🛑 Arrêt du serveur")
+    except Exception as e:
+        print(f"❌ Erreur: {e}")
+        return False
+    
+    return True
+
+if __name__ == '__main__':
+    success = main()
+    sys.exit(0 if success else 1)

capture_element_cible_vwb_20260109_151052/tests/integration/test_backend_vwb_simple_09jan2026.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""
+Test simple du backend VWB avec environnement virtuel.
+
+Auteur : Dom, Alice, Kiro - 09 janvier 2026
+
+Ce test vérifie que le backend VWB fonctionne correctement avec l'environnement virtuel.
+"""
+
+import sys
+import subprocess
+import time
+from pathlib import Path
+
+# Ajouter le répertoire racine au path
+ROOT_DIR = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(ROOT_DIR))
+
+def test_backend_direct():
+    """Teste le backend directement avec l'environnement virtuel."""
+    print("🔍 Test direct du backend VWB...")
+    
+    # Utiliser l'environnement virtuel
+    venv_python = ROOT_DIR / "venv_v3" / "bin" / "python3"
+    
+    if not venv_python.exists():
+        print("❌ Environnement virtuel non trouvé")
+        return False
+    
+    # Test des fonctions backend directement
+    test_script = f'''
+import sys
+from pathlib import Path
+ROOT_DIR = Path("{ROOT_DIR}")
+sys.path.insert(0, str(ROOT_DIR))
+sys.path.insert(0, str(ROOT_DIR / "visual_workflow_builder" / "backend"))
+
+try:
+    from app_lightweight import capture_screen_to_base64, create_visual_embedding
+    
+    print("🔄 Test de capture d'écran...")
+    result = capture_screen_to_base64()
+    
+    if result['success']:
+        print(f"✅ Capture réussie - {{result['width']}}x{{result['height']}}")
+        
+        # Test d'embedding
+        print("🔄 Test d'embedding...")
+        bounding_box = {{'x': 100, 'y': 100, 'width': 200, 'height': 150}}
+        
+        embedding_result = create_visual_embedding(
+            result['screenshot'], 
+            bounding_box, 
+            'test_backend_simple'
+        )
+        
+        if embedding_result['success']:
+            print(f"✅ Embedding créé - ID: {{embedding_result['embedding_id']}}")
+            print("✅ BACKEND FONCTIONNE CORRECTEMENT")
+        else:
+            print(f"❌ Erreur embedding: {{embedding_result['error']}}")
+    else:
+        print(f"❌ Erreur capture: {{result['error']}}")
+        
+except Exception as e:
+    print(f"❌ Erreur: {{e}}")
+    import traceback
+    traceback.print_exc()
+'''
+    
+    try:
+        # Exécuter le test avec l'environnement virtuel
+        result = subprocess.run(
+            [str(venv_python), "-c", test_script],
+            capture_output=True,
+            text=True,
+            cwd=str(ROOT_DIR)
+        )
+        
+        print("Sortie du test:")
+        print(result.stdout)
+        
+        if result.stderr:
+            print("Erreurs:")
+            print(result.stderr)
+        
+        return "BACKEND FONCTIONNE CORRECTEMENT" in result.stdout
+        
+    except Exception as e:
+        print(f"❌ Erreur lors du test: {e}")
+        return False
+
+def main():
+    """Fonction principale de test."""
+    print("=" * 60)
+    print(" TEST BACKEND VWB SIMPLE")
+    print("=" * 60)
+    print("Auteur : Dom, Alice, Kiro - 09 janvier 2026")
+    print("")
+    
+    success = test_backend_direct()
+    
+    if success:
+        print("\n✅ Le backend VWB fonctionne correctement !")
+    else:
+        print("\n❌ Le backend VWB ne fonctionne pas correctement")
+    
+    return success
+
+if __name__ == '__main__':
+    success = main()
+    sys.exit(0 if success else 1)

capture_element_cible_vwb_20260109_151052/tests/integration/test_capture_element_cible_vwb_09jan2026.py

@@ -0,0 +1,297 @@
+#!/usr/bin/env python3
+"""
+Test de la capture d'élément cible pour le Visual Workflow Builder.
+
+Auteur : Dom, Alice, Kiro - 09 janvier 2026
+
+Ce test vérifie que le système de capture d'élément cible fonctionne correctement
+en testant les endpoints /api/screen-capture et /api/visual-embedding.
+"""
+
+import sys
+import os
+import time
+import requests
+import json
+import subprocess
+from pathlib import Path
+
+# Ajouter le répertoire racine au path
+ROOT_DIR = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(ROOT_DIR))
+
+def start_backend_server():
+    """Démarre le serveur backend VWB avec l'environnement virtuel."""
+    print("🚀 Démarrage du serveur backend VWB...")
+    
+    # Utiliser l'environnement virtuel
+    venv_python = ROOT_DIR / "venv_v3" / "bin" / "python3"
+    backend_script = ROOT_DIR / "visual_workflow_builder" / "backend" / "app_lightweight.py"
+    
+    if not venv_python.exists():
+        print("❌ Environnement virtuel non trouvé")
+        return None
+    
+    if not backend_script.exists():
+        print("❌ Script backend non trouvé")
+        return None
+    
+    # Variables d'environnement pour le serveur
+    env = os.environ.copy()
+    env['PYTHONPATH'] = str(ROOT_DIR)
+    env['PORT'] = '5002'
+    
+    print(f"🐍 Utilisation de: {venv_python}")
+    print(f"📁 Script: {backend_script}")
+    
+    # Démarrer le serveur en arrière-plan avec l'environnement virtuel
+    process = subprocess.Popen(
+        [str(venv_python), str(backend_script)],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        cwd=str(ROOT_DIR),
+        env=env
+    )
+    
+    # Attendre que le serveur démarre
+    print("⏳ Attente du démarrage du serveur...")
+    time.sleep(10)  # Plus de temps pour l'initialisation CLIP
+    
+    return process
+
+def test_health_endpoint():
+    """Teste l'endpoint de santé."""
+    print("\n🔍 Test de l'endpoint de santé...")
+    
+    try:
+        response = requests.get("http://localhost:5002/health", timeout=5)
+        if response.status_code == 200:
+            data = response.json()
+            print(f"✅ Serveur en bonne santé - Version: {data.get('version', 'inconnue')}")
+            
+            # Vérifier les fonctionnalités disponibles
+            features = data.get('features', {})
+            if features.get('screen_capture'):
+                print("✅ Capture d'écran disponible")
+            else:
+                print("⚠️ Capture d'écran non disponible")
+                
+            if features.get('visual_embedding'):
+                print("✅ Embedding visuel disponible")
+            else:
+                print("⚠️ Embedding visuel non disponible")
+                
+            return True
+        else:
+            print(f"❌ Erreur health check: {response.status_code}")
+            return False
+    except Exception as e:
+        print(f"❌ Erreur connexion serveur: {e}")
+        return False
+
+def test_screen_capture_endpoint():
+    """Teste l'endpoint de capture d'écran."""
+    print("\n📷 Test de l'endpoint de capture d'écran...")
+    
+    try:
+        response = requests.post(
+            "http://localhost:5002/api/screen-capture",
+            json={"format": "png", "quality": 90},
+            timeout=15
+        )
+        
+        if response.status_code == 200:
+            data = response.json()
+            if data.get('success'):
+                print(f"✅ Capture réussie - {data['width']}x{data['height']}")
+                print(f"📊 Taille base64: {len(data['screenshot'])} caractères")
+                print(f"⏰ Timestamp: {data.get('timestamp', 'N/A')}")
+                return data['screenshot']
+            else:
+                print(f"❌ Erreur capture: {data.get('error', 'inconnue')}")
+                return None
+        else:
+            print(f"❌ Erreur HTTP: {response.status_code}")
+            print(f"Réponse: {response.text}")
+            return None
+            
+    except Exception as e:
+        print(f"❌ Erreur lors de la capture: {e}")
+        return None
+
+def test_visual_embedding_endpoint(screenshot_base64):
+    """Teste l'endpoint de création d'embedding visuel."""
+    print("\n🎯 Test de l'endpoint d'embedding visuel...")
+    
+    if not screenshot_base64:
+        print("❌ Pas de capture d'écran disponible")
+        return False
+    
+    try:
+        # Zone de test au centre de l'écran
+        bounding_box = {
+            "x": 500,
+            "y": 300,
+            "width": 200,
+            "height": 150
+        }
+        
+        payload = {
+            "screenshot": screenshot_base64,
+            "boundingBox": bounding_box,
+            "stepId": "test_capture_element_cible"
+        }
+        
+        response = requests.post(
+            "http://localhost:5002/api/visual-embedding",
+            json=payload,
+            timeout=20  # Plus de temps pour CLIP
+        )
+        
+        if response.status_code == 200:
+            data = response.json()
+            if data.get('success'):
+                print(f"✅ Embedding créé - ID: {data['embedding_id']}")
+                print(f"📐 Dimension: {data['dimension']}")
+                print(f"🖼️  Image de référence: {data['reference_image']}")
+                print(f"📦 Zone traitée: {data['bounding_box']}")
+                
+                # Vérifier que les fichiers ont été créés
+                embeddings_dir = ROOT_DIR / "data" / "visual_embeddings"
+                embedding_file = embeddings_dir / f"{data['embedding_id']}.npy"
+                reference_file = embeddings_dir / f"{data['embedding_id']}_ref.png"
+                
+                if embedding_file.exists() and reference_file.exists():
+                    print(f"✅ Fichiers sauvegardés correctement")
+                    print(f"   - Embedding: {embedding_file}")
+                    print(f"   - Référence: {reference_file}")
+                    return True
+                else:
+                    print(f"❌ Fichiers non créés")
+                    return False
+            else:
+                print(f"❌ Erreur embedding: {data.get('error', 'inconnue')}")
+                return False
+        else:
+            print(f"❌ Erreur HTTP: {response.status_code}")
+            print(f"Réponse: {response.text}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Erreur lors de l'embedding: {e}")
+        return False
+
+def test_frontend_integration():
+    """Teste l'intégration avec le frontend."""
+    print("\n🌐 Test d'intégration frontend...")
+    
+    # Vérifier que le composant VisualSelector existe
+    visual_selector_path = ROOT_DIR / "visual_workflow_builder" / "frontend" / "src" / "components" / "VisualSelector" / "index.tsx"
+    
+    if visual_selector_path.exists():
+        print("✅ Composant VisualSelector trouvé")
+        
+        # Lire le contenu pour vérifier les endpoints
+        content = visual_selector_path.read_text()
+        
+        if "/api/screen-capture" in content and "/api/visual-embedding" in content:
+            print("✅ Endpoints API correctement référencés dans le frontend")
+            
+            # Vérifier les types TypeScript
+            types_path = ROOT_DIR / "visual_workflow_builder" / "frontend" / "src" / "types" / "index.ts"
+            if types_path.exists():
+                types_content = types_path.read_text()
+                if "VisualSelection" in types_content and "BoundingBox" in types_content:
+                    print("✅ Types TypeScript définis correctement")
+                    return True
+                else:
+                    print("⚠️ Types TypeScript manquants")
+                    return False
+            else:
+                print("⚠️ Fichier de types non trouvé")
+                return False
+        else:
+            print("❌ Endpoints API manquants dans le frontend")
+            return False
+    else:
+        print("❌ Composant VisualSelector non trouvé")
+        return False
+
+def test_canvas_integration():
+    """Teste l'intégration avec le canvas."""
+    print("\n🎨 Test d'intégration canvas...")
+    
+    # Vérifier que le canvas peut afficher l'image
+    canvas_path = ROOT_DIR / "visual_workflow_builder" / "frontend" / "src" / "components" / "Canvas"
+    
+    if canvas_path.exists():
+        print("✅ Répertoire Canvas trouvé")
+        
+        # Vérifier les fichiers du canvas
+        step_node_path = canvas_path / "StepNode.tsx"
+        if step_node_path.exists():
+            print("✅ Composant StepNode trouvé")
+            return True
+        else:
+            print("⚠️ Composant StepNode non trouvé")
+            return False
+    else:
+        print("❌ Répertoire Canvas non trouvé")
+        return False
+
+def main():
+    """Fonction principale de test."""
+    print("=" * 60)
+    print(" TEST CAPTURE D'ÉLÉMENT CIBLE - VWB")
+    print("=" * 60)
+    print("Auteur : Dom, Alice, Kiro - 09 janvier 2026")
+    print("")
+    
+    # Démarrer le serveur backend
+    server_process = start_backend_server()
+    
+    if not server_process:
+        print("❌ Impossible de démarrer le serveur backend")
+        return False
+    
+    try:
+        # Test 1: Health check
+        if not test_health_endpoint():
+            return False
+        
+        # Test 2: Capture d'écran
+        screenshot = test_screen_capture_endpoint()
+        if not screenshot:
+            return False
+        
+        # Test 3: Embedding visuel
+        if not test_visual_embedding_endpoint(screenshot):
+            return False
+        
+        # Test 4: Intégration frontend
+        if not test_frontend_integration():
+            return False
+        
+        # Test 5: Intégration canvas
+        if not test_canvas_integration():
+            return False
+        
+        print("\n" + "=" * 60)
+        print("🎉 TOUS LES TESTS SONT PASSÉS AVEC SUCCÈS !")
+        print("✅ La capture d'élément cible fonctionne correctement")
+        print("✅ Backend et frontend intégrés")
+        print("✅ Fichiers d'embedding sauvegardés")
+        print("=" * 60)
+        
+        return True
+        
+    finally:
+        # Arrêter le serveur
+        if server_process:
+            print("\n🛑 Arrêt du serveur backend...")
+            server_process.terminate()
+            server_process.wait()
+
+if __name__ == '__main__':
+    success = main()
+    sys.exit(0 if success else 1)

capture_element_cible_vwb_20260109_151052/tests/integration/test_debug_backend_vwb_09jan2026.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+"""
+Test de debug du backend VWB pour identifier le problème de capture.
+
+Auteur : Dom, Alice, Kiro - 09 janvier 2026
+
+Ce test examine les logs du serveur pour identifier pourquoi la capture échoue.
+"""
+
+import sys
+import os
+import time
+import requests
+import subprocess
+from pathlib import Path
+
+# Ajouter le répertoire racine au path
+ROOT_DIR = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(ROOT_DIR))
+
+def start_backend_server_debug():
+    """Démarre le serveur backend VWB en mode debug."""
+    print("🚀 Démarrage du serveur backend VWB en mode debug...")
+    
+    # Utiliser l'environnement virtuel
+    venv_python = ROOT_DIR / "venv_v3" / "bin" / "python3"
+    backend_script = ROOT_DIR / "visual_workflow_builder" / "backend" / "app_lightweight.py"
+    
+    # Variables d'environnement pour le serveur
+    env = os.environ.copy()
+    env['PYTHONPATH'] = str(ROOT_DIR)
+    env['PORT'] = '5002'
+    
+    print(f"🐍 Utilisation de: {venv_python}")
+    print(f"📁 Script: {backend_script}")
+    
+    # Démarrer le serveur en mode interactif pour voir les logs
+    process = subprocess.Popen(
+        [str(venv_python), str(backend_script)],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,  # Rediriger stderr vers stdout
+        cwd=str(ROOT_DIR),
+        env=env,
+        text=True,
+        bufsize=1,
+        universal_newlines=True
+    )
+    
+    # Attendre que le serveur démarre et afficher les logs
+    print("⏳ Attente du démarrage du serveur...")
+    time.sleep(3)
+    
+    # Lire les logs de démarrage
+    print("\n📋 Logs de démarrage du serveur:")
+    print("-" * 40)
+    
+    # Lire quelques lignes de sortie
+    for i in range(20):  # Lire les 20 premières lignes
+        try:
+            line = process.stdout.readline()
+            if line:
+                print(f"LOG: {line.strip()}")
+            else:
+                break
+        except:
+            break
+    
+    print("-" * 40)
+    
+    return process
+
+def test_capture_with_logs(server_process):
+    """Teste la capture en surveillant les logs."""
+    print("\n📷 Test de capture avec surveillance des logs...")
+    
+    # Faire une requête de capture
+    try:
+        print("🔄 Envoi de la requête de capture...")
+        response = requests.post(
+            "http://localhost:5002/api/screen-capture",
+            json={"format": "png", "quality": 90},
+            timeout=15
+        )
+        
+        print(f"📊 Statut de réponse: {response.status_code}")
+        
+        # Lire les logs pendant la requête
+        print("\n📋 Logs pendant la capture:")
+        print("-" * 40)
+        
+        # Lire quelques lignes supplémentaires
+        for i in range(10):
+            try:
+                line = server_process.stdout.readline()
+                if line:
+                    print(f"LOG: {line.strip()}")
+                else:
+                    break
+            except:
+                break
+        
+        print("-" * 40)
+        
+        if response.status_code == 200:
+            data = response.json()
+            if data.get('success'):
+                print(f"✅ Capture réussie - {data['width']}x{data['height']}")
+                return True
+            else:
+                print(f"❌ Erreur capture: {data.get('error', 'inconnue')}")
+                return False
+        else:
+            print(f"❌ Erreur HTTP: {response.status_code}")
+            print(f"Réponse: {response.text}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Erreur lors de la capture: {e}")
+        return False
+
+def main():
+    """Fonction principale de test."""
+    print("=" * 60)
+    print(" TEST DEBUG BACKEND VWB")
+    print("=" * 60)
+    print("Auteur : Dom, Alice, Kiro - 09 janvier 2026")
+    print("")
+    
+    # Démarrer le serveur backend
+    server_process = start_backend_server_debug()
+    
+    if not server_process:
+        print("❌ Impossible de démarrer le serveur backend")
+        return False
+    
+    try:
+        # Attendre un peu plus pour le démarrage complet
+        time.sleep(5)
+        
+        # Tester la capture avec logs
+        success = test_capture_with_logs(server_process)
+        
+        return success
+        
+    finally:
+        # Arrêter le serveur
+        if server_process:
+            print("\n🛑 Arrêt du serveur backend...")
+            server_process.terminate()
+            server_process.wait()
+
+if __name__ == '__main__':
+    success = main()
+    sys.exit(0 if success else 1)

capture_element_cible_vwb_20260109_151052/tests/integration/test_vwb_screen_capture_api.py

@@ -0,0 +1,257 @@
+#!/usr/bin/env python3
+"""
+Tests d'intégration pour l'API de capture d'écran et d'embedding visuel du VWB.
+
+Auteur : Dom, Alice, Kiro - 09 janvier 2026
+
+Ces tests vérifient que les endpoints /api/screen-capture et /api/visual-embedding
+fonctionnent correctement avec le système de capture réel.
+"""
+
+import pytest
+import sys
+import os
+from pathlib import Path
+
+# Ajouter le répertoire racine au path
+ROOT_DIR = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(ROOT_DIR))
+
+
+class TestScreenCaptureService:
+    """Tests pour le service de capture d'écran."""
+    
+    def test_screen_capturer_import(self):
+        """Vérifie que le ScreenCapturer peut être importé."""
+        try:
+            from core.capture import ScreenCapturer
+            assert ScreenCapturer is not None
+        except ImportError as e:
+            pytest.skip(f"ScreenCapturer non disponible: {e}")
+    
+    def test_screen_capturer_initialization(self):
+        """Vérifie que le ScreenCapturer peut être initialisé."""
+        try:
+            from core.capture import ScreenCapturer
+            capturer = ScreenCapturer(buffer_size=2, detect_changes=False)
+            assert capturer is not None
+            assert capturer.method in ["mss", "pyautogui"]
+        except ImportError as e:
+            pytest.skip(f"ScreenCapturer non disponible: {e}")
+        except Exception as e:
+            # Peut échouer sur un serveur sans écran
+            pytest.skip(f"Capture d'écran non disponible: {e}")
+    
+    def test_screen_capture_returns_array(self):
+        """Vérifie que la capture retourne un tableau numpy valide."""
+        try:
+            from core.capture import ScreenCapturer
+            import numpy as np
+            
+            capturer = ScreenCapturer(buffer_size=2, detect_changes=False)
+            img = capturer.capture()
+            
+            if img is None:
+                pytest.skip("Capture d'écran non disponible (pas d'écran)")
+            
+            assert isinstance(img, np.ndarray)
+            assert len(img.shape) == 3  # (H, W, C)
+            assert img.shape[2] == 3    # RGB
+            assert img.shape[0] > 0     # Hauteur > 0
+            assert img.shape[1] > 0     # Largeur > 0
+            
+        except ImportError as e:
+            pytest.skip(f"Dépendances non disponibles: {e}")
+        except Exception as e:
+            pytest.skip(f"Capture d'écran non disponible: {e}")
+
+
+class TestCLIPEmbedderService:
+    """Tests pour le service d'embedding CLIP."""
+    
+    def test_clip_embedder_import(self):
+        """Vérifie que le CLIPEmbedder peut être importé."""
+        try:
+            from core.embedding import create_clip_embedder
+            assert create_clip_embedder is not None
+        except ImportError as e:
+            pytest.skip(f"CLIPEmbedder non disponible: {e}")
+    
+    def test_clip_embedder_initialization(self):
+        """Vérifie que le CLIPEmbedder peut être initialisé."""
+        try:
+            from core.embedding import create_clip_embedder
+            embedder = create_clip_embedder(device="cpu")
+            assert embedder is not None
+            assert embedder.get_dimension() > 0
+        except ImportError as e:
+            pytest.skip(f"CLIPEmbedder non disponible: {e}")
+        except Exception as e:
+            pytest.skip(f"Initialisation CLIP échouée: {e}")
+    
+    def test_clip_embedding_dimension(self):
+        """Vérifie que les embeddings ont la bonne dimension."""
+        try:
+            from core.embedding import create_clip_embedder
+            from PIL import Image
+            import numpy as np
+            
+            embedder = create_clip_embedder(device="cpu")
+            
+            # Créer une image de test
+            test_image = Image.fromarray(
+                np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)
+            )
+            
+            embedding = embedder.embed_image(test_image)
+            
+            assert isinstance(embedding, np.ndarray)
+            assert len(embedding.shape) == 1
+            assert embedding.shape[0] == embedder.get_dimension()
+            
+        except ImportError as e:
+            pytest.skip(f"Dépendances non disponibles: {e}")
+        except Exception as e:
+            pytest.skip(f"Embedding échoué: {e}")
+
+
+class TestBackendFunctions:
+    """Tests pour les fonctions du backend VWB."""
+    
+    def test_capture_screen_to_base64_function(self):
+        """Vérifie la fonction capture_screen_to_base64."""
+        try:
+            sys.path.insert(0, str(ROOT_DIR / "visual_workflow_builder" / "backend"))
+            from app_lightweight import capture_screen_to_base64
+            
+            result = capture_screen_to_base64()
+            
+            assert isinstance(result, dict)
+            assert 'success' in result
+            
+            if result['success']:
+                assert 'screenshot' in result
+                assert 'width' in result
+                assert 'height' in result
+                assert isinstance(result['screenshot'], str)
+                assert len(result['screenshot']) > 0
+            else:
+                # Peut échouer si pas d'écran disponible
+                assert 'error' in result
+                
+        except ImportError as e:
+            pytest.skip(f"Backend non disponible: {e}")
+        except Exception as e:
+            pytest.skip(f"Test échoué: {e}")
+    
+    def test_create_visual_embedding_function(self):
+        """Vérifie la fonction create_visual_embedding."""
+        try:
+            import base64
+            from PIL import Image
+            import numpy as np
+            import io
+            
+            sys.path.insert(0, str(ROOT_DIR / "visual_workflow_builder" / "backend"))
+            from app_lightweight import create_visual_embedding
+            
+            # Créer une image de test en base64
+            test_image = Image.fromarray(
+                np.random.randint(0, 255, (200, 200, 3), dtype=np.uint8)
+            )
+            buffer = io.BytesIO()
+            test_image.save(buffer, format='PNG')
+            buffer.seek(0)
+            screenshot_base64 = base64.b64encode(buffer.getvalue()).decode('utf-8')
+            
+            # Zone de sélection
+            bounding_box = {
+                'x': 50,
+                'y': 50,
+                'width': 100,
+                'height': 100
+            }
+            
+            result = create_visual_embedding(screenshot_base64, bounding_box, "test_step")
+            
+            assert isinstance(result, dict)
+            assert 'success' in result
+            
+            if result['success']:
+                assert 'embedding' in result
+                assert 'embedding_id' in result
+                assert 'dimension' in result
+                assert isinstance(result['embedding'], list)
+                assert len(result['embedding']) > 0
+            else:
+                # Peut échouer si CLIP non disponible
+                assert 'error' in result
+                
+        except ImportError as e:
+            pytest.skip(f"Dépendances non disponibles: {e}")
+        except Exception as e:
+            pytest.skip(f"Test échoué: {e}")
+
+
+class TestAPIEndpointsStructure:
+    """Tests pour la structure des endpoints API."""
+    
+    def test_backend_module_loads(self):
+        """Vérifie que le module backend peut être chargé."""
+        try:
+            sys.path.insert(0, str(ROOT_DIR / "visual_workflow_builder" / "backend"))
+            import app_lightweight
+            assert app_lightweight is not None
+        except ImportError as e:
+            pytest.fail(f"Impossible de charger le backend: {e}")
+    
+    def test_workflow_database_class_exists(self):
+        """Vérifie que la classe WorkflowDatabase existe."""
+        try:
+            sys.path.insert(0, str(ROOT_DIR / "visual_workflow_builder" / "backend"))
+            from app_lightweight import WorkflowDatabase
+            assert WorkflowDatabase is not None
+            
+            db = WorkflowDatabase()
+            assert db is not None
+        except ImportError as e:
+            pytest.fail(f"WorkflowDatabase non disponible: {e}")
+    
+    def test_simple_workflow_class_exists(self):
+        """Vérifie que la classe SimpleWorkflow existe."""
+        try:
+            sys.path.insert(0, str(ROOT_DIR / "visual_workflow_builder" / "backend"))
+            from app_lightweight import SimpleWorkflow
+            assert SimpleWorkflow is not None
+            
+            workflow = SimpleWorkflow(
+                id="test_wf",
+                name="Test Workflow",
+                description="Description de test"
+            )
+            assert workflow.id == "test_wf"
+            assert workflow.name == "Test Workflow"
+        except ImportError as e:
+            pytest.fail(f"SimpleWorkflow non disponible: {e}")
+
+
+class TestDataDirectory:
+    """Tests pour la structure des répertoires de données."""
+    
+    def test_visual_embeddings_directory_creation(self):
+        """Vérifie que le répertoire visual_embeddings peut être créé."""
+        embeddings_dir = ROOT_DIR / "data" / "visual_embeddings"
+        embeddings_dir.mkdir(parents=True, exist_ok=True)
+        assert embeddings_dir.exists()
+        assert embeddings_dir.is_dir()
+    
+    def test_workflows_directory_creation(self):
+        """Vérifie que le répertoire workflows peut être créé."""
+        workflows_dir = ROOT_DIR / "data" / "workflows"
+        workflows_dir.mkdir(parents=True, exist_ok=True)
+        assert workflows_dir.exists()
+        assert workflows_dir.is_dir()
+
+
+if __name__ == '__main__':
+    pytest.main([__file__, '-v', '--tb=short'])

capture_element_cible_vwb_20260109_151052/visual_workflow_builder/backend/app_lightweight.py

@@ -0,0 +1,753 @@
+#!/usr/bin/env python3
+"""
+Visual Workflow Builder - Backend Flask Application (Version Allégée)
+
+Auteur : Dom, Alice, Kiro - 09 janvier 2026
+
+Version optimisée pour un démarrage rapide avec uniquement les fonctionnalités essentielles.
+Cette version évite les imports lourds et les dépendances optionnelles.
+
+Fonctionnalités :
+- API REST pour la gestion des workflows
+- Capture d'écran via ScreenCapturer (core/capture)
+- Création d'embeddings visuels via CLIPEmbedder (core/embedding)
+"""
+
+import json
+import os
+import sys
+import base64
+import io
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, Any, List, Optional
+
+# Ajouter le répertoire racine au path pour les imports core
+ROOT_DIR = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(ROOT_DIR))
+sys.path.insert(0, str(Path(__file__).parent))
+
+# Import minimal sans dépendances lourdes
+try:
+    from http.server import HTTPServer, BaseHTTPRequestHandler
+    from urllib.parse import urlparse, parse_qs
+    import socketserver
+    USE_FLASK = False
+    print("⚡ Mode serveur HTTP natif (sans Flask)")
+except ImportError:
+    USE_FLASK = True
+    print("🔄 Tentative d'utilisation de Flask...")
+
+# ============================================================================
+# Services de capture d'écran et d'embedding
+# ============================================================================
+
+# Instance globale du capturer (initialisée à la demande)
+_screen_capturer = None
+_clip_embedder = None
+
+
+def get_screen_capturer():
+    """
+    Obtenir l'instance du ScreenCapturer (initialisation paresseuse).
+    
+    Returns:
+        ScreenCapturer ou None si non disponible
+    """
+    global _screen_capturer
+    if _screen_capturer is None:
+        try:
+            # Vérifier les dépendances de capture d'écran
+            try:
+                import mss
+                print("✅ mss disponible")
+            except ImportError:
+                print("❌ mss non disponible")
+                
+            try:
+                import pyautogui
+                print("✅ pyautogui disponible")
+            except ImportError:
+                print("❌ pyautogui non disponible")
+            
+            from core.capture import ScreenCapturer
+            _screen_capturer = ScreenCapturer(buffer_size=5, detect_changes=False)
+            print(f"✅ ScreenCapturer initialisé avec succès - méthode: {_screen_capturer.method}")
+        except ImportError as e:
+            print(f"⚠️ ScreenCapturer non disponible: {e}")
+            return None
+        except Exception as e:
+            print(f"❌ Erreur initialisation ScreenCapturer: {e}")
+            return None
+    return _screen_capturer
+
+
+def get_clip_embedder():
+    """
+    Obtenir l'instance du CLIPEmbedder (initialisation paresseuse).
+    
+    Returns:
+        CLIPEmbedder ou None si non disponible
+    """
+    global _clip_embedder
+    if _clip_embedder is None:
+        try:
+            from core.embedding import create_clip_embedder
+            _clip_embedder = create_clip_embedder(device="cpu")
+            print("✅ CLIPEmbedder initialisé avec succès")
+        except ImportError as e:
+            print(f"⚠️ CLIPEmbedder non disponible: {e}")
+            return None
+        except Exception as e:
+            print(f"❌ Erreur initialisation CLIPEmbedder: {e}")
+            return None
+    return _clip_embedder
+
+
+def capture_screen_to_base64() -> Dict[str, Any]:
+    """
+    Capture l'écran et retourne l'image en base64.
+    
+    Returns:
+        Dict avec 'success', 'screenshot' (base64), 'width', 'height', ou 'error'
+    """
+    capturer = get_screen_capturer()
+    if capturer is None:
+        return {
+            'success': False,
+            'error': 'Service de capture d\'écran non disponible'
+        }
+    
+    try:
+        from PIL import Image
+        import numpy as np
+        
+        # Capturer l'écran
+        img_array = capturer.capture()
+        if img_array is None:
+            return {
+                'success': False,
+                'error': 'Échec de la capture d\'écran'
+            }
+        
+        # Convertir en PIL Image
+        pil_image = Image.fromarray(img_array)
+        
+        # Convertir en base64
+        buffer = io.BytesIO()
+        pil_image.save(buffer, format='PNG', optimize=True)
+        buffer.seek(0)
+        screenshot_base64 = base64.b64encode(buffer.getvalue()).decode('utf-8')
+        
+        return {
+            'success': True,
+            'screenshot': screenshot_base64,
+            'width': pil_image.width,
+            'height': pil_image.height,
+            'timestamp': datetime.now().isoformat()
+        }
+        
+    except Exception as e:
+        return {
+            'success': False,
+            'error': f'Erreur lors de la capture: {str(e)}'
+        }
+
+
+def create_visual_embedding(screenshot_base64: str, bounding_box: Dict[str, int], step_id: str) -> Dict[str, Any]:
+    """
+    Crée un embedding visuel à partir d'une capture d'écran et d'une zone sélectionnée.
+    
+    Args:
+        screenshot_base64: Image en base64
+        bounding_box: Zone sélectionnée {'x', 'y', 'width', 'height'}
+        step_id: Identifiant de l'étape
+    
+    Returns:
+        Dict avec 'success', 'embedding', 'embedding_id', ou 'error'
+    """
+    embedder = get_clip_embedder()
+    if embedder is None:
+        return {
+            'success': False,
+            'error': 'Service d\'embedding non disponible'
+        }
+    
+    try:
+        from PIL import Image
+        import numpy as np
+        
+        # Décoder l'image base64
+        image_data = base64.b64decode(screenshot_base64)
+        pil_image = Image.open(io.BytesIO(image_data))
+        
+        # Extraire la zone sélectionnée
+        x = bounding_box.get('x', 0)
+        y = bounding_box.get('y', 0)
+        width = bounding_box.get('width', 100)
+        height = bounding_box.get('height', 100)
+        
+        # Valider les coordonnées
+        x = max(0, min(x, pil_image.width - 1))
+        y = max(0, min(y, pil_image.height - 1))
+        width = max(10, min(width, pil_image.width - x))
+        height = max(10, min(height, pil_image.height - y))
+        
+        # Découper la zone
+        cropped_image = pil_image.crop((x, y, x + width, y + height))
+        
+        # Créer l'embedding
+        embedding = embedder.embed_image(cropped_image)
+        
+        # Générer un ID unique pour l'embedding
+        embedding_id = f"emb_{step_id}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+        
+        # Sauvegarder l'embedding et l'image de référence
+        embeddings_dir = ROOT_DIR / "data" / "visual_embeddings"
+        embeddings_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Sauvegarder l'embedding en numpy
+        embedding_path = embeddings_dir / f"{embedding_id}.npy"
+        np.save(str(embedding_path), embedding)
+        
+        # Sauvegarder l'image de référence
+        reference_path = embeddings_dir / f"{embedding_id}_ref.png"
+        cropped_image.save(str(reference_path))
+        
+        return {
+            'success': True,
+            'embedding': embedding.tolist(),
+            'embedding_id': embedding_id,
+            'dimension': len(embedding),
+            'reference_image': f"{embedding_id}_ref.png",
+            'bounding_box': {
+                'x': x,
+                'y': y,
+                'width': width,
+                'height': height
+            }
+        }
+        
+    except Exception as e:
+        return {
+            'success': False,
+            'error': f'Erreur lors de la création de l\'embedding: {str(e)}'
+        }
+
+class WorkflowHandler(BaseHTTPRequestHandler):
+    """Gestionnaire HTTP simple pour les workflows."""
+    
+    def __init__(self, *args, **kwargs):
+        self.workflows_db = WorkflowDatabase()
+        super().__init__(*args, **kwargs)
+    
+    def do_GET(self):
+        """Gère les requêtes GET."""
+        parsed_path = urlparse(self.path)
+        path = parsed_path.path
+        
+        # Headers CORS
+        self.send_cors_headers()
+        
+        if path == '/health':
+            self.send_health_check()
+        elif path == '/':
+            self.send_index()
+        elif path.startswith('/api/workflows'):
+            self.handle_workflows_get(path)
+        else:
+            self.send_error(404, "Not Found")
+    
+    def do_POST(self):
+        """Gère les requêtes POST."""
+        parsed_path = urlparse(self.path)
+        path = parsed_path.path
+        
+        self.send_cors_headers()
+        
+        if path.startswith('/api/workflows'):
+            self.handle_workflows_post(path)
+        else:
+            self.send_error(404, "Not Found")
+    
+    def do_OPTIONS(self):
+        """Gère les requêtes OPTIONS pour CORS."""
+        self.send_cors_headers()
+        self.send_response(200)
+        self.end_headers()
+    
+    def send_cors_headers(self):
+        """Envoie les headers CORS."""
+        self.send_header('Access-Control-Allow-Origin', '*')
+        self.send_header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS')
+        self.send_header('Access-Control-Allow-Headers', 'Content-Type, Authorization')
+    
+    def send_json_response(self, data: Any, status_code: int = 200):
+        """Envoie une réponse JSON."""
+        self.send_response(status_code)
+        self.send_header('Content-Type', 'application/json')
+        self.send_cors_headers()
+        self.end_headers()
+        
+        json_data = json.dumps(data, ensure_ascii=False, indent=2)
+        self.wfile.write(json_data.encode('utf-8'))
+    
+    def send_health_check(self):
+        """Endpoint de santé."""
+        self.send_json_response({
+            'status': 'healthy',
+            'version': '1.0.0-lightweight',
+            'mode': 'native-http'
+        })
+    
+    def send_index(self):
+        """Page d'accueil."""
+        self.send_json_response({
+            'message': 'Visual Workflow Builder Backend (Version Allégée)',
+            'version': '1.0.0-lightweight',
+            'mode': 'native-http',
+            'endpoints': ['/health', '/api/workflows']
+        })
+    
+    def handle_workflows_get(self, path: str):
+        """Gère les GET sur /api/workflows."""
+        if path == '/api/workflows' or path == '/api/workflows/':
+            # Liste des workflows
+            try:
+                workflows = self.workflows_db.list_workflows()
+                self.send_json_response([w.to_dict() for w in workflows])
+            except Exception as e:
+                self.send_json_response({'error': str(e)}, 500)
+        else:
+            # Workflow spécifique
+            workflow_id = path.split('/')[-1]
+            try:
+                workflow = self.workflows_db.get_workflow(workflow_id)
+                if workflow:
+                    self.send_json_response(workflow.to_dict())
+                else:
+                    self.send_json_response({'error': 'Workflow not found'}, 404)
+            except Exception as e:
+                self.send_json_response({'error': str(e)}, 500)
+    
+    def handle_workflows_post(self, path: str):
+        """Gère les POST sur /api/workflows."""
+        try:
+            content_length = int(self.headers.get('Content-Length', 0))
+            if content_length > 0:
+                post_data = self.rfile.read(content_length)
+                data = json.loads(post_data.decode('utf-8'))
+            else:
+                data = {}
+            
+            if path == '/api/workflows' or path == '/api/workflows/':
+                # Créer un nouveau workflow
+                workflow = self.workflows_db.create_workflow(data)
+                self.send_json_response(workflow.to_dict(), 201)
+            else:
+                self.send_json_response({'error': 'Method not allowed'}, 405)
+                
+        except json.JSONDecodeError:
+            self.send_json_response({'error': 'Invalid JSON'}, 400)
+        except Exception as e:
+            self.send_json_response({'error': str(e)}, 500)
+
+class SimpleWorkflow:
+    """Modèle de workflow simplifié."""
+    
+    def __init__(self, id: str, name: str, description: str = "", created_by: str = "unknown"):
+        self.id = id
+        self.name = name
+        self.description = description
+        self.created_by = created_by
+        self.created_at = datetime.now().isoformat()
+        self.updated_at = self.created_at
+        self.nodes = []
+        self.edges = []
+        self.variables = []
+        self.settings = {}
+        self.tags = []
+        self.category = "default"
+        self.is_template = False
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convertit en dictionnaire."""
+        return {
+            'id': self.id,
+            'name': self.name,
+            'description': self.description,
+            'created_by': self.created_by,
+            'created_at': self.created_at,
+            'updated_at': self.updated_at,
+            'nodes': self.nodes,
+            'edges': self.edges,
+            'variables': self.variables,
+            'settings': self.settings,
+            'tags': self.tags,
+            'category': self.category,
+            'is_template': self.is_template
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'SimpleWorkflow':
+        """Crée depuis un dictionnaire."""
+        workflow = cls(
+            id=data.get('id', f"wf_{datetime.now().strftime('%Y%m%d_%H%M%S')}"),
+            name=data.get('name', 'Sans titre'),
+            description=data.get('description', ''),
+            created_by=data.get('created_by', 'unknown')
+        )
+        
+        workflow.nodes = data.get('nodes', [])
+        workflow.edges = data.get('edges', [])
+        workflow.variables = data.get('variables', [])
+        workflow.settings = data.get('settings', {})
+        workflow.tags = data.get('tags', [])
+        workflow.category = data.get('category', 'default')
+        workflow.is_template = data.get('is_template', False)
+        
+        return workflow
+
+class WorkflowDatabase:
+    """Base de données simple pour les workflows."""
+    
+    def __init__(self):
+        self.data_dir = Path("../../data/workflows")
+        self.data_dir.mkdir(parents=True, exist_ok=True)
+        print(f"📁 Base de données: {self.data_dir.absolute()}")
+    
+    def _get_file_path(self, workflow_id: str) -> Path:
+        """Retourne le chemin du fichier pour un workflow."""
+        safe_id = "".join(c for c in workflow_id if c.isalnum() or c in ("_", "-"))
+        return self.data_dir / f"{safe_id}.json"
+    
+    def create_workflow(self, data: Dict[str, Any]) -> SimpleWorkflow:
+        """Crée un nouveau workflow."""
+        if 'name' not in data:
+            raise ValueError("Le nom est requis")
+        
+        workflow = SimpleWorkflow.from_dict(data)
+        self.save_workflow(workflow)
+        return workflow
+    
+    def save_workflow(self, workflow: SimpleWorkflow):
+        """Sauvegarde un workflow."""
+        file_path = self._get_file_path(workflow.id)
+        with open(file_path, 'w', encoding='utf-8') as f:
+            json.dump(workflow.to_dict(), f, ensure_ascii=False, indent=2)
+    
+    def get_workflow(self, workflow_id: str) -> Optional[SimpleWorkflow]:
+        """Récupère un workflow par ID."""
+        file_path = self._get_file_path(workflow_id)
+        if not file_path.exists():
+            return None
+        
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            return SimpleWorkflow.from_dict(data)
+        except Exception as e:
+            print(f"Erreur lecture workflow {workflow_id}: {e}")
+            return None
+    
+    def list_workflows(self) -> List[SimpleWorkflow]:
+        """Liste tous les workflows."""
+        workflows = []
+        for file_path in self.data_dir.glob("*.json"):
+            try:
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                workflows.append(SimpleWorkflow.from_dict(data))
+            except Exception as e:
+                print(f"Erreur lecture {file_path}: {e}")
+        
+        return workflows
+
+def start_native_server(port: int = 5002):
+    """Démarre le serveur HTTP natif."""
+    print(f"🚀 Démarrage du serveur natif sur le port {port}")
+    print(f"🌐 URL: http://localhost:{port}")
+    print(f"❤️  Health check: http://localhost:{port}/health")
+    print(f"📋 API Workflows: http://localhost:{port}/api/workflows")
+    print("")
+    print("Appuyez sur Ctrl+C pour arrêter")
+    
+    try:
+        with socketserver.TCPServer(("", port), WorkflowHandler) as httpd:
+            httpd.serve_forever()
+    except KeyboardInterrupt:
+        print("\n🛑 Arrêt du serveur")
+    except Exception as e:
+        print(f"❌ Erreur serveur: {e}")
+
+def start_flask_server(port: int = 5002):
+    """Démarre le serveur Flask si disponible."""
+    try:
+        from flask import Flask, jsonify, request
+        from flask_cors import CORS
+        
+        app = Flask(__name__)
+        CORS(app)
+        
+        db = WorkflowDatabase()
+        
+        @app.route('/health')
+        @app.route('/api/health')
+        def health_check():
+            return jsonify({
+                'status': 'healthy',
+                'version': '1.0.0-lightweight',
+                'mode': 'flask',
+                'features': {
+                    'screen_capture': get_screen_capturer() is not None,
+                    'visual_embedding': get_clip_embedder() is not None
+                }
+            })
+        
+        @app.route('/')
+        def index():
+            return jsonify({
+                'message': 'Visual Workflow Builder Backend (Version Allégée)',
+                'version': '1.0.0-lightweight',
+                'mode': 'flask',
+                'endpoints': [
+                    '/health',
+                    '/api/workflows',
+                    '/api/screen-capture',
+                    '/api/visual-embedding'
+                ]
+            })
+        
+        @app.route('/api/workflows', methods=['GET'])
+        def list_workflows():
+            try:
+                workflows = db.list_workflows()
+                return jsonify([w.to_dict() for w in workflows])
+            except Exception as e:
+                return jsonify({'error': str(e)}), 500
+        
+        @app.route('/api/workflows', methods=['POST'])
+        def create_workflow():
+            try:
+                data = request.get_json() or {}
+                workflow = db.create_workflow(data)
+                return jsonify(workflow.to_dict()), 201
+            except Exception as e:
+                return jsonify({'error': str(e)}), 400
+        
+        @app.route('/api/workflows/<workflow_id>', methods=['GET'])
+        def get_workflow(workflow_id):
+            try:
+                workflow = db.get_workflow(workflow_id)
+                if workflow:
+                    return jsonify(workflow.to_dict())
+                else:
+                    return jsonify({'error': 'Workflow not found'}), 404
+            except Exception as e:
+                return jsonify({'error': str(e)}), 500
+        
+        # ====================================================================
+        # Endpoints de capture d'écran et d'embedding visuel
+        # ====================================================================
+        
+        @app.route('/api/screen-capture', methods=['POST'])
+        def screen_capture():
+            """
+            Capture l'écran actuel et retourne l'image en base64.
+            
+            Request Body (optionnel):
+                {
+                    "format": "png",  // Format de l'image (png par défaut)
+                    "quality": 90     // Qualité (non utilisé pour PNG)
+                }
+            
+            Response:
+                {
+                    "success": true,
+                    "screenshot": "base64_encoded_image",
+                    "width": 1920,
+                    "height": 1080,
+                    "timestamp": "2026-01-09T..."
+                }
+            """
+            try:
+                result = capture_screen_to_base64()
+                if result['success']:
+                    return jsonify(result)
+                else:
+                    return jsonify(result), 500
+            except Exception as e:
+                return jsonify({
+                    'success': False,
+                    'error': f'Erreur serveur: {str(e)}'
+                }), 500
+        
+        @app.route('/api/visual-embedding', methods=['POST'])
+        def visual_embedding():
+            """
+            Crée un embedding visuel à partir d'une capture d'écran et d'une zone sélectionnée.
+            
+            Request Body:
+                {
+                    "screenshot": "base64_encoded_image",
+                    "boundingBox": {
+                        "x": 100,
+                        "y": 200,
+                        "width": 150,
+                        "height": 50
+                    },
+                    "stepId": "step_123"
+                }
+            
+            Response:
+                {
+                    "success": true,
+                    "embedding": [0.1, 0.2, ...],
+                    "embedding_id": "emb_step_123_20260109_...",
+                    "dimension": 512,
+                    "reference_image": "emb_step_123_..._ref.png",
+                    "bounding_box": {...}
+                }
+            """
+            try:
+                data = request.get_json()
+                if not data:
+                    return jsonify({
+                        'success': False,
+                        'error': 'Corps de requête JSON requis'
+                    }), 400
+                
+                # Valider les paramètres requis
+                screenshot = data.get('screenshot')
+                bounding_box = data.get('boundingBox')
+                step_id = data.get('stepId', 'unknown')
+                
+                if not screenshot:
+                    return jsonify({
+                        'success': False,
+                        'error': 'Paramètre "screenshot" requis'
+                    }), 400
+                
+                if not bounding_box:
+                    return jsonify({
+                        'success': False,
+                        'error': 'Paramètre "boundingBox" requis'
+                    }), 400
+                
+                # Créer l'embedding
+                result = create_visual_embedding(screenshot, bounding_box, step_id)
+                
+                if result['success']:
+                    return jsonify(result)
+                else:
+                    return jsonify(result), 500
+                    
+            except Exception as e:
+                return jsonify({
+                    'success': False,
+                    'error': f'Erreur serveur: {str(e)}'
+                }), 500
+        
+        @app.route('/api/visual-embedding/<embedding_id>', methods=['GET'])
+        def get_visual_embedding(embedding_id):
+            """
+            Récupère un embedding visuel existant par son ID.
+            
+            Response:
+                {
+                    "success": true,
+                    "embedding_id": "emb_...",
+                    "embedding": [0.1, 0.2, ...],
+                    "reference_image_url": "/api/visual-embedding/emb_.../image"
+                }
+            """
+            try:
+                import numpy as np
+                
+                embeddings_dir = ROOT_DIR / "data" / "visual_embeddings"
+                embedding_path = embeddings_dir / f"{embedding_id}.npy"
+                
+                if not embedding_path.exists():
+                    return jsonify({
+                        'success': False,
+                        'error': f'Embedding "{embedding_id}" non trouvé'
+                    }), 404
+                
+                embedding = np.load(str(embedding_path))
+                
+                return jsonify({
+                    'success': True,
+                    'embedding_id': embedding_id,
+                    'embedding': embedding.tolist(),
+                    'dimension': len(embedding),
+                    'reference_image_url': f'/api/visual-embedding/{embedding_id}/image'
+                })
+                
+            except Exception as e:
+                return jsonify({
+                    'success': False,
+                    'error': f'Erreur: {str(e)}'
+                }), 500
+        
+        @app.route('/api/visual-embedding/<embedding_id>/image', methods=['GET'])
+        def get_embedding_reference_image(embedding_id):
+            """
+            Récupère l'image de référence d'un embedding.
+            """
+            try:
+                from flask import send_file
+                
+                embeddings_dir = ROOT_DIR / "data" / "visual_embeddings"
+                image_path = embeddings_dir / f"{embedding_id}_ref.png"
+                
+                if not image_path.exists():
+                    return jsonify({
+                        'success': False,
+                        'error': f'Image de référence non trouvée'
+                    }), 404
+                
+                return send_file(str(image_path), mimetype='image/png')
+                
+            except Exception as e:
+                return jsonify({
+                    'success': False,
+                    'error': f'Erreur: {str(e)}'
+                }), 500
+        
+        print(f"🚀 Démarrage du serveur Flask sur le port {port}")
+        print(f"🌐 URL: http://localhost:{port}")
+        print(f"❤️  Health check: http://localhost:{port}/health")
+        print(f"📋 API Workflows: http://localhost:{port}/api/workflows")
+        print(f"📷 API Capture: http://localhost:{port}/api/screen-capture")
+        print(f"🎯 API Embedding: http://localhost:{port}/api/visual-embedding")
+        
+        app.run(host='0.0.0.0', port=port, debug=False)
+        
+    except ImportError as e:
+        print(f"❌ Flask non disponible: {e}")
+        print("🔄 Basculement vers le serveur natif...")
+        start_native_server(port)
+
+def main():
+    """Fonction principale."""
+    print("=" * 60)
+    print(" VISUAL WORKFLOW BUILDER - BACKEND ALLÉGÉ")
+    print("=" * 60)
+    print("Auteur : Dom, Alice, Kiro - 08 janvier 2026")
+    print("")
+    
+    # Déterminer le port
+    port = int(os.getenv('PORT', 5002))
+    
+    # Vérifier les dépendances
+    try:
+        import flask
+        import flask_cors
+        print("✅ Flask disponible - utilisation du mode Flask")
+        start_flask_server(port)
+    except ImportError:
+        print("⚡ Flask non disponible - utilisation du serveur natif")
+        start_native_server(port)
+
+if __name__ == '__main__':
+    main()

capture_element_cible_vwb_20260109_151052/visual_workflow_builder/backend/services/real_screen_capture.py

@@ -0,0 +1,299 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Service de Capture d'Écran Réelle - RPA Vision V3
+Auteur : Dom, Alice, Kiro - 8 janvier 2026
+
+Service pour capturer l'écran réel de l'utilisateur et détecter les éléments UI.
+"""
+
+import cv2
+import numpy as np
+import mss
+import base64
+import io
+from PIL import Image
+from typing import Dict, List, Tuple, Optional
+import threading
+import time
+import logging
+
+# Import des modules RPA Vision V3 pour la détection UI
+import sys
+import os
+
+# Ajouter le chemin vers le répertoire racine du projet
+project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '../../..'))
+if project_root not in sys.path:
+    sys.path.insert(0, project_root)
+
+try:
+    from core.detection.ui_detector import UIDetector
+    UI_DETECTOR_AVAILABLE = True
+except ImportError as e:
+    print(f"Warning: UIDetector non disponible: {e}")
+    UI_DETECTOR_AVAILABLE = False
+    UIDetector = None
+
+try:
+    from core.models.screen_state import ScreenState, UIElement
+    SCREEN_STATE_AVAILABLE = True
+except ImportError as e:
+    print(f"Warning: ScreenState non disponible: {e}")
+    SCREEN_STATE_AVAILABLE = False
+    ScreenState = None
+    UIElement = None
+
+logger = logging.getLogger(__name__)
+
+class RealScreenCaptureService:
+    """
+    Service de capture d'écran réelle avec détection d'éléments UI
+    """
+    
+    def __init__(self):
+        self.is_capturing = False
+        self.capture_thread = None
+        self.current_screenshot = None
+        self.detected_elements = []
+        
+        # Initialiser le détecteur UI si disponible
+        if UI_DETECTOR_AVAILABLE:
+            self.ui_detector = UIDetector()
+        else:
+            self.ui_detector = None
+            print("Warning: UIDetector non disponible - détection d'éléments désactivée")
+            
+        self.capture_interval = 1.0  # 1 seconde par défaut
+        self.monitors = []
+        self.selected_monitor = 0
+        
+        # Initialiser MSS pour la capture d'écran
+        try:
+            # Utiliser MSS temporairement pour détecter les moniteurs
+            with mss.mss() as sct:
+                self.monitors = sct.monitors
+                logger.info(f"Détecté {len(self.monitors)} moniteurs")
+                for i, monitor in enumerate(self.monitors):
+                    logger.info(f"Moniteur {i}: {monitor}")
+        except Exception as e:
+            logger.error(f"Erreur lors de la détection des moniteurs: {e}")
+            self.monitors = [{"top": 0, "left": 0, "width": 1920, "height": 1080}]
+    
+    def _detect_monitors(self):
+        """Détecte les moniteurs disponibles"""
+        try:
+            self.monitors = self.sct.monitors
+            logger.info(f"Détecté {len(self.monitors)} moniteurs")
+            for i, monitor in enumerate(self.monitors):
+                logger.info(f"Moniteur {i}: {monitor}")
+        except Exception as e:
+            logger.error(f"Erreur lors de la détection des moniteurs: {e}")
+            self.monitors = [{"top": 0, "left": 0, "width": 1920, "height": 1080}]
+    
+    def get_monitors(self) -> List[Dict]:
+        """Retourne la liste des moniteurs disponibles"""
+        return [
+            {
+                "id": i,
+                "width": monitor.get("width", 0),
+                "height": monitor.get("height", 0),
+                "top": monitor.get("top", 0),
+                "left": monitor.get("left", 0)
+            }
+            for i, monitor in enumerate(self.monitors)
+        ]
+    
+    def select_monitor(self, monitor_id: int) -> bool:
+        """Sélectionne le moniteur à capturer"""
+        if 0 <= monitor_id < len(self.monitors):
+            self.selected_monitor = monitor_id
+            logger.info(f"Moniteur sélectionné: {monitor_id}")
+            return True
+        return False
+    
+    def start_capture(self, interval: float = 1.0) -> bool:
+        """Démarre la capture d'écran en temps réel"""
+        if self.is_capturing:
+            logger.warning("Capture déjà en cours")
+            return False
+        
+        self.capture_interval = interval
+        self.is_capturing = True
+        
+        # Démarrer le thread de capture
+        self.capture_thread = threading.Thread(target=self._capture_loop, daemon=True)
+        self.capture_thread.start()
+        
+        logger.info(f"Capture démarrée (intervalle: {interval}s)")
+        return True
+    
+    def stop_capture(self) -> bool:
+        """Arrête la capture d'écran"""
+        if not self.is_capturing:
+            return False
+        
+        self.is_capturing = False
+        
+        if self.capture_thread and self.capture_thread.is_alive():
+            self.capture_thread.join(timeout=2.0)
+        
+        logger.info("Capture arrêtée")
+        return True
+    
+    def _capture_loop(self):
+        """Boucle principale de capture avec MSS local au thread"""
+        # Créer une instance MSS locale au thread pour éviter les problèmes de threading
+        try:
+            with mss.mss() as sct_local:
+                while self.is_capturing:
+                    try:
+                        # Capturer l'écran avec l'instance locale
+                        screenshot = self._capture_screen_with_sct(sct_local)
+                        if screenshot is not None:
+                            self.current_screenshot = screenshot
+                            
+                            # Détecter les éléments UI
+                            if UI_DETECTOR_AVAILABLE and self.ui_detector:
+                                self._detect_ui_elements(screenshot)
+                        
+                        # Attendre avant la prochaine capture
+                        time.sleep(self.capture_interval)
+                        
+                    except Exception as e:
+                        logger.error(f"Erreur dans la boucle de capture: {e}")
+                        time.sleep(1.0)  # Attendre avant de réessayer
+        except Exception as e:
+            logger.error(f"Erreur lors de l'initialisation MSS dans le thread: {e}")
+    
+    def _capture_screen_with_sct(self, sct):
+        """Capture l'écran avec une instance MSS donnée"""
+        try:
+            if self.selected_monitor >= len(self.monitors):
+                self.selected_monitor = 0
+            
+            monitor = self.monitors[self.selected_monitor]
+            
+            # Capturer avec MSS
+            screenshot = sct.grab(monitor)
+            
+            # Convertir en array numpy
+            img_array = np.array(screenshot)
+            
+            # Convertir BGRA vers BGR (OpenCV)
+            if img_array.shape[2] == 4:
+                img_array = cv2.cvtColor(img_array, cv2.COLOR_BGRA2BGR)
+            
+            return img_array
+            
+        except Exception as e:
+            logger.error(f"Erreur lors de la capture d'écran: {e}")
+            return None
+    
+    def _capture_screen(self) -> Optional[np.ndarray]:
+        """Capture l'écran sélectionné (version legacy, utilise _capture_screen_with_sct)"""
+        try:
+            with mss.mss() as sct:
+                return self._capture_screen_with_sct(sct)
+        except Exception as e:
+            logger.error(f"Erreur lors de la capture d'écran legacy: {e}")
+            return None
+    
+    def _detect_ui_elements(self, screenshot: np.ndarray):
+        """Détecte les éléments UI sur la capture d'écran"""
+        try:
+            # Créer un ScreenState temporaire pour la détection
+            screen_state = ScreenState(
+                timestamp=time.time(),
+                screenshot_path="",  # Pas de fichier, image en mémoire
+                screenshot_data=screenshot,
+                ui_elements=[],
+                metadata={"source": "real_capture"}
+            )
+            
+            # Utiliser le détecteur UI existant
+            detected_elements = self.ui_detector.detect_elements(screen_state)
+            
+            # Mettre à jour les éléments détectés
+            self.detected_elements = detected_elements
+            
+            logger.debug(f"Détecté {len(detected_elements)} éléments UI")
+            
+        except Exception as e:
+            logger.error(f"Erreur lors de la détection UI: {e}")
+            self.detected_elements = []
+    
+    def get_current_screenshot_base64(self) -> Optional[str]:
+        """Retourne la capture d'écran actuelle en base64"""
+        if self.current_screenshot is None:
+            return None
+        
+        try:
+            # Convertir en PIL Image
+            if len(self.current_screenshot.shape) == 3:
+                # BGR vers RGB
+                rgb_image = cv2.cvtColor(self.current_screenshot, cv2.COLOR_BGR2RGB)
+                pil_image = Image.fromarray(rgb_image)
+            else:
+                pil_image = Image.fromarray(self.current_screenshot)
+            
+            # Redimensionner pour l'affichage web (optionnel)
+            max_width = 1200
+            if pil_image.width > max_width:
+                ratio = max_width / pil_image.width
+                new_height = int(pil_image.height * ratio)
+                pil_image = pil_image.resize((max_width, new_height), Image.Resampling.LANCZOS)
+            
+            # Convertir en base64
+            buffer = io.BytesIO()
+            pil_image.save(buffer, format='JPEG', quality=85)
+            img_base64 = base64.b64encode(buffer.getvalue()).decode('utf-8')
+            
+            return f"data:image/jpeg;base64,{img_base64}"
+            
+        except Exception as e:
+            logger.error(f"Erreur lors de la conversion base64: {e}")
+            return None
+    
+    def get_detected_elements(self) -> List[Dict]:
+        """Retourne les éléments UI détectés"""
+        elements = []
+        
+        for element in self.detected_elements:
+            try:
+                elements.append({
+                    "id": getattr(element, 'id', ''),
+                    "type": getattr(element, 'element_type', 'unknown'),
+                    "text": getattr(element, 'text', ''),
+                    "bbox": {
+                        "x": getattr(element, 'bbox', {}).get('x', 0),
+                        "y": getattr(element, 'bbox', {}).get('y', 0),
+                        "width": getattr(element, 'bbox', {}).get('width', 0),
+                        "height": getattr(element, 'bbox', {}).get('height', 0)
+                    },
+                    "confidence": getattr(element, 'confidence', 0.0),
+                    "attributes": getattr(element, 'attributes', {})
+                })
+            except Exception as e:
+                logger.error(f"Erreur lors de la sérialisation d'un élément: {e}")
+        
+        return elements
+    
+    def get_status(self) -> Dict:
+        """Retourne le statut du service"""
+        return {
+            "is_capturing": self.is_capturing,
+            "selected_monitor": self.selected_monitor,
+            "monitors_count": len(self.monitors),
+            "capture_interval": self.capture_interval,
+            "elements_detected": len(self.detected_elements),
+            "has_screenshot": self.current_screenshot is not None
+        }
+    
+    def cleanup(self):
+        """Nettoie les ressources"""
+        self.stop_capture()
+        # Plus besoin de fermer self.sct car nous utilisons des instances locales
+
+# Instance globale du service
+real_capture_service = RealScreenCaptureService()

capture_element_cible_vwb_20260109_151052/visual_workflow_builder/frontend/src/components/VisualSelector/index.tsx

@@ -0,0 +1,454 @@
+/**
+ * Composant Sélecteur Visuel - Sélection d'éléments basée sur la vision
+ * Auteur : Dom, Alice, Kiro - 08 janvier 2026
+ * 
+ * Ce composant permet la sélection d'éléments à l'écran via capture d'écran
+ * et création d'embeddings visuels pour la reconnaissance d'éléments.
+ */
+
+import React, { useState, useCallback, useRef } from 'react';
+import {
+  Dialog,
+  DialogTitle,
+  DialogContent,
+  DialogActions,
+  Button,
+  Box,
+  Typography,
+  CircularProgress,
+  Alert,
+  Stepper,
+  Step,
+  StepLabel,
+  Paper,
+  IconButton,
+} from '@mui/material';
+import {
+  CameraAlt as CameraIcon,
+  Close as CloseIcon,
+  CheckCircle as CheckIcon,
+  Visibility as VisibilityIcon,
+} from '@mui/icons-material';
+
+// Import des types partagés
+import { VisualSelection, BoundingBox } from '../../types';
+
+interface VisualSelectorProps {
+  isOpen: boolean;
+  stepId: string;
+  onClose: () => void;
+  onElementSelected: (selection: VisualSelection) => void;
+}
+
+interface CaptureState {
+  screenshot: string | null;
+  isCapturing: boolean;
+  error: string | null;
+  selectedArea: BoundingBox | null;
+  isProcessing: boolean;
+}
+
+const steps = [
+  'Capture d\'écran',
+  'Sélection d\'élément',
+  'Confirmation',
+];
+
+/**
+ * Composant Sélecteur Visuel
+ */
+const VisualSelector: React.FC<VisualSelectorProps> = ({
+  isOpen,
+  stepId,
+  onClose,
+  onElementSelected,
+}) => {
+  const [activeStep, setActiveStep] = useState(0);
+  const [captureState, setCaptureState] = useState<CaptureState>({
+    screenshot: null,
+    isCapturing: false,
+    error: null,
+    selectedArea: null,
+    isProcessing: false,
+  });
+  
+  const canvasRef = useRef<HTMLCanvasElement>(null);
+  const [isSelecting, setIsSelecting] = useState(false);
+  const [selectionStart, setSelectionStart] = useState<{ x: number; y: number } | null>(null);
+
+  // Réinitialiser l'état lors de l'ouverture/fermeture
+  const handleClose = useCallback(() => {
+    setActiveStep(0);
+    setCaptureState({
+      screenshot: null,
+      isCapturing: false,
+      error: null,
+      selectedArea: null,
+      isProcessing: false,
+    });
+    setIsSelecting(false);
+    setSelectionStart(null);
+    onClose();
+  }, [onClose]);
+
+  // Capturer l'écran via l'API ScreenCapturer
+  const handleCaptureScreen = useCallback(async () => {
+    setCaptureState(prev => ({ ...prev, isCapturing: true, error: null }));
+    
+    try {
+      // Appel à l'API ScreenCapturer réelle du système RPA Vision V3
+      const response = await fetch('/api/screen-capture', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          format: 'png',
+          quality: 90,
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error(`Erreur de capture: ${response.status} ${response.statusText}`);
+      }
+
+      const data = await response.json();
+      
+      if (!data.success || !data.screenshot) {
+        throw new Error(data.error || 'Échec de la capture d\'écran');
+      }
+
+      setCaptureState(prev => ({
+        ...prev,
+        screenshot: data.screenshot,
+        isCapturing: false,
+      }));
+      
+      setActiveStep(1);
+    } catch (error) {
+      console.error('Erreur lors de la capture d\'écran:', error);
+      setCaptureState(prev => ({
+        ...prev,
+        isCapturing: false,
+        error: error instanceof Error ? error.message : 'Erreur inconnue lors de la capture',
+      }));
+    }
+  }, []);
+
+  // Gérer le début de sélection sur le canvas
+  const handleMouseDown = useCallback((event: React.MouseEvent<HTMLCanvasElement>) => {
+    if (!captureState.screenshot) return;
+    
+    const canvas = canvasRef.current;
+    if (!canvas) return;
+
+    const rect = canvas.getBoundingClientRect();
+    const x = event.clientX - rect.left;
+    const y = event.clientY - rect.top;
+    
+    setIsSelecting(true);
+    setSelectionStart({ x, y });
+    setCaptureState(prev => ({ ...prev, selectedArea: null }));
+  }, [captureState.screenshot]);
+
+  // Gérer le mouvement de sélection
+  const handleMouseMove = useCallback((event: React.MouseEvent<HTMLCanvasElement>) => {
+    if (!isSelecting || !selectionStart || !canvasRef.current) return;
+
+    const canvas = canvasRef.current;
+    const rect = canvas.getBoundingClientRect();
+    const currentX = event.clientX - rect.left;
+    const currentY = event.clientY - rect.top;
+
+    // Dessiner la zone de sélection en temps réel
+    const ctx = canvas.getContext('2d');
+    if (!ctx) return;
+
+    // Redessiner l'image de base
+    if (captureState.screenshot) {
+      const img = new Image();
+      img.onload = () => {
+        ctx.clearRect(0, 0, canvas.width, canvas.height);
+        ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
+        
+        // Dessiner le rectangle de sélection
+        ctx.strokeStyle = '#1976d2';
+        ctx.lineWidth = 2;
+        ctx.setLineDash([5, 5]);
+        ctx.strokeRect(
+          selectionStart.x,
+          selectionStart.y,
+          currentX - selectionStart.x,
+          currentY - selectionStart.y
+        );
+      };
+      img.src = `data:image/png;base64,${captureState.screenshot}`;
+    }
+  }, [isSelecting, selectionStart, captureState.screenshot]);
+
+  // Finaliser la sélection
+  const handleMouseUp = useCallback((event: React.MouseEvent<HTMLCanvasElement>) => {
+    if (!isSelecting || !selectionStart || !canvasRef.current) return;
+
+    const canvas = canvasRef.current;
+    const rect = canvas.getBoundingClientRect();
+    const endX = event.clientX - rect.left;
+    const endY = event.clientY - rect.top;
+
+    const selectedArea: BoundingBox = {
+      x: Math.min(selectionStart.x, endX),
+      y: Math.min(selectionStart.y, endY),
+      width: Math.abs(endX - selectionStart.x),
+      height: Math.abs(endY - selectionStart.y),
+    };
+
+    // Valider que la zone sélectionnée a une taille minimale
+    if (selectedArea.width < 10 || selectedArea.height < 10) {
+      setCaptureState(prev => ({
+        ...prev,
+        error: 'La zone sélectionnée est trop petite. Veuillez sélectionner une zone plus grande.',
+      }));
+      setIsSelecting(false);
+      setSelectionStart(null);
+      return;
+    }
+
+    setCaptureState(prev => ({
+      ...prev,
+      selectedArea,
+      error: null,
+    }));
+    
+    setIsSelecting(false);
+    setSelectionStart(null);
+    setActiveStep(2);
+  }, [isSelecting, selectionStart]);
+
+  // Confirmer la sélection et créer l'embedding visuel
+  const handleConfirmSelection = useCallback(async () => {
+    if (!captureState.screenshot || !captureState.selectedArea) return;
+
+    setCaptureState(prev => ({ ...prev, isProcessing: true, error: null }));
+
+    try {
+      // Créer l'embedding visuel via l'API du système RPA Vision V3
+      const response = await fetch('/api/visual-embedding', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          screenshot: captureState.screenshot,
+          boundingBox: captureState.selectedArea,
+          stepId: stepId,
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error(`Erreur de création d'embedding: ${response.status} ${response.statusText}`);
+      }
+
+      const data = await response.json();
+      
+      if (!data.success || !data.embedding) {
+        throw new Error(data.error || 'Échec de la création de l\'embedding visuel');
+      }
+
+      // Créer l'objet VisualSelection
+      const visualSelection: VisualSelection = {
+        id: `visual_${stepId}_${Date.now()}`,
+        screenshot: captureState.screenshot,
+        boundingBox: captureState.selectedArea,
+        embedding: data.embedding,
+        description: `Élément sélectionné pour l'étape ${stepId}`,
+      };
+
+      onElementSelected(visualSelection);
+      handleClose();
+    } catch (error) {
+      console.error('Erreur lors de la création de l\'embedding:', error);
+      setCaptureState(prev => ({
+        ...prev,
+        isProcessing: false,
+        error: error instanceof Error ? error.message : 'Erreur inconnue lors de la création de l\'embedding',
+      }));
+    }
+  }, [captureState.screenshot, captureState.selectedArea, stepId, onElementSelected, handleClose]);
+
+  // Rendu du contenu selon l'étape active
+  const renderStepContent = () => {
+    switch (activeStep) {
+      case 0:
+        return (
+          <Box sx={{ textAlign: 'center', py: 4 }}>
+            <CameraIcon sx={{ fontSize: 64, color: 'primary.main', mb: 2 }} />
+            <Typography variant="h6" gutterBottom>
+              Capture d'écran
+            </Typography>
+            <Typography variant="body2" color="text.secondary" sx={{ mb: 2 }}>
+              Cliquez sur le bouton ci-dessous pour capturer l'écran actuel.
+              Assurez-vous que l'élément que vous souhaitez sélectionner est visible.
+            </Typography>
+            
+            {captureState.error && (
+              <Alert severity="error" sx={{ mt: 2, mb: 2 }}>
+                {captureState.error}
+              </Alert>
+            )}
+            
+            <Button
+              variant="contained"
+              size="large"
+              onClick={handleCaptureScreen}
+              disabled={captureState.isCapturing}
+              startIcon={captureState.isCapturing ? <CircularProgress size={20} /> : <CameraIcon />}
+            >
+              {captureState.isCapturing ? 'Capture en cours...' : 'Capturer l\'écran'}
+            </Button>
+          </Box>
+        );
+
+      case 1:
+        return (
+          <Box>
+            <Typography variant="h6" gutterBottom>
+              Sélection d'élément
+            </Typography>
+            <Typography variant="body2" color="text.secondary" sx={{ mb: 2 }}>
+              Cliquez et glissez pour sélectionner l'élément souhaité sur la capture d'écran.
+            </Typography>
+            
+            {captureState.error && (
+              <Alert severity="error" sx={{ mb: 2 }}>
+                {captureState.error}
+              </Alert>
+            )}
+            
+            <Paper elevation={2} sx={{ p: 1, maxHeight: 400, overflow: 'auto' }}>
+              {captureState.screenshot && (
+                <canvas
+                  ref={canvasRef}
+                  width={800}
+                  height={600}
+                  style={{
+                    maxWidth: '100%',
+                    height: 'auto',
+                    cursor: 'crosshair',
+                    border: '1px solid #e0e0e0',
+                  }}
+                  onMouseDown={handleMouseDown}
+                  onMouseMove={handleMouseMove}
+                  onMouseUp={handleMouseUp}
+                  onLoad={() => {
+                    const canvas = canvasRef.current;
+                    const ctx = canvas?.getContext('2d');
+                    if (canvas && ctx && captureState.screenshot) {
+                      const img = new Image();
+                      img.onload = () => {
+                        ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
+                      };
+                      img.src = `data:image/png;base64,${captureState.screenshot}`;
+                    }
+                  }}
+                />
+              )}
+            </Paper>
+          </Box>
+        );
+
+      case 2:
+        return (
+          <Box>
+            <Typography variant="h6" gutterBottom>
+              Confirmation de sélection
+            </Typography>
+            <Typography variant="body2" color="text.secondary" sx={{ mb: 2 }}>
+              Vérifiez que la zone sélectionnée correspond à l'élément souhaité.
+            </Typography>
+            
+            {captureState.selectedArea && (
+              <Alert severity="info" sx={{ mb: 2 }}>
+                Zone sélectionnée : {captureState.selectedArea.width} × {captureState.selectedArea.height} pixels
+                à la position ({captureState.selectedArea.x}, {captureState.selectedArea.y})
+              </Alert>
+            )}
+            
+            {captureState.error && (
+              <Alert severity="error" sx={{ mb: 2 }}>
+                {captureState.error}
+              </Alert>
+            )}
+            
+            <Box sx={{ display: 'flex', gap: 2, justifyContent: 'center' }}>
+              <Button
+                variant="outlined"
+                onClick={() => setActiveStep(1)}
+                disabled={captureState.isProcessing}
+              >
+                Modifier la sélection
+              </Button>
+              <Button
+                variant="contained"
+                onClick={handleConfirmSelection}
+                disabled={captureState.isProcessing}
+                startIcon={captureState.isProcessing ? <CircularProgress size={20} /> : <CheckIcon />}
+              >
+                {captureState.isProcessing ? 'Traitement...' : 'Confirmer la sélection'}
+              </Button>
+            </Box>
+          </Box>
+        );
+
+      default:
+        return null;
+    }
+  };
+
+  return (
+    <Dialog
+      open={isOpen}
+      onClose={handleClose}
+      maxWidth="md"
+      fullWidth
+      slotProps={{
+        paper: {
+          sx: { minHeight: 500 },
+        },
+      }}
+    >
+      <DialogTitle>
+        <Box sx={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
+          <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
+            <VisibilityIcon />
+            <Typography variant="h6">Sélection visuelle d'élément</Typography>
+          </Box>
+          <IconButton onClick={handleClose} size="small">
+            <CloseIcon />
+          </IconButton>
+        </Box>
+      </DialogTitle>
+
+      <DialogContent>
+        {/* Stepper pour indiquer la progression */}
+        <Stepper activeStep={activeStep} sx={{ mb: 4 }}>
+          {steps.map((label) => (
+            <Step key={label}>
+              <StepLabel>{label}</StepLabel>
+            </Step>
+          ))}
+        </Stepper>
+
+        {/* Contenu de l'étape active */}
+        {renderStepContent()}
+      </DialogContent>
+
+      <DialogActions>
+        <Button onClick={handleClose} disabled={captureState.isCapturing || captureState.isProcessing}>
+          Annuler
+        </Button>
+      </DialogActions>
+    </Dialog>
+  );
+};
+
+export default VisualSelector;

capture_element_cible_vwb_20260109_151052/visual_workflow_builder/frontend/src/hooks/useApiClient.ts

@@ -0,0 +1,414 @@
+/**
+ * Hook API Client - Interface React pour le client API
+ * Auteur : Dom, Alice, Kiro - 09 janvier 2026
+ * 
+ * Ce hook fournit une interface React pour utiliser le client API
+ * avec gestion d'état, loading, erreurs et mode hors ligne gracieux.
+ * Optimisé pour éviter les re-renders excessifs et les sauts de page.
+ */
+
+import { useState, useCallback, useRef, useEffect, useMemo } from 'react';
+import { apiClient, ApiError, ConnectionState } from '../services/apiClient';
+import { WorkflowApiData } from '../types';
+
+// Types pour les états de requête
+interface RequestState<T = any> {
+  data: T | null;
+  loading: boolean;
+  error: ApiError | null;
+  lastUpdated: Date | null;
+  isOffline: boolean;
+}
+
+interface UseApiClientOptions {
+  enableAutoRetry?: boolean;
+  retryDelay?: number;
+  maxRetries?: number;
+  onError?: (error: ApiError) => void;
+  onSuccess?: (data: any) => void;
+  silentOffline?: boolean; // Ne pas afficher d'erreur en mode hors ligne
+}
+
+// État initial stable (évite les re-créations)
+const INITIAL_STATE: RequestState = {
+  data: null,
+  loading: false,
+  error: null,
+  lastUpdated: null,
+  isOffline: false,
+};
+
+/**
+ * Hook pour utiliser le client API avec gestion d'état React
+ * Optimisé pour éviter les re-renders inutiles
+ */
+export function useApiClient<T = any>(options: UseApiClientOptions = {}) {
+  const {
+    enableAutoRetry = false, // Désactivé par défaut pour éviter les sauts
+    retryDelay = 1000,
+    maxRetries = 2,
+    onError,
+    onSuccess,
+    silentOffline = true, // Par défaut, ne pas afficher d'erreur en mode hors ligne
+  } = options;
+
+  const [state, setState] = useState<RequestState<T>>(INITIAL_STATE);
+  const retryCountRef = useRef(0);
+  const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const mountedRef = useRef(true);
+
+  // Nettoyer les timeouts et marquer comme démonté
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, []);
+
+  // Fonction pour mettre à jour l'état de manière sécurisée
+  const safeSetState = useCallback((updater: (prev: RequestState<T>) => RequestState<T>) => {
+    if (mountedRef.current) {
+      setState(updater);
+    }
+  }, []);
+
+  // Fonction générique pour exécuter une requête API
+  const executeRequest = useCallback(async <R = T>(
+    requestFn: () => Promise<R>,
+    requestOptions: { skipLoading?: boolean; skipErrorHandling?: boolean } = {}
+  ): Promise<R | null> => {
+    const { skipLoading = false, skipErrorHandling = false } = requestOptions;
+
+    try {
+      if (!skipLoading) {
+        safeSetState(prev => ({
+          ...prev,
+          loading: true,
+          error: null,
+        }));
+      }
+
+      const result = await requestFn();
+      
+      // Vérifier si le résultat indique un mode hors ligne
+      const isOfflineResult = result && typeof result === 'object' && 'offline' in result && (result as any).offline;
+      
+      safeSetState(prev => ({
+        ...prev,
+        data: isOfflineResult ? prev.data : (result as unknown as T), // Garder les anciennes données si hors ligne
+        loading: false,
+        error: null,
+        lastUpdated: isOfflineResult ? prev.lastUpdated : new Date(),
+        isOffline: isOfflineResult,
+      }));
+
+      retryCountRef.current = 0;
+      
+      if (onSuccess && !isOfflineResult) {
+        onSuccess(result);
+      }
+
+      return result;
+
+    } catch (error) {
+      const apiError = error as ApiError;
+      const isOffline = apiError.code === 'OFFLINE' || apiError.code === 'NETWORK_ERROR';
+      
+      safeSetState(prev => ({
+        ...prev,
+        loading: false,
+        error: (silentOffline && isOffline) ? null : apiError,
+        isOffline,
+      }));
+
+      // Gestion du retry automatique (seulement si pas hors ligne)
+      if (enableAutoRetry && !isOffline && retryCountRef.current < maxRetries && shouldRetryError(apiError)) {
+        retryCountRef.current++;
+        
+        timeoutRef.current = setTimeout(() => {
+          executeRequest(requestFn, requestOptions);
+        }, retryDelay * Math.pow(2, retryCountRef.current - 1));
+        
+        return null;
+      }
+
+      retryCountRef.current = 0;
+
+      if (!skipErrorHandling && onError && !(silentOffline && isOffline)) {
+        onError(apiError);
+      }
+
+      // Ne pas relancer l'erreur en mode hors ligne silencieux
+      if (silentOffline && isOffline) {
+        return null;
+      }
+
+      throw apiError;
+    }
+  }, [enableAutoRetry, maxRetries, retryDelay, onError, onSuccess, silentOffline, safeSetState]);
+
+  // Déterminer si une erreur justifie un retry
+  const shouldRetryError = useCallback((error: ApiError): boolean => {
+    // Ne pas retry pour les erreurs hors ligne
+    if (error.code === 'OFFLINE' || error.code === 'NETWORK_ERROR') {
+      return false;
+    }
+    // Retry pour les erreurs serveur
+    return (
+      (error.status !== undefined && error.status >= 500) ||
+      error.status === 408 ||
+      error.status === 429
+    );
+  }, []);
+
+  // Réinitialiser l'état
+  const reset = useCallback(() => {
+    safeSetState(() => INITIAL_STATE);
+    retryCountRef.current = 0;
+    
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  }, [safeSetState]);
+
+  // Annuler la requête en cours
+  const cancel = useCallback(() => {
+    apiClient.cancelRequest();
+    
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+    
+    safeSetState(prev => ({
+      ...prev,
+      loading: false,
+    }));
+  }, [safeSetState]);
+
+  return {
+    ...state,
+    executeRequest,
+    reset,
+    cancel,
+    isRetrying: retryCountRef.current > 0,
+    retryCount: retryCountRef.current,
+  };
+}
+
+/**
+ * Hook pour surveiller l'état de connexion de l'API
+ * Utilise un abonnement pour éviter les re-renders excessifs
+ * L'état initial est 'offline' pour éviter les tentatives de connexion au montage
+ */
+export function useConnectionState() {
+  // État initial 'offline' pour éviter les appels API au montage
+  const [connectionState, setConnectionState] = useState<ConnectionState>('offline');
+
+  useEffect(() => {
+    // Référence pour éviter les mises à jour après démontage
+    let isMounted = true;
+    
+    // S'abonner aux changements d'état de connexion
+    const unsubscribe = apiClient.onConnectionStateChange((state) => {
+      if (isMounted) {
+        setConnectionState(state);
+      }
+    });
+
+    return () => {
+      isMounted = false;
+      unsubscribe();
+    };
+  }, []);
+
+  // Mémoiser les valeurs dérivées
+  const derivedState = useMemo(() => ({
+    isOnline: connectionState === 'online',
+    isOffline: connectionState === 'offline',
+    isChecking: connectionState === 'checking',
+    connectionState,
+  }), [connectionState]);
+
+  // Fonction pour forcer une vérification
+  const forceCheck = useCallback(async () => {
+    return apiClient.forceConnectionCheck();
+  }, []);
+
+  return {
+    ...derivedState,
+    forceCheck,
+  };
+}
+
+/**
+ * Hook spécialisé pour les opérations sur les workflows
+ * Gère gracieusement le mode hors ligne
+ */
+export function useWorkflowApi(options: UseApiClientOptions = {}) {
+  const api = useApiClient<any>({ ...options, silentOffline: true });
+  const { isOffline } = useConnectionState();
+
+  // Charger la liste des workflows
+  const loadWorkflows = useCallback(async () => {
+    if (isOffline) {
+      return []; // Retourner un tableau vide si hors ligne
+    }
+    return api.executeRequest(() => apiClient.getWorkflows());
+  }, [api, isOffline]);
+
+  // Charger un workflow spécifique
+  const loadWorkflow = useCallback(async (workflowId: string) => {
+    if (isOffline) {
+      return null;
+    }
+    return api.executeRequest(() => apiClient.getWorkflow(workflowId));
+  }, [api, isOffline]);
+
+  // Sauvegarder un workflow
+  const saveWorkflow = useCallback(async (workflowData: WorkflowApiData) => {
+    return api.executeRequest(() => apiClient.saveWorkflow(workflowData));
+  }, [api]);
+
+  // Supprimer un workflow
+  const deleteWorkflow = useCallback(async (workflowId: string) => {
+    return api.executeRequest(() => apiClient.deleteWorkflow(workflowId));
+  }, [api]);
+
+  // Valider un workflow
+  const validateWorkflow = useCallback(async (workflowData: WorkflowApiData) => {
+    return api.executeRequest(() => apiClient.validateWorkflow(workflowData));
+  }, [api]);
+
+  return {
+    ...api,
+    isOffline,
+    loadWorkflows,
+    loadWorkflow,
+    saveWorkflow,
+    deleteWorkflow,
+    validateWorkflow,
+  };
+}
+
+/**
+ * Hook spécialisé pour l'exécution de workflows
+ */
+export function useWorkflowExecution(options: UseApiClientOptions = {}) {
+  const api = useApiClient<any>({ ...options, silentOffline: true });
+  const { isOffline } = useConnectionState();
+
+  // Exécuter une étape
+  const executeStep = useCallback(async (stepData: {
+    stepId: string;
+    stepType: string;
+    parameters: any;
+    workflowId?: string;
+  }) => {
+    if (isOffline) {
+      return { success: false, error: 'API hors ligne', offline: true };
+    }
+    return api.executeRequest(() => apiClient.executeStep(stepData));
+  }, [api, isOffline]);
+
+  // Exécuter un workflow complet
+  const executeWorkflow = useCallback(async (workflowId: string, parameters?: any) => {
+    if (isOffline) {
+      return { success: false, error: 'API hors ligne', offline: true };
+    }
+    return api.executeRequest(() => apiClient.executeWorkflow(workflowId, parameters));
+  }, [api, isOffline]);
+
+  return {
+    ...api,
+    isOffline,
+    executeStep,
+    executeWorkflow,
+  };
+}
+
+/**
+ * Hook pour surveiller la santé de l'API
+ * Optimisé pour éviter les re-renders excessifs
+ */
+export function useApiHealth(options: UseApiClientOptions & { 
+  pollInterval?: number;
+  enablePolling?: boolean;
+} = {}) {
+  const { pollInterval = 30000, enablePolling = false } = options;
+  const api = useApiClient<{ status: string; timestamp: string }>({ ...options, silentOffline: true });
+  const intervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
+  const { connectionState, isOnline, forceCheck } = useConnectionState();
+
+  // Vérifier la santé de l'API
+  const checkHealth = useCallback(async () => {
+    return api.executeRequest(() => apiClient.healthCheck(), { skipLoading: true });
+  }, [api]);
+
+  // Démarrer le polling
+  const startPolling = useCallback(() => {
+    if (intervalRef.current) {
+      clearInterval(intervalRef.current);
+    }
+
+    intervalRef.current = setInterval(() => {
+      checkHealth();
+    }, pollInterval);
+
+    // Vérification initiale
+    checkHealth();
+  }, [checkHealth, pollInterval]);
+
+  // Arrêter le polling
+  const stopPolling = useCallback(() => {
+    if (intervalRef.current) {
+      clearInterval(intervalRef.current);
+      intervalRef.current = null;
+    }
+  }, []);
+
+  // Démarrer le polling automatiquement si activé
+  useEffect(() => {
+    if (enablePolling) {
+      startPolling();
+    }
+
+    return () => {
+      stopPolling();
+    };
+  }, [enablePolling, startPolling, stopPolling]);
+
+  return {
+    ...api,
+    checkHealth,
+    startPolling,
+    stopPolling,
+    forceCheck,
+    isHealthy: isOnline,
+    connectionState,
+  };
+}
+
+/**
+ * Hook pour les statistiques de l'API
+ */
+export function useApiStats(options: UseApiClientOptions = {}) {
+  const api = useApiClient<any>({ ...options, silentOffline: true });
+
+  // Charger les statistiques
+  const loadStats = useCallback(async () => {
+    return api.executeRequest(() => apiClient.getApiStats());
+  }, [api]);
+
+  return {
+    ...api,
+    loadStats,
+  };
+}
+
+// Export des types
+export type { RequestState, UseApiClientOptions };

capture_element_cible_vwb_20260109_151052/visual_workflow_builder/frontend/src/services/apiClient.ts

@@ -0,0 +1,713 @@
+/**
+ * Client API - Gestion centralisée des communications avec le Backend_VWB
+ * Auteur : Dom, Alice, Kiro - 09 janvier 2026
+ * 
+ * Ce service centralise toutes les communications avec le backend,
+ * incluant la gestion d'erreurs, retry automatique, validation des données
+ * et gestion gracieuse du mode hors ligne.
+ * 
+ * IMPORTANT: Ce client utilise une initialisation paresseuse (lazy) pour
+ * éviter les boucles infinies de re-render au chargement de la page.
+ */
+
+import { WorkflowApiData } from '../types';
+
+// Configuration du client API
+interface ApiClientConfig {
+  baseUrl: string;
+  timeout: number;
+  maxRetries: number;
+  retryDelay: number;
+  enableRetry: boolean;
+  healthCheckInterval: number;
+}
+
+// Types pour les réponses API
+interface ApiResponse<T = any> {
+  success: boolean;
+  data?: T;
+  error?: string;
+  code?: string;
+  timestamp?: string;
+  offline?: boolean;
+}
+
+interface ApiError {
+  message: string;
+  code?: string;
+  status?: number;
+  details?: any;
+  offline?: boolean;
+}
+
+// État de connexion - 'offline' par défaut pour éviter les appels au montage
+type ConnectionState = 'online' | 'offline' | 'checking';
+
+// Callbacks pour les changements d'état
+type ConnectionStateCallback = (state: ConnectionState) => void;
+
+// Configuration par défaut
+const DEFAULT_CONFIG: ApiClientConfig = {
+  baseUrl: '/api',
+  timeout: 3000, // 3 secondes (réduit pour éviter les attentes longues)
+  maxRetries: 1, // Réduit pour éviter les délais
+  retryDelay: 500, // 500ms
+  enableRetry: false, // Désactivé par défaut pour éviter les boucles
+  healthCheckInterval: 60000, // 60 secondes (augmenté pour réduire les appels)
+};
+
+/**
+ * Client API centralisé pour les communications avec le Backend_VWB
+ * Gère automatiquement le mode hors ligne sans provoquer de re-rendus excessifs
+ * 
+ * ARCHITECTURE:
+ * - État initial: 'offline' (pas de vérification automatique au démarrage)
+ * - Initialisation paresseuse: la vérification se fait au premier appel API
+ * - Pas de timer de health check automatique (évite les re-renders)
+ */
+class ApiClient {
+  private config: ApiClientConfig;
+  private abortController: AbortController | null = null;
+  // État initial 'offline' pour éviter les appels API au montage des composants
+  private connectionState: ConnectionState = 'offline';
+  private stateCallbacks: Set<ConnectionStateCallback> = new Set();
+  private healthCheckTimer: ReturnType<typeof setInterval> | null = null;
+  private lastHealthCheck: number = 0;
+  private isInitialized: boolean = false;
+  private initializationPromise: Promise<void> | null = null;
+
+  constructor(config: Partial<ApiClientConfig> = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+
+  /**
+   * Initialiser le client et vérifier la connexion
+   * Appelé une seule fois au premier appel API (initialisation paresseuse)
+   * Utilise un pattern singleton pour éviter les initialisations multiples
+   */
+  async initialize(): Promise<void> {
+    // Si déjà initialisé, retourner immédiatement
+    if (this.isInitialized) return;
+    
+    // Si une initialisation est en cours, attendre qu'elle se termine
+    if (this.initializationPromise) {
+      return this.initializationPromise;
+    }
+    
+    // Créer la promesse d'initialisation
+    this.initializationPromise = this.doInitialize();
+    
+    try {
+      await this.initializationPromise;
+    } finally {
+      this.initializationPromise = null;
+    }
+  }
+
+  /**
+   * Effectuer l'initialisation réelle
+   */
+  private async doInitialize(): Promise<void> {
+    if (this.isInitialized) return;
+    this.isInitialized = true;
+    
+    // Vérification initiale silencieuse (une seule fois)
+    await this.checkConnectionSilently();
+    
+    // NE PAS démarrer le timer automatique pour éviter les re-renders
+    // Le timer peut être démarré manuellement si nécessaire
+  }
+
+  /**
+   * Vérification silencieuse de la connexion (sans logs excessifs)
+   * Utilise un debounce pour éviter les vérifications trop fréquentes
+   */
+  private async checkConnectionSilently(): Promise<boolean> {
+    const now = Date.now();
+    
+    // Éviter les vérifications trop fréquentes (minimum 10 secondes entre chaque)
+    if (now - this.lastHealthCheck < 10000) {
+      return this.connectionState === 'online';
+    }
+    
+    this.lastHealthCheck = now;
+    
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 2000); // 2 secondes max
+      
+      // Utiliser /api/health selon la configuration
+      const healthUrl = `${this.config.baseUrl}/health`;
+      const response = await fetch(healthUrl, {
+        signal: controller.signal,
+        headers: { 'Accept': 'application/json' },
+      });
+      
+      clearTimeout(timeoutId);
+      
+      if (response.ok) {
+        const contentType = response.headers.get('content-type');
+        if (contentType && contentType.includes('application/json')) {
+          this.setConnectionState('online');
+          return true;
+        }
+      }
+      
+      this.setConnectionState('offline');
+      return false;
+    } catch {
+      this.setConnectionState('offline');
+      return false;
+    }
+  }
+
+  /**
+   * Démarrer le timer de vérification de santé (optionnel)
+   * À appeler manuellement si nécessaire
+   */
+  startHealthCheckTimer(): void {
+    if (this.healthCheckTimer) return;
+    
+    this.healthCheckTimer = setInterval(() => {
+      this.checkConnectionSilently();
+    }, this.config.healthCheckInterval);
+  }
+
+  /**
+   * Arrêter le timer de vérification
+   */
+  stopHealthCheck(): void {
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+      this.healthCheckTimer = null;
+    }
+  }
+
+  /**
+   * Mettre à jour l'état de connexion et notifier les listeners
+   * Utilise un mécanisme de batch pour éviter les notifications multiples
+   */
+  private setConnectionState(state: ConnectionState): void {
+    if (this.connectionState !== state) {
+      this.connectionState = state;
+      // Notifier les callbacks de manière asynchrone pour éviter les boucles
+      setTimeout(() => {
+        this.stateCallbacks.forEach(callback => {
+          try {
+            callback(state);
+          } catch (e) {
+            console.warn('Erreur dans le callback de connexion:', e);
+          }
+        });
+      }, 0);
+    }
+  }
+
+  /**
+   * S'abonner aux changements d'état de connexion
+   * NE notifie PAS immédiatement l'état actuel pour éviter les re-renders au montage
+   */
+  onConnectionStateChange(callback: ConnectionStateCallback): () => void {
+    this.stateCallbacks.add(callback);
+    
+    // NE PAS notifier immédiatement - cela évite les re-renders au montage
+    // L'état sera mis à jour lors du premier appel API ou forceConnectionCheck
+    
+    // Retourner une fonction de désabonnement
+    return () => {
+      this.stateCallbacks.delete(callback);
+    };
+  }
+
+  /**
+   * Obtenir l'état de connexion actuel
+   */
+  getConnectionState(): ConnectionState {
+    return this.connectionState;
+  }
+
+  /**
+   * Vérifier si l'API est en ligne
+   */
+  isOnline(): boolean {
+    return this.connectionState === 'online';
+  }
+
+  /**
+   * Effectuer une requête HTTP avec gestion d'erreurs et retry
+   * Initialisation paresseuse au premier appel
+   */
+  private async makeRequest<T>(
+    endpoint: string,
+    options: RequestInit = {},
+    retryCount = 0
+  ): Promise<ApiResponse<T>> {
+    // Initialisation paresseuse au premier appel API
+    if (!this.isInitialized) {
+      await this.initialize();
+    }
+    
+    // Si hors ligne, retourner immédiatement une réponse offline
+    if (this.connectionState === 'offline' && retryCount === 0) {
+      return {
+        success: false,
+        error: 'API hors ligne - Les données locales sont utilisées',
+        code: 'OFFLINE',
+        offline: true,
+        timestamp: new Date().toISOString(),
+      };
+    }
+
+    // Créer un nouveau AbortController pour cette requête
+    this.abortController = new AbortController();
+    
+    const url = `${this.config.baseUrl}${endpoint}`;
+    const requestOptions: RequestInit = {
+      ...options,
+      signal: this.abortController.signal,
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        ...options.headers,
+      },
+    };
+
+    // Ajouter un timeout
+    const timeoutId = setTimeout(() => {
+      if (this.abortController) {
+        this.abortController.abort();
+      }
+    }, this.config.timeout);
+
+    try {
+      const response = await fetch(url, requestOptions);
+      clearTimeout(timeoutId);
+
+      // Vérifier si la réponse est du JSON
+      const contentType = response.headers.get('content-type');
+      if (!contentType || !contentType.includes('application/json')) {
+        // Le serveur retourne du HTML (probablement le serveur React)
+        this.setConnectionState('offline');
+        return {
+          success: false,
+          error: 'API hors ligne - Le backend n\'est pas démarré',
+          code: 'OFFLINE',
+          offline: true,
+          timestamp: new Date().toISOString(),
+        };
+      }
+
+      // Marquer comme en ligne si la réponse est valide
+      this.setConnectionState('online');
+
+      // Vérifier le statut de la réponse
+      if (!response.ok) {
+        const errorText = await response.text();
+        let errorData: any = {};
+        
+        try {
+          errorData = JSON.parse(errorText);
+        } catch {
+          errorData = { message: errorText };
+        }
+
+        const apiError: ApiError = {
+          message: errorData.message || `Erreur HTTP ${response.status}`,
+          code: errorData.code || `HTTP_${response.status}`,
+          status: response.status,
+          details: errorData,
+        };
+
+        // Retry pour certaines erreurs (5xx, timeouts, network errors)
+        if (this.shouldRetry(response.status) && retryCount < this.config.maxRetries) {
+          await this.delay(this.config.retryDelay * Math.pow(2, retryCount));
+          return this.makeRequest<T>(endpoint, options, retryCount + 1);
+        }
+
+        throw apiError;
+      }
+
+      // Parser la réponse JSON
+      const data = await response.json();
+      
+      return {
+        success: true,
+        data,
+        timestamp: new Date().toISOString(),
+      };
+
+    } catch (error) {
+      clearTimeout(timeoutId);
+
+      // Gestion des erreurs d'abort
+      if (error instanceof Error && error.name === 'AbortError') {
+        this.setConnectionState('offline');
+        return {
+          success: false,
+          error: 'Requête annulée (timeout)',
+          code: 'TIMEOUT',
+          offline: true,
+          timestamp: new Date().toISOString(),
+        };
+      }
+
+      // Gestion des erreurs réseau
+      if (error instanceof TypeError && (error.message.includes('fetch') || error.message.includes('network'))) {
+        this.setConnectionState('offline');
+        
+        // Retry pour les erreurs réseau
+        if (this.config.enableRetry && retryCount < this.config.maxRetries) {
+          await this.delay(this.config.retryDelay * Math.pow(2, retryCount));
+          return this.makeRequest<T>(endpoint, options, retryCount + 1);
+        }
+
+        return {
+          success: false,
+          error: 'Erreur de connexion réseau - API hors ligne',
+          code: 'NETWORK_ERROR',
+          offline: true,
+          timestamp: new Date().toISOString(),
+        };
+      }
+
+      // Re-lancer les autres erreurs
+      throw error;
+    }
+  }
+
+  /**
+   * Déterminer si une erreur justifie un retry
+   */
+  private shouldRetry(status: number): boolean {
+    if (!this.config.enableRetry) return false;
+    return status >= 500 || status === 408 || status === 429;
+  }
+
+  /**
+   * Attendre un délai spécifié
+   */
+  private delay(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Annuler la requête en cours
+   */
+  public cancelRequest(): void {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+  }
+
+  /**
+   * Valider les données d'un workflow avant envoi
+   */
+  private validateWorkflowData(workflow: WorkflowApiData): void {
+    if (!workflow.name || workflow.name.trim().length === 0) {
+      throw new Error('Le nom du workflow est obligatoire');
+    }
+
+    if (workflow.name.length > 100) {
+      throw new Error('Le nom du workflow ne peut pas dépasser 100 caractères');
+    }
+
+    if (workflow.description && workflow.description.length > 500) {
+      throw new Error('La description ne peut pas dépasser 500 caractères');
+    }
+
+    if (!Array.isArray(workflow.steps)) {
+      throw new Error('Les étapes du workflow doivent être un tableau');
+    }
+
+    if (!Array.isArray(workflow.connections)) {
+      throw new Error('Les connexions du workflow doivent être un tableau');
+    }
+
+    if (!Array.isArray(workflow.variables)) {
+      throw new Error('Les variables du workflow doivent être un tableau');
+    }
+  }
+
+  /**
+   * Valider les données d'une étape avant exécution
+   */
+  private validateStepData(stepData: any): void {
+    if (!stepData.stepId || typeof stepData.stepId !== 'string') {
+      throw new Error('L\'ID de l\'étape est obligatoire');
+    }
+
+    if (!stepData.stepType || typeof stepData.stepType !== 'string') {
+      throw new Error('Le type d\'étape est obligatoire');
+    }
+
+    if (!stepData.parameters || typeof stepData.parameters !== 'object') {
+      throw new Error('Les paramètres de l\'étape doivent être un objet');
+    }
+  }
+
+  // === MÉTHODES PUBLIQUES POUR LES WORKFLOWS ===
+
+  /**
+   * Récupérer la liste des workflows
+   * Retourne un tableau vide si hors ligne
+   */
+  async getWorkflows(): Promise<any[]> {
+    try {
+      const response = await this.makeRequest<any[]>('/workflows');
+      if (response.offline) {
+        return []; // Retourner un tableau vide en mode hors ligne
+      }
+      return response.data || [];
+    } catch (error) {
+      console.warn('Erreur lors du chargement des workflows:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Récupérer un workflow par ID
+   */
+  async getWorkflow(workflowId: string): Promise<any | null> {
+    if (!workflowId || workflowId.trim().length === 0) {
+      throw new Error('L\'ID du workflow est obligatoire');
+    }
+
+    try {
+      const response = await this.makeRequest<{ workflow: any }>(`/workflows/${workflowId}`);
+      if (response.offline) {
+        return null;
+      }
+      return response.data?.workflow || response.data;
+    } catch (error) {
+      console.warn(`Erreur lors du chargement du workflow ${workflowId}:`, error);
+      return null;
+    }
+  }
+
+  /**
+   * Sauvegarder un workflow
+   * Retourne null si hors ligne
+   */
+  async saveWorkflow(workflowData: WorkflowApiData): Promise<string | null> {
+    // Validation côté client
+    this.validateWorkflowData(workflowData);
+
+    try {
+      const response = await this.makeRequest<{ workflowId: string; id: string }>('/workflows', {
+        method: 'POST',
+        body: JSON.stringify(workflowData),
+      });
+
+      if (response.offline) {
+        console.warn('Sauvegarde impossible - API hors ligne');
+        return null;
+      }
+
+      return response.data?.workflowId || response.data?.id || '';
+    } catch (error) {
+      console.error('Erreur lors de la sauvegarde du workflow:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Supprimer un workflow
+   */
+  async deleteWorkflow(workflowId: string): Promise<boolean> {
+    if (!workflowId || workflowId.trim().length === 0) {
+      throw new Error('L\'ID du workflow est obligatoire');
+    }
+
+    try {
+      const response = await this.makeRequest(`/workflows/${workflowId}`, {
+        method: 'DELETE',
+      });
+      return !response.offline && response.success;
+    } catch (error) {
+      console.error(`Erreur lors de la suppression du workflow ${workflowId}:`, error);
+      return false;
+    }
+  }
+
+  // === MÉTHODES POUR L'EXÉCUTION ===
+
+  /**
+   * Exécuter une étape de workflow
+   */
+  async executeStep(stepData: {
+    stepId: string;
+    stepType: string;
+    parameters: any;
+    workflowId?: string;
+  }): Promise<{ success: boolean; output?: any; error?: string; offline?: boolean }> {
+    // Validation côté client
+    this.validateStepData(stepData);
+
+    try {
+      const response = await this.makeRequest<{
+        success: boolean;
+        output?: any;
+        error?: string;
+      }>('/workflow/execute-step', {
+        method: 'POST',
+        body: JSON.stringify(stepData),
+      });
+
+      if (response.offline) {
+        return { success: false, error: 'API hors ligne', offline: true };
+      }
+
+      return response.data || { success: false, error: 'Réponse invalide du serveur' };
+    } catch (error) {
+      console.error('Erreur lors de l\'exécution de l\'étape:', error);
+      return { success: false, error: (error as ApiError).message || 'Erreur inconnue' };
+    }
+  }
+
+  /**
+   * Exécuter un workflow complet
+   */
+  async executeWorkflow(workflowId: string, parameters?: any): Promise<{
+    success: boolean;
+    results?: any[];
+    error?: string;
+    offline?: boolean;
+  }> {
+    if (!workflowId || workflowId.trim().length === 0) {
+      throw new Error('L\'ID du workflow est obligatoire');
+    }
+
+    try {
+      const response = await this.makeRequest<{
+        success: boolean;
+        results?: any[];
+        error?: string;
+      }>('/workflow/execute', {
+        method: 'POST',
+        body: JSON.stringify({
+          workflowId,
+          parameters: parameters || {},
+        }),
+      });
+
+      if (response.offline) {
+        return { success: false, error: 'API hors ligne', offline: true };
+      }
+
+      return response.data || { success: false, error: 'Réponse invalide du serveur' };
+    } catch (error) {
+      console.error(`Erreur lors de l'exécution du workflow ${workflowId}:`, error);
+      return { success: false, error: (error as ApiError).message || 'Erreur inconnue' };
+    }
+  }
+
+  // === MÉTHODES POUR LA VALIDATION ===
+
+  /**
+   * Valider un workflow
+   */
+  async validateWorkflow(workflowData: WorkflowApiData): Promise<{
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+    offline?: boolean;
+  }> {
+    // Validation côté client d'abord
+    try {
+      this.validateWorkflowData(workflowData);
+    } catch (error) {
+      return {
+        isValid: false,
+        errors: [(error as ApiError).message],
+        warnings: [],
+      };
+    }
+
+    try {
+      const response = await this.makeRequest<{
+        isValid: boolean;
+        errors: string[];
+        warnings: string[];
+      }>('/workflow/validate', {
+        method: 'POST',
+        body: JSON.stringify(workflowData),
+      });
+
+      if (response.offline) {
+        // En mode hors ligne, faire une validation locale basique
+        return {
+          isValid: true,
+          errors: [],
+          warnings: ['Validation serveur non disponible (mode hors ligne)'],
+          offline: true,
+        };
+      }
+
+      return response.data || {
+        isValid: false,
+        errors: ['Erreur de validation du serveur'],
+        warnings: [],
+      };
+    } catch (error) {
+      console.warn('Erreur lors de la validation du workflow:', error);
+      return {
+        isValid: true,
+        errors: [],
+        warnings: ['Validation serveur non disponible'],
+      };
+    }
+  }
+
+  // === MÉTHODES UTILITAIRES ===
+
+  /**
+   * Vérifier la santé de l'API
+   */
+  async healthCheck(): Promise<{ status: string; timestamp: string; offline?: boolean }> {
+    try {
+      const response = await this.makeRequest<{ status: string; timestamp: string }>('/health');
+      if (response.offline) {
+        return { status: 'offline', timestamp: new Date().toISOString(), offline: true };
+      }
+      return response.data || { status: 'unknown', timestamp: new Date().toISOString() };
+    } catch (error) {
+      return { status: 'offline', timestamp: new Date().toISOString(), offline: true };
+    }
+  }
+
+  /**
+   * Forcer une vérification de connexion
+   */
+  async forceConnectionCheck(): Promise<boolean> {
+    this.lastHealthCheck = 0; // Réinitialiser pour forcer la vérification
+    return this.checkConnectionSilently();
+  }
+
+  /**
+   * Obtenir les statistiques de l'API
+   */
+  async getApiStats(): Promise<any> {
+    try {
+      const response = await this.makeRequest<any>('/stats');
+      if (response.offline) {
+        return { offline: true };
+      }
+      return response.data || {};
+    } catch (error) {
+      console.warn('Erreur lors de la récupération des statistiques:', error);
+      return { offline: true };
+    }
+  }
+}
+
+// Instance singleton du client API
+export const apiClient = new ApiClient();
+
+// NOTE: L'initialisation est maintenant paresseuse (lazy)
+// Elle se fait automatiquement lors du premier appel API
+// Cela évite les boucles infinies au chargement de la page
+
+// Export des types pour utilisation externe
+export type { ApiError, ApiResponse, ApiClientConfig, ConnectionState };
+export default ApiClient;

capture_element_cible_vwb_20260109_151052/visual_workflow_builder/frontend/src/types/index.ts

@@ -0,0 +1,229 @@
+/**
+ * Types partagés pour le Visual Workflow Builder V2
+ * Auteur : Dom, Alice, Kiro - 08 janvier 2026
+ * 
+ * Définitions TypeScript centralisées pour tous les composants.
+ */
+
+// Types de base pour les workflows
+export interface Workflow {
+  id: string;
+  name: string;
+  description?: string;
+  steps: Step[];
+  connections: WorkflowConnection[];
+  variables: Variable[];
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface Step {
+  id: string;
+  type: StepType;
+  name: string;
+  position: Position;
+  data: StepData;
+  executionState?: StepExecutionState;
+  validationErrors?: ValidationError[];
+}
+
+export interface StepData {
+  label: string;
+  stepType: StepType;
+  parameters: Record<string, any>;
+  visualSelection?: VisualSelection;
+  isSelected?: boolean;
+}
+
+export interface WorkflowConnection {
+  id: string;
+  source: string;
+  target: string;
+  type?: string;
+  label?: string;
+}
+
+export interface Position {
+  x: number;
+  y: number;
+}
+
+// Types pour les variables
+export interface Variable {
+  id: string;
+  name: string;
+  type: VariableType;
+  defaultValue?: any;
+  description?: string;
+  value?: any;
+}
+
+export type VariableType = 'text' | 'number' | 'boolean' | 'list';
+
+export enum VariableTypeEnum {
+  TEXT = 'text',
+  NUMBER = 'number',
+  BOOLEAN = 'boolean',
+  LIST = 'list'
+}
+
+// Types pour les étapes
+export type StepType = 
+  | 'click' 
+  | 'type' 
+  | 'wait' 
+  | 'condition' 
+  | 'extract' 
+  | 'scroll'
+  | 'navigate'
+  | 'screenshot';
+
+export enum StepExecutionState {
+  IDLE = 'idle',
+  RUNNING = 'running',
+  SUCCESS = 'success',
+  ERROR = 'error',
+  SKIPPED = 'skipped'
+}
+
+// Types pour la validation
+export interface ValidationError {
+  parameter: string;
+  message: string;
+  severity: 'error' | 'warning';
+}
+
+// Types pour la sélection visuelle
+export interface VisualSelection {
+  id: string;
+  screenshot: string; // Base64 de l'image
+  boundingBox: BoundingBox;
+  embedding?: number[];
+  description?: string;
+}
+
+export interface BoundingBox {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+// Types pour l'exécution
+export interface ExecutionState {
+  currentStep?: string;
+  status: ExecutionStatus;
+  startTime?: Date;
+  endTime?: Date;
+  errors?: ExecutionError[];
+}
+
+export type ExecutionStatus = 'idle' | 'running' | 'completed' | 'error' | 'paused';
+
+export interface ExecutionError {
+  stepId: string;
+  message: string;
+  timestamp: Date;
+}
+
+// Types pour les catégories de la palette
+export interface StepCategory {
+  id: string;
+  name: string;
+  description: string;
+  icon: string;
+  steps: StepTemplate[];
+}
+
+export interface StepTemplate {
+  id: string;
+  type: StepType;
+  name: string;
+  description: string;
+  icon: string;
+  defaultParameters: Record<string, any>;
+  requiredParameters: string[];
+}
+
+// Types pour les propriétés des composants
+export interface CanvasProps {
+  workflow?: Workflow;
+  selectedStep?: Step | null;
+  executionState?: ExecutionState;
+  onStepSelect?: (step: Step | null) => void;
+  onStepMove?: (stepId: string, position: Position) => void;
+  onConnection?: (source: string, target: string) => void;
+  onStepAdd?: (step: Omit<Step, 'id'>) => void;
+  onStepDelete?: (stepId: string) => void;
+}
+
+export interface PaletteProps {
+  categories: StepCategory[];
+  searchTerm: string;
+  onSearch: (term: string) => void;
+  onStepDrag: (stepTemplate: StepTemplate) => void;
+}
+
+export interface PropertiesPanelProps {
+  selectedStep?: Step | null;
+  variables: Variable[];
+  onParameterChange: (stepId: string, parameter: string, value: any) => void;
+  onVisualSelection: (stepId: string) => void;
+}
+
+export interface VariableManagerProps {
+  variables: Variable[];
+  onVariableCreate: (variable: Omit<Variable, 'id'>) => void;
+  onVariableUpdate: (id: string, updates: Partial<Variable>) => void;
+  onVariableDelete: (id: string) => void;
+}
+
+export interface DocumentationTabProps {
+  toolName: string;
+  isActive: boolean;
+  onActivate: () => void;
+}
+
+// Types pour les nœuds ReactFlow
+export interface StepNodeData extends Record<string, unknown> {
+  label: string;
+  stepType: StepType;
+  executionState: StepExecutionState;
+  validationErrors: ValidationError[];
+  isSelected: boolean;
+  parameters: Record<string, any>;
+}
+
+// Types pour l'API
+export interface ApiResponse<T = any> {
+  success: boolean;
+  data?: T;
+  error?: string;
+  message?: string;
+}
+
+export interface WorkflowApiData {
+  id?: string;
+  name: string;
+  description?: string;
+  steps: Step[];
+  connections: WorkflowConnection[];
+  variables: Variable[];
+}
+
+// Types pour les événements
+export interface StepMoveEvent {
+  stepId: string;
+  position: Position;
+}
+
+export interface ConnectionEvent {
+  source: string;
+  target: string;
+}
+
+export interface ParameterChangeEvent {
+  stepId: string;
+  parameter: string;
+  value: any;
+}