projectdavid 1.32.20__py3-none-any.whl → 1.33.0__py3-none-any.whl

projectdavid/clients/file_processor.py

@@ -1,6 +1,8 @@
 import asyncio
 import csv
+import hashlib
 import json
+import math
 import re
 import textwrap
 from concurrent.futures import ThreadPoolExecutor
@@ -13,34 +15,124 @@ except ImportError:  # 3.9–3.10
     from typing_extensions import LiteralString
 
 import numpy as np
+import open_clip
 import pdfplumber
+import torch
 from docx import Document
+from PIL import Image
 from pptx import Presentation
+from transformers import Blip2ForConditionalGeneration, Blip2Processor
+from ultralytics import YOLO
+
+# OCR fallback – optional
+try:
+    import pytesseract  # noqa: F401  # pylint: disable=unused-import
+except ImportError:
+    pytesseract = None
+
 from projectdavid_common import UtilsInterface
 from sentence_transformers import SentenceTransformer
 
 log = UtilsInterface.LoggingUtility()
 
 
+def latlon_to_unit_vec(lat: float, lon: float) -> List[float]:
+    """Convert geographic lat/lon (deg) to a 3-D unit vector for Qdrant."""
+    lat_r = math.radians(lat)
+    lon_r = math.radians(lon)
+    return [
+        math.cos(lat_r) * math.cos(lon_r),
+        math.cos(lat_r) * math.sin(lon_r),
+        math.sin(lat_r),
+    ]
+
+
 class FileProcessor:
+    """Unified processor for text, tabular, office, JSON, **and image** files.
+
+    Each modality is embedded with its optimal model:
+        • Text   → paraphrase‑MiniLM‑L6‑v2 (384‑D)
+        • Image  → OpenCLIP ViT‑H/14         (1024‑D)
+        • Caption→ OpenCLIP text head        (1024‑D)
+
+    Rich captions are generated via BLIP‑2 Flan‑T5‑XL.
+    GPU usage is optional; pass `use_gpu=False` to stay on CPU.
+    """
+
     # ------------------------------------------------------------------ #
     #  Construction
     # ------------------------------------------------------------------ #
-    def __init__(self, max_workers: int = 4, chunk_size: int = 512):
-        self.embedding_model = SentenceTransformer("paraphrase-MiniLM-L6-v2")
+    def __init__(
+        self,
+        *,
+        max_workers: int = 4,
+        chunk_size: int = 512,
+        use_gpu: bool = True,
+        use_ocr: bool = True,
+        use_detection: bool = False,
+        image_model_name: str = "ViT-H-14",
+        caption_model_name: str = "Salesforce/blip2-flan-t5-xl",
+    ):
+        # Device selection
+        if use_gpu and torch.cuda.is_available():
+            self.device = torch.device("cuda")
+            self.torch_dtype = torch.float16
+        else:
+            self.device = torch.device("cpu")
+            self.torch_dtype = torch.float32
+
+        # Feature flags
+        self.use_ocr = use_ocr and pytesseract is not None
+        self.use_detection = use_detection
+        if use_ocr and pytesseract is None:
+            log.warning("OCR requested but pytesseract not installed – skipping.")
+        if self.use_detection:
+            self.detector = YOLO("yolov8x.pt").to(self.device)
+
+        # Text embedder
         self.embedding_model_name = "paraphrase-MiniLM-L6-v2"
-        self._executor = ThreadPoolExecutor(max_workers=max_workers)
+        self.embedding_model = SentenceTransformer(self.embedding_model_name)
+        self.embedding_model.to(str(self.device))
 
-        # token limits
+        # Chunking parameters
         self.max_seq_length = self.embedding_model.get_max_seq_length()
         self.special_tokens_count = 2
         self.effective_max_length = self.max_seq_length - self.special_tokens_count
         self.chunk_size = min(chunk_size, self.effective_max_length * 4)
 
-        log.info("Initialized optimized FileProcessor")
+        # Image embedder
+        self.clip_model, _, self.clip_preprocess = (
+            open_clip.create_model_and_transforms(
+                image_model_name,
+                pretrained="laion2b_s32b_b79k",
+                precision="fp16" if self.device.type == "cuda" else "fp32",
+            )
+        )
+        self.clip_model = self.clip_model.to(self.device).eval()
+        self.clip_tokenizer = open_clip.get_tokenizer(image_model_name)
+
+        # Caption generator
+        self.blip_processor = Blip2Processor.from_pretrained(caption_model_name)
+        self.blip_model = (
+            Blip2ForConditionalGeneration.from_pretrained(
+                caption_model_name,
+                torch_dtype=self.torch_dtype,
+            )
+            .to(self.device)
+            .eval()
+        )
+
+        # Executor & logging
+        self._executor = ThreadPoolExecutor(max_workers=max_workers)
+        log.info(
+            "FileProcessor ready (device=%s, OCR=%s, detection=%s)",
+            self.device,
+            self.use_ocr,
+            self.use_detection,
+        )
 
     # ------------------------------------------------------------------ #
-    #  Generic validators
+    #  Generic validators                                           *
     # ------------------------------------------------------------------ #
     def validate_file(self, file_path: Path):
         """Ensure file exists and is under 100 MB."""
