projectdavid 1.31.0__py3-none-any.whl → 1.38.1__py3-none-any.whl

projectdavid/clients/threads_client.py

@@ -1,4 +1,4 @@
-# projectdavid/clients/threads_client.py
+#! projectdavid/clients/threads_client.py
 from typing import Any, Dict, List, Optional
 
 import httpx
@@ -104,16 +104,30 @@ class ThreadsClient(BaseAPIClient):
             logging_utility.error("Unexpected error retrieving thread: %s", str(e))
             raise
 
-    def update_thread(self, thread_id: str, **updates) -> validator.ThreadReadDetailed:
+    def update_thread(
+        self,
+        thread_id: str,
+        *,
+        participant_ids: Optional[List[str]] = None,
+        meta_data: Optional[Dict[str, Any]] = None,
+        tool_resources: Optional[Dict[str, Any]] = None,
+    ) -> validator.ThreadReadDetailed:
         logging_utility.info("Updating thread with id: %s", thread_id)
         try:
-            validated_updates = validator.ThreadUpdate(**updates)
-            response = self.client.post(
-                f"/v1/threads/{thread_id}", json=validated_updates.model_dump()
+            validated_updates = validator.ThreadUpdate(
+                participant_ids=participant_ids,
+                meta_data=meta_data,
+                tool_resources=tool_resources,
+            )
+
+            response = self.client.put(
+                f"/v1/threads/{thread_id}",
+                json=validated_updates.model_dump(),
             )
             response.raise_for_status()
             updated_thread = response.json()
             return validator.ThreadReadDetailed(**updated_thread)
+
         except httpx.HTTPStatusError as e:
             logging_utility.error("HTTP error updating thread: %s", str(e))
             raise
@@ -154,17 +168,23 @@ class ThreadsClient(BaseAPIClient):
             logging_utility.error("Unexpected error listing threads: %s", str(e))
             raise
 
-    def delete_thread(self, thread_id: str) -> bool:
+    def delete_thread(self, thread_id: str) -> validator.ThreadDeleted | None:
+        """
+        Delete a thread.
+        ▶ On success:  returns ThreadDeleted(id=…, object='thread.deleted', deleted=True)
+        ▶ If not found: returns None
+        """
         logging_utility.info("Deleting thread with id: %s", thread_id)
+
         try:
-            response = self.client.delete(f"/v1/threads/{thread_id}")
-            response.raise_for_status()
-            return True
+            resp = self.client.delete(f"/v1/threads/{thread_id}")
+            resp.raise_for_status()  # 2xx → OK
+            return validator.ThreadDeleted(**resp.json())  # ← parse envelope
         except httpx.HTTPStatusError as e:
             if e.response.status_code == 404:
-                return False
-            logging_utility.error("HTTP error deleting thread: %s", str(e))
+                return None  # thread not found
+            logging_utility.error("HTTP error deleting thread: %s", e)
             raise
         except Exception as e:
-            logging_utility.error("Unexpected error deleting thread: %s", str(e))
+            logging_utility.error("Unexpected error deleting thread: %s", e)
             raise

projectdavid/clients/vector_store_manager.py

@@ -9,7 +9,6 @@ from __future__ import annotations
 
 import time
 import uuid
-from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from dotenv import load_dotenv
@@ -50,11 +49,20 @@ 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.
+
+        • If *vectors_config* is provided → use it verbatim (multi-vector schema).
+        • Otherwise create a classic single-vector collection *without* naming the
+          vector field – so upserts can omit ``vector_name``.
+        """
         try:
-            # quick existence check
+            # ── pre-existence check ────────────────────────────────────────────
             if any(
                 col.name == collection_name
                 for col in self.client.get_collections().collections
@@ -65,16 +73,32 @@ class VectorStoreManager(BaseVectorStore):
             if dist not in qdrant.Distance.__members__:
                 raise ValueError(f"Invalid distance metric '{distance}'")
 
+            # ── choose schema ──────────────────────────────────────────────────
+            if vectors_config:  # caller supplied full mapping
+                config = vectors_config  # e.g. {"text_vec": ..., "img_vec": ...}
+            else:  # default = single unnamed vector
+                config = qdrant.VectorParams(
+                    size=vector_size,
+                    distance=qdrant.Distance[dist],
+                )
+
+            # ── (re)create collection ─────────────────────────────────────────
             self.client.recreate_collection(
                 collection_name=collection_name,
-                vectors_config=qdrant.VectorParams(
-                    size=vector_size, distance=qdrant.Distance[dist]
-                ),
+                vectors_config=config,
             )
+
+            # ── bookkeeping ───────────────────────────────────────────────────
+            if isinstance(config, dict):
+                fields = list(config.keys())
+            else:  # unnamed field
+                fields = [None]
+
             self.active_stores[collection_name] = {
                 "created_at": int(time.time()),
                 "vector_size": vector_size,
                 "distance": dist,
+                "fields": fields,
             }
             log.info("Created Qdrant collection %s", collection_name)
             return {"collection_name": collection_name, "status": "created"}
@@ -103,30 +127,68 @@ 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)
             raise VectorStoreError(f"Info retrieval failed: {e}") from e
 
-    # ------------------------------------------------------------------ #
-    # ingestion helpers
-    # ------------------------------------------------------------------ #
     def add_to_store(
         self,
+        *,
         store_name: str,
         texts: List[str],
         vectors: List[List[float]],
         metadata: List[dict],
-    ):
+        vector_name: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Upsert vectors + payloads into *store_name*.
+
+        If *vector_name* is omitted the manager:
+
+        • auto-detects the single vector field for classic (unnamed) collections
+        • auto-detects the sole key for named-vector collections with exactly one field
+        • raises if multiple named fields exist.
+        """
+
+        # ─── input validation ───────────────────────────────────────────────
         if not vectors:
             raise ValueError("Empty vectors list")
         expected = len(vectors[0])
         for i, vec in enumerate(vectors):
             if len(vec) != expected or not all(isinstance(v, float) for v in vec):
-                raise ValueError(f"Vector {i} malformed")
+                raise ValueError(f"Vector {i} malformed: expected {expected} floats")
 
+        # ─── auto-detect vector field ───────────────────────────────────────
+        if vector_name is None:
+            coll_info = self.client.get_collection(collection_name=store_name)
+            v_cfg = coll_info.config.params.vectors
+
+            if isinstance(v_cfg, dict):  # modern named-vector schema
+                vector_fields = list(v_cfg.keys())
+                if len(vector_fields) == 1:  # exactly one → safe default
+                    vector_name = vector_fields[0]
+                    log.debug(
+                        "Auto-detected vector_name=%r for store=%s",
+                        vector_name,
+                        store_name,
+                    )
+                else:  # >1 named fields → ambiguous
+                    raise ValueError(
+                        f"Multiple vector fields {vector_fields}; please specify vector_name"
+                    )
+            else:
+                # legacy single-vector schema → leave vector_name as None
+                log.debug(
+                    "Collection %s uses legacy single-vector schema; "
+                    "upserting without vector_name",
+                    store_name,
+                )
+
+        # ─── build points payload ───────────────────────────────────────────
         points = [
             qdrant.PointStruct(
                 id=self._generate_vector_id(),
@@ -135,12 +197,27 @@ class VectorStoreManager(BaseVectorStore):
             )
             for txt, vec, meta in zip(texts, vectors, metadata)
         ]
+
+        # ─── upsert with backward-compat for old qdrant-client builds ───────
+        import inspect  # keep local to avoid top-level dependency if absent elsewhere
+
+        upsert_sig = inspect.signature(self.client.upsert)
+        supports_vector_name = "vector_name" in upsert_sig.parameters
+
+        upsert_kwargs: Dict[str, Any] = {
+            "collection_name": store_name,
+            "points": points,
+            "wait": True,
+        }
+        if supports_vector_name and vector_name is not None:
+            upsert_kwargs["vector_name"] = vector_name
+
         try:
-            self.client.upsert(collection_name=store_name, points=points, wait=True)
+            self.client.upsert(**upsert_kwargs)
             return {"status": "success", "points_inserted": len(points)}
-        except Exception as e:
-            log.error("Add‑to‑store failed: %s", e)
-            raise VectorStoreError(f"Insertion failed: {e}") from e
+        except Exception as exc:  # noqa: BLE001
+            log.error("Add-to-store failed: %s", exc, exc_info=True)
+            raise VectorStoreError(f"Insertion failed: {exc}") from exc
 
     # ------------------------------------------------------------------ #
     # search / query
@@ -189,15 +266,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,
@@ -208,19 +295,21 @@ class VectorStoreManager(BaseVectorStore):
             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

@@ -61,13 +61,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,9 +87,13 @@ 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()
+
+        # 🔶 forward kwargs into the upgraded FileProcessor
+        # self.file_processor = FileProcessor(**(file_processor_kwargs or {}))
+        # Using Stripped down version for now until we move forward with multi-modal stores
         self.file_processor = FileProcessor()
 
         log.info("VectorStoreClient → %s", self.base_url)
@@ -240,32 +247,31 @@ class VectorStoreClient:
     ) -> ValidationInterface.VectorStoreFileRead:
         processed = await self.file_processor.process_file(p)
         texts, vectors = processed["chunks"], processed["vectors"]
