matrice-analytics 0.1.70__py3-none-any.whl → 0.1.96__py3-none-any.whl

matrice_analytics/post_processing/face_reg/face_recognition.py

@@ -26,7 +26,10 @@ Configuration options:
 import subprocess
 import logging
 import asyncio
+import json
 import os
+import re
+from pathlib import Path
 log_file = open("pip_jetson_btii.log", "w")
 cmd = ["pip", "install", "httpx"]
 subprocess.run(
@@ -37,7 +40,7 @@ subprocess.run(
     )
 log_file.close()
 
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple, NamedTuple
 import time
 import base64
 import cv2
@@ -46,6 +49,20 @@ import threading
 from datetime import datetime, timezone
 from collections import deque
 
+try:
+    from matrice_common.session import Session
+    HAS_MATRICE_SESSION = True
+except ImportError:
+    Session = None
+    HAS_MATRICE_SESSION = False
+
+try:
+    import redis.asyncio as aioredis
+    HAS_AIREDIS = True
+except ImportError:
+    aioredis = None
+    HAS_AIREDIS = False
+
 from ..core.base import (
     BaseProcessor,
     ProcessingContext,
@@ -65,9 +82,13 @@ from .face_recognition_client import FacialRecognitionClient
 from .people_activity_logging import PeopleActivityLogging
 from .embedding_manager import EmbeddingManager, EmbeddingConfig
 
+# Cache for location names to avoid repeated API calls
+_location_name_cache: Dict[str, str] = {}
+
 
 # ---- Lightweight identity tracking and temporal smoothing (adapted from compare_similarity.py) ---- #
 from collections import deque, defaultdict
+from matrice_common.session import Session
 
 
 
@@ -83,6 +104,545 @@ def _normalize_embedding(vec: List[float]) -> List[float]:
     return arr.tolist()
 
 
+class RedisFaceMatchResult(NamedTuple):
+    staff_id: Optional[str]
+    person_name: str
+    confidence: float
+    employee_id: Optional[str]
+    raw: Dict[str, Any]
+
+
+class RedisFaceMatcher:
+    """Handles Redis-based face similarity search."""
+
+    ACTION_ID_PATTERN = re.compile(r"^[0-9a-f]{8,}$", re.IGNORECASE)
+
+    def __init__(
+        self,
+        session=None,
+        logger: Optional[logging.Logger] = None,
+        redis_url: Optional[str] = None,
+        face_client=None,
+    ) -> None:
+        self.logger = logger or logging.getLogger(__name__)
+        self._session = session
+        self.face_client = face_client
+        self.redis_url = (
+            redis_url
+            or os.getenv("FACE_RECOG_REDIS_URL")
+            or os.getenv("REDIS_URL")
+        )
+        self.stream_name = os.getenv(
+            "FACE_RECOG_REDIS_STREAM", "facial_detection_stream"
+        )
+        self.default_min_confidence = float(
+            os.getenv("FACE_RECOG_REDIS_MIN_CONFIDENCE", "0.01")
+        )
+        self.response_timeout = (
+            float(os.getenv("FACE_RECOG_REDIS_RESPONSE_TIMEOUT_MS", "200")) / 1000.0  # Reduced from 600ms to 200ms for faster failure
+        )
+        self.poll_interval = (
+            float(os.getenv("FACE_RECOG_REDIS_POLL_INTERVAL_MS", "5")) / 1000.0  # Reduced from 20ms to 5ms for faster polling
+        )
+        self.stream_maxlen = int(
+            os.getenv("FACE_RECOG_REDIS_STREAM_MAXLEN", "5000")
+        )
+        self._redis_client = None  # type: ignore[assignment]
+        self._redis_connection_params: Optional[Dict[str, Any]] = None
+        self._app_deployment_id = os.getenv("APP_DEPLOYMENT_ID")
+        self._action_id = (
+            os.getenv("ACTION_ID")
+            or os.getenv("MATRISE_ACTION_ID")
+            or self._discover_action_id()
+        )
+        self._redis_server_id = os.getenv("REDIS_SERVER_ID")
+        self._app_dep_lock = asyncio.Lock()
+        self._session_lock = asyncio.Lock()
+        self._redis_lock = asyncio.Lock()
+        self._redis_warning_logged = False
+
+    def is_available(self) -> bool:
+        return HAS_AIREDIS
+
+    async def match_embedding(
+        self,
+        embedding: List[float],
+        search_id: Optional[str],
+        location: str = "",
+        min_confidence: Optional[float] = None,
+    ) -> Optional[RedisFaceMatchResult]:
+        """Send embedding to Redis stream and wait for match result."""
+        if not HAS_AIREDIS:
+            if not self._redis_warning_logged:
+                self.logger.warning(
+                    "redis.asyncio not available; skipping Redis face matcher flow"
+                )
+                self._redis_warning_logged = True
+            return None
+
+        embedding_list = self._prepare_embedding_list(embedding)
+        if not embedding_list:
+            self.logger.warning(f"Empty embedding list for search_id={search_id}, cannot send to Redis")
+            print(f"WARNING: Empty embedding list for search_id={search_id}, cannot send to Redis")
+            return None
+        
+        if len(embedding_list) == 0:
+            self.logger.warning(f"Embedding list has zero length for search_id={search_id}")
+            print(f"WARNING: Embedding list has zero length for search_id={search_id}")
+            return None
+
+        app_dep_id = await self._ensure_app_deployment_id()
+        if not app_dep_id:
+            return None
+
+        redis_client = await self._ensure_redis_client()
+        if redis_client is None:
+            return None
+
+        resolved_search_id = str(search_id or self._generate_search_id())
+        payload = {
+            "appDepId": app_dep_id,
+            "searchId": resolved_search_id,
+            "embedding": embedding_list,
+            "location": location or "",
+            "minConfidence": float(
+                min_confidence if min_confidence is not None else self.default_min_confidence
+            ),
+        }
+
+        try:
+            self.logger.debug(
+                f"Sending embedding to Redis stream {self.stream_name} with search_id={resolved_search_id}, "
+                f"embedding_len={len(embedding_list)}, minConfidence={payload.get('minConfidence')}"
+            )
+            await redis_client.xadd(
+                self.stream_name,
+                {"data": json.dumps(payload, separators=(",", ":"))},
+                maxlen=self.stream_maxlen,
+                approximate=True,
+            )
+            self.logger.debug(f"Successfully sent embedding to Redis stream for search_id={resolved_search_id}")
+        except Exception as exc:
+            self.logger.error(
+                "Failed to enqueue face embedding to Redis stream %s: %s",
+                self.stream_name,
+                exc,
+                exc_info=True,
+            )
+            print(f"ERROR: Failed to send to Redis stream {self.stream_name}: {exc}")
+            return None
+
+        result_key = f"{resolved_search_id}_{app_dep_id}"
+        deadline = time.monotonic() + self.response_timeout
+        poll_count = 0
+        start_poll_time = time.monotonic()
+        
+        self.logger.debug(f"Waiting for Redis response with key={result_key}, timeout={self.response_timeout:.3f}s")
+
+        # Poll loop - check immediately first, then with intervals
+        while time.monotonic() < deadline:
+            try:
+                raw_value = await redis_client.get(result_key)
+                poll_count += 1
+            except Exception as exc:
+                self.logger.error(
+                    "Failed to read Redis result for key %s: %s",
+                    result_key,
+                    exc,
+                    exc_info=True,
+                )
+                print(f"ERROR: Failed to read Redis result for key {result_key}: {exc}")
+                return None
+
+            if raw_value:
+                await redis_client.delete(result_key)
+                try:
+                    parsed = json.loads(raw_value)
+                except Exception as exc:
+                    parsed = json.loads(raw_value)
+                    self.logger.error(
+                        "Unable to parse Redis face match response: %s",
+                        exc,
+                        exc_info=True,
+                    )
+                    print(f"ERROR: Unable to parse Redis face match response: {exc}")
+                    #return None
+
+                # Log and print the raw Redis response for debugging
+                self.logger.info(f"Redis raw response for search_id={resolved_search_id}: {parsed}")
+                print(f"Redis raw response for search_id={resolved_search_id}: {parsed}")
+
+                match_data = None
+                if isinstance(parsed, list) and parsed:
+                    match_data = parsed[0]
+                    self.logger.info(f"Redis response is array, extracted first element: {match_data}")
+                    print(f"Redis response is array, extracted first element: {match_data}")
+                elif isinstance(parsed, dict):
+                    match_data = parsed
+                    self.logger.info(f"Redis response is dict: {match_data}")
+                    print(f"Redis response is dict: {match_data}")
+                else:
+                    self.logger.warning(f"Redis response is neither list nor dict: {type(parsed)}, value: {parsed}")
+                    print(f"WARNING: Redis response is neither list nor dict: {type(parsed)}, value: {parsed}")
+
+                if not isinstance(match_data, dict):
+                    self.logger.warning(f"match_data is not a dict after extraction: {type(match_data)}, value: {match_data}")
+                    print(f"WARNING: match_data is not a dict after extraction: {type(match_data)}, value: {match_data}")
+                    return None
+
+                staff_id = match_data.get("staffId") or match_data.get("staff_id")
+                if not staff_id:
+                    self.logger.warning(f"No staffId found in match_data: {match_data}")
+                    print(f"WARNING: No staffId found in match_data: {match_data}")
+                    return None
+                person_name = str(match_data.get("name") or "Unknown")
+                confidence = float(match_data.get("conf") or match_data.get("confidence") or 0.0)
+                employee_id = match_data.get("employeeId") or match_data.get("embeddingId")
+
+                # Log the extracted values
+                self.logger.info(
+                    f"Redis match extracted - staff_id={staff_id}, person_name={person_name}, "
+                    f"confidence={confidence}, employee_id={employee_id}"
+                )
+                print(
+                    f"Redis match extracted - staff_id={staff_id}, person_name={person_name}, "
+                    f"confidence={confidence}, employee_id={employee_id}"
+                )
+
+                # Check confidence threshold before returning
+                min_conf = float(min_confidence if min_confidence is not None else self.default_min_confidence)
+                if confidence < min_conf:
+                    self.logger.debug(
+                        f"Redis match confidence {confidence:.3f} below threshold {min_conf:.3f}, rejecting"
+                    )
+                    print(f"Redis match confidence {confidence:.3f} below threshold {min_conf:.3f}, rejecting")
+                    return None
+
+                result = RedisFaceMatchResult(
+                    staff_id=str(staff_id),
+                    person_name=person_name,
+                    confidence=round(confidence, 3),
+                    employee_id=str(employee_id) if employee_id else None,
+                    raw=match_data,
+                )
+                
+                poll_time = (time.monotonic() - start_poll_time) * 1000.0
+                self.logger.info(
+                    f"Redis match result created (polls={poll_count}, poll_time={poll_time:.2f}ms): "
+                    f"staff_id={result.staff_id}, name={result.person_name}, conf={result.confidence}"
+                )
+                print(
+                    f"Redis match result created (polls={poll_count}, poll_time={poll_time:.2f}ms): "
+                    f"staff_id={result.staff_id}, name={result.person_name}, conf={result.confidence}"
+                )
+                
+                return result
+
+            # Use shorter sleep for faster response (already reduced poll_interval to 5ms)
+            await asyncio.sleep(self.poll_interval)
+
+        poll_time = (time.monotonic() - start_poll_time) * 1000.0
+        self.logger.warning(
+            "Timed out waiting for Redis face match result for key %s (timeout=%.3fs, polls=%d, poll_time=%.2fms)",
+            result_key,
+            self.response_timeout,
+            poll_count,
+            poll_time,
+        )
+        print(
+            f"WARNING: Redis timeout for search_id={resolved_search_id} "
+            f"(timeout={self.response_timeout:.3f}s, polls={poll_count}, poll_time={poll_time:.2f}ms)"
+        )
+        return None
+
+    def _prepare_embedding_list(self, embedding: List[float]) -> List[float]:
+        if isinstance(embedding, np.ndarray):
+            return embedding.astype(np.float32).tolist()
+        prepared = []
+        try:
+            for value in embedding:
+                prepared.append(float(value))
+        except Exception:
+            self.logger.debug("Failed to convert embedding to float list", exc_info=True)
+            return []
+        return prepared
+
+    def _generate_search_id(self) -> str:
+        return f"face_{int(time.time() * 1000)}"
+
+    async def _ensure_app_deployment_id(self) -> Optional[str]:
+        if self._app_deployment_id:
+            return self._app_deployment_id
+
+        async with self._app_dep_lock:
+            if self._app_deployment_id:
+                return self._app_deployment_id
+
+            action_id = self._action_id or self._discover_action_id()
+            if not action_id:
+                self.logger.warning(
+                    "Unable to determine action_id for Redis face matcher"
+                )
+                return None
+
+            session = await self._ensure_session()
+            if session is None:
+                return None
+
+            # Use run_in_executor for Python 3.8 compatibility (asyncio.to_thread requires 3.9+)
+            loop = asyncio.get_running_loop()
+            response = await loop.run_in_executor(
+                None, self._fetch_action_details_sync, session, action_id
+            )
+            if not response or not response.get("success", False):
+                self.logger.warning(
+                    "Failed to fetch action details for action_id=%s", action_id
+                )
+                return None
+
+            action_doc = response.get("data", {})
+            action_details = action_doc.get("actionDetails", {})
+            app_dep_id = (
+                action_details.get("app_deployment_id")
+                or action_details.get("appDepId")
+            )
+            redis_server_id = (
+                action_details.get("redis_server_id")
+                or action_details.get("redisServerId")
+                or action_details.get("redis_serverid")
+                or action_details.get("redisServerID")
+            )
+            if not app_dep_id:
+                self.logger.warning(
+                    "app_deployment_id missing in action details for action_id=%s",
+                    action_id,
+                )
+                return None
+
+            self._app_deployment_id = str(app_dep_id)
+            if redis_server_id:
+                self._redis_server_id = str(redis_server_id)
+            self.logger.info(
+                "Resolved app deployment id %s for action_id=%s",
+                self._app_deployment_id,
+                action_id,
+            )
+            return self._app_deployment_id
+
+    async def _ensure_session(self):
+        if self._session or not HAS_MATRICE_SESSION:
+            if not self._session and not HAS_MATRICE_SESSION:
+                self.logger.warning(
+                    "matrice_common.session unavailable; cannot create RPC session for Redis matcher"
+                )
+            return self._session
+
+        async with self._session_lock:
+            if self._session:
+                return self._session
+
+            access_key = os.getenv("MATRICE_ACCESS_KEY_ID")
+            secret_key = os.getenv("MATRICE_SECRET_ACCESS_KEY")
+            account_number = os.getenv("MATRICE_ACCOUNT_NUMBER", "")
+
+            if not access_key or not secret_key:
+                self.logger.warning(
+                    "Missing Matrice credentials; cannot initialize session for Redis matcher"
+                )
+                return None
+
+            try:
+                self._session = Session(
+                    account_number=account_number,
+                    access_key=access_key,
+                    secret_key=secret_key,
+                )
+                self.logger.info("Initialized Matrice session for Redis face matcher")
+            except Exception as exc:
+                self.logger.error(
+                    "Failed to initialize Matrice session for Redis matcher: %s",
+                    exc,
+                    exc_info=True,
+                )
+                self._session = None
+
+            return self._session
+
+    async def _ensure_redis_client(self):
+        if self._redis_client:
+            return self._redis_client
+
+        async with self._redis_lock:
+            if self._redis_client:
+                return self._redis_client
+
+            if not self.redis_url:
+                host = os.getenv("FACE_RECOG_REDIS_HOST")
+                port = os.getenv("FACE_RECOG_REDIS_PORT")
+                if host and port:
+                    self.redis_url = f"redis://{host}:{port}/0"
+
+            if self.redis_url:
+                try:
+                    self._redis_client = aioredis.from_url(
+                        self.redis_url,
+                        decode_responses=True,
+                        health_check_interval=30,
+                    )
+                    self.logger.info(
+                        "Connected Redis face matcher client to %s (stream=%s)",
+                        self.redis_url,
+                        self.stream_name,
+                    )
+                    return self._redis_client
+                except Exception as exc:
+                    self.logger.error(
+                        "Failed to connect to Redis at %s: %s",
+                        self.redis_url,
+                        exc,
+                        exc_info=True,
+                    )
+                    self._redis_client = None
+
+            conn_params = await self._ensure_redis_connection_params()
+            if not conn_params:
+                self.logger.error(
+                    "Redis connection parameters unavailable. Configure FACE_RECOG_REDIS_URL or ensure redis_server_id is set."
+                )
+                return None
+
+            try:
+                self._redis_client = aioredis.Redis(
+                    host=conn_params.get("host"),
+                    port=conn_params.get("port", 6379),
+                    username=conn_params.get("username"),
+                    password=conn_params.get("password") or None,
+                    db=conn_params.get("db", 0),
+                    ssl=conn_params.get("ssl", False),
+                    decode_responses=True,
+                    socket_connect_timeout=conn_params.get("connection_timeout", 120),
+                    socket_timeout=conn_params.get("socket_timeout", 120),
+                    retry_on_timeout=True,
+                    health_check_interval=30,
+                )
+                self.logger.info(
+                    "Connected Redis face matcher client to %s:%s (db=%s, stream=%s)",
+                    conn_params.get("host"),
+                    conn_params.get("port"),
+                    conn_params.get("db"),
+                    self.stream_name,
+                )
+            except Exception as exc:
+                self.logger.error(
+                    "Failed to create Redis client with fetched parameters: %s",
+                    exc,
+                    exc_info=True,
+                )
+                self._redis_client = None
+
+            return self._redis_client
+
+    async def _ensure_redis_connection_params(self) -> Optional[Dict[str, Any]]:
+        if self._redis_connection_params:
+            return self._redis_connection_params
+
+        if not self.face_client:
+            self.logger.warning(
+                "Cannot fetch Redis connection parameters without face_client"
+            )
+            return None
+
+        await self._ensure_app_deployment_id()
+
+        try:
+            response = await self.face_client.get_redis_details()
+        except Exception as exc:
+            self.logger.error(
+                "Failed to fetch Redis details from facial recognition server: %s",
+                exc,
+                exc_info=True,
+            )
+            return None
+
+        if not response or not response.get("success", False):
+            self.logger.warning(
+                "Redis details API returned failure: %s",
+                response,
+            )
+            return None
+
+        data = response.get("data", {})
+        host = data.get("REDIS_IP")
+        port = data.get("REDIS_PORT")
+        password = data.get("REDIS_PASSWORD")
+
+        if not host or not port:
+            self.logger.warning(
+                "Redis details missing REDIS_IP or REDIS_PORT"
+            )
+            return None
+
+        try:
+            params = {
+                "host": host,
+                "port": int(port),
+                "password": password or None,
+                "username": None,
+                "db": 0,
+                "connection_timeout": 120,
+                "socket_timeout": 120,
+                "ssl": False,
+            }
+        except Exception as exc:
+            self.logger.error(
+                "Invalid Redis connection config: %s",
+                exc,
+                exc_info=True,
+            )
+            return None
+
+        self._redis_connection_params = params
+        return self._redis_connection_params
+
+    @classmethod
+    def _discover_action_id(cls) -> Optional[str]:
+        candidates: List[str] = []
+        try:
+            cwd = Path.cwd()
+            candidates.append(cwd.name)
+            for parent in cwd.parents:
+                candidates.append(parent.name)
+        except Exception:
+            pass
+
+        try:
+            usr_src = Path("/usr/src")
+            if usr_src.exists():
+                for child in usr_src.iterdir():
+                    if child.is_dir():
+                        candidates.append(child.name)
+        except Exception:
+            pass
+
+        for candidate in candidates:
+            if candidate and len(candidate) >= 8 and cls.ACTION_ID_PATTERN.match(candidate):
+                return candidate
+        return None
+
+    def _fetch_action_details_sync(self, session, action_id: str) -> Optional[Dict[str, Any]]:
+        url = f"/v1/actions/action/{action_id}/details"
+        try:
+            return session.rpc.get(url)
+        except Exception as exc:
+            self.logger.error(
+                "Failed to fetch action details for action_id=%s: %s",
+                action_id,
+                exc,
+                exc_info=True,
+            )
+            return None
+
+
 ## Removed FaceTracker fallback (using AdvancedTracker only)
 
 
@@ -97,8 +657,9 @@ class TemporalIdentityManager:
     def __init__(
         self,
         face_client: FacialRecognitionClient,
-        embedding_manager = None,
-        recognition_threshold: float = 0.35,
+        embedding_manager=None,
+        redis_matcher: Optional[RedisFaceMatcher] = None,
+        recognition_threshold: float = 0.3,
         history_size: int = 20,
         unknown_patience: int = 7,
         switch_patience: int = 5,
@@ -107,12 +668,14 @@ class TemporalIdentityManager:
         self.logger = logging.getLogger(__name__)
         self.face_client = face_client
         self.embedding_manager = embedding_manager
+        self.redis_matcher = redis_matcher
         self.threshold = float(recognition_threshold)
         self.history_size = int(history_size)
         self.unknown_patience = int(unknown_patience)
         self.switch_patience = int(switch_patience)
         self.fallback_margin = float(fallback_margin)
         self.tracks: Dict[Any, Dict[str, object]] = {}
+        self.emb_run=False
 
     def _ensure_track(self, track_id: Any) -> None:
         if track_id not in self.tracks:
@@ -128,7 +691,13 @@ class TemporalIdentityManager:
                 "streaks": defaultdict(int),  # staff_id -> consecutive frames
             }
 
-    async def _compute_best_identity(self, emb: List[float], location: str = "", timestamp: str = "") -> Tuple[Optional[str], str, float, Optional[str], Dict[str, Any], str]:
+    async def _compute_best_identity(
+        self,
+        emb: List[float],
+        location: str = "",
+        timestamp: str = "",
+        search_id: Optional[str] = None,
+    ) -> Tuple[Optional[str], str, float, Optional[str], Dict[str, Any], str]:
         """
         Find best identity match using local similarity search (fast) with optional API fallback.
         Returns (staff_id, person_name, score, employee_id, staff_details, detection_type).
@@ -138,11 +707,86 @@ class TemporalIdentityManager:
         """
         if not emb or not isinstance(emb, list):
             return None, "Unknown", 0.0, None, {}, "unknown"
-        
-        st10 = time.time()
-        
+
+        #--------------  New Redis API Fast Call Start------------------------------------------------------------------------------------------------------------------------------
+        # ALWAYS attempt Redis match for every detection (required for every frame)
+        if self.redis_matcher:
+            try:
+                self.logger.debug(f"Attempting Redis match for search_id={search_id}, embedding_len={len(emb) if emb else 0}")
+                redis_start_time = time.time()
+                redis_match = await self.redis_matcher.match_embedding(
+                    embedding=emb,
+                    search_id=search_id,
+                    location=location or "",
+                    min_confidence=self.threshold,  # Use recognition threshold instead of default_min_confidence
+                )
+                redis_latency_ms = (time.time() - redis_start_time) * 1000.0
+                
+                if redis_match:
+                    self.logger.info(
+                        f"Redis match found in {redis_latency_ms:.2f}ms - staff_id={redis_match.staff_id}, "
+                        f"person_name={redis_match.person_name}, confidence={redis_match.confidence:.3f}"
+                    )
+                    print(
+                        f"Redis match found in {redis_latency_ms:.2f}ms - staff_id={redis_match.staff_id}, "
+                        f"person_name={redis_match.person_name}, confidence={redis_match.confidence:.3f}"
+                    )
+                    
+                    if redis_match.staff_id:
+                        staff_details = (
+                            dict(redis_match.raw) if isinstance(redis_match.raw, dict) else {}
+                        )
+                        if redis_match.person_name and not staff_details.get("name"):
+                            staff_details["name"] = redis_match.person_name
+                        
+                        # Check if confidence meets threshold
+                        if float(redis_match.confidence) >= self.threshold:
+                            self.logger.info(
+                                "Redis embedding match ACCEPTED - staff_id=%s, person_name=%s, score=%.3f (threshold=%.3f)",
+                                redis_match.staff_id,
+                                redis_match.person_name,
+                                float(redis_match.confidence),
+                                self.threshold,
+                            )
+                            print(
+                                f"Redis embedding match ACCEPTED - staff_id={redis_match.staff_id}, "
+                                f"person_name={redis_match.person_name}, score={redis_match.confidence:.3f} "
+                                f"(threshold={self.threshold:.3f})"
+                            )
+                            return (
+                                str(redis_match.staff_id),
+                                redis_match.person_name or "Unknown",
+                                float(redis_match.confidence),
+                                redis_match.employee_id,
+                                staff_details,
+                                "known",
+                            )
+                        else:
+                            self.logger.debug(
+                                "Redis embedding match REJECTED - confidence %.3f below threshold %.3f",
+                                float(redis_match.confidence),
+                                self.threshold,
+                            )
+                            print(
+                                f"Redis embedding match REJECTED - confidence {redis_match.confidence:.3f} "
+                                f"below threshold {self.threshold:.3f}"
+                            )
+                    else:
+                        self.logger.warning("Redis match returned but staff_id is None/empty")
+                        print("WARNING: Redis match returned but staff_id is None/empty")
+                else:
+                    self.logger.debug(f"No Redis match found for search_id={search_id} (took {redis_latency_ms:.2f}ms)")
+                    print(f"No Redis match found for search_id={search_id} (took {redis_latency_ms:.2f}ms)")
+            except Exception as exc:
+                self.logger.warning(
+                    "Redis face match flow failed; falling back to local search: %s",
+                    exc,
+                    exc_info=True,
+                )
+                print(f"Redis face match flow failed: {exc}")
+        #--------------  New Redis API Fast Call END------------------------------------------------------------------------------------------------------------------------------
         # PRIMARY PATH: Local similarity search using EmbeddingManager (FAST - ~1-5ms)
-        if self.embedding_manager:
+        if self.embedding_manager and self.emb_run:
             # Defensive check: ensure embeddings are loaded before attempting search
             if not self.embedding_manager.is_ready():
                 status = self.embedding_manager.get_status()
@@ -169,10 +813,6 @@ class TemporalIdentityManager:
                         elif first_name or last_name:
                             person_name = f"{first_name or ''} {last_name or ''}".strip() or "Unknown"
                     
-                    # print("------------------FACE RECOG TEMPORAL IDENTITY MANAGER UPDATE - COMPUTE BEST IDENTITY (LOCAL)----------------------------")
-                    # print("LATENCY:",(time.time() - st10)*1000,"| Throughput fps:",(1.0 / (time.time() - st10)) if (time.time() - st10) > 0 else None)
-                    # print(f"LOCAL MATCH: staff_id={staff_embedding.staff_id}, similarity={similarity_score:.3f}")
-                    # print("------------------FACE RECOG TEMPORAL IDENTITY MANAGER UPDATE - COMPUTE BEST IDENTITY (LOCAL)----------------------------")
                     
                     self.logger.info(f"Local embedding match - staff_id={staff_embedding.staff_id}, person_name={person_name}, score={similarity_score:.3f}")
                     
@@ -192,10 +832,6 @@ class TemporalIdentityManager:
                     except Exception:
                         pass
                     self.logger.debug(f"No local match found - best_similarity={best_sim:.3f}, threshold={self.threshold:.3f}")
-                    # print("------------------FACE RECOG TEMPORAL IDENTITY MANAGER UPDATE - COMPUTE BEST IDENTITY (LOCAL - NO MATCH)----------------------------")
-                    # print("LATENCY:",(time.time() - st10)*1000,"| Throughput fps:",(1.0 / (time.time() - st10)) if (time.time() - st10) > 0 else None)
-                    # print(f"BEST_SIM={best_sim:.3f} THRESH={self.threshold:.3f}")
-                    # print("------------------FACE RECOG TEMPORAL IDENTITY MANAGER UPDATE - COMPUTE BEST IDENTITY (LOCAL - NO MATCH)----------------------------")
                     
                     return None, "Unknown", 0.0, None, {}, "unknown"
                     
@@ -203,74 +839,83 @@ class TemporalIdentityManager:
                 self.logger.warning(f"Local similarity search failed, falling back to API: {e}")
                 # Fall through to API call below
         
+#---------------------------------BACKUP MONGODB API SLOW CALL--------------------------------------------------------------------------------------
         # FALLBACK PATH: API call (SLOW - ~2000ms) - only if embedding manager not available
         # This path should rarely be used in production
-        try:
-            self.logger.warning("Using slow API fallback for identity search - consider checking embedding manager initialization")
-            resp = await self.face_client.search_similar_faces(
-                face_embedding=emb,
-                threshold=0.01,  # low threshold to always get top-1
-                limit=1,
-                collection="staff_enrollment",
-                location=location,
-                timestamp=timestamp,
-            )
-            # print("------------------FACE RECOG TEMPORAL IDENTITY MANAGER UPDATE - COMPUTE BEST IDENTITY (API FALLBACK)----------------------------")
-            # print("LATENCY:",(time.time() - st10)*1000,"| Throughput fps:",(1.0 / (time.time() - st10)) if (time.time() - st10) > 0 else None)
-            # print("WARNING: Using slow API fallback!")
-            # print("------------------FACE RECOG TEMPORAL IDENTITY MANAGER UPDATE - COMPUTE BEST IDENTITY (API FALLBACK)----------------------------")
-
-        except Exception as e:
-            self.logger.error(f"API ERROR: Failed to search similar faces in _compute_best_identity: {e}", exc_info=True)
-            return None, "Unknown", 0.0, None, {}, "unknown"
+        # try:
+        #     self.logger.warning("Using slow API fallback for identity search - consider checking embedding manager initialization")
+        #     resp = await self.face_client.search_similar_faces(
+        #         face_embedding=emb,
+        #         threshold=0.01,  # low threshold to always get top-1
+        #         limit=1,
+        #         collection="staff_enrollment",
+        #         location=location,
+        #         timestamp=timestamp,
+        #     )
+            
 
-        try:
-            results: List[Any] = []
-            self.logger.debug('API Response received for identity search')
-            if isinstance(resp, dict):
-                if isinstance(resp.get("data"), list):
-                    results = resp.get("data", [])
-                elif isinstance(resp.get("results"), list):
-                    results = resp.get("results", [])
-                elif isinstance(resp.get("items"), list):
-                    results = resp.get("items", [])
-            elif isinstance(resp, list):
-                results = resp
-
-            if not results:
-                self.logger.debug("No identity match found from API")
-                return None, "Unknown", 0.0, None, {}, "unknown"
+        # except Exception as e:
+        #     self.logger.error(f"API ERROR: Failed to search similar faces in _compute_best_identity: {e}", exc_info=True)
+        #     return None, "Unknown", 0.0, None, {}, "unknown"
 
-            item = results[0] if isinstance(results, list) else results
-            self.logger.debug(f'Top-1 match from API: {item}')
-            # Be defensive with keys and types
-            staff_id = item.get("staffId") if isinstance(item, dict) else None
-            employee_id = str(item.get("_id")) if isinstance(item, dict) and item.get("_id") is not None else None
-            score = float(item.get("score", 0.0)) if isinstance(item, dict) else 0.0
-            detection_type = str(item.get("detectionType", "unknown")) if isinstance(item, dict) else "unknown"
-            staff_details = item.get("staffDetails", {}) if isinstance(item, dict) else {}
-            # Extract a person name from staff_details
-            person_name = "Unknown"
-            if isinstance(staff_details, dict) and staff_details:
-                first_name = staff_details.get("firstName")
-                last_name = staff_details.get("lastName")
-                name = staff_details.get("name")
-                if name:
-                    person_name = str(name)
-                else:
-                    if first_name or last_name:
-                        person_name = f"{first_name or ''} {last_name or ''}".strip() or "UnknowNN" #TODO:ebugging change to normal once done
-            # If API says unknown or missing staff_id, treat as unknown
-            if not staff_id: #or detection_type == "unknown"
-                self.logger.debug(f"API returned unknown or missing staff_id - score={score}, employee_id={employee_id}")
-                return None, "Unknown", float(score), employee_id, staff_details if isinstance(staff_details, dict) else {}, "unknown"
-            self.logger.info(f"API identified face - staff_id={staff_id}, person_name={person_name}, score={score:.3f}")
-            return str(staff_id), person_name, float(score), employee_id, staff_details if isinstance(staff_details, dict) else {}, "known"
-        except Exception as e:
-            self.logger.error(f"Error parsing API response in _compute_best_identity: {e}", exc_info=True)
-            return None, "Unknown", 0.0, None, {}, "unknown"
+        # try:
+        #     results: List[Any] = []
+        #     self.logger.debug('API Response received for identity search')
+        #     if isinstance(resp, dict):
+        #         if isinstance(resp.get("data"), list):
+        #             results = resp.get("data", [])
+        #         elif isinstance(resp.get("results"), list):
+        #             results = resp.get("results", [])
+        #         elif isinstance(resp.get("items"), list):
+        #             results = resp.get("items", [])
+        #     elif isinstance(resp, list):
+        #         results = resp
+
+        #     if not results:
+        #         self.logger.debug("No identity match found from API")
+        #         return None, "Unknown", 0.0, None, {}, "unknown"
+
+        #     item = results[0] if isinstance(results, list) else results
+        #     self.logger.debug(f'Top-1 match from API: {item}')
+        #     # Be defensive with keys and types
+        #     staff_id = item.get("staffId") if isinstance(item, dict) else None
+        #     employee_id = str(item.get("_id")) if isinstance(item, dict) and item.get("_id") is not None else None
+        #     score = float(item.get("score", 0.0)) if isinstance(item, dict) else 0.0
+        #     detection_type = str(item.get("detectionType", "unknown")) if isinstance(item, dict) else "unknown"
+        #     staff_details = item.get("staffDetails", {}) if isinstance(item, dict) else {}
+        #     # Extract a person name from staff_details
+        #     person_name = "Unknown"
+        #     if isinstance(staff_details, dict) and staff_details:
+        #         first_name = staff_details.get("firstName")
+        #         last_name = staff_details.get("lastName")
+        #         name = staff_details.get("name")
+        #         if name:
+        #             person_name = str(name)
+        #         else:
+        #             if first_name or last_name:
+        #                 person_name = f"{first_name or ''} {last_name or ''}".strip() or "UnknowNN" #TODO:ebugging change to normal once done
+        #     # If API says unknown or missing staff_id, treat as unknown
+        #     if not staff_id: #or detection_type == "unknown"
+        #         self.logger.debug(f"API returned unknown or missing staff_id - score={score}, employee_id={employee_id}")
+        #         return None, "Unknown", float(score), employee_id, staff_details if isinstance(staff_details, dict) else {}, "unknown"
+        #     self.logger.info(f"API identified face - staff_id={staff_id}, person_name={person_name}, score={score:.3f}")
+        #     return str(staff_id), person_name, float(score), employee_id, staff_details if isinstance(staff_details, dict) else {}, "known"
+        # except Exception as e:
+        #     self.logger.error(f"Error parsing API response in _compute_best_identity: {e}", exc_info=True)
+        #     return None, "Unknown", 0.0, None, {}, "unknown"
+#---------------------------------BACKUP MONGODB API SLOW CALL--------------------------------------------------------------------------------------
+
+        # If we reach here, no match was found through any method
+        self.logger.debug("No identity match found - returning unknown")
+        return None, "Unknown", 0.0, None, {}, "unknown"
 
-    async def _compute_best_identity_from_history(self, track_state: Dict[str, object], location: str = "", timestamp: str = "") -> Tuple[Optional[str], str, float, Optional[str], Dict[str, Any], str]:
+    async def _compute_best_identity_from_history(
+        self,
+        track_state: Dict[str, object],
+        location: str = "",
+        timestamp: str = "",
+        search_id: Optional[str] = None,
+    ) -> Tuple[Optional[str], str, float, Optional[str], Dict[str, Any], str]:
         hist: deque = track_state.get("embedding_history", deque())  # type: ignore
         if not hist:
             return None, "Unknown", 0.0, None, {}, "unknown"
@@ -281,7 +926,12 @@ class TemporalIdentityManager:
         except Exception as e:
             self.logger.error(f"Error computing prototype from history: {e}", exc_info=True)
             proto_list = []
-        return await self._compute_best_identity(proto_list, location=location, timestamp=timestamp)
+        return await self._compute_best_identity(
+            proto_list,
+            location=location,
+            timestamp=timestamp,
+            search_id=search_id,
+        )
 
     async def update(
         self,
@@ -290,6 +940,7 @@ class TemporalIdentityManager:
         eligible_for_recognition: bool,
         location: str = "",
         timestamp: str = "",
+        search_id: Optional[str] = None,
     ) -> Tuple[Optional[str], str, float, Optional[str], Dict[str, Any], str]:
         """
         Update temporal identity state for a track and return a stabilized identity.
@@ -321,7 +972,7 @@ class TemporalIdentityManager:
         if eligible_for_recognition and emb:
             st8=time.time()
             staff_id, person_name, inst_score, employee_id, staff_details, det_type = await self._compute_best_identity(
-                emb, location=location, timestamp=timestamp
+                emb, location=location, timestamp=timestamp, search_id=search_id
             )
             # print("------------------FACE RECOG TEMPORAL IDENTITY MANAGER UPDATE - COMPUTE BEST IDENTITY_I----------------------------")
             # print("LATENCY:",(time.time() - st8)*1000,"| Throughput fps:",(1.0 / (time.time() - st8)) if (time.time() - st8) > 0 else None)
@@ -386,7 +1037,10 @@ class TemporalIdentityManager:
 
             # Fallback: use prototype from history
             st9=time.time()
-            fb_staff_id, fb_name, fb_score, fb_employee_id, fb_details, fb_type = await self._compute_best_identity_from_history(s, location=location, timestamp=timestamp)
+            history_search_id = f"{search_id}_hist" if search_id else None
+            fb_staff_id, fb_name, fb_score, fb_employee_id, fb_details, fb_type = await self._compute_best_identity_from_history(
+                s, location=location, timestamp=timestamp, search_id=history_search_id
+            )
             # print("------------------FACE RECOG TEMPORAL IDENTITY MANAGER UPDATE - COMPUTE BEST IDENTITY FROM HISTORY----------------------------")
             # print("LATENCY:",(time.time() - st9)*1000,"| Throughput fps:",(1.0 / (time.time() - st9)) if (time.time() - st9) > 0 else None)
             # print("------------------FACE RECOG TEMPORAL IDENTITY MANAGER UPDATE - COMPUTE BEST IDENTITY FROM HISTORY----------------------------")
@@ -427,9 +1081,9 @@ class FaceRecognitionEmbeddingConfig(BaseConfig):
     smoothing_confidence_range_factor: float = 0.5
 
     # Base confidence threshold (separate from embedding similarity threshold)
-    similarity_threshold: float = 0.2  # Lowered to match local code - 0.45 was too conservative
+    similarity_threshold: float = 0.3  # Lowered to match local code - 0.45 was too conservative
     # Base confidence threshold (separate from embedding similarity threshold)
-    confidence_threshold: float = 0.1  # Detection confidence threshold
+    confidence_threshold: float = 0.06  # Detection confidence threshold
     
     # Face recognition optional features
     enable_face_tracking: bool = True  # Enable BYTE TRACKER advanced face tracking -- KEEP IT TRUE ALWAYS
@@ -523,6 +1177,7 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
 
         # Initialize EmbeddingManager - will be configured in process method
         self.embedding_manager = None
+        self.redis_face_matcher = None
         # Temporal identity manager for API-based top-1 identity smoothing
         self.temporal_identity_manager = None
         # Removed lightweight face tracker fallback; we always use AdvancedTracker
@@ -542,7 +1197,7 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         # Initialization must be done by calling await initialize(config) after instantiation
         # This is handled in PostProcessor._get_use_case_instance()
 
-    async def initialize(self, config: Optional[FaceRecognitionEmbeddingConfig] = None) -> None:
+    async def initialize(self, config: Optional[FaceRecognitionEmbeddingConfig] = None, emb:bool=False) -> None:
         """
         Async initialization method to set up face client and all components.
         Must be called after __init__ before process() can be called.
@@ -563,7 +1218,7 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         
         Args:
             config: Optional config to use. If not provided, uses config from __init__.
-            
+            emb: Optional boolean to indicate if embedding manager should be loaded. If True, embedding manager will be loaded.
         Raises:
             RuntimeError: If embeddings fail to load or verification fails
         """
@@ -584,69 +1239,80 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             raise TypeError(f"Invalid config type for initialization: {type(init_config)}, expected FaceRecognitionEmbeddingConfig")
             
         self.logger.info("Initializing face recognition use case with provided config")
-        
+        # print("=============== STEP 1: INITIALIZING FACE CLIENT ===============")
         
         # Initialize face client (includes deployment update)
         try:
             self.face_client = await self._get_facial_recognition_client(init_config)
-            
+            # print(f"=============== FACE CLIENT INITIALIZED: {self.face_client is not None} ===============")
             
             # Initialize People activity logging if enabled
             if init_config.enable_people_activity_logging:
                 self.people_activity_logging = PeopleActivityLogging(self.face_client)
                 # PeopleActivityLogging starts its background thread in __init__
                 self.logger.info("People activity logging enabled and started")
+
+            # Initialize Redis face matcher for fast remote similarity search
+            try:
+                redis_session = getattr(self.face_client, "session", None)
+            except Exception:
+                redis_session = None
+            self.redis_face_matcher = RedisFaceMatcher(
+                session=redis_session,
+                logger=self.logger,
+                face_client=self.face_client,
+            )
             
             # Initialize EmbeddingManager
-            
             if not init_config.embedding_config:
-                
-                init_config.embedding_config = EmbeddingConfig(
-                    similarity_threshold=init_config.similarity_threshold,
-                    confidence_threshold=init_config.confidence_threshold,
-                    enable_track_id_cache=init_config.enable_track_id_cache,
-                    cache_max_size=init_config.cache_max_size,
-                    cache_ttl=3600,
-                    background_refresh_interval=43200,
-                    staff_embeddings_cache_ttl=43200,
-                )
+                    
+                    init_config.embedding_config = EmbeddingConfig(
+                        similarity_threshold=init_config.similarity_threshold,
+                        confidence_threshold=init_config.confidence_threshold,
+                        enable_track_id_cache=init_config.enable_track_id_cache,
+                        cache_max_size=init_config.cache_max_size,
+                        cache_ttl=3600,
+                        background_refresh_interval=43200,
+                        staff_embeddings_cache_ttl=43200,
+                    )
             self.embedding_manager = EmbeddingManager(init_config.embedding_config, self.face_client)
-            
+                
             self.logger.info("Embedding manager initialized")
+            if emb:
+                                
+                # Load staff embeddings immediately for fast startup (avoid race conditions)
+                # This MUST succeed before we can proceed - fail fast if it doesn't
+                
+                embeddings_loaded = await self.embedding_manager._load_staff_embeddings()
+                               
+                if not embeddings_loaded:
+                    error_msg = "CRITICAL: Failed to load staff embeddings at initialization - cannot proceed without embeddings"
+                    print(f"=============== {error_msg} ===============")
+                    self.logger.error(error_msg)
+                    raise RuntimeError(error_msg)
+                
+                # Verify embeddings are actually loaded using is_ready() method
+                if not self.embedding_manager.is_ready():
+                    status = self.embedding_manager.get_status()
+                    error_msg = f"CRITICAL: Embeddings not ready after load - status: {status}"
+                    print(f"=============== {error_msg} ===============")
+                    self.logger.error(error_msg)
+                    raise RuntimeError(error_msg)
+                
+                self.logger.info(f"Successfully loaded {len(self.embedding_manager.staff_embeddings)} staff embeddings at initialization")
             
-            embeddings_loaded = await self.embedding_manager._load_staff_embeddings()
-            
-            
-            if not embeddings_loaded:
-                error_msg = "CRITICAL: Failed to load staff embeddings at initialization - cannot proceed without embeddings"
-                print(f"=============== {error_msg} ===============")
-                self.logger.error(error_msg)
-                raise RuntimeError(error_msg)
-            
-            # Verify embeddings are actually loaded using is_ready() method
-            if not self.embedding_manager.is_ready():
-                status = self.embedding_manager.get_status()
-                error_msg = f"CRITICAL: Embeddings not ready after load - status: {status}"
-                print(f"=============== {error_msg} ===============")
-                self.logger.error(error_msg)
-                raise RuntimeError(error_msg)
-            
-            # print(f"=============== STAFF EMBEDDINGS COUNT: {len(self.embedding_manager.staff_embeddings)} ===============")
-            # print(f"=============== EMBEDDINGS MATRIX SHAPE: {self.embedding_manager.embeddings_matrix.shape} ===============")
-            # print(f"=============== EMBEDDINGS LOADED FLAG: {self.embedding_manager._embeddings_loaded} ===============")
-            self.logger.info(f"Successfully loaded {len(self.embedding_manager.staff_embeddings)} staff embeddings at initialization")
-            
-            # NOW start background refresh after successful initial load (prevents race conditions)
-            if init_config.embedding_config.enable_background_refresh:
-                # print("=============== STEP 4: STARTING BACKGROUND REFRESH ===============")
-                self.embedding_manager.start_background_refresh()
-                self.logger.info("Background embedding refresh started after successful initial load")
+                # NOW start background refresh after successful initial load (prevents race conditions)
+                if init_config.embedding_config.enable_background_refresh:
+                    # print("=============== STEP 4: STARTING BACKGROUND REFRESH ===============")
+                    self.embedding_manager.start_background_refresh()
+                    self.logger.info("Background embedding refresh started after successful initial load")
             
             # Initialize TemporalIdentityManager with EmbeddingManager for fast local search
             # print("=============== STEP 5: INITIALIZING TEMPORAL IDENTITY MANAGER ===============")
             self.temporal_identity_manager = TemporalIdentityManager(
                 face_client=self.face_client,
                 embedding_manager=self.embedding_manager,
+                 redis_matcher=self.redis_face_matcher,
                 recognition_threshold=float(init_config.similarity_threshold),
                 history_size=20,
                 unknown_patience=7,
@@ -656,24 +1322,117 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             self.logger.info("Temporal identity manager initialized with embedding manager for local similarity search")
             
             # Final verification before marking as initialized
-
-            if not self.embedding_manager.is_ready():
-                status = self.embedding_manager.get_status()
-                error_msg = f"CRITICAL: Final verification failed - embeddings not ready. Status: {status}"
-                print(f"=============== {error_msg} ===============")
-                self.logger.error(error_msg)
-                raise RuntimeError(error_msg)
             
-            # Log detailed status for debugging
-            status = self.embedding_manager.get_status()
+            # if not self.embedding_manager.is_ready():
+            #     status = self.embedding_manager.get_status()
+            #     error_msg = f"CRITICAL: Final verification failed - embeddings not ready. Status: {status}"
+            #     print(f"=============== {error_msg} ===============")
+            #     self.logger.error(error_msg)
+            #     raise RuntimeError(error_msg)
+            
+            # # Log detailed status for debugging
+            # status = self.embedding_manager.get_status()
+
             
             self._initialized = True
             self.logger.info("Face recognition use case fully initialized and verified")
-                        
+                      
         except Exception as e:
             self.logger.error(f"Error during use case initialization: {e}", exc_info=True)
             raise RuntimeError(f"Failed to initialize face recognition use case: {e}") from e
 
+    def _extract_camera_info_from_stream(self, stream_info: Optional[Dict[str, Any]]) -> Dict[str, str]:
+        """
+        Extract camera_name, camera_id, and location_id from stream_info.
+        
+        Args:
+            stream_info: Stream information dictionary
+            
+        Returns:
+            Dict with camera_name, camera_id, location_id
+        """
+        camera_name = ""
+        camera_id = ""
+        location_id = ""
+        
+        if not stream_info:
+            return {"camera_name": camera_name, "camera_id": camera_id, "location_id": location_id}
+        
+        # Extract camera_name from camera_info
+        camera_info = stream_info.get("camera_info", {})
+        if camera_info:
+            camera_name = camera_info.get("camera_name", "")
+            location_id = camera_info.get("location", "")
+        
+        # Extract camera_id from topic (format: {camera_id}_input_topic)
+        topic = stream_info.get("topic", "")
+        if topic and "_input_topic" in topic:
+            camera_id = topic.replace("_input_topic", "")
+        
+        self.logger.debug(f"Extracted camera info - camera_name: '{camera_name}', camera_id: '{camera_id}', location_id: '{location_id}'")
+        
+        return {"camera_name": camera_name, "camera_id": camera_id, "location_id": location_id}
+
+    async def _fetch_location_name(self, location_id: str) -> str:
+        """
+        Fetch location name from API using location_id.
+        
+        Args:
+            location_id: The location ID to look up
+            
+        Returns:
+            Location name string, or 'Entry Reception' as default if API fails
+        """
+        global _location_name_cache
+        default_location = "Entry Reception"
+        
+        if not location_id:
+            self.logger.debug(f"[LOCATION] No location_id provided, using default: '{default_location}'")
+            return default_location
+        
+        # Check cache first
+        if location_id in _location_name_cache:
+            cached_name = _location_name_cache[location_id]
+            self.logger.debug(f"[LOCATION] Using cached location name for '{location_id}': '{cached_name}'")
+            return cached_name
+        
+        # Need a session to make API call
+        if not self.face_client or not hasattr(self.face_client, 'session') or not self.face_client.session:
+            self.logger.warning(f"[LOCATION] No session available, using default: '{default_location}'")
+            return default_location
+        
+        try:
+            endpoint = f"/v1/inference/get_location/{location_id}"
+            self.logger.info(f"[LOCATION] Fetching location name from API: {endpoint}")
+            
+            response = self.face_client.session.rpc.get(endpoint)
+            
+            if response and isinstance(response, dict):
+                success = response.get("success", False)
+                if success:
+                    data = response.get("data", {})
+                    location_name = data.get("locationName", default_location)
+                    self.logger.info(f"[LOCATION] ✓ Fetched location name: '{location_name}' for location_id: '{location_id}'")
+                    
+                    # Cache the result
+                    _location_name_cache[location_id] = location_name
+                    return location_name
+                else:
+                    self.logger.warning(
+                        f"[LOCATION] API returned success=false for location_id '{location_id}': "
+                        f"{response.get('message', 'Unknown error')}"
+                    )
+            else:
+                self.logger.warning(f"[LOCATION] Invalid response format from API: {response}")
+                
+        except Exception as e:
+            self.logger.error(f"[LOCATION] Error fetching location name for '{location_id}': {e}", exc_info=True)
+        
+        # Use default on any failure
+        self.logger.info(f"[LOCATION] Using default location name: '{default_location}'")
+        _location_name_cache[location_id] = default_location
+        return default_location
+
     async def _get_facial_recognition_client(
         self, config: FaceRecognitionEmbeddingConfig
     ) -> FacialRecognitionClient:
@@ -683,21 +1442,61 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             self.logger.info(
                 f"Initializing face recognition client with server ID: {config.facial_recognition_server_id}"
             )
+            print(f"=============== CONFIG: {config} ===============")  
+            print(f"=============== CONFIG.SESSION: {config.session} ===============")  
+            account_number = os.getenv("MATRICE_ACCOUNT_NUMBER", "")
+            access_key_id = os.getenv("MATRICE_ACCESS_KEY_ID", "")
+            secret_key = os.getenv("MATRICE_SECRET_ACCESS_KEY", "")
+            project_id = os.getenv("MATRICE_PROJECT_ID", "")
+            
+            self.logger.info(f"[PROJECT_ID] Initial project_id from env: '{project_id}'")
+            
+            self.session1 = Session(
+                account_number=account_number,
+                access_key=access_key_id,
+                secret_key=secret_key,
+                project_id=project_id,
+            )
             self.face_client = FacialRecognitionClient(
-                server_id=config.facial_recognition_server_id, session=config.session
+                server_id=config.facial_recognition_server_id, session=self.session1
             )
             self.logger.info("Face recognition client initialized")
             
+            # After FacialRecognitionClient initialization, it may have fetched project_id from action details
+            # and updated MATRICE_PROJECT_ID env var. Update session1 with the correct project_id.
+            updated_project_id = self.face_client.project_id or os.getenv("MATRICE_PROJECT_ID", "")
+            if updated_project_id and updated_project_id != project_id:
+                self.logger.info(f"[PROJECT_ID] Project ID updated by FacialRecognitionClient: '{updated_project_id}'")
+                try:
+                    self.session1.update(updated_project_id)
+                    self.logger.info(f"[PROJECT_ID] Updated session1 with project_id: '{updated_project_id}'")
+                except Exception as e:
+                    self.logger.warning(f"[PROJECT_ID] Failed to update session1 with project_id: {e}")
+            elif updated_project_id:
+                self.logger.info(f"[PROJECT_ID] Using project_id: '{updated_project_id}'")
+
             # Call update_deployment if deployment_id is provided
             if config.deployment_id:
                 try:
-                    self.logger.info(f"Updating deployment action with ID: {config.deployment_id}")
-                    response = await self.face_client.update_deployment_action(config.deployment_id)
-                    if response:
-                        self.logger.info(f"Successfully updated deployment action {config.deployment_id}")
+                    # Create temporary RedisFaceMatcher to get app_deployment_id using verified method
+                    redis_session = getattr(self.face_client, "session", None) or config.session
+                    temp_redis_matcher = RedisFaceMatcher(
+                        session=redis_session,
+                        logger=self.logger,
+                        face_client=self.face_client,
+                    )
+                    app_deployment_id = await temp_redis_matcher._ensure_app_deployment_id()
+
+                    if app_deployment_id:
+                        self.logger.info(f"Updating deployment action with app_deployment_id: {app_deployment_id}")
+                        response = await self.face_client.update_deployment_action(app_deployment_id)
+                        if response:
+                            self.logger.info(f"Successfully updated deployment action {app_deployment_id}")
+                        else:
+                            self.logger.warning(f"Failed to update deployment: {response.get('error', 'Unknown error')}")
                     else:
-                        self.logger.warning(f"Failed to update deployment: {response.get('error', 'Unknown error')}")
-                    
+                        self.logger.warning("Could not resolve app_deployment_id, skipping deployment action update")
+
                     self.logger.info(f"Updating deployment with ID: {config.deployment_id}")
                     response = await self.face_client.update_deployment(config.deployment_id)
                     if response:
@@ -728,6 +1527,9 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         """
         processing_start = time.time()
         # Ensure config is correct type
+        self.logger.info(f"[CONFIG-PRINT]-------------------------- {config} --------------------------")
+        self.logger.info(f"[STREAM-PRINT]-------------------------- {stream_info} --------------------------")
+        
         if not isinstance(config, FaceRecognitionEmbeddingConfig):
             return self.create_error_result(
                 "Invalid config type",
@@ -818,9 +1620,7 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             )
             self.logger.debug("Applied category filtering")
 
-        # print("------------------TILL TRACKER MS----------------------------")
-        # print(self._initialized,"LATENCY:",(time.time() - processing_start)*1000,"| Throughput fps:",(1.0 / (time.time() - processing_start)) if (time.time() - processing_start) > 0 else None)
-        # print("------------------TILL TRACKER MS----------------------------")
+        
         # Advanced tracking (BYTETracker-like) - only if enabled
         if config.enable_face_tracking:
             from ..advanced_tracker import AdvancedTracker
@@ -860,27 +1660,35 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         recognized_persons = {}
         current_frame_staff_details = {}
 
-        # print("------------------TRACKER INIT END----------------------------")
-        # print("LATENCY:",(time.time() - processing_start)*1000,"| Throughput fps:",(1.0 / (time.time() - processing_start)) if (time.time() - processing_start) > 0 else None)
-        # print("------------------TRACKER INIT END----------------------------")
+
+        # Extract camera info and fetch location name
+        camera_info_extracted = self._extract_camera_info_from_stream(stream_info)
+        camera_name = camera_info_extracted.get("camera_name", "")
+        camera_id = camera_info_extracted.get("camera_id", "")
+        location_id = camera_info_extracted.get("location_id", "")
+        
+        # Fetch actual location name from API
+        location_name = await self._fetch_location_name(location_id)
+        self.logger.debug(f"Using location_name: '{location_name}', camera_name: '{camera_name}', camera_id: '{camera_id}'")
 
         # Process face recognition for each detection (if enabled)
         if config.enable_face_recognition:
             # Additional safety check: verify embeddings are still loaded and ready
-            if not self.embedding_manager or not self.embedding_manager.is_ready():
-                status = self.embedding_manager.get_status() if self.embedding_manager else {}
-                error_msg = f"CRITICAL: Cannot process face recognition - embeddings not ready. Status: {status}"
-                self.logger.error(error_msg)
-                print(f"ERROR: {error_msg}")
-                return self.create_error_result(
-                    error_msg,
-                    usecase=self.name,
-                    category=self.category,
-                    context=context,
-                )
+            # if not self.embedding_manager or not self.embedding_manager.is_ready():
+            #     status = self.embedding_manager.get_status() if self.embedding_manager else {}
+            #     error_msg = f"CRITICAL: Cannot process face recognition - embeddings not ready. Status: {status}"
+            #     self.logger.error(error_msg)
+            #     print(f"ERROR: {error_msg}")
+            #     return self.create_error_result(
+            #         error_msg,
+            #         usecase=self.name,
+            #         category=self.category,
+            #         context=context,
+            #     )
             
             face_recognition_result = await self._process_face_recognition(
-                processed_data, config, stream_info, input_bytes
+                processed_data, config, stream_info, input_bytes,
+                camera_name=camera_name, camera_id=camera_id, location_name=location_name
             )
             processed_data, current_recognized_count, current_unknown_count, recognized_persons, current_frame_staff_details = face_recognition_result
         else:
@@ -891,9 +1699,6 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                 detection["recognition_status"] = "disabled"
                 detection["enrolled"] = False
 
-        # print("------------------FACE RECONG CONFIG ENABLED----------------------------")
-        # print("LATENCY:",(time.time() - processing_start)*1000,"| Throughput fps:",(1.0 / (time.time() - processing_start)) if (time.time() - processing_start) > 0 else None)
-        # print("------------------FACE RECONG CONFIG ENABLED----------------------------")
 
         # Update tracking state for total count per label
         self._update_tracking_state(processed_data)
@@ -927,9 +1732,6 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             current_recognized_count, current_unknown_count, recognized_persons
         ))
 