@@ -52,20 +144,10 @@ class FileProcessor:
             raise ValueError(f"{file_path.name} > {mb} MB limit")
 
     # ------------------------------------------------------------------ #
-    #  File-type detection  (simple extension map – NO libmagic)
+    #  File‑type detection (extension‑based – no libmagic)
     # ------------------------------------------------------------------ #
     def _detect_file_type(self, file_path: Path) -> str:
-        """
-        Return one of:
-
-            • 'pdf'   • 'csv'   • 'json'
-            • 'office' (.doc/.docx/.pptx)
-            • 'text'  (code / markup / plain text)
-
-        Raises *ValueError* if the extension is not recognised.
-        """
         suffix = file_path.suffix.lower()
-
         if suffix == ".pdf":
             return "pdf"
         if suffix == ".csv":
@@ -74,7 +156,8 @@ class FileProcessor:
             return "json"
         if suffix in {".doc", ".docx", ".pptx"}:
             return "office"
-
+        if suffix in {".jpg", ".jpeg", ".png", ".webp", ".bmp", ".gif", ".tiff"}:
+            return "image"
         text_exts = {
             ".txt",
             ".md",
@@ -96,29 +179,100 @@ class FileProcessor:
         }
         if suffix in text_exts:
             return "text"
-
         raise ValueError(f"Unsupported file type: {file_path.name} (ext={suffix})")
 
     # ------------------------------------------------------------------ #
-    #  Public entry-point
+    # Dispatcher
     # ------------------------------------------------------------------ #
     async def process_file(self, file_path: Union[str, Path]) -> Dict[str, Any]:
-        """Validate → detect → dispatch to the appropriate processor."""
-        file_path = Path(file_path)
-        self.validate_file(file_path)
-        ftype = self._detect_file_type(file_path)
-
-        dispatch_map = {
-            "pdf": self._process_pdf,
-            "text": self._process_text,
-            "csv": self._process_csv,
-            "office": self._process_office,
-            "json": self._process_json,
+        path = Path(file_path)
+        self.validate_file(path)
+        ftype = self._detect_file_type(path)
+        return await getattr(self, f"_process_{ftype}")(path)
+
+    # ------------------------------------------------------------------ #
+    #  Image processing (OpenCLIP + BLIP-2 + OCR + YOLO)
+    # ------------------------------------------------------------------ #
+    async def _process_image(self, file_path: Path) -> Dict[str, Any]:
+        loop = asyncio.get_event_loop()
+        img = await loop.run_in_executor(self._executor, Image.open, file_path)
+
+        # 1) Image vector
+        def enc_img():
+            with torch.no_grad():
+                t = self.clip_preprocess(img).unsqueeze(0).to(self.device)
+                v = self.clip_model.encode_image(t).squeeze()
+                return (v / v.norm()).float().cpu().numpy()
+
+        image_vec = await loop.run_in_executor(self._executor, enc_img)
+
+        # 2) Caption
+        def gen_cap():
+            inp = self.blip_processor(images=img, return_tensors="pt").to(self.device)
+            with torch.no_grad():
+                ids = self.blip_model.generate(**inp, max_new_tokens=50)
+            return self.blip_processor.decode(ids[0], skip_special_tokens=True)
+
+        caption = await loop.run_in_executor(self._executor, gen_cap)
+
+        # 3) OCR
+        if self.use_ocr:
+            text = await loop.run_in_executor(
+                self._executor, pytesseract.image_to_string, img
+            )
+            if t := text.strip():
+                caption += "\n" + t
+
+        # 4) Caption vector
+        def enc_txt():
+            with torch.no_grad():
+                tok = self.clip_tokenizer(caption).unsqueeze(0).to(self.device)
+                v = self.clip_model.encode_text(tok).squeeze()
+                return (v / v.norm()).float().cpu().numpy()
+
+        caption_vec = await loop.run_in_executor(self._executor, enc_txt)
+
+        # 5) YOLO regions
+        region_vectors = []
+        if self.use_detection:
+            dets = self.detector(img)[0]
+            for box in dets.boxes:
+                x1, y1, x2, y2 = map(int, box.xyxy[0].cpu().tolist())
+                crop = img.crop((x1, y1, x2, y2))
+                vec = self.encode_image(crop)
+                region_vectors.append(
+                    {
+                        "vector": vec.tolist(),
+                        "bbox": [x1, y1, x2, y2],
+                        "label": dets.names[int(box.cls)],
+                        "conf": float(box.conf),
+                    }
+                )
+
+        # Metadata
+        sha = hashlib.sha256(file_path.read_bytes()).hexdigest()
+        w, h = img.size
+        meta = {
+            "source": str(file_path),
+            "type": "image",
+            "width": w,
+            "height": h,
+            "mime": f"image/{file_path.suffix.lstrip('.')}",
+            "sha256": sha,
+            "embedding_model": "openclip-vit-h-14",
+            "caption": caption,
         }
-        if ftype not in dispatch_map:
-            raise ValueError(f"Unsupported file type: {file_path.suffix}")
 
-        return await dispatch_map[ftype](file_path)
+        result = {
+            "content": None,
+            "metadata": meta,
+            "chunks": [caption],
+            "vectors": [image_vec.tolist()],
+            "caption_vector": caption_vec.tolist(),
+        }
+        if region_vectors:
+            result["region_vectors"] = region_vectors
+        return result
 
     # ------------------------------------------------------------------ #
     #  PDF
@@ -126,7 +280,6 @@ class FileProcessor:
     async def _process_pdf(self, file_path: Path) -> Dict[str, Any]:
         page_chunks, doc_meta = await self._extract_text(file_path)
         all_chunks, line_data = [], []
-
         for page_text, page_num, line_nums in page_chunks:
             lines = page_text.split("\n")
             buf, buf_lines, length = [], [], 0
@@ -165,7 +318,7 @@ class FileProcessor:
         }
 
     # ------------------------------------------------------------------ #
