usecortex-ai 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

usecortex_ai/user_memory/raw_client.py

@@ -8,7 +8,22 @@ from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
 from ..core.http_response import AsyncHttpResponse, HttpResponse
 from ..core.pydantic_utilities import parse_obj_as
 from ..core.request_options import RequestOptions
+from ..errors.bad_request_error import BadRequestError
+from ..errors.forbidden_error import ForbiddenError
+from ..errors.internal_server_error import InternalServerError
+from ..errors.not_found_error import NotFoundError
+from ..errors.service_unavailable_error import ServiceUnavailableError
+from ..errors.unauthorized_error import UnauthorizedError
 from ..errors.unprocessable_entity_error import UnprocessableEntityError
+from ..types.actual_error_response import ActualErrorResponse
+from ..types.add_user_memory_response import AddUserMemoryResponse
+from ..types.delete_user_memory_response import DeleteUserMemoryResponse
+from ..types.generate_user_memory_response import GenerateUserMemoryResponse
+from ..types.list_user_memories_response import ListUserMemoriesResponse
+from ..types.retrieve_user_memory_response import RetrieveUserMemoryResponse
+
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
 
 
 class RawUserMemoryClient:
@@ -16,21 +31,35 @@ class RawUserMemoryClient:
         self._client_wrapper = client_wrapper
 
     def list_user_memories(
-        self, *, tenant_id: str, sub_tenant_id: str, request_options: typing.Optional[RequestOptions] = None
-    ) -> HttpResponse[typing.Optional[typing.Any]]:
+        self,
+        *,
+        tenant_id: str,
+        sub_tenant_id: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> HttpResponse[ListUserMemoriesResponse]:
         """
+        Retrieve all stored user memories for your tenant.
+
+        This endpoint returns a comprehensive list of all user memories that have been stored,
+        whether they were added manually or generated through AI. User memories help personalize
+        your experience by storing context, preferences, and important information.
+
+        You can optionally specify a sub-tenant to filter memories within that specific scope.
+
         Parameters
         ----------
         tenant_id : str
+            Unique identifier for the tenant/organization
 
-        sub_tenant_id : str
+        sub_tenant_id : typing.Optional[str]
+            Optional sub-tenant identifier for organizing data within a tenant. If not provided, defaults to tenant_id
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        HttpResponse[typing.Optional[typing.Any]]
+        HttpResponse[ListUserMemoriesResponse]
             Successful Response
         """
         _response = self._client_wrapper.httpx_client.request(
@@ -43,17 +72,59 @@ class RawUserMemoryClient:
             request_options=request_options,
         )
         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],
+                    ListUserMemoriesResponse,
                     parse_obj_as(
-                        type_=typing.Optional[typing.Any],  # type: ignore
+                        type_=ListUserMemoriesResponse,  # 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),
@@ -65,6 +136,28 @@ class RawUserMemoryClient:
                         ),
                     ),
                 )
+            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)
@@ -75,24 +168,35 @@ class RawUserMemoryClient:
         *,
         tenant_id: str,
         memory_id: str,
-        sub_tenant_id: str,
+        sub_tenant_id: typing.Optional[str] = None,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> HttpResponse[typing.Optional[typing.Any]]:
+    ) -> HttpResponse[DeleteUserMemoryResponse]:
         """
+        Permanently remove a specific user memory from storage.
+
+        This endpoint allows you to delete a user memory by its unique identifier.
+        Once deleted, the memory cannot be recovered, so use this operation carefully.
+
+        The memory will be removed from your tenant's storage and will no longer
+        appear in search results or memory listings.
+
         Parameters
         ----------
         tenant_id : str
+            Unique identifier for the tenant/organization
 
         memory_id : str
+            Unique identifier of the memory to delete
 
-        sub_tenant_id : str
+        sub_tenant_id : typing.Optional[str]
+            Optional sub-tenant identifier for organizing data within a tenant. If not provided, defaults to tenant_id
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        HttpResponse[typing.Optional[typing.Any]]
+        HttpResponse[DeleteUserMemoryResponse]
             Successful Response
         """
         _response = self._client_wrapper.httpx_client.request(
@@ -106,17 +210,59 @@ class RawUserMemoryClient:
             request_options=request_options,
         )
         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],
