nucliadb 6.2.0.post2679__py3-none-any.whl → 6.2.1__py3-none-any.whl

nucliadb/writer/api/v1/knowledgebox.py

@@ -20,7 +20,7 @@
 import asyncio
 from functools import partial
 
-from fastapi import HTTPException, Response
+from fastapi import HTTPException
 from fastapi_versioning import version
 from starlette.requests import Request
 
@@ -32,7 +32,7 @@ from nucliadb.common.external_index_providers.exceptions import (
 from nucliadb.common.maindb.utils import get_driver
 from nucliadb.ingest.orm.exceptions import KnowledgeBoxConflict
 from nucliadb.ingest.orm.knowledgebox import KnowledgeBox
-from nucliadb.writer import logger, vectorsets
+from nucliadb.writer import logger
 from nucliadb.writer.api.utils import only_for_onprem
 from nucliadb.writer.api.v1.router import KB_PREFIX, KBS_PREFIX, api
 from nucliadb.writer.utilities import get_processing
@@ -68,6 +68,7 @@ async def create_kb_endpoint(request: Request, item: KnowledgeBoxConfig) -> Know
     except ExternalIndexCreationError as exc:
         raise HTTPException(status_code=502, detail=str(exc))
     except Exception:
+        logger.exception("Could not create KB")
         raise HTTPException(status_code=500, detail="Error creating knowledge box")
     else:
         return KnowledgeBoxObj(uuid=kbid, slug=slug)
@@ -247,47 +248,3 @@ def to_pinecone_serverless_cloud_pb(
         PineconeServerlessCloud.AZURE_EASTUS2: knowledgebox_pb2.PineconeServerlessCloud.AZURE_EASTUS2,
         PineconeServerlessCloud.GCP_US_CENTRAL1: knowledgebox_pb2.PineconeServerlessCloud.GCP_US_CENTRAL1,
     }[serverless]
-
-
-@api.post(
-    f"/{KB_PREFIX}/{{kbid}}/vectorsets/{{vectorset_id}}",
-    status_code=200,
-    summary="Add a vectorset to Knowledge Box",
-    tags=["Knowledge Boxes"],
-    # TODO: remove when the feature is mature
-    include_in_schema=False,
-)
-@requires(NucliaDBRoles.MANAGER)
-@version(1)
-async def add_vectorset(request: Request, kbid: str, vectorset_id: str) -> Response:
-    try:
-        await vectorsets.add(kbid, vectorset_id)
-    except learning_proxy.ProxiedLearningConfigError as err:
-        return Response(
-            status_code=err.status_code,
-            content=err.content,
-            media_type=err.content_type,
-        )
-    return Response(status_code=200)
-
-
-@api.delete(
-    f"/{KB_PREFIX}/{{kbid}}/vectorsets/{{vectorset_id}}",
-    status_code=200,
-    summary="Delete vectorset from Knowledge Box",
-    tags=["Knowledge Boxes"],
-    # TODO: remove when the feature is mature
-    include_in_schema=False,
-)
-@requires(NucliaDBRoles.MANAGER)
-@version(1)
-async def delete_vectorset(request: Request, kbid: str, vectorset_id: str) -> Response:
-    try:
-        await vectorsets.delete(kbid, vectorset_id)
-    except learning_proxy.ProxiedLearningConfigError as err:
-        return Response(
-            status_code=err.status_code,
-            content=err.content,
-            media_type=err.content_type,
-        )
-    return Response(status_code=200)

nucliadb/writer/api/v1/resource.py

@@ -20,7 +20,7 @@
 import asyncio
 import contextlib
 from time import time
-from typing import Optional
+from typing import Annotated, Optional
 from uuid import uuid4
 
 from fastapi import HTTPException, Query, Response
@@ -35,7 +35,7 @@ from nucliadb.common.maindb.utils import get_driver
 from nucliadb.ingest.orm.knowledgebox import KnowledgeBox
 from nucliadb.ingest.processing import ProcessingInfo, PushPayload, Source
 from nucliadb.writer import SERVICE_NAME, logger
-from nucliadb.writer.api.constants import SKIP_STORE_DEFAULT, X_NUCLIADB_USER
+from nucliadb.writer.api.constants import X_NUCLIADB_USER, X_SKIP_STORE
 from nucliadb.writer.api.v1 import transaction
 from nucliadb.writer.api.v1.router import (
     KB_PREFIX,
@@ -63,8 +63,8 @@ from nucliadb_models.writer import (
     ResourceUpdated,
     UpdateResourcePayload,
 )
-from nucliadb_protos.resources_pb2 import Metadata
-from nucliadb_protos.writer_pb2 import BrokerMessage, IndexResource
+from nucliadb_protos.resources_pb2 import FieldID, Metadata
+from nucliadb_protos.writer_pb2 import BrokerMessage, FieldIDStatus, FieldStatus, IndexResource
 from nucliadb_telemetry.errors import capture_exception
 from nucliadb_utils.authentication import requires
 from nucliadb_utils.exceptions import LimitsExceededError, SendToProcessError
@@ -90,8 +90,8 @@ async def create_resource(
     request: Request,
     item: CreateResourcePayload,
     kbid: str,
-    x_skip_store: bool = SKIP_STORE_DEFAULT,
-    x_nucliadb_user: str = X_NUCLIADB_USER,
+    x_skip_store: Annotated[bool, X_SKIP_STORE] = False,
+    x_nucliadb_user: Annotated[str, X_NUCLIADB_USER] = "",
 ):
     kb_config = await datamanagers.atomic.kb.get_config(kbid=kbid)
     if item.hidden and not (kb_config and kb_config.hidden_resources_enabled):
@@ -180,8 +180,8 @@ async def modify_resource_rslug_prefix(
     kbid: str,
     rslug: str,
     item: UpdateResourcePayload,
-    x_skip_store: bool = SKIP_STORE_DEFAULT,
-    x_nucliadb_user: str = X_NUCLIADB_USER,
+    x_skip_store: Annotated[bool, X_SKIP_STORE] = False,
+    x_nucliadb_user: Annotated[str, X_NUCLIADB_USER] = "",
 ):
     rid = await get_rid_from_slug_or_raise_error(kbid, rslug)
     return await modify_resource_endpoint(
@@ -208,8 +208,8 @@ async def modify_resource_rid_prefix(
     kbid: str,
     rid: str,
     item: UpdateResourcePayload,
-    x_skip_store: bool = SKIP_STORE_DEFAULT,
-    x_nucliadb_user: str = X_NUCLIADB_USER,
+    x_nucliadb_user: Annotated[str, X_NUCLIADB_USER] = "",
+    x_skip_store: Annotated[bool, X_SKIP_STORE] = False,
 ):
     return await modify_resource_endpoint(
         request,
@@ -371,7 +371,7 @@ async def reprocess_resource_rslug_prefix(
     request: Request,
     kbid: str,
     rslug: str,
-    x_nucliadb_user: str = X_NUCLIADB_USER,
+    x_nucliadb_user: Annotated[str, X_NUCLIADB_USER] = "",
 ):
     rid = await get_rid_from_slug_or_raise_error(kbid, rslug)
     return await _reprocess_resource(request, kbid, rid, x_nucliadb_user=x_nucliadb_user)
@@ -390,7 +390,7 @@ async def reprocess_resource_rid_prefix(
     request: Request,
     kbid: str,
     rid: str,
-    x_nucliadb_user: str = X_NUCLIADB_USER,
+    x_nucliadb_user: Annotated[str, X_NUCLIADB_USER] = "",
 ):
     return await _reprocess_resource(request, kbid, rid, x_nucliadb_user=x_nucliadb_user)
 
@@ -422,6 +422,7 @@ async def _reprocess_resource(
     storage = await get_storage(service_name=SERVICE_NAME)
     driver = get_driver()
 
+    writer = BrokerMessage()
     async with driver.transaction() as txn:
         kb = KnowledgeBox(txn, storage, kbid)
 
@@ -430,8 +431,14 @@ async def _reprocess_resource(
             raise HTTPException(status_code=404, detail="Resource does not exist")
 
         await extract_fields(resource=resource, toprocess=toprocess)
+        for field_type, field_id in resource.fields.keys():
+            writer.field_statuses.append(
+                FieldIDStatus(
+                    id=FieldID(field_type=field_type, field=field_id),
+                    status=FieldStatus.Status.PENDING,
+                )
+            )
 
-    writer = BrokerMessage()
     writer.kbid = kbid
     writer.uuid = rid
     writer.source = BrokerMessage.MessageSource.WRITER

nucliadb/writer/api/v1/services.py

@@ -23,6 +23,7 @@ from starlette.requests import Request
 
 from nucliadb.common import datamanagers
 from nucliadb.common.datamanagers.exceptions import KnowledgeBoxNotFound
+from nucliadb.common.models_utils import to_proto
 from nucliadb.models.responses import (
     HTTPConflict,
     HTTPInternalServerError,
@@ -173,7 +174,15 @@ async def delete_entities(request: Request, kbid: str, group: str):
 @requires(NucliaDBRoles.WRITER)
 @version(1)
 async def set_labelset_endpoint(request: Request, kbid: str, labelset: str, item: LabelSet):
+    if item.title is None:
+        item.title = labelset
+
     try:
+        labelsets = await datamanagers.atomic.labelset.get_all(kbid=kbid)
+        labelset_titles = [ls.title.lower() for (k, ls) in labelsets.labelset.items() if k != labelset]
+        if item.title.lower() in labelset_titles:
+            raise HTTPException(status_code=422, detail="Duplicated labelset titles are not allowed")
+
         await set_labelset(kbid, labelset, item)
     except KnowledgeBoxNotFound:
         raise HTTPException(status_code=404, detail="Knowledge Box does not exist")
@@ -240,7 +249,7 @@ async def delete_labelset(kbid: str, labelset_id: str):
 async def set_custom_synonyms(request: Request, kbid: str, item: KnowledgeBoxSynonyms):
     if not await datamanagers.atomic.kb.exists_kb(kbid=kbid):
         raise HTTPException(status_code=404, detail="Knowledge Box does not exist")
-    synonyms = item.to_message()
+    synonyms = to_proto.kb_synonyms(item)
     await datamanagers.atomic.synonyms.set(kbid=kbid, synonyms=synonyms)
     return Response(status_code=204)
 

nucliadb/writer/api/v1/upload.py

@@ -23,10 +23,9 @@ import uuid
 from datetime import datetime
 from hashlib import md5
 from io import BytesIO
-from typing import Optional
+from typing import Annotated, Optional
 
 from fastapi import HTTPException
-from fastapi.params import Header
 from fastapi.requests import Request
 from fastapi.responses import Response
 from fastapi_versioning import version
@@ -37,6 +36,7 @@ from nucliadb.ingest.orm.utils import set_title
 from nucliadb.ingest.processing import PushPayload, Source
 from nucliadb.models.responses import HTTPClientError
 from nucliadb.writer import SERVICE_NAME
+from nucliadb.writer.api.constants import X_EXTRACT_STRATEGY, X_FILENAME, X_LANGUAGE, X_MD5, X_PASSWORD
 from nucliadb.writer.api.v1 import transaction
 from nucliadb.writer.api.v1.resource import (
     get_rid_from_slug_or_raise_error,
@@ -64,8 +64,8 @@ from nucliadb_models import content_types
 from nucliadb_models.resource import NucliaDBRoles
 from nucliadb_models.utils import FieldIdString
 from nucliadb_models.writer import CreateResourcePayload, ResourceFileUploaded
-from nucliadb_protos.resources_pb2 import CloudFile, FieldFile, Metadata
-from nucliadb_protos.writer_pb2 import BrokerMessage
+from nucliadb_protos.resources_pb2 import CloudFile, FieldFile, FieldID, FieldType, Metadata
+from nucliadb_protos.writer_pb2 import BrokerMessage, FieldIDStatus, FieldStatus
 from nucliadb_utils.authentication import requires_one
 from nucliadb_utils.exceptions import LimitsExceededError, SendToProcessError
 from nucliadb_utils.storages.storage import KB_RESOURCE_FIELD
@@ -74,7 +74,7 @@ from nucliadb_utils.utilities import (
     get_storage,
 )
 
-from .router import KB_PREFIX, RESOURCE_PREFIX, RSLUG_PREFIX, api
+from .router import KB_PREFIX, RESOURCE_PREFIX, RESOURCES_PREFIX, RSLUG_PREFIX, api
 
 TUS_HEADERS = {
     "Tus-Resumable": "1.0.0",
@@ -142,9 +142,12 @@ async def tus_post_rslug_prefix(
     rslug: str,
     field: FieldIdString,
     item: Optional[CreateResourcePayload] = None,
+    x_extract_strategy: Annotated[Optional[str], X_EXTRACT_STRATEGY] = None,
 ) -> Response:
     rid = await get_rid_from_slug_or_raise_error(kbid, rslug)
-    return await _tus_post(request, kbid, item, path_rid=rid, field_id=field)
+    return await _tus_post(
+        request, kbid, item, path_rid=rid, field_id=field, extract_strategy=x_extract_strategy
+    )
 
 
 @api.post(
@@ -161,8 +164,11 @@ async def tus_post_rid_prefix(
     path_rid: str,
     field: FieldIdString,
     item: Optional[CreateResourcePayload] = None,
+    x_extract_strategy: Annotated[Optional[str], X_EXTRACT_STRATEGY] = None,
 ) -> Response:
-    return await _tus_post(request, kbid, item, path_rid=path_rid, field_id=field)
+    return await _tus_post(
+        request, kbid, item, path_rid=path_rid, field_id=field, extract_strategy=x_extract_strategy
+    )
 
 
 @api.post(
@@ -177,8 +183,9 @@ async def tus_post(
     request: Request,
     kbid: str,
     item: Optional[CreateResourcePayload] = None,
+    x_extract_strategy: Annotated[Optional[str], X_EXTRACT_STRATEGY] = None,
 ) -> Response:
-    return await _tus_post(request, kbid, item)
+    return await _tus_post(request, kbid, item, extract_strategy=x_extract_strategy)
 
 
 # called by one the three POST above - there are defined distinctly to produce clean API doc
@@ -188,6 +195,7 @@ async def _tus_post(
     item: Optional[CreateResourcePayload] = None,
     path_rid: Optional[str] = None,
     field_id: Optional[str] = None,
+    extract_strategy: Optional[str] = None,
 ) -> Response:
     """
     An empty POST request is used to create a new upload resource.
@@ -219,7 +227,7 @@ async def _tus_post(
         size = int(request.headers["upload-length"])
     else:
         if not deferred_length:
-            raise HTTPPreconditionFailed(detail="We need upload-length header")
+            raise HTTPPreconditionFailed(detail="upload-length header is required")
 
     if "tus-resumable" not in request.headers:
         raise HTTPPreconditionFailed(detail="TUS needs a TUS version")
@@ -285,6 +293,7 @@ async def _tus_post(
         deferred_length=deferred_length,
         offset=0,
         item=creation_payload,
+        extract_strategy=extract_strategy,
     )
 
     if size is not None:
@@ -502,7 +511,7 @@ async def _tus_patch(
 
     if offset != dm.offset:
         raise HTTPConflict(
-            detail=f"Current upload offset({offset}) does not match " f"object offset {dm.offset}"
+            detail=f"Current upload offset({offset}) does not match object offset {dm.offset}"
         )
 
     storage_manager = get_storage_manager()
@@ -535,8 +544,8 @@ async def _tus_patch(
             raise AttributeError()
         path = await storage_manager.finish(dm)
         headers["Tus-Upload-Finished"] = "1"
-        headers["NDB-Resource"] = f"/{KB_PREFIX}/{kbid}/resources/{rid}"
-        headers["NDB-Field"] = f"/{KB_PREFIX}/{kbid}/resources/{rid}/field/{field}"
+        headers["NDB-Resource"] = f"/{KB_PREFIX}/{kbid}/{RESOURCES_PREFIX}/{rid}"
+        headers["NDB-Field"] = f"/{KB_PREFIX}/{kbid}/{RESOURCES_PREFIX}/{rid}/field/{field}"
 
         item_payload = dm.get("item")
         creation_payload = None
@@ -569,6 +578,7 @@ async def _tus_patch(
                 request=request,
                 bucket=storage_manager.storage.get_bucket_name(kbid),
                 item=creation_payload,
+                extract_strategy=dm.get("extract_strategy") or None,
             )
         except LimitsExceededError as exc:
             raise HTTPException(status_code=exc.status_code, detail=exc.detail)
@@ -602,10 +612,11 @@ async def upload_rslug_prefix(
     kbid: str,
     rslug: str,
     field: FieldIdString,
-    x_filename: Optional[list[str]] = Header(None),  # type: ignore
-    x_password: Optional[list[str]] = Header(None),  # type: ignore
-    x_language: Optional[list[str]] = Header(None),  # type: ignore
-    x_md5: Optional[list[str]] = Header(None),  # type: ignore
+    x_filename: Annotated[Optional[str], X_FILENAME] = None,
+    x_password: Annotated[Optional[str], X_PASSWORD] = None,
+    x_language: Annotated[Optional[str], X_LANGUAGE] = None,
+    x_md5: Annotated[Optional[str], X_MD5] = None,
+    x_extract_strategy: Annotated[Optional[str], X_EXTRACT_STRATEGY] = None,
 ) -> ResourceFileUploaded:
     rid = await get_rid_from_slug_or_raise_error(kbid, rslug)
     return await _upload(
@@ -617,6 +628,7 @@ async def upload_rslug_prefix(
         x_password=x_password,
         x_language=x_language,
         x_md5=x_md5,
+        x_extract_strategy=x_extract_strategy,
     )
 
 
@@ -634,10 +646,11 @@ async def upload_rid_prefix(
     kbid: str,
     path_rid: str,
     field: FieldIdString,
-    x_filename: Optional[list[str]] = Header(None),  # type: ignore
-    x_password: Optional[list[str]] = Header(None),  # type: ignore
-    x_language: Optional[list[str]] = Header(None),  # type: ignore
-    x_md5: Optional[list[str]] = Header(None),  # type: ignore
+    x_filename: Annotated[Optional[str], X_FILENAME] = None,
+    x_password: Annotated[Optional[str], X_PASSWORD] = None,
+    x_language: Annotated[Optional[str], X_LANGUAGE] = None,
+    x_md5: Annotated[Optional[str], X_MD5] = None,
+    x_extract_strategy: Annotated[Optional[str], X_EXTRACT_STRATEGY] = None,
 ) -> ResourceFileUploaded:
     return await _upload(
         request,
@@ -648,6 +661,7 @@ async def upload_rid_prefix(
         x_password=x_password,
         x_language=x_language,
         x_md5=x_md5,
+        x_extract_strategy=x_extract_strategy,
     )
 
 
@@ -663,10 +677,11 @@ async def upload_rid_prefix(
 async def upload(
     request: StarletteRequest,
     kbid: str,
-    x_filename: Optional[list[str]] = Header(None),  # type: ignore
-    x_password: Optional[list[str]] = Header(None),  # type: ignore
-    x_language: Optional[list[str]] = Header(None),  # type: ignore
-    x_md5: Optional[list[str]] = Header(None),  # type: ignore
+    x_filename: Annotated[Optional[str], X_FILENAME] = None,
+    x_password: Annotated[Optional[str], X_PASSWORD] = None,
+    x_language: Annotated[Optional[str], X_LANGUAGE] = None,
+    x_md5: Annotated[Optional[str], X_MD5] = None,
+    x_extract_strategy: Annotated[Optional[str], X_EXTRACT_STRATEGY] = None,
 ) -> ResourceFileUploaded:
     return await _upload(
         request,
@@ -675,6 +690,7 @@ async def upload(
         x_password=x_password,
         x_language=x_language,
         x_md5=x_md5,
+        x_extract_strategy=x_extract_strategy,
     )
 
 
@@ -684,17 +700,18 @@ async def _upload(
     kbid: str,
     path_rid: Optional[str] = None,
     field: Optional[str] = None,
-    x_filename: Optional[list[str]] = Header(None),  # type: ignore
-    x_password: Optional[list[str]] = Header(None),  # type: ignore
-    x_language: Optional[list[str]] = Header(None),  # type: ignore
-    x_md5: Optional[list[str]] = Header(None),  # type: ignore
+    x_filename: Optional[str] = None,
+    x_password: Optional[str] = None,
+    x_language: Optional[str] = None,
+    x_md5: Optional[str] = None,
+    x_extract_strategy: Optional[str] = None,
 ) -> ResourceFileUploaded:
     if path_rid is not None:
         await validate_rid_exists_or_raise_error(kbid, path_rid)
 
     await maybe_back_pressure(request, kbid, resource_uuid=path_rid)
 
-    md5_user = x_md5[0] if x_md5 is not None and len(x_md5) > 0 else None
+    md5_user = x_md5
     path, rid, valid_field = await validate_field_upload(kbid, path_rid, field, md5_user)
     dm = get_dm()
     storage_manager = get_storage_manager()
@@ -715,8 +732,8 @@ async def _upload(
 
     await dm.start(request)
 
-    if x_filename and len(x_filename):
-        filename = maybe_b64decode(x_filename[0])
+    if x_filename is not None:
+        filename = maybe_b64decode(x_filename)
     else:
         filename = uuid.uuid4().hex
 
@@ -772,15 +789,16 @@ async def _upload(
             content_type=content_type,
             override_resource_title=implies_resource_creation,
             filename=filename,
-            password=x_password[0] if x_password and len(x_password) else None,
-            language=x_language[0] if x_language and len(x_language) else None,
-            md5=x_md5[0] if x_md5 and len(x_md5) else None,
+            password=x_password,
+            language=x_language,
+            md5=x_md5,
             field=valid_field,
             source=storage_manager.storage.source,
             rid=rid,
             path=path,
             request=request,
             bucket=storage_manager.storage.get_bucket_name(kbid),
+            extract_strategy=x_extract_strategy,
         )
     except LimitsExceededError as exc:
         raise HTTPException(status_code=exc.status_code, detail=exc.detail)
@@ -840,6 +858,7 @@ async def store_file_on_nuclia_db(
     language: Optional[str] = None,
     md5: Optional[str] = None,
     item: Optional[CreateResourcePayload] = None,
+    extract_strategy: Optional[str] = None,
 ) -> Optional[int]:
     # File is on NucliaDB Storage at path
     partitioning = get_partitioning()
@@ -921,10 +940,18 @@ async def store_file_on_nuclia_db(
             file_field.language = language
         if password:
             file_field.password = password
+        if extract_strategy is not None:
+            file_field.extract_strategy = extract_strategy
 
         writer.files[field].CopyFrom(file_field)
         # Do not store passwords on maindb
         writer.files[field].ClearField("password")
+        writer.field_statuses.append(
+            FieldIDStatus(
+                id=FieldID(field_type=FieldType.FILE, field=field),
+                status=FieldStatus.Status.PENDING,
+            )
+        )
 
         toprocess.filefield[field] = await processing.convert_internal_filefield_to_str(
             file_field, storage=storage

nucliadb/writer/{vectorsets.py → api/v1/vectorsets.py}

@@ -17,37 +17,57 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
-# Copyright (C) 2021 Bosutech XXI S.L.
-#
-# nucliadb is offered under the AGPL v3.0 and as commercial software.
-# For commercial licensing, contact us at info@nuclia.com.
-#
-# AGPL:
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as
-# published by the Free Software Foundation, either version 3 of the
-# License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU Affero General Public License for more details.
-#
-# You should have received a copy of the GNU Affero General Public License
-# along with this program. If not, see <http://www.gnu.org/licenses/>.
-#
+
+from fastapi import HTTPException, Response
+from fastapi_versioning import version
+from starlette.requests import Request
 
 from nucliadb import learning_proxy
 from nucliadb.common import datamanagers
 from nucliadb.ingest.orm.exceptions import VectorSetConflict
 from nucliadb.ingest.orm.knowledgebox import KnowledgeBox
 from nucliadb.writer import logger
+from nucliadb.writer.api.v1.router import KB_PREFIX, api
+from nucliadb_models.resource import (
+    NucliaDBRoles,
+)
+from nucliadb_models.vectorsets import CreatedVectorSet
 from nucliadb_protos import knowledgebox_pb2
 from nucliadb_telemetry import errors
+from nucliadb_utils.authentication import requires_one
 from nucliadb_utils.utilities import get_storage
 
 
-async def add(kbid: str, vectorset_id: str) -> None:
+@api.post(
+    f"/{KB_PREFIX}/{{kbid}}/vectorsets/{{vectorset_id}}",
+    status_code=201,
+    summary="Add a vector set to Knowledge Box",
+    tags=["VectorSets"],
+    # TODO: remove when the feature is mature
+    include_in_schema=False,
+)
+@requires_one([NucliaDBRoles.MANAGER, NucliaDBRoles.WRITER])
+@version(1)
+async def add_vectorset(request: Request, kbid: str, vectorset_id: str) -> CreatedVectorSet:
+    try:
+        await _add_vectorset(kbid, vectorset_id)
+
+    except learning_proxy.ProxiedLearningConfigError as err:
+        raise HTTPException(
+            status_code=err.status_code,
+            detail=err.content,
+        )
+
+    except VectorSetConflict:
+        raise HTTPException(
+            status_code=409,
+            detail="A vectorset with this embedding model already exists in your KB",
+        )
+
+    return CreatedVectorSet(id=vectorset_id)
+
+
+async def _add_vectorset(kbid: str, vectorset_id: str) -> None:
     # First off, add the vectorset to the learning configuration if it's not already there
     lconfig = await learning_proxy.get_configuration(kbid)
     assert lconfig is not None
@@ -59,34 +79,12 @@ async def add(kbid: str, vectorset_id: str) -> None:
         assert lconfig is not None
 
     # Then, add the vectorset to the index if it's not already there
+    storage = await get_storage()
+    vectorset_config = get_vectorset_config(lconfig, vectorset_id)
     async with datamanagers.with_rw_transaction() as txn:
-        kbobj = KnowledgeBox(txn, await get_storage(), kbid)
-        vectorset_config = get_vectorset_config(lconfig, vectorset_id)
-        try:
-            await kbobj.create_vectorset(vectorset_config)
-            await txn.commit()
-        except VectorSetConflict:
-            # Vectorset already exists, nothing to do
-            return
-
-
-async def delete(kbid: str, vectorset_id: str) -> None:
-    lconfig = await learning_proxy.get_configuration(kbid)
-    if lconfig is not None:
-        semantic_models = lconfig.model_dump()["semantic_models"]
-        if vectorset_id in semantic_models:
-            semantic_models.remove(vectorset_id)
-            await learning_proxy.update_configuration(kbid, {"semantic_models": semantic_models})
-    try:
-        async with datamanagers.with_rw_transaction() as txn:
-            kbobj = KnowledgeBox(txn, await get_storage(), kbid)
-            await kbobj.delete_vectorset(vectorset_id=vectorset_id)
-            await txn.commit()
-    except Exception as ex:
-        errors.capture_exception(ex)
-        logger.exception(
-            "Could not delete vectorset from index", extra={"kbid": kbid, "vectorset_id": vectorset_id}
-        )
+        kbobj = KnowledgeBox(txn, storage, kbid)
+        await kbobj.create_vectorset(vectorset_config)
+        await txn.commit()
 
 
 def get_vectorset_config(
@@ -123,3 +121,57 @@ def get_vectorset_config(
         vectorset_index_config.normalize_vectors = False
     vectorset_config.vectorset_index_config.CopyFrom(vectorset_index_config)
     return vectorset_config
+
+
+@api.delete(
+    f"/{KB_PREFIX}/{{kbid}}/vectorsets/{{vectorset_id}}",
+    status_code=204,
+    summary="Delete vector set from Knowledge Box",
+    tags=["VectorSets"],
+    # TODO: remove when the feature is mature
+    include_in_schema=False,
+)
+@requires_one([NucliaDBRoles.MANAGER, NucliaDBRoles.WRITER])
+@version(1)
+async def delete_vectorset(request: Request, kbid: str, vectorset_id: str) -> Response:
+    try:
+        await _delete_vectorset(kbid, vectorset_id)
+
+    except VectorSetConflict as exc:
+        raise HTTPException(
+            status_code=409,
+            detail=str(exc),
+        )
+
+    except learning_proxy.ProxiedLearningConfigError as err:
+        raise HTTPException(
+            status_code=err.status_code,
+            detail=err.content,
+        )
+
+    return Response(status_code=204)
+
+
+async def _delete_vectorset(kbid: str, vectorset_id: str) -> None:
+    lconfig = await learning_proxy.get_configuration(kbid)
+    if lconfig is not None:
+        semantic_models = lconfig.model_dump()["semantic_models"]
+        if vectorset_id in semantic_models:
+            semantic_models.remove(vectorset_id)
+            await learning_proxy.update_configuration(kbid, {"semantic_models": semantic_models})
+
+    storage = await get_storage()
+    try:
+        async with datamanagers.with_rw_transaction() as txn:
+            kbobj = KnowledgeBox(txn, storage, kbid)
+            await kbobj.delete_vectorset(vectorset_id=vectorset_id)
+            await txn.commit()
+
+    except VectorSetConflict:
+        # caller should handle this error
+        raise
+    except Exception as ex:
+        errors.capture_exception(ex)
+        logger.exception(
+            "Could not delete vectorset from index", extra={"kbid": kbid, "vectorset_id": vectorset_id}
+        )