-    #  Plain-text / code / markup
+    #  Plain‑text / code / markup
     # ------------------------------------------------------------------ #
     async def _process_text(self, file_path: Path) -> Dict[str, Any]:
         text, extra_meta, _ = await self._extract_text(file_path)
@@ -198,7 +351,6 @@ class FileProcessor:
                     continue
                 texts.append(txt)
                 metas.append({k: v for k, v in row.items() if k != text_field and v})
-
         vectors = await asyncio.gather(*[self._encode_chunk_async(t) for t in texts])
         return {
             "content": None,
@@ -209,7 +361,7 @@ class FileProcessor:
         }
 
     # ------------------------------------------------------------------ #
-    #  Office docs (.doc/.docx/.pptx)
+    #  Office docs
     # ------------------------------------------------------------------ #
     async def _process_office(self, file_path: Path) -> Dict[str, Any]:
         loop = asyncio.get_event_loop()
@@ -217,11 +369,10 @@ class FileProcessor:
             text = await loop.run_in_executor(
                 self._executor, self._read_docx, file_path
             )
-        else:  # .pptx
+        else:
             text = await loop.run_in_executor(
                 self._executor, self._read_pptx, file_path
             )
-
         chunks = self._chunk_text(text)
         vectors = await asyncio.gather(*[self._encode_chunk_async(c) for c in chunks])
         return {
@@ -267,11 +418,25 @@ class FileProcessor:
             return await loop.run_in_executor(
                 self._executor, self._extract_pdf_text, file_path
             )
-        else:
-            text = await loop.run_in_executor(
-                self._executor, self._read_text_file, file_path
+        text = await loop.run_in_executor(
+            self._executor, self._read_text_file, file_path
+        )
+        return text, {}, []
+
+    # ------------------------------------------------------------------ #
+    # util: clip‑text encoder (public)
+    # ------------------------------------------------------------------ #
+    def encode_clip_text(self, text: Union[str, List[str]]) -> np.ndarray:
+        with torch.no_grad():
+            toks = (
+                self.clip_tokenizer(text)
+                if isinstance(text, str)
+                else self.clip_tokenizer(text, truncate=True)
             )
-            return text, {}, []
+            tensor = toks.unsqueeze(0).to(self.device)
+            feat = self.clip_model.encode_text(tensor).squeeze()
+            feat = feat / feat.norm()
+            return feat.float().cpu().numpy()
 
     def _extract_pdf_text(self, file_path: Path):
         page_chunks, meta = [], {}
@@ -287,8 +452,8 @@ class FileProcessor:
                 lines = page.extract_text_lines()
                 sorted_lines = sorted(lines, key=lambda x: x["top"])
                 txts, nums = [], []
-                for ln_idx, L in enumerate(sorted_lines, start=1):
-                    t = L.get("text", "").strip()
+                for ln_idx, line in enumerate(sorted_lines, start=1):
+                    t = line.get("text", "").strip()
                     if t:
                         txts.append(t)
                         nums.append(ln_idx)
@@ -362,3 +527,24 @@ class FileProcessor:
             seg = tokens[i : i + self.effective_max_length]
             out.append(self.embedding_model.tokenizer.convert_tokens_to_string(seg))
         return out
+
+    # ------------------------------------------------------------------ #
+    #  Retrieval helpers (optional use)
+    # ------------------------------------------------------------------ #
+    def encode_text(self, text: Union[str, List[str]]) -> np.ndarray:
+        """Embed raw text with the SentenceTransformer model."""
+        single = isinstance(text, str)
+        out = self.embedding_model.encode(
+            text,
+            convert_to_numpy=True,
+            normalize_embeddings=True,
+            show_progress_bar=False,
+        )
+        return out if not single else out[0]
+
+    def encode_image(self, img: Image.Image) -> np.ndarray:
+        with torch.no_grad():
+            tensor = self.clip_preprocess(img).unsqueeze(0).to(self.device)
+            feat = self.clip_model.encode_image(tensor).squeeze()
+            feat = feat / feat.norm()
+            return feat.float().cpu().numpy()

projectdavid/clients/synchronous_inference_wrapper.py

@@ -106,7 +106,14 @@ class SynchronousInferenceStream:
                 # Always attach run_id
                 chunk["run_id"] = self.run_id
 
-                if chunk.get("type") in ("hot_code", "hot_code_output", "status"):
+                # ------------------------------------------------------
+                # allow status chunks to bypass suppression suppression
+                # -------------------------------------------------------
+                if chunk.get("type") == "status":
+                    yield chunk
+                    continue
+
+                if chunk.get("type") in ("hot_code", "hot_code_output"):
                     yield chunk
                     continue
 

projectdavid/clients/vector_store_manager.py

@@ -50,11 +50,18 @@ class VectorStoreManager(BaseVectorStore):
     def create_store(
         self,
         collection_name: str,
+        *,
         vector_size: int = 384,
         distance: str = "COSINE",
+        vectors_config: Optional[Dict[str, qdrant.VectorParams]] = None,
     ) -> dict:
+        """
+        Create or recreate a Qdrant collection.  By default creates a single-vector
+        collection with `vector_size`.  To define multi-vector schema, pass
+        `vectors_config` mapping field names to VectorParams.
+        """
         try:
-            # quick existence check
+            # existence check
             if any(
                 col.name == collection_name
                 for col in self.client.get_collections().collections
@@ -65,16 +72,27 @@ class VectorStoreManager(BaseVectorStore):
             if dist not in qdrant.Distance.__members__:
                 raise ValueError(f"Invalid distance metric '{distance}'")
 
+            # choose schema
+            if vectors_config:
+                config = vectors_config
+            else:
+                config = {
+                    "_default": qdrant.VectorParams(
+                        size=vector_size, distance=qdrant.Distance[dist]
+                    )
+                }
+
+            # recreate with full schema
             self.client.recreate_collection(
                 collection_name=collection_name,
-                vectors_config=qdrant.VectorParams(
-                    size=vector_size, distance=qdrant.Distance[dist]
-                ),
+                vectors_config=config,
             )
+            # record metadata for each field
             self.active_stores[collection_name] = {
                 "created_at": int(time.time()),
                 "vector_size": vector_size,
                 "distance": dist,
+                "fields": list(config.keys()),
             }
             log.info("Created Qdrant collection %s", collection_name)
             return {"collection_name": collection_name, "status": "created"}
@@ -103,8 +121,9 @@ class VectorStoreManager(BaseVectorStore):
                 "name": store_name,
                 "status": "active",
                 "vectors_count": info.points_count,
-                "configuration": info.config.params["default"],
+                "configuration": info.config.params,
                 "created_at": self.active_stores[store_name]["created_at"],
+                "fields": self.active_stores[store_name].get("fields"),
             }
         except Exception as e:
             log.error("Store info failed: %s", e)
@@ -119,6 +138,8 @@ class VectorStoreManager(BaseVectorStore):
         texts: List[str],
         vectors: List[List[float]],
         metadata: List[dict],
+        *,
+        vector_name: Optional[str] = None,  # NEW
     ):
         if not vectors:
             raise ValueError("Empty vectors list")
@@ -136,7 +157,13 @@ class VectorStoreManager(BaseVectorStore):
             for txt, vec, meta in zip(texts, vectors, metadata)
         ]
         try:
-            self.client.upsert(collection_name=store_name, points=points, wait=True)
+            # pass vector_name if multi-column
+            self.client.upsert(
+                collection_name=store_name,
+                points=points,
+                wait=True,
+                vector_name=vector_name,  # ignored if None
+            )
             return {"status": "success", "points_inserted": len(points)}
         except Exception as e:
             log.error("Add‑to‑store failed: %s", e)
@@ -189,15 +216,25 @@ class VectorStoreManager(BaseVectorStore):
         query_vector: List[float],
         top_k: int = 5,
         filters: Optional[dict] = None,
+        *,
+        vector_field: Optional[str] = None,  # ← NEW
         score_threshold: float = 0.0,
         offset: int = 0,
         limit: Optional[int] = None,
     ) -> List[dict]:
-        """Run a similarity search that works with any 1.x qdrant‑client."""
+        """
+        Run a similarity search against *store_name*.
+
+        • Works with any Qdrant-client ≥ 1.0
+        • `vector_field` lets you target a non-default vector column
+          (e.g. ``\"caption_vector\"`` for image stores).  Pass **None**
+          to use the collection’s default vector.
+        """
 
         limit = limit or top_k
         flt = self._dict_to_filter(filters) if filters else None
 
+        # ── shared kwargs ----------------------------------------------------
         common: Dict[str, Any] = dict(
             collection_name=store_name,
             query_vector=query_vector,
@@ -207,20 +244,21 @@ class VectorStoreManager(BaseVectorStore):
             with_payload=True,
             with_vectors=False,
         )
+        if vector_field:  # ← inject when requested
+            common["vector_name"] = vector_field
 
+        # ── call search (new client first, fallback to old) ------------------
         try:
-            # Newer clients (≥ 1.6) use `filter=`
-            res = self.client.search(**common, filter=flt)  # type: ignore[arg-type]
+            res = self.client.search(**common, filter=flt)  # ≥ 1.6
         except AssertionError as ae:
             if "Unknown arguments" not in str(ae):
                 raise