+                    DeleteUserMemoryResponse,
                     parse_obj_as(
-                        type_=typing.Optional[typing.Any],  # type: ignore
+                        type_=DeleteUserMemoryResponse,  # 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),
@@ -128,6 +274,28 @@ class RawUserMemoryClient:
                         ),
                     ),
                 )
+            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)
@@ -138,52 +306,113 @@ class RawUserMemoryClient:
         *,
         tenant_id: str,
         query: str,
-        sub_tenant_id: str,
+        sub_tenant_id: typing.Optional[str] = None,
         max_count: typing.Optional[int] = None,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> HttpResponse[typing.Optional[typing.Any]]:
+    ) -> HttpResponse[RetrieveUserMemoryResponse]:
         """
+        Find relevant user memories using semantic search.
+
+        This endpoint performs a semantic search across all your stored user memories
+        to find the most relevant ones based on your query. The results are ranked by
+        similarity score, with the most relevant memories returned first.
+
+        Use this to recall past preferences, context, or information that might be
+        relevant to your current task or query.
+
         Parameters
         ----------
         tenant_id : str
+            Unique identifier for the tenant/organization
 
         query : str
+            Search query to find relevant user memories
 
-        sub_tenant_id : str
+        sub_tenant_id : typing.Optional[str]
+            Optional sub-tenant identifier for organizing data within a tenant. If not provided, defaults to tenant_id
 
         max_count : typing.Optional[int]
+            Maximum number of memories to return (default: 5)
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        HttpResponse[typing.Optional[typing.Any]]
+        HttpResponse[RetrieveUserMemoryResponse]
             Successful Response
         """
         _response = self._client_wrapper.httpx_client.request(
             "user_memory/retrieve_user_memory",
-            method="GET",
+            method="POST",
             params={
                 "tenant_id": tenant_id,
-                "query": query,
                 "sub_tenant_id": sub_tenant_id,
                 "max_count": max_count,
             },
+            json={
+                "query": query,
+            },
+            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],
+                    RetrieveUserMemoryResponse,
                     parse_obj_as(
-                        type_=typing.Optional[typing.Any],  # type: ignore
+                        type_=RetrieveUserMemoryResponse,  # 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),
@@ -195,6 +424,28 @@ class RawUserMemoryClient:
                         ),
                     ),
                 )
+            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)
@@ -206,26 +457,39 @@ class RawUserMemoryClient:
         tenant_id: str,
         user_query: str,
         user_name: str,
-        sub_tenant_id: str,
+        sub_tenant_id: typing.Optional[str] = None,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> HttpResponse[typing.Optional[typing.Any]]:
+    ) -> HttpResponse[GenerateUserMemoryResponse]:
         """
+        Generate AI-powered user memories from your query and context.
+
+        This endpoint uses artificial intelligence to create personalized memories
+        based on your query and user context. The AI analyzes your input and generates
+        relevant, contextual memories that can help improve future interactions.
+
+        Generated memories are automatically stored and can be retrieved through
+        the standard memory search endpoints.
+
         Parameters
         ----------
         tenant_id : str
+            Unique identifier for the tenant/organization
 
         user_query : str
+            Your query or context for AI memory generation
 
         user_name : str
+            Your name to personalize the generated memories
 
-        sub_tenant_id : str
+        sub_tenant_id : typing.Optional[str]
+            Optional sub-tenant identifier for organizing data within a tenant. If not provided, defaults to tenant_id
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        HttpResponse[typing.Optional[typing.Any]]
+        HttpResponse[GenerateUserMemoryResponse]
             Successful Response
         """
         _response = self._client_wrapper.httpx_client.request(
@@ -233,24 +497,72 @@ class RawUserMemoryClient:
             method="POST",
             params={
                 "tenant_id": tenant_id,
+                "sub_tenant_id": sub_tenant_id,
+            },
+            json={
                 "user_query": user_query,
                 "user_name": user_name,
-                "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],
+                    GenerateUserMemoryResponse,
                     parse_obj_as(
-                        type_=typing.Optional[typing.Any],  # type: ignore
+                        type_=GenerateUserMemoryResponse,  # 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),
@@ -262,6 +574,28 @@ class RawUserMemoryClient:
                         ),
                     ),
                 )
