vikingdb-python-sdk 0.1.8__tar.gz → 0.1.10__tar.gz

{vikingdb_python_sdk-0.1.8/vikingdb_python_sdk.egg-info → vikingdb_python_sdk-0.1.10}/PKG-INFO

@@ -1,8 +1,8 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: vikingdb-python-sdk
-Version: 0.1.8
+Version: 0.1.10
 Summary: vikingdb Python SDK
-License-Expression: Apache-2.0
+License: Apache-2.0
 Project-URL: Documentation, https://github.com/volcengine/volc-vikingdb-python-sdk/README.md
 Project-URL: Source, https://github.com/volcengine/volc-vikingdb-python-sdk
 Keywords: vikingdb,vector,bytedance,volcengine,sdk
@@ -20,10 +20,10 @@ License-File: LICENSE.txt
 Requires-Dist: httpx>=0.24.1
 Requires-Dist: requests>=2.28.1
 Requires-Dist: pydantic>=2.5.3
+Requires-Dist: typing_extensions>=4.9.0
 Requires-Dist: urllib3>=1.21.1
 Requires-Dist: volcengine>=1.0.0
 Requires-Dist: aiohttp>=3.10.0
-Dynamic: license-file
 
 ## VikingDB Python SDK (v2)
 
@@ -53,10 +53,10 @@ uv add vikingdb-python-sdk
 ```python
 import os
 from vikingdb import IAM
-from vikingdb.vector import SearchByRandomRequest, VikingVector
+from vikingdb.vector import SearchByRandomRequest, VikingDB
 
 auth = IAM(ak=os.environ["VIKINGDB_AK"], sk=os.environ["VIKINGDB_SK"]) 
-client = VikingVector(
+client = VikingDB(
     host=os.environ["VIKINGDB_HOST"],
     region=os.environ["VIKINGDB_REGION"],
     auth=auth,
@@ -181,7 +181,7 @@ python examples/memory/03_search_memory.py
 ### Architecture Overview
 
 - `vikingdb._client`, `vikingdb.auth`, `vikingdb.request_options`, and `vikingdb.vector.exceptions` form the shared runtime used by all present and future SDK domains (vector, memory, knowledge).
-- Domain-specific features live under dedicated namespaces such as `vikingdb.vector` and `vikingdb.memory`, where the high-level clients (`VikingVector`, `VikingMem`) compose the shared auth stack atop the shared client.
+- Domain-specific features live under dedicated namespaces such as `vikingdb.vector` and `vikingdb.memory`, where the high-level clients (`VikingDB`, `VikingMem`) compose the shared auth stack atop the shared client.
 - Vector request/response models now surface directly from `vikingdb.vector` (backed internally by `vikingdb/vector/models`).
 - Memory APIs return plain dictionaries without object encapsulation, providing a lightweight interface for conversational memory management (session, profile, event operations).
 - Imports from the root package now focus on cross-cutting utilities (auth, config, request options), while application code should pull domain-specific functionality from `vikingdb.vector` or `vikingdb.memory` explicitly.
@@ -199,6 +199,7 @@ vikingdb/
 │   ├── base.py          # Shared helpers for vector clients
 │   ├── collection.py    # Collection operations
 │   ├── embedding.py     # Embedding operations
+│   ├── rerank.py        # rerank operations
 │   ├── index.py         # Index/search operations
 │   ├── client.py        # Vector service wrapper and high-level client
 │   ├── exceptions.py    # Vector-specific exceptions

{vikingdb_python_sdk-0.1.8 → vikingdb_python_sdk-0.1.10}/README.md

@@ -26,10 +26,10 @@ uv add vikingdb-python-sdk
 ```python
 import os
 from vikingdb import IAM
-from vikingdb.vector import SearchByRandomRequest, VikingVector
+from vikingdb.vector import SearchByRandomRequest, VikingDB
 
 auth = IAM(ak=os.environ["VIKINGDB_AK"], sk=os.environ["VIKINGDB_SK"]) 
