fix : database pinecone issue

main.py

@@ -328,31 +328,54 @@ async def upload_new_images(
             async with _inference_sem:
                 vectors = await ai.process_image_async(tmp_path, is_query=False, detect_faces=detect_faces)
 
-            face_upserts, object_upserts = [], []
+            face_upserts  = []
+            object_upserts = []
+
             for v in vectors:
                 vec_list = v["vector"].tolist() if hasattr(v["vector"], "tolist") else v["vector"]
                 if v["type"] == "face":
-                    # V3: store per-face metadata including crop thumbnail + bbox
-                    metadata = {
-                        "url":        image_url,
-                        "folder":     folder,
-                        "face_idx":   v.get("face_idx", 0),
-                        "bbox":       str(v.get("bbox", [])),
-                        "face_crop":  v.get("face_crop", ""),  # base64 thumbnail
-                        "det_score":  v.get("det_score", 1.0),
-                    }
-                    face_upserts.append({"id": str(uuid.uuid4()), "values": vec_list, "metadata": metadata})
+                    # ── FACE STORE: ArcFace 512-D embedding
+                    # Metadata includes original image_url so we can
+                    # retrieve the full image after a face match
+                    face_upserts.append({
+                        "id":     str(uuid.uuid4()),
+                        "values": vec_list,
+                        "metadata": {
+                            "image_url": image_url,   # original full image
+                            "url":       image_url,   # alias for compatibility
+                            "folder":    folder,
+                            "face_idx":  v.get("face_idx", 0),
+                            "bbox":      str(v.get("bbox", [])),
+                            "face_crop": v.get("face_crop", ""),  # base64 thumb for UI
+                            "det_score": v.get("det_score", 1.0),
+                        }
+                    })
                 else:
-                    object_upserts.append({"id": str(uuid.uuid4()), "values": vec_list,
-                                           "metadata": {"url": image_url, "folder": folder}})
+                    # ── OBJECT STORE: SigLIP+DINOv2 1536-D fused embedding
+                    # Always stores full image — includes all crops + full image
+                    object_upserts.append({
+                        "id":     str(uuid.uuid4()),
+                        "values": vec_list,
+                        "metadata": {
+                            "image_url": image_url,
+                            "url":       image_url,
+                            "folder":    folder,
+                        }
+                    })
 
+            # Always upsert to BOTH indexes:
+            # - face index gets face embeddings (if any faces detected)
+            # - object index ALWAYS gets full image embedding
             face_vec_total   += len(face_upserts)
             object_vec_total += len(object_upserts)
 
             upsert_tasks = []
-            if face_upserts:   upsert_tasks.append(asyncio.to_thread(idx_face.upsert, vectors=face_upserts))
-            if object_upserts: upsert_tasks.append(asyncio.to_thread(idx_obj.upsert,  vectors=object_upserts))
-            if upsert_tasks:   await asyncio.gather(*upsert_tasks)
+            if face_upserts:
+                upsert_tasks.append(asyncio.to_thread(idx_face.upsert, vectors=face_upserts))
+            if object_upserts:
+                upsert_tasks.append(asyncio.to_thread(idx_obj.upsert, vectors=object_upserts))
+            if upsert_tasks:
+                await asyncio.gather(*upsert_tasks)
 
             log("INFO", "upload.file.success",
                 user_id=user_id or "anonymous", ip=ip, mode=mode,
@@ -456,35 +479,59 @@ async def search_database(
         object_vectors = [v for v in vectors if v["type"] == "object"]
 
         if detect_faces and face_vectors:
-            # ── FACE MODE: return grouped results per detected face ──
+            # ══════════════════════════════════════════════════════
+            # FACE MODE — Two-step retrieval (from cloud_db.py):
+            # Step 1: Query enterprise-faces index with ArcFace vector
+            #         → get matched image_urls + face_crop thumbnails
+            # Step 2: De-duplicate by image_url, rank by face score
+            #         → return full original images grouped per face
+            # ══════════════════════════════════════════════════════
             async def _query_face_group(face_vec: dict) -> dict:
                 vec_list = face_vec["vector"].tolist() if hasattr(face_vec["vector"], "tolist") else face_vec["vector"]
                 try:
-                    res = await asyncio.to_thread(idx_face.query,
-                        vector=vec_list, top_k=10, include_metadata=True)
+                    # Query enterprise-FACES index (512-D ArcFace)
+                    res = await asyncio.to_thread(
+                        idx_face.query,
+                        vector=vec_list,
+                        top_k=20,  # fetch more, filter below
+                        include_metadata=True,
+                    )
                 except Exception as e:
                     if "404" in str(e):
                         raise HTTPException(404, "Pinecone index not found. Go to Settings → Verify & Save.")
                     raise e
 
-                matches = []
-                seen_urls = set()
+                matches    = []
+                seen_urls  = set()
+
                 for match in res.get("matches", []):
-                    score = match["score"]
-                    # ArcFace cosine — threshold 0.35 same as before
-                    if score < 0.35:
+                    raw_score = match["score"]
+
+                    # ArcFace cosine similarity threshold
+                    # 0.35 = same person (from cloud_db.py RAW_THRESHOLD)
+                    if raw_score < 0.35:
                         continue
-                    url = match["metadata"].get("url", "")
-                    if url in seen_urls:
+
+                    # Get the ORIGINAL full image URL (not face crop)
+                    # Both "url" and "image_url" keys stored for compatibility
+                    image_url_match = (
+                        match["metadata"].get("url") or
+                        match["metadata"].get("image_url", "")
+                    )
+                    if not image_url_match or image_url_match in seen_urls:
                         continue
-                    seen_urls.add(url)
-                    # Remap score to 75-99% for UI
-                    ui_score = min(0.99, 0.75 + ((score - 0.35) / 0.65) * 0.24)
+                    seen_urls.add(image_url_match)
+
+                    # Remap raw ArcFace score (0.35–1.0) → UI score (75%–99%)
+                    # Matches cloud_db.py remapping exactly
+                    ui_score = 0.75 + ((raw_score - 0.35) / (1.0 - 0.35)) * 0.24
+                    ui_score = min(0.99, ui_score)
+
                     matches.append({
-                        "url":        url,
+                        "url":        image_url_match,      # full original image
                         "score":      round(ui_score, 4),
-                        "face_crop":  match["metadata"].get("face_crop", ""),
-                        "bbox":       match["metadata"].get("bbox", ""),
+                        "raw_score":  round(raw_score, 4),
+                        "face_crop":  match["metadata"].get("face_crop", ""),  # matched face thumb
                         "folder":     match["metadata"].get("folder", ""),
                         "caption":    "👤 Verified Identity",
                     })
@@ -497,10 +544,9 @@ async def search_database(
                 }
 
             face_groups = await asyncio.gather(*[_query_face_group(fv) for fv in face_vectors])
-            # Filter out groups with 0 matches
             face_groups = [g for g in face_groups if g["matches"]]
 
-            duration_ms = round((time.perf_counter() - start) * 1000)
+            duration_ms   = round((time.perf_counter() - start) * 1000)
             total_matches = sum(len(g["matches"]) for g in face_groups)
             log("INFO", "search.complete",
                 user_id=user_id or "anonymous", ip=ip, mode=mode,
@@ -512,7 +558,7 @@ async def search_database(
             return {
                 "mode":        "face",
                 "face_groups": list(face_groups),
-                "results":     [],  # empty for backward compat
+                "results":     [],  # empty — face mode returns groups only
             }
 
         else:

src/models.py

@@ -281,16 +281,23 @@ class AIModelManager:
                     extracted.append(fr)
 
         # ── OBJECT LANE ──────────────────────────────────────────
-        # Always run object lane — even if faces found
-        # (image may contain both people and objects)
-        crops_pil    = [_resize_pil(original_pil, MAX_IMAGE_SIZE)]  # full-image always
+        # ALWAYS runs — stores full image + YOLO crops in enterprise-objects
+        # This is critical: even when faces found, the full image must be
+        # stored in enterprise-objects so face search can retrieve it!
+        #
+        # Strategy (matches cloud_db.py):
+        #   - full image ALWAYS included as first crop
+        #   - YOLO person crops SKIPPED when faces found (avoid duplication)
+        #   - other object crops always included
+        crops_pil    = [_resize_pil(original_pil, MAX_IMAGE_SIZE)]  # ALWAYS include full image
         yolo_results = self.yolo(image_path, conf=0.5, verbose=False)
 
         for r in yolo_results:
             if r.masks is not None:
                 for seg_idx, mask_xy in enumerate(r.masks.xy):
                     cls_id = int(r.boxes.cls[seg_idx].item())
-                    # Skip person crops if face lane already handled them
+                    # Skip YOLO person crops when face lane handled faces
+                    # (avoids storing low-quality person crops redundantly)
                     if faces_found and cls_id == YOLO_PERSON_CLASS_ID:
                         print("🔵 PERSON crop skipped — face lane active")
                         continue
@@ -317,6 +324,7 @@ class AIModelManager:
             if len(crops_pil) >= MAX_CROPS + 1:
                 break
 
+        # Embed all crops — full image is ALWAYS first in the list
         crops = [_resize_pil(c, MAX_IMAGE_SIZE) for c in crops_pil]
         print(f"🧠 Embedding {len(crops)} object crop(s) in one batch …")
         obj_vecs = self._embed_crops_batch(crops)