+            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)
@@ -272,24 +606,36 @@ class RawUserMemoryClient:
         *,
         tenant_id: str,
         user_memory: str,
-        sub_tenant_id: str,
+        sub_tenant_id: typing.Optional[str] = None,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> HttpResponse[typing.Optional[typing.Any]]:
+    ) -> HttpResponse[AddUserMemoryResponse]:
         """
+        Store a new user memory for future reference.
+
+        This endpoint allows you to manually add a memory that will be stored and
+        can be retrieved later through memory search. Use this to save important
+        preferences, context, or information that you want the system to remember.
+
+        The stored memory will be indexed and available for semantic search, making
+        it accessible when relevant to future queries or interactions.
+
         Parameters
         ----------
         tenant_id : str
+            Unique identifier for the tenant/organization
 
         user_memory : str
+            The memory content to store for future reference
 
-        sub_tenant_id : str
+        sub_tenant_id : typing.Optional[str]
+            Optional sub-tenant identifier for organizing data within a tenant. If not provided, defaults to tenant_id
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        HttpResponse[typing.Optional[typing.Any]]
+        HttpResponse[AddUserMemoryResponse]
             Successful Response
         """
         _response = self._client_wrapper.httpx_client.request(
@@ -297,23 +643,71 @@ class RawUserMemoryClient:
             method="POST",
             params={
                 "tenant_id": tenant_id,
-                "user_memory": user_memory,
                 "sub_tenant_id": sub_tenant_id,
             },
+            json={
+                "user_memory": user_memory,
+            },
+            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],
+                    AddUserMemoryResponse,
                     parse_obj_as(
-                        type_=typing.Optional[typing.Any],  # type: ignore
+                        type_=AddUserMemoryResponse,  # 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),
@@ -325,6 +719,28 @@ class RawUserMemoryClient:
                         ),
                     ),
                 )
+            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)
@@ -336,21 +752,35 @@ class AsyncRawUserMemoryClient:
         self._client_wrapper = client_wrapper
 
     async def list_user_memories(
-        self, *, tenant_id: str, sub_tenant_id: str, request_options: typing.Optional[RequestOptions] = None
-    ) -> AsyncHttpResponse[typing.Optional[typing.Any]]:
+        self,
+        *,
+        tenant_id: str,
+        sub_tenant_id: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[ListUserMemoriesResponse]:
         """
+        Retrieve all stored user memories for your tenant.
+
+        This endpoint returns a comprehensive list of all user memories that have been stored,
+        whether they were added manually or generated through AI. User memories help personalize
+        your experience by storing context, preferences, and important information.
+
+        You can optionally specify a sub-tenant to filter memories within that specific scope.
+
         Parameters
         ----------
         tenant_id : str
+            Unique identifier for the tenant/organization
 
-        sub_tenant_id : str
+        sub_tenant_id : typing.Optional[str]
+            Optional sub-tenant identifier for organizing data within a tenant. If not provided, defaults to tenant_id
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[typing.Optional[typing.Any]]
+        AsyncHttpResponse[ListUserMemoriesResponse]
             Successful Response
         """
         _response = await self._client_wrapper.httpx_client.request(
@@ -363,17 +793,59 @@ class AsyncRawUserMemoryClient:
             request_options=request_options,
         )
         try:
-            if _response is None or not _response.text.strip():
-                return AsyncHttpResponse(response=_response, data=None)
             if 200 <= _response.status_code < 300:
                 _data = typing.cast(
-                    typing.Optional[typing.Any],
+                    ListUserMemoriesResponse,
                     parse_obj_as(
-                        type_=typing.Optional[typing.Any],  # type: ignore
+                        type_=ListUserMemoriesResponse,  # 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),
@@ -385,6 +857,28 @@ class AsyncRawUserMemoryClient:
                         ),
                     ),
                 )
+            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)
@@ -395,24 +889,35 @@ class AsyncRawUserMemoryClient:
         *,
         tenant_id: str,
         memory_id: str,