-            # Older clients use `query_filter=`
-            res = self.client.search(**common, query_filter=flt)  # type: ignore[arg-type]
-
+            res = self.client.search(**common, query_filter=flt)  # < 1.6
         except Exception as e:
             log.error("Query failed: %s", e)
             raise VectorStoreError(f"Query failed: {e}") from e
 
+        # ── normalise result -------------------------------------------------
         return [
             {
                 "id": p.id,

projectdavid/clients/vectors.py

@@ -13,8 +13,10 @@ from typing import Any, Dict, List, Optional, Union
 
 import httpx
 from dotenv import load_dotenv
+from PIL import Image
 from projectdavid_common import UtilsInterface, ValidationInterface
 from pydantic import BaseModel, Field
+from qdrant_client.http import models as qdrant
 
 from projectdavid.clients.file_processor import FileProcessor
 from projectdavid.clients.vector_store_manager import VectorStoreManager
@@ -61,13 +63,16 @@ class VectorStoreClient:
     • create_vector_store() no longer takes user_id; ownership from token.
     """
 
-    # Construction / cleanup
+    # ------------------------------------------------------------------ #
+    #  Construction / cleanup
+    # ------------------------------------------------------------------ #
     def __init__(
         self,
         base_url: Optional[str] = None,
         api_key: Optional[str] = None,
         *,
         vector_store_host: str = "localhost",
+        file_processor_kwargs: Optional[dict] = None,  # 🔶 add arg
     ):
         self.base_url = (base_url or os.getenv("BASE_URL", "")).rstrip("/")
         self.api_key = api_key or os.getenv("API_KEY")
@@ -84,10 +89,12 @@ class VectorStoreClient:
             base_url=self.base_url, headers=self._base_headers, timeout=30.0
         )
 
-        # Local helpers
+        # Local helpers ---------------------------------------------------
         self.vector_manager = VectorStoreManager(vector_store_host=vector_store_host)
         self.identifier_service = UtilsInterface.IdentifierService()
-        self.file_processor = FileProcessor()
+
+        # 🔶 forward kwargs into the upgraded FileProcessor
+        self.file_processor = FileProcessor(**(file_processor_kwargs or {}))
 
         log.info("VectorStoreClient → %s", self.base_url)
 
@@ -180,12 +187,15 @@ class VectorStoreClient:
         vector_size: int,
         distance_metric: str,
         config: Optional[Dict[str, Any]],
+        vectors_config: Optional[Dict[str, qdrant.VectorParams]] = None,  # ← NEW
     ) -> ValidationInterface.VectorStoreRead:
         shared_id = self.identifier_service.generate_vector_id()
+        # forward multi-vector schema if given
         self.vector_manager.create_store(
             collection_name=shared_id,
             vector_size=vector_size,
             distance=distance_metric.upper(),
+            vectors_config=vectors_config,
         )
 
         payload = {
@@ -198,10 +208,6 @@ class VectorStoreClient:
         resp = await self._request("POST", "/v1/vector-stores", json=payload)
         return ValidationInterface.VectorStoreRead.model_validate(resp)
 
-    async def _list_my_vs_async(self) -> List[ValidationInterface.VectorStoreRead]:
-        resp = await self._request("GET", "/v1/vector-stores")
-        return [ValidationInterface.VectorStoreRead.model_validate(r) for r in resp]
-
     # ------------------------------------------------------------------ #
     # NEW  admin‑aware creation helper
     # ------------------------------------------------------------------ #
@@ -212,13 +218,17 @@ class VectorStoreClient:
         vector_size: int,
         distance_metric: str,
         config: Optional[Dict[str, Any]],
+        vectors_config: Optional[Dict[str, qdrant.VectorParams]] = None,  # ← NEW
     ) -> ValidationInterface.VectorStoreRead:
         shared_id = self.identifier_service.generate_vector_id()
+        # forward multi-vector schema if given
         self.vector_manager.create_store(
             collection_name=shared_id,
             vector_size=vector_size,
             distance=distance_metric.upper(),
+            vectors_config=vectors_config,
         )
+
         payload = {
             "shared_id": shared_id,
             "name": name,
@@ -226,7 +236,6 @@ class VectorStoreClient:
             "distance_metric": distance_metric.upper(),
             "config": config or {},
         }
-        # pass owner_id as query‑param (backend enforces admin‑only)
         resp = await self._request(
             "POST",
             "/v1/vector-stores",
@@ -282,25 +291,63 @@ class VectorStoreClient:
     async def _search_vs_async(
         self,
         vector_store_id: str,
-        query_text: str,
+        query_text: Union[str, List[float]],
         top_k: int,
         filters: Optional[Dict] = None,
         vector_store_host: Optional[str] = None,
+        vector_field: Optional[str] = None,  # allow caller override
     ) -> List[Dict[str, Any]]:
-        # Use the provided vector_store_host if specified, otherwise fall back to the default
-        if vector_store_host:
-            vector_manager = VectorStoreManager(vector_store_host=vector_store_host)
-        else:
-            vector_manager = self.vector_manager
+        """
+        Internal: run ANN search against the specified vector field or auto-detect by store size.
+
+        If `vector_field` is provided, it will be used directly. Otherwise:
+          • 1024-D → caption_vector
+          • 3-D    → geo_vector
+          • others → default vector (text)
+        """
+        # pick local vs. override host
+        vector_manager = (
+            VectorStoreManager(vector_store_host=vector_store_host)
+            if vector_store_host
+            else self.vector_manager
+        )
 
+        # fetch store info to inspect schema
         store = self.retrieve_vector_store_sync(vector_store_id)
-        vec = self.file_processor.embedding_model.encode(query_text).tolist()
 
+        # determine the query vector and target field
+        if vector_field is not None:
+            # if caller passed a raw vector list, use it; otherwise treat as caption search
+            if isinstance(query_text, list):
+                vec = query_text
+            else:
+                vec = self.file_processor.encode_clip_text(query_text).tolist()
+        else:
+            # auto-detect based on stored vector dimensionality
+            if store.vector_size == 1024:
+                # image/caption space
+                vec = self.file_processor.encode_clip_text(query_text).tolist()
+                vector_field = "caption_vector"
+            elif store.vector_size == 3:
+                # geo space; query_text must be a raw 3-D list
+                if not isinstance(query_text, list):
+                    raise VectorStoreClientError(
+                        "Geo search requires a 3-element vector; pass raw unit-sphere list"
+                    )
+                vec = query_text
+                vector_field = "geo_vector"
+            else:
+                # fallback to text embedding
+                vec = self.file_processor.encode_text(query_text).tolist()
+                vector_field = None  # use default
+
+        # perform the search on the selected vector column
         return vector_manager.query_store(
             store_name=store.collection_name,
             query_vector=vec,
             top_k=top_k,
             filters=filters,
+            vector_field=vector_field,
         )
 
     async def _delete_vs_async(
@@ -427,12 +474,48 @@ class VectorStoreClient:
         vector_size: int = 384,
         distance_metric: str = "Cosine",
         config: Optional[Dict[str, Any]] = None,
+        vectors_config: Optional[Dict[str, qdrant.VectorParams]] = None,  # ← NEW
     ) -> ValidationInterface.VectorStoreRead:
-        """Create a new store owned by *this* API key."""
+        """
+        Create a new store owned by this API key.
+
+        If `vectors_config` is provided, it should map each vector
+        field name to its Qdrant VectorParams (size + distance).
+        """
         return self._run_sync(
-            self._create_vs_async(name, vector_size, distance_metric, config)
+            self._create_vs_async(
+                name,
+                vector_size,
+                distance_metric,
+                config,
+                vectors_config,
+            )
         )
 
+    def create_vector_vision_store(
+        self,
+        name: str = "vision",
+    ):
+
+        vectors_config = {
+            # Raw visual embeddings (OpenCLIP ViT-H/14 → 1024-D)
+            "image_vector": qdrant.VectorParams(
+                size=1024, distance=qdrant.Distance.COSINE
+            ),
+            # Language embeddings of your BLIP-2 captions → 1024-D
+            "caption_vector": qdrant.VectorParams(
+                size=1024, distance=qdrant.Distance.COSINE
+            ),
+            # Object-region embeddings (YOLO crop + Sentence-BERT) → 1024-D
+            "region_vector": qdrant.VectorParams(
+                size=1024, distance=qdrant.Distance.COSINE
+            ),
+            # Geo-location unit vectors (RegioNet) → 3-D
+            "geo_vector": qdrant.VectorParams(size=3, distance=qdrant.Distance.COSINE),
+        }
+
+        return self.create_vector_store(name=name, vectors_config=vectors_config)
+
     def create_vector_store_for_user(
         self,
         owner_id: str,
@@ -441,16 +524,20 @@ class VectorStoreClient:
         vector_size: int = 384,
         distance_metric: str = "Cosine",
         config: Optional[Dict[str, Any]] = None,
+        vectors_config: Optional[Dict[str, qdrant.VectorParams]] = None,  # ← NEW
     ) -> ValidationInterface.VectorStoreRead:
         """
-        **Admin‑only** helper → create a store on behalf of *owner_id*.
-
-        The caller’s API‑key must belong to an admin; otherwise the
-        request will be rejected by the server with HTTP 403.
+        Admin-only: create a store on behalf of another user.
+        Pass `vectors_config` to define a multi-vector schema.
         """
         return self._run_sync(
             self._create_vs_for_user_async(
-                owner_id, name, vector_size, distance_metric, config
+                owner_id,
+                name,
+                vector_size,
+                distance_metric,
+                config,
+                vectors_config,
             )
         )
 
@@ -629,10 +716,16 @@ class VectorStoreClient:
         top_k: int = 5,
         filters: Optional[Dict] = None,
         vector_store_host: Optional[str] = None,
+        vector_field: Optional[str] = None,  # ← NEW
     ) -> List[Dict[str, Any]]:
         return self._run_sync(
             self._search_vs_async(
-                vector_store_id, query_text, top_k, filters, vector_store_host
+                vector_store_id,
+                query_text,
+                top_k,
+                filters,
+                vector_store_host,
+                vector_field,
             )
         )
 
@@ -796,3 +889,91 @@ class VectorStoreClient:
         hits = self._normalise_hits(hits)
 
         return hits
+
+    def image_similarity_search(
+        self,
+        vector_store_id: str,
+        img: Image.Image,
+        k: int = 10,
+        vector_store_host: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        vec = self.file_processor.encode_image(img).tolist()
+        return self.vector_file_search_raw(
+            vector_store_id=vector_store_id,
+            query_text=vec,
+            top_k=k,
+            filters=None,
+            vector_store_host=vector_store_host,
+            vector_field="image_vector",
+        )
+
+    def search_images(
+        self,
+        vector_store_id: str,
+        query: Union[str, Image.Image, List[float]],
+        *,
+        modality: Optional[str] = None,
+        k: int = 10,
+        vector_store_host: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        Unified image search across multiple modalities, with appropriate reranking:
+
+        - If `query` is a str → caption search (reranked)
+        - If `query` is a PIL.Image.Image → visual search (no rerank)
+        - If `query` is a list[float] → raw vector search
+        - `modality` override: one of 'caption', 'image', 'region', 'geo'
+        """
+        # Map modality to (vector_field, encoder)
+        field_map = {
+            "caption": (
+                "caption_vector",
+                lambda q: self.file_processor.encode_clip_text(q).tolist(),
+            ),
+            "image": (
+                "image_vector",
+                lambda q: self.file_processor.encode_image(q).tolist(),
+            ),
+            "region": (
+                "region_vector",
+                lambda q: self.file_processor.encode_text(q).tolist(),
+            ),
+            "geo": ("geo_vector", lambda q: q),  # assume q is raw 3-D vector
+        }
+
+        # Auto-detect if not provided
+        if modality is None:
+            if isinstance(query, str):
+                modality = "caption"
+            elif isinstance(query, Image.Image):
+                modality = "image"
+            elif isinstance(query, list):
+                modality = "image"
+            else:
+                raise VectorStoreClientError(f"Unsupported query type: {type(query)}")
+
+        modality = modality.lower()
+        if modality not in field_map:
+            raise VectorStoreClientError(f"Unknown modality '{modality}'")
+
+        vector_field, encoder = field_map[modality]
+        vec = encoder(query)
+
+        # 1️⃣ ANN search
+        hits = self.vector_file_search_raw(
+            vector_store_id=vector_store_id,
+            query_text=vec,
+            top_k=k,
+            filters=None,
+            vector_store_host=vector_store_host,
+            vector_field=vector_field,
+        )
+
+        # 2️⃣ Rerank for text-based modalities
+        if modality in ("caption", "region"):
+            hits = reranker.rerank(
+                query if isinstance(query, str) else "", hits, top_k=min(len(hits), k)
+            )
+
+        # 3️⃣ Normalize and return
+        return self._normalise_hits(hits)

{projectdavid-1.32.20.dist-info → projectdavid-1.33.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: projectdavid
-Version: 1.32.20
+Version: 1.33.0
 Summary: Python SDK for interacting with the Entities Assistant API.
 Author-email: Francis Neequaye Armah <francis.neequaye@projectdavid.co.uk>
 License: PolyForm Noncommercial License 1.0.0
@@ -29,6 +29,13 @@ Requires-Dist: sseclient-py
 Requires-Dist: requests
 Requires-Dist: python-docx
 Requires-Dist: python-pptx
+Requires-Dist: open_clip_torch>=2.24
+Requires-Dist: pillow>=10.2
+Requires-Dist: transformers>=4.41
+Requires-Dist: accelerate>=0.28
+Requires-Dist: sentencepiece>=0.2
+Requires-Dist: ultralytics>=8.2.21
+Requires-Dist: pytesseract>=0.3
 Provides-Extra: dev
 Requires-Dist: black>=23.3; extra == "dev"
 Requires-Dist: isort>=5.12; extra == "dev"
@@ -36,6 +43,17 @@ Requires-Dist: pytest>=7.2; extra == "dev"
 Requires-Dist: mypy>=1.0; extra == "dev"
 Requires-Dist: build; extra == "dev"
 Requires-Dist: twine; extra == "dev"
+Provides-Extra: vision
+Requires-Dist: torch>=2.2.1; extra == "vision"
+Requires-Dist: torchvision>=0.17.1; extra == "vision"
+Requires-Dist: torchaudio>=2.2.1; extra == "vision"
+Requires-Dist: open_clip_torch>=2.24; extra == "vision"
+Requires-Dist: pillow>=10.2; extra == "vision"
+Requires-Dist: transformers>=4.41; extra == "vision"
+Requires-Dist: accelerate>=0.28; extra == "vision"
+Requires-Dist: sentencepiece>=0.2; extra == "vision"
+Requires-Dist: ultralytics>=8.2.21; extra == "vision"
+Requires-Dist: pytesseract>=0.3; extra == "vision"
 Dynamic: license-file
 
 # Entity  — by Project David

{projectdavid-1.32.20.dist-info → projectdavid-1.33.0.dist-info}/RECORD

@@ -9,18 +9,18 @@ projectdavid/clients/assistants_client.py,sha256=SsIGa5wPr7ga9WX0ywam3djUF-uWFdk
 projectdavid/clients/base_client.py,sha256=UWl6nr6sxD1_xC6iyptQDR1tnNdFCOrEx5cEUPCRqJE,3417
 projectdavid/clients/base_vector_store.py,sha256=jXivmqAW1bgYcLgIeW-hPxOiWZbs2hCsLy4oWzSvpNI,2061
 projectdavid/clients/event_handler.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-projectdavid/clients/file_processor.py,sha256=t-Uw-kBP_VmlguMxO9PWY6ANuMAY0PstQDW37wLPF0Q,13980
+projectdavid/clients/file_processor.py,sha256=nFccQmiow3lkjv1-Pdgv_2WQAtSy0FRN7oJlTKt4fs4,21114
 projectdavid/clients/file_search.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 projectdavid/clients/files_client.py,sha256=XkIDzbQFGDrd88taf0Kouc_4YJOPIYEHiIyWYLKDofI,15581
 projectdavid/clients/inference_client.py,sha256=xz4ACPv5Tkis604QxO5mJX1inH_TGDfQP-31geETYpE,6609
 projectdavid/clients/messages_client.py,sha256=467xeIt3VYs6cG8-bl-eDRi_auWOPmfd5tSJDmQSJUI,17232
 projectdavid/clients/runs.py,sha256=-fXOq5L9w2efDPmZkNxb0s2yjl6oN0XN4_aLXqaeceo,25270
-projectdavid/clients/synchronous_inference_wrapper.py,sha256=M0Z8YvOIcYQsYKZ7m5U7edq-OwY1wU9BKH6EIlG3WHI,4769
+projectdavid/clients/synchronous_inference_wrapper.py,sha256=mN5WAHmv0aRoeMIb7XPgv3cuqrMPzu378UsZ02jEvRY,5090
 projectdavid/clients/threads_client.py,sha256=ekzU5w14zftmtmFkiec3NC90Of-_KVSUY1qH9cmfSFg,6771
 projectdavid/clients/tools_client.py,sha256=GkCVOmwpAoPqVt6aYmH0G1HIFha3iEwR9IIf9teR0j8,11487
 projectdavid/clients/users_client.py,sha256=eCuUb9qvyH1GUFhZu6TRL9zdoK-qzHSs8-Vmrk_0mmg,13729
-projectdavid/clients/vector_store_manager.py,sha256=lk-sWJjo6Z0EHZzjRoKiHPr0GpEXfE4bJBQzmKV8ezc,11372
-projectdavid/clients/vectors.py,sha256=1UNnLN5nsMvVHXK4Yf7iTXGWZfgIjQ9eLQtCBe0Cqew,30986
+projectdavid/clients/vector_store_manager.py,sha256=q-ZgRQVX_S3nMrKYhmvkVrDjDRzM3ZFzUF55HBGRTe8,12861
+projectdavid/clients/vectors.py,sha256=sDbT1GbsIuwzvInuDDcyX4scuuLJDWWgL7Fmc-pguRQ,37672
 projectdavid/constants/platform.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 projectdavid/services/logging_service.py,sha256=jdoRL46E42Ar8JFTDOV-xVD67CulcHSN-xhcEqA5CXQ,2643
 projectdavid/synthesis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -34,8 +34,8 @@ projectdavid/utils/monitor_launcher.py,sha256=3YAgJdeuaUvq3JGvpA4ymqFsAnk29nH5q9
 projectdavid/utils/peek_gate.py,sha256=5whMRnDOQjATRpThWDJkvY9ScXuJ7Sd_-9rvGgXeTAQ,2532
 projectdavid/utils/run_monitor.py,sha256=F_WkqIP-qnWH-4llIbileWWLfRj2Q1Cg-ni23SR1rec,3786
 projectdavid/utils/vector_search_formatter.py,sha256=YTe3HPGec26qGY7uxY8_GS8lc4QaN6aNXMzkl29nZpI,1735
-projectdavid-1.32.20.dist-info/licenses/LICENSE,sha256=_8yjiEGttpS284BkfhXxfERqTRZW_tUaHiBB0GTJTMg,4563
-projectdavid-1.32.20.dist-info/METADATA,sha256=OpxxEI8F42M3uCPtloApoabA5c_AG4Yvnb_81ix0aHE,10782
-projectdavid-1.32.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-projectdavid-1.32.20.dist-info/top_level.txt,sha256=kil8GU4s7qYRfNnzGnFHhZnSNRSxgNG-J4HLgQMmMtw,13
-projectdavid-1.32.20.dist-info/RECORD,,
+projectdavid-1.33.0.dist-info/licenses/LICENSE,sha256=_8yjiEGttpS284BkfhXxfERqTRZW_tUaHiBB0GTJTMg,4563
+projectdavid-1.33.0.dist-info/METADATA,sha256=1Yhr24U_T9-Wv6Ladi67ZjTqwvcmpP4C241DtcCJMRk,11554
+projectdavid-1.33.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+projectdavid-1.33.0.dist-info/top_level.txt,sha256=kil8GU4s7qYRfNnzGnFHhZnSNRSxgNG-J4HLgQMmMtw,13
+projectdavid-1.33.0.dist-info/RECORD,,