Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

Remove qdrant and opengauss vector backends (#3872)

Jiahui Zhou1d02a72b2b9f
diff --git a/docs/en/configuration/01-server.md b/docs/en/configuration/01-server.md
index 702a6bd3c..4ea97164e 100644
--- a/docs/en/configuration/01-server.md
+++ b/docs/en/configuration/01-server.md
@@ -192,7 +192,7 @@ Search and Find requests default to `limit: 10`; override the limit on each API
|---|---|---|---|
| `workspace` | path | `"./data"` | OpenViking workspace |
| `agfs.backend` | `local`, `memory`, `s3` | `local` | File and metadata backend |
-| `vectordb.backend` | `local`, `cuvs`, `http`, `volcengine`, `vikingdb`, `qdrant`, `opengauss` | `local` | Vector database backend |
+| `vectordb.backend` | `local`, `cuvs`, `http`, `volcengine`, `vikingdb` | `local` | Vector database backend |
| `vectordb.dimension` | integer | follows Embedding | Vector collection dimension |
| `skip_process_lock` | boolean | `false` | Skip the workspace process lock; use only when accepting concurrent-write risk |
diff --git a/docs/en/guides/01-configuration.md b/docs/en/guides/01-configuration.md
index e15c8c6d2..e95af1337 100644
--- a/docs/en/guides/01-configuration.md
+++ b/docs/en/guides/01-configuration.md
@@ -988,7 +988,7 @@ Grep engine configuration for content pattern search. These settings are server-
| `engine` | str | Search engine mode: `"auto"` uses VikingDB BM25 recall when available and falls back to local filesystem search; `"fs"` forces local filesystem search only. | `"auto"` |
| `switch_to_remote_threshold` | int | L2 record count threshold to switch to VikingDB BM25 recall. When the number of L2 files under the search scope reaches this threshold, VikingDB BM25 is used for phase-1 recall; otherwise local filesystem search is used. Set to `0` to always use VikingDB BM25. Must be ≥ 0. | `10000` |
-For VikingDB / Volcengine FullText grep, OpenViking writes a `content` text field for BM25 recall. The source context keeps the full content, while the vector-store write payload truncates this field to **1 MB** at the final adapter boundary to stay within backend payload limits. Only VikingDB-backed backends use `content`; on all other backends (`local`, `cuvs`, `qdrant`, `opengauss`, `http`) the field is not written.
+For VikingDB / Volcengine FullText grep, OpenViking writes a `content` text field for BM25 recall. The source context keeps the full content, while the vector-store write payload truncates this field to **1 MB** at the final adapter boundary to stay within backend payload limits. Only VikingDB-backed backends use `content`; on all other backends (`local`, `cuvs`, `http`) the field is not written.
### storage
@@ -1351,7 +1351,7 @@ Vector database storage configuration
| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
-| `backend` | str | VectorDB backend type: 'local' (file-based), 'http' (remote service), 'volcengine' (cloud VikingDB), 'vikingdb' (private deployment), 'cuvs' (local storage + GPU dense search), 'qdrant', or 'opengauss' | "local" |
+| `backend` | str | VectorDB backend type: 'local' (file-based), 'http' (remote service), 'volcengine' (cloud VikingDB), 'vikingdb' (private deployment), or 'cuvs' (local storage + GPU dense search) | "local" |
| `name` | str | VectorDB collection name | "context" |
| `url` | str | Remote service URL for 'http' type (e.g., 'http://localhost:5000') | null |
| `project_name` | str | Project name (alias project) | "default" |
@@ -1361,8 +1361,6 @@ Vector database storage configuration
| `volcengine` | object | 'volcengine' type VikingDB configuration | - |
| `vikingdb` | object | 'vikingdb' type private deployment configuration | - |
| `cuvs` | object | NVIDIA cuVS configuration for the 'cuvs' backend and the opt-in memory-aware auto mode on 'local'; see the [cuVS guide](./16-cuvs.md) | - |
-| `qdrant` | object | 'qdrant' type Qdrant configuration | - |
-| `opengauss` | object | 'opengauss' native vector backend configuration | - |
Default local mode
```
@@ -1396,40 +1394,6 @@ Supports cloud-deployed VikingDB on Volcengine
```
</details>
-<details>
-<summary><b>openGauss</b></summary>
-
-Requires an openGauss server with native `vector` support and a remote-capable database user.
-Install the optional driver with `pip install "openviking[opengauss]"`.
-In the official container, the initial `omm` user may be restricted for remote login; create a normal user for OpenViking if needed.
-
-```json
-{
- "storage": {
- "vectordb": {
- "name": "context",
- "backend": "opengauss",
- "project": "default",
- "distance_metric": "cosine",
- "dimension": 1024,
- "opengauss": {
- "host": "127.0.0.1",
- "port": 5432,
- "user": "openviking",
- "password": "your-password",
- "db_name": "postgres",
- "schema": "public",
- "mode": "standalone"
- }
- }
- }
-}
-```
-
-Set `mode` to `"distributed"` for openGauss distributed deployments; OpenViking will attempt to mark metadata tables as reference tables and distribute collection tables by `id`.
-</details>
-
-
## Config Files
OpenViking uses two config files:
diff --git a/docs/zh/configuration/01-server.md b/docs/zh/configuration/01-server.md
index a90f0a0e9..29c26cd1f 100644
--- a/docs/zh/configuration/01-server.md
+++ b/docs/zh/configuration/01-server.md
@@ -192,7 +192,7 @@ Search 和 Find 请求的默认 `limit` 为 `10`,可以在每次 API 或 SDK
|---|---|---|---|
| `workspace` | path | `"./data"` | OpenViking 工作目录 |
| `agfs.backend` | `local`、`memory`、`s3` | `local` | 文件与元数据存储后端 |
-| `vectordb.backend` | `local`、`cuvs`、`http`、`volcengine`、`vikingdb`、`qdrant`、`opengauss` | `local` | 向量数据库后端 |
+| `vectordb.backend` | `local`、`cuvs`、`http`、`volcengine`、`vikingdb` | `local` | 向量数据库后端 |
| `vectordb.dimension` | integer | 跟随 Embedding | 向量集合维度 |
| `skip_process_lock` | boolean | `false` | 是否跳过 workspace 进程锁;仅在明确接受并发写风险时启用 |
diff --git a/docs/zh/guides/01-configuration.md b/docs/zh/guides/01-configuration.md
index 5746dd37c..a0c03a903 100644
--- a/docs/zh/guides/01-configuration.md
+++ b/docs/zh/guides/01-configuration.md
@@ -956,7 +956,7 @@ Grep 引擎配置,用于内容模式搜索。这些设置为服务端配置,
| `engine` | str | 搜索引擎模式:`"auto"` 在可用时使用 VikingDB BM25 召回,不可用时回退到本地文件系统搜索;`"fs"` 强制仅使用本地文件系统搜索。 | `"auto"` |
| `switch_to_remote_threshold` | int | 切换到 VikingDB BM25 召回的 L2 记录数阈值。当搜索范围内的 L2 文件数达到此阈值时,使用 VikingDB BM25 进行第一阶段召回;否则使用本地文件系统搜索。设为 `0` 表示始终使用 VikingDB BM25。必须 ≥ 0。 | `10000` |
-对于 VikingDB / Volcengine FullText grep,OpenViking 会写入 `content` text 字段用于 BM25 召回。源上下文中保留完整内容,仅在最终写入向量库 adapter payload 时将该字段截断到 **1 MB**,以满足后端 payload 限制。只有 VikingDB 系后端使用 `content`;其它后端(`local`、`cuvs`、`qdrant`、`opengauss`、`http`)不写入该字段。
+对于 VikingDB / Volcengine FullText grep,OpenViking 会写入 `content` text 字段用于 BM25 召回。源上下文中保留完整内容,仅在最终写入向量库 adapter payload 时将该字段截断到 **1 MB**,以满足后端 payload 限制。只有 VikingDB 系后端使用 `content`;其它后端(`local`、`cuvs`、`http`)不写入该字段。
### storage
@@ -1437,7 +1437,7 @@ Redis Sentinel 分别配置数据节点和 Sentinel 的 ACL:
| 参数 | 类型 | 说明 | 默认值 |
|------|------|------|--------|
-| `backend` | str | VectorDB 后端类型: 'local'(基于文件), 'http'(远程服务), 'volcengine'(云上 VikingDB), 'vikingdb'(私有部署), 'cuvs'(本地存储 + GPU dense search), 'qdrant' 或 'opengauss' | "local" |
+| `backend` | str | VectorDB 后端类型: 'local'(基于文件), 'http'(远程服务), 'volcengine'(云上 VikingDB), 'vikingdb'(私有部署)或 'cuvs'(本地存储 + GPU dense search) | "local" |
| `name` | str | VectorDB 的集合名称 | "context" |
| `url` | str | 'http' 类型的远程服务 URL(例如 'http://localhost:5000') | null |
| `project_name` | str | 项目名称(别名 project) | "default" |
@@ -1447,8 +1447,6 @@ Redis Sentinel 分别配置数据节点和 Sentinel 的 ACL:
| `volcengine` | object | 'volcengine' 类型的 VikingDB 配置 | - |
| `vikingdb` | object | 'vikingdb' 类型的私有部署配置 | - |
| `cuvs` | object | NVIDIA cuVS 配置,也用于在 'local' 下显式开启显存感知自动模式,参见 [cuVS 使用指南](./16-cuvs.md) | - |
-| `qdrant` | object | 'qdrant' 类型的 Qdrant 配置 | - |
-| `opengauss` | object | 'opengauss' 原生向量后端配置 | - |
默认使用本地模式
```
@@ -1482,41 +1480,6 @@ Redis Sentinel 分别配置数据节点和 Sentinel 的 ACL:
```
</details>
-<details>
-<summary><b>openGauss</b></summary>
-
-需要 openGauss 服务端支持原生 `vector` 类型,并使用允许远程连接的数据库用户。
-可通过 `pip install "openviking[opengauss]"` 安装可选驱动。
-官方容器中的初始 `omm` 用户可能限制远程登录,必要时请为 OpenViking 创建普通数据库用户。
-
-```json
-{
- "storage": {
- "vectordb": {
- "name": "context",
- "backend": "opengauss",
- "project": "default",
- "distance_metric": "cosine",
- "dimension": 1024,
- "opengauss": {
- "host": "127.0.0.1",
- "port": 5432,
- "user": "openviking",
- "password": "your-password",
- "db_name": "postgres",
- "schema": "public",
- "mode": "standalone"
- }
- }
- }
-}
-```
-
-分布式 openGauss 部署可将 `mode` 设为 `"distributed"`;OpenViking 会尝试把元数据表标记为 reference table,并按 `id` 分布集合表。
-</details>
-
-
-
## 配置文件
OpenViking 使用两个配置文件:
diff --git a/openviking/storage/vectordb/collection/qdrant_collection.py b/openviking/storage/vectordb/collection/qdrant_collection.py
deleted file mode 100644
index 375c40825..000000000
--- a/openviking/storage/vectordb/collection/qdrant_collection.py
+++ /dev/null
@@ -1,1245 +0,0 @@
-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
-# SPDX-License-Identifier: AGPL-3.0
-"""Qdrant-backed ICollection implementation for OpenViking."""
-
-from __future__ import annotations
-
-import datetime as dt
-import uuid
-from typing import Any, Dict, List, Optional, Sequence, Tuple
-
-import xxhash
-
-from openviking.storage.vectordb.collection.collection import ICollection
-from openviking.storage.vectordb.collection.qdrant_meta_store import QdrantMetaStore
-from openviking.storage.vectordb.collection.qdrant_rest import QdrantRestClient, QdrantRestError
-from openviking.storage.vectordb.collection.result import (
- AggregateResult,
- DataItem,
- FetchDataInCollectionResult,
- SearchItemResult,
- SearchResult,
-)
-from openviking.storage.vectordb.index.index import IIndex
-from openviking.storage.vectordb.store.data import DeltaRecord
-from openviking_cli.utils import get_logger
-
-logger = get_logger(__name__)
-
-QDRANT_SPARSE_INDEX_MAX = 2**31 - 1
-QDRANT_UINT64_MAX = 2**64 - 1
-OPENVIKING_QDRANT_ID_NAMESPACE = uuid.UUID("4b6bb5a8-7f1f-5b1a-9d4c-b93f29b1d67c")
-ORIGINAL_ID_FIELD = "_openviking_original_id"
-
-
-def _coerce_iso_datetime(value: Any) -> Any:
- if isinstance(value, dt.datetime):
- if value.tzinfo is None:
- value = value.replace(tzinfo=dt.timezone.utc)
- return value.isoformat()
- return value
-
-
-def _normalize_distance(distance: str) -> str:
- distance_value = (distance or "cosine").strip().lower()
- mapping = {
- "cosine": "Cosine",
- "ip": "Dot",
- "dot": "Dot",
- "l2": "Euclid",
- "euclid": "Euclid",
- "manhattan": "Manhattan",
- }
- return mapping.get(distance_value, "Cosine")
-
-
-def _payload_selector(output_fields: Optional[List[str]]) -> bool | Dict[str, List[str]]:
- if not output_fields:
- return True
- include_fields = [field for field in output_fields if field != "id"]
- if ORIGINAL_ID_FIELD not in include_fields:
- include_fields.append(ORIGINAL_ID_FIELD)
- return {"include": include_fields} if include_fields else True
-
-
-def _parse_point_id(value: Any) -> Any:
- if value is None:
- return ""
- if isinstance(value, int) and not isinstance(value, bool):
- return value
- return str(value)
-
-
-def _to_qdrant_point_id(value: Any) -> int | str:
- if isinstance(value, int) and not isinstance(value, bool) and 0 <= value <= QDRANT_UINT64_MAX:
- return value
- value_str = str(value)
- try:
- return str(uuid.UUID(value_str))
- except (ValueError, AttributeError, TypeError):
- return str(uuid.uuid5(OPENVIKING_QDRANT_ID_NAMESPACE, value_str))
-
-
-def _extract_points(response: Dict[str, Any]) -> List[Dict[str, Any]]:
- result = response.get("result", response)
- if isinstance(result, list):
- return result
- if isinstance(result, dict):
- if isinstance(result.get("points"), list):
- return result.get("points", [])
- if isinstance(result.get("result"), list):
- return result.get("result", [])
- return []
-
-
-def _hash_sparse_term(term: str) -> int:
- # Keep sparse indices in the positive signed 32-bit integer range expected
- # by Qdrant sparse vectors.
- return xxhash.xxh64_intdigest(str(term)) % QDRANT_SPARSE_INDEX_MAX
-
-
-def _sparse_to_qdrant(sparse_vector: Optional[Dict[str, float]]) -> Optional[Dict[str, List[Any]]]:
- if not sparse_vector:
- return None
- merged: Dict[int, float] = {}
- hashed_terms: Dict[int, str] = {}
- collisions: List[tuple[str, str, int]] = []
- for raw_term, raw_weight in sparse_vector.items():
- try:
- weight = float(raw_weight)
- except (TypeError, ValueError):
- continue
- idx = _hash_sparse_term(str(raw_term))
- previous_term = hashed_terms.get(idx)
- if previous_term is not None and previous_term != str(raw_term):
- collisions.append((previous_term, str(raw_term), idx))
- else:
- hashed_terms[idx] = str(raw_term)
- merged[idx] = merged.get(idx, 0.0) + weight
- if collisions:
- sample = ", ".join(f"{left!r}<->{right!r}@{idx}" for left, right, idx in collisions[:3])
- logger.warning(
- "Qdrant sparse term hash collision detected; colliding terms are merged into the same sparse index bucket. count=%s sample=%s",
- len(collisions),
- sample,
- )
- if not merged:
- return None
- indices = sorted(merged.keys())
- values = [merged[idx] for idx in indices]
- return {"indices": indices, "values": values}
-
-
-class QdrantIndex(IIndex):
- """Lightweight logical index facade backed by Qdrant payload/vector config."""
-
- def __init__(
- self, collection: "QdrantCollection", index_name: str, meta: Dict[str, Any]
- ) -> None:
- super().__init__(meta=meta)
- self._collection = collection
- self._index_name = index_name
- self._meta = dict(meta)
-
- def upsert_data(self, delta_list: List[DeltaRecord]):
- raise NotImplementedError("QdrantIndex.upsert_data is managed at collection level")
-
- def delete_data(self, delta_list: List[DeltaRecord]):
- raise NotImplementedError("QdrantIndex.delete_data is managed at collection level")
-
- def search(
- self,
- query_vector: Optional[List[float]],
- limit: int = 10,
- filters: Optional[Dict[str, Any]] = None,
- sparse_raw_terms: Optional[List[str]] = None,
- sparse_values: Optional[List[float]] = None,
- ) -> Tuple[List[int], List[float]]:
- raise NotImplementedError("QdrantIndex.search is not exposed via raw index interface")
-
- def aggregate(self, filters: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
- raise NotImplementedError("QdrantIndex.aggregate is not exposed via raw index interface")
-
- def update(
- self, scalar_index: Optional[Dict[str, Any]] = None, description: Optional[str] = None
- ):
- self._collection.update_index(
- index_name=self._index_name,
- scalar_index=scalar_index,
- description=description,
- )
- self._meta = self._collection.get_index_meta_data(self._index_name) or self._meta
-
- def get_meta_data(self):
- return dict(self._meta)
-
- def close(self):
- return None
-
- def drop(self):
- self._collection.drop_index(self._index_name)
-
-
-class QdrantCollection(ICollection):
- """Qdrant-backed collection implementation."""
-
- DEFAULT_SCROLL_PAGE_SIZE = 256
- DEFAULT_DELETE_BATCH_SIZE = 1_000
- DEFAULT_HYBRID_PREFETCH_LIMIT = 32
- MAX_HYBRID_PREFETCH_LIMIT = 256
- MAX_SCROLL_ITERATIONS = 10_000
- CLIENT_SIDE_SCAN_WARNING_THRESHOLD = 10_000
- TEXT_INDEX_FIELDS = {"name", "description", "abstract", "tags"}
-
- def __init__(
- self,
- *,
- url: str,
- api_key: str | None,
- timeout_seconds: int,
- project_name: str,
- logical_collection_name: str,
- physical_collection_name: str,
- dense_vector_name: str,
- sparse_vector_name: str,
- meta_collection_name: str,
- distance_metric: str,
- enable_text_index: bool = False,
- ) -> None:
- super().__init__()
- self._client = QdrantRestClient(
- url=url,
- api_key=api_key,
- timeout_seconds=timeout_seconds,
- )
- self._project_name = project_name
- self._logical_collection_name = logical_collection_name
- self._physical_collection_name = physical_collection_name
- self._dense_vector_name = dense_vector_name
- self._sparse_vector_name = sparse_vector_name
- self._distance_metric = distance_metric
- self._enable_text_index = enable_text_index
- self._meta_store = QdrantMetaStore(
- client=self._client,
- meta_collection_name=meta_collection_name,
- )
- self._vector_dim = 0
- self._path_payload_fields: set[str] = {"parent_uri", "scope_roots"}
- self._refresh_vector_dim_from_meta()
-
- # ---------------------------------------------------------------------
- # Helpers
- # ---------------------------------------------------------------------
- @property
- def collection_key(self) -> str:
- return self._physical_collection_name
-
- def collection_exists(self) -> bool:
- return self._client.collection_exists(self._physical_collection_name)
-
- def _apply_meta_schema(self, meta: Dict[str, Any]) -> None:
- path_payload_fields = {"parent_uri", "scope_roots"}
- for field in meta.get("Fields", []):
- if field.get("FieldType") == "path":
- field_name = field.get("FieldName")
- if field_name:
- path_payload_fields.add(str(field_name))
- if field.get("FieldType") == "vector":
- try:
- self._vector_dim = int(field.get("Dim") or 0)
- except (TypeError, ValueError):
- self._vector_dim = 0
- self._path_payload_fields = path_payload_fields
-
- def _refresh_vector_dim_from_meta(self) -> None:
- meta = self._meta_store.get_collection_meta(collection_key=self.collection_key)
- if not meta:
- return
- self._apply_meta_schema(meta)
-
- @staticmethod
- def _decode_path_value(value: Any) -> Any:
- if isinstance(value, list):
- return [QdrantCollection._decode_path_value(item) for item in value]
- if not isinstance(value, str):
- return value
- stripped = value.strip()
- if stripped.startswith("viking://") or not stripped.startswith("/"):
- return value
- suffix = stripped.strip("/")
- return f"viking://{suffix}" if suffix else "viking://"
-
- def _normalize_payload_for_read(self, payload: Dict[str, Any]) -> Dict[str, Any]:
- if not payload:
- return {}
- normalized = dict(payload)
- for field_name in self._path_payload_fields:
- if field_name in normalized:
- normalized[field_name] = self._decode_path_value(normalized[field_name])
- return normalized
-
- def _build_vector_config(self, meta_data: Dict[str, Any]) -> Dict[str, Any]:
- dense_dim = 0
- has_sparse = False
- for field in meta_data.get("Fields", []):
- field_type = field.get("FieldType")
- if field_type == "vector":
- dense_dim = int(field.get("Dim") or 0)
- elif field_type == "sparse_vector":
- has_sparse = True
-
- if dense_dim <= 0:
- raise ValueError("Qdrant collection requires a positive dense vector dimension")
-
- self._vector_dim = dense_dim
- body: Dict[str, Any] = {
- "vectors": {
- self._dense_vector_name: {
- "size": dense_dim,
- "distance": _normalize_distance(self._distance_metric),
- }
- }
- }
- if has_sparse:
- body["sparse_vectors"] = {self._sparse_vector_name: {}}
- return body
-
- def create_remote_collection(self, meta_data: Dict[str, Any]) -> None:
- body = self._build_vector_config(meta_data)
- self._client.request(
- "PUT",
- f"/collections/{self._physical_collection_name}",
- json_body=body,
- expected_statuses=(200, 201),
- )
- try:
- self._meta_store.save_collection_meta(
- collection_key=self.collection_key,
- logical_collection_name=self._logical_collection_name,
- project_name=self._project_name,
- meta=meta_data,
- )
- except Exception:
- try:
- self._client.request(
- "DELETE",
- f"/collections/{self._physical_collection_name}",
- expected_statuses=(200, 202, 404),
- )
- except Exception as cleanup_error:
- logger.warning(
- "Failed to rollback Qdrant collection after metadata write failure: collection=%s error=%s",
- self._physical_collection_name,
- cleanup_error,
- )
- raise
- self._apply_meta_schema(meta_data)
-
- def _make_point(self, record: Dict[str, Any]) -> Dict[str, Any]:
- original_id = record.get("id")
- if original_id is None or original_id == "":
- raise ValueError("Qdrant point requires id")
-
- dense_vector = record.get(self._dense_vector_name)
- sparse_vector = record.get(self._sparse_vector_name)
- payload = {
- key: _coerce_iso_datetime(value)
- for key, value in record.items()
- if key not in {"id", self._dense_vector_name, self._sparse_vector_name}
- }
- payload[ORIGINAL_ID_FIELD] = _parse_point_id(original_id)
-
- vector_payload: Dict[str, Any] = {}
- if isinstance(dense_vector, list) and dense_vector:
- vector_payload[self._dense_vector_name] = dense_vector
-
- sparse_payload = _sparse_to_qdrant(sparse_vector)
- if sparse_payload:
- vector_payload[self._sparse_vector_name] = sparse_payload
-
- if not vector_payload:
- raise ValueError("Qdrant point requires at least one dense or sparse vector")
-
- return {
- "id": _to_qdrant_point_id(original_id),
- "vector": vector_payload,
- "payload": payload,
- }
-
- def _point_payload_for_read(self, point: Dict[str, Any]) -> Tuple[Any, Dict[str, Any]]:
- raw_payload = dict(point.get("payload", {}) or {})
- original_id = raw_payload.pop(ORIGINAL_ID_FIELD, None)
- if original_id is None:
- original_id = _parse_point_id(point.get("id"))
- return original_id, self._normalize_payload_for_read(raw_payload)
-
- def _parse_search_result(
- self,
- response: Dict[str, Any],
- *,
- offset: int,
- limit: int,
- ) -> SearchResult:
- items: List[SearchItemResult] = []
- for point in _extract_points(response):
- if not isinstance(point, dict):
- continue
- original_id, payload = self._point_payload_for_read(point)
- score = point.get("score") if isinstance(point, dict) else None
- items.append(
- SearchItemResult(
- id=original_id,
- fields=payload,
- score=score,
- )
- )
- if offset > 0:
- items = items[offset:]
- if len(items) > limit:
- items = items[:limit]
- return SearchResult(data=items)
-
- def _parse_points_as_search_result(
- self,
- points: Sequence[Dict[str, Any]],
- *,
- score: Optional[float] = 1.0,
- ) -> SearchResult:
- data: List[SearchItemResult] = []
- for point in points:
- original_id, payload = self._point_payload_for_read(point)
- data.append(
- SearchItemResult(
- id=original_id,
- fields=payload,
- score=score,
- )
- )
- return SearchResult(data=data)
-
- def _extract_named_vectors(
- self,
- point: Dict[str, Any],
- ) -> Tuple[Optional[List[float]], Optional[Dict[str, List[Any]]]]:
- vectors = point.get("vector")
- if not isinstance(vectors, dict):
- return None, None
-
- dense_vector = vectors.get(self._dense_vector_name)
- sparse_vector = vectors.get(self._sparse_vector_name)
- if not isinstance(dense_vector, list):
- dense_vector = None
- if not isinstance(sparse_vector, dict):
- sparse_vector = None
- return dense_vector, sparse_vector
-
- def _scroll_points(
- self,
- *,
- filters: Optional[Dict[str, Any]] = None,
- with_payload: bool | Dict[str, List[str]] = True,
- limit: Optional[int] = None,
- order_by: Optional[str] = None,
- order_desc: bool = False,
- ) -> List[Dict[str, Any]]:
- points: List[Dict[str, Any]] = []
- next_offset: Any = None
- seen_offsets: set[str] = set()
- iterations = 0
-
- while iterations < self.MAX_SCROLL_ITERATIONS:
- iterations += 1
- remaining = None if limit is None else max(limit - len(points), 0)
- if remaining == 0:
- break
-
- body: Dict[str, Any] = {
- "limit": min(
- self.DEFAULT_SCROLL_PAGE_SIZE,
- remaining if remaining is not None else self.DEFAULT_SCROLL_PAGE_SIZE,
- ),
- "with_payload": with_payload,
- "with_vector": False,
- }
- if filters:
- body["filter"] = filters
- if next_offset is not None:
- body["offset"] = next_offset
- if order_by:
- body["order_by"] = {
- "key": order_by,
- "direction": "desc" if order_desc else "asc",
- }
-
- response = self._client.request(
- "POST",
- f"/collections/{self._physical_collection_name}/points/scroll",
- json_body=body,
- )
- result = response.get("result", {})
- page_points = result.get("points", []) if isinstance(result, dict) else []
- if not page_points:
- break
-
- points.extend(page_points)
- next_offset = result.get("next_page_offset") if isinstance(result, dict) else None
- if next_offset is None:
- break
- offset_key = repr(next_offset)
- if offset_key in seen_offsets:
- logger.warning(
- "Stopping Qdrant scroll early because next_page_offset repeated for collection=%s offset=%s",
- self._physical_collection_name,
- next_offset,
- )
- break
- seen_offsets.add(offset_key)
- else:
- logger.warning(
- "Stopping Qdrant scroll after reaching MAX_SCROLL_ITERATIONS=%s for collection=%s",
- self.MAX_SCROLL_ITERATIONS,
- self._physical_collection_name,
- )
- return points
-
- def _scan_points_with_warning(
- self,
- *,
- purpose: str,
- filters: Optional[Dict[str, Any]],
- with_payload: bool | Dict[str, List[str]],
- limit: Optional[int] = None,
- order_by: Optional[str] = None,
- order_desc: bool = False,
- ) -> List[Dict[str, Any]]:
- if limit is None:
- logger.warning(
- "Qdrant %s uses client-side full scan/scroll. This may be expensive for large collections.",
- purpose,
- )
- elif limit >= self.CLIENT_SIDE_SCAN_WARNING_THRESHOLD:
- logger.warning(
- "Qdrant %s will scan up to %s points client-side. This may be expensive for large collections.",
- purpose,
- limit,
- )
- return self._scroll_points(
- filters=filters,
- with_payload=with_payload,
- limit=limit,
- order_by=order_by,
- order_desc=order_desc,
- )
-
- def _delete_field_index(self, field_name: str) -> None:
- try:
- self._client.request(
- "DELETE",
- f"/collections/{self._physical_collection_name}/index/{field_name}",
- params={"wait": "true"},
- expected_statuses=(200, 202),
- )
- except QdrantRestError as exc:
- logger.warning("Failed to delete Qdrant field index %s: %s", field_name, exc)
-
- def _field_type_map(self) -> Dict[str, str]:
- meta = self.get_meta_data() or {}
- fields = meta.get("Fields", [])
- mapping = {field.get("FieldName"): field.get("FieldType") for field in fields}
- mapping.setdefault("parent_uri", "string")
- mapping.setdefault("scope_roots", "string")
- mapping.setdefault("uri_depth", "int64")
- return {str(k): str(v) for k, v in mapping.items() if k}
-
- def _payload_field_schema(self, field_name: str, field_type: str) -> Optional[str]:
- normalized_type = (field_type or "").lower()
- if normalized_type in {"string", "path"}:
- if self._enable_text_index and field_name in self.TEXT_INDEX_FIELDS:
- return "text"
- return "keyword"
- if normalized_type in {"int64", "int32"}:
- return "integer"
- if normalized_type in {"float", "double"}:
- return "float"
- if normalized_type in {"bool", "boolean"}:
- return "bool"
- if normalized_type == "date_time":
- return "datetime"
- return None
-
- def _count_points(self, filters: Optional[Dict[str, Any]] = None) -> int:
- response = self._client.request(
- "POST",
- f"/collections/{self._physical_collection_name}/points/count",
- json_body={
- "filter": filters or {},
- "exact": True,
- },
- )
- result = response.get("result", {})
- try:
- return int(result.get("count", 0)) if isinstance(result, dict) else 0
- except (TypeError, ValueError):
- return 0
-
- def _delete_points(self, point_ids: Sequence[Any]) -> None:
- if not point_ids:
- return
- self._client.request(
- "POST",
- f"/collections/{self._physical_collection_name}/points/delete",
- json_body={"points": list(point_ids)},
- params={"wait": "true"},
- expected_statuses=(200, 202),
- )
-
- # ---------------------------------------------------------------------
- # ICollection
- # ---------------------------------------------------------------------
- def update(self, fields: Optional[Dict[str, Any]] = None, description: Optional[str] = None):
- meta = self._meta_store.update_collection_meta(
- collection_key=self.collection_key,
- logical_collection_name=self._logical_collection_name,
- project_name=self._project_name,
- fields=fields,
- description=description,
- )
- if isinstance(meta, dict):
- self._apply_meta_schema(meta)
- return meta
-
- def get_meta_data(self):
- return self._meta_store.get_collection_meta(collection_key=self.collection_key) or {}
-
- def has_openviking_metadata(self) -> bool:
- return bool(self._meta_store.get_collection_meta(collection_key=self.collection_key))
-
- def close(self):
- self._client.close()
-
- def drop(self):
- try:
- self._client.request(
- "DELETE",
- f"/collections/{self._physical_collection_name}",
- expected_statuses=(200, 202, 404),
- )
- finally:
- self._meta_store.delete_collection_meta(collection_key=self.collection_key)
-
- def create_index(self, index_name: str, meta_data: Dict[str, Any]):
- field_type_map = self._field_type_map()
- scalar_fields = list(meta_data.get("ScalarIndex", []) or [])
- for field_name in scalar_fields:
- field_schema = self._payload_field_schema(
- field_name, field_type_map.get(field_name, "")
- )
- if not field_schema:
- continue
- self._client.request(
- "PUT",
- f"/collections/{self._physical_collection_name}/index",
- json_body={
- "field_name": field_name,
- "field_schema": field_schema,
- },
- params={"wait": "true"},
- expected_statuses=(200, 202),
- )
- self._meta_store.save_index_meta(
- collection_key=self.collection_key,
- logical_collection_name=self._logical_collection_name,
- index_name=index_name,
- meta=meta_data,
- )
- return QdrantIndex(self, index_name, meta_data)
-
- def has_index(self, index_name: str) -> bool:
- return index_name in self.list_indexes()
-
- def get_index(self, index_name: str) -> Optional[IIndex]:
- meta = self.get_index_meta_data(index_name)
- if not meta:
- return None
- return QdrantIndex(self, index_name, meta)
-
- def search_by_vector(
- self,
- index_name: str,
- dense_vector: Optional[List[float]] = None,
- limit: int = 10,
- offset: int = 0,
- filters: Optional[Dict[str, Any]] = None,
- sparse_vector: Optional[Dict[str, float]] = None,
- output_fields: Optional[List[str]] = None,
- ) -> SearchResult:
- if dense_vector is None and sparse_vector is None:
- return SearchResult()
-
- fetch_limit = max(limit + offset, limit)
- body: Dict[str, Any] = {
- "limit": fetch_limit,
- "with_payload": _payload_selector(output_fields),
- }
- if filters:
- body["filter"] = filters
-
- try:
- if dense_vector is not None and sparse_vector:
- sparse_payload = _sparse_to_qdrant(sparse_vector)
- if not sparse_payload:
- sparse_vector = None
- else:
- hybrid_prefetch_limit = min(
- max(fetch_limit * 4, fetch_limit + 8, self.DEFAULT_HYBRID_PREFETCH_LIMIT),
- self.MAX_HYBRID_PREFETCH_LIMIT,
- )
- body.update(
- {
- "prefetch": [
- {
- "query": dense_vector,
- "using": self._dense_vector_name,
- "limit": hybrid_prefetch_limit,
- },
- {
- "query": sparse_payload,
- "using": self._sparse_vector_name,
- "limit": hybrid_prefetch_limit,
- },
- ],
- "query": {"fusion": "rrf"},
- }
- )
- response = self._client.request(
- "POST",
- f"/collections/{self._physical_collection_name}/points/query",
- json_body=body,
- expected_statuses=(200, 202),
- )
- return self._parse_search_result(response, offset=offset, limit=limit)
-
- if sparse_vector and dense_vector is None:
- sparse_payload = _sparse_to_qdrant(sparse_vector)
- if not sparse_payload:
- return SearchResult()
- body.update(
- {
- "query": sparse_payload,
- "using": self._sparse_vector_name,
- }
- )
- response = self._client.request(
- "POST",
- f"/collections/{self._physical_collection_name}/points/query",
- json_body=body,
- expected_statuses=(200, 202),
- )
- return self._parse_search_result(response, offset=offset, limit=limit)
-
- if dense_vector is None:
- return SearchResult()
-
- body.update(
- {
- "query": dense_vector,
- "using": self._dense_vector_name,
- }
- )
- response = self._client.request(
- "POST",
- f"/collections/{self._physical_collection_name}/points/query",
- json_body=body,
- expected_statuses=(200, 202),
- )
- return self._parse_search_result(response, offset=offset, limit=limit)
- except QdrantRestError as exc:
- if dense_vector is None:
- raise
- logger.warning(
- "Falling back to Qdrant /points/search for dense-only query because /points/query failed: %s",
- exc,
- )
- fallback_body: Dict[str, Any] = {
- "vector": {
- "name": self._dense_vector_name,
- "vector": dense_vector,
- },
- "limit": fetch_limit,
- "with_payload": _payload_selector(output_fields),
- }
- if filters:
- fallback_body["filter"] = filters
- response = self._client.request(
- "POST",
- f"/collections/{self._physical_collection_name}/points/search",
- json_body=fallback_body,
- expected_statuses=(200, 202),
- )
- return self._parse_search_result(response, offset=offset, limit=limit)
-
- def search_by_keywords(
- self,
- index_name: str,
- keywords: Optional[List[str]] = None,
- query: Optional[str] = None,
- limit: int = 10,
- offset: int = 0,
- filters: Optional[Dict[str, Any]] = None,
- output_fields: Optional[List[str]] = None,
- ) -> SearchResult:
- query_text = query or " ".join(keywords or [])
- if not query_text.strip():
- return SearchResult()
-
- text_filter = {
- "should": [
- {"must": [{"key": field_name, "match": {"text": query_text}}]}
- for field_name in sorted(self.TEXT_INDEX_FIELDS)
- ]
- }
- compound_filter = {"must": [filters, text_filter]} if filters else text_filter
- points = self._scroll_points(
- filters=compound_filter,
- with_payload=_payload_selector(output_fields),
- limit=limit + offset,
- )
- if offset > 0:
- points = points[offset:]
- if len(points) > limit:
- points = points[:limit]
- return SearchResult(data=self._parse_points_as_search_result(points, score=1.0).data)
-
- def search_by_id(
- self,
- index_name: str,
- id: Any,
- limit: int = 10,
- offset: int = 0,
- filters: Optional[Dict[str, Any]] = None,
- output_fields: Optional[List[str]] = None,
- ) -> SearchResult:
- point_id = _to_qdrant_point_id(id)
- response = self._client.request(
- "POST",
- f"/collections/{self._physical_collection_name}/points",
- json_body={
- "ids": [point_id],
- "with_payload": _payload_selector([ORIGINAL_ID_FIELD]),
- "with_vector": True,
- },
- )
- points = _extract_points(response)
- if not points:
- return SearchResult()
-
- dense_vector, sparse_payload = self._extract_named_vectors(points[0])
- if dense_vector is None and sparse_payload is None:
- return SearchResult()
-
- fetch_limit = max(limit + offset + 1, limit + 1)
- body: Dict[str, Any] = {
- "limit": fetch_limit,
- "with_payload": _payload_selector(output_fields),
- }
- if filters:
- body["filter"] = filters
-
- try:
- if dense_vector is not None and sparse_payload is not None:
- hybrid_prefetch_limit = min(
- max(fetch_limit * 4, fetch_limit + 8, self.DEFAULT_HYBRID_PREFETCH_LIMIT),
- self.MAX_HYBRID_PREFETCH_LIMIT,
- )
- body.update(
- {
- "prefetch": [
- {
- "query": dense_vector,
- "using": self._dense_vector_name,
- "limit": hybrid_prefetch_limit,
- },
- {
- "query": sparse_payload,
- "using": self._sparse_vector_name,
- "limit": hybrid_prefetch_limit,
- },
- ],
- "query": {"fusion": "rrf"},
- }
- )
- elif sparse_payload is not None:
- body.update({"query": sparse_payload, "using": self._sparse_vector_name})
- else:
- body.update({"query": dense_vector, "using": self._dense_vector_name})
-
- search_response = self._client.request(
- "POST",
- f"/collections/{self._physical_collection_name}/points/query",
- json_body=body,
- expected_statuses=(200, 202),
- )
- except QdrantRestError as exc:
- if dense_vector is None:
- raise
- logger.warning(
- "Falling back to Qdrant /points/search for search_by_id because /points/query failed: %s",
- exc,
- )
- fallback_body: Dict[str, Any] = {
- "vector": {
- "name": self._dense_vector_name,
- "vector": dense_vector,
- },
- "limit": fetch_limit,
- "with_payload": _payload_selector(output_fields),
- }
- if filters:
- fallback_body["filter"] = filters
- search_response = self._client.request(
- "POST",
- f"/collections/{self._physical_collection_name}/points/search",
- json_body=fallback_body,
- expected_statuses=(200, 202),
- )
-
- data = []
- for item in self._parse_search_result(search_response, offset=0, limit=fetch_limit).data:
- if item.id == id or str(item.id) == str(id):
- continue
- data.append(item)
- return SearchResult(data=data[offset : offset + limit])
-
- def search_by_multimodal(
- self,
- index_name: str,
- text: Optional[str],
- image: Optional[Any],
- video: Optional[Any],
- limit: int = 10,
- offset: int = 0,
- filters: Optional[Dict[str, Any]] = None,
- output_fields: Optional[List[str]] = None,
- ) -> SearchResult:
- raise NotImplementedError("QdrantCollection.search_by_multimodal is not supported")
-
- def search_by_random(
- self,
- index_name: str,
- limit: int = 10,
- offset: int = 0,
- filters: Optional[Dict[str, Any]] = None,
- output_fields: Optional[List[str]] = None,
- ) -> SearchResult:
- points = self._scroll_points(
- filters=filters,
- with_payload=_payload_selector(output_fields),
- limit=limit + offset,
- )
- if offset > 0:
- points = points[offset:]
- if len(points) > limit:
- points = points[:limit]
- return SearchResult(data=self._parse_points_as_search_result(points, score=1.0).data)
-
- def search_by_scalar(
- self,
- index_name: str,
- field: str,
- order: Optional[str] = "desc",
- limit: int = 10,
- offset: int = 0,
- filters: Optional[Dict[str, Any]] = None,
- output_fields: Optional[List[str]] = None,
- ) -> SearchResult:
- need_cleanup = False
- with_payload = list(output_fields or [])
- if field not in with_payload:
- with_payload.append(field)
- need_cleanup = True
-
- reverse = (order or "desc").lower() == "desc"
- try:
- points = self._scan_points_with_warning(
- purpose="scalar sort",
- filters=filters,
- with_payload=_payload_selector(with_payload),
- limit=limit + offset,
- order_by=field,
- order_desc=reverse,
- )
- except QdrantRestError as exc:
- logger.warning(
- "Falling back to client-side scalar sort because Qdrant order_by is unavailable for field=%s: %s",
- field,
- exc,
- )
- points = self._scan_points_with_warning(
- purpose="scalar sort fallback",
- filters=filters,
- with_payload=_payload_selector(with_payload),
- limit=None,
- )
- points.sort(
- key=lambda point: (
- point.get("payload", {}).get(field) is None,
- point.get("payload", {}).get(field),
- ),
- reverse=reverse,
- )
- points = points[offset : offset + limit]
- data: List[SearchItemResult] = []
- for point in points:
- original_id, payload = self._point_payload_for_read(point)
- score = payload.get(field)
- if need_cleanup:
- payload.pop(field, None)
- data.append(
- SearchItemResult(
- id=original_id,
- fields=payload,
- score=score if isinstance(score, (int, float)) else None,
- )
- )
- return SearchResult(data=data)
-
- def update_index(
- self,
- index_name: str,
- scalar_index: Optional[Dict[str, Any]] = None,
- description: Optional[str] = None,
- ):
- current_meta = self.get_index_meta_data(index_name) or {"IndexName": index_name}
- old_scalar_fields = set(current_meta.get("ScalarIndex", []) or [])
-
- if scalar_index is not None:
- if isinstance(scalar_index, dict):
- new_scalar_fields = list(scalar_index.keys())
- else:
- new_scalar_fields = list(scalar_index)
- current_meta["ScalarIndex"] = new_scalar_fields
- else:
- new_scalar_fields = list(current_meta.get("ScalarIndex", []) or [])
-
- if description is not None:
- current_meta["Description"] = description
-
- field_type_map = self._field_type_map()
- for field_name in new_scalar_fields:
- if field_name in old_scalar_fields:
- continue
- field_schema = self._payload_field_schema(
- field_name, field_type_map.get(field_name, "")
- )
- if not field_schema:
- continue
- self._client.request(
- "PUT",
- f"/collections/{self._physical_collection_name}/index",
- json_body={
- "field_name": field_name,
- "field_schema": field_schema,
- },
- params={"wait": "true"},
- expected_statuses=(200, 202),
- )
-
- for field_name in sorted(old_scalar_fields - set(new_scalar_fields)):
- self._delete_field_index(field_name)
-
- self._meta_store.save_index_meta(
- collection_key=self.collection_key,
- logical_collection_name=self._logical_collection_name,
- index_name=index_name,
- meta=current_meta,
- )
- return current_meta
-
- def get_index_meta_data(self, index_name: str):
- return self._meta_store.get_index_meta(
- collection_key=self.collection_key, index_name=index_name
- )
-
- def list_indexes(self):
- return self._meta_store.list_indexes(collection_key=self.collection_key)
-
- def drop_index(self, index_name: str):
- index_meta = self.get_index_meta_data(index_name) or {}
- for field_name in index_meta.get("ScalarIndex", []) or []:
- self._delete_field_index(field_name)
- self._meta_store.delete_index_meta(
- collection_key=self.collection_key, index_name=index_name
- )
-
- def upsert_data(self, data_list: List[Dict[str, Any]], ttl=0):
- # Qdrant does not provide a collection-level per-point TTL primitive that
- # matches the existing ICollection contract, so ttl is accepted only for
- # interface compatibility and intentionally ignored here.
- points = [self._make_point(data) for data in data_list]
- self._client.request(
- "PUT",
- f"/collections/{self._physical_collection_name}/points",
- json_body={"points": points},
- params={"wait": "true"},
- expected_statuses=(200, 202),
- )
- return [data.get("id") for data in data_list]
-
- def update_data(self, data_list: List[Dict[str, Any]]):
- updated_records: List[Dict[str, Any]] = []
- updated_ids: List[Any] = []
-
- for raw_data in data_list:
- if "id" not in raw_data or raw_data.get("id") in (None, ""):
- raise ValueError("Qdrant update requires id")
-
- original_id = raw_data.get("id")
- response = self._client.request(
- "POST",
- f"/collections/{self._physical_collection_name}/points",
- json_body={
- "ids": [_to_qdrant_point_id(original_id)],
- "with_payload": True,
- "with_vector": True,
- },
- )
- points = _extract_points(response)
- if not points:
- raise ValueError(f"Qdrant point does not exist for update: {original_id}")
-
- point = points[0]
- existing_id, existing_payload = self._point_payload_for_read(point)
- dense_vector, sparse_vector = self._extract_named_vectors(point)
-
- merged_record: Dict[str, Any] = {"id": existing_id, **existing_payload}
- if dense_vector is not None:
- merged_record[self._dense_vector_name] = dense_vector
- if sparse_vector is not None:
- merged_record[self._sparse_vector_name] = sparse_vector
-
- for field_name, field_value in raw_data.items():
- merged_record[field_name] = field_value
-
- updated_records.append(merged_record)
- updated_ids.append(existing_id)
-
- points = [self._make_point(data) for data in updated_records]
- self._client.request(
- "PUT",
- f"/collections/{self._physical_collection_name}/points",
- json_body={"points": points},
- params={"wait": "true"},
- expected_statuses=(200, 202),
- )
- return updated_ids
-
- def fetch_data(self, primary_keys: List[Any]):
- if not primary_keys:
- return FetchDataInCollectionResult()
- response = self._client.request(
- "POST",
- f"/collections/{self._physical_collection_name}/points",
- json_body={
- "ids": [_to_qdrant_point_id(pk) for pk in primary_keys],
- "with_payload": True,
- "with_vector": False,
- },
- )
- points = _extract_points(response)
- items: List[DataItem] = []
- found_ids: set[str] = set()
- for point in points:
- if not isinstance(point, dict):
- continue
- original_id, payload = self._point_payload_for_read(point)
- found_ids.add(str(original_id))
- items.append(DataItem(id=original_id, fields=payload))
- return FetchDataInCollectionResult(
- items=items,
- ids_not_exist=[pk for pk in primary_keys if str(pk) not in found_ids],
- )
-
- def delete_data(self, primary_keys: List[Any]):
- self._delete_points([_to_qdrant_point_id(pk) for pk in primary_keys])
-
- def delete_all_data(self):
- try:
- self._client.request(
- "POST",
- f"/collections/{self._physical_collection_name}/points/delete",
- json_body={"filter": {}},
- params={"wait": "true"},
- expected_statuses=(200, 202),
- )
- except QdrantRestError as exc:
- logger.warning(
- "Falling back to batched delete_all_data for collection=%s because filter delete failed: %s",
- self._physical_collection_name,
- exc,
- )
- points = self._scan_points_with_warning(
- purpose="delete_all_data fallback",
- filters=None,
- with_payload=False,
- limit=None,
- )
- batch_ids: List[str] = []
- for point in points:
- batch_ids.append(_parse_point_id(point.get("id")))
- if len(batch_ids) >= self.DEFAULT_DELETE_BATCH_SIZE:
- self._delete_points(batch_ids)
- batch_ids = []
- if batch_ids:
- self._delete_points(batch_ids)
-
- def aggregate_data(
- self,
- index_name: str,
- op: str = "count",
- field: Optional[str] = None,
- filters: Optional[Dict[str, Any]] = None,
- cond: Optional[Dict[str, Any]] = None,
- ) -> AggregateResult:
- if op != "count":
- return AggregateResult(agg={}, op=op, field=field)
-
- if not field:
- return AggregateResult(
- agg={"_total": self._count_points(filters)},
- op="count",
- field=None,
- )
-
- grouped: Dict[Any, int] = {}
- points = self._scan_points_with_warning(
- purpose=f"aggregate(count by {field})",
- filters=filters,
- with_payload=_payload_selector([field]),
- limit=None,
- )
- for point in points:
- payload = point.get("payload", {})
- value = payload.get(field)
- if value is None:
- continue
- if field in self._path_payload_fields:
- value = self._decode_path_value(value)
- grouped[value] = grouped.get(value, 0) + 1
-
- if cond:
- filtered_grouped: Dict[Any, int] = {}
- for key, value in grouped.items():
- include = True
- if cond.get("gt") is not None:
- include = include and value > cond["gt"]
- if cond.get("gte") is not None:
- include = include and value >= cond["gte"]
- if cond.get("lt") is not None:
- include = include and value < cond["lt"]
- if cond.get("lte") is not None:
- include = include and value <= cond["lte"]
- if include:
- filtered_grouped[key] = value
- grouped = filtered_grouped
-
- return AggregateResult(agg=grouped, op="count", field=field)
diff --git a/openviking/storage/vectordb/collection/qdrant_meta_store.py b/openviking/storage/vectordb/collection/qdrant_meta_store.py
deleted file mode 100644
index 4d344d6ef..000000000
--- a/openviking/storage/vectordb/collection/qdrant_meta_store.py
+++ /dev/null
@@ -1,291 +0,0 @@
-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
-# SPDX-License-Identifier: AGPL-3.0
-"""Sidecar metadata persistence for Qdrant-backed OpenViking collections."""
-
-from __future__ import annotations
-
-import datetime as dt
-import uuid
-from typing import Any, Dict, List, Optional
-
-from .qdrant_rest import QdrantRestClient, QdrantRestError
-
-
-def _utcnow_iso() -> str:
- return dt.datetime.now(dt.timezone.utc).isoformat()
-
-
-class QdrantMetaStore:
- """Store OpenViking collection/index metadata in a dedicated Qdrant collection."""
-
- COLLECTION_KIND = "collection"
- INDEX_KIND = "index"
-
- def __init__(
- self,
- *,
- client: QdrantRestClient,
- meta_collection_name: str,
- ) -> None:
- self._client = client
- self._meta_collection_name = meta_collection_name
- self._meta_collection_ensured = False
-
- @property
- def meta_collection_name(self) -> str:
- return self._meta_collection_name
-
- def _ensure_meta_collection(self) -> None:
- if self._meta_collection_ensured:
- return
- if self._client.collection_exists(self._meta_collection_name):
- self._meta_collection_ensured = True
- return
- self._client.request(
- "PUT",
- f"/collections/{self._meta_collection_name}",
- json_body={
- # Keep metadata in a tiny dedicated collection. Some Qdrant
- # deployments still require vector configuration, so we use a
- # 1D dummy vector payload for sidecar metadata documents.
- "vectors": {
- "size": 1,
- "distance": "Cosine",
- }
- },
- expected_statuses=(200, 201),
- )
- self._meta_collection_ensured = True
-
- @staticmethod
- def _collection_doc_id(collection_key: str) -> str:
- return str(uuid.uuid5(uuid.NAMESPACE_URL, f"openviking:qdrant:collection:{collection_key}"))
-
- @staticmethod
- def _index_doc_id(collection_key: str, index_name: str) -> str:
- return str(
- uuid.uuid5(
- uuid.NAMESPACE_URL,
- f"openviking:qdrant:index:{collection_key}:{index_name}",
- )
- )
-
- def _upsert_meta_doc(self, *, point_id: str, payload: Dict[str, Any]) -> None:
- self._ensure_meta_collection()
- self._client.request(
- "PUT",
- f"/collections/{self._meta_collection_name}/points",
- json_body={
- "points": [
- {
- "id": point_id,
- "vector": [0.0],
- "payload": payload,
- }
- ]
- },
- params={"wait": "true"},
- expected_statuses=(200, 202),
- )
-
- def _get_point(self, point_id: str) -> Optional[Dict[str, Any]]:
- if not self._meta_collection_ensured and not self._client.collection_exists(
- self._meta_collection_name
- ):
- return None
- self._meta_collection_ensured = True
- try:
- response = self._client.request(
- "POST",
- f"/collections/{self._meta_collection_name}/points",
- json_body={
- "ids": [point_id],
- "with_payload": True,
- "with_vector": False,
- },
- )
- except QdrantRestError as exc:
- if exc.status_code == 404:
- return None
- raise
-
- result = response.get("result", {})
- if isinstance(result, list):
- points = result
- elif isinstance(result, dict):
- points = result.get("points", [])
- else:
- points = []
- return points[0] if points else None
-
- def _scroll_index_docs(self, collection_key: str) -> List[Dict[str, Any]]:
- if not self._meta_collection_ensured and not self._client.collection_exists(
- self._meta_collection_name
- ):
- return []
- self._meta_collection_ensured = True
- points: List[Dict[str, Any]] = []
- next_offset: Optional[Any] = None
-
- while True:
- request_body: Dict[str, Any] = {
- "limit": 128,
- "with_payload": True,
- "with_vector": False,
- "filter": {
- "must": [
- {"key": "kind", "match": {"value": self.INDEX_KIND}},
- {"key": "collection_key", "match": {"value": collection_key}},
- ]
- },
- }
- if next_offset is not None:
- request_body["offset"] = next_offset
-
- response = self._client.request(
- "POST",
- f"/collections/{self._meta_collection_name}/points/scroll",
- json_body=request_body,
- )
- result = response.get("result", {})
- if not isinstance(result, dict):
- break
-
- batch = result.get("points", [])
- if isinstance(batch, list):
- points.extend(batch)
-
- next_offset = result.get("next_page_offset")
- if next_offset is None:
- break
-
- return points
-
- def save_collection_meta(
- self,
- *,
- collection_key: str,
- logical_collection_name: str,
- project_name: str,
- meta: Dict[str, Any],
- ) -> None:
- now = _utcnow_iso()
- payload = {
- "kind": self.COLLECTION_KIND,
- "collection_key": collection_key,
- "logical_collection_name": logical_collection_name,
- "project_name": project_name,
- "meta": meta,
- "updated_at": now,
- }
- self._upsert_meta_doc(
- point_id=self._collection_doc_id(collection_key),
- payload=payload,
- )
-
- def get_collection_meta(self, *, collection_key: str) -> Optional[Dict[str, Any]]:
- point = self._get_point(self._collection_doc_id(collection_key))
- if not point:
- return None
- payload = point.get("payload", {})
- meta = payload.get("meta")
- return meta if isinstance(meta, dict) else None
-
- def update_collection_meta(
- self,
- *,
- collection_key: str,
- logical_collection_name: str,
- project_name: str,
- fields: Optional[Dict[str, Any]] = None,
- description: Optional[str] = None,
- ) -> Dict[str, Any]:
- meta = self.get_collection_meta(collection_key=collection_key) or {
- "CollectionName": logical_collection_name
- }
- if fields is not None:
- meta["Fields"] = fields
- if description is not None:
- meta["Description"] = description
- self.save_collection_meta(
- collection_key=collection_key,
- logical_collection_name=logical_collection_name,
- project_name=project_name,
- meta=meta,
- )
- return meta
-
- def save_index_meta(
- self,
- *,
- collection_key: str,
- logical_collection_name: str,
- index_name: str,
- meta: Dict[str, Any],
- ) -> None:
- now = _utcnow_iso()
- payload = {
- "kind": self.INDEX_KIND,
- "collection_key": collection_key,
- "logical_collection_name": logical_collection_name,
- "index_name": index_name,
- "meta": meta,
- "updated_at": now,
- }
- self._upsert_meta_doc(
- point_id=self._index_doc_id(collection_key, index_name),
- payload=payload,
- )
-
- def get_index_meta(self, *, collection_key: str, index_name: str) -> Optional[Dict[str, Any]]:
- point = self._get_point(self._index_doc_id(collection_key, index_name))
- if not point:
- return None
- payload = point.get("payload", {})
- meta = payload.get("meta")
- return meta if isinstance(meta, dict) else None
-
- def list_indexes(self, *, collection_key: str) -> List[str]:
- docs = self._scroll_index_docs(collection_key)
- index_names: List[str] = []
- for doc in docs:
- payload = doc.get("payload", {})
- index_name = payload.get("index_name")
- if isinstance(index_name, str):
- index_names.append(index_name)
- return index_names
-
- def delete_index_meta(self, *, collection_key: str, index_name: str) -> None:
- if not self._meta_collection_ensured and not self._client.collection_exists(
- self._meta_collection_name
- ):
- return
- self._meta_collection_ensured = True
- self._client.request(
- "POST",
- f"/collections/{self._meta_collection_name}/points/delete",
- json_body={"points": [self._index_doc_id(collection_key, index_name)]},
- params={"wait": "true"},
- expected_statuses=(200, 202),
- )
-
- def delete_collection_meta(self, *, collection_key: str) -> None:
- if not self._meta_collection_ensured and not self._client.collection_exists(
- self._meta_collection_name
- ):
- return
- self._meta_collection_ensured = True
- point_ids = [self._collection_doc_id(collection_key)]
- point_ids.extend(
- self._index_doc_id(collection_key, index_name)
- for index_name in self.list_indexes(collection_key=collection_key)
- )
- if not point_ids:
- return
- self._client.request(
- "POST",
- f"/collections/{self._meta_collection_name}/points/delete",
- json_body={"points": point_ids},
- params={"wait": "true"},
- expected_statuses=(200, 202),
- )
diff --git a/openviking/storage/vectordb/collection/qdrant_rest.py b/openviking/storage/vectordb/collection/qdrant_rest.py
deleted file mode 100644
index 0dce339f9..000000000
--- a/openviking/storage/vectordb/collection/qdrant_rest.py
+++ /dev/null
@@ -1,239 +0,0 @@
-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
-# SPDX-License-Identifier: AGPL-3.0
-"""Lightweight Qdrant REST client helpers used by the adapter."""
-
-from __future__ import annotations
-
-import asyncio
-import json
-from typing import Any, Dict, Optional
-
-import httpx
-import requests
-
-
-class QdrantRestError(RuntimeError):
- """Raised when a Qdrant REST request fails."""
-
- def __init__(
- self,
- message: str,
- *,
- status_code: int | None = None,
- response_text: str | None = None,
- ) -> None:
- super().__init__(message)
- self.status_code = status_code
- self.response_text = response_text
-
-
-class QdrantRestClient:
- """Minimal REST client for Qdrant.
-
- The implementation intentionally uses REST instead of `qdrant-client` so the
- adapter can be developed and unit-tested without introducing a hard runtime
- dependency on the Python SDK.
-
- This client is intentionally synchronous because the current ICollection
- contract is synchronous across backends. Async OpenViking code paths must
- either:
-
- 1. use the async backend façade (`_AsyncVectorAdapter`) that wraps adapter
- calls with `asyncio.to_thread`, or
- 2. use `request_async()` / `collection_exists_async()` directly.
- """
-
- def __init__(
- self,
- *,
- url: str,
- api_key: str | None = None,
- timeout_seconds: int = 10,
- ) -> None:
- normalized = url.strip()
- if normalized and not normalized.startswith(("http://", "https://")):
- normalized = f"http://{normalized}"
- self._base_url = normalized.rstrip("/")
- self._timeout_seconds = timeout_seconds
- self._session = requests.Session()
- self._headers: Dict[str, str] = {"Content-Type": "application/json"}
- if api_key:
- self._headers["api-key"] = api_key
-
- @property
- def base_url(self) -> str:
- return self._base_url
-
- def close(self) -> None:
- self._session.close()
-
- def request(
- self,
- method: str,
- path: str,
- *,
- json_body: Optional[Dict[str, Any]] = None,
- params: Optional[Dict[str, Any]] = None,
- expected_statuses: tuple[int, ...] = (200,),
- ) -> Dict[str, Any]:
- response = self._session.request(
- method=method.upper(),
- url=f"{self._base_url}{path}",
- headers=self._headers,
- json=json_body,
- params=params,
- timeout=self._timeout_seconds,
- )
- if response.status_code not in expected_statuses:
- raise QdrantRestError(
- f"Qdrant request failed: {method.upper()} {path} -> {response.status_code}",
- status_code=response.status_code,
- response_text=response.text,
- )
-
- if not response.text:
- return {}
-
- try:
- data = response.json()
- except json.JSONDecodeError as exc:
- raise QdrantRestError(
- f"Qdrant returned non-JSON response for {method.upper()} {path}",
- status_code=response.status_code,
- response_text=response.text,
- ) from exc
-
- if isinstance(data, dict) and data.get("status") == "error":
- raise QdrantRestError(
- f"Qdrant reported error for {method.upper()} {path}: {data.get('result') or data}",
- status_code=response.status_code,
- response_text=response.text,
- )
- return data if isinstance(data, dict) else {"result": data}
-
- async def request_async(
- self,
- method: str,
- path: str,
- *,
- json_body: Optional[Dict[str, Any]] = None,
- params: Optional[Dict[str, Any]] = None,
- expected_statuses: tuple[int, ...] = (200,),
- ) -> Dict[str, Any]:
- return await asyncio.to_thread(
- self.request,
- method,
- path,
- json_body=json_body,
- params=params,
- expected_statuses=expected_statuses,
- )
-
- def collection_exists(self, collection_name: str) -> bool:
- response = self._session.get(
- f"{self._base_url}/collections/{collection_name}",
- headers=self._headers,
- timeout=self._timeout_seconds,
- )
- if response.status_code == 404:
- return False
- if response.status_code != 200:
- raise QdrantRestError(
- f"Failed to check Qdrant collection existence: {collection_name}",
- status_code=response.status_code,
- response_text=response.text,
- )
- return True
-
- async def collection_exists_async(self, collection_name: str) -> bool:
- return await asyncio.to_thread(self.collection_exists, collection_name)
-
-
-class AsyncQdrantRestClient:
- """Async REST client for Qdrant based on httpx.AsyncClient.
-
- This is provided for async-only call sites that should not rely on
- `asyncio.to_thread`. The current Qdrant ICollection implementation remains
- synchronous because it follows the shared ICollection interface.
- """
-
- def __init__(
- self,
- *,
- url: str,
- api_key: str | None = None,
- timeout_seconds: int = 10,
- ) -> None:
- normalized = url.strip()
- if normalized and not normalized.startswith(("http://", "https://")):
- normalized = f"http://{normalized}"
- self._base_url = normalized.rstrip("/")
- headers: Dict[str, str] = {"Content-Type": "application/json"}
- if api_key:
- headers["api-key"] = api_key
- self._client = httpx.AsyncClient(
- base_url=self._base_url,
- headers=headers,
- timeout=timeout_seconds,
- )
-
- @property
- def base_url(self) -> str:
- return self._base_url
-
- async def close(self) -> None:
- await self._client.aclose()
-
- async def request(
- self,
- method: str,
- path: str,
- *,
- json_body: Optional[Dict[str, Any]] = None,
- params: Optional[Dict[str, Any]] = None,
- expected_statuses: tuple[int, ...] = (200,),
- ) -> Dict[str, Any]:
- response = await self._client.request(
- method=method.upper(),
- url=path,
- json=json_body,
- params=params,
- )
- if response.status_code not in expected_statuses:
- raise QdrantRestError(
- f"Qdrant request failed: {method.upper()} {path} -> {response.status_code}",
- status_code=response.status_code,
- response_text=response.text,
- )
-
- if not response.text:
- return {}
-
- try:
- data = response.json()
- except json.JSONDecodeError as exc:
- raise QdrantRestError(
- f"Qdrant returned non-JSON response for {method.upper()} {path}",
- status_code=response.status_code,
- response_text=response.text,
- ) from exc
-
- if isinstance(data, dict) and data.get("status") == "error":
- raise QdrantRestError(
- f"Qdrant reported error for {method.upper()} {path}: {data.get('result') or data}",
- status_code=response.status_code,
- response_text=response.text,
- )
- return data if isinstance(data, dict) else {"result": data}
-
- async def collection_exists(self, collection_name: str) -> bool:
- response = await self._client.get(f"/collections/{collection_name}")
- if response.status_code == 404:
- return False
- if response.status_code != 200:
- raise QdrantRestError(
- f"Failed to check Qdrant collection existence: {collection_name}",
- status_code=response.status_code,
- response_text=response.text,
- )
- return True
diff --git a/openviking/storage/vectordb_adapters/__init__.py b/openviking/storage/vectordb_adapters/__init__.py
index bb33a3a36..1d19e1bac 100644
--- a/openviking/storage/vectordb_adapters/__init__.py
+++ b/openviking/storage/vectordb_adapters/__init__.py
@@ -6,8 +6,6 @@ from .base import CollectionAdapter
from .factory import create_collection_adapter
from .http_adapter import HttpCollectionAdapter
from .local_adapter import CuVSCollectionAdapter, LocalCollectionAdapter
-from .opengauss_adapter import OpenGaussCollectionAdapter
-from .qdrant_adapter import QdrantCollectionAdapter
from .vikingdb_private_adapter import VikingDBPrivateCollectionAdapter
from .volcengine_adapter import VolcengineCollectionAdapter
@@ -16,8 +14,6 @@ __all__ = [
"LocalCollectionAdapter",
"CuVSCollectionAdapter",
"HttpCollectionAdapter",
- "OpenGaussCollectionAdapter",
- "QdrantCollectionAdapter",
"VolcengineCollectionAdapter",
"VikingDBPrivateCollectionAdapter",
"create_collection_adapter",
diff --git a/openviking/storage/vectordb_adapters/factory.py b/openviking/storage/vectordb_adapters/factory.py
index 24e570e6c..b01dc6dec 100644
--- a/openviking/storage/vectordb_adapters/factory.py
+++ b/openviking/storage/vectordb_adapters/factory.py
@@ -9,8 +9,6 @@ import importlib
from .base import CollectionAdapter
from .http_adapter import HttpCollectionAdapter
from .local_adapter import CuVSCollectionAdapter, LocalCollectionAdapter
-from .opengauss_adapter import OpenGaussCollectionAdapter
-from .qdrant_adapter import QdrantCollectionAdapter
from .vikingdb_private_adapter import VikingDBPrivateCollectionAdapter
from .volcengine_adapter import VolcengineCollectionAdapter
@@ -18,8 +16,6 @@ _ADAPTER_REGISTRY: dict[str, type[CollectionAdapter]] = {
"local": LocalCollectionAdapter,
"cuvs": CuVSCollectionAdapter,
"http": HttpCollectionAdapter,
- "opengauss": OpenGaussCollectionAdapter,
- "qdrant": QdrantCollectionAdapter,
"volcengine": VolcengineCollectionAdapter,
"vikingdb": VikingDBPrivateCollectionAdapter,
}
diff --git a/openviking/storage/vectordb_adapters/opengauss_adapter.py b/openviking/storage/vectordb_adapters/opengauss_adapter.py
deleted file mode 100644
index 21b4913a8..000000000
--- a/openviking/storage/vectordb_adapters/opengauss_adapter.py
+++ /dev/null
@@ -1,1596 +0,0 @@
-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
-# SPDX-License-Identifier: AGPL-3.0
-"""openGauss-backed vector collection adapter.
-
-The official openGauss container ships a native ``vector`` type and HNSW/IVFFlat
-index support. The adapter stores one SQL table per OpenViking collection and
-keeps collection/index metadata in small sidecar tables.
-"""
-
-from __future__ import annotations
-
-import datetime as dt
-import json
-import math
-import re
-import threading
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple
-
-from openviking.storage.expr import (
- And,
- Contains,
- Eq,
- FilterExpr,
- In,
- Or,
- PathScope,
- Range,
- RawDSL,
- TimeRange,
-)
-from openviking.storage.vectordb.collection.collection import Collection, ICollection
-from openviking.storage.vectordb.collection.result import (
- AggregateResult,
- DataItem,
- FetchDataInCollectionResult,
- SearchItemResult,
- SearchResult,
-)
-from openviking.storage.vectordb.index.index import IIndex
-from openviking.storage.vectordb.store.data import DeltaRecord
-from openviking.storage.vectordb_adapters.base import CollectionAdapter
-from openviking_cli.utils import get_logger
-
-logger = get_logger(__name__)
-
-_COLLECTION_META_TABLE = "__openviking_opengauss_collections"
-_INDEX_META_TABLE = "__openviking_opengauss_indexes"
-_DEFAULT_SCHEMA = "public"
-_IDENT_RE = re.compile(r"[^a-zA-Z0-9_]+")
-_MAX_IDENTIFIER_BYTES = 63
-
-_FIELD_TYPE_SQL: Dict[str, str] = {
- "string": "TEXT",
- "path": "TEXT",
- "int64": "BIGINT",
- "int32": "INTEGER",
- "float": "DOUBLE PRECISION",
- "double": "DOUBLE PRECISION",
- "bool": "BOOLEAN",
- "boolean": "BOOLEAN",
- "date_time": "TIMESTAMP WITH TIME ZONE",
-}
-
-_VECTOR_OPS: Dict[str, Dict[str, str]] = {
- "cosine": {"operator": "<=>", "hnsw": "vector_cosine_ops"},
- "ip": {"operator": "<#>", "hnsw": "vector_ip_ops"},
- "l2": {"operator": "<->", "hnsw": "vector_l2_ops"},
-}
-
-
-def _import_psycopg2():
- try:
- import psycopg2 # type: ignore # noqa: PLC0415
-
- return psycopg2
- except ImportError as exc: # pragma: no cover - exercised only without optional driver
- raise ImportError(
- "The openGauss backend requires a psycopg2-compatible driver. "
- 'Install it with `pip install "openviking[opengauss]"`, or install another '
- "psycopg2-compatible driver that can connect to openGauss."
- ) from exc
-
-
-def _quote_ident(name: str) -> str:
- return '"' + str(name).replace('"', '""') + '"'
-
-
-def _qualify(schema: str, name: str) -> str:
- return f"{_quote_ident(schema)}.{_quote_ident(name)}"
-
-
-def _safe_identifier(*parts: Any, prefix: str = "ov") -> str:
- raw = "_".join(str(part or "") for part in parts)
- normalized = _IDENT_RE.sub("_", raw).strip("_").lower() or "default"
- name = f"{prefix}_{normalized}"
- encoded = name.encode("utf-8")
- if len(encoded) <= _MAX_IDENTIFIER_BYTES:
- return name
- import hashlib
-
- digest = hashlib.sha1(encoded).hexdigest()[:10]
- keep = max(8, _MAX_IDENTIFIER_BYTES - len(prefix) - len(digest) - 3)
- return f"{prefix}_{normalized[:keep]}_{digest}"
-
-
-def _json_default(value: Any) -> Any:
- if isinstance(value, (dt.datetime, dt.date)):
- return value.isoformat()
- return str(value)
-
-
-def _json_dumps(value: Any) -> str:
- return json.dumps(value, ensure_ascii=False, sort_keys=True, default=_json_default)
-
-
-def _encode_scope_roots(value: Any) -> str:
- roots = value if isinstance(value, list) else [value]
- normalized = [str(root) for root in roots if root is not None]
- return "\n" + "\n".join(normalized) + "\n" if normalized else "\n"
-
-
-def _vector_literal(vector: Sequence[float]) -> str:
- values = []
- for item in vector:
- number = float(item)
- if not math.isfinite(number):
- number = 0.0
- values.append(format(number, ".12g"))
- return "[" + ",".join(values) + "]"
-
-
-def _normalize_distance(distance: str) -> str:
- value = (distance or "cosine").strip().lower()
- if value not in _VECTOR_OPS:
- raise ValueError(
- "openGauss vector backend supports only cosine, l2, and ip distance metrics; "
- f"got {distance!r}"
- )
- return value
-
-
-def _coerce_sql_value(value: Any, field_type: str | None) -> Any:
- if value is None:
- return None
- normalized_type = (field_type or "").lower()
- if normalized_type == "date_time":
- if isinstance(value, dt.datetime):
- return value
- if isinstance(value, dt.date):
- return dt.datetime.combine(value, dt.time.min, tzinfo=dt.timezone.utc)
- return str(value)
- if normalized_type in {"int64", "int32"}:
- try:
- return int(value)
- except (TypeError, ValueError):
- return None
- if normalized_type in {"float", "double"}:
- try:
- number = float(value)
- except (TypeError, ValueError):
- return None
- return number if math.isfinite(number) else None
- if normalized_type in {"bool", "boolean"}:
- if isinstance(value, bool):
- return value
- if isinstance(value, str):
- lowered = value.strip().lower()
- if lowered in {"true", "t", "yes", "y", "1", "on"}:
- return True
- if lowered in {"false", "f", "no", "n", "0", "off"}:
- return False
- return None
- return bool(value)
- if isinstance(value, (dict, list, tuple)):
- return _json_dumps(value)
- return value
-
-
-def _sparse_dot(left: Optional[Dict[str, float]], right: Optional[Dict[str, float]]) -> float:
- if not left or not right:
- return 0.0
- total = 0.0
- for key, raw_value in left.items():
- try:
- total += float(raw_value) * float(right.get(key, 0.0))
- except (TypeError, ValueError):
- continue
- return total
-
-
-class OpenGaussIndex(IIndex):
- """Metadata-only logical index facade for openGauss."""
-
- def __init__(
- self, collection: "OpenGaussCollection", index_name: str, meta: Dict[str, Any]
- ) -> None:
- super().__init__(meta=meta)
- self._collection = collection
- self._index_name = index_name
- self._meta = dict(meta)
-
- def upsert_data(self, delta_list: List[DeltaRecord]):
- raise NotImplementedError("OpenGaussIndex.upsert_data is managed at collection level")
-
- def delete_data(self, delta_list: List[DeltaRecord]):
- raise NotImplementedError("OpenGaussIndex.delete_data is managed at collection level")
-
- def search(
- self,
- query_vector: Optional[List[float]],
- limit: int = 10,
- filters: Optional[Dict[str, Any]] = None,
- sparse_raw_terms: Optional[List[str]] = None,
- sparse_values: Optional[List[float]] = None,
- ) -> Tuple[List[int], List[float]]:
- raise NotImplementedError("OpenGaussIndex.search is not exposed via raw index interface")
-
- def aggregate(self, filters: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
- raise NotImplementedError("OpenGaussIndex.aggregate is not exposed via raw index interface")
-
- def update(
- self, scalar_index: Optional[Dict[str, Any]] = None, description: Optional[str] = None
- ):
- self._collection.update_index(
- index_name=self._index_name,
- scalar_index=scalar_index,
- description=description,
- )
- self._meta = self._collection.get_index_meta_data(self._index_name) or self._meta
-
- def get_meta_data(self):
- return dict(self._meta)
-
- def close(self):
- return None
-
- def drop(self):
- self._collection.drop_index(self._index_name)
-
-
-class OpenGaussCollection(ICollection):
- """A single OpenViking collection stored in openGauss."""
-
- DEFAULT_FETCH_LIMIT = 256
- DEFAULT_SPARSE_SCAN_LIMIT = 10_000
- INTERNAL_PATH_FIELDS = {
- "parent_uri": "TEXT",
- "scope_roots": "TEXT",
- "uri_depth": "BIGINT",
- }
-
- def __init__(
- self,
- *,
- conn: Any,
- schema_name: str,
- table_name: str,
- logical_collection_name: str,
- project_name: str,
- dense_vector_name: str,
- sparse_vector_name: str,
- distance_metric: str,
- meta: Optional[Dict[str, Any]] = None,
- vector_dim: int = 0,
- lock: Optional[threading.RLock] = None,
- reconnect: Optional[Any] = None,
- ) -> None:
- super().__init__()
- self._conn = conn
- self._lock = lock or threading.RLock()
- self._reconnect = reconnect
- self._schema_name = (schema_name or _DEFAULT_SCHEMA).strip() or _DEFAULT_SCHEMA
- self._table_name = table_name
- self._logical_collection_name = logical_collection_name
- self._project_name = project_name
- self._dense_vector_name = dense_vector_name
- self._sparse_vector_name = sparse_vector_name
- self._distance_metric = _normalize_distance(distance_metric)
- self._meta = dict(meta or {})
- self._vector_dim = int(vector_dim or self._extract_vector_dim(self._meta) or 0)
- self._field_types = self._build_field_type_map(self._meta)
-
- @property
- def collection_key(self) -> str:
- return self._table_name
-
- @staticmethod
- def _extract_vector_dim(meta: Dict[str, Any]) -> int:
- for field in meta.get("Fields", []) or []:
- if field.get("FieldType") == "vector":
- try:
- return int(field.get("Dim") or 0)
- except (TypeError, ValueError):
- return 0
- return 0
-
- @staticmethod
- def _build_field_type_map(meta: Dict[str, Any]) -> Dict[str, str]:
- mapping: Dict[str, str] = {}
- for field in meta.get("Fields", []) or []:
- name = field.get("FieldName")
- field_type = field.get("FieldType")
- if name and field_type:
- mapping[str(name)] = str(field_type)
- mapping.setdefault("id", "string")
- mapping.setdefault("parent_uri", "path")
- mapping.setdefault("scope_roots", "string")
- mapping.setdefault("uri_depth", "int64")
- return mapping
-
- def _ensure_connection(self) -> Any:
- if getattr(self._conn, "closed", 0):
- if self._reconnect is None:
- raise RuntimeError("openGauss connection is closed")
- self._conn = self._reconnect()
- return self._conn
-
- def _safe_rollback(self) -> None:
- try:
- if not getattr(self._conn, "closed", 1):
- self._conn.rollback()
- except Exception:
- logger.debug("Failed to rollback openGauss connection", exc_info=True)
-
- def _execute(
- self,
- sql: str,
- params: Optional[Sequence[Any]] = None,
- *,
- fetch: bool = False,
- ) -> List[Tuple[Any, ...]]:
- with self._lock:
- conn = self._ensure_connection()
- cur = conn.cursor()
- try:
- cur.execute(sql, list(params or []))
- rows = cur.fetchall() if fetch else []
- conn.commit()
- return rows
- except Exception:
- self._safe_rollback()
- raise
- finally:
- cur.close()
-
- def _table_exists(self) -> bool:
- rows = self._execute(
- """
- SELECT 1
- FROM information_schema.tables
- WHERE table_schema = %s AND table_name = %s
- LIMIT 1
- """,
- [self._schema_name, self._table_name],
- fetch=True,
- )
- return bool(rows)
-
- def create_remote_collection(self, meta_data: Dict[str, Any]) -> None:
- self._meta = dict(meta_data)
- self._vector_dim = self._extract_vector_dim(self._meta)
- self._field_types = self._build_field_type_map(self._meta)
- if self._vector_dim <= 0:
- raise ValueError("openGauss collection requires a positive dense vector dimension")
-
- columns = ["id TEXT PRIMARY KEY"]
- seen = {"id"}
- for field in meta_data.get("Fields", []) or []:
- ddl = self._field_to_column_ddl(field)
- field_name = field.get("FieldName")
- if ddl and field_name not in seen:
- columns.append(ddl)
- seen.add(str(field_name))
- for field_name, sql_type in self.INTERNAL_PATH_FIELDS.items():
- if field_name not in seen:
- columns.append(f"{_quote_ident(field_name)} {sql_type}")
- seen.add(field_name)
-
- self._execute(f"CREATE TABLE IF NOT EXISTS {self._table_ref()} ({', '.join(columns)})")
- self._save_collection_meta(meta_data)
-
- def _field_to_column_ddl(self, field: Dict[str, Any]) -> Optional[str]:
- name = field.get("FieldName")
- field_type = str(field.get("FieldType") or "").lower()
- if not name or name == "id":
- return None
- if field_type == "vector":
- dim = int(field.get("Dim") or self._vector_dim or 0)
- if dim <= 0:
- raise ValueError("openGauss vector field requires Dim")
- return f"{_quote_ident(name)} vector({dim})"
- if field_type == "sparse_vector":
- return f"{_quote_ident(name)} TEXT"
- return f"{_quote_ident(name)} {_FIELD_TYPE_SQL.get(field_type, 'TEXT')}"
-
- def _save_collection_meta(self, meta: Dict[str, Any]) -> None:
- self._execute(
- f"""
- MERGE INTO {self._meta_table_ref(_COLLECTION_META_TABLE)} target
- USING (
- SELECT
- %s AS table_name,
- %s AS logical_collection_name,
- %s AS project_name,
- %s AS meta_json
- ) source
- ON (target.table_name = source.table_name)
- WHEN MATCHED THEN UPDATE SET
- logical_collection_name = source.logical_collection_name,
- project_name = source.project_name,
- meta_json = source.meta_json,
- updated_at = CURRENT_TIMESTAMP
- WHEN NOT MATCHED THEN INSERT
- (table_name, logical_collection_name, project_name, meta_json, updated_at)
- VALUES (
- source.table_name,
- source.logical_collection_name,
- source.project_name,
- source.meta_json,
- CURRENT_TIMESTAMP
- )
- """,
- [
- self.collection_key,
- self._logical_collection_name,
- self._project_name,
- _json_dumps(meta),
- ],
- )
-
- def _save_index_meta(self, index_name: str, meta: Dict[str, Any]) -> None:
- self._execute(
- f"""
- MERGE INTO {self._meta_table_ref(_INDEX_META_TABLE)} target
- USING (
- SELECT
- %s AS table_name,
- %s AS index_name,
- %s AS meta_json
- ) source
- ON (
- target.table_name = source.table_name
- AND target.index_name = source.index_name
- )
- WHEN MATCHED THEN UPDATE SET
- meta_json = source.meta_json,
- updated_at = CURRENT_TIMESTAMP
- WHEN NOT MATCHED THEN INSERT
- (table_name, index_name, meta_json, updated_at)
- VALUES (
- source.table_name,
- source.index_name,
- source.meta_json,
- CURRENT_TIMESTAMP
- )
- """,
- [self.collection_key, index_name, _json_dumps(meta)],
- )
-
- def _delete_index_meta(self, index_name: str) -> None:
- self._execute(
- f"DELETE FROM {self._meta_table_ref(_INDEX_META_TABLE)} "
- "WHERE table_name = %s AND index_name = %s",
- [self.collection_key, index_name],
- )
-
- def _all_columns(self) -> List[str]:
- rows = self._execute(
- """
- SELECT column_name
- FROM information_schema.columns
- WHERE table_schema = %s AND table_name = %s
- ORDER BY ordinal_position
- """,
- [self._schema_name, self._table_name],
- fetch=True,
- )
- return [str(row[0]) for row in rows]
-
- def _table_ref(self) -> str:
- return _qualify(self._schema_name, self._table_name)
-
- def _meta_table_ref(self, table_name: str) -> str:
- return _qualify(self._schema_name, table_name)
-
- def _index_ref(self, index_name: str) -> str:
- return _qualify(self._schema_name, index_name)
-
- def _function_table_name(self, table_name: str) -> str:
- return f"{_quote_ident(self._schema_name)}.{_quote_ident(table_name)}"
-
- def _ensure_columns_for_record(self, record: Dict[str, Any]) -> None:
- existing = set(self._all_columns())
- for field_name in record:
- if field_name in existing:
- continue
- if field_name == "id":
- continue
- if field_name == self._dense_vector_name:
- sql_type = f"vector({self._vector_dim})"
- elif field_name == self._sparse_vector_name:
- sql_type = "TEXT"
- elif field_name in self.INTERNAL_PATH_FIELDS:
- sql_type = self.INTERNAL_PATH_FIELDS[field_name]
- else:
- field_type = self._field_types.get(field_name)
- sql_type = _FIELD_TYPE_SQL.get(str(field_type or "").lower(), "TEXT")
- self._field_types.setdefault(field_name, field_type or "string")
- self._execute(
- f"ALTER TABLE {self._table_ref()} ADD COLUMN {_quote_ident(field_name)} {sql_type}"
- )
- existing.add(field_name)
-
- def _select_columns(
- self,
- output_fields: Optional[List[str]],
- *,
- include_vector: bool = False,
- include_sparse: bool = False,
- ) -> List[str]:
- columns = self._all_columns()
- wanted = ["id"]
- if output_fields:
- for field in output_fields:
- if field != "id" and field in columns and field not in wanted:
- wanted.append(field)
- else:
- for field in columns:
- if field == "id":
- continue
- if field == self._dense_vector_name and not include_vector:
- continue
- if field == self._sparse_vector_name and not include_sparse:
- continue
- wanted.append(field)
- if (
- include_vector
- and self._dense_vector_name in columns
- and self._dense_vector_name not in wanted
- ):
- wanted.append(self._dense_vector_name)
- if (
- include_sparse
- and self._sparse_vector_name in columns
- and self._sparse_vector_name not in wanted
- ):
- wanted.append(self._sparse_vector_name)
- return wanted
-
- def _row_to_payload(
- self, row: Sequence[Any], columns: Sequence[str]
- ) -> Tuple[Any, Dict[str, Any]]:
- record = dict(zip(columns, row, strict=False))
- record_id = record.pop("id", "")
- record.pop(self._dense_vector_name, None)
- sparse = record.pop(self._sparse_vector_name, None)
- if sparse is not None and self._sparse_vector_name in columns:
- try:
- record[self._sparse_vector_name] = json.loads(sparse)
- except (TypeError, ValueError):
- record[self._sparse_vector_name] = sparse
- return record_id, record
-
- def _where_sql(self, filters: Optional[Dict[str, Any]]) -> Tuple[str, List[Any]]:
- clause, params = self._compile_filter(filters or {})
- return (f" WHERE {clause}", params) if clause else ("", [])
-
- def _compile_filter(self, payload: Any) -> Tuple[str, List[Any]]:
- if not payload:
- return "", []
- if not isinstance(payload, dict):
- return "", []
- op = str(payload.get("op") or "").lower()
- if not op:
- clauses = []
- params: List[Any] = []
- for key, value in payload.items():
- clauses.append(f"{_quote_ident(str(key))} = %s")
- params.append(value)
- return " AND ".join(clauses), params
- if op == "and":
- return self._join_filter_clauses("AND", payload.get("conds", []) or [])
- if op == "or":
- return self._join_filter_clauses("OR", payload.get("conds", []) or [])
- if op == "must":
- field = str(payload.get("field") or "")
- values = list(payload.get("conds", []) or [])
- if not field or not values:
- return "", []
- return self._match_sql(field, values, negate=False)
- if op == "must_not":
- field = str(payload.get("field") or "")
- values = list(payload.get("conds", []) or [])
- if not field or not values:
- return "", []
- return self._match_sql(field, values, negate=True)
- if op in {"range", "time_range"}:
- field = str(payload.get("field") or "")
- clauses = []
- params = []
- for sql_op, key in ((">=", "gte"), (">", "gt"), ("<=", "lte"), ("<", "lt")):
- if payload.get(key) is not None:
- clauses.append(f"{_quote_ident(field)} {sql_op} %s")
- params.append(_coerce_sql_value(payload[key], self._field_types.get(field)))
- return " AND ".join(clauses), params
- if op == "range_out":
- field = str(payload.get("field") or "")
- clauses = []
- params = []
- if payload.get("gte") is not None:
- clauses.append(f"{_quote_ident(field)} < %s")
- params.append(payload["gte"])
- if payload.get("lte") is not None:
- clauses.append(f"{_quote_ident(field)} > %s")
- params.append(payload["lte"])
- return " OR ".join(clauses), params
- if op == "contains":
- field = str(payload.get("field") or "")
- return f"{_quote_ident(field)} LIKE %s", [f"%{payload.get('substring', '')}%"]
- if op == "prefix":
- field = str(payload.get("field") or "")
- return f"{_quote_ident(field)} LIKE %s", [f"{payload.get('prefix', '')}%"]
- logger.warning("openGauss vector backend ignoring unsupported filter op=%r", op)
- return "", []
-
- def _join_filter_clauses(self, operator: str, conds: Iterable[Any]) -> Tuple[str, List[Any]]:
- clauses = []
- params: List[Any] = []
- for cond in conds:
- clause, cond_params = self._compile_filter(cond)
- if clause:
- clauses.append(f"({clause})")
- params.extend(cond_params)
- return f" {operator} ".join(clauses), params
-
- def _match_sql(self, field: str, values: List[Any], *, negate: bool) -> Tuple[str, List[Any]]:
- if field == "scope_roots":
- clauses = []
- params = []
- for value in values:
- clauses.append(f"{_quote_ident(field)} LIKE %s")
- params.append(f"%\n{str(value)}\n%")
- joined = " OR ".join(clauses)
- elif len(values) == 1:
- joined = f"{_quote_ident(field)} = %s"
- params = [values[0]]
- else:
- joined = f"{_quote_ident(field)} IN ({', '.join(['%s'] * len(values))})"
- params = values
- return (f"NOT ({joined})" if negate else joined), params
-
- # ------------------------------------------------------------------
- # ICollection lifecycle
- # ------------------------------------------------------------------
- def update(self, fields: Optional[Dict[str, Any]] = None, description: Optional[str] = None):
- meta = dict(self.get_meta_data() or {})
- if fields is not None:
- meta["Fields"] = fields
- if description is not None:
- meta["Description"] = description
- self._meta = meta
- self._field_types = self._build_field_type_map(meta)
- self._save_collection_meta(meta)
- return meta
-
- def get_meta_data(self):
- rows = self._execute(
- f"SELECT meta_json FROM {self._meta_table_ref(_COLLECTION_META_TABLE)} WHERE table_name = %s",
- [self.collection_key],
- fetch=True,
- )
- if not rows:
- return {}
- try:
- return json.loads(rows[0][0])
- except (TypeError, ValueError):
- return {}
-
- def close(self):
- return None
-
- def drop(self):
- self._execute(f"DROP TABLE IF EXISTS {self._table_ref()}")
- self._execute(
- f"DELETE FROM {self._meta_table_ref(_INDEX_META_TABLE)} WHERE table_name = %s",
- [self.collection_key],
- )
- self._execute(
- f"DELETE FROM {self._meta_table_ref(_COLLECTION_META_TABLE)} WHERE table_name = %s",
- [self.collection_key],
- )
-
- def create_index(self, index_name: str, meta_data: Dict[str, Any]):
- full_meta = dict(meta_data)
- full_meta["IndexName"] = index_name
- vector_meta = dict(full_meta.get("VectorIndex", {}) or {})
- distance = _normalize_distance(vector_meta.get("Distance") or self._distance_metric)
- vector_meta["IndexType"] = "hnsw"
- full_meta["VectorIndex"] = vector_meta
- self._create_vector_index(index_name, distance, full_meta)
- for field_name in full_meta.get("ScalarIndex", []) or []:
- self._create_scalar_index(index_name, str(field_name))
- self._save_index_meta(index_name, full_meta)
- return OpenGaussIndex(self, index_name, full_meta)
-
- def _create_vector_index(
- self,
- index_name: str,
- distance: str,
- meta: Dict[str, Any],
- ) -> None:
- if self._dense_vector_name not in self._all_columns():
- return
- ops_class = _VECTOR_OPS[distance]["hnsw"]
- pg_index_name = _safe_identifier(self._table_name, index_name, "vec", prefix="idx")
- try:
- hnsw = meta.get("VectorIndex") or {}
- m = int(hnsw.get("M") or hnsw.get("m") or 16)
- ef = int(hnsw.get("EfConstruction") or hnsw.get("ef_construction") or 64)
- self._execute(
- f"""
- CREATE INDEX IF NOT EXISTS {_quote_ident(pg_index_name)}
- ON {self._table_ref()}
- USING hnsw ({_quote_ident(self._dense_vector_name)} {ops_class})
- WITH (m = {m}, ef_construction = {ef})
- """
- )
- except Exception as exc:
- raise RuntimeError(f"Failed to create openGauss vector index {pg_index_name}") from exc
-
- def _create_scalar_index(self, index_name: str, field_name: str) -> None:
- if field_name not in self._all_columns():
- return
- pg_index_name = _safe_identifier(self._table_name, index_name, field_name, prefix="idx")
- try:
- self._execute(
- f"""
- CREATE INDEX IF NOT EXISTS {_quote_ident(pg_index_name)}
- ON {self._table_ref()} ({_quote_ident(field_name)})
- """
- )
- except Exception as exc:
- logger.warning("Failed to create openGauss scalar index %s: %s", field_name, exc)
-
- def has_index(self, index_name: str) -> bool:
- return index_name in self.list_indexes()
-
- def get_index(self, index_name: str) -> Optional[IIndex]:
- meta = self.get_index_meta_data(index_name)
- if not meta:
- return None
- return OpenGaussIndex(self, index_name, meta)
-
- def update_index(
- self,
- index_name: str,
- scalar_index: Optional[Dict[str, Any]] = None,
- description: Optional[str] = None,
- ):
- meta = self.get_index_meta_data(index_name) or {"IndexName": index_name}
- if scalar_index is not None:
- meta["ScalarIndex"] = (
- list(scalar_index.keys()) if isinstance(scalar_index, dict) else list(scalar_index)
- )
- if description is not None:
- meta["Description"] = description
- for field_name in meta.get("ScalarIndex", []) or []:
- self._create_scalar_index(index_name, str(field_name))
- self._save_index_meta(index_name, meta)
- return meta
-
- def get_index_meta_data(self, index_name: str):
- rows = self._execute(
- f"""
- SELECT meta_json
- FROM {self._meta_table_ref(_INDEX_META_TABLE)}
- WHERE table_name = %s AND index_name = %s
- """,
- [self.collection_key, index_name],
- fetch=True,
- )
- if not rows:
- return None
- try:
- return json.loads(rows[0][0])
- except (TypeError, ValueError):
- return None
-
- def list_indexes(self):
- rows = self._execute(
- f"SELECT index_name FROM {self._meta_table_ref(_INDEX_META_TABLE)} "
- "WHERE table_name = %s ORDER BY index_name",
- [self.collection_key],
- fetch=True,
- )
- return [str(row[0]) for row in rows]
-
- def drop_index(self, index_name: str):
- meta = self.get_index_meta_data(index_name) or {}
- pg_index_name = _safe_identifier(self._table_name, index_name, "vec", prefix="idx")
- self._execute(f"DROP INDEX IF EXISTS {self._index_ref(pg_index_name)}")
- for field_name in meta.get("ScalarIndex", []) or []:
- scalar_index_name = _safe_identifier(
- self._table_name, index_name, field_name, prefix="idx"
- )
- self._execute(f"DROP INDEX IF EXISTS {self._index_ref(scalar_index_name)}")
- self._delete_index_meta(index_name)
-
- # ------------------------------------------------------------------
- # Search
- # ------------------------------------------------------------------
- def search_by_vector(
- self,
- index_name: str,
- dense_vector: Optional[List[float]] = None,
- limit: int = 10,
- offset: int = 0,
- filters: Optional[Dict[str, Any]] = None,
- sparse_vector: Optional[Dict[str, float]] = None,
- output_fields: Optional[List[str]] = None,
- ) -> SearchResult:
- if limit <= 0:
- return SearchResult()
- if dense_vector is None and sparse_vector is None:
- return SearchResult()
- fetch_limit = max(limit + offset, limit)
- if dense_vector is None:
- return self._search_by_sparse(
- sparse_vector, fetch_limit, offset, limit, filters, output_fields
- )
-
- columns = self._select_columns(output_fields, include_sparse=bool(sparse_vector))
- where_sql, params = self._where_sql(filters)
- operator = _VECTOR_OPS[self._distance_metric]["operator"]
- vector_text = _vector_literal(dense_vector)
- sql = (
- f"SELECT {', '.join(_quote_ident(col) for col in columns)}, "
- f"{_quote_ident(self._dense_vector_name)} {operator} %s::vector AS _distance "
- f"FROM {self._table_ref()}"
- f"{where_sql} "
- f"ORDER BY {_quote_ident(self._dense_vector_name)} {operator} %s::vector "
- "LIMIT %s OFFSET %s"
- )
- rows = self._execute(
- sql, [vector_text] + params + [vector_text, fetch_limit, 0], fetch=True
- )
- scored_items: List[SearchItemResult] = []
- for row in rows:
- record_id, payload = self._row_to_payload(row[:-1], columns)
- distance = row[-1]
- score = self._distance_to_score(distance, self._distance_metric)
- if sparse_vector:
- sparse_payload = payload.pop(self._sparse_vector_name, None)
- if isinstance(sparse_payload, dict):
- score += _sparse_dot(sparse_vector, sparse_payload)
- scored_items.append(SearchItemResult(id=record_id, fields=payload, score=score))
- if sparse_vector:
- scored_items.sort(key=lambda item: item.score or 0.0, reverse=True)
- return SearchResult(data=scored_items[offset : offset + limit])
-
- def _search_by_sparse(
- self,
- sparse_vector: Optional[Dict[str, float]],
- fetch_limit: int,
- offset: int,
- limit: int,
- filters: Optional[Dict[str, Any]],
- output_fields: Optional[List[str]],
- ) -> SearchResult:
- if not sparse_vector:
- return SearchResult()
- columns = self._select_columns(output_fields, include_sparse=True)
- where_sql, params = self._where_sql(filters)
- sql = (
- f"SELECT {', '.join(_quote_ident(col) for col in columns)} "
- f"FROM {self._table_ref()}{where_sql} LIMIT %s"
- )
- rows = self._execute(
- sql, params + [max(fetch_limit, self.DEFAULT_SPARSE_SCAN_LIMIT)], fetch=True
- )
- items = []
- for row in rows:
- record_id, payload = self._row_to_payload(row, columns)
- sparse_payload = payload.pop(self._sparse_vector_name, None)
- score = _sparse_dot(
- sparse_vector, sparse_payload if isinstance(sparse_payload, dict) else None
- )
- if score > 0:
- items.append(SearchItemResult(id=record_id, fields=payload, score=score))
- items.sort(key=lambda item: item.score or 0.0, reverse=True)
- return SearchResult(data=items[offset : offset + limit])
-
- @staticmethod
- def _distance_to_score(distance: Any, distance_metric: str = "cosine") -> float:
- try:
- value = float(distance)
- except (TypeError, ValueError):
- return 0.0
- if not math.isfinite(value):
- return 0.0
- if distance_metric == "ip":
- return -value
- return 1.0 / (1.0 + max(value, 0.0))
-
- def search_by_keywords(
- self,
- index_name: str,
- keywords: Optional[List[str]] = None,
- query: Optional[str] = None,
- limit: int = 10,
- offset: int = 0,
- filters: Optional[Dict[str, Any]] = None,
- output_fields: Optional[List[str]] = None,
- ) -> SearchResult:
- query_text = query or " ".join(keywords or [])
- if not query_text.strip():
- return SearchResult()
- text_filter = {
- "op": "or",
- "conds": [
- {"op": "contains", "field": field, "substring": query_text}
- for field in ("name", "description", "abstract", "tags")
- if field in self._all_columns()
- ],
- }
- filters = {"op": "and", "conds": [filters, text_filter]} if filters else text_filter
- return self.search_by_random(index_name, limit, offset, filters, output_fields)
-
- def search_by_id(
- self,
- index_name: str,
- id: Any,
- limit: int = 10,
- offset: int = 0,
- filters: Optional[Dict[str, Any]] = None,
- output_fields: Optional[List[str]] = None,
- ) -> SearchResult:
- columns = self._select_columns(output_fields, include_vector=True, include_sparse=True)
- rows = self._execute(
- f"SELECT {', '.join(_quote_ident(col) for col in columns)} "
- f"FROM {self._table_ref()} WHERE id = %s",
- [str(id)],
- fetch=True,
- )
- if not rows:
- return SearchResult()
- row_payload = dict(zip(columns, rows[0], strict=False))
- dense_vector = row_payload.get(self._dense_vector_name)
- sparse_raw = row_payload.get(self._sparse_vector_name)
- sparse_vector = None
- if sparse_raw:
- try:
- sparse_vector = json.loads(sparse_raw)
- except (TypeError, ValueError):
- sparse_vector = None
- result = self.search_by_vector(
- index_name=index_name,
- dense_vector=self._parse_vector_value(dense_vector),
- sparse_vector=sparse_vector,
- limit=limit + offset + 1,
- filters=filters,
- output_fields=output_fields,
- )
- data = [item for item in result.data if str(item.id) != str(id)]
- return SearchResult(data=data[offset : offset + limit])
-
- @staticmethod
- def _parse_vector_value(value: Any) -> Optional[List[float]]:
- if isinstance(value, list):
- return [float(item) for item in value]
- if not isinstance(value, str):
- return None
- stripped = value.strip().strip("[]")
- if not stripped:
- return None
- return [float(item.strip()) for item in stripped.split(",")]
-
- def search_by_multimodal(
- self,
- index_name: str,
- text: Optional[str],
- image: Optional[Any],
- video: Optional[Any],
- limit: int = 10,
- offset: int = 0,
- filters: Optional[Dict[str, Any]] = None,
- output_fields: Optional[List[str]] = None,
- ) -> SearchResult:
- raise NotImplementedError("OpenGaussCollection.search_by_multimodal is not supported")
-
- def search_by_random(
- self,
- index_name: str,
- limit: int = 10,
- offset: int = 0,
- filters: Optional[Dict[str, Any]] = None,
- output_fields: Optional[List[str]] = None,
- ) -> SearchResult:
- columns = self._select_columns(output_fields)
- where_sql, params = self._where_sql(filters)
- rows = self._execute(
- f"SELECT {', '.join(_quote_ident(col) for col in columns)} "
- f"FROM {self._table_ref()}{where_sql} LIMIT %s OFFSET %s",
- params + [limit, offset],
- fetch=True,
- )
- return SearchResult(
- data=[
- SearchItemResult(id=record_id, fields=payload, score=1.0)
- for record_id, payload in (self._row_to_payload(row, columns) for row in rows)
- ]
- )
-
- def search_by_scalar(
- self,
- index_name: str,
- field: str,
- order: Optional[str] = "desc",
- limit: int = 10,
- offset: int = 0,
- filters: Optional[Dict[str, Any]] = None,
- output_fields: Optional[List[str]] = None,
- ) -> SearchResult:
- columns = self._select_columns(output_fields)
- if field not in columns:
- columns.append(field)
- where_sql, params = self._where_sql(filters)
- direction = "DESC" if (order or "desc").lower() == "desc" else "ASC"
- rows = self._execute(
- f"SELECT {', '.join(_quote_ident(col) for col in columns)} "
- f"FROM {self._table_ref()}{where_sql} "
- f"ORDER BY {_quote_ident(field)} {direction} NULLS LAST LIMIT %s OFFSET %s",
- params + [limit, offset],
- fetch=True,
- )
- items = []
- for row in rows:
- record_id, payload = self._row_to_payload(row, columns)
- score = (
- payload.pop(field, None)
- if output_fields and field not in output_fields
- else payload.get(field)
- )
- items.append(
- SearchItemResult(
- id=record_id,
- fields=payload,
- score=score if isinstance(score, (int, float)) else None,
- )
- )
- return SearchResult(data=items)
-
- # ------------------------------------------------------------------
- # Data operations
- # ------------------------------------------------------------------
- def upsert_data(self, data_list: List[Dict[str, Any]], ttl=0):
- if not data_list:
- return []
- ids = []
- for record in data_list:
- record_id = record.get("id")
- if record_id is None or record_id == "":
- raise ValueError("openGauss vector record requires id")
- self._ensure_columns_for_record(record)
- columns = []
- values = []
- for column in self._all_columns():
- if column not in record:
- continue
- columns.append(column)
- if column == self._dense_vector_name:
- values.append(_vector_literal(record[column]))
- elif column == self._sparse_vector_name:
- values.append(_json_dumps(record[column] or {}))
- elif column == "scope_roots":
- values.append(_encode_scope_roots(record[column]))
- else:
- values.append(_coerce_sql_value(record[column], self._field_types.get(column)))
- if "id" not in columns:
- columns.insert(0, "id")
- values.insert(0, str(record_id))
- self._upsert_row(columns, values)
- ids.append(record_id)
- return ids
-
- def _upsert_row(self, columns: List[str], values: List[Any]) -> None:
- id_index = columns.index("id")
- update_columns = [column for column in columns if column != "id"]
- update_values = [
- value for column, value in zip(columns, values, strict=False) if column != "id"
- ]
- set_parts = [
- f"{_quote_ident(column)} = {'%s::vector' if column == self._dense_vector_name else '%s'}"
- for column in update_columns
- ]
- insert_placeholders = [
- "%s::vector" if column == self._dense_vector_name else "%s" for column in columns
- ]
-
- with self._lock:
- conn = self._ensure_connection()
- cur = conn.cursor()
- try:
- if update_columns:
- cur.execute(
- f"UPDATE {self._table_ref()} SET {', '.join(set_parts)} WHERE id = %s",
- update_values + [values[id_index]],
- )
- if not update_columns or cur.rowcount == 0:
- try:
- cur.execute(
- f"INSERT INTO {self._table_ref()} "
- f"({', '.join(_quote_ident(column) for column in columns)}) "
- f"VALUES ({', '.join(insert_placeholders)})",
- values,
- )
- except Exception as exc:
- if getattr(exc, "pgcode", None) != "23505" or not update_columns:
- raise
- self._safe_rollback()
- cur.close()
- conn = self._ensure_connection()
- cur = conn.cursor()
- cur.execute(
- f"UPDATE {self._table_ref()} SET {', '.join(set_parts)} WHERE id = %s",
- update_values + [values[id_index]],
- )
- conn.commit()
- except Exception:
- self._safe_rollback()
- raise
- finally:
- cur.close()
-
- def fetch_data(self, primary_keys: List[Any]):
- if not primary_keys:
- return FetchDataInCollectionResult()
- columns = self._select_columns(None)
- placeholders = ", ".join(["%s"] * len(primary_keys))
- rows = self._execute(
- f"SELECT {', '.join(_quote_ident(col) for col in columns)} "
- f"FROM {self._table_ref()} WHERE id IN ({placeholders})",
- [str(pk) for pk in primary_keys],
- fetch=True,
- )
- items = []
- found_ids = set()
- for row in rows:
- record_id, payload = self._row_to_payload(row, columns)
- found_ids.add(str(record_id))
- items.append(DataItem(id=record_id, fields=payload))
- return FetchDataInCollectionResult(
- items=items,
- ids_not_exist=[pk for pk in primary_keys if str(pk) not in found_ids],
- )
-
- def delete_data(self, primary_keys: List[Any]):
- if not primary_keys:
- return None
- placeholders = ", ".join(["%s"] * len(primary_keys))
- self._execute(
- f"DELETE FROM {self._table_ref()} WHERE id IN ({placeholders})",
- [str(pk) for pk in primary_keys],
- )
- return None
-
- def delete_all_data(self):
- self._execute(f"DELETE FROM {self._table_ref()}")
-
- def aggregate_data(
- self,
- index_name: str,
- op: str = "count",
- field: Optional[str] = None,
- filters: Optional[Dict[str, Any]] = None,
- cond: Optional[Dict[str, Any]] = None,
- ) -> AggregateResult:
- if op != "count":
- return AggregateResult(agg={}, op=op, field=field)
- where_sql, params = self._where_sql(filters)
- if not field:
- rows = self._execute(
- f"SELECT COUNT(*) FROM {self._table_ref()}{where_sql}",
- params,
- fetch=True,
- )
- return AggregateResult(
- agg={"_total": int(rows[0][0]) if rows else 0}, op=op, field=None
- )
- rows = self._execute(
- f"SELECT {_quote_ident(field)}, COUNT(*) FROM {self._table_ref()}"
- f"{where_sql} GROUP BY {_quote_ident(field)}",
- params,
- fetch=True,
- )
- grouped = {row[0]: int(row[1]) for row in rows if row[0] is not None}
- if cond:
- grouped = {
- key: value
- for key, value in grouped.items()
- if (cond.get("gt") is None or value > cond["gt"])
- and (cond.get("gte") is None or value >= cond["gte"])
- and (cond.get("lt") is None or value < cond["lt"])
- and (cond.get("lte") is None or value <= cond["lte"])
- }
- return AggregateResult(agg=grouped, op=op, field=field)
-
-
-class OpenGaussCollectionAdapter(CollectionAdapter):
- """CollectionAdapter backed by openGauss native vector tables."""
-
- mode = "opengauss"
- INTERNAL_PATH_FIELDS = ["parent_uri", "scope_roots", "uri_depth"]
-
- def __init__(
- self,
- *,
- host: str,
- port: int,
- user: str,
- password: str,
- db_name: str,
- schema_name: str,
- project_name: str,
- collection_name: str,
- index_name: str,
- distance_metric: str,
- dense_vector_name: str,
- sparse_vector_name: str,
- connect_timeout: int,
- mode: str,
- shard_count: int,
- ) -> None:
- super().__init__(collection_name=collection_name, index_name=index_name)
- self._host = host
- self._port = int(port)
- self._user = user
- self._password = password
- self._db_name = db_name
- self._schema_name = (schema_name or _DEFAULT_SCHEMA).strip() or _DEFAULT_SCHEMA
- self._project_name = project_name
- self._distance_metric = _normalize_distance(distance_metric)
- self._dense_vector_name = dense_vector_name
- self._sparse_vector_name = sparse_vector_name
- self._connect_timeout = int(connect_timeout)
- self._deployment_mode = mode
- self._shard_count = int(shard_count)
- self._conn = None
- self._lock = threading.RLock()
-
- @classmethod
- def from_config(cls, config: Any):
- cfg = getattr(config, "opengauss", None)
- params = dict(getattr(config, "custom_params", {}) or {})
- if cfg is None:
- raise ValueError("openGauss backend requires opengauss config")
- return cls(
- host=str(getattr(cfg, "host", None) or params.get("host") or "127.0.0.1"),
- port=int(getattr(cfg, "port", None) or params.get("port") or 5432),
- user=str(getattr(cfg, "user", None) or params.get("user") or "omm"),
- password=str(getattr(cfg, "password", None) or params.get("password") or ""),
- db_name=str(getattr(cfg, "db_name", None) or params.get("db_name") or "postgres"),
- schema_name=str(
- getattr(cfg, "schema_name", None)
- or getattr(cfg, "schema", None)
- or params.get("schema")
- or _DEFAULT_SCHEMA
- ),
- project_name=config.project_name or "default",
- collection_name=config.name or "context",
- index_name=config.index_name or "default",
- distance_metric=config.distance_metric or "cosine",
- dense_vector_name=str(
- getattr(cfg, "dense_vector_name", None)
- or params.get("dense_vector_name")
- or "vector"
- ),
- sparse_vector_name=str(
- getattr(cfg, "sparse_vector_name", None)
- or params.get("sparse_vector_name")
- or "sparse_vector"
- ),
- connect_timeout=int(
- getattr(cfg, "connect_timeout", None) or params.get("connect_timeout") or 10
- ),
- mode=str(getattr(cfg, "mode", None) or params.get("mode") or "standalone"),
- shard_count=int(getattr(cfg, "shard_count", None) or params.get("shard_count") or 32),
- )
-
- @property
- def physical_table_name(self) -> str:
- return _safe_identifier(self._project_name, self._collection_name, prefix="ov")
-
- def _connect(self):
- if self._conn is not None and not getattr(self._conn, "closed", 0):
- return self._conn
- if self._conn is not None:
- try:
- self._conn.close()
- except Exception:
- logger.debug("Failed to close stale openGauss connection", exc_info=True)
- psycopg2 = _import_psycopg2()
- self._conn = psycopg2.connect(
- host=self._host,
- port=self._port,
- user=self._user,
- password=self._password,
- dbname=self._db_name,
- connect_timeout=self._connect_timeout,
- )
- self._ensure_meta_tables()
- return self._conn
-
- def _ensure_meta_tables(self) -> None:
- conn = self._conn
- if conn is None:
- return
- cur = conn.cursor()
- try:
- cur.execute(f"CREATE SCHEMA IF NOT EXISTS {_quote_ident(self._schema_name)}")
- cur.execute(
- f"""
- CREATE TABLE IF NOT EXISTS {_qualify(self._schema_name, _COLLECTION_META_TABLE)} (
- table_name TEXT PRIMARY KEY,
- logical_collection_name TEXT NOT NULL,
- project_name TEXT NOT NULL,
- meta_json TEXT NOT NULL,
- updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
- )
- """
- )
- cur.execute(
- f"""
- CREATE TABLE IF NOT EXISTS {_qualify(self._schema_name, _INDEX_META_TABLE)} (
- table_name TEXT NOT NULL,
- index_name TEXT NOT NULL,
- meta_json TEXT NOT NULL,
- updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
- PRIMARY KEY (table_name, index_name)
- )
- """
- )
- conn.commit()
- except Exception:
- conn.rollback()
- raise
- finally:
- cur.close()
- if self._deployment_mode == "distributed":
- self._try_make_reference_table(_COLLECTION_META_TABLE)
- self._try_make_reference_table(_INDEX_META_TABLE)
-
- def _try_make_reference_table(self, table_name: str) -> None:
- conn = self._conn
- if conn is None:
- return
- cur = conn.cursor()
- try:
- cur.execute(
- "SELECT create_reference_table(%s)", [self._function_table_name(table_name)]
- )
- conn.commit()
- except Exception as exc:
- conn.rollback()
- logger.warning(
- "Failed to mark openGauss metadata table %s as reference table: %s",
- self._function_table_name(table_name),
- exc,
- )
- finally:
- cur.close()
-
- def _new_collection(self, meta: Optional[Dict[str, Any]] = None) -> OpenGaussCollection:
- return OpenGaussCollection(
- conn=self._connect(),
- schema_name=self._schema_name,
- table_name=self.physical_table_name,
- logical_collection_name=self._collection_name,
- project_name=self._project_name,
- dense_vector_name=self._dense_vector_name,
- sparse_vector_name=self._sparse_vector_name,
- distance_metric=self._distance_metric,
- meta=meta,
- lock=self._lock,
- reconnect=self._connect,
- )
-
- def _load_existing_collection_if_needed(self) -> None:
- if self._collection is not None:
- return
- conn = self._connect()
- raw_collection = self._new_collection()
- if not raw_collection._table_exists():
- return
- meta = raw_collection.get_meta_data()
- if not meta:
- raise RuntimeError(
- "openGauss collection table exists but OpenViking metadata is missing: "
- f"{self.physical_table_name}. Use a different project/name, restore metadata, "
- "or drop the stale table."
- )
- self._collection = Collection(
- OpenGaussCollection(
- conn=conn,
- schema_name=self._schema_name,
- table_name=self.physical_table_name,
- logical_collection_name=self._collection_name,
- project_name=self._project_name,
- dense_vector_name=self._dense_vector_name,
- sparse_vector_name=self._sparse_vector_name,
- distance_metric=self._distance_metric,
- meta=meta,
- lock=self._lock,
- reconnect=self._connect,
- )
- )
-
- def _create_backend_collection(self, meta: Dict[str, Any]) -> Collection:
- raw_collection = self._new_collection(meta)
- raw_collection.create_remote_collection(meta)
- if self._deployment_mode == "distributed":
- self._try_make_distributed_table(self.physical_table_name)
- return Collection(raw_collection)
-
- def _try_make_distributed_table(self, table_name: str) -> None:
- conn = self._conn
- if conn is None:
- return
- cur = conn.cursor()
- try:
- cur.execute(
- "SELECT create_distributed_table(%s, 'id', 'hash', %s)",
- [self._function_table_name(table_name), self._shard_count],
- )
- conn.commit()
- except Exception as exc:
- conn.rollback()
- logger.warning(
- "Failed to distribute openGauss table %s with shard_count=%s: %s",
- table_name,
- self._shard_count,
- exc,
- )
- finally:
- cur.close()
-
- def close(self) -> None:
- super().close()
- if self._conn is not None:
- self._conn.close()
- self._conn = None
-
- def _sanitize_scalar_index_fields(
- self,
- scalar_index_fields: list[str],
- fields_meta: list[dict[str, Any]],
- ) -> list[str]:
- del fields_meta
- return list(dict.fromkeys(list(scalar_index_fields) + self.INTERNAL_PATH_FIELDS))
-
- def _build_default_index_meta(
- self,
- *,
- index_name: str,
- distance: str,
- use_sparse: bool,
- sparse_weight: float,
- scalar_index_fields: list[str],
- ) -> Dict[str, Any]:
- index_meta = super()._build_default_index_meta(
- index_name=index_name,
- distance=distance,
- use_sparse=use_sparse,
- sparse_weight=sparse_weight,
- scalar_index_fields=scalar_index_fields,
- )
- index_meta["VectorIndex"]["IndexType"] = "hnsw_hybrid" if use_sparse else "hnsw"
- return index_meta
-
- @staticmethod
- def _normalize_path(path: str) -> str:
- stripped = (path or "").strip()
- if not stripped:
- return "/"
- if not stripped.startswith("/"):
- stripped = f"/{stripped}"
- if len(stripped) > 1:
- stripped = stripped.rstrip("/")
- return stripped or "/"
-
- @classmethod
- def _compute_parent_uri(cls, uri: str) -> str:
- normalized = cls._normalize_path(uri)
- if normalized == "/":
- return "/"
- parts = normalized.strip("/").split("/")
- if len(parts) <= 1:
- return "/"
- return "/" + "/".join(parts[:-1])
-
- @classmethod
- def _compute_scope_roots(cls, uri: str) -> List[str]:
- normalized = cls._normalize_path(uri)
- if normalized == "/":
- return ["/"]
- parts = normalized.strip("/").split("/")
- roots = ["/"]
- current_parts: List[str] = []
- for part in parts[:-1]:
- current_parts.append(part)
- roots.append("/" + "/".join(current_parts))
- return roots
-
- def _normalize_record_for_write(self, record: Dict[str, Any]) -> Dict[str, Any]:
- normalized = dict(super()._normalize_record_for_write(record))
- raw_uri = normalized.get("uri")
- if isinstance(raw_uri, str):
- normalized_uri = self._normalize_path(raw_uri)
- normalized["uri"] = normalized_uri
- normalized["parent_uri"] = self._compute_parent_uri(normalized_uri)
- normalized["scope_roots"] = self._compute_scope_roots(normalized_uri)
- normalized["uri_depth"] = len(
- [part for part in normalized_uri.strip("/").split("/") if part]
- )
- return normalized
-
- def _normalize_record_for_read(self, record: Dict[str, Any]) -> Dict[str, Any]:
- normalized = super()._normalize_record_for_read(record)
- for field_name in self.INTERNAL_PATH_FIELDS:
- normalized.pop(field_name, None)
- return normalized
-
- def _coerce_datetime_value(self, value: Any) -> Any:
- if isinstance(value, dt.datetime):
- if value.tzinfo is None:
- value = value.replace(tzinfo=dt.timezone.utc)
- return value.isoformat()
- return value
-
- def _compile_filter(self, expr: FilterExpr | Dict[str, Any] | None) -> Dict[str, Any]:
- if expr is None:
- return {}
- if isinstance(expr, dict):
- return self._normalize_filter_payload_for_write(expr)
- if isinstance(expr, RawDSL):
- return self._normalize_filter_payload_for_write(expr.payload)
- if isinstance(expr, And):
- conds = [self._compile_filter(cond) for cond in expr.conds if cond]
- return {"op": "and", "conds": [cond for cond in conds if cond]}
- if isinstance(expr, Or):
- conds = [self._compile_filter(cond) for cond in expr.conds if cond]
- return {"op": "or", "conds": [cond for cond in conds if cond]}
- if isinstance(expr, Eq):
- value = expr.value
- if expr.field in self._URI_FIELD_NAMES:
- value = self._normalize_path(self._encode_uri_field_value(value))
- return {"op": "must", "field": expr.field, "conds": [value]}
- if isinstance(expr, In):
- values = list(expr.values)
- if expr.field in self._URI_FIELD_NAMES:
- values = [
- self._normalize_path(self._encode_uri_field_value(value)) for value in values
- ]
- return {"op": "must", "field": expr.field, "conds": values}
- if isinstance(expr, Range):
- payload: Dict[str, Any] = {"op": "range", "field": expr.field}
- for key in ("gte", "gt", "lte", "lt"):
- value = getattr(expr, key)
- if value is not None:
- payload[key] = value
- return payload
- if isinstance(expr, TimeRange):
- payload: Dict[str, Any] = {"op": "range", "field": expr.field}
- if expr.start is not None:
- payload["gte"] = self._coerce_datetime_value(expr.start)
- if expr.end is not None:
- payload["lt"] = self._coerce_datetime_value(expr.end)
- return payload
- if isinstance(expr, Contains):
- return {"op": "contains", "field": expr.field, "substring": expr.substring}
- if isinstance(expr, PathScope):
- encoded_path = (
- self._normalize_path(self._encode_uri_field_value(expr.path))
- if expr.field in self._URI_FIELD_NAMES
- else expr.path
- )
- if expr.depth == 0:
- return {"op": "must", "field": expr.field, "conds": [encoded_path]}
- if expr.depth == 1:
- return {"op": "must", "field": "parent_uri", "conds": [encoded_path]}
- if expr.depth == -1:
- return {"op": "must", "field": "scope_roots", "conds": [encoded_path]}
- raise ValueError(
- f"OpenGauss adapter only supports PathScope depth 0/1/-1, got {expr.depth}"
- )
- raise TypeError(f"Unsupported filter expr type: {type(expr)!r}")
diff --git a/openviking/storage/vectordb_adapters/qdrant_adapter.py b/openviking/storage/vectordb_adapters/qdrant_adapter.py
deleted file mode 100644
index 743d7f06f..000000000
--- a/openviking/storage/vectordb_adapters/qdrant_adapter.py
+++ /dev/null
@@ -1,396 +0,0 @@
-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
-# SPDX-License-Identifier: AGPL-3.0
-"""Qdrant backend collection adapter."""
-
-from __future__ import annotations
-
-from datetime import datetime, timezone
-from typing import Any, Dict, List
-
-from openviking.storage.expr import (
- And,
- Contains,
- Eq,
- FilterExpr,
- In,
- Or,
- PathScope,
- Range,
- RawDSL,
- TimeRange,
-)
-from openviking.storage.vectordb.collection.collection import Collection
-from openviking.storage.vectordb.collection.qdrant_collection import QdrantCollection
-
-from .base import CollectionAdapter
-
-
-class QdrantCollectionAdapter(CollectionAdapter):
- """Adapter for Qdrant-backed vector collections."""
-
- INTERNAL_PATH_FIELDS = ["parent_uri", "scope_roots", "uri_depth"]
- DEFAULT_TEXT_INDEX_FIELDS = ["name", "description", "abstract", "tags"]
-
- def __init__(
- self,
- *,
- url: str,
- api_key: str | None,
- timeout_seconds: int,
- project_name: str,
- collection_name: str,
- index_name: str,
- distance_metric: str,
- dense_vector_name: str,
- sparse_vector_name: str,
- meta_collection_name: str,
- enable_text_index: bool,
- ) -> None:
- super().__init__(collection_name=collection_name, index_name=index_name)
- self.mode = "qdrant"
- self._url = url
- self._api_key = api_key
- self._timeout_seconds = timeout_seconds
- self._project_name = project_name
- self._distance_metric = distance_metric
- self._dense_vector_name = dense_vector_name
- self._sparse_vector_name = sparse_vector_name
- self._meta_collection_name = meta_collection_name
- self._enable_text_index = enable_text_index
-
- @classmethod
- def from_config(cls, config: Any):
- cfg = getattr(config, "qdrant", None)
- params = dict(getattr(config, "custom_params", {}) or {})
- url = getattr(cfg, "url", None) or getattr(config, "url", None) or params.get("url")
- if not url:
- raise ValueError("Qdrant backend requires qdrant.url or url")
- return cls(
- url=str(url).strip().rstrip("/"),
- api_key=getattr(cfg, "api_key", None) or params.get("api_key"),
- timeout_seconds=int(
- getattr(cfg, "timeout_seconds", None) or params.get("timeout_seconds") or 10
- ),
- project_name=config.project_name or "default",
- collection_name=config.name or "context",
- index_name=config.index_name or "default",
- distance_metric=config.distance_metric or "cosine",
- dense_vector_name=getattr(cfg, "dense_vector_name", "vector"),
- sparse_vector_name=getattr(cfg, "sparse_vector_name", "sparse_vector"),
- meta_collection_name=getattr(cfg, "meta_collection_name", "__openviking_meta"),
- enable_text_index=bool(getattr(cfg, "enable_text_index", True)),
- )
-
- @property
- def physical_collection_name(self) -> str:
- return f"{self._project_name}__{self._collection_name}"
-
- def _new_qdrant_collection(self) -> QdrantCollection:
- return QdrantCollection(
- url=self._url,
- api_key=self._api_key,
- timeout_seconds=self._timeout_seconds,
- project_name=self._project_name,
- logical_collection_name=self._collection_name,
- physical_collection_name=self.physical_collection_name,
- dense_vector_name=self._dense_vector_name,
- sparse_vector_name=self._sparse_vector_name,
- meta_collection_name=self._meta_collection_name,
- distance_metric=self._distance_metric,
- enable_text_index=self._enable_text_index,
- )
-
- def _load_existing_collection_if_needed(self) -> None:
- if self._collection is not None:
- return
- candidate = self._new_qdrant_collection()
- try:
- if not candidate.collection_exists():
- return
- if not candidate.has_openviking_metadata():
- raise RuntimeError(
- "Qdrant collection exists but OpenViking metadata is missing: "
- f"{self.physical_collection_name}. "
- "Use a different project/name, restore metadata, or drop the stale Qdrant collection."
- )
- self._collection = Collection(candidate)
- candidate = None
- finally:
- if candidate is not None:
- candidate.close()
-
- def _create_backend_collection(self, meta: Dict[str, Any]) -> Collection:
- raw_collection = self._new_qdrant_collection()
- raw_collection.create_remote_collection(meta)
- return Collection(raw_collection)
-
- def _sanitize_scalar_index_fields(
- self,
- scalar_index_fields: list[str],
- fields_meta: list[dict[str, Any]],
- ) -> list[str]:
- text_fields = self.DEFAULT_TEXT_INDEX_FIELDS if self._enable_text_index else []
- merged = list(
- dict.fromkeys(list(scalar_index_fields) + self.INTERNAL_PATH_FIELDS + text_fields)
- )
- return merged
-
- def _build_default_index_meta(
- self,
- *,
- index_name: str,
- distance: str,
- use_sparse: bool,
- sparse_weight: float,
- scalar_index_fields: list[str],
- ) -> Dict[str, Any]:
- index_type = "hnsw_hybrid" if use_sparse else "hnsw"
- index_meta: Dict[str, Any] = {
- "IndexName": index_name,
- "VectorIndex": {
- "IndexType": index_type,
- "Distance": distance,
- "Quant": "int8",
- },
- "ScalarIndex": scalar_index_fields,
- }
- if use_sparse:
- index_meta["VectorIndex"]["EnableSparse"] = True
- index_meta["VectorIndex"]["SearchWithSparseLogitAlpha"] = sparse_weight
- return index_meta
-
- @staticmethod
- def _normalize_path(path: str) -> str:
- stripped = (path or "").strip()
- if not stripped:
- return "/"
- if not stripped.startswith("/"):
- stripped = f"/{stripped}"
- if len(stripped) > 1:
- stripped = stripped.rstrip("/")
- return stripped or "/"
-
- @classmethod
- def _compute_parent_uri(cls, uri: str) -> str:
- normalized = cls._normalize_path(uri)
- if normalized == "/":
- return "/"
- parts = normalized.strip("/").split("/")
- if len(parts) <= 1:
- return "/"
- return "/" + "/".join(parts[:-1])
-
- @classmethod
- def _compute_scope_roots(cls, uri: str) -> List[str]:
- normalized = cls._normalize_path(uri)
- if normalized == "/":
- return ["/"]
- parts = normalized.strip("/").split("/")
- roots = ["/"]
- current_parts: List[str] = []
- for part in parts[:-1]:
- current_parts.append(part)
- roots.append("/" + "/".join(current_parts))
- return roots
-
- def _normalize_record_for_write(self, record: Dict[str, Any]) -> Dict[str, Any]:
- normalized = dict(super()._normalize_record_for_write(record))
- raw_uri = normalized.get("uri")
- if isinstance(raw_uri, str):
- normalized_uri = self._normalize_path(raw_uri)
- normalized["uri"] = normalized_uri
- normalized["parent_uri"] = self._compute_parent_uri(normalized_uri)
- normalized["scope_roots"] = self._compute_scope_roots(normalized_uri)
- normalized["uri_depth"] = len(
- [part for part in normalized_uri.strip("/").split("/") if part]
- )
- return normalized
-
- def _normalize_record_for_read(self, record: Dict[str, Any]) -> Dict[str, Any]:
- normalized = super()._normalize_record_for_read(record)
- for field_name in self.INTERNAL_PATH_FIELDS:
- normalized.pop(field_name, None)
- return normalized
-
- def _coerce_datetime_value(self, value: Any) -> Any:
- if isinstance(value, datetime):
- if value.tzinfo is None:
- value = value.replace(tzinfo=timezone.utc)
- return value.isoformat()
- return value
-
- def _must_clause(self, *conds: Dict[str, Any]) -> Dict[str, Any]:
- items = [cond for cond in conds if cond]
- if not items:
- return {}
- if len(items) == 1 and set(items[0].keys()) in ({"must"}, {"should"}, {"must_not"}):
- return items[0]
- flattened: List[Dict[str, Any]] = []
- for item in items:
- if set(item.keys()) == {"must"}:
- flattened.extend(item.get("must", []))
- else:
- flattened.append(item)
- return {"must": flattened}
-
- def _should_clause(self, *conds: Dict[str, Any]) -> Dict[str, Any]:
- items = [cond for cond in conds if cond]
- if not items:
- return {}
- flattened: List[Dict[str, Any]] = []
- for item in items:
- if set(item.keys()) == {"should"}:
- flattened.extend(item.get("should", []))
- else:
- flattened.append(item)
- return {"should": flattened}
-
- @staticmethod
- def _match_condition(field: str, value: Any) -> Dict[str, Any]:
- return {"key": field, "match": {"value": value}}
-
- @staticmethod
- def _match_any_condition(field: str, values: List[Any]) -> Dict[str, Any]:
- return {"key": field, "match": {"any": values}}
-
- @staticmethod
- def _range_condition(field: str, payload: Dict[str, Any]) -> Dict[str, Any]:
- return {"key": field, "range": payload}
-
- @staticmethod
- def _text_condition(field: str, text: str) -> Dict[str, Any]:
- return {"key": field, "match": {"text": text}}
-
- def _compile_legacy_dict_filter(self, payload: Dict[str, Any]) -> Dict[str, Any]:
- op = str(payload.get("op") or "").lower()
- if not op:
- return self._normalize_filter_payload_for_write(payload)
-
- if op == "and":
- return self._must_clause(
- *(
- self._compile_legacy_dict_filter(cond)
- for cond in payload.get("conds", [])
- if cond
- )
- )
- if op == "or":
- return self._should_clause(
- *(
- self._compile_legacy_dict_filter(cond)
- for cond in payload.get("conds", [])
- if cond
- )
- )
- if op == "must":
- field = payload.get("field")
- values = payload.get("conds", []) or []
- if field in self._URI_FIELD_NAMES:
- values = [
- self._normalize_path(self._encode_uri_field_value(value)) for value in values
- ]
- if len(values) <= 1:
- value = values[0] if values else None
- return {"must": [self._match_condition(field, value)]} if value is not None else {}
- return {"must": [self._match_any_condition(field, list(values))]}
- if op == "must_not":
- field = payload.get("field")
- values = payload.get("conds", []) or []
- if field in self._URI_FIELD_NAMES:
- values = [
- self._normalize_path(self._encode_uri_field_value(value)) for value in values
- ]
- condition = (
- self._match_any_condition(field, list(values))
- if len(values) > 1
- else self._match_condition(field, values[0] if values else None)
- )
- return {"must_not": [condition]} if condition else {}
- if op in {"range", "time_range"}:
- range_payload: Dict[str, Any] = {}
- for key in ("gte", "gt", "lte", "lt"):
- if payload.get(key) is not None:
- range_payload[key] = self._coerce_datetime_value(payload[key])
- return {"must": [self._range_condition(payload.get("field"), range_payload)]}
- if op == "range_out":
- field = payload.get("field")
- branches: List[Dict[str, Any]] = []
- if payload.get("gte") is not None:
- branches.append({"must": [self._range_condition(field, {"lt": payload["gte"]})]})
- if payload.get("lte") is not None:
- branches.append({"must": [self._range_condition(field, {"gt": payload["lte"]})]})
- return self._should_clause(*branches)
- if op == "contains":
- return {
- "must": [self._text_condition(payload.get("field"), payload.get("substring", ""))]
- }
- if op == "prefix":
- field = payload.get("field")
- prefix = payload.get("prefix", "")
- if field in self._URI_FIELD_NAMES:
- return self._compile_filter(PathScope(field, prefix, depth=-1))
- return {"must": [self._text_condition(field, prefix)]}
- return self._normalize_filter_payload_for_write(payload)
-
- def _compile_filter(self, expr: FilterExpr | Dict[str, Any] | None) -> Dict[str, Any]:
- if expr is None:
- return {}
- if isinstance(expr, dict):
- if "op" in expr:
- return self._compile_legacy_dict_filter(expr)
- return self._normalize_filter_payload_for_write(expr)
- if isinstance(expr, RawDSL):
- payload = expr.payload
- if isinstance(payload, dict) and "op" in payload:
- return self._compile_legacy_dict_filter(payload)
- return self._normalize_filter_payload_for_write(payload)
- if isinstance(expr, And):
- return self._must_clause(*(self._compile_filter(cond) for cond in expr.conds if cond))
- if isinstance(expr, Or):
- return self._should_clause(*(self._compile_filter(cond) for cond in expr.conds if cond))
- if isinstance(expr, Eq):
- value = expr.value
- if expr.field in self._URI_FIELD_NAMES:
- value = self._normalize_path(self._encode_uri_field_value(value))
- return {"must": [self._match_condition(expr.field, value)]}
- if isinstance(expr, In):
- values = list(expr.values)
- if expr.field in self._URI_FIELD_NAMES:
- values = [
- self._normalize_path(self._encode_uri_field_value(value)) for value in values
- ]
- if len(values) == 1:
- return {"must": [self._match_condition(expr.field, values[0])]}
- return {"must": [self._match_any_condition(expr.field, values)]}
- if isinstance(expr, Range):
- numeric_range_payload: Dict[str, Any] = {}
- for key in ("gte", "gt", "lte", "lt"):
- value = getattr(expr, key)
- if value is not None:
- numeric_range_payload[key] = value
- return {"must": [self._range_condition(expr.field, numeric_range_payload)]}
- if isinstance(expr, TimeRange):
- time_range_payload: Dict[str, Any] = {}
- if expr.start is not None:
- time_range_payload["gte"] = self._coerce_datetime_value(expr.start)
- if expr.end is not None:
- time_range_payload["lt"] = self._coerce_datetime_value(expr.end)
- return {"must": [self._range_condition(expr.field, time_range_payload)]}
- if isinstance(expr, Contains):
- return {"must": [self._text_condition(expr.field, expr.substring)]}
- if isinstance(expr, PathScope):
- encoded_path = (
- self._normalize_path(self._encode_uri_field_value(expr.path))
- if expr.field in self._URI_FIELD_NAMES
- else expr.path
- )
- if expr.depth == 0:
- return {"must": [self._match_condition(expr.field, encoded_path)]}
- if expr.depth == 1:
- return {"must": [self._match_condition("parent_uri", encoded_path)]}
- if expr.depth == -1:
- return {"must": [self._match_condition("scope_roots", encoded_path)]}
- raise ValueError(
- f"Qdrant adapter only supports PathScope depth 0/1/-1, got {expr.depth}"
- )
- raise TypeError(f"Unsupported filter expr type: {type(expr)!r}")
diff --git a/openviking_cli/utils/config/vectordb_config.py b/openviking_cli/utils/config/vectordb_config.py
index ef8593e04..bccc25cde 100644
--- a/openviking_cli/utils/config/vectordb_config.py
+++ b/openviking_cli/utils/config/vectordb_config.py
@@ -50,32 +50,6 @@ class VikingDBConfig(BaseModel):
model_config = {"extra": "forbid"}
-class QdrantConfig(BaseModel):
- """Configuration for Qdrant backend."""
-
- url: Optional[str] = Field(default=None, description="Qdrant service URL")
- api_key: Optional[str] = Field(default=None, description="Optional Qdrant API key")
- timeout_seconds: int = Field(default=10, description="HTTP timeout for Qdrant requests")
- dense_vector_name: str = Field(
- default="vector",
- description="Named dense vector field in Qdrant collection.",
- )
- sparse_vector_name: str = Field(
- default="sparse_vector",
- description="Named sparse vector field in Qdrant collection.",
- )
- meta_collection_name: str = Field(
- default="__openviking_meta",
- description="Sidecar collection name for OpenViking metadata in Qdrant.",
- )
- enable_text_index: bool = Field(
- default=True,
- description="Whether to create text payload indexes for supported text fields.",
- )
-
- model_config = {"extra": "forbid"}
-
-
class CuVSConfig(BaseModel):
"""Configuration for GPU dense-vector search through NVIDIA cuVS."""
@@ -214,56 +188,6 @@ class CuVSConfig(BaseModel):
return self
-_OPENGAUSS_MODES = {"standalone", "distributed"}
-
-
-class OpenGaussConfig(BaseModel):
- """Configuration for openGauss native vector backend."""
-
- host: Optional[str] = Field(
- default="127.0.0.1",
- description="openGauss host address. Use the CN address when mode=distributed.",
- )
- port: int = Field(default=5432, description="openGauss port")
- user: str = Field(default="omm", description="Database user")
- password: str = Field(default="", description="Database password")
- db_name: str = Field(default="postgres", description="Database name")
- schema_name: str = Field(
- default="public",
- alias="schema",
- description="Database schema for OpenViking tables",
- )
- mode: str = Field(
- default="standalone",
- description="openGauss deployment mode: 'standalone' or 'distributed'",
- )
- shard_count: int = Field(
- default=32,
- description="Shard count for create_distributed_table when mode=distributed",
- )
- connect_timeout: int = Field(default=10, description="Database connection timeout in seconds")
- dense_vector_name: str = Field(default="vector", description="Dense vector column name")
- sparse_vector_name: str = Field(
- default="sparse_vector", description="Sparse vector JSON column name"
- )
-
- model_config = {"extra": "forbid", "populate_by_name": True}
-
- @model_validator(mode="after")
- def validate_mode(self):
- self.schema_name = (self.schema_name or "public").strip()
- if not self.schema_name:
- raise ValueError("openGauss schema must not be empty")
- self.mode = (self.mode or "standalone").strip().lower()
- if self.mode not in _OPENGAUSS_MODES:
- raise ValueError(
- f"Invalid openGauss mode: '{self.mode}'. Must be one of: {sorted(_OPENGAUSS_MODES)}"
- )
- self.dense_vector_name = (self.dense_vector_name or "vector").strip()
- self.sparse_vector_name = (self.sparse_vector_name or "sparse_vector").strip()
- return self
-
-
class VectorDBBackendConfig(BaseModel):
"""
Configuration for VectorDB backend.
@@ -277,7 +201,7 @@ class VectorDBBackendConfig(BaseModel):
description=(
"VectorDB backend type: 'local', 'cuvs', 'http', "
"'volcengine' (AK/SK signed or API key data-plane only), "
- "'vikingdb' (private deployment), 'qdrant', or 'opengauss'"
+ "or 'vikingdb' (private deployment)"
),
)
@@ -331,21 +255,11 @@ class VectorDBBackendConfig(BaseModel):
description="VikingDB private deployment configuration for 'vikingdb' type",
)
- qdrant: Optional[QdrantConfig] = Field(
- default_factory=QdrantConfig,
- description="Qdrant configuration for 'qdrant' type",
- )
-
cuvs: Optional[CuVSConfig] = Field(
default_factory=CuVSConfig,
description="NVIDIA cuVS dense-vector search configuration for the 'cuvs' backend",
)
- opengauss: Optional[OpenGaussConfig] = Field(
- default_factory=OpenGaussConfig,
- description="openGauss configuration for 'opengauss' type",
- )
-
custom_params: Dict[str, Any] = Field(
default_factory=dict,
description="Custom parameters for custom backend adapters",
@@ -362,8 +276,6 @@ class VectorDBBackendConfig(BaseModel):
"http",
"volcengine",
"vikingdb",
- "qdrant",
- "opengauss",
]
# Allow custom backend classes (containing dot) without standard validation
@@ -413,25 +325,4 @@ class VectorDBBackendConfig(BaseModel):
if not self.vikingdb or not self.vikingdb.host:
raise ValueError("VectorDB vikingdb backend requires 'host' to be set")
- elif self.backend == "qdrant":
- qdrant_url = (
- (self.qdrant.url if self.qdrant else None)
- or self.url
- or self.custom_params.get("url")
- )
- if not qdrant_url:
- raise ValueError("VectorDB qdrant backend requires 'qdrant.url' or 'url' to be set")
- if self.qdrant is None:
- self.qdrant = QdrantConfig()
- self.qdrant.url = str(qdrant_url).strip().rstrip("/")
- if self.url:
- self.url = self.url.strip().rstrip("/")
-
- elif self.backend == "opengauss":
- if self.opengauss is None:
- self.opengauss = OpenGaussConfig()
- if not self.opengauss.host:
- raise ValueError("VectorDB opengauss backend requires 'opengauss.host' to be set")
- self.opengauss.host = self.opengauss.host.strip()
-
return self
diff --git a/pyproject.toml b/pyproject.toml
index cf42fcb27..defbab250 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -110,9 +110,6 @@ auth = [
"httpx>=0.25.0",
"python-ldap>=3.4.0",
]
-opengauss = [
- "psycopg2-binary>=2.9",
-]
dev = [
"mypy>=1.0.0",
"ruff>=0.1.0",
diff --git a/tests/integration/conftest.py b/tests/integration/conftest.py
index 8f98d3d92..87572a28d 100644
--- a/tests/integration/conftest.py
+++ b/tests/integration/conftest.py
@@ -14,7 +14,6 @@ import shutil
import socket
import threading
import time
-from functools import lru_cache
from pathlib import Path
import httpx
@@ -51,40 +50,6 @@ requires_volcengine_kms = pytest.mark.skipif(
reason="VOLCENGINE_ACCESS_KEY, VOLCENGINE_SECRET_KEY, or VOLCENGINE_KMS_KEY_ID not set",
)
-# ── Qdrant integration test helpers ─────────────────────────────────────────
-QDRANT_URL = os.environ.get("QDRANT_URL", "http://127.0.0.1:6333").rstrip("/")
-QDRANT_API_KEY = os.environ.get("QDRANT_API_KEY", "")
-
-
-@lru_cache(maxsize=1)
-def _qdrant_available() -> bool:
- try:
- headers = {"api-key": QDRANT_API_KEY} if QDRANT_API_KEY else None
- response = httpx.get(
- f"{QDRANT_URL}/collections",
- headers=headers,
- timeout=2.0,
- )
- return response.status_code == 200
- except Exception:
- return False
-
-
-requires_qdrant = pytest.mark.qdrant
-
-
-def pytest_configure(config):
- config.addinivalue_line("markers", "qdrant: requires a reachable Qdrant instance")
-
-
[email protected](autouse=True)
-def _skip_when_qdrant_unavailable(request):
- if request.node.get_closest_marker("qdrant") is None:
- return
- if not _qdrant_available():
- pytest.skip(f"Qdrant not available at {QDRANT_URL}")
-
-
# (model_name, default_dimension, token_limit)
GEMINI_MODELS = [
("gemini-embedding-2-preview", 3072, 8192),
diff --git a/tests/integration/test_qdrant_integration.py b/tests/integration/test_qdrant_integration.py
deleted file mode 100644
index 8a23836f3..000000000
--- a/tests/integration/test_qdrant_integration.py
+++ /dev/null
@@ -1,342 +0,0 @@
-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
-# SPDX-License-Identifier: AGPL-3.0
-"""Integration tests for the Qdrant vectordb adapter.
-
-Usage:
-
- QDRANT_URL=http://127.0.0.1:6333 pytest tests/integration/test_qdrant_integration.py -v -s
-"""
-
-from __future__ import annotations
-
-import uuid
-
-import pytest
-
-from openviking.storage.expr import Contains, Eq, PathScope
-from openviking.storage.vectordb_adapters.factory import create_collection_adapter
-from openviking_cli.utils.config.vectordb_config import VectorDBBackendConfig
-from tests.integration.conftest import QDRANT_API_KEY, QDRANT_URL, requires_qdrant
-
-pytestmark = [pytest.mark.integration, requires_qdrant]
-
-
-def _build_qdrant_config(collection_name: str) -> VectorDBBackendConfig:
- return VectorDBBackendConfig.model_validate(
- {
- "backend": "qdrant",
- "project": "it",
- "name": collection_name,
- "index_name": "default",
- "distance_metric": "cosine",
- "qdrant": {
- "url": QDRANT_URL,
- "api_key": QDRANT_API_KEY or None,
- "timeout_seconds": 10,
- "dense_vector_name": "vector",
- "sparse_vector_name": "sparse_vector",
- "meta_collection_name": "__openviking_meta",
- "enable_text_index": True,
- },
- }
- )
-
-
-def _build_schema(collection_name: str) -> dict:
- return {
- "CollectionName": collection_name,
- "Description": "Qdrant integration test collection",
- "Fields": [
- {"FieldName": "id", "FieldType": "string", "IsPrimaryKey": True},
- {"FieldName": "uri", "FieldType": "path"},
- {"FieldName": "vector", "FieldType": "vector", "Dim": 4},
- {"FieldName": "sparse_vector", "FieldType": "sparse_vector"},
- {"FieldName": "created_at", "FieldType": "date_time"},
- {"FieldName": "updated_at", "FieldType": "date_time"},
- {"FieldName": "active_count", "FieldType": "int64"},
- {"FieldName": "level", "FieldType": "int64"},
- {"FieldName": "abstract", "FieldType": "string"},
- {"FieldName": "account_id", "FieldType": "string"},
- ],
- "ScalarIndex": [
- "uri",
- "updated_at",
- "active_count",
- "level",
- "account_id",
- "abstract",
- ],
- }
-
-
-def qdrant_adapter():
- collection_name = f"qdrant_it_{uuid.uuid4().hex[:8]}"
- adapter = create_collection_adapter(_build_qdrant_config(collection_name))
- try:
- yield adapter, collection_name
- finally:
- try:
- if adapter.collection_exists():
- adapter.drop_collection()
- finally:
- adapter.close()
-
-
-def test_qdrant_adapter_end_to_end(qdrant_adapter):
- adapter, collection_name = qdrant_adapter
- schema = _build_schema(collection_name)
-
- created = adapter.create_collection(
- collection_name,
- schema,
- distance="cosine",
- sparse_weight=0.0,
- index_name="default",
- )
- assert created is True
- assert adapter.physical_collection_name == f"it__{collection_name}"
- assert adapter.get_collection().list_indexes() == ["default"]
-
- records = [
- {
- "id": "doc_1",
- "uri": "viking://resources/acme/docs/a.md",
- "vector": [1.0, 0.0, 0.0, 0.0],
- "created_at": "2026-05-29T12:00:00Z",
- "updated_at": "2026-05-29T12:00:00Z",
- "active_count": 5,
- "level": 2,
- "abstract": "alpha quarterly report",
- "account_id": "acme",
- },
- {
- "id": "doc_2",
- "uri": "viking://resources/acme/docs/b.md",
- "vector": [0.9, 0.1, 0.0, 0.0],
- "created_at": "2026-05-29T12:01:00Z",
- "updated_at": "2026-05-29T12:01:00Z",
- "active_count": 3,
- "level": 2,
- "abstract": "beta design note",
- "account_id": "acme",
- },
- {
- "id": "doc_3",
- "uri": "viking://resources/beta/notes/c.md",
- "vector": [0.0, 1.0, 0.0, 0.0],
- "created_at": "2026-05-29T12:02:00Z",
- "updated_at": "2026-05-29T12:02:00Z",
- "active_count": 1,
- "level": 2,
- "abstract": "gamma meeting note",
- "account_id": "beta",
- },
- ]
-
- ids = adapter.upsert(records)
- assert len(ids) == 3
-
- fetched = adapter.get(ids[:2])
- assert len(fetched) == 2
- assert fetched[0]["uri"].startswith("viking://resources/")
- assert "parent_uri" not in fetched[0]
- assert "scope_roots" not in fetched[0]
-
- assert adapter.count() == 3
- assert adapter.count(Eq("account_id", "acme")) == 2
- assert adapter.count({"op": "must", "field": "account_id", "conds": ["beta"]}) == 1
-
- vector_hits = adapter.query(
- query_vector=[1.0, 0.0, 0.0, 0.0],
- filter=Eq("account_id", "acme"),
- limit=2,
- output_fields=["uri", "account_id", "active_count"],
- )
- assert len(vector_hits) >= 1
- assert all(item["account_id"] == "acme" for item in vector_hits)
- assert vector_hits[0]["uri"] == "viking://resources/acme/docs/a.md"
-
- id_hits = adapter.get_collection().search_by_id(
- index_name="default",
- id="doc_1",
- limit=2,
- output_fields=["uri", "account_id"],
- )
- assert id_hits.data[0].id == "doc_2"
- assert id_hits.data[0].fields["uri"] == "viking://resources/acme/docs/b.md"
-
- path_hits = adapter.query(
- filter=PathScope("uri", "viking://resources/acme/docs", depth=-1),
- limit=10,
- output_fields=["uri", "account_id"],
- )
- assert len(path_hits) == 2
- assert {item["uri"] for item in path_hits} == {
- "viking://resources/acme/docs/a.md",
- "viking://resources/acme/docs/b.md",
- }
-
- parent_hits = adapter.query(
- filter=PathScope("uri", "viking://resources/acme/docs", depth=1),
- limit=10,
- output_fields=["uri"],
- )
- assert len(parent_hits) == 2
-
- ordered = adapter.query(
- filter=Eq("account_id", "acme"),
- limit=10,
- order_by="active_count",
- order_desc=True,
- output_fields=["uri", "active_count"],
- )
- assert [item["active_count"] for item in ordered][:2] == [5, 3]
-
- meta = adapter.get_collection_info()
- assert meta["CollectionName"] == collection_name
- assert meta["Description"] == "Qdrant integration test collection"
- assert len(meta["Fields"]) == 10
-
- deleted = adapter.delete(filter=Eq("account_id", "beta"))
- assert deleted == 1
- assert adapter.count() == 2
-
-
-def test_qdrant_hybrid_dense_sparse_query(qdrant_adapter):
- adapter, collection_name = qdrant_adapter
- schema = _build_schema(collection_name)
-
- created = adapter.create_collection(
- collection_name,
- schema,
- distance="cosine",
- sparse_weight=0.5,
- index_name="default",
- )
- assert created is True
-
- records = [
- {
- "id": str(uuid.uuid4()),
- "uri": "viking://resources/acme/hybrid/doc1.md",
- "vector": [1.0, 0.0, 0.0, 0.0],
- "sparse_vector": {"alpha": 1.0, "beta": 0.5},
- "created_at": "2026-05-29T12:10:00Z",
- "updated_at": "2026-05-29T12:10:00Z",
- "active_count": 10,
- "level": 2,
- "abstract": "alpha beta anchor",
- "account_id": "acme",
- },
- {
- "id": str(uuid.uuid4()),
- "uri": "viking://resources/acme/hybrid/doc2.md",
- "vector": [0.98, 0.02, 0.0, 0.0],
- "sparse_vector": {"gamma": 1.0},
- "created_at": "2026-05-29T12:11:00Z",
- "updated_at": "2026-05-29T12:11:00Z",
- "active_count": 8,
- "level": 2,
- "abstract": "dense only neighbor",
- "account_id": "acme",
- },
- {
- "id": str(uuid.uuid4()),
- "uri": "viking://resources/acme/hybrid/doc3.md",
- "vector": [0.0, 1.0, 0.0, 0.0],
- "sparse_vector": {"alpha": 1.0},
- "created_at": "2026-05-29T12:12:00Z",
- "updated_at": "2026-05-29T12:12:00Z",
- "active_count": 6,
- "level": 2,
- "abstract": "sparse only booster",
- "account_id": "acme",
- },
- ]
- adapter.upsert(records)
-
- dense_only = adapter.query(
- query_vector=[1.0, 0.0, 0.0, 0.0],
- filter=Eq("account_id", "acme"),
- limit=2,
- output_fields=["uri"],
- )
- dense_uris = [item["uri"] for item in dense_only]
- assert dense_uris == [
- "viking://resources/acme/hybrid/doc1.md",
- "viking://resources/acme/hybrid/doc2.md",
- ]
-
- hybrid_hits = adapter.query(
- query_vector=[1.0, 0.0, 0.0, 0.0],
- sparse_query_vector={"alpha": 1.0},
- filter=Eq("account_id", "acme"),
- limit=2,
- output_fields=["uri"],
- )
- hybrid_uris = [item["uri"] for item in hybrid_hits]
-
- # doc1 should remain top because it is strong on both dense and sparse.
- assert hybrid_uris[0] == "viking://resources/acme/hybrid/doc1.md"
- # doc3 should be pulled up by sparse matching into top2.
- assert "viking://resources/acme/hybrid/doc3.md" in hybrid_uris
-
-
-def test_qdrant_contains_and_keywords_search(qdrant_adapter):
- adapter, collection_name = qdrant_adapter
- schema = _build_schema(collection_name)
-
- created = adapter.create_collection(
- collection_name,
- schema,
- distance="cosine",
- sparse_weight=0.0,
- index_name="default",
- )
- assert created is True
-
- records = [
- {
- "id": str(uuid.uuid4()),
- "uri": "viking://resources/acme/text/report.md",
- "vector": [1.0, 0.0, 0.0, 0.0],
- "created_at": "2026-05-29T12:20:00Z",
- "updated_at": "2026-05-29T12:20:00Z",
- "active_count": 2,
- "level": 2,
- "abstract": "quarterly report for product alpha",
- "account_id": "acme",
- },
- {
- "id": str(uuid.uuid4()),
- "uri": "viking://resources/acme/text/design.md",
- "vector": [0.8, 0.2, 0.0, 0.0],
- "created_at": "2026-05-29T12:21:00Z",
- "updated_at": "2026-05-29T12:21:00Z",
- "active_count": 1,
- "level": 2,
- "abstract": "design draft for project beta",
- "account_id": "acme",
- },
- ]
- ids = adapter.upsert(records)
- assert len(ids) == 2
-
- contains_hits = adapter.query(
- filter=Contains("abstract", "quarterly"),
- limit=10,
- output_fields=["uri", "abstract"],
- )
- assert len(contains_hits) == 1
- assert contains_hits[0]["uri"] == "viking://resources/acme/text/report.md"
-
- collection = adapter.get_collection()
- keyword_hits = collection.search_by_keywords(
- index_name="default",
- keywords=["quarterly"],
- limit=10,
- output_fields=["uri", "abstract"],
- )
- assert len(keyword_hits.data) >= 1
- assert keyword_hits.data[0].fields["uri"] == "viking://resources/acme/text/report.md"
diff --git a/tests/misc/test_config_validation.py b/tests/misc/test_config_validation.py
index d5bffa0f3..cd685f80f 100644
--- a/tests/misc/test_config_validation.py
+++ b/tests/misc/test_config_validation.py
@@ -878,6 +878,18 @@ def test_removed_volcengine_api_key_backend_name_is_rejected():
assert "volcengine_api_key" in str(e)
[email protected]("backend", ["qdrant", "opengauss"])
+def test_removed_third_party_vectordb_backends_are_rejected(backend):
+ with pytest.raises(ValueError) as exc_info:
+ VectorDBBackendConfig(backend=backend)
+
+ message = str(exc_info.value)
+ assert backend in message
+ assert "local" in message
+ assert "volcengine" in message
+ assert "vikingdb" in message
+
+
def test_vectordb_volcengine_api_key_auth_requires_host_or_region():
try:
VectorDBBackendConfig(
diff --git a/tests/storage/test_collection_schemas.py b/tests/storage/test_collection_schemas.py
index 56e897e82..647e05b2a 100644
--- a/tests/storage/test_collection_schemas.py
+++ b/tests/storage/test_collection_schemas.py
@@ -40,7 +40,6 @@ from openviking.storage.viking_vector_index_backend import (
_SingleAccountBackend,
)
from openviking_cli.utils.config.vectordb_config import (
- QdrantConfig,
VectorDBBackendConfig,
VolcengineConfig,
)
@@ -1960,136 +1959,6 @@ def test_storage_upsert_signatures_use_options_instead_of_partial_update():
assert "partial_update" not in signature.parameters
-async def test_qdrant_backend_upsert_partial_update_reads_then_upserts_existing_record():
- calls = []
-
- class _Collection:
- def get_meta_data(self):
- return {
- "Fields": [
- {"FieldName": "id", "FieldType": "string"},
- {"FieldName": "uri", "FieldType": "path"},
- {"FieldName": "abstract", "FieldType": "string"},
- {"FieldName": "account_id", "FieldType": "string"},
- ]
- }
-
- class _Adapter:
- mode = "qdrant"
- USE_CONTENT_FIELD = False
-
- def get(self, ids):
- calls.append(("get", ids))
- return [
- {
- "id": "doc-1",
- "uri": "viking://resources/qdrant",
- "abstract": "before",
- "account_id": "acc1",
- }
- ]
-
- def upsert(self, data):
- calls.append(("upsert", data))
- return ["doc-1"]
-
- backend = _SingleAccountBackend(
- config=VectorDBBackendConfig(
- backend="qdrant",
- name="context",
- dimension=2,
- qdrant=QdrantConfig(url="http://qdrant:6333"),
- ),
- bound_account_id="acc1",
- shared_adapter=_Adapter(),
- )
-
- result = await backend.upsert(
- {"id": "doc-1", "uri": "viking://resources/qdrant", "abstract": "patched"},
- options=UpsertOptions(partial_update=True),
- )
-
- assert result == "doc-1"
- assert calls == [
- (
- "get",
- ["doc-1"],
- ),
- (
- "upsert",
- {
- "id": "doc-1",
- "uri": "viking://resources/qdrant",
- "abstract": "patched",
- "account_id": "acc1",
- },
- ),
- ]
-
-
-async def test_qdrant_backend_upsert_partial_update_creates_when_record_does_not_exist():
- calls = []
-
- class _Collection:
- def get_meta_data(self):
- return {
- "Fields": [
- {"FieldName": "id", "FieldType": "string"},
- {"FieldName": "uri", "FieldType": "path"},
- {"FieldName": "abstract", "FieldType": "string"},
- {"FieldName": "vector", "FieldType": "vector", "Dim": 2},
- {"FieldName": "sparse_vector", "FieldType": "sparse_vector"},
- {"FieldName": "active_count", "FieldType": "int64"},
- {"FieldName": "account_id", "FieldType": "string"},
- ]
- }
-
- class _Adapter:
- mode = "qdrant"
- USE_CONTENT_FIELD = False
-
- def get(self, ids):
- calls.append(("get", ids))
- return []
-
- def upsert(self, data):
- calls.append(("upsert", data))
- return ["doc-404"]
-
- backend = _SingleAccountBackend(
- config=VectorDBBackendConfig(
- backend="qdrant",
- name="context",
- dimension=2,
- qdrant=QdrantConfig(url="http://qdrant:6333"),
- ),
- bound_account_id="acc1",
- shared_adapter=_Adapter(),
- )
-
- result = await backend.upsert(
- {"id": "doc-404", "uri": "viking://resources/qdrant/new", "abstract": "created"},
- options=UpsertOptions(partial_update=True),
- )
-
- assert result == "doc-404"
- assert calls[0] == (
- "get",
- ["doc-404"],
- )
- assert calls[1] == (
- "upsert",
- {
- "id": "doc-404",
- "uri": "viking://resources/qdrant/new",
- "abstract": "created",
- "account_id": "acc1",
- },
- )
-
-
@pytest.mark.asyncio
async def test_volcengine_backend_upsert_partial_update_reads_then_upserts_existing_record():
calls = []
diff --git a/tests/storage/test_opengauss_adapter.py b/tests/storage/test_opengauss_adapter.py
deleted file mode 100644
index 1f4d140a8..000000000
--- a/tests/storage/test_opengauss_adapter.py
+++ /dev/null
@@ -1,345 +0,0 @@
-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
-# SPDX-License-Identifier: AGPL-3.0
-
-from __future__ import annotations
-
-import os
-import uuid
-
-import pytest
-
-from openviking.storage.vectordb.collection.result import SearchResult
-from openviking.storage.vectordb_adapters.factory import create_collection_adapter
-from openviking.storage.vectordb_adapters.opengauss_adapter import (
- OpenGaussCollection,
- OpenGaussCollectionAdapter,
- _coerce_sql_value,
- _encode_scope_roots,
- _normalize_distance,
- _safe_identifier,
- _vector_literal,
-)
-from openviking_cli.utils.config.vectordb_config import VectorDBBackendConfig
-
-
-def _build_config() -> VectorDBBackendConfig:
- return VectorDBBackendConfig.model_validate(
- {
- "backend": "opengauss",
- "project": "default",
- "name": "context",
- "index_name": "default",
- "distance_metric": "cosine",
- "opengauss": {
- "host": "127.0.0.1",
- "port": 8888,
- "user": "omm",
- "password": "OpenGauss@123",
- "db_name": "postgres",
- "schema": "public",
- "mode": "standalone",
- "dense_vector_name": "vector",
- "sparse_vector_name": "sparse_vector",
- },
- }
- )
-
-
-def test_opengauss_backend_config_validation():
- config = _build_config()
-
- assert config.backend == "opengauss"
- assert config.opengauss is not None
- assert config.opengauss.host == "127.0.0.1"
- assert config.opengauss.port == 8888
- assert config.opengauss.db_name == "postgres"
- assert config.opengauss.schema_name == "public"
-
-
-def test_factory_creates_opengauss_adapter_without_connecting():
- adapter = create_collection_adapter(_build_config())
-
- assert isinstance(adapter, OpenGaussCollectionAdapter)
- assert adapter.mode == "opengauss"
- assert adapter.collection_name == "context"
- assert adapter.index_name == "default"
- assert adapter.physical_table_name == "ov_default_context"
-
-
-def test_collection_filter_to_sql_for_path_scope():
- collection = object.__new__(OpenGaussCollection)
- collection._field_types = {"updated_at": "date_time"}
-
- clause, params = collection._compile_filter(
- {
- "op": "and",
- "conds": [
- {"op": "must", "field": "scope_roots", "conds": ["/resources/acme/docs"]},
- {
- "op": "range",
- "field": "updated_at",
- "gte": "2026-05-01T00:00:00+00:00",
- "lt": "2026-06-01T00:00:00+00:00",
- },
- ],
- }
- )
-
- assert '"scope_roots" LIKE %s' in clause
- assert '"updated_at" >= %s' in clause
- assert '"updated_at" < %s' in clause
- assert params == [
- "%\n/resources/acme/docs\n%",
- "2026-05-01T00:00:00+00:00",
- "2026-06-01T00:00:00+00:00",
- ]
-
-
-def test_vector_literal_and_identifier_safety():
- assert _vector_literal([1, 2.5, float("nan")]) == "[1,2.5,0]"
-
- name = _safe_identifier("Project/With Space", "Context.Table", prefix="ov")
- assert name.startswith("ov_project_with_space_context_table")
- assert len(name.encode("utf-8")) <= 63
-
-
-def test_opengauss_distance_validation_accepts_ip_and_rejects_dot():
- assert _normalize_distance("cosine") == "cosine"
- assert _normalize_distance("l2") == "l2"
- assert _normalize_distance("ip") == "ip"
-
- with pytest.raises(ValueError, match="supports only cosine, l2, and ip"):
- _normalize_distance("dot")
-
- with pytest.raises(ValueError, match="supports only cosine, l2, and ip"):
- _normalize_distance("euclid")
-
-
-def test_distance_to_score_handles_inner_product_distance():
- assert OpenGaussCollection._distance_to_score(-0.75, "ip") == 0.75
- assert OpenGaussCollection._distance_to_score(0.25, "l2") == 0.8
-
-
-def test_scope_roots_encoding_is_token_safe():
- encoded = _encode_scope_roots(["/a", "/a/b"])
-
- assert encoded == "\n/a\n/a/b\n"
- assert "\n/a\n" in encoded
- assert "\n/a/b\n" in encoded
- assert "\n/a/c\n" not in encoded
-
-
-def test_bool_coercion_parses_string_values():
- assert _coerce_sql_value(True, "bool") is True
- assert _coerce_sql_value(False, "bool") is False
- assert _coerce_sql_value("true", "bool") is True
- assert _coerce_sql_value("1", "bool") is True
- assert _coerce_sql_value("false", "bool") is False
- assert _coerce_sql_value("0", "bool") is False
- assert _coerce_sql_value("unknown", "bool") is None
-
-
-def test_drop_index_removes_vector_and_scalar_indexes():
- collection = object.__new__(OpenGaussCollection)
- collection._schema_name = "public"
- collection._table_name = "ov_test"
- statements = []
-
- collection.get_index_meta_data = lambda index_name: {
- "IndexName": index_name,
- "ScalarIndex": ["uri", "account_id"],
- }
- collection._delete_index_meta = lambda index_name: statements.append(
- ("delete_meta", index_name)
- )
- collection._execute = lambda sql, params=None, fetch=False: statements.append(sql)
-
- collection.drop_index("default")
-
- assert 'DROP INDEX IF EXISTS "public"."idx_ov_test_default_vec"' in statements
- assert 'DROP INDEX IF EXISTS "public"."idx_ov_test_default_uri"' in statements
- assert 'DROP INDEX IF EXISTS "public"."idx_ov_test_default_account_id"' in statements
- assert ("delete_meta", "default") in statements
-
-
-def test_vector_index_creation_uses_hnsw_only():
- collection = object.__new__(OpenGaussCollection)
- collection._schema_name = "public"
- collection._table_name = "ov_test"
- collection._dense_vector_name = "vector"
- statements = []
-
- collection._table_ref = lambda: '"public"."ov_test"'
- collection._all_columns = lambda: ["id", "vector"]
- collection._execute = lambda sql, params=None, fetch=False: statements.append(sql)
-
- collection._create_vector_index(
- "default",
- "cosine",
- {"VectorIndex": {"IndexType": "flat", "Distance": "cosine"}},
- )
-
- sql = "\n".join(statements).lower()
- assert "using hnsw" in sql
- assert "vector_cosine_ops" in sql
-
-
-def test_create_index_normalizes_metadata_to_hnsw():
- collection = object.__new__(OpenGaussCollection)
- saved = {}
-
- collection._create_vector_index = lambda index_name, distance, meta: saved.setdefault(
- "vector_meta", meta
- )
- collection._create_scalar_index = lambda index_name, field_name: None
- collection._save_index_meta = lambda index_name, meta: saved.setdefault("saved_meta", meta)
-
- collection.create_index(
- "default",
- {
- "IndexName": "default",
- "VectorIndex": {"IndexType": "flat", "Distance": "cosine"},
- "ScalarIndex": ["uri"],
- },
- )
-
- assert saved["vector_meta"]["VectorIndex"]["IndexType"] == "hnsw"
- assert saved["saved_meta"]["VectorIndex"]["IndexType"] == "hnsw"
-
-
-def test_create_index_does_not_save_metadata_when_vector_index_fails():
- collection = object.__new__(OpenGaussCollection)
- saved = {}
-
- def fail_vector_index(index_name, distance, meta):
- raise RuntimeError("boom")
-
- collection._create_vector_index = fail_vector_index
- collection._create_scalar_index = lambda index_name, field_name: saved.setdefault(
- "scalar", field_name
- )
- collection._save_index_meta = lambda index_name, meta: saved.setdefault("saved_meta", meta)
-
- with pytest.raises(RuntimeError, match="boom"):
- collection.create_index(
- "default",
- {
- "IndexName": "default",
- "VectorIndex": {"IndexType": "flat", "Distance": "cosine"},
- "ScalarIndex": ["uri"],
- },
- )
-
- assert saved == {}
-
-
-def test_vector_search_binds_vector_before_filter_params():
- collection = object.__new__(OpenGaussCollection)
- collection._dense_vector_name = "vector"
- collection._distance_metric = "cosine"
- collection._select_columns = lambda output_fields, include_sparse=False: ["id"]
- collection._where_sql = lambda filters: (' WHERE "scope_roots" LIKE %s', ["%\n/a\n%"])
- collection._table_ref = lambda: '"public"."ov_test"'
- captured = {}
-
- def execute(sql, params=None, *, fetch=False):
- captured["sql"] = sql
- captured["params"] = params
- captured["fetch"] = fetch
- return []
-
- collection._execute = execute
-
- collection.search_by_vector(
- "default",
- dense_vector=[0.1, 0.2],
- filters={"op": "must", "field": "scope_roots", "conds": ["/a"]},
- )
-
- assert captured["fetch"] is True
- assert captured["params"] == ["[0.1,0.2]", "%\n/a\n%", "[0.1,0.2]", 10, 0]
-
-
- not os.getenv("OPENVIKING_OPENGAUSS_HOST"),
- reason="set OPENVIKING_OPENGAUSS_HOST to run openGauss integration smoke test",
-)
-def test_opengauss_adapter_integration_smoke():
- suffix = uuid.uuid4().hex[:8]
- adapter = OpenGaussCollectionAdapter(
- host=os.environ["OPENVIKING_OPENGAUSS_HOST"],
- port=int(os.getenv("OPENVIKING_OPENGAUSS_PORT", "5432")),
- user=os.getenv("OPENVIKING_OPENGAUSS_USER", "omm"),
- password=os.getenv("OPENVIKING_OPENGAUSS_PASSWORD", ""),
- db_name=os.getenv("OPENVIKING_OPENGAUSS_DB", "postgres"),
- schema_name=os.getenv("OPENVIKING_OPENGAUSS_SCHEMA", "public"),
- project_name=f"pytest_{suffix}",
- collection_name="context",
- index_name="default",
- distance_metric="cosine",
- dense_vector_name="vector",
- sparse_vector_name="sparse_vector",
- connect_timeout=10,
- mode=os.getenv("OPENVIKING_OPENGAUSS_MODE", "standalone"),
- shard_count=4,
- )
- meta = {
- "CollectionName": "context",
- "Fields": [
- {"FieldName": "id", "FieldType": "string", "IsPrimaryKey": True},
- {"FieldName": "uri", "FieldType": "path"},
- {"FieldName": "vector", "FieldType": "vector", "Dim": 2},
- {"FieldName": "sparse_vector", "FieldType": "sparse_vector"},
- {"FieldName": "abstract", "FieldType": "string"},
- ],
- }
-
- collection = adapter._new_collection(meta)
- try:
- collection.create_remote_collection(meta)
- collection.create_index(
- "default",
- {
- "IndexName": "default",
- "VectorIndex": {"IndexType": "hnsw", "Distance": "cosine"},
- "ScalarIndex": ["uri", "parent_uri", "scope_roots"],
- },
- )
- collection.upsert_data(
- [
- adapter._normalize_record_for_write(
- {
- "id": "doc-1",
- "uri": "viking://resources/acme/docs/a.md",
- "vector": [0.1, 0.2],
- "sparse_vector": {"quarter": 1.0},
- "abstract": "quarterly report",
- }
- ),
- adapter._normalize_record_for_write(
- {
- "id": "doc-2",
- "uri": "viking://resources/acme/notes/b.md",
- "vector": [0.2, 0.1],
- "sparse_vector": {"notes": 1.0},
- "abstract": "meeting notes",
- }
- ),
- ]
- )
-
- result = collection.search_by_vector(
- "default",
- dense_vector=[0.1, 0.2],
- sparse_vector={"quarter": 1.0},
- limit=1,
- filters={"op": "must", "field": "scope_roots", "conds": ["/resources/acme/docs"]},
- )
- count = collection.aggregate_data("default")
-
- assert isinstance(result, SearchResult)
- assert [item.id for item in result.data] == ["doc-1"]
- assert count.agg["_total"] == 2
- finally:
- collection.drop()
- adapter.close()
diff --git a/tests/storage/test_qdrant_adapter.py b/tests/storage/test_qdrant_adapter.py
deleted file mode 100644
index 0ee35af03..000000000
--- a/tests/storage/test_qdrant_adapter.py
+++ /dev/null
@@ -1,70 +0,0 @@
-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
-# SPDX-License-Identifier: AGPL-3.0
-
-
-import pytest
-
-from openviking.storage.vectordb_adapters.factory import create_collection_adapter
-from openviking.storage.vectordb_adapters.qdrant_adapter import QdrantCollectionAdapter
-from openviking_cli.utils.config.vectordb_config import VectorDBBackendConfig
-
-
-def _build_config() -> VectorDBBackendConfig:
- return VectorDBBackendConfig.model_validate(
- {
- "backend": "qdrant",
- "project": "default",
- "name": "context",
- "index_name": "default",
- "distance_metric": "cosine",
- "qdrant": {
- "url": "http://qdrant:6333/",
- "api_key": "test-key",
- "timeout_seconds": 7,
- "dense_vector_name": "vector",
- "sparse_vector_name": "sparse_vector",
- "meta_collection_name": "__openviking_meta",
- "enable_text_index": True,
- },
- }
- )
-
-
-def test_qdrant_backend_config_validation():
- config = _build_config()
- assert config.backend == "qdrant"
- assert config.qdrant is not None
- assert config.qdrant.url == "http://qdrant:6333"
-
-
-def test_factory_creates_qdrant_adapter():
- adapter = create_collection_adapter(_build_config())
- assert isinstance(adapter, QdrantCollectionAdapter)
- assert adapter.mode == "qdrant"
- assert adapter.collection_name == "context"
- assert adapter.index_name == "default"
- assert adapter.physical_collection_name == "default__context"
-
-
-def test_existing_physical_collection_without_metadata_is_rejected_and_closed(monkeypatch):
- class FakeQdrantCollection:
- def __init__(self) -> None:
- self.closed = False
-
- def collection_exists(self) -> bool:
- return True
-
- def has_openviking_metadata(self) -> bool:
- return False
-
- def close(self) -> None:
- self.closed = True
-
- candidate = FakeQdrantCollection()
- adapter = QdrantCollectionAdapter.from_config(_build_config())
- monkeypatch.setattr(adapter, "_new_qdrant_collection", lambda: candidate)
-
- with pytest.raises(RuntimeError, match="OpenViking metadata is missing"):
- adapter.collection_exists()
-
- assert candidate.closed is True
diff --git a/tests/storage/test_qdrant_collection.py b/tests/storage/test_qdrant_collection.py
deleted file mode 100644
index 69a156eed..000000000
--- a/tests/storage/test_qdrant_collection.py
+++ /dev/null
@@ -1,306 +0,0 @@
-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
-# SPDX-License-Identifier: AGPL-3.0
-
-from __future__ import annotations
-
-from typing import Any, Dict, List
-
-import pytest
-
-import openviking.storage.vectordb.collection.qdrant_collection as qdrant_collection_module
-from openviking.storage.vectordb.collection.qdrant_collection import (
- ORIGINAL_ID_FIELD,
- QdrantCollection,
- _sparse_to_qdrant,
- _to_qdrant_point_id,
-)
-from openviking.storage.vectordb.collection.qdrant_rest import QdrantRestError
-
-
-class _StubClient:
- def __init__(self, responses: List[Any]) -> None:
- self._responses = list(responses)
- self.calls: List[Dict[str, Any]] = []
-
- def request(self, method: str, path: str, **kwargs: Any) -> Dict[str, Any]:
- self.calls.append({"method": method, "path": path, **kwargs})
- if not self._responses:
- raise AssertionError("No more stubbed Qdrant responses available")
- response = self._responses.pop(0)
- if isinstance(response, Exception):
- raise response
- return response
-
-
-def _build_collection_stub(client: _StubClient) -> QdrantCollection:
- collection = object.__new__(QdrantCollection)
- collection._client = client
- collection._physical_collection_name = "proj__context"
- collection._dense_vector_name = "vector"
- collection._sparse_vector_name = "sparse_vector"
- collection._vector_dim = 3
- collection._path_payload_fields = {"parent_uri", "scope_roots"}
- return collection
-
-
-class _FailingMetaStore:
- def save_collection_meta(self, **_: Any) -> None:
- raise RuntimeError("metadata write failed")
-
-
-class _RecordingMetaStore:
- def __init__(self) -> None:
- self.deleted_keys: List[str] = []
-
- def delete_collection_meta(self, *, collection_key: str) -> None:
- self.deleted_keys.append(collection_key)
-
-
-def test_sparse_to_qdrant_warns_on_hash_collision(monkeypatch, caplog):
- monkeypatch.setattr(
- qdrant_collection_module,
- "_hash_sparse_term",
- lambda term: 7 if term in {"alpha", "beta"} else 9,
- )
-
- payload = _sparse_to_qdrant({"alpha": 1.0, "beta": 2.5, "gamma": 4.0})
-
- assert payload == {"indices": [7, 9], "values": [3.5, 4.0]}
- assert "hash collision detected" in caplog.text
-
-
-def test_scroll_points_stops_on_repeated_next_page_offset(caplog):
- client = _StubClient(
- [
- {"result": {"points": [{"id": "p1"}], "next_page_offset": "repeat-me"}},
- {"result": {"points": [{"id": "p2"}], "next_page_offset": "repeat-me"}},
- ]
- )
- collection = _build_collection_stub(client)
-
- points = collection._scroll_points(limit=None)
-
- assert [point["id"] for point in points] == ["p1", "p2"]
- assert "next_page_offset repeated" in caplog.text
-
-
-def test_delete_all_data_prefers_filter_delete():
- client = _StubClient([{"status": "ok", "result": {}}])
- collection = _build_collection_stub(client)
- collection._scan_points_with_warning = lambda **_: (_ for _ in ()).throw(
- AssertionError("fallback scan should not be used")
- )
- collection._delete_points = lambda _: (_ for _ in ()).throw(
- AssertionError("batched delete should not be used")
- )
-
- collection.delete_all_data()
-
- assert len(client.calls) == 1
- call = client.calls[0]
- assert call["method"] == "POST"
- assert call["path"] == "/collections/proj__context/points/delete"
- assert call["json_body"] == {"filter": {}}
- assert call["params"] == {"wait": "true"}
-
-
-def test_delete_all_data_falls_back_to_batched_delete(caplog):
- client = _StubClient([QdrantRestError("delete failed")])
- collection = _build_collection_stub(client)
- collection._scan_points_with_warning = lambda **_: [
- {"id": str(i)} for i in range(QdrantCollection.DEFAULT_DELETE_BATCH_SIZE * 2 + 5)
- ]
-
- deleted_batches: List[List[str]] = []
- collection._delete_points = lambda ids: deleted_batches.append(list(ids))
-
- collection.delete_all_data()
-
- assert [len(batch) for batch in deleted_batches] == [
- QdrantCollection.DEFAULT_DELETE_BATCH_SIZE,
- QdrantCollection.DEFAULT_DELETE_BATCH_SIZE,
- 5,
- ]
- assert "Falling back to batched delete_all_data" in caplog.text
-
-
-def test_make_point_accepts_zero_id():
- collection = _build_collection_stub(_StubClient([]))
-
- point = collection._make_point({"id": 0, "vector": [0.1, 0.2, 0.3], "name": "zero"})
-
- assert point["id"] == 0
- assert point["vector"]["vector"] == [0.1, 0.2, 0.3]
- assert point["payload"]["name"] == "zero"
- assert point["payload"][ORIGINAL_ID_FIELD] == 0
-
-
-def test_make_point_maps_arbitrary_string_id_and_preserves_original_id():
- collection = _build_collection_stub(_StubClient([]))
-
- point = collection._make_point({"id": "doc_1", "vector": [0.1, 0.2, 0.3]})
-
- assert point["id"] == _to_qdrant_point_id("doc_1")
- assert point["id"] != "doc_1"
- assert point["payload"][ORIGINAL_ID_FIELD] == "doc_1"
-
-
-def test_make_point_rejects_missing_vector():
- collection = _build_collection_stub(_StubClient([]))
-
- with pytest.raises(ValueError, match="requires at least one dense or sparse vector"):
- collection._make_point({"id": "doc_1", "name": "missing vector"})
-
-
-def test_create_remote_collection_rolls_back_when_metadata_write_fails():
- client = _StubClient([{"status": "ok"}, {"status": "ok"}])
- collection = _build_collection_stub(client)
- collection._logical_collection_name = "context"
- collection._project_name = "proj"
- collection._distance_metric = "cosine"
- collection._meta_store = _FailingMetaStore()
-
- with pytest.raises(RuntimeError, match="metadata write failed"):
- collection.create_remote_collection(
- {
- "Fields": [
- {"FieldName": "id", "FieldType": "string"},
- {"FieldName": "vector", "FieldType": "vector", "Dim": 3},
- ]
- }
- )
-
- assert client.calls[0]["method"] == "PUT"
- assert client.calls[0]["path"] == "/collections/proj__context"
- assert client.calls[1]["method"] == "DELETE"
- assert client.calls[1]["path"] == "/collections/proj__context"
- assert client.calls[1]["expected_statuses"] == (200, 202, 404)
-
-
-def test_drop_tolerates_missing_physical_collection_and_deletes_metadata():
- client = _StubClient([{"status": "ok"}])
- collection = _build_collection_stub(client)
- meta_store = _RecordingMetaStore()
- collection._meta_store = meta_store
-
- collection.drop()
-
- assert client.calls[0]["method"] == "DELETE"
- assert client.calls[0]["expected_statuses"] == (200, 202, 404)
- assert meta_store.deleted_keys == ["proj__context"]
-
-
-def test_fetch_data_maps_ids_and_returns_original_ids():
- point_id = _to_qdrant_point_id("doc_1")
- client = _StubClient(
- [
- {
- "result": [
- {
- "id": point_id,
- "payload": {ORIGINAL_ID_FIELD: "doc_1", "name": "Document"},
- }
- ]
- }
- ]
- )
- collection = _build_collection_stub(client)
-
- result = collection.fetch_data(["doc_1", "doc_2"])
-
- assert client.calls[0]["json_body"]["ids"] == [point_id, _to_qdrant_point_id("doc_2")]
- assert result.items[0].id == "doc_1"
- assert result.items[0].fields == {"name": "Document"}
- assert result.ids_not_exist == ["doc_2"]
-
-
-def test_update_data_preserves_omitted_fields_and_overwrites_explicit_fields():
- point_id = _to_qdrant_point_id("doc_1")
- client = _StubClient(
- [
- {
- "result": [
- {
- "id": point_id,
- "payload": {
- ORIGINAL_ID_FIELD: "doc_1",
- "name": "Before",
- "status": "active",
- },
- "vector": {"vector": [0.1, 0.2, 0.3]},
- }
- ]
- },
- {"status": "ok"},
- ]
- )
- collection = _build_collection_stub(client)
-
- updated_ids = collection.update_data([{"id": "doc_1", "name": "After"}])
-
- assert updated_ids == ["doc_1"]
- assert client.calls[0]["method"] == "POST"
- assert client.calls[0]["path"] == "/collections/proj__context/points"
- assert client.calls[0]["json_body"]["ids"] == [point_id]
- assert client.calls[0]["json_body"]["with_vector"] is True
-
- assert client.calls[1]["method"] == "PUT"
- assert client.calls[1]["path"] == "/collections/proj__context/points"
- point = client.calls[1]["json_body"]["points"][0]
- assert point["id"] == point_id
- assert point["vector"]["vector"] == [0.1, 0.2, 0.3]
- assert point["payload"] == {
- ORIGINAL_ID_FIELD: "doc_1",
- "name": "After",
- "status": "active",
- }
-
-
-def test_update_data_requires_existing_record():
- client = _StubClient([{"result": []}])
- collection = _build_collection_stub(client)
-
- with pytest.raises(ValueError, match="Qdrant point does not exist for update: doc_404"):
- collection.update_data([{"id": "doc_404", "name": "After"}])
-
-
-def test_search_by_id_uses_stored_vector_for_similarity_query():
- point_id = _to_qdrant_point_id("doc_1")
- client = _StubClient(
- [
- {
- "result": [
- {
- "id": point_id,
- "payload": {ORIGINAL_ID_FIELD: "doc_1"},
- "vector": {"vector": [0.1, 0.2, 0.3]},
- }
- ]
- },
- {
- "result": {
- "points": [
- {
- "id": point_id,
- "payload": {ORIGINAL_ID_FIELD: "doc_1"},
- "score": 1.0,
- },
- {
- "id": _to_qdrant_point_id("doc_2"),
- "payload": {ORIGINAL_ID_FIELD: "doc_2", "name": "Document 2"},
- "score": 0.9,
- },
- ]
- }
- },
- ]
- )
- collection = _build_collection_stub(client)
-
- result = collection.search_by_id("default", "doc_1", limit=10)
-
- assert client.calls[0]["json_body"]["with_vector"] is True
- assert client.calls[1]["path"] == "/collections/proj__context/points/query"
- assert client.calls[1]["json_body"]["query"] == [0.1, 0.2, 0.3]
- assert result.data[0].id == "doc_2"
- assert result.data[0].fields == {"name": "Document 2"}
diff --git a/tests/storage/test_qdrant_meta_store.py b/tests/storage/test_qdrant_meta_store.py
deleted file mode 100644
index 4b00bbf6e..000000000
--- a/tests/storage/test_qdrant_meta_store.py
+++ /dev/null
@@ -1,62 +0,0 @@
-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
-# SPDX-License-Identifier: AGPL-3.0
-
-from __future__ import annotations
-
-from typing import Any, Dict, List
-
-from openviking.storage.vectordb.collection.qdrant_meta_store import QdrantMetaStore
-from openviking.storage.vectordb.collection.qdrant_rest import QdrantRestError
-
-
-class _StubClient:
- def __init__(self, responses: List[Any]) -> None:
- self._responses = list(responses)
- self.calls: List[Dict[str, Any]] = []
-
- def collection_exists(self, name: str) -> bool:
- self.calls.append({"method": "COLLECTION_EXISTS", "name": name})
- return True
-
- def request(self, method: str, path: str, **kwargs: Any) -> Dict[str, Any]:
- self.calls.append({"method": method, "path": path, **kwargs})
- if not self._responses:
- raise AssertionError("No more stubbed Qdrant responses available")
- response = self._responses.pop(0)
- if isinstance(response, Exception):
- raise response
- return response
-
-
-def test_scroll_index_docs_paginates_until_exhausted():
- client = _StubClient(
- [
- {"result": {"points": [{"id": "idx-1"}], "next_page_offset": "page-2"}},
- {"result": {"points": [{"id": "idx-2"}], "next_page_offset": None}},
- ]
- )
- store = QdrantMetaStore(client=client, meta_collection_name="__meta")
-
- docs = store._scroll_index_docs("proj__context")
-
- assert [doc["id"] for doc in docs] == ["idx-1", "idx-2"]
- assert client.calls[2]["json_body"]["offset"] == "page-2"
-
-
-def test_get_point_returns_none_for_missing_meta_collection():
- client = _StubClient([QdrantRestError("missing", status_code=404)])
- store = QdrantMetaStore(client=client, meta_collection_name="__meta")
-
- assert store._get_point("missing") is None
-
-
-def test_get_point_reraises_non_missing_qdrant_errors():
- client = _StubClient([QdrantRestError("auth failed", status_code=401)])
- store = QdrantMetaStore(client=client, meta_collection_name="__meta")
-
- try:
- store._get_point("meta-id")
- except QdrantRestError as exc:
- assert exc.status_code == 401
- else:
- raise AssertionError("Expected QdrantRestError to be reraised")
diff --git a/uv.lock b/uv.lock
index e1f10739d..3cfb2dba9 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1636,6 +1636,7 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/38/3f/9859f655d11901e7b2996c6e3d33e0caa9a1d4572c3bc61ed0faa64b2f4c/greenlet-3.3.2-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:9bc885b89709d901859cf95179ec9f6bb67a3d2bb1f0e88456461bd4b7f8fd0d", size = 277747, upload-time = "2026-02-20T20:16:21.325Z" },
{ url = "https://files.pythonhosted.org/packages/fb/07/cb284a8b5c6498dbd7cba35d31380bb123d7dceaa7907f606c8ff5993cbf/greenlet-3.3.2-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b568183cf65b94919be4438dc28416b234b678c608cafac8874dfeeb2a9bbe13", size = 579202, upload-time = "2026-02-20T20:47:28.955Z" },
{ url = "https://files.pythonhosted.org/packages/ed/45/67922992b3a152f726163b19f890a85129a992f39607a2a53155de3448b8/greenlet-3.3.2-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:527fec58dc9f90efd594b9b700662ed3fb2493c2122067ac9c740d98080a620e", size = 590620, upload-time = "2026-02-20T20:55:55.581Z" },
+ { url = "https://files.pythonhosted.org/packages/03/5f/6e2a7d80c353587751ef3d44bb947f0565ec008a2e0927821c007e96d3a7/greenlet-3.3.2-cp310-cp310-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:508c7f01f1791fbc8e011bd508f6794cb95397fdb198a46cb6635eb5b78d85a7", size = 602132, upload-time = "2026-02-20T21:02:43.261Z" },
{ url = "https://files.pythonhosted.org/packages/ad/55/9f1ebb5a825215fadcc0f7d5073f6e79e3007e3282b14b22d6aba7ca6cb8/greenlet-3.3.2-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ad0c8917dd42a819fe77e6bdfcb84e3379c0de956469301d9fd36427a1ca501f", size = 591729, upload-time = "2026-02-20T20:20:58.395Z" },
{ url = "https://files.pythonhosted.org/packages/24/b4/21f5455773d37f94b866eb3cf5caed88d6cea6dd2c6e1f9c34f463cba3ec/greenlet-3.3.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:97245cc10e5515dbc8c3104b2928f7f02b6813002770cfaffaf9a6e0fc2b94ef", size = 1551946, upload-time = "2026-02-20T20:49:31.102Z" },
{ url = "https://files.pythonhosted.org/packages/00/68/91f061a926abead128fe1a87f0b453ccf07368666bd59ffa46016627a930/greenlet-3.3.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8c1fdd7d1b309ff0da81d60a9688a8bd044ac4e18b250320a96fc68d31c209ca", size = 1618494, upload-time = "2026-02-20T20:21:06.541Z" },
@@ -1643,6 +1644,7 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/f3/47/16400cb42d18d7a6bb46f0626852c1718612e35dcb0dffa16bbaffdf5dd2/greenlet-3.3.2-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:c56692189a7d1c7606cb794be0a8381470d95c57ce5be03fb3d0ef57c7853b86", size = 278890, upload-time = "2026-02-20T20:19:39.263Z" },
{ url = "https://files.pythonhosted.org/packages/a3/90/42762b77a5b6aa96cd8c0e80612663d39211e8ae8a6cd47c7f1249a66262/greenlet-3.3.2-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ebd458fa8285960f382841da585e02201b53a5ec2bac6b156fc623b5ce4499f", size = 581120, upload-time = "2026-02-20T20:47:30.161Z" },
{ url = "https://files.pythonhosted.org/packages/bf/6f/f3d64f4fa0a9c7b5c5b3c810ff1df614540d5aa7d519261b53fba55d4df9/greenlet-3.3.2-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a443358b33c4ec7b05b79a7c8b466f5d275025e750298be7340f8fc63dff2a55", size = 594363, upload-time = "2026-02-20T20:55:56.965Z" },
+ { url = "https://files.pythonhosted.org/packages/9c/8b/1430a04657735a3f23116c2e0d5eb10220928846e4537a938a41b350bed6/greenlet-3.3.2-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4375a58e49522698d3e70cc0b801c19433021b5c37686f7ce9c65b0d5c8677d2", size = 605046, upload-time = "2026-02-20T21:02:45.234Z" },
{ url = "https://files.pythonhosted.org/packages/72/83/3e06a52aca8128bdd4dcd67e932b809e76a96ab8c232a8b025b2850264c5/greenlet-3.3.2-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e2cd90d413acbf5e77ae41e5d3c9b3ac1d011a756d7284d7f3f2b806bbd6358", size = 594156, upload-time = "2026-02-20T20:20:59.955Z" },
{ url = "https://files.pythonhosted.org/packages/70/79/0de5e62b873e08fe3cef7dbe84e5c4bc0e8ed0c7ff131bccb8405cd107c8/greenlet-3.3.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:442b6057453c8cb29b4fb36a2ac689382fc71112273726e2423f7f17dc73bf99", size = 1554649, upload-time = "2026-02-20T20:49:32.293Z" },
{ url = "https://files.pythonhosted.org/packages/5a/00/32d30dee8389dc36d42170a9c66217757289e2afb0de59a3565260f38373/greenlet-3.3.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:45abe8eb6339518180d5a7fa47fa01945414d7cca5ecb745346fc6a87d2750be", size = 1619472, upload-time = "2026-02-20T20:21:07.966Z" },
@@ -1651,6 +1653,7 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/ea/ab/1608e5a7578e62113506740b88066bf09888322a311cff602105e619bd87/greenlet-3.3.2-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:ac8d61d4343b799d1e526db579833d72f23759c71e07181c2d2944e429eb09cd", size = 280358, upload-time = "2026-02-20T20:17:43.971Z" },
{ url = "https://files.pythonhosted.org/packages/a5/23/0eae412a4ade4e6623ff7626e38998cb9b11e9ff1ebacaa021e4e108ec15/greenlet-3.3.2-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3ceec72030dae6ac0c8ed7591b96b70410a8be370b6a477b1dbc072856ad02bd", size = 601217, upload-time = "2026-02-20T20:47:31.462Z" },
{ url = "https://files.pythonhosted.org/packages/f8/16/5b1678a9c07098ecb9ab2dd159fafaf12e963293e61ee8d10ecb55273e5e/greenlet-3.3.2-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a2a5be83a45ce6188c045bcc44b0ee037d6a518978de9a5d97438548b953a1ac", size = 611792, upload-time = "2026-02-20T20:55:58.423Z" },
+ { url = "https://files.pythonhosted.org/packages/5c/c5/cc09412a29e43406eba18d61c70baa936e299bc27e074e2be3806ed29098/greenlet-3.3.2-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ae9e21c84035c490506c17002f5c8ab25f980205c3e61ddb3a2a2a2e6c411fcb", size = 626250, upload-time = "2026-02-20T21:02:46.596Z" },
{ url = "https://files.pythonhosted.org/packages/50/1f/5155f55bd71cabd03765a4aac9ac446be129895271f73872c36ebd4b04b6/greenlet-3.3.2-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43e99d1749147ac21dde49b99c9abffcbc1e2d55c67501465ef0930d6e78e070", size = 613875, upload-time = "2026-02-20T20:21:01.102Z" },
{ url = "https://files.pythonhosted.org/packages/fc/dd/845f249c3fcd69e32df80cdab059b4be8b766ef5830a3d0aa9d6cad55beb/greenlet-3.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4c956a19350e2c37f2c48b336a3afb4bff120b36076d9d7fb68cb44e05d95b79", size = 1571467, upload-time = "2026-02-20T20:49:33.495Z" },
{ url = "https://files.pythonhosted.org/packages/2a/50/2649fe21fcc2b56659a452868e695634722a6655ba245d9f77f5656010bf/greenlet-3.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6c6f8ba97d17a1e7d664151284cb3315fc5f8353e75221ed4324f84eb162b395", size = 1640001, upload-time = "2026-02-20T20:21:09.154Z" },
@@ -1659,6 +1662,7 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/ac/48/f8b875fa7dea7dd9b33245e37f065af59df6a25af2f9561efa8d822fde51/greenlet-3.3.2-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:aa6ac98bdfd716a749b84d4034486863fd81c3abde9aa3cf8eff9127981a4ae4", size = 279120, upload-time = "2026-02-20T20:19:01.9Z" },
{ url = "https://files.pythonhosted.org/packages/49/8d/9771d03e7a8b1ee456511961e1b97a6d77ae1dea4a34a5b98eee706689d3/greenlet-3.3.2-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ab0c7e7901a00bc0a7284907273dc165b32e0d109a6713babd04471327ff7986", size = 603238, upload-time = "2026-02-20T20:47:32.873Z" },
{ url = "https://files.pythonhosted.org/packages/59/0e/4223c2bbb63cd5c97f28ffb2a8aee71bdfb30b323c35d409450f51b91e3e/greenlet-3.3.2-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d248d8c23c67d2291ffd47af766e2a3aa9fa1c6703155c099feb11f526c63a92", size = 614219, upload-time = "2026-02-20T20:55:59.817Z" },
+ { url = "https://files.pythonhosted.org/packages/94/2b/4d012a69759ac9d77210b8bfb128bc621125f5b20fc398bce3940d036b1c/greenlet-3.3.2-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ccd21bb86944ca9be6d967cf7691e658e43417782bce90b5d2faeda0ff78a7dd", size = 628268, upload-time = "2026-02-20T21:02:48.024Z" },
{ url = "https://files.pythonhosted.org/packages/7a/34/259b28ea7a2a0c904b11cd36c79b8cef8019b26ee5dbe24e73b469dea347/greenlet-3.3.2-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b6997d360a4e6a4e936c0f9625b1c20416b8a0ea18a8e19cabbefc712e7397ab", size = 616774, upload-time = "2026-02-20T20:21:02.454Z" },
{ url = "https://files.pythonhosted.org/packages/0a/03/996c2d1689d486a6e199cb0f1cf9e4aa940c500e01bdf201299d7d61fa69/greenlet-3.3.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:64970c33a50551c7c50491671265d8954046cb6e8e2999aacdd60e439b70418a", size = 1571277, upload-time = "2026-02-20T20:49:34.795Z" },
{ url = "https://files.pythonhosted.org/packages/d9/c4/2570fc07f34a39f2caf0bf9f24b0a1a0a47bc2e8e465b2c2424821389dfc/greenlet-3.3.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1a9172f5bf6bd88e6ba5a84e0a68afeac9dc7b6b412b245dd64f52d83c81e55b", size = 1640455, upload-time = "2026-02-20T20:21:10.261Z" },
@@ -1667,6 +1671,7 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/3f/ae/8bffcbd373b57a5992cd077cbe8858fff39110480a9d50697091faea6f39/greenlet-3.3.2-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:8d1658d7291f9859beed69a776c10822a0a799bc4bfe1bd4272bb60e62507dab", size = 279650, upload-time = "2026-02-20T20:18:00.783Z" },
{ url = "https://files.pythonhosted.org/packages/d1/c0/45f93f348fa49abf32ac8439938726c480bd96b2a3c6f4d949ec0124b69f/greenlet-3.3.2-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:18cb1b7337bca281915b3c5d5ae19f4e76d35e1df80f4ad3c1a7be91fadf1082", size = 650295, upload-time = "2026-02-20T20:47:34.036Z" },
{ url = "https://files.pythonhosted.org/packages/b3/de/dd7589b3f2b8372069ab3e4763ea5329940fc7ad9dcd3e272a37516d7c9b/greenlet-3.3.2-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c2e47408e8ce1c6f1ceea0dffcdf6ebb85cc09e55c7af407c99f1112016e45e9", size = 662163, upload-time = "2026-02-20T20:56:01.295Z" },
+ { url = "https://files.pythonhosted.org/packages/cd/ac/85804f74f1ccea31ba518dcc8ee6f14c79f73fe36fa1beba38930806df09/greenlet-3.3.2-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e3cb43ce200f59483eb82949bf1835a99cf43d7571e900d7c8d5c62cdf25d2f9", size = 675371, upload-time = "2026-02-20T21:02:49.664Z" },
{ url = "https://files.pythonhosted.org/packages/d2/d8/09bfa816572a4d83bccd6750df1926f79158b1c36c5f73786e26dbe4ee38/greenlet-3.3.2-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:63d10328839d1973e5ba35e98cccbca71b232b14051fd957b6f8b6e8e80d0506", size = 664160, upload-time = "2026-02-20T20:21:04.015Z" },
{ url = "https://files.pythonhosted.org/packages/48/cf/56832f0c8255d27f6c35d41b5ec91168d74ec721d85f01a12131eec6b93c/greenlet-3.3.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8e4ab3cfb02993c8cc248ea73d7dae6cec0253e9afa311c9b37e603ca9fad2ce", size = 1619181, upload-time = "2026-02-20T20:49:36.052Z" },
{ url = "https://files.pythonhosted.org/packages/0a/23/b90b60a4aabb4cec0796e55f25ffbfb579a907c3898cd2905c8918acaa16/greenlet-3.3.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94ad81f0fd3c0c0681a018a976e5c2bd2ca2d9d94895f23e7bb1af4e8af4e2d5", size = 1687713, upload-time = "2026-02-20T20:21:11.684Z" },
@@ -1675,6 +1680,7 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/98/6d/8f2ef704e614bcf58ed43cfb8d87afa1c285e98194ab2cfad351bf04f81e/greenlet-3.3.2-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:e26e72bec7ab387ac80caa7496e0f908ff954f31065b0ffc1f8ecb1338b11b54", size = 286617, upload-time = "2026-02-20T20:19:29.856Z" },
{ url = "https://files.pythonhosted.org/packages/5e/0d/93894161d307c6ea237a43988f27eba0947b360b99ac5239ad3fe09f0b47/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b466dff7a4ffda6ca975979bab80bdadde979e29fc947ac3be4451428d8b0e4", size = 655189, upload-time = "2026-02-20T20:47:35.742Z" },
{ url = "https://files.pythonhosted.org/packages/f5/2c/d2d506ebd8abcb57386ec4f7ba20f4030cbe56eae541bc6fd6ef399c0b41/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b8bddc5b73c9720bea487b3bffdb1840fe4e3656fba3bd40aa1489e9f37877ff", size = 658225, upload-time = "2026-02-20T20:56:02.527Z" },
+ { url = "https://files.pythonhosted.org/packages/d1/67/8197b7e7e602150938049d8e7f30de1660cfb87e4c8ee349b42b67bdb2e1/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:59b3e2c40f6706b05a9cd299c836c6aa2378cabe25d021acd80f13abf81181cf", size = 666581, upload-time = "2026-02-20T21:02:51.526Z" },
{ url = "https://files.pythonhosted.org/packages/8e/30/3a09155fbf728673a1dea713572d2d31159f824a37c22da82127056c44e4/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b26b0f4428b871a751968285a1ac9648944cea09807177ac639b030bddebcea4", size = 657907, upload-time = "2026-02-20T20:21:05.259Z" },
{ url = "https://files.pythonhosted.org/packages/f3/fd/d05a4b7acd0154ed758797f0a43b4c0962a843bedfe980115e842c5b2d08/greenlet-3.3.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:1fb39a11ee2e4d94be9a76671482be9398560955c9e568550de0224e41104727", size = 1618857, upload-time = "2026-02-20T20:49:37.309Z" },
{ url = "https://files.pythonhosted.org/packages/6f/e1/50ee92a5db521de8f35075b5eff060dd43d39ebd46c2181a2042f7070385/greenlet-3.3.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:20154044d9085151bc309e7689d6f7ba10027f8f5a8c0676ad398b951913d89e", size = 1680010, upload-time = "2026-02-20T20:21:13.427Z" },
@@ -3784,9 +3790,6 @@ local-embed = [
ocr = [
{ name = "pytesseract" },
]
-opengauss = [
- { name = "psycopg2-binary" },
-]
test = [
{ name = "boto3" },
{ name = "datasets" },
@@ -3875,7 +3878,6 @@ requires-dist = [
{ name = "pdfplumber", specifier = ">=0.10.0" },
{ name = "prompt-toolkit", marker = "extra == 'bot'", specifier = ">=3.0.0" },
{ name = "protobuf", specifier = ">=6.33.5" },
- { name = "psycopg2-binary", marker = "extra == 'opengauss'", specifier = ">=2.9" },
{ name = "py-machineid", marker = "extra == 'bot'", specifier = ">=1.0.0" },
{ name = "pydantic", specifier = ">=2.0.0" },
{ name = "pydantic-settings", marker = "extra == 'bot'", specifier = ">=2.0.0" },
@@ -3939,7 +3941,7 @@ requires-dist = [
{ name = "xlrd", specifier = ">=2.0.1" },
{ name = "xxhash", specifier = ">=3.0.0" },
]
-provides-extras = ["test", "auth", "opengauss", "dev", "doc", "eval", "gemini", "gemini-async", "ocr", "build", "bot", "benchmark", "langchain", "langgraph", "local-embed"]
+provides-extras = ["test", "auth", "dev", "doc", "eval", "gemini", "gemini-async", "ocr", "build", "bot", "benchmark", "langchain", "langgraph", "local-embed"]
[package.metadata.requires-dev]
dev = [{ name = "pytest", specifier = ">=9.0.2" }]
@@ -4587,69 +4589,6 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/57/bf/2086963c69bdac3d7cff1cc7ff79b8ce5ea0bec6797a017e1be338a46248/protobuf-6.33.5-py3-none-any.whl", hash = "sha256:69915a973dd0f60f31a08b8318b73eab2bd6a392c79184b3612226b0a3f8ec02", size = 170687, upload-time = "2026-01-29T21:51:32.557Z" },
]
-[[package]]
-name = "psycopg2-binary"
-version = "2.9.12"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/2a/60/a3624f79acea344c16fbef3a94d28b89a8042ddfb8f3e4ca83f538671409/psycopg2_binary-2.9.12.tar.gz", hash = "sha256:5ac9444edc768c02a6b6a591f070b8aae28ff3a99be57560ac996001580f294c", size = 379686, upload-time = "2026-04-21T09:40:34.304Z" }
-wheels = [
- { url = "https://files.pythonhosted.org/packages/78/80/49bacf9e51617d8309f6f0123e29edc793f6f5f6700c7d1f1b20782fbb37/psycopg2_binary-2.9.12-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9b818ceff717f98851a64bffd4c5eb5b3059ae280276dcecc52ac658dcf006a4", size = 3712314, upload-time = "2026-04-20T23:33:31.363Z" },
- { url = "https://files.pythonhosted.org/packages/d3/f2/98eeac7d60c43df9338287834edf9b3e69be68a2db78a57b1b81d705e735/psycopg2_binary-2.9.12-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d2fa0d7caca8635c56e373055094eeda3208d901d55dd0ff5abc1d4e47f82b56", size = 3822389, upload-time = "2026-04-20T23:33:34.178Z" },
- { url = "https://files.pythonhosted.org/packages/9f/7c/30575e75f14d5351a56a1971bb43fe7f8bf7edf1b654fb1bec65c42a8812/psycopg2_binary-2.9.12-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:864c261b3690e1207d14bbfe0a61e27567981b80c47a778561e49f676f7ce433", size = 4578448, upload-time = "2026-04-20T23:33:37.073Z" },
- { url = "https://files.pythonhosted.org/packages/65/9b/4df366d89f28c527dc39d0b6c98a5ca74e30d37ac097b73f3352147568ae/psycopg2_binary-2.9.12-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c5ee5213445dd45312459029b8c4c0a695461eb517b753d2582315bd07995f5e", size = 4273705, upload-time = "2026-04-20T23:33:39.291Z" },
- { url = "https://files.pythonhosted.org/packages/4e/8a/c566803818eb03161ba869b6ba612bf7ad56816d98b9e5121e0a22ad6b0b/psycopg2_binary-2.9.12-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6f9cae1f848779b5b01f417e762c40d026ea93eb0648249a604728cda991dde3", size = 5893784, upload-time = "2026-04-20T23:33:41.658Z" },
- { url = "https://files.pythonhosted.org/packages/63/fe/0dfa5797e0b229e0567bc378695224caf14d547f73b05be0c80549089772/psycopg2_binary-2.9.12-cp310-cp310-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:63a3ebbd543d3d1eda088ac99164e8c5bac15293ee91f20281fd17d050aee1c4", size = 4109306, upload-time = "2026-04-20T23:33:43.953Z" },
- { url = "https://files.pythonhosted.org/packages/3c/89/28063adf17a4ba501eedd9890feab0c649ee4d8bd0a97df0ff1e9584feab/psycopg2_binary-2.9.12-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d6fcbba8c9fed08a73b8ac61ea79e4821e45b1e92bb466230c5e746bbf3d5256", size = 3654400, upload-time = "2026-04-20T23:33:46.115Z" },
- { url = "https://files.pythonhosted.org/packages/84/94/5a01de0aa4ead0b8d8d1aa4ec18cec0bd36d03fa714eaa5bb8a0b1b50020/psycopg2_binary-2.9.12-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:36512911ebb2b60a0c3e44d0bb5048c1980aced91235d133b7874f3d1d93487c", size = 3299215, upload-time = "2026-04-20T23:33:48.202Z" },
- { url = "https://files.pythonhosted.org/packages/7a/85/723bb085a61c6ac2dc0a0043f375f2fe7365363e27b073bad56ca5bda979/psycopg2_binary-2.9.12-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:8ffdb59fe88f99589e34354a130217aa1fd2d615612402d6edc8b3dbc7a44463", size = 3047724, upload-time = "2026-04-20T23:33:50.74Z" },
- { url = "https://files.pythonhosted.org/packages/b4/67/4d8b1e0d2fc4166677380eac0edf9cdff91013aca2546e8ef7bc04b56158/psycopg2_binary-2.9.12-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:a46fe069b65255df410f856d842bc235f90e22ffdf532dda625fd4213d3fd9b1", size = 3349183, upload-time = "2026-04-20T23:33:59.635Z" },
- { url = "https://files.pythonhosted.org/packages/73/99/21af7a5498637ea4dc91a17c281a53bc1d632fbafe00f6689fbfb32a9fed/psycopg2_binary-2.9.12-cp310-cp310-win_amd64.whl", hash = "sha256:ab29414b25dcb698bf26bf213e3348abdcd07bbd5de032a5bec15bd75b298b03", size = 2757036, upload-time = "2026-04-20T23:34:01.606Z" },
- { url = "https://files.pythonhosted.org/packages/d5/19/d4ce60954f3bb9d8e3bc5e5c4d1f2487de2d3851bf2391d54954c9df12a6/psycopg2_binary-2.9.12-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5c8ce6c61bd1b1f6b9c24ee32211599f6166af2c55abb19456090a21fd16554b", size = 3712338, upload-time = "2026-04-20T23:34:03.961Z" },
- { url = "https://files.pythonhosted.org/packages/53/71/c85409ee0d78890f0660eff262e815e7dd2bb741a17611d82e9e8cd9dc5e/psycopg2_binary-2.9.12-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b4a9eaa6e7f4ff91bec10aa3fb296878e75187bced5cc4bafe17dc40915e1326", size = 3822407, upload-time = "2026-04-20T23:34:05.977Z" },
- { url = "https://files.pythonhosted.org/packages/3c/ed/60486c2c7f0d4d1ede2bfb1ed27e2498477ce646bc7f6b2759906303117e/psycopg2_binary-2.9.12-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:c6528cefc8e50fcc6f4a107e27a672058b36cc5736d665476aeb413ba88dbb06", size = 4578425, upload-time = "2026-04-20T23:34:08.246Z" },
- { url = "https://files.pythonhosted.org/packages/0b/b9/656cb03fad9f4f49f2145c334b1126ee75189929ca4e6187d485a2d59951/psycopg2_binary-2.9.12-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e4e184b1fb6072bf05388aa41c697e1b2d01b3473f107e7ec44f186a32cfd0b8", size = 4273709, upload-time = "2026-04-20T23:34:10.974Z" },
- { url = "https://files.pythonhosted.org/packages/99/66/08cf0da0e25cc6fb142c89be45fc8418792858f0c4cbff5e24530ff02cd6/psycopg2_binary-2.9.12-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4766ab678563054d3f1d064a4db19cc4b5f9e3a8d9018592a8285cf200c248f3", size = 5893779, upload-time = "2026-04-20T23:34:13.905Z" },
- { url = "https://files.pythonhosted.org/packages/17/d7/eecd9ce8e146d3721115d82d3836efdbb712187e4590325df549989d18f4/psycopg2_binary-2.9.12-cp311-cp311-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5a0253224780c978746cb9be55a946bcdaf40fe3519c0f622924cdabdafe2c39", size = 4109308, upload-time = "2026-04-20T23:34:16.761Z" },
- { url = "https://files.pythonhosted.org/packages/b6/2e/b1dc289b362cc8d45697b57eefbd673186f49a4ea0906928988e3affcc98/psycopg2_binary-2.9.12-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0dc9228d47c46bda253d2ecd6bb93b56a9f2d7ad33b684a1fa3622bf74ffe30c", size = 3654405, upload-time = "2026-04-20T23:34:19.303Z" },
- { url = "https://files.pythonhosted.org/packages/eb/e4/4c4aea6473214dbdbd0fbba11aa4691e76dc01722c55724c5951719865ff/psycopg2_binary-2.9.12-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f921f3cd87035ef7df233383011d7a53ea1d346224752c1385f1edfd790ceb6a", size = 3299187, upload-time = "2026-04-20T23:34:21.206Z" },
- { url = "https://files.pythonhosted.org/packages/ba/5d/b03b99986446a4f57b170ed9a2579fb7ff9783ca0fa5226b19db99737fee/psycopg2_binary-2.9.12-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:3d999bd982a723113c1a45b55a7a6a90d64d0ed2278020ed625c490ff7bef96c", size = 3047716, upload-time = "2026-04-20T23:34:23.077Z" },
- { url = "https://files.pythonhosted.org/packages/14/86/382ee4afbd1d97500c9d2862b20c2fdeddf4b7335e984df3fb4309f64108/psycopg2_binary-2.9.12-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:29d4d134bd0ab46ffb04e94aa3c5fa3ef582e9026609165e2f758ff76fc3a3be", size = 3349237, upload-time = "2026-04-20T23:34:25.211Z" },
- { url = "https://files.pythonhosted.org/packages/a8/16/9a57c75ba1eda7165c017342f526810d5f5a12647dde749c99ae9a7141d7/psycopg2_binary-2.9.12-cp311-cp311-win_amd64.whl", hash = "sha256:cb4a1dacdd48077150dc762a9e5ddbf32c256d66cb46f80839391aa458774936", size = 2757036, upload-time = "2026-04-20T23:34:27.77Z" },
- { url = "https://files.pythonhosted.org/packages/e2/9f/ef4ef3c8e15083df90ca35265cfd1a081a2f0cc07bb229c6314c6af817f4/psycopg2_binary-2.9.12-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5cdc05117180c5fa9c40eea8ea559ce64d73824c39d928b7da9fb5f6a9392433", size = 3712459, upload-time = "2026-04-20T23:34:30.549Z" },
- { url = "https://files.pythonhosted.org/packages/b5/01/3dd14e46ba48c1e1a6ec58ee599fa1b5efa00c246d5046cd903d0eeb1af1/psycopg2_binary-2.9.12-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d3227a3bc228c10d21011a99245edca923e4e8bf461857e869a507d9a41fe9f6", size = 3822936, upload-time = "2026-04-20T23:34:32.77Z" },
- { url = "https://files.pythonhosted.org/packages/a6/f7/0640e4901119d8a9f7a1784b927f494e2198e213ceb593753d1f2c8b1b30/psycopg2_binary-2.9.12-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:995ce929eede89db6254b50827e2b7fd61e50d11f0b116b29fffe4a2e53c4580", size = 4578676, upload-time = "2026-04-20T23:34:35.18Z" },
- { url = "https://files.pythonhosted.org/packages/b0/55/44df3965b5f297c50cc0b1b594a31c67d6127a9d133045b8a66611b14dfb/psycopg2_binary-2.9.12-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9fe06d93e72f1c048e731a2e3e7854a5bfaa58fc736068df90b352cefe66f03f", size = 4274917, upload-time = "2026-04-20T23:34:37.982Z" },
- { url = "https://files.pythonhosted.org/packages/b0/4b/74535248b1eac0c9336862e8617c765ac94dac76f9e25d7c4a79588c8907/psycopg2_binary-2.9.12-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:40e7b28b63aaf737cb3a1edc3a9bbc9a9f4ad3dcb7152e8c1130e4050eddcb7d", size = 5894843, upload-time = "2026-04-20T23:34:40.856Z" },
- { url = "https://files.pythonhosted.org/packages/f2/ba/f1bf8d2ae71868ad800b661099086ee52bc0f8d9f05be1acd8ebb06757cc/psycopg2_binary-2.9.12-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:89d19a9f7899e8eb0656a2b3a08e0da04c720a06db6e0033eab5928aabe60fa9", size = 4110556, upload-time = "2026-04-20T23:34:44.016Z" },
- { url = "https://files.pythonhosted.org/packages/45/46/c15706c338403b7c420bcc0c2905aad116cc064545686d8bf85f1999ea00/psycopg2_binary-2.9.12-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:612b965daee295ae2da8f8218ce1d274645dc76ef3f1abf6a0a94fd57eff876d", size = 3655714, upload-time = "2026-04-20T23:34:46.233Z" },
- { url = "https://files.pythonhosted.org/packages/b3/7c/a2d5dc09b64a4564db242a0fe418fde7d33f6f8259dd2c5b9d7def00fb5a/psycopg2_binary-2.9.12-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:b9a339b79d37c1b45f3235265f07cdeb0cb5ad7acd2ac7720a5920989c17c24e", size = 3301154, upload-time = "2026-04-20T23:34:49.528Z" },
- { url = "https://files.pythonhosted.org/packages/c0/e8/cc8c9a4ce71461f9ec548d38cadc41dc184b34c73e6455450775a9334ccd/psycopg2_binary-2.9.12-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:3471336e1acfd9c7fe507b8bad5af9317b6a89294f9eb37bd9a030bb7bebcdc6", size = 3048882, upload-time = "2026-04-20T23:34:51.86Z" },
- { url = "https://files.pythonhosted.org/packages/19/6a/31e2296bc0787c5ab75d3d118e40b239db8151b5192b90b77c72bc9256e9/psycopg2_binary-2.9.12-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7af18183109e23502c8b2ae7f6926c0882766f35b5175a4cd737ad825e4d7a1b", size = 3351298, upload-time = "2026-04-20T23:34:54.124Z" },
- { url = "https://files.pythonhosted.org/packages/5f/a8/75f4e3e11203b590150abed2cf7794b9c9c9f7eceddae955191138b44dde/psycopg2_binary-2.9.12-cp312-cp312-win_amd64.whl", hash = "sha256:398fcd4db988c7d7d3713e2b8e18939776fd3fb447052daae4f24fa39daede4c", size = 2757230, upload-time = "2026-04-20T23:34:56.242Z" },
- { url = "https://files.pythonhosted.org/packages/91/bb/4608c96f970f6e0c56572e87027ef4404f709382a3503e9934526d7ba051/psycopg2_binary-2.9.12-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7c729a73c7b1b84de3582f73cdd27d905121dc2c531f3d9a3c32a3011033b965", size = 3712419, upload-time = "2026-04-20T23:34:58.754Z" },
- { url = "https://files.pythonhosted.org/packages/5e/af/48f76af9d50d61cf390f8cd657b503168b089e2e9298e48465d029fcc713/psycopg2_binary-2.9.12-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4413d0caef93c5cf50b96863df4c2efe8c269bf2267df353225595e7e15e8df7", size = 3822990, upload-time = "2026-04-20T23:35:00.821Z" },
- { url = "https://files.pythonhosted.org/packages/7a/df/aba0f99397cd811d32e06fc0cc781f1f3ce98bc0e729cb423925085d781a/psycopg2_binary-2.9.12-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:4dfcf8e45ebb0c663be34a3442f65e17311f3367089cd4e5e3a3e8e62c978777", size = 4578696, upload-time = "2026-04-20T23:35:03.409Z" },
- { url = "https://files.pythonhosted.org/packages/95/9c/eaa74021ac4e4d5c2f83d82fc6615a63f4fe6c94dc4e94c3990427053f67/psycopg2_binary-2.9.12-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c41321a14dd74aceb6a9a643b9253a334521babfa763fa873e33d89cfa122fb5", size = 4274982, upload-time = "2026-04-20T23:35:05.583Z" },
- { url = "https://files.pythonhosted.org/packages/35/ed/c25deff98bd26187ba48b3b250a3ffc3037c46c5b89362534a15d200e0db/psycopg2_binary-2.9.12-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:83946ba43979ebfdc99a3cd0ee775c89f221df026984ba19d46133d8d75d3cd9", size = 5894867, upload-time = "2026-04-20T23:35:07.902Z" },
- { url = "https://files.pythonhosted.org/packages/9a/81/8d0e21ca77373c6c9589e5c4528f6e8f0c08c62cafc76fb0bddb7a2cee22/psycopg2_binary-2.9.12-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:411e85815652d13560fbe731878daa5d92378c4995a22302071890ec3397d019", size = 4110578, upload-time = "2026-04-20T23:35:10.149Z" },
- { url = "https://files.pythonhosted.org/packages/00/fc/f481e2435bd8f742d0123309174aae4165160ad3ef17c1b99c3622c241d2/psycopg2_binary-2.9.12-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1c8ad4c08e00f7679559eaed7aff1edfffc60c086b976f93972f686384a95e2c", size = 3655816, upload-time = "2026-04-20T23:35:12.56Z" },
- { url = "https://files.pythonhosted.org/packages/53/79/b9f46466bdbe9f239c96cde8be33c1aace4842f06013b47b730dc9759187/psycopg2_binary-2.9.12-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:00814e40fa23c2b37ef0a1e3c749d89982c73a9cb5046137f0752a22d432e82f", size = 3301307, upload-time = "2026-04-20T23:35:15.029Z" },
- { url = "https://files.pythonhosted.org/packages/3f/19/7dc003b32fe35024df89b658104f7c8538a8b2dcbde7a4e746ce929742e7/psycopg2_binary-2.9.12-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:98062447aebc20ed20add1f547a364fd0ef8933640d5372ff1873f8deb9b61be", size = 3048968, upload-time = "2026-04-20T23:35:16.757Z" },
- { url = "https://files.pythonhosted.org/packages/91/58/2dbd7db5c604d45f4950d988506aae672a14126ec22998ced5021cbb76bb/psycopg2_binary-2.9.12-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:66a7685d7e548f10fb4ce32fb01a7b7f4aa702134de92a292c7bd9e0d3dbd290", size = 3351369, upload-time = "2026-04-20T23:35:18.933Z" },
- { url = "https://files.pythonhosted.org/packages/42/ee/dee8dcaad07f735824de3d6563bc67119fa6c28257b17977a8d624f02fab/psycopg2_binary-2.9.12-cp313-cp313-win_amd64.whl", hash = "sha256:b6937f5fe4e180aeee87de907a2fa982ded6f7f15d7218f78a083e4e1d68f2a0", size = 2757347, upload-time = "2026-04-20T23:35:21.283Z" },
- { url = "https://files.pythonhosted.org/packages/13/1b/708c0dca874acfad6d65314271859899a79007686f3a1f74e82a2ed4b645/psycopg2_binary-2.9.12-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:6f3b3de8a74ef8db215f22edffb19e32dc6fa41340456de7ec99efdc8a7b3ec2", size = 3712428, upload-time = "2026-04-20T23:35:23.453Z" },
- { url = "https://files.pythonhosted.org/packages/d6/39/ddbea9d4b4de6aca9431b6ed253f530f8a02d3b8f9bcfd0dbfe2b3de6fe4/psycopg2_binary-2.9.12-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1006fb62f0f0bc5ce256a832356c6262e91be43f5e4eb15b5eaf38079464caf2", size = 3823184, upload-time = "2026-04-20T23:35:25.92Z" },
- { url = "https://files.pythonhosted.org/packages/bf/a0/bc2fef74b106fa345567122a0659e6d94512ed7dc0131ec44c9e5aba3725/psycopg2_binary-2.9.12-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:840066105706cd2eb29b9a1c2329620056582a4bf3e8169dec5c447042d0869f", size = 4579157, upload-time = "2026-04-20T23:35:28.542Z" },
- { url = "https://files.pythonhosted.org/packages/57/d7/d4e3b2005d3de607ca4fbb0e8742e248056e52184a6b94ebda3c1c2c329b/psycopg2_binary-2.9.12-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:863f5d12241ebe1c76a72a04c2113b6dc905f90b9cef0e9be0efd994affd9354", size = 4274970, upload-time = "2026-04-20T23:35:30.418Z" },
- { url = "https://files.pythonhosted.org/packages/2e/42/c9853f8db3967fe08bcde11f53d53b85d351750cae726ce001cb68afa9c1/psycopg2_binary-2.9.12-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a99eaab34a9010f1a086b126de467466620a750634d114d20455f3a824aae033", size = 5895175, upload-time = "2026-04-20T23:35:33.584Z" },
- { url = "https://files.pythonhosted.org/packages/eb/fd/b82b5601a97630308bef079f545ffec481bbbc795c2ba5ec416a01d03f60/psycopg2_binary-2.9.12-cp314-cp314-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ffdd7dc5463ccd61845ac37b7012d0f35a1548df9febe14f8dd549be4a0bc81e", size = 4110658, upload-time = "2026-04-20T23:35:35.638Z" },
- { url = "https://files.pythonhosted.org/packages/62/8c/32ca69b0389ef25dd22937bf9e8fbe2ce27aea20b05ded48c4ce4cb42475/psycopg2_binary-2.9.12-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:54a0dfecab1b48731f934e06139dfe11e24219fb6d0ceb32177cf0375f14c7b5", size = 3656251, upload-time = "2026-04-20T23:35:37.854Z" },
- { url = "https://files.pythonhosted.org/packages/c4/29/96992a2b59e3b9d730fcf9612d0a387305025dc867a9fc490a9e496e074e/psycopg2_binary-2.9.12-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:96937c9c5d891f772430f418a7a8b4691a90c3e6b93cf72b5bd7cad8cbca32a5", size = 3301810, upload-time = "2026-04-20T23:35:39.927Z" },
- { url = "https://files.pythonhosted.org/packages/56/ad/44b06659949b243ae10112cd3b20a197f9bf3e81d5651379b9eb889bfaad/psycopg2_binary-2.9.12-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:77b348775efd4cdab410ec6609d81ccecd1139c90265fa583a7255c8064bc03d", size = 3048977, upload-time = "2026-04-20T23:35:41.806Z" },
- { url = "https://files.pythonhosted.org/packages/1d/f2/10a1bcebadb6aa55e280e1f58975c36a7b560ea525184c7aa4064c466633/psycopg2_binary-2.9.12-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:527e6342b3e44c2f0544f6b8e927d60de7f163f5723b8f1dfa7d2a84298738cd", size = 3351466, upload-time = "2026-04-20T23:35:43.993Z" },
- { url = "https://files.pythonhosted.org/packages/20/be/b732c8418ffa5bcfda002890f5dc4c869fc17db66ff11f53b17cfe44afc0/psycopg2_binary-2.9.12-cp314-cp314-win_amd64.whl", hash = "sha256:f12ae41fcafadb39b2785e64a40f9db05d6de2ac114077457e0e7c597f3af980", size = 2848762, upload-time = "2026-04-20T23:35:46.421Z" },
-]
-
[[package]]
name = "py"
version = "1.11.0"