-        sub_tenant_id: str,
+        sub_tenant_id: typing.Optional[str] = None,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[typing.Optional[typing.Any]]:
+    ) -> AsyncHttpResponse[DeleteUserMemoryResponse]:
         """
+        Permanently remove a specific user memory from storage.
+
+        This endpoint allows you to delete a user memory by its unique identifier.
+        Once deleted, the memory cannot be recovered, so use this operation carefully.
+
+        The memory will be removed from your tenant's storage and will no longer
+        appear in search results or memory listings.
+
         Parameters
         ----------
         tenant_id : str
+            Unique identifier for the tenant/organization
 
         memory_id : str
+            Unique identifier of the memory to delete
 
-        sub_tenant_id : str
+        sub_tenant_id : typing.Optional[str]
+            Optional sub-tenant identifier for organizing data within a tenant. If not provided, defaults to tenant_id
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[typing.Optional[typing.Any]]
+        AsyncHttpResponse[DeleteUserMemoryResponse]
             Successful Response
         """
         _response = await self._client_wrapper.httpx_client.request(
@@ -426,17 +931,59 @@ class AsyncRawUserMemoryClient:
             request_options=request_options,
         )
         try:
-            if _response is None or not _response.text.strip():
-                return AsyncHttpResponse(response=_response, data=None)
             if 200 <= _response.status_code < 300:
                 _data = typing.cast(
-                    typing.Optional[typing.Any],
+                    DeleteUserMemoryResponse,
                     parse_obj_as(
-                        type_=typing.Optional[typing.Any],  # type: ignore
+                        type_=DeleteUserMemoryResponse,  # 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),
@@ -448,6 +995,28 @@ class AsyncRawUserMemoryClient:
                         ),
                     ),
                 )
+            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)
@@ -458,52 +1027,113 @@ class AsyncRawUserMemoryClient:
         *,
         tenant_id: str,
         query: str,
-        sub_tenant_id: str,
+        sub_tenant_id: typing.Optional[str] = None,
         max_count: typing.Optional[int] = None,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[typing.Optional[typing.Any]]:
+    ) -> AsyncHttpResponse[RetrieveUserMemoryResponse]:
         """
+        Find relevant user memories using semantic search.
+
+        This endpoint performs a semantic search across all your stored user memories
+        to find the most relevant ones based on your query. The results are ranked by
+        similarity score, with the most relevant memories returned first.
+
+        Use this to recall past preferences, context, or information that might be
+        relevant to your current task or query.
+
         Parameters
         ----------
         tenant_id : str
+            Unique identifier for the tenant/organization
 
         query : str
+            Search query to find relevant user memories
 
-        sub_tenant_id : str
+        sub_tenant_id : typing.Optional[str]
+            Optional sub-tenant identifier for organizing data within a tenant. If not provided, defaults to tenant_id
 
         max_count : typing.Optional[int]
+            Maximum number of memories to return (default: 5)
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[typing.Optional[typing.Any]]
+        AsyncHttpResponse[RetrieveUserMemoryResponse]
             Successful Response
         """
         _response = await self._client_wrapper.httpx_client.request(
             "user_memory/retrieve_user_memory",
-            method="GET",
+            method="POST",
             params={
                 "tenant_id": tenant_id,
-                "query": query,
                 "sub_tenant_id": sub_tenant_id,
                 "max_count": max_count,
             },
+            json={
+                "query": query,
+            },
+            headers={
+                "content-type": "application/json",
+            },
             request_options=request_options,
+            omit=OMIT,
         )
         try:
-            if _response is None or not _response.text.strip():
-                return AsyncHttpResponse(response=_response, data=None)
             if 200 <= _response.status_code < 300:
                 _data = typing.cast(
-                    typing.Optional[typing.Any],
+                    RetrieveUserMemoryResponse,
                     parse_obj_as(
-                        type_=typing.Optional[typing.Any],  # type: ignore
+                        type_=RetrieveUserMemoryResponse,  # 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),
@@ -515,6 +1145,28 @@ class AsyncRawUserMemoryClient:
                         ),
                     ),
                 )
+            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)
@@ -526,26 +1178,39 @@ class AsyncRawUserMemoryClient:
         tenant_id: str,
         user_query: str,
         user_name: str,
