usecortex-ai 0.3.4__py3-none-any.whl → 0.3.5__py3-none-any.whl

usecortex_ai/upload/raw_client.py

@@ -20,9 +20,11 @@ from ..errors.unprocessable_entity_error import UnprocessableEntityError
 from ..types.actual_error_response import ActualErrorResponse
 from ..types.app_sources_upload_data import AppSourcesUploadData
 from ..types.batch_upload_data import BatchUploadData
+from ..types.markdown_upload_request import MarkdownUploadRequest
 from ..types.processing_status import ProcessingStatus
 from ..types.single_upload_data import SingleUploadData
 from ..types.source_model import SourceModel
+from ..types.webpage_scrape_request import WebpageScrapeRequest
 
 # this is used as the default value for optional parameters
 OMIT = typing.cast(typing.Any, ...)
@@ -1487,55 +1489,47 @@ class RawUploadClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    def upload_embeddings(
+    def batch_upload_markdown(
         self,
         *,
         tenant_id: str,
-        embeddings: typing.Sequence[typing.Sequence[float]],
+        request: typing.Sequence[MarkdownUploadRequest],
         sub_tenant_id: typing.Optional[str] = None,
-        file_id: typing.Optional[str] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> HttpResponse[SingleUploadData]:
+    ) -> HttpResponse[BatchUploadData]:
         """
-        Upload pre-computed embeddings for advanced similarity search.
-
-        This endpoint accepts vector embeddings that you've generated externally, allowing you to integrate with custom embedding models or existing vector databases. The embeddings represent chunks of your content as numerical vectors.
+        Upload multiple markdown/text documents simultaneously for efficient bulk processing.
 
-        The system stores these embeddings and makes them available for semantic search and similarity matching. Use this when you want to leverage specialized embedding models or have existing vector representations.
+        This endpoint allows you to upload several markdown or text contents at once. Each content item gets processed asynchronously, and you can track the progress using their returned file IDs.
 
         Parameters
         ----------
         tenant_id : str
             Unique identifier for the tenant/organization
 
-        embeddings : typing.Sequence[typing.Sequence[float]]
-            The embeddings of source you want to index
+        request : typing.Sequence[MarkdownUploadRequest]
 
         sub_tenant_id : typing.Optional[str]
             Optional sub-tenant identifier used to organize data within a tenant. If omitted, the default sub-tenant created during tenant setup will be used.
 
-        file_id : typing.Optional[str]
-            The Source ID of the target source you want to index
-
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        HttpResponse[SingleUploadData]
+        HttpResponse[BatchUploadData]
             Successful Response
         """
         _response = self._client_wrapper.httpx_client.request(
-            "upload/upload_embeddings",
+            "upload/batch_upload_markdown",
             method="POST",
             params={
                 "tenant_id": tenant_id,
                 "sub_tenant_id": sub_tenant_id,
             },
-            json={
-                "embeddings": embeddings,
-                "file_id": file_id,
-            },
+            json=convert_and_respect_annotation_metadata(
+                object_=request, annotation=typing.Sequence[MarkdownUploadRequest], direction="write"
+            ),
             headers={
                 "content-type": "application/json",
             },
@@ -1545,9 +1539,9 @@ class RawUploadClient:
         try:
             if 200 <= _response.status_code < 300:
                 _data = typing.cast(
-                    SingleUploadData,
+                    BatchUploadData,
                     parse_obj_as(
-                        type_=SingleUploadData,  # type: ignore
+                        type_=BatchUploadData,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
@@ -1634,50 +1628,47 @@ class RawUploadClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    def update_embeddings(
+    def batch_upload_text(
         self,
         *,
         tenant_id: str,
+        request: typing.Sequence[MarkdownUploadRequest],
         sub_tenant_id: typing.Optional[str] = None,
-        embeddings: typing.Optional[typing.Dict[str, typing.Sequence[float]]] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> HttpResponse[SingleUploadData]:
+    ) -> HttpResponse[BatchUploadData]:
         """
-        Update existing embeddings with new vector representations.
+        Upload multiple markdown/text documents simultaneously for efficient bulk processing.
 
-        This endpoint allows you to modify embeddings that are already stored in your knowledge base. Provide updated vector representations for specific chunks of content, identified by their chunk IDs.
-
-        The system will replace the existing embeddings with your new ones, ensuring that similarity searches reflect the most current vector representations. Use this when you need to update embeddings due to model improvements or content changes.
+        This endpoint allows you to upload several markdown or text contents at once. Each content item gets processed asynchronously, and you can track the progress using their returned file IDs.
 
         Parameters
         ----------
         tenant_id : str
             Unique identifier for the tenant/organization
 
+        request : typing.Sequence[MarkdownUploadRequest]
+
         sub_tenant_id : typing.Optional[str]
             Optional sub-tenant identifier used to organize data within a tenant. If omitted, the default sub-tenant created during tenant setup will be used.
 
-        embeddings : typing.Optional[typing.Dict[str, typing.Sequence[float]]]
-            The embeddings of source you want to index
-
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        HttpResponse[SingleUploadData]
+        HttpResponse[BatchUploadData]
             Successful Response
         """
         _response = self._client_wrapper.httpx_client.request(
-            "upload/update_embeddings",
-            method="PATCH",
+            "upload/batch_upload_text",
+            method="POST",
             params={
                 "tenant_id": tenant_id,
                 "sub_tenant_id": sub_tenant_id,
             },
-            json={
-                "embeddings": embeddings,
-            },
+            json=convert_and_respect_annotation_metadata(
+                object_=request, annotation=typing.Sequence[MarkdownUploadRequest], direction="write"
+            ),
             headers={
                 "content-type": "application/json",
             },
@@ -1687,9 +1678,9 @@ class RawUploadClient:
         try:
             if 200 <= _response.status_code < 300:
                 _data = typing.cast(
-                    SingleUploadData,
+                    BatchUploadData,
                     parse_obj_as(
-                        type_=SingleUploadData,  # type: ignore
+                        type_=BatchUploadData,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
@@ -1776,35 +1767,35 @@ class RawUploadClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    def scrape_webpage(
+    def upload_embeddings(
         self,
         *,
-        web_url: str,
         tenant_id: str,
+        embeddings: typing.Sequence[typing.Sequence[float]],
         sub_tenant_id: typing.Optional[str] = None,
-        file_id: typing.Optional[str] = None,
+        file_id: typing.Optional[str] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
     ) -> HttpResponse[SingleUploadData]:
         """
-        Extract and index content from web pages automatically.
+        Upload pre-computed embeddings for advanced similarity search.
 
-        This endpoint initiates web scraping for the specified URL, extracting the main content, text, and structure from the webpage. It's perfect for capturing articles, documentation, or any web content you want to include in your knowledge base.
+        This endpoint accepts vector embeddings that you've generated externally, allowing you to integrate with custom embedding models or existing vector databases. The embeddings represent chunks of your content as numerical vectors.
 
-        The system processes the webpage content asynchronously, cleaning and structuring the information for optimal search and retrieval. Use this when you need to add web content without manual copying and pasting.
+        The system stores these embeddings and makes them available for semantic search and similarity matching. Use this when you want to leverage specialized embedding models or have existing vector representations.
 
         Parameters
         ----------
-        web_url : str
-            The URL of the webpage to scrape and index
-
         tenant_id : str
             Unique identifier for the tenant/organization
 
+        embeddings : typing.Sequence[typing.Sequence[float]]
+            The embeddings of source you want to index
+
         sub_tenant_id : typing.Optional[str]
             Optional sub-tenant identifier used to organize data within a tenant. If omitted, the default sub-tenant created during tenant setup will be used.
 
         file_id : typing.Optional[str]
-            Optional custom file ID for the scraped content. If not provided, a unique ID will be generated
+            The Source ID of the target source you want to index
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
@@ -1815,17 +1806,18 @@ class RawUploadClient:
             Successful Response
         """
         _response = self._client_wrapper.httpx_client.request(
-            "upload/scrape_webpage",
+            "upload/upload_embeddings",
             method="POST",
             params={
-                "web_url": web_url,
                 "tenant_id": tenant_id,
                 "sub_tenant_id": sub_tenant_id,
+            },
+            json={
+                "embeddings": embeddings,
                 "file_id": file_id,
             },
-            data={},
             headers={
-                "content-type": "application/x-www-form-urlencoded",
+                "content-type": "application/json",
             },
             request_options=request_options,
             omit=OMIT,
@@ -1922,36 +1914,32 @@ class RawUploadClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    def update_webpage(
+    def update_embeddings(
         self,
         *,
-        web_url: str,
-        source_id: str,
         tenant_id: str,
         sub_tenant_id: typing.Optional[str] = None,
+        embeddings: typing.Optional[typing.Dict[str, typing.Sequence[float]]] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
     ) -> HttpResponse[SingleUploadData]:
         """
-        Update web scraping content with fresh data from the source URL.
+        Update existing embeddings with new vector representations.
 
-        This endpoint refreshes the content for an existing web scraping job. Provide the source ID of the webpage content you want to update, and the system will re-scrape the URL to capture any changes.
+        This endpoint allows you to modify embeddings that are already stored in your knowledge base. Provide updated vector representations for specific chunks of content, identified by their chunk IDs.
 
-        The updated content gets processed asynchronously and re-indexed in your knowledge base. Use this to keep web content current when the source pages are frequently updated.
+        The system will replace the existing embeddings with your new ones, ensuring that similarity searches reflect the most current vector representations. Use this when you need to update embeddings due to model improvements or content changes.
 
         Parameters
         ----------
-        web_url : str
-            The URL of the webpage to re-scrape
-
-        source_id : str
-            The file ID of the existing web scraping job to update
-
         tenant_id : str
             Unique identifier for the tenant/organization
 
         sub_tenant_id : typing.Optional[str]
             Optional sub-tenant identifier used to organize data within a tenant. If omitted, the default sub-tenant created during tenant setup will be used.
 
+        embeddings : typing.Optional[typing.Dict[str, typing.Sequence[float]]]
+            The embeddings of source you want to index
+
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
@@ -1961,17 +1949,17 @@ class RawUploadClient:
             Successful Response
         """
         _response = self._client_wrapper.httpx_client.request(
-            "upload/update_webpage",
+            "upload/update_embeddings",
             method="PATCH",
             params={
-                "web_url": web_url,
-                "source_id": source_id,
                 "tenant_id": tenant_id,
                 "sub_tenant_id": sub_tenant_id,
             },
-            data={},
+            json={
+                "embeddings": embeddings,
+            },
             headers={
-                "content-type": "application/x-www-form-urlencoded",
+                "content-type": "application/json",
             },
             request_options=request_options,
             omit=OMIT,
@@ -2068,66 +2056,114 @@ class RawUploadClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    def delete_source(
+    def scrape_webpage(
         self,
         *,
+        web_url: str,
         tenant_id: str,
-        source_ids: typing.Sequence[str],
-        sub_tenant_id: typing.Optional[str] = OMIT,
+        sub_tenant_id: typing.Optional[str] = None,
+        file_id: typing.Optional[str] = None,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> HttpResponse[typing.Optional[typing.Any]]:
+    ) -> HttpResponse[SingleUploadData]:
         """
-        Remove documents and content from your knowledge base.
+        Extract and index content from web pages automatically.
 
-        This endpoint permanently deletes the specified sources from your knowledge base. Once deleted, the content will no longer be available for search or retrieval.
+        This endpoint initiates web scraping for the specified URL, extracting the main content, text, and structure from the webpage. It's perfect for capturing articles, documentation, or any web content you want to include in your knowledge base.
 
-        Use this carefully as the action cannot be undone. The system will confirm successful deletion of each source ID you specify.
+        The system processes the webpage content asynchronously, cleaning and structuring the information for optimal search and retrieval. Use this when you need to add web content without manual copying and pasting.
 
         Parameters
         ----------
+        web_url : str
+            The URL of the webpage to scrape and index
+
         tenant_id : str
             Unique identifier for the tenant/organization
 
-        source_ids : typing.Sequence[str]
-            List of source IDs to delete
-
         sub_tenant_id : typing.Optional[str]
             Optional sub-tenant identifier used to organize data within a tenant. If omitted, the default sub-tenant created during tenant setup will be used.
 
+        file_id : typing.Optional[str]
+            Optional custom file ID for the scraped content. If not provided, a unique ID will be generated
+
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        HttpResponse[typing.Optional[typing.Any]]
+        HttpResponse[SingleUploadData]
             Successful Response
         """
         _response = self._client_wrapper.httpx_client.request(
-            "upload/delete_source",
-            method="DELETE",
-            json={
+            "upload/scrape_webpage",
+            method="POST",
+            params={
+                "web_url": web_url,
                 "tenant_id": tenant_id,
-                "source_ids": source_ids,
                 "sub_tenant_id": sub_tenant_id,
+                "file_id": file_id,
             },
+            data={},
             headers={
-                "content-type": "application/json",
+                "content-type": "application/x-www-form-urlencoded",
             },
             request_options=request_options,
             omit=OMIT,
         )
         try:
-            if _response is None or not _response.text.strip():
-                return HttpResponse(response=_response, data=None)
             if 200 <= _response.status_code < 300:
                 _data = typing.cast(
-                    typing.Optional[typing.Any],
+                    SingleUploadData,
                     parse_obj_as(
-                        type_=typing.Optional[typing.Any],  # type: ignore
+                        type_=SingleUploadData,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
                 return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
             if _response.status_code == 422:
                 raise UnprocessableEntityError(
                     headers=dict(_response.headers),
@@ -2139,34 +2175,60 @@ class RawUploadClient:
                         ),
                     ),
                 )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 503:
+                raise ServiceUnavailableError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
             _response_json = _response.json()
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    def delete_memory(
+    def update_webpage(
         self,
         *,
+        web_url: str,
+        source_id: str,
         tenant_id: str,
-        source_ids: typing.Sequence[str],
-        sub_tenant_id: typing.Optional[str] = OMIT,
+        sub_tenant_id: typing.Optional[str] = None,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> HttpResponse[typing.Optional[typing.Any]]:
+    ) -> HttpResponse[SingleUploadData]:
         """
-        Remove documents and content from your knowledge base.
+        Update web scraping content with fresh data from the source URL.
 
-        This endpoint permanently deletes the specified sources from your knowledge base. Once deleted, the content will no longer be available for search or retrieval.
+        This endpoint refreshes the content for an existing web scraping job. Provide the source ID of the webpage content you want to update, and the system will re-scrape the URL to capture any changes.
 
-        Use this carefully as the action cannot be undone. The system will confirm successful deletion of each source ID you specify.
+        The updated content gets processed asynchronously and re-indexed in your knowledge base. Use this to keep web content current when the source pages are frequently updated.
 
         Parameters
         ----------
+        web_url : str
+            The URL of the webpage to re-scrape
+
+        source_id : str
+            The file ID of the existing web scraping job to update
+
         tenant_id : str
             Unique identifier for the tenant/organization
 
-        source_ids : typing.Sequence[str]
-            List of source IDs to delete
-
         sub_tenant_id : typing.Optional[str]
             Optional sub-tenant identifier used to organize data within a tenant. If omitted, the default sub-tenant created during tenant setup will be used.
 
@@ -2175,35 +2237,79 @@ class RawUploadClient:
 
         Returns
         -------
-        HttpResponse[typing.Optional[typing.Any]]
+        HttpResponse[SingleUploadData]
             Successful Response
         """
         _response = self._client_wrapper.httpx_client.request(
-            "upload/delete_memory",
-            method="DELETE",
-            json={
+            "upload/update_webpage",
+            method="PATCH",
+            params={
+                "web_url": web_url,
+                "source_id": source_id,
                 "tenant_id": tenant_id,
-                "source_ids": source_ids,
                 "sub_tenant_id": sub_tenant_id,
             },
+            data={},
             headers={
-                "content-type": "application/json",
+                "content-type": "application/x-www-form-urlencoded",
             },
             request_options=request_options,
             omit=OMIT,
         )
         try:
-            if _response is None or not _response.text.strip():
-                return HttpResponse(response=_response, data=None)
             if 200 <= _response.status_code < 300:
                 _data = typing.cast(
-                    typing.Optional[typing.Any],
+                    SingleUploadData,
                     parse_obj_as(
-                        type_=typing.Optional[typing.Any],  # type: ignore
+                        type_=SingleUploadData,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
                 return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
             if _response.status_code == 422:
                 raise UnprocessableEntityError(
                     headers=dict(_response.headers),
@@ -2215,34 +2321,197 @@ class RawUploadClient:
                         ),
                     ),
                 )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 503:
+                raise ServiceUnavailableError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
             _response_json = _response.json()
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    def verify_processing(
+    def batch_scrape_webpage(
         self,
         *,
-        file_id: str,
-        tenant_id: typing.Optional[str] = None,
+        tenant_id: str,
+        request: typing.Sequence[WebpageScrapeRequest],
         sub_tenant_id: typing.Optional[str] = None,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> HttpResponse[ProcessingStatus]:
+    ) -> HttpResponse[BatchUploadData]:
         """
-        Check the current processing status of your uploaded content.
+        Extract and index content from multiple web pages simultaneously.
 
-        This endpoint allows you to monitor the progress of documents, text, or other content you've uploaded. Simply provide the file ID to see whether processing is complete, still in progress, or if any errors occurred.
+        This endpoint initiates web scraping for multiple URLs at once, extracting the main content, text, and structure from each webpage. It's perfect for capturing multiple articles, documentation pages, or any web content you want to include in your knowledge base.
 
-        Use this to determine when your content is ready for search and retrieval, or to troubleshoot any processing issues.
+        The system processes all webpage content asynchronously, cleaning and structuring the information for optimal search and retrieval.
 
         Parameters
         ----------
-        file_id : str
-            The file ID to check processing status for
+        tenant_id : str
+            Unique identifier for the tenant/organization
 
-        tenant_id : typing.Optional[str]
+        request : typing.Sequence[WebpageScrapeRequest]
+
+        sub_tenant_id : typing.Optional[str]
+            Optional sub-tenant identifier used to organize data within a tenant. If omitted, the default sub-tenant created during tenant setup will be used.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[BatchUploadData]
+            Successful Response
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "upload/batch_scrape_webpage",
+            method="POST",
+            params={
+                "tenant_id": tenant_id,
+                "sub_tenant_id": sub_tenant_id,
+            },
+            json=convert_and_respect_annotation_metadata(
+                object_=request, annotation=typing.Sequence[WebpageScrapeRequest], direction="write"
+            ),
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    BatchUploadData,
+                    parse_obj_as(
+                        type_=BatchUploadData,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 503:
+                raise ServiceUnavailableError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    def delete_source(
+        self,
+        *,
+        tenant_id: str,
+        source_ids: typing.Sequence[str],
+        sub_tenant_id: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> HttpResponse[typing.Optional[typing.Any]]:
+        """
+        Remove documents and content from your knowledge base.
+
+        This endpoint permanently deletes the specified sources from your knowledge base. Once deleted, the content will no longer be available for search or retrieval.
+
+        Use this carefully as the action cannot be undone. The system will confirm successful deletion of each source ID you specify.
+
+        Parameters
+        ----------
+        tenant_id : str
             Unique identifier for the tenant/organization
 
+        source_ids : typing.Sequence[str]
+            List of source IDs to delete
+
         sub_tenant_id : typing.Optional[str]
             Optional sub-tenant identifier used to organize data within a tenant. If omitted, the default sub-tenant created during tenant setup will be used.
 
@@ -2251,29 +2520,514 @@ class RawUploadClient:
 
         Returns
         -------
-        HttpResponse[ProcessingStatus]
+        HttpResponse[typing.Optional[typing.Any]]
+            Successful Response
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "upload/delete_source",
+            method="DELETE",
+            json={
+                "tenant_id": tenant_id,
+                "source_ids": source_ids,
+                "sub_tenant_id": sub_tenant_id,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if _response is None or not _response.text.strip():
+                return HttpResponse(response=_response, data=None)
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    typing.Optional[typing.Any],
+                    parse_obj_as(
+                        type_=typing.Optional[typing.Any],  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    def delete_memory(
+        self,
+        *,
+        tenant_id: str,
+        source_ids: typing.Sequence[str],
+        sub_tenant_id: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> HttpResponse[typing.Optional[typing.Any]]:
+        """
+        Remove documents and content from your knowledge base.
+
+        This endpoint permanently deletes the specified sources from your knowledge base. Once deleted, the content will no longer be available for search or retrieval.
+
+        Use this carefully as the action cannot be undone. The system will confirm successful deletion of each source ID you specify.
+
+        Parameters
+        ----------
+        tenant_id : str
+            Unique identifier for the tenant/organization
+
+        source_ids : typing.Sequence[str]
+            List of source IDs to delete
+
+        sub_tenant_id : typing.Optional[str]
+            Optional sub-tenant identifier used to organize data within a tenant. If omitted, the default sub-tenant created during tenant setup will be used.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[typing.Optional[typing.Any]]
+            Successful Response
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "upload/delete_memory",
+            method="DELETE",
+            json={
+                "tenant_id": tenant_id,
+                "source_ids": source_ids,
+                "sub_tenant_id": sub_tenant_id,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if _response is None or not _response.text.strip():
+                return HttpResponse(response=_response, data=None)
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    typing.Optional[typing.Any],
+                    parse_obj_as(
+                        type_=typing.Optional[typing.Any],  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    def verify_processing(
+        self,
+        *,
+        file_id: str,
+        tenant_id: typing.Optional[str] = None,
+        sub_tenant_id: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> HttpResponse[ProcessingStatus]:
+        """
+        Check the current processing status of your uploaded content.
+
+        This endpoint allows you to monitor the progress of documents, text, or other content you've uploaded. Simply provide the file ID to see whether processing is complete, still in progress, or if any errors occurred.
+
+        Use this to determine when your content is ready for search and retrieval, or to troubleshoot any processing issues.
+
+        Parameters
+        ----------
+        file_id : str
+            The file ID to check processing status for
+
+        tenant_id : typing.Optional[str]
+            Unique identifier for the tenant/organization
+
+        sub_tenant_id : typing.Optional[str]
+            Optional sub-tenant identifier used to organize data within a tenant. If omitted, the default sub-tenant created during tenant setup will be used.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[ProcessingStatus]
+            Successful Response
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "upload/verify_processing",
+            method="POST",
+            params={
+                "file_id": file_id,
+                "tenant_id": tenant_id,
+                "sub_tenant_id": sub_tenant_id,
+            },
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    ProcessingStatus,
+                    parse_obj_as(
+                        type_=ProcessingStatus,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 503:
+                raise ServiceUnavailableError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+
+class AsyncRawUploadClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    async def batch_upload(
+        self,
+        *,
+        tenant_id: str,
+        files: typing.List[core.File],
+        sub_tenant_id: typing.Optional[str] = None,
+        file_ids: typing.Optional[str] = OMIT,
+        tenant_metadata: typing.Optional[str] = OMIT,
+        document_metadata: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[BatchUploadData]:
+        """
+        Upload multiple documents simultaneously for efficient bulk processing.
+
+        This endpoint allows you to upload several files at once, which is ideal for large document collections or periodic data imports. Each file gets processed asynchronously, and you can track the progress of individual files using their returned file IDs.
+
+        The system automatically handles file parsing, content extraction, and indexing across all uploaded documents. You'll receive confirmation once all files are queued for processing.
+
+        Parameters
+        ----------
+        tenant_id : str
+            Unique identifier for the tenant/organization
+
+        files : typing.List[core.File]
+            See core.File for more documentation
+
+        sub_tenant_id : typing.Optional[str]
+            Optional sub-tenant identifier used to organize data within a tenant. If omitted, the default sub-tenant created during tenant setup will be used.
+
+        file_ids : typing.Optional[str]
+            Optional JSON string array of file IDs for the uploaded content. If not provided or empty, will be generated automatically.
+
+        tenant_metadata : typing.Optional[str]
+            JSON string containing tenant-level document metadata (e.g., department, compliance_tag)
+
+            Example: > "{"department":"Finance","compliance_tag":"GDPR"}"
+
+
+        document_metadata : typing.Optional[str]
+            JSON string containing document-specific metadata (e.g., title, author, file_id). If file_id is not provided, the system will generate an ID automatically.
+
+            Example: > "{"title":"Q1 Report.pdf","author":"Alice Smith","file_id":"custom_file_123"}"
+
+
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[BatchUploadData]
+            Successful Response
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "upload/batch_upload",
+            method="POST",
+            params={
+                "tenant_id": tenant_id,
+                "sub_tenant_id": sub_tenant_id,
+            },
+            data={
+                "file_ids": file_ids,
+                "tenant_metadata": tenant_metadata,
+                "document_metadata": document_metadata,
+            },
+            files={
+                "files": files,
+            },
+            request_options=request_options,
+            omit=OMIT,
+            force_multipart=True,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    BatchUploadData,
+                    parse_obj_as(
+                        type_=BatchUploadData,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 503:
+                raise ServiceUnavailableError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def batch_update(
+        self,
+        *,
+        tenant_id: str,
+        files: typing.List[core.File],
+        sub_tenant_id: typing.Optional[str] = None,
+        source_ids: typing.Optional[typing.List[str]] = OMIT,
+        tenant_metadata: typing.Optional[str] = OMIT,
+        document_metadata: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[BatchUploadData]:
+        """
+        Update multiple existing documents with new content and metadata.
+
+        Use this endpoint when you need to replace or modify several documents that are already in your knowledge base. Each file must correspond to an existing source ID, ensuring that updates are applied to the correct documents.
+
+        The system processes updates asynchronously, allowing you to continue working while your documents are re-indexed. Track the progress using the returned file IDs to know when updates are complete.
+
+        Parameters
+        ----------
+        tenant_id : str
+            Unique identifier for the tenant/organization
+
+        files : typing.List[core.File]
+            See core.File for more documentation
+
+        sub_tenant_id : typing.Optional[str]
+            Optional sub-tenant identifier used to organize data within a tenant. If omitted, the default sub-tenant created during tenant setup will be used.
+
+        source_ids : typing.Optional[typing.List[str]]
+            List of source IDs corresponding to the files being updated
+
+        tenant_metadata : typing.Optional[str]
+            JSON string containing tenant-level document metadata (e.g., department, compliance_tag)
+
+            Example: > "{"department":"Finance","compliance_tag":"GDPR"}"
+
+
+        document_metadata : typing.Optional[str]
+            JSON string containing document-specific metadata (e.g., title, author, file_id). If file_id is not provided, the system will generate an ID automatically.
+
+            Example: > "{"title":"Q1 Report.pdf","author":"Alice Smith","file_id":"custom_file_123"}"
+
+
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[BatchUploadData]
             Successful Response
         """
-        _response = self._client_wrapper.httpx_client.request(
-            "upload/verify_processing",
-            method="POST",
+        _response = await self._client_wrapper.httpx_client.request(
+            "upload/batch_update",
+            method="PATCH",
             params={
-                "file_id": file_id,
                 "tenant_id": tenant_id,
                 "sub_tenant_id": sub_tenant_id,
             },
+            data={
+                "source_ids": source_ids,
+                "tenant_metadata": tenant_metadata,
+                "document_metadata": document_metadata,
+            },
+            files={
+                "files": files,
+            },
             request_options=request_options,
+            omit=OMIT,
+            force_multipart=True,
         )
         try:
             if 200 <= _response.status_code < 300:
                 _data = typing.cast(
-                    ProcessingStatus,
+                    BatchUploadData,
                     parse_obj_as(
-                        type_=ProcessingStatus,  # type: ignore
+                        type_=BatchUploadData,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
-                return HttpResponse(response=_response, data=_data)
+                return AsyncHttpResponse(response=_response, data=_data)
             if _response.status_code == 400:
                 raise BadRequestError(
                     headers=dict(_response.headers),
@@ -2356,42 +3110,37 @@ class RawUploadClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-
-class AsyncRawUploadClient:
-    def __init__(self, *, client_wrapper: AsyncClientWrapper):
-        self._client_wrapper = client_wrapper
-
-    async def batch_upload(
+    async def upload_document(
         self,
         *,
         tenant_id: str,
-        files: typing.List[core.File],
+        file: core.File,
         sub_tenant_id: typing.Optional[str] = None,
-        file_ids: typing.Optional[str] = OMIT,
+        file_id: typing.Optional[str] = OMIT,
         tenant_metadata: typing.Optional[str] = OMIT,
         document_metadata: typing.Optional[str] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[BatchUploadData]:
+    ) -> AsyncHttpResponse[SingleUploadData]:
         """
-        Upload multiple documents simultaneously for efficient bulk processing.
+        Upload a single document for processing and indexing into your knowledge base.
 
-        This endpoint allows you to upload several files at once, which is ideal for large document collections or periodic data imports. Each file gets processed asynchronously, and you can track the progress of individual files using their returned file IDs.
+        This endpoint accepts documents in various formats and processes them for search and retrieval. You can include custom metadata to help organize and categorize your content.
 
-        The system automatically handles file parsing, content extraction, and indexing across all uploaded documents. You'll receive confirmation once all files are queued for processing.
+        The system extracts text content, processes it asynchronously, and makes it available for search queries. You can track the processing status using the returned file ID.
 
         Parameters
         ----------
         tenant_id : str
             Unique identifier for the tenant/organization
 
-        files : typing.List[core.File]
+        file : core.File
             See core.File for more documentation
 
         sub_tenant_id : typing.Optional[str]
             Optional sub-tenant identifier used to organize data within a tenant. If omitted, the default sub-tenant created during tenant setup will be used.
 
-        file_ids : typing.Optional[str]
-            Optional JSON string array of file IDs for the uploaded content. If not provided or empty, will be generated automatically.
+        file_id : typing.Optional[str]
+            Optional file ID for the uploaded content. If not provided, will be generated automatically.
 
         tenant_metadata : typing.Optional[str]
             JSON string containing tenant-level document metadata (e.g., department, compliance_tag)
@@ -2411,23 +3160,23 @@ class AsyncRawUploadClient:
 
         Returns
         -------
-        AsyncHttpResponse[BatchUploadData]
+        AsyncHttpResponse[SingleUploadData]
             Successful Response
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "upload/batch_upload",
+            "upload/upload_document",
             method="POST",
             params={
                 "tenant_id": tenant_id,
                 "sub_tenant_id": sub_tenant_id,
             },
             data={
-                "file_ids": file_ids,
+                "file_id": file_id,
                 "tenant_metadata": tenant_metadata,
                 "document_metadata": document_metadata,
             },
             files={
-                "files": files,
+                "file": file,
             },
             request_options=request_options,
             omit=OMIT,
@@ -2436,9 +3185,9 @@ class AsyncRawUploadClient:
         try:
             if 200 <= _response.status_code < 300:
                 _data = typing.cast(
-                    BatchUploadData,
+                    SingleUploadData,
                     parse_obj_as(
-                        type_=BatchUploadData,  # type: ignore
+                        type_=SingleUploadData,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
@@ -2525,38 +3274,38 @@ class AsyncRawUploadClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def batch_update(
+    async def update_document(
         self,
         *,
+        source_id: str,
         tenant_id: str,
-        files: typing.List[core.File],
+        file: core.File,
         sub_tenant_id: typing.Optional[str] = None,
-        source_ids: typing.Optional[typing.List[str]] = OMIT,
         tenant_metadata: typing.Optional[str] = OMIT,
         document_metadata: typing.Optional[str] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[BatchUploadData]:
+    ) -> AsyncHttpResponse[SingleUploadData]:
         """
-        Update multiple existing documents with new content and metadata.
+        Replace an existing document with updated content.
 
-        Use this endpoint when you need to replace or modify several documents that are already in your knowledge base. Each file must correspond to an existing source ID, ensuring that updates are applied to the correct documents.
+        This endpoint allows you to update a specific document that's already in your knowledge base. Provide the source ID of the document you want to modify, along with the new file content.
 
-        The system processes updates asynchronously, allowing you to continue working while your documents are re-indexed. Track the progress using the returned file IDs to know when updates are complete.
+        The system will process your update asynchronously and re-index the document with the new content. You can monitor the progress using the returned file ID.
 
         Parameters
         ----------
+        source_id : str
+            The source ID of the document to update
+
         tenant_id : str
             Unique identifier for the tenant/organization
 
-        files : typing.List[core.File]
+        file : core.File
             See core.File for more documentation
 
         sub_tenant_id : typing.Optional[str]
             Optional sub-tenant identifier used to organize data within a tenant. If omitted, the default sub-tenant created during tenant setup will be used.
 
-        source_ids : typing.Optional[typing.List[str]]
-            List of source IDs corresponding to the files being updated
-
         tenant_metadata : typing.Optional[str]
             JSON string containing tenant-level document metadata (e.g., department, compliance_tag)
 
@@ -2575,23 +3324,23 @@ class AsyncRawUploadClient:
 
         Returns
         -------
-        AsyncHttpResponse[BatchUploadData]
+        AsyncHttpResponse[SingleUploadData]
             Successful Response
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "upload/batch_update",
+            "upload/update_document",
             method="PATCH",
             params={
+                "source_id": source_id,
                 "tenant_id": tenant_id,
                 "sub_tenant_id": sub_tenant_id,
             },
             data={
-                "source_ids": source_ids,
                 "tenant_metadata": tenant_metadata,
                 "document_metadata": document_metadata,
             },
             files={
-                "files": files,
+                "file": file,
             },
             request_options=request_options,
             omit=OMIT,
@@ -2600,9 +3349,9 @@ class AsyncRawUploadClient:
         try:
             if 200 <= _response.status_code < 300:
                 _data = typing.cast(
-                    BatchUploadData,
+                    SingleUploadData,
                     parse_obj_as(
-                        type_=BatchUploadData,  # type: ignore
+                        type_=SingleUploadData,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
@@ -2689,84 +3438,61 @@ class AsyncRawUploadClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def upload_document(
+    async def upload_app_sources(
         self,
         *,
         tenant_id: str,
-        file: core.File,
+        request: typing.Sequence[SourceModel],
         sub_tenant_id: typing.Optional[str] = None,
-        file_id: typing.Optional[str] = OMIT,
-        tenant_metadata: typing.Optional[str] = OMIT,
-        document_metadata: typing.Optional[str] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[SingleUploadData]:
+    ) -> AsyncHttpResponse[AppSourcesUploadData]:
         """
-        Upload a single document for processing and indexing into your knowledge base.
+        Upload structured data from applications or APIs for indexing.
 
-        This endpoint accepts documents in various formats and processes them for search and retrieval. You can include custom metadata to help organize and categorize your content.
+        This endpoint is designed for importing data from applications. If you are specifically using Cortex to provide search to an application, you should prefer this endpoint. It accepts structured source objects and allows you to clearly define contents of attachments
 
-        The system extracts text content, processes it asynchronously, and makes it available for search queries. You can track the processing status using the returned file ID.
+        The system processes each source asynchronously and makes the content available for search and retrieval. Use this when you need to integrate search and indexing from data in your applications into your knowledge base.
 
         Parameters
         ----------
         tenant_id : str
             Unique identifier for the tenant/organization
 
-        file : core.File
-            See core.File for more documentation
+        request : typing.Sequence[SourceModel]
 
         sub_tenant_id : typing.Optional[str]
             Optional sub-tenant identifier used to organize data within a tenant. If omitted, the default sub-tenant created during tenant setup will be used.
 
-        file_id : typing.Optional[str]
-            Optional file ID for the uploaded content. If not provided, will be generated automatically.
-
-        tenant_metadata : typing.Optional[str]
-            JSON string containing tenant-level document metadata (e.g., department, compliance_tag)
-
-            Example: > "{"department":"Finance","compliance_tag":"GDPR"}"
-
-
-        document_metadata : typing.Optional[str]
-            JSON string containing document-specific metadata (e.g., title, author, file_id). If file_id is not provided, the system will generate an ID automatically.
-
-            Example: > "{"title":"Q1 Report.pdf","author":"Alice Smith","file_id":"custom_file_123"}"
-
-
-
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[SingleUploadData]
+        AsyncHttpResponse[AppSourcesUploadData]
             Successful Response
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "upload/upload_document",
+            "upload/upload_app_sources",
             method="POST",
             params={
                 "tenant_id": tenant_id,
                 "sub_tenant_id": sub_tenant_id,
             },
-            data={
-                "file_id": file_id,
-                "tenant_metadata": tenant_metadata,
-                "document_metadata": document_metadata,
-            },
-            files={
-                "file": file,
+            json=convert_and_respect_annotation_metadata(
+                object_=request, annotation=typing.Sequence[SourceModel], direction="write"
+            ),
+            headers={
+                "content-type": "application/json",
             },
             request_options=request_options,
             omit=OMIT,
-            force_multipart=True,
         )
         try:
             if 200 <= _response.status_code < 300:
                 _data = typing.cast(
-                    SingleUploadData,
+                    AppSourcesUploadData,
                     parse_obj_as(
-                        type_=SingleUploadData,  # type: ignore
+                        type_=AppSourcesUploadData,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
@@ -2853,51 +3579,49 @@ class AsyncRawUploadClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def update_document(
+    async def upload_markdown(
         self,
         *,
-        source_id: str,
         tenant_id: str,
-        file: core.File,
+        content: str,
         sub_tenant_id: typing.Optional[str] = None,
-        tenant_metadata: typing.Optional[str] = OMIT,
-        document_metadata: typing.Optional[str] = OMIT,
+        file_id: typing.Optional[str] = OMIT,
+        tenant_metadata: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = OMIT,
+        document_metadata: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
     ) -> AsyncHttpResponse[SingleUploadData]:
         """
-        Replace an existing document with updated content.
+        Upload text or markdown content directly for processing.
 
-        This endpoint allows you to update a specific document that's already in your knowledge base. Provide the source ID of the document you want to modify, along with the new file content.
+        This endpoint accepts plain text or markdown-formatted content that you want to add to your knowledge base. It's perfect for notes, documentation, articles, or any text-based content you want to make searchable.
 
-        The system will process your update asynchronously and re-index the document with the new content. You can monitor the progress using the returned file ID.
+        You can include custom metadata to help organize and categorize your content. You can track the processing status using the returned file ID.
 
         Parameters
         ----------
-        source_id : str
-            The source ID of the document to update
-
         tenant_id : str
             Unique identifier for the tenant/organization
 
-        file : core.File
-            See core.File for more documentation
+        content : str
+            The text or markdown content to upload
 
         sub_tenant_id : typing.Optional[str]
             Optional sub-tenant identifier used to organize data within a tenant. If omitted, the default sub-tenant created during tenant setup will be used.
 
-        tenant_metadata : typing.Optional[str]
+        file_id : typing.Optional[str]
+            Optional file ID for the uploaded content. If not provided, will be generated automatically.
+
+        tenant_metadata : typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]]
             JSON string containing tenant-level document metadata (e.g., department, compliance_tag)
 
             Example: > "{"department":"Finance","compliance_tag":"GDPR"}"
 
-
-        document_metadata : typing.Optional[str]
+        document_metadata : typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]]
             JSON string containing document-specific metadata (e.g., title, author, file_id). If file_id is not provided, the system will generate an ID automatically.
 
             Example: > "{"title":"Q1 Report.pdf","author":"Alice Smith","file_id":"custom_file_123"}"
 
 
-
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
@@ -2907,23 +3631,23 @@ class AsyncRawUploadClient:
             Successful Response
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "upload/update_document",
-            method="PATCH",
+            "upload/upload_markdown",
+            method="POST",
             params={
-                "source_id": source_id,
                 "tenant_id": tenant_id,
                 "sub_tenant_id": sub_tenant_id,
             },
-            data={
+            json={
+                "content": content,
+                "file_id": file_id,
                 "tenant_metadata": tenant_metadata,
                 "document_metadata": document_metadata,
             },
-            files={
-                "file": file,
+            headers={
+                "content-type": "application/json",
             },
             request_options=request_options,
             omit=OMIT,
-            force_multipart=True,
         )
         try:
             if 200 <= _response.status_code < 300:
@@ -3017,49 +3741,70 @@ class AsyncRawUploadClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def upload_app_sources(
+    async def upload_text(
         self,
         *,
         tenant_id: str,
-        request: typing.Sequence[SourceModel],
+        content: str,
         sub_tenant_id: typing.Optional[str] = None,
+        file_id: typing.Optional[str] = OMIT,
+        tenant_metadata: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = OMIT,
+        document_metadata: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[AppSourcesUploadData]:
+    ) -> AsyncHttpResponse[SingleUploadData]:
         """
-        Upload structured data from applications or APIs for indexing.
+        Upload text or markdown content directly for processing.
 
-        This endpoint is designed for importing data from applications. If you are specifically using Cortex to provide search to an application, you should prefer this endpoint. It accepts structured source objects and allows you to clearly define contents of attachments
+        This endpoint accepts plain text or markdown-formatted content that you want to add to your knowledge base. It's perfect for notes, documentation, articles, or any text-based content you want to make searchable.
 
-        The system processes each source asynchronously and makes the content available for search and retrieval. Use this when you need to integrate search and indexing from data in your applications into your knowledge base.
+        You can include custom metadata to help organize and categorize your content. You can track the processing status using the returned file ID.
 
         Parameters
         ----------
         tenant_id : str
             Unique identifier for the tenant/organization
 
-        request : typing.Sequence[SourceModel]
+        content : str
+            The text or markdown content to upload
 
         sub_tenant_id : typing.Optional[str]
             Optional sub-tenant identifier used to organize data within a tenant. If omitted, the default sub-tenant created during tenant setup will be used.
 
+        file_id : typing.Optional[str]
+            Optional file ID for the uploaded content. If not provided, will be generated automatically.
+
+        tenant_metadata : typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]]
+            JSON string containing tenant-level document metadata (e.g., department, compliance_tag)
+
+            Example: > "{"department":"Finance","compliance_tag":"GDPR"}"
+
+        document_metadata : typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]]
+            JSON string containing document-specific metadata (e.g., title, author, file_id). If file_id is not provided, the system will generate an ID automatically.
+
+            Example: > "{"title":"Q1 Report.pdf","author":"Alice Smith","file_id":"custom_file_123"}"
+
+
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[AppSourcesUploadData]
+        AsyncHttpResponse[SingleUploadData]
             Successful Response
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "upload/upload_app_sources",
+            "upload/upload_text",
             method="POST",
             params={
                 "tenant_id": tenant_id,
                 "sub_tenant_id": sub_tenant_id,
             },
-            json=convert_and_respect_annotation_metadata(
-                object_=request, annotation=typing.Sequence[SourceModel], direction="write"
-            ),
+            json={
+                "content": content,
+                "file_id": file_id,
+                "tenant_metadata": tenant_metadata,
+                "document_metadata": document_metadata,
+            },
             headers={
                 "content-type": "application/json",
             },
@@ -3069,9 +3814,9 @@ class AsyncRawUploadClient:
         try:
             if 200 <= _response.status_code < 300:
                 _data = typing.cast(
-                    AppSourcesUploadData,
+                    SingleUploadData,
                     parse_obj_as(
-                        type_=AppSourcesUploadData,  # type: ignore
+                        type_=SingleUploadData,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
@@ -3158,9 +3903,10 @@ class AsyncRawUploadClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def upload_markdown(
+    async def update_markdown(
         self,
         *,
+        source_id: str,
         tenant_id: str,
         content: str,
         sub_tenant_id: typing.Optional[str] = None,
@@ -3170,14 +3916,17 @@ class AsyncRawUploadClient:
         request_options: typing.Optional[RequestOptions] = None,
     ) -> AsyncHttpResponse[SingleUploadData]:
         """
-        Upload text or markdown content directly for processing.
+        Update existing text or markdown content with new information.
 
-        This endpoint accepts plain text or markdown-formatted content that you want to add to your knowledge base. It's perfect for notes, documentation, articles, or any text-based content you want to make searchable.
+        This endpoint allows you to modify text or markdown content that's already in your knowledge base. Provide the source ID of the content you want to update, along with the new text.
 
-        You can include custom metadata to help organize and categorize your content. You can track the processing status using the returned file ID.
+        The system will reprocess and re-index the updated content asynchronously. Use this when you need to correct information, add details, or refresh existing documentation.
 
         Parameters
         ----------
+        source_id : str
+            The source ID of the document to update
+
         tenant_id : str
             Unique identifier for the tenant/organization
 
@@ -3210,9 +3959,10 @@ class AsyncRawUploadClient:
             Successful Response
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "upload/upload_markdown",
-            method="POST",
+            "upload/update_markdown",
+            method="PATCH",
             params={
+                "source_id": source_id,
                 "tenant_id": tenant_id,
                 "sub_tenant_id": sub_tenant_id,
             },
@@ -3320,9 +4070,10 @@ class AsyncRawUploadClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def upload_text(
+    async def update_text(
         self,
         *,
+        source_id: str,
         tenant_id: str,
         content: str,
         sub_tenant_id: typing.Optional[str] = None,
@@ -3332,14 +4083,17 @@ class AsyncRawUploadClient:
         request_options: typing.Optional[RequestOptions] = None,
     ) -> AsyncHttpResponse[SingleUploadData]:
         """
-        Upload text or markdown content directly for processing.
+        Update existing text or markdown content with new information.
 
-        This endpoint accepts plain text or markdown-formatted content that you want to add to your knowledge base. It's perfect for notes, documentation, articles, or any text-based content you want to make searchable.
+        This endpoint allows you to modify text or markdown content that's already in your knowledge base. Provide the source ID of the content you want to update, along with the new text.
 
-        You can include custom metadata to help organize and categorize your content. You can track the processing status using the returned file ID.
+        The system will reprocess and re-index the updated content asynchronously. Use this when you need to correct information, add details, or refresh existing documentation.
 
         Parameters
         ----------
+        source_id : str
+            The source ID of the document to update
+
         tenant_id : str
             Unique identifier for the tenant/organization
 
@@ -3372,9 +4126,10 @@ class AsyncRawUploadClient:
             Successful Response
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "upload/upload_text",
-            method="POST",
+            "upload/update_text",
+            method="PATCH",
             params={
+                "source_id": source_id,
                 "tenant_id": tenant_id,
                 "sub_tenant_id": sub_tenant_id,
             },
@@ -3482,75 +4237,47 @@ class AsyncRawUploadClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def update_markdown(
+    async def batch_upload_markdown(
         self,
         *,
-        source_id: str,
         tenant_id: str,
-        content: str,
+        request: typing.Sequence[MarkdownUploadRequest],
         sub_tenant_id: typing.Optional[str] = None,
-        file_id: typing.Optional[str] = OMIT,
-        tenant_metadata: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = OMIT,
-        document_metadata: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[SingleUploadData]:
+    ) -> AsyncHttpResponse[BatchUploadData]:
         """
-        Update existing text or markdown content with new information.
-
-        This endpoint allows you to modify text or markdown content that's already in your knowledge base. Provide the source ID of the content you want to update, along with the new text.
+        Upload multiple markdown/text documents simultaneously for efficient bulk processing.
 
-        The system will reprocess and re-index the updated content asynchronously. Use this when you need to correct information, add details, or refresh existing documentation.
+        This endpoint allows you to upload several markdown or text contents at once. Each content item gets processed asynchronously, and you can track the progress using their returned file IDs.
 
         Parameters
         ----------
-        source_id : str
-            The source ID of the document to update
-
         tenant_id : str
             Unique identifier for the tenant/organization
 
-        content : str
-            The text or markdown content to upload
+        request : typing.Sequence[MarkdownUploadRequest]
 
         sub_tenant_id : typing.Optional[str]
             Optional sub-tenant identifier used to organize data within a tenant. If omitted, the default sub-tenant created during tenant setup will be used.
 
-        file_id : typing.Optional[str]
-            Optional file ID for the uploaded content. If not provided, will be generated automatically.
-
-        tenant_metadata : typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]]
-            JSON string containing tenant-level document metadata (e.g., department, compliance_tag)
-
-            Example: > "{"department":"Finance","compliance_tag":"GDPR"}"
-
-        document_metadata : typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]]
-            JSON string containing document-specific metadata (e.g., title, author, file_id). If file_id is not provided, the system will generate an ID automatically.
-
-            Example: > "{"title":"Q1 Report.pdf","author":"Alice Smith","file_id":"custom_file_123"}"
-
-
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[SingleUploadData]
+        AsyncHttpResponse[BatchUploadData]
             Successful Response
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "upload/update_markdown",
-            method="PATCH",
+            "upload/batch_upload_markdown",
+            method="POST",
             params={
-                "source_id": source_id,
                 "tenant_id": tenant_id,
                 "sub_tenant_id": sub_tenant_id,
             },
-            json={
-                "content": content,
-                "file_id": file_id,
-                "tenant_metadata": tenant_metadata,
-                "document_metadata": document_metadata,
-            },
+            json=convert_and_respect_annotation_metadata(
+                object_=request, annotation=typing.Sequence[MarkdownUploadRequest], direction="write"
+            ),
             headers={
                 "content-type": "application/json",
             },
@@ -3560,9 +4287,9 @@ class AsyncRawUploadClient:
         try:
             if 200 <= _response.status_code < 300:
                 _data = typing.cast(
-                    SingleUploadData,
+                    BatchUploadData,
                     parse_obj_as(
-                        type_=SingleUploadData,  # type: ignore
+                        type_=BatchUploadData,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
@@ -3649,75 +4376,47 @@ class AsyncRawUploadClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def update_text(
+    async def batch_upload_text(
         self,
         *,
-        source_id: str,
         tenant_id: str,
-        content: str,
+        request: typing.Sequence[MarkdownUploadRequest],
         sub_tenant_id: typing.Optional[str] = None,
-        file_id: typing.Optional[str] = OMIT,
-        tenant_metadata: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = OMIT,
-        document_metadata: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[SingleUploadData]:
+    ) -> AsyncHttpResponse[BatchUploadData]:
         """
-        Update existing text or markdown content with new information.
-
-        This endpoint allows you to modify text or markdown content that's already in your knowledge base. Provide the source ID of the content you want to update, along with the new text.
+        Upload multiple markdown/text documents simultaneously for efficient bulk processing.
 
-        The system will reprocess and re-index the updated content asynchronously. Use this when you need to correct information, add details, or refresh existing documentation.
+        This endpoint allows you to upload several markdown or text contents at once. Each content item gets processed asynchronously, and you can track the progress using their returned file IDs.
 
         Parameters
         ----------
-        source_id : str
-            The source ID of the document to update
-
         tenant_id : str
             Unique identifier for the tenant/organization
 
-        content : str
-            The text or markdown content to upload
+        request : typing.Sequence[MarkdownUploadRequest]
 
         sub_tenant_id : typing.Optional[str]
             Optional sub-tenant identifier used to organize data within a tenant. If omitted, the default sub-tenant created during tenant setup will be used.
 
-        file_id : typing.Optional[str]
-            Optional file ID for the uploaded content. If not provided, will be generated automatically.
-
-        tenant_metadata : typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]]
-            JSON string containing tenant-level document metadata (e.g., department, compliance_tag)
-
-            Example: > "{"department":"Finance","compliance_tag":"GDPR"}"
-
-        document_metadata : typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]]
-            JSON string containing document-specific metadata (e.g., title, author, file_id). If file_id is not provided, the system will generate an ID automatically.
-
-            Example: > "{"title":"Q1 Report.pdf","author":"Alice Smith","file_id":"custom_file_123"}"
-
-
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[SingleUploadData]
+        AsyncHttpResponse[BatchUploadData]
             Successful Response
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "upload/update_text",
-            method="PATCH",
+            "upload/batch_upload_text",
+            method="POST",
             params={
-                "source_id": source_id,
                 "tenant_id": tenant_id,
                 "sub_tenant_id": sub_tenant_id,
             },
-            json={
-                "content": content,
-                "file_id": file_id,
-                "tenant_metadata": tenant_metadata,
-                "document_metadata": document_metadata,
-            },
+            json=convert_and_respect_annotation_metadata(
+                object_=request, annotation=typing.Sequence[MarkdownUploadRequest], direction="write"
+            ),
             headers={
                 "content-type": "application/json",
             },
@@ -3727,9 +4426,9 @@ class AsyncRawUploadClient:
         try:
             if 200 <= _response.status_code < 300:
                 _data = typing.cast(
-                    SingleUploadData,
+                    BatchUploadData,
                     parse_obj_as(
-                        type_=SingleUploadData,  # type: ignore
+                        type_=BatchUploadData,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
@@ -4397,6 +5096,147 @@ class AsyncRawUploadClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
+    async def batch_scrape_webpage(
+        self,
+        *,
+        tenant_id: str,
+        request: typing.Sequence[WebpageScrapeRequest],
+        sub_tenant_id: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[BatchUploadData]:
+        """
+        Extract and index content from multiple web pages simultaneously.
+
+        This endpoint initiates web scraping for multiple URLs at once, extracting the main content, text, and structure from each webpage. It's perfect for capturing multiple articles, documentation pages, or any web content you want to include in your knowledge base.
+
+        The system processes all webpage content asynchronously, cleaning and structuring the information for optimal search and retrieval.
+
+        Parameters
+        ----------
+        tenant_id : str
+            Unique identifier for the tenant/organization
+
+        request : typing.Sequence[WebpageScrapeRequest]
+
+        sub_tenant_id : typing.Optional[str]
+            Optional sub-tenant identifier used to organize data within a tenant. If omitted, the default sub-tenant created during tenant setup will be used.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[BatchUploadData]
+            Successful Response
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "upload/batch_scrape_webpage",
+            method="POST",
+            params={
+                "tenant_id": tenant_id,
+                "sub_tenant_id": sub_tenant_id,
+            },
+            json=convert_and_respect_annotation_metadata(
+                object_=request, annotation=typing.Sequence[WebpageScrapeRequest], direction="write"
+            ),
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    BatchUploadData,
+                    parse_obj_as(
+                        type_=BatchUploadData,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 503:
+                raise ServiceUnavailableError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ActualErrorResponse,
+                        parse_obj_as(
+                            type_=ActualErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
     async def delete_source(
         self,
         *,