-        line_data = processed.get("line_data") or []  # ← NEW
-
-        base_md = meta or {}
-        base_md.update({"source": str(p), "file_name": p.name})
+        line_data = processed.get("line_data") or []
 
+        base_md = (meta or {}) | {"source": str(p), "file_name": p.name}
         file_record_id = f"vsf_{uuid.uuid4()}"
 
-        # Build per‑chunk payload, now including page/lines if present
         chunk_md = []
-        for i in range(len(texts)):
-            payload = {
-                **base_md,
-                "chunk_index": i,
-                "file_id": file_record_id,
-            }
-            if i < len(line_data):  # ← NEW
-                payload.update(line_data[i])  # {'page': …, 'lines': …}
+        for i, txt in enumerate(texts):
+            payload = {**base_md, "chunk_index": i, "file_id": file_record_id}
+            if i < len(line_data):
+                payload.update(line_data[i])  # {'page':…, 'lines':…}
             chunk_md.append(payload)
 
+        # 🔑 1. look up the backend store to get its *collection* name
+        store = self.retrieve_vector_store_sync(vector_store_id)
+        collection_name = store.collection_name
+
+        # 🔑 2. upsert via VectorStoreManager (auto-detects vector field)
         self.vector_manager.add_to_store(
-            store_name=vector_store_id,
+            store_name=collection_name,
             texts=texts,
             vectors=vectors,
             metadata=chunk_md,
         )
 
+        # 3. register the file with the API
         resp = await self._request(
             "POST",
             f"/v1/vector-stores/{vector_store_id}/files",
@@ -287,26 +293,36 @@ class VectorStoreClient:
         filters: Optional[Dict] = None,
         vector_store_host: Optional[str] = None,
     ) -> 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
+
+        # pick local vs. override host
+        vector_manager = (
+            VectorStoreManager(vector_store_host=vector_store_host)
+            if vector_store_host
+            else self.vector_manager
+        )
 
         store = self.retrieve_vector_store_sync(vector_store_id)
-        vec = self.file_processor.embedding_model.encode(query_text).tolist()
+
+        # 🔶 choose encoder by vector_size
+        if store.vector_size == 1024:  # images collection
+            vec = self.file_processor.encode_clip_text(query_text).tolist()
+            vector_field = "caption_vector"  # field name in Qdrant
+        else:  # 384-D text collection
+            vec = self.file_processor.encode_text(query_text).tolist()
+            vector_field = None  # default field
 
         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(
-        self, vector_store_id: str, permanent: bool
-    ) -> Dict[str, Any]:
-        qres = self.vector_manager.delete_store(vector_store_id)
+    async def _delete_vs_async(self, vector_store_id: str, permanent: bool):
+        # collection deletion must use the *collection* name
+        store = self.retrieve_vector_store_sync(vector_store_id)
+        qres = self.vector_manager.delete_store(store.collection_name)
         await self._request(
             "DELETE",
             f"/v1/vector-stores/{vector_store_id}",
@@ -319,10 +335,11 @@ class VectorStoreClient:
             "qdrant_result": qres,
         }
 
-    async def _delete_file_async(
-        self, vector_store_id: str, file_path: str
-    ) -> Dict[str, Any]:
-        fres = self.vector_manager.delete_file_from_store(vector_store_id, file_path)
+    async def _delete_file_async(self, vector_store_id: str, file_path: str):
+        store = self.retrieve_vector_store_sync(vector_store_id)
+        fres = self.vector_manager.delete_file_from_store(
+            store.collection_name, file_path
+        )
         await self._request(
             "DELETE",
             f"/v1/vector-stores/{vector_store_id}/files",