-        # print("------------------TILL FACE RECOG SUMMARY----------------------------")
-        # print("LATENCY:",(time.time() - processing_start)*1000,"| Throughput fps:",(1.0 / (time.time() - processing_start)) if (time.time() - processing_start) > 0 else None)
-        # print("------------------TILL FACE RECOG SUMMARY----------------------------")
 
         # Add detections to the counting summary (standard pattern for detection use cases)
         # Ensure display label is present for UI (does not affect logic/counters)
@@ -962,10 +1764,6 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         )
         summary = summary_list[0] if summary_list else {}
 
-        # print("------------------TILL TRACKING STATS----------------------------")
-        # print("LATENCY:",(time.time() - processing_start)*1000,"| Throughput fps:",(1.0 / (time.time() - processing_start)) if (time.time() - processing_start) > 0 else None)
-        # print("------------------TILL TRACKING STATS----------------------------")
-
 
         agg_summary = {
             str(frame_number): {
@@ -1039,6 +1837,12 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
 
         return processed_data
 
+    def _build_search_id(self, track_key: Any, frame_id: Optional[Any]) -> str:
+        """Generate a deterministic Redis search identifier per detection."""
+        base_frame = frame_id if frame_id is not None else self._total_frame_counter
+        safe_track = str(track_key if track_key is not None else "na").replace(" ", "_")
+        return f"face_{base_frame}_{safe_track}"
+
     def _extract_frame_from_data(self, input_bytes: bytes) -> Optional[np.ndarray]:
         """
         Extract frame from original model data
@@ -1075,6 +1879,9 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         config: FaceRecognitionEmbeddingConfig,
         stream_info: Optional[Dict[str, Any]] = None,
         input_bytes: Optional[bytes] = None,
+        camera_name: str = "",
+        camera_id: str = "",
+        location_name: str = "",
     ) -> List[Dict]:
         """Process face recognition for each detection with embeddings"""
 
@@ -1111,10 +1918,8 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                 )
             self._frame_warning_logged = True
 
-        # Get location from stream_info
-        location = (
-            stream_info.get("camera_location", "unknown") if stream_info else "unknown"
-        )
+        # Use the location_name passed from process() (fetched from API)
+        location = location_name if location_name else "Entry Reception"
 
         # Generate current timestamp
         current_timestamp = datetime.now(timezone.utc).isoformat()
@@ -1128,7 +1933,8 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             processed_detection = await self._process_face(
                 detection, current_frame, location, current_timestamp, config,
                 current_recognized_count, current_unknown_count, 
-                recognized_persons, current_frame_staff_details
+                recognized_persons, current_frame_staff_details,
+                camera_name=camera_name, camera_id=camera_id
             )
             # print("------------------WHOLE FACE RECOG PROCESSING DETECTION----------------------------")
             # print("LATENCY:",(time.time() - st1)*1000,"| Throughput fps:",(1.0 / (time.time() - st1)) if (time.time() - st1) > 0 else None)
@@ -1160,6 +1966,8 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         current_unknown_count: int = 0,
         recognized_persons: Dict = None,
         current_frame_staff_details: Dict = None,
+        camera_name: str = "",
+        camera_id: str = "",
     ) -> Dict:
 
         # Extract and validate embedding using EmbeddingManager
@@ -1184,6 +1992,9 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         h_box = max(1, y2 - y1)
         frame_id = detection.get("frame_id", None) #TODO: Maybe replace this with stream_info frame_id
 
+        track_key = track_id if track_id is not None else f"no_track_{id(detection)}"
+        search_id = self._build_search_id(track_key, frame_id)
+
         # Track probation age strictly by internal tracker id
         if track_id is not None:
             if track_id not in self._track_first_seen:
@@ -1207,7 +2018,6 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         detection_type = "unknown"
         try:
             if self.temporal_identity_manager:
-                track_key = track_id if track_id is not None else f"no_track_{id(detection)}"
                 if not eligible_for_recognition:
                     # Mirror compare_similarity: when not eligible, keep stable label if present
                     s = self.temporal_identity_manager.tracks.get(track_key, {})
@@ -1243,6 +2053,7 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                         eligible_for_recognition=True,
                         location=location,
                         timestamp=current_timestamp,
+                        search_id=search_id,
                     )
                     # print("------------------FACE RECOG TEMPORAL IDENTITY MANAGER UPDATE----------------------------")
                     # print("LATENCY:",(time.time() - st3)*1000,"| Throughput fps:",(1.0 / (time.time() - st3)) if (time.time() - st3) > 0 else None)
@@ -1330,6 +2141,8 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                     detection=detection,
                     current_frame=current_frame,
                     location=location,
+                    camera_name=camera_name,
+                    camera_id=camera_id,
                 )
                 # print("------------------FACE RECOG ENQUEUEING DETECTION FOR ACTIVITY LOGGING----------------------------")
                 # print("LATENCY:",(time.time() - st4)*1000,"| Throughput fps:",(1.0 / (time.time() - st4)) if (time.time() - st4) > 0 else None)
@@ -1592,19 +2405,19 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
 
         # Build current_counts array in expected format
         current_counts = []
-        for cat, count in per_category_count.items():
-            if count > 0 or total_detections > 0:
-                current_counts.append({"category": cat, "count": count})
+        # for cat, count in per_category_count.items():
+        #     if count > 0 or total_detections > 0:
+        #         current_counts.append({"category": cat, "count": count})
 
         # Add face recognition specific current counts
         current_frame = face_summary.get("current_frame", {})
         current_counts.extend(
             [
                 {
-                    "category": "recognized_faces",
+                    "category": "Recognized Faces",
                     "count": current_frame.get("recognized", 0),
                 },
-                {"category": "unknown_faces", "count": current_frame.get("unknown", 0)},
+                {"category": "Unknown Faces", "count": current_frame.get("unknown", 0)},
             ]
         )
 
@@ -1667,7 +2480,7 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             )
 
     
-        human_text_lines = [f"CURRENT FRAME @ {current_timestamp}"]
+        human_text_lines = [f"CURRENT FRAME @ {current_timestamp}:"]
 
         current_recognized = current_frame.get("recognized", 0)
         current_unknown = current_frame.get("unknown", 0)
@@ -1675,8 +2488,8 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         total_current = current_recognized + current_unknown
 
         # Show staff names and IDs being recognized in current frame (with tabs)
-        human_text_lines.append(f"\tCurrent Total Faces: {total_current}")
-        human_text_lines.append(f"\tCurrent Recognized: {current_recognized}")
+        human_text_lines.append(f"\t- Current Total Faces: {total_current}")
+        human_text_lines.append(f"\t- Current Recognized: {current_recognized}")
         
         if recognized_persons:
             for person_id in recognized_persons.keys():
@@ -1684,15 +2497,15 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                 staff_name = (current_frame_staff_details or {}).get(
                     person_id, f"Staff {person_id}"
                 )
-                human_text_lines.append(f"\tName: {staff_name} (ID: {person_id})")
-        human_text_lines.append(f"\tCurrent Unknown: {current_unknown}")
+                human_text_lines.append(f"\t\t- Name: {staff_name} (ID: {person_id})")
+        human_text_lines.append(f"\t- Current Unknown: {current_unknown}")
 
         # Show current frame counts only (with tabs)
         human_text_lines.append("")
-        human_text_lines.append(f"TOTAL SINCE @ {start_timestamp}")
-        human_text_lines.append(f"\tTotal Faces: {cumulative_total}")
-        human_text_lines.append(f"\tRecognized: {face_summary.get('session_totals',{}).get('total_recognized', 0)}")  
-        human_text_lines.append(f"\tUnknown: {face_summary.get('session_totals',{}).get('total_unknown', 0)}")
+        # human_text_lines.append(f"TOTAL SINCE @ {start_timestamp}")
+        # human_text_lines.append(f"\tTotal Faces: {cumulative_total}")
+        # human_text_lines.append(f"\tRecognized: {face_summary.get('session_totals',{}).get('total_recognized', 0)}")  
+        # human_text_lines.append(f"\tUnknown: {face_summary.get('session_totals',{}).get('total_unknown', 0)}")
         # Additional counts similar to compare_similarity HUD
         # try:
         #     human_text_lines.append(f"\tCurrent Faces (detections): {total_detections}")
@@ -1702,15 +2515,15 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
 
         human_text = "\n".join(human_text_lines)
 
-        if alerts:
-            for alert in alerts:
-                human_text_lines.append(
-                    f"Alerts: {alert.get('settings', {})} sent @ {current_timestamp}"
-                )
-        else:
-            human_text_lines.append("Alerts: None")
+        # if alerts:
+        #     for alert in alerts:
+        #         human_text_lines.append(
+        #             f"Alerts: {alert.get('settings', {})} sent @ {current_timestamp}"
+        #         )
+        # else:
+        #     human_text_lines.append("Alerts: None")
 
-        human_text = "\n".join(human_text_lines)
+        # human_text = "\n".join(human_text_lines)
         reset_settings = [
             {"interval_type": "daily", "reset_time": {"value": 9, "time_unit": "hour"}}
         ]
@@ -1727,7 +2540,7 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             start_time=high_precision_start_timestamp,
             reset_time=high_precision_reset_timestamp,
         )
-
+        tracking_stat['target_categories'] = ['Recognized Faces', 'Unknown Faces']
         tracking_stats.append(tracking_stat)
         return tracking_stats