-client = VikingVector(
+client = VikingDB(
     host=os.environ["VIKINGDB_HOST"],
     region=os.environ["VIKINGDB_REGION"],
     auth=auth,
@@ -154,7 +154,7 @@ python examples/memory/03_search_memory.py
 ### Architecture Overview
 
 - `vikingdb._client`, `vikingdb.auth`, `vikingdb.request_options`, and `vikingdb.vector.exceptions` form the shared runtime used by all present and future SDK domains (vector, memory, knowledge).
-- Domain-specific features live under dedicated namespaces such as `vikingdb.vector` and `vikingdb.memory`, where the high-level clients (`VikingVector`, `VikingMem`) compose the shared auth stack atop the shared client.
+- Domain-specific features live under dedicated namespaces such as `vikingdb.vector` and `vikingdb.memory`, where the high-level clients (`VikingDB`, `VikingMem`) compose the shared auth stack atop the shared client.
 - Vector request/response models now surface directly from `vikingdb.vector` (backed internally by `vikingdb/vector/models`).
 - Memory APIs return plain dictionaries without object encapsulation, providing a lightweight interface for conversational memory management (session, profile, event operations).
 - Imports from the root package now focus on cross-cutting utilities (auth, config, request options), while application code should pull domain-specific functionality from `vikingdb.vector` or `vikingdb.memory` explicitly.
@@ -172,6 +172,7 @@ vikingdb/
 │   ├── base.py          # Shared helpers for vector clients
 │   ├── collection.py    # Collection operations
 │   ├── embedding.py     # Embedding operations
+│   ├── rerank.py        # rerank operations
 │   ├── index.py         # Index/search operations
 │   ├── client.py        # Vector service wrapper and high-level client
 │   ├── exceptions.py    # Vector-specific exceptions

{vikingdb_python_sdk-0.1.8 → vikingdb_python_sdk-0.1.10}/pyproject.toml

@@ -8,7 +8,7 @@ dynamic = ["version"]
 description = "vikingdb Python SDK"
 readme = "README.md"
 requires-python = ">=3.8"
-license = "Apache-2.0"
+license = {text = "Apache-2.0"}
 keywords = ["vikingdb", "vector", "bytedance", "volcengine", "sdk"]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -24,6 +24,7 @@ dependencies = [
     "httpx>=0.24.1",
     "requests>=2.28.1",
     "pydantic>=2.5.3",
+    "typing_extensions>=4.9.0",
     "urllib3>=1.21.1",
     "volcengine>=1.0.0",
     "aiohttp>=3.10.0",

{vikingdb_python_sdk-0.1.8 → vikingdb_python_sdk-0.1.10}/vikingdb/__init__.py

@@ -11,6 +11,8 @@ from .vector import (
     CollectionClient,
     EmbeddingClient,
     IndexClient,
+    RerankClient,
+    VikingDB,
     VikingVector,
 )
 from .memory import (
@@ -23,8 +25,10 @@ __all__ = [
     "APIKey",
     "CollectionClient",
     "EmbeddingClient",
+    "RerankClient",
     "IndexClient",
     "RequestOptions",
+    "VikingDB",
     "VikingVector",
     "vector",
     "memory",

vikingdb_python_sdk-0.1.10/vikingdb/knowledge/__init__.py

@@ -0,0 +1,126 @@
+# coding:utf-8
+# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd.
+# SPDX-License-Identifier: Apache-2.0
+
+from .client import VikingKnowledge
+from .collection import KnowledgeCollection
+from .exceptions import (
+    VikingKnowledgeException,
+    UnauthorizedException,
+    NoPermissionException,
+    InvalidRequestException,
+    CollectionExistException,
+    CollectionNotExistException,
+    OperationNotAllowedException,
+    IndexExistException,
+    IndexNotExistException,
+    QueryOpFailedException,
+    DataNotFoundException,
+    DelOpFailedException,
+    UpsertOpFailedException,
+    TokenMismatchException,
+    InvalidQueryVecException,
+    InvalidPrimaryKeyException,
+    InvalidPartitionException,
+    InvalidScalarCondException,
+    InvalidProxyServiceException,
+    IndexRecallException,
+    IndexFetchDataException,
+    IndexNotReadyException,
+    APINotImplementedException,
+    CalcEmbeddingFailedException,
+    ListEmbeddingModelsException,
+    InternalServerException,
+    QuotaLimiterException,
+    RerankException,
+    DocNotExistException,
+    DocIsFullException,
+    PointNotExistException,
+)
+from .models.base import CollectionMeta
+from .models.doc import DocInfo, DocInfo, ListDocsResponse, AddDocRequest, AddDocV2Request, ListDocsRequest, DedupOptions, MetaItem, AddDocResponse, AddDocResponseData
+from .models.point import (
+    PointInfo,
+    ListPointsResponse,
+    AddPointRequest,
+    UpdatePointRequest,
+    ListPointsRequest,
+    DeletePointRequest,
+)
+from .models.search import (
+    SearchCollectionRequest,
+    SearchResponse,
+    SearchKnowledgeResponse,
+    SearchKnowledgeRequest,
+)
+from .models.rerank import RerankDataItem, RerankResponse
+from .models.service_chat import ServiceChatRequest, ServiceChatResponse
+from .models.chat import (
+    ChatMessage,
+    ChatCompletionRequest,
+    ChatCompletionResponse,
+)
+
+__all__ = [
+    "VikingKnowledge",
+    "KnowledgeCollection",
+    "VikingKnowledgeException",
+    "UnauthorizedException",
+    "NoPermissionException",
+    "InvalidRequestException",
+    "CollectionExistException",
+    "CollectionNotExistException",
+    "OperationNotAllowedException",
+    "IndexExistException",
+    "IndexNotExistException",
+    "QueryOpFailedException",
+    "DataNotFoundException",
+    "DelOpFailedException",
+    "UpsertOpFailedException",
+    "TokenMismatchException",
+    "InvalidQueryVecException",
+    "InvalidPrimaryKeyException",
+    "InvalidPartitionException",
+    "InvalidScalarCondException",
+    "InvalidProxyServiceException",
+    "IndexRecallException",
+    "IndexFetchDataException",
+    "IndexNotReadyException",
+    "APINotImplementedException",
+    "CalcEmbeddingFailedException",
+    "ListEmbeddingModelsException",
+    "InternalServerException",
+    "QuotaLimiterException",
+    "RerankException",
+    "DocNotExistException",
+    "DocIsFullException",
+    "PointNotExistException",
+    "CollectionMeta",
+    "DocInfo",
+    "DocInfo",
+    "ListDocsResponse",
+    "AddDocRequest",
+    "AddDocV2Request",
+    "AddDocResponse",
+    "AddDocResponseData",
+    "ListDocsRequest",
+    "PointInfo",
+    "DedupOptions",
+    "MetaItem",
+    "ListPointsResponse",
+    "AddPointRequest",
+    "UpdatePointRequest",
+    "ListPointsRequest",
+    "DeletePointRequest",
+    "SearchCollectionRequest",
+    "SearchResponse",
+    "SearchKnowledgeResponse",
+    "SearchKnowledgeRequest",
+    "RerankDataItem",
+    "RerankResponse",
+    "ServiceChatRequest",
+    "ServiceChatResponse",
+    "ChatMessage",
+    "ChatCompletionRequest",
+    "ChatCompletionResponse",
+]

vikingdb_python_sdk-0.1.10/vikingdb/knowledge/client.py

@@ -0,0 +1,174 @@
+# coding:utf-8
+# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import json
+from typing import Mapping, Optional, Union, Sequence, cast
+
+from volcengine.ApiInfo import ApiInfo
+
+from .. import APIKey
+from .._client import Client, _REQUEST_ID_HEADER
+from ..auth import Auth
+from ..exceptions import VikingException, promote_exception
+from .exceptions import EXCEPTION_MAP, VikingKnowledgeException
+from ..version import __version__
+from .models.base import CollectionMeta, Model
+from .models.rerank import RerankDataItem, RerankResponse
+from .models.chat import ChatCompletionRequest, ChatCompletionResponse
+from .models.service_chat import ServiceChatRequest, ServiceChatResponse
+
+
+_DEFAULT_USER_AGENT = f"vikingdb-python-sdk/{__version__}"
+
+
+def _get_common_viking_request_header():
+    header = {
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+        "User-Agent": _DEFAULT_USER_AGENT,
+    }
+    return header
+
+
+class VikingKnowledge(Client):
+    def __init__(
+        self,
+        *,
+        host: str = "api-knowledgebase.mlp.cn-beijing.volces.com",
+        region: str = "cn-beijing",
+        auth: Auth,
+        sts_token: str = "",
+        scheme: str = "http",
+        timeout: int = 30,
+    ):
+        super().__init__(
+            host=host,
+            region=region,
+            service="air",
+            auth=auth,
+            sts_token=sts_token,
+            scheme=scheme,
+            timeout=timeout,
+        )
+
+    def _build_api_info(self):
+        header = _get_common_viking_request_header()
+        return {
+            "SearchCollection": ApiInfo("POST", "/api/knowledge/collection/search", {}, {}, header),
+            "SearchKnowledge": ApiInfo("POST", "/api/knowledge/collection/search_knowledge", {}, {}, header),
+            "ServiceChat": ApiInfo("POST", "/api/knowledge/service/chat", {}, {}, header),
+            # Doc
+            "AddDoc": ApiInfo("POST", "/api/knowledge/doc/add", {}, {}, header),
+            "AddDocV2": ApiInfo("POST", "/api/knowledge/doc/v2/add", {}, {}, header),
+            "DeleteDoc": ApiInfo("POST", "/api/knowledge/doc/delete", {}, {}, header),
+            "GetDocInfo": ApiInfo("POST", "/api/knowledge/doc/info", {}, {}, header),
+            "ListDocs": ApiInfo("POST", "/api/knowledge/doc/list", {}, {}, header),
+            "UpdateDocMeta": ApiInfo("POST", "/api/knowledge/doc/update_meta", {}, {}, header),
+            "UpdateDoc": ApiInfo("POST", "/api/knowledge/doc/update", {}, {}, header),
+            # Point
+            "GetPointInfo": ApiInfo("POST", "/api/knowledge/point/info", {}, {}, header),
+            "ListPoints": ApiInfo("POST", "/api/knowledge/point/list", {}, {}, header),
+            "AddPoint": ApiInfo("POST", "/api/knowledge/point/add", {}, {}, header),
+            "UpdatePoint": ApiInfo("POST", "/api/knowledge/point/update", {}, {}, header),
+            "DeletePoint": ApiInfo("POST", "/api/knowledge/point/delete", {}, {}, header),
+            # Service
+            "Ping": ApiInfo("GET", "/ping", {}, {}, header),
+            "Rerank": ApiInfo("POST", "/api/knowledge/service/rerank", {}, {}, header),
+            # Chat
+            "ChatCompletion": ApiInfo("POST", "/api/knowledge/chat/completions", {}, {}, header),
+        }
+
+    def json_exception(self, api, params, body, headers=None, timeout=None):
+        try:
+            res = self._json(api, params, body, headers=headers, timeout=timeout)
+        except VikingException as exc:
+            raise promote_exception(exc, exception_map=EXCEPTION_MAP, default_cls=VikingKnowledgeException) from None
+        if res is None:
+            raise VikingKnowledgeException(1000028, "missed", "empty response due to unknown error", status_code=None)
+        return res
+
+    async def async_json_exception(self, api, params, body, headers=None, timeout=None):
+        try:
+            res = await self.async_json(api, params, body, headers=headers, timeout=timeout)
+        except VikingException as exc:
+            raise promote_exception(exc, exception_map=EXCEPTION_MAP, default_cls=VikingKnowledgeException) from None
+        if res is None:
+            raise VikingKnowledgeException(1000028, "missed", "empty response due to unknown error", status_code=None)
+        return res
+
+    def collection(
+        self,
+        *,
+        resource_id: Optional[str] = None,
+        collection_name: Optional[str] = None,
+        project_name: Optional[str] = None,
+    ):
+        from .collection import KnowledgeCollection
+
+        meta = CollectionMeta(
+            resource_id=resource_id,
+            collection_name=collection_name,
+            project_name=project_name,
+        )
+        return KnowledgeCollection(self, meta)
+
+    def rerank(
+        self,
+        datas: Sequence[Union[RerankDataItem,Mapping[str, object]]],
+        *,
+        rerank_model: str = "Doubao-pro-4k-rerank",
+        rerank_instruction: Optional[str] = None,
+        endpoint_id: Optional[str] = None,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: Optional[int] = None,
+    ) -> RerankResponse:
+        items = [
+            (d.model_dump(by_alias=True, exclude_none=True) if isinstance(d, RerankDataItem) else dict(d))
+            for d in datas
+        ]
+        if len(items) > 50:
+            raise VikingKnowledgeException(1000028, "missed", "datas list too large", status_code=None)
+        payload: dict = {"datas": items, "rerank_model": rerank_model}
+        if rerank_instruction is not None:
+            payload["rerank_instruction"] = rerank_instruction
+        if endpoint_id is not None:
+            payload["endpoint_id"] = endpoint_id
+        res = self.json_exception("Rerank", {}, json.dumps(payload), headers=headers, timeout=timeout)
+        response = RerankResponse.parse_with(res)
+        return response
+
+    def chat_completion(
+        self,
+        request: Union[ChatCompletionRequest, Mapping[str, object]],
+        *,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: Optional[int] = None,
+    ) -> ChatCompletionResponse:
+        payload = (
+            request.model_dump(by_alias=True, exclude_none=True)  # type: ignore[attr-defined]
+            if isinstance(request, ChatCompletionRequest)
+            else dict(request)
+        )
+        res = self.json_exception("ChatCompletion", {}, json.dumps(payload), headers=headers, timeout=timeout)
+        response = ChatCompletionResponse.parse_with(res)
+        return response
+
+    def service_chat(
+        self,
+        request: Union[ServiceChatRequest, Mapping[str, object]],
+        *,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: Optional[int] = None,
+    ) -> ServiceChatResponse:
+        payload = (
+            request.model_dump(by_alias=True, exclude_none=True)  # type: ignore[attr-defined]
+            if isinstance(request, ServiceChatRequest)
+            else dict(request)
+        )
+        req_headers = dict(headers or {})
+        res = self.json_exception("ServiceChat", {}, json.dumps(payload), headers=req_headers, timeout=timeout)
+        response = ServiceChatResponse.parse_with(res)
+        return response

vikingdb_python_sdk-0.1.10/vikingdb/knowledge/collection.py

@@ -0,0 +1,263 @@
+# coding:utf-8
+# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import json
+from typing import Mapping, Optional, Union, List
+import warnings
+
+from .models.base import CollectionMeta, Model
+from .models.doc import DocInfo, ListDocsResponse, AddDocRequest, ListDocsRequest, MetaItem, AddDocV2Request, AddDocResponse
+from .models.point import (
+    ListPointsResponse,
+    PointInfo,
+    AddPointRequest,
+    UpdatePointRequest,
+    ListPointsRequest,
+    DeletePointRequest,
+    PointAddResponse
+)
+from .models.search import (
+    SearchCollectionRequest,
+    SearchKnowledgeResponse,
+    SearchResponse,
+    SearchKnowledgeRequest,
+)
+
+
+class KnowledgeCollection:
+    def __init__(self, client, meta: CollectionMeta):
+        self.client = client
+        self._meta = meta
+        self._meta_payload = meta.model_dump(by_alias=True, exclude_none=True)
+
+    def add_doc(
+        self,
+        request: Union[AddDocRequest, Mapping[str, object]],
+        *,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: Optional[int] = None,
+    ):
+        warnings.warn("add_doc 已废弃，请使用 add_doc_v2", DeprecationWarning, stacklevel=2)
+        req_payload = (
+            request.model_dump(by_alias=True, exclude_none=True)  # type: ignore[attr-defined]
+            if isinstance(request, Model)
+            else dict(request)
+        )
+        payload = {**self._meta_payload, **req_payload}
+        res = self.client.json_exception("AddDoc", {}, json.dumps(payload), headers=headers, timeout=timeout)
+        response = AddDocResponse.parse_with(res)
+        return response
+
+    def add_doc_v2(
+        self,
+        request: Union[AddDocV2Request, Mapping[str, object]],
+        *,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: Optional[int] = None,
+    ) -> AddDocResponse:
+        req_payload = (
+            request.model_dump(by_alias=True, exclude_none=True)  # type: ignore[attr-defined]
+            if isinstance(request, Model)
+            else dict(request)
+        )
+        payload = {**self._meta_payload, **req_payload}
+        res = self.client.json_exception("AddDocV2", {}, json.dumps(payload), headers=headers, timeout=timeout)
+        response = AddDocResponse.parse_with(res)
+        return response
+
+    def delete_doc(
+        self,
+        doc_id: str,
+        *,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: Optional[int] = None,
+    ):
+        payload = {**self._meta_payload, "doc_id": doc_id}
+        res = self.client.json_exception("DeleteDoc", {}, json.dumps(payload), headers=headers, timeout=timeout)
+        return res
+
+    def get_doc(
+        self,
+        doc_id: str,
+        *,
+        return_token_usage: bool = False,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: Optional[int] = None,
+    ) -> DocInfo:
+        payload = {**self._meta_payload, "doc_id": doc_id}
+        if return_token_usage:
+            payload["return_token_usage"] = True
+        res = self.client.json_exception("GetDocInfo", {}, json.dumps(payload), headers=headers, timeout=timeout)
+        data_obj = res["data"] if isinstance(res, dict) and "data" in res else {}
+        if not isinstance(data_obj, dict):
+            data_obj = {}
+        doc = DocInfo.model_validate(
+            {**data_obj, "project": self._meta.project_name or "default", "resource_id": self._meta.resource_id}
+        )
+        return doc
+
+    def list_docs(
+        self,
+        request: Union[ListDocsRequest, Mapping[str, object]],
+        *,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: Optional[int] = None,
+    ) -> ListDocsResponse:
+        req_payload = (
+            request.model_dump(by_alias=True, exclude_none=True)  # type: ignore[attr-defined]
+            if isinstance(request, Model)
+            else dict(request)
+        )
+        payload: dict = {**self._meta_payload, **req_payload}
+        res = self.client.json_exception("ListDocs", {}, json.dumps(payload), headers=headers, timeout=timeout)
+        response = ListDocsResponse.parse_with(res)
+        return response
+
+    def update_doc_meta(
+        self,
+        doc_id: str,
+        meta: List[MetaItem],
+        *,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: Optional[int] = None,
+    ):
+        payload = {**self._meta_payload, "doc_id": doc_id, "meta": [item.model_dump(by_alias=True) for item in meta]}
+        res = self.client.json_exception("UpdateDocMeta", {}, json.dumps(payload), headers=headers, timeout=timeout)
+        return res
+
+    def update_doc(
+        self,
+        doc_id: str,
+        doc_name: str,
+        *,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: Optional[int] = None,
+    ):
+        payload = {**self._meta_payload, "doc_id": doc_id, "doc_name": doc_name}
+        res = self.client.json_exception("UpdateDoc", {}, json.dumps(payload), headers=headers, timeout=timeout)
+        return res
+
+    def get_point(
+        self,
+        point_id: str,
+        *,
+        get_attachment_link: bool = False,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: Optional[int] = None,
+    ) -> PointInfo:
+        payload = {**self._meta_payload, "point_id": point_id}
+        if get_attachment_link:
+            payload["get_attachment_link"] = True
+        res = self.client.json_exception("GetPointInfo", {}, json.dumps(payload), headers=headers, timeout=timeout)
+        data_obj = res["data"] if isinstance(res, dict) and "data" in res else {}
+        if not isinstance(data_obj, dict):
+            data_obj = {}
+        point = PointInfo.model_validate(
+            {**data_obj, "project": self._meta.project_name or "default", "resource_id": self._meta.resource_id}
+        )
+        return point
+
+    def list_points(
+        self,
+        request: Union[ListPointsRequest, Mapping[str, object]],
+        *,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: Optional[int] = None,
+    ) -> ListPointsResponse:
+        req_payload = (
+            request.model_dump(by_alias=True, exclude_none=True)  # type: ignore[attr-defined]
+            if isinstance(request, Model)
+            else dict(request)
+        )
+        payload: dict = {**self._meta_payload, **req_payload}
+        res = self.client.json_exception("ListPoints", {}, json.dumps(payload), headers=headers, timeout=timeout)
+        response = ListPointsResponse.parse_with(res)
+        return response
+
+    def add_point(
+        self,
+        request: Union[AddPointRequest, Mapping[str, object]],
+        *,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: Optional[int] = None,
+    ):
+        req_payload = (
+            request.model_dump(by_alias=True, exclude_none=True)  # type: ignore[attr-defined]
+            if isinstance(request, Model)
+            else dict(request)
+        )
+        payload = {**self._meta_payload, **req_payload}
+        res = self.client.json_exception("AddPoint", {}, json.dumps(payload), headers=headers, timeout=timeout)
+        response = PointAddResponse.parse_with(res)
+        return response
+
+    def update_point(
+        self,
+        point_id: str,
+        update: Union[UpdatePointRequest, Mapping[str, object]],
+        *,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: Optional[int] = None,
+    ):
+        upd_payload = (
+            update.model_dump(by_alias=True, exclude_none=True)  # type: ignore[attr-defined]
+            if isinstance(update, Model)
+            else dict(update)
+        )
+        payload = {**self._meta_payload, "point_id": point_id, **upd_payload}
+        res = self.client.json_exception("UpdatePoint", {}, json.dumps(payload), headers=headers, timeout=timeout)
+        return res
+
+    def delete_point(
+        self,
+        request: Union[DeletePointRequest, Mapping[str, object]],
+        *,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: Optional[int] = None,
+    ):
+        req_payload = (
+            request.model_dump(by_alias=True, exclude_none=True)  # type: ignore[attr-defined]
+            if isinstance(request, Model)
+            else dict(request)
+        )
+        payload = {**self._meta_payload, **req_payload}
+        res = self.client.json_exception("DeletePoint", {}, json.dumps(payload), headers=headers, timeout=timeout)
+        return res
+
+    def search_collection(
+        self,
+        request: Union[SearchCollectionRequest, Mapping[str, object]],
+        *,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: Optional[int] = None,
+    ) -> SearchResponse:
+        req_payload = (
+            request.model_dump(by_alias=True, exclude_none=True)  # type: ignore[attr-defined]
+            if isinstance(request, Model)
+            else dict(request)
+        )
+        payload: dict = {**self._meta_payload, **req_payload, "name": self._meta.collection_name}
+        res = self.client.json_exception("SearchCollection", {}, json.dumps(payload), headers=headers, timeout=timeout)
+        response = SearchResponse.parse_with(res)
+        return response
+
+
+    def search_knowledge(
+        self,
+        request: Union[SearchKnowledgeRequest, Mapping[str, object]],
+        *,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: Optional[int] = None,
+    ) -> SearchKnowledgeResponse:
+        req_payload = (
+            request.model_dump(by_alias=True, exclude_none=True)  # type: ignore[attr-defined]
+            if isinstance(request, Model)
+            else dict(request)
+        )
+        payload: dict = {**self._meta_payload, **req_payload, "name": self._meta.collection_name}
+        res = self.client.json_exception("SearchKnowledge", {}, json.dumps(payload), headers=headers, timeout=timeout)
+        response = SearchKnowledgeResponse.parse_with(res)
+        return response