-        sub_tenant_id: str,
+        sub_tenant_id: typing.Optional[str] = None,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[typing.Optional[typing.Any]]:
+    ) -> AsyncHttpResponse[GenerateUserMemoryResponse]:
         """
+        Generate AI-powered user memories from your query and context.
+
+        This endpoint uses artificial intelligence to create personalized memories
+        based on your query and user context. The AI analyzes your input and generates
+        relevant, contextual memories that can help improve future interactions.
+
+        Generated memories are automatically stored and can be retrieved through
+        the standard memory search endpoints.
+
         Parameters
         ----------
         tenant_id : str
+            Unique identifier for the tenant/organization
 
         user_query : str
+            Your query or context for AI memory generation
 
         user_name : str
+            Your name to personalize the generated memories
 
-        sub_tenant_id : str
+        sub_tenant_id : typing.Optional[str]
+            Optional sub-tenant identifier for organizing data within a tenant. If not provided, defaults to tenant_id
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[typing.Optional[typing.Any]]
+        AsyncHttpResponse[GenerateUserMemoryResponse]
             Successful Response
         """
         _response = await self._client_wrapper.httpx_client.request(
@@ -553,24 +1218,72 @@ class AsyncRawUserMemoryClient:
             method="POST",
             params={
                 "tenant_id": tenant_id,
+                "sub_tenant_id": sub_tenant_id,
+            },
+            json={
                 "user_query": user_query,
                 "user_name": user_name,
-                "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 AsyncHttpResponse(response=_response, data=None)
             if 200 <= _response.status_code < 300:
                 _data = typing.cast(
-                    typing.Optional[typing.Any],
+                    GenerateUserMemoryResponse,
                     parse_obj_as(
-                        type_=typing.Optional[typing.Any],  # type: ignore
+                        type_=GenerateUserMemoryResponse,  # 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),
@@ -582,6 +1295,28 @@ class AsyncRawUserMemoryClient:
                         ),
                     ),
                 )
+            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)
@@ -592,24 +1327,36 @@ class AsyncRawUserMemoryClient:
         *,
         tenant_id: str,
         user_memory: str,
-        sub_tenant_id: str,
+        sub_tenant_id: typing.Optional[str] = None,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[typing.Optional[typing.Any]]:
+    ) -> AsyncHttpResponse[AddUserMemoryResponse]:
         """
+        Store a new user memory for future reference.
+
+        This endpoint allows you to manually add a memory that will be stored and
+        can be retrieved later through memory search. Use this to save important
+        preferences, context, or information that you want the system to remember.
+
+        The stored memory will be indexed and available for semantic search, making
+        it accessible when relevant to future queries or interactions.
+
         Parameters
         ----------
         tenant_id : str
+            Unique identifier for the tenant/organization
 
         user_memory : str
+            The memory content to store for future reference
 
-        sub_tenant_id : str
+        sub_tenant_id : typing.Optional[str]
+            Optional sub-tenant identifier for organizing data within a tenant. If not provided, defaults to tenant_id
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[typing.Optional[typing.Any]]
+        AsyncHttpResponse[AddUserMemoryResponse]
             Successful Response
         """
         _response = await self._client_wrapper.httpx_client.request(
@@ -617,23 +1364,71 @@ class AsyncRawUserMemoryClient:
             method="POST",
             params={
                 "tenant_id": tenant_id,
-                "user_memory": user_memory,
                 "sub_tenant_id": sub_tenant_id,
             },
+            json={
+                "user_memory": user_memory,
+            },
+            headers={
+                "content-type": "application/json",
+            },
             request_options=request_options,
+            omit=OMIT,
         )
         try:
-            if _response is None or not _response.text.strip():
-                return AsyncHttpResponse(response=_response, data=None)
             if 200 <= _response.status_code < 300:
                 _data = typing.cast(
-                    typing.Optional[typing.Any],
+                    AddUserMemoryResponse,
                     parse_obj_as(
-                        type_=typing.Optional[typing.Any],  # type: ignore
+                        type_=AddUserMemoryResponse,  # 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),
@@ -645,6 +1440,28 @@ class AsyncRawUserMemoryClient:
                         ),
                     ),
                 )
+            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)