supermemory 3.0.0a25__py3-none-any.whl → 3.0.0a27__py3-none-any.whl

supermemory/_files.py

@@ -34,7 +34,7 @@ def assert_is_file_content(obj: object, *, key: str | None = None) -> None:
     if not is_file_content(obj):
         prefix = f"Expected entry at `{key}`" if key is not None else f"Expected file input `{obj!r}`"
         raise RuntimeError(
-            f"{prefix} to be bytes, an io.IOBase instance, PathLike or a tuple but received {type(obj)} instead."
+            f"{prefix} to be bytes, an io.IOBase instance, PathLike or a tuple but received {type(obj)} instead. See https://github.com/supermemoryai/python-sdk/tree/main#file-uploads"
         ) from None
 
 

supermemory/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "supermemory"
-__version__ = "3.0.0-alpha.25"  # x-release-please-version
+__version__ = "3.0.0-alpha.27"  # x-release-please-version

supermemory/resources/memories.py

@@ -2,14 +2,14 @@
 
 from __future__ import annotations
 
-from typing import Dict, List, Union
+from typing import Dict, List, Union, Mapping, cast
 from typing_extensions import Literal
 
 import httpx
 
-from ..types import memory_add_params, memory_list_params, memory_update_params
-from .._types import NOT_GIVEN, Body, Query, Headers, NoneType, NotGiven
-from .._utils import maybe_transform, async_maybe_transform
+from ..types import memory_add_params, memory_list_params, memory_update_params, memory_upload_file_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NoneType, NotGiven, FileTypes
+from .._utils import extract_files, maybe_transform, deepcopy_minimal, async_maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
 from .._response import (
@@ -23,6 +23,7 @@ from ..types.memory_add_response import MemoryAddResponse
 from ..types.memory_get_response import MemoryGetResponse
 from ..types.memory_list_response import MemoryListResponse
 from ..types.memory_update_response import MemoryUpdateResponse
+from ..types.memory_upload_file_response import MemoryUploadFileResponse
 
 __all__ = ["MemoriesResource", "AsyncMemoriesResource"]
 
@@ -305,6 +306,51 @@ class MemoriesResource(SyncAPIResource):
             cast_to=MemoryGetResponse,
         )
 
+    def upload_file(
+        self,
+        *,
+        file: FileTypes,
+        container_tags: str | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> MemoryUploadFileResponse:
+        """
+        Upload a file to be processed
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        body = deepcopy_minimal(
+            {
+                "file": file,
+                "container_tags": container_tags,
+            }
+        )
+        files = extract_files(cast(Mapping[str, object], body), paths=[["file"]])
+        # It should be noted that the actual Content-Type header that will be
+        # sent to the server will contain a `boundary` parameter, e.g.
+        # multipart/form-data; boundary=---abc--
+        extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
+        return self._post(
+            "/v3/memories/file",
+            body=maybe_transform(body, memory_upload_file_params.MemoryUploadFileParams),
+            files=files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=MemoryUploadFileResponse,
+        )
+
 
 class AsyncMemoriesResource(AsyncAPIResource):
     @cached_property
@@ -584,6 +630,51 @@ class AsyncMemoriesResource(AsyncAPIResource):
             cast_to=MemoryGetResponse,
         )
 
+    async def upload_file(
+        self,
+        *,
+        file: FileTypes,
+        container_tags: str | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> MemoryUploadFileResponse:
+        """
+        Upload a file to be processed
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        body = deepcopy_minimal(
+            {
+                "file": file,
+                "container_tags": container_tags,
+            }
+        )
+        files = extract_files(cast(Mapping[str, object], body), paths=[["file"]])
+        # It should be noted that the actual Content-Type header that will be
+        # sent to the server will contain a `boundary` parameter, e.g.
+        # multipart/form-data; boundary=---abc--
+        extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
+        return await self._post(
+            "/v3/memories/file",
+            body=await async_maybe_transform(body, memory_upload_file_params.MemoryUploadFileParams),
+            files=files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=MemoryUploadFileResponse,
+        )
+
 
 class MemoriesResourceWithRawResponse:
     def __init__(self, memories: MemoriesResource) -> None:
@@ -604,6 +695,9 @@ class MemoriesResourceWithRawResponse:
         self.get = to_raw_response_wrapper(
             memories.get,
         )
+        self.upload_file = to_raw_response_wrapper(
+            memories.upload_file,
+        )
 
 
 class AsyncMemoriesResourceWithRawResponse:
@@ -625,6 +719,9 @@ class AsyncMemoriesResourceWithRawResponse:
         self.get = async_to_raw_response_wrapper(
             memories.get,
         )
+        self.upload_file = async_to_raw_response_wrapper(
+            memories.upload_file,
+        )
 
 
 class MemoriesResourceWithStreamingResponse:
@@ -646,6 +743,9 @@ class MemoriesResourceWithStreamingResponse:
         self.get = to_streamed_response_wrapper(
             memories.get,
         )
+        self.upload_file = to_streamed_response_wrapper(
+            memories.upload_file,
+        )
 
 
 class AsyncMemoriesResourceWithStreamingResponse:
@@ -667,3 +767,6 @@ class AsyncMemoriesResourceWithStreamingResponse:
         self.get = async_to_streamed_response_wrapper(
             memories.get,
         )
+        self.upload_file = async_to_streamed_response_wrapper(
+            memories.upload_file,
+        )

supermemory/resources/search.py

@@ -7,7 +7,7 @@ from typing_extensions import Literal
 
 import httpx
 
-from ..types import search_execute_params
+from ..types import search_execute_params, search_memories_params, search_documents_params
 from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
 from .._utils import maybe_transform, async_maybe_transform
 from .._compat import cached_property
@@ -20,6 +20,8 @@ from .._response import (
 )
 from .._base_client import make_request_options
 from ..types.search_execute_response import SearchExecuteResponse
+from ..types.search_memories_response import SearchMemoriesResponse
+from ..types.search_documents_response import SearchDocumentsResponse
 
 __all__ = ["SearchResource", "AsyncSearchResource"]
 
@@ -44,6 +46,105 @@ class SearchResource(SyncAPIResource):
         """
         return SearchResourceWithStreamingResponse(self)
 
+    def documents(
+        self,
+        *,
+        q: str,
+        categories_filter: List[Literal["technology", "science", "business", "health"]] | NotGiven = NOT_GIVEN,
+        chunk_threshold: float | NotGiven = NOT_GIVEN,
+        container_tags: List[str] | NotGiven = NOT_GIVEN,
+        doc_id: str | NotGiven = NOT_GIVEN,
+        document_threshold: float | NotGiven = NOT_GIVEN,
+        filters: search_documents_params.Filters | NotGiven = NOT_GIVEN,
+        include_full_docs: bool | NotGiven = NOT_GIVEN,
+        include_summary: bool | NotGiven = NOT_GIVEN,
+        limit: int | NotGiven = NOT_GIVEN,
+        only_matching_chunks: bool | NotGiven = NOT_GIVEN,
+        rerank: bool | NotGiven = NOT_GIVEN,
+        rewrite_query: bool | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> SearchDocumentsResponse:
+        """
+        Search memories with advanced filtering
+
+        Args:
+          q: Search query string
+
+          categories_filter: Optional category filters
+
+          chunk_threshold: Threshold / sensitivity for chunk selection. 0 is least sensitive (returns most
+              chunks, more results), 1 is most sensitive (returns lesser chunks, accurate
+              results)
+
+          container_tags: Optional tags this search should be containerized by. This can be an ID for your
+              user, a project ID, or any other identifier you wish to use to filter memories.
+
+          doc_id: Optional document ID to search within. You can use this to find chunks in a very
+              large document.
+
+          document_threshold: Threshold / sensitivity for document selection. 0 is least sensitive (returns
+              most documents, more results), 1 is most sensitive (returns lesser documents,
+              accurate results)
+
+          filters: Optional filters to apply to the search
+
+          include_full_docs: If true, include full document in the response. This is helpful if you want a
+              chatbot to know the full context of the document.
+
+          include_summary: If true, include document summary in the response. This is helpful if you want a
+              chatbot to know the full context of the document.
+
+          limit: Maximum number of results to return
+
+          only_matching_chunks: If true, only return matching chunks without context. Normally, we send the
+              previous and next chunk to provide more context for LLMs. If you only want the
+              matching chunk, set this to true.
+
+          rerank: If true, rerank the results based on the query. This is helpful if you want to
+              ensure the most relevant results are returned.
+
+          rewrite_query: If true, rewrites the query to make it easier to find documents. This increases
+              the latency by about 400ms
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/v3/search",
+            body=maybe_transform(
+                {
+                    "q": q,
+                    "categories_filter": categories_filter,
+                    "chunk_threshold": chunk_threshold,
+                    "container_tags": container_tags,
+                    "doc_id": doc_id,
+                    "document_threshold": document_threshold,
+                    "filters": filters,
+                    "include_full_docs": include_full_docs,
+                    "include_summary": include_summary,
+                    "limit": limit,
+                    "only_matching_chunks": only_matching_chunks,
+                    "rerank": rerank,
+                    "rewrite_query": rewrite_query,
+                },
+                search_documents_params.SearchDocumentsParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SearchDocumentsResponse,
+        )
+
     def execute(
         self,
         *,
@@ -143,6 +244,76 @@ class SearchResource(SyncAPIResource):
             cast_to=SearchExecuteResponse,
         )
 
+    def memories(
+        self,
+        *,
+        q: str,
+        container_tag: str | NotGiven = NOT_GIVEN,
+        filters: search_memories_params.Filters | NotGiven = NOT_GIVEN,
+        include: search_memories_params.Include | NotGiven = NOT_GIVEN,
+        limit: int | NotGiven = NOT_GIVEN,
+        rerank: bool | NotGiven = NOT_GIVEN,
+        rewrite_query: bool | NotGiven = NOT_GIVEN,
+        threshold: float | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> SearchMemoriesResponse:
+        """
+        Search memory entries - Low latency for conversational
+
+        Args:
+          q: Search query string
+
+          container_tag: Optional tag this search should be containerized by. This can be an ID for your
+              user, a project ID, or any other identifier you wish to use to filter memories.
+
+          filters: Optional filters to apply to the search
+
+          limit: Maximum number of results to return
+
+          rerank: If true, rerank the results based on the query. This is helpful if you want to
+              ensure the most relevant results are returned.
+
+          rewrite_query: If true, rewrites the query to make it easier to find documents. This increases
+              the latency by about 400ms
+
+          threshold: Threshold / sensitivity for memories selection. 0 is least sensitive (returns
+              most memories, more results), 1 is most sensitive (returns lesser memories,
+              accurate results)
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/v4/search",
+            body=maybe_transform(
+                {
+                    "q": q,
+                    "container_tag": container_tag,
+                    "filters": filters,
+                    "include": include,
+                    "limit": limit,
+                    "rerank": rerank,
+                    "rewrite_query": rewrite_query,
+                    "threshold": threshold,
+                },
+                search_memories_params.SearchMemoriesParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SearchMemoriesResponse,
+        )
+
 
 class AsyncSearchResource(AsyncAPIResource):
     @cached_property
@@ -164,6 +335,105 @@ class AsyncSearchResource(AsyncAPIResource):
         """
         return AsyncSearchResourceWithStreamingResponse(self)
 
+    async def documents(
+        self,
+        *,
+        q: str,
+        categories_filter: List[Literal["technology", "science", "business", "health"]] | NotGiven = NOT_GIVEN,
+        chunk_threshold: float | NotGiven = NOT_GIVEN,
+        container_tags: List[str] | NotGiven = NOT_GIVEN,
+        doc_id: str | NotGiven = NOT_GIVEN,
+        document_threshold: float | NotGiven = NOT_GIVEN,
+        filters: search_documents_params.Filters | NotGiven = NOT_GIVEN,
+        include_full_docs: bool | NotGiven = NOT_GIVEN,
+        include_summary: bool | NotGiven = NOT_GIVEN,
+        limit: int | NotGiven = NOT_GIVEN,
+        only_matching_chunks: bool | NotGiven = NOT_GIVEN,
+        rerank: bool | NotGiven = NOT_GIVEN,
+        rewrite_query: bool | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> SearchDocumentsResponse:
+        """
+        Search memories with advanced filtering
+
+        Args:
+          q: Search query string
+
+          categories_filter: Optional category filters
+
+          chunk_threshold: Threshold / sensitivity for chunk selection. 0 is least sensitive (returns most
+              chunks, more results), 1 is most sensitive (returns lesser chunks, accurate
+              results)
+
+          container_tags: Optional tags this search should be containerized by. This can be an ID for your
+              user, a project ID, or any other identifier you wish to use to filter memories.
+
+          doc_id: Optional document ID to search within. You can use this to find chunks in a very
+              large document.
+
+          document_threshold: Threshold / sensitivity for document selection. 0 is least sensitive (returns
+              most documents, more results), 1 is most sensitive (returns lesser documents,
+              accurate results)
+
+          filters: Optional filters to apply to the search
+
+          include_full_docs: If true, include full document in the response. This is helpful if you want a
+              chatbot to know the full context of the document.
+
+          include_summary: If true, include document summary in the response. This is helpful if you want a
+              chatbot to know the full context of the document.
+
+          limit: Maximum number of results to return
+
+          only_matching_chunks: If true, only return matching chunks without context. Normally, we send the
+              previous and next chunk to provide more context for LLMs. If you only want the
+              matching chunk, set this to true.
+
+          rerank: If true, rerank the results based on the query. This is helpful if you want to
+              ensure the most relevant results are returned.
+
+          rewrite_query: If true, rewrites the query to make it easier to find documents. This increases
+              the latency by about 400ms
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/v3/search",
+            body=await async_maybe_transform(
+                {
+                    "q": q,
+                    "categories_filter": categories_filter,
+                    "chunk_threshold": chunk_threshold,
+                    "container_tags": container_tags,
+                    "doc_id": doc_id,
+                    "document_threshold": document_threshold,
+                    "filters": filters,
+                    "include_full_docs": include_full_docs,
+                    "include_summary": include_summary,
+                    "limit": limit,
+                    "only_matching_chunks": only_matching_chunks,
+                    "rerank": rerank,
+                    "rewrite_query": rewrite_query,
+                },
+                search_documents_params.SearchDocumentsParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SearchDocumentsResponse,
+        )
+
     async def execute(
         self,
         *,
@@ -263,38 +533,132 @@ class AsyncSearchResource(AsyncAPIResource):
             cast_to=SearchExecuteResponse,
         )
 
+    async def memories(
+        self,
+        *,
+        q: str,
+        container_tag: str | NotGiven = NOT_GIVEN,
+        filters: search_memories_params.Filters | NotGiven = NOT_GIVEN,
+        include: search_memories_params.Include | NotGiven = NOT_GIVEN,
+        limit: int | NotGiven = NOT_GIVEN,
+        rerank: bool | NotGiven = NOT_GIVEN,
+        rewrite_query: bool | NotGiven = NOT_GIVEN,
+        threshold: float | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> SearchMemoriesResponse:
+        """
+        Search memory entries - Low latency for conversational
+
+        Args:
+          q: Search query string
+
+          container_tag: Optional tag this search should be containerized by. This can be an ID for your
+              user, a project ID, or any other identifier you wish to use to filter memories.
+
+          filters: Optional filters to apply to the search
+
+          limit: Maximum number of results to return
+
+          rerank: If true, rerank the results based on the query. This is helpful if you want to
+              ensure the most relevant results are returned.
+
+          rewrite_query: If true, rewrites the query to make it easier to find documents. This increases
+              the latency by about 400ms
+
+          threshold: Threshold / sensitivity for memories selection. 0 is least sensitive (returns
+              most memories, more results), 1 is most sensitive (returns lesser memories,
+              accurate results)
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/v4/search",
+            body=await async_maybe_transform(
+                {
+                    "q": q,
+                    "container_tag": container_tag,
+                    "filters": filters,
+                    "include": include,
+                    "limit": limit,
+                    "rerank": rerank,
+                    "rewrite_query": rewrite_query,
+                    "threshold": threshold,
+                },
+                search_memories_params.SearchMemoriesParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SearchMemoriesResponse,
+        )
+
 
 class SearchResourceWithRawResponse:
     def __init__(self, search: SearchResource) -> None:
         self._search = search
 
+        self.documents = to_raw_response_wrapper(
+            search.documents,
+        )
         self.execute = to_raw_response_wrapper(
             search.execute,
         )
+        self.memories = to_raw_response_wrapper(
+            search.memories,
+        )
 
 
 class AsyncSearchResourceWithRawResponse:
     def __init__(self, search: AsyncSearchResource) -> None:
         self._search = search
 
+        self.documents = async_to_raw_response_wrapper(
+            search.documents,
+        )
         self.execute = async_to_raw_response_wrapper(
             search.execute,
         )
+        self.memories = async_to_raw_response_wrapper(
+            search.memories,
+        )
 
 
 class SearchResourceWithStreamingResponse:
     def __init__(self, search: SearchResource) -> None:
         self._search = search
 
+        self.documents = to_streamed_response_wrapper(
+            search.documents,
+        )
         self.execute = to_streamed_response_wrapper(
             search.execute,
         )
+        self.memories = to_streamed_response_wrapper(
+            search.memories,
+        )
 
 
 class AsyncSearchResourceWithStreamingResponse:
     def __init__(self, search: AsyncSearchResource) -> None:
         self._search = search
 
+        self.documents = async_to_streamed_response_wrapper(
+            search.documents,
+        )
         self.execute = async_to_streamed_response_wrapper(
             search.execute,
         )
+        self.memories = async_to_streamed_response_wrapper(
+            search.memories,
+        )

supermemory/types/__init__.py

@@ -13,12 +13,18 @@ from .search_execute_params import SearchExecuteParams as SearchExecuteParams
 from .setting_update_params import SettingUpdateParams as SettingUpdateParams
 from .connection_list_params import ConnectionListParams as ConnectionListParams
 from .memory_update_response import MemoryUpdateResponse as MemoryUpdateResponse
+from .search_memories_params import SearchMemoriesParams as SearchMemoriesParams
+from .search_documents_params import SearchDocumentsParams as SearchDocumentsParams
 from .search_execute_response import SearchExecuteResponse as SearchExecuteResponse
 from .setting_update_response import SettingUpdateResponse as SettingUpdateResponse
 from .connection_create_params import ConnectionCreateParams as ConnectionCreateParams
 from .connection_import_params import ConnectionImportParams as ConnectionImportParams
 from .connection_list_response import ConnectionListResponse as ConnectionListResponse
+from .search_memories_response import SearchMemoriesResponse as SearchMemoriesResponse
+from .memory_upload_file_params import MemoryUploadFileParams as MemoryUploadFileParams
+from .search_documents_response import SearchDocumentsResponse as SearchDocumentsResponse
 from .connection_create_response import ConnectionCreateResponse as ConnectionCreateResponse
+from .memory_upload_file_response import MemoryUploadFileResponse as MemoryUploadFileResponse
 from .connection_get_by_id_response import ConnectionGetByIDResponse as ConnectionGetByIDResponse
 from .connection_get_by_tags_params import ConnectionGetByTagsParams as ConnectionGetByTagsParams
 from .connection_get_by_tags_response import ConnectionGetByTagsResponse as ConnectionGetByTagsResponse

supermemory/types/memory_upload_file_params.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, Annotated, TypedDict
+
+from .._types import FileTypes
+from .._utils import PropertyInfo
+
+__all__ = ["MemoryUploadFileParams"]
+
+
+class MemoryUploadFileParams(TypedDict, total=False):
+    file: Required[FileTypes]
+
+    container_tags: Annotated[str, PropertyInfo(alias="containerTags")]

supermemory/types/memory_upload_file_response.py

@@ -0,0 +1,11 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .._models import BaseModel
+
+__all__ = ["MemoryUploadFileResponse"]
+
+
+class MemoryUploadFileResponse(BaseModel):
+    id: str
+
+    status: str

supermemory/types/search_documents_params.py

@@ -0,0 +1,93 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, List, Union, Iterable
+from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["SearchDocumentsParams", "Filters", "FiltersUnionMember0"]
+
+
+class SearchDocumentsParams(TypedDict, total=False):
+    q: Required[str]
+    """Search query string"""
+
+    categories_filter: Annotated[
+        List[Literal["technology", "science", "business", "health"]], PropertyInfo(alias="categoriesFilter")
+    ]
+    """Optional category filters"""
+
+    chunk_threshold: Annotated[float, PropertyInfo(alias="chunkThreshold")]
+    """Threshold / sensitivity for chunk selection.
+
+    0 is least sensitive (returns most chunks, more results), 1 is most sensitive
+    (returns lesser chunks, accurate results)
+    """
+
+    container_tags: Annotated[List[str], PropertyInfo(alias="containerTags")]
+    """Optional tags this search should be containerized by.
+
+    This can be an ID for your user, a project ID, or any other identifier you wish
+    to use to filter memories.
+    """
+
+    doc_id: Annotated[str, PropertyInfo(alias="docId")]
+    """Optional document ID to search within.
+
+    You can use this to find chunks in a very large document.
+    """
+
+    document_threshold: Annotated[float, PropertyInfo(alias="documentThreshold")]
+    """Threshold / sensitivity for document selection.
+
+    0 is least sensitive (returns most documents, more results), 1 is most sensitive
+    (returns lesser documents, accurate results)
+    """
+
+    filters: Filters
+    """Optional filters to apply to the search"""
+
+    include_full_docs: Annotated[bool, PropertyInfo(alias="includeFullDocs")]
+    """If true, include full document in the response.
+
+    This is helpful if you want a chatbot to know the full context of the document.
+    """
+
+    include_summary: Annotated[bool, PropertyInfo(alias="includeSummary")]
+    """If true, include document summary in the response.
+
+    This is helpful if you want a chatbot to know the full context of the document.
+    """
+
+    limit: int
+    """Maximum number of results to return"""
+
+    only_matching_chunks: Annotated[bool, PropertyInfo(alias="onlyMatchingChunks")]
+    """If true, only return matching chunks without context.
+
+    Normally, we send the previous and next chunk to provide more context for LLMs.
+    If you only want the matching chunk, set this to true.
+    """
+
+    rerank: bool
+    """If true, rerank the results based on the query.
+
+    This is helpful if you want to ensure the most relevant results are returned.
+    """
+
+    rewrite_query: Annotated[bool, PropertyInfo(alias="rewriteQuery")]
+    """If true, rewrites the query to make it easier to find documents.
+
+    This increases the latency by about 400ms
+    """
+
+
+class FiltersUnionMember0(TypedDict, total=False):
+    and_: Annotated[Iterable[object], PropertyInfo(alias="AND")]
+
+    or_: Annotated[Iterable[object], PropertyInfo(alias="OR")]
+
+
+Filters: TypeAlias = Union[FiltersUnionMember0, Dict[str, object]]

supermemory/types/search_documents_response.py

@@ -0,0 +1,61 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Optional
+from datetime import datetime
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["SearchDocumentsResponse", "Result", "ResultChunk"]
+
+
+class ResultChunk(BaseModel):
+    content: str
+    """Content of the matching chunk"""
+
+    is_relevant: bool = FieldInfo(alias="isRelevant")
+    """Whether this chunk is relevant to the query"""
+
+    score: float
+    """Similarity score for this chunk"""
+
+
+class Result(BaseModel):
+    chunks: List[ResultChunk]
+    """Matching content chunks from the document"""
+
+    created_at: datetime = FieldInfo(alias="createdAt")
+    """Document creation date"""
+
+    document_id: str = FieldInfo(alias="documentId")
+    """ID of the matching document"""
+
+    metadata: Optional[Dict[str, object]] = None
+    """Document metadata"""
+
+    score: float
+    """Relevance score of the match"""
+
+    title: Optional[str] = None
+    """Document title"""
+
+    type: Optional[str] = None
+    """Document type"""
+
+    updated_at: datetime = FieldInfo(alias="updatedAt")
+    """Document last update date"""
+
+    content: Optional[str] = None
+    """Full document content (only included when includeFullDocs=true)"""
+
+    summary: Optional[str] = None
+    """Document summary"""
+
+
+class SearchDocumentsResponse(BaseModel):
+    results: List[Result]
+
+    timing: float
+
+    total: float

supermemory/types/search_memories_params.py

@@ -0,0 +1,66 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union, Iterable
+from typing_extensions import Required, Annotated, TypeAlias, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["SearchMemoriesParams", "Filters", "FiltersUnionMember0", "Include"]
+
+
+class SearchMemoriesParams(TypedDict, total=False):
+    q: Required[str]
+    """Search query string"""
+
+    container_tag: Annotated[str, PropertyInfo(alias="containerTag")]
+    """Optional tag this search should be containerized by.
+
+    This can be an ID for your user, a project ID, or any other identifier you wish
+    to use to filter memories.
+    """
+
+    filters: Filters
+    """Optional filters to apply to the search"""
+
+    include: Include
+
+    limit: int
+    """Maximum number of results to return"""
+
+    rerank: bool
+    """If true, rerank the results based on the query.
+
+    This is helpful if you want to ensure the most relevant results are returned.
+    """
+
+    rewrite_query: Annotated[bool, PropertyInfo(alias="rewriteQuery")]
+    """If true, rewrites the query to make it easier to find documents.
+
+    This increases the latency by about 400ms
+    """
+
+    threshold: float
+    """Threshold / sensitivity for memories selection.
+
+    0 is least sensitive (returns most memories, more results), 1 is most sensitive
+    (returns lesser memories, accurate results)
+    """
+
+
+class FiltersUnionMember0(TypedDict, total=False):
+    and_: Annotated[Iterable[object], PropertyInfo(alias="AND")]
+
+    or_: Annotated[Iterable[object], PropertyInfo(alias="OR")]
+
+
+Filters: TypeAlias = Union[FiltersUnionMember0, Dict[str, object]]
+
+
+class Include(TypedDict, total=False):
+    documents: bool
+
+    related_memories: Annotated[bool, PropertyInfo(alias="relatedMemories")]
+
+    summaries: bool

supermemory/types/search_memories_response.py

@@ -0,0 +1,121 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = [
+    "SearchMemoriesResponse",
+    "Result",
+    "ResultContext",
+    "ResultContextChild",
+    "ResultContextParent",
+    "ResultDocument",
+]
+
+
+class ResultContextChild(BaseModel):
+    memory: str
+    """The contextual memory content"""
+
+    relation: Literal["updates", "extends", "derives"]
+    """Relation type between this memory and its parent/child"""
+
+    updated_at: datetime = FieldInfo(alias="updatedAt")
+    """Contextual memory last update date"""
+
+    metadata: Optional[Dict[str, object]] = None
+    """Contextual memory metadata"""
+
+    version: Optional[float] = None
+    """
+    Relative version distance from the primary memory (+1 for direct child, +2 for
+    grand-child, etc.)
+    """
+
+
+class ResultContextParent(BaseModel):
+    memory: str
+    """The contextual memory content"""
+
+    relation: Literal["updates", "extends", "derives"]
+    """Relation type between this memory and its parent/child"""
+
+    updated_at: datetime = FieldInfo(alias="updatedAt")
+    """Contextual memory last update date"""
+
+    metadata: Optional[Dict[str, object]] = None
+    """Contextual memory metadata"""
+
+    version: Optional[float] = None
+    """
+    Relative version distance from the primary memory (-1 for direct parent, -2 for
+    grand-parent, etc.)
+    """
+
+
+class ResultContext(BaseModel):
+    children: Optional[List[ResultContextChild]] = None
+
+    parents: Optional[List[ResultContextParent]] = None
+
+
+class ResultDocument(BaseModel):
+    id: str
+    """Document ID"""
+
+    created_at: datetime = FieldInfo(alias="createdAt")
+    """Document creation date"""
+
+    metadata: Optional[Dict[str, object]] = None
+    """Document metadata"""
+
+    title: str
+    """Document title"""
+
+    type: str
+    """Document type"""
+
+    updated_at: datetime = FieldInfo(alias="updatedAt")
+    """Document last update date"""
+
+
+class Result(BaseModel):
+    id: str
+    """Memory entry ID"""
+
+    memory: str
+    """The memory content"""
+
+    metadata: Optional[Dict[str, object]] = None
+    """Memory metadata"""
+
+    similarity: float
+    """Similarity score between the query and memory entry"""
+
+    updated_at: datetime = FieldInfo(alias="updatedAt")
+    """Memory last update date"""
+
+    context: Optional[ResultContext] = None
+    """Object containing arrays of parent and child contextual memories"""
+
+    documents: Optional[List[ResultDocument]] = None
+    """Associated documents for this memory entry"""
+
+    version: Optional[float] = None
+    """Version number of this memory entry"""
+
+
+class SearchMemoriesResponse(BaseModel):
+    results: List[Result]
+    """Array of matching memory entries with similarity scores"""
+
+    timing: float
+    """Search execution time in milliseconds"""
+
+    total: float
+    """Total number of results returned"""

{supermemory-3.0.0a25.dist-info → supermemory-3.0.0a27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: supermemory
-Version: 3.0.0a25
+Version: 3.0.0a27
 Summary: The official Python library for the supermemory API
 Project-URL: Homepage, https://github.com/supermemoryai/python-sdk
 Project-URL: Repository, https://github.com/supermemoryai/python-sdk
@@ -67,7 +67,7 @@ client = Supermemory(
     api_key=os.environ.get("SUPERMEMORY_API_KEY"),  # This is the default and can be omitted
 )
 
-response = client.search.execute(
+response = client.search.documents(
     q="documents related to python",
 )
 print(response.results)
@@ -93,7 +93,7 @@ client = AsyncSupermemory(
 
 
 async def main() -> None:
-    response = await client.search.execute(
+    response = await client.search.documents(
         q="documents related to python",
     )
     print(response.results)
@@ -128,7 +128,7 @@ async def main() -> None:
         api_key="My API Key",
         http_client=DefaultAioHttpClient(),
     ) as client:
-        response = await client.search.execute(
+        response = await client.search.documents(
             q="documents related to python",
         )
         print(response.results)
@@ -146,6 +146,39 @@ Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typ
 
 Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.
 
+## Nested params
+
+Nested parameters are dictionaries, typed using `TypedDict`, for example:
+
+```python
+from supermemory import Supermemory
+
+client = Supermemory()
+
+response = client.search.memories(
+    q="machine learning concepts",
+    include={},
+)
+print(response.include)
+```
+
+## File uploads
+
+Request parameters that correspond to file uploads can be passed as `bytes`, or a [`PathLike`](https://docs.python.org/3/library/os.html#os.PathLike) instance or a tuple of `(filename, contents, media type)`.
+
+```python
+from pathlib import Path
+from supermemory import Supermemory
+
+client = Supermemory()
+
+client.memories.upload_file(
+    file=Path("/path/to/file"),
+)
+```
+
+The async client uses the exact same interface. If you pass a [`PathLike`](https://docs.python.org/3/library/os.html#os.PathLike) instance, the file contents will be read asynchronously automatically.
+
 ## Handling errors
 
 When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `supermemory.APIConnectionError` is raised.

{supermemory-3.0.0a25.dist-info → supermemory-3.0.0a27.dist-info}/RECORD

@@ -4,14 +4,14 @@ supermemory/_client.py,sha256=2KcNz77blgIaQddenKFBrWXUqBG7IlP4vGuVYTix5bk,16890
 supermemory/_compat.py,sha256=VWemUKbj6DDkQ-O4baSpHVLJafotzeXmCQGJugfVTIw,6580
 supermemory/_constants.py,sha256=S14PFzyN9-I31wiV7SmIlL5Ga0MLHxdvegInGdXH7tM,462
 supermemory/_exceptions.py,sha256=5nnX7W8L_eA6LkX3SBl7csJy5d9QEcDqRVuwDq8wVh8,3230
-supermemory/_files.py,sha256=KnEzGi_O756MvKyJ4fOCW_u3JhOeWPQ4RsmDvqihDQU,3545
+supermemory/_files.py,sha256=9QITJCyATjxJqhMXckfLrrOKltxCpKhbrlZX_NcL9WQ,3616
 supermemory/_models.py,sha256=KvjsMfb88XZlFUKVoOxr8OyDj47MhoH2OKqWNEbBhk4,30010
 supermemory/_qs.py,sha256=AOkSz4rHtK4YI3ZU_kzea-zpwBUgEY8WniGmTPyEimc,4846
 supermemory/_resource.py,sha256=_wuaB1exMy-l-qqdJJdTv15hH5qBSN2Rj9CFwjXTZJU,1130
 supermemory/_response.py,sha256=Yh869-U8INkojKZHFsNw69z5Y2BrK2isgRJ8mifEURM,28848
 supermemory/_streaming.py,sha256=MGbosxSTqq0_JG52hvH2Z-Mr_Y95ws5UdFw77_iYukc,10120
 supermemory/_types.py,sha256=ohS8PFDHBFM-0ua6YsUlS55BPHft3xY6DhiIKaYrlN0,6202
-supermemory/_version.py,sha256=ayogEgVcdRtqyjCWUnynAHZSzkPhBycE73D5v8L7dqk,172
+supermemory/_version.py,sha256=sFJWpy_yeVi_Hvg_eoRnRJwR_7U9vkyzR8HWuPNsV44,172
 supermemory/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supermemory/_utils/__init__.py,sha256=PNZ_QJuzZEgyYXqkO1HVhGkj5IU9bglVUcw7H-Knjzw,2062
 supermemory/_utils/_logs.py,sha256=iceljYaEUb4Q4q1SgbSzwSrlJA64ISbaccczzZ8Z9Vg,789
@@ -26,10 +26,10 @@ supermemory/_utils/_utils.py,sha256=ts4CiiuNpFiGB6YMdkQRh2SZvYvsl7mAF-JWHCcLDf4,
 supermemory/lib/.keep,sha256=wuNrz-5SXo3jJaJOJgz4vFHM41YH_g20F5cRQo0vLes,224
 supermemory/resources/__init__.py,sha256=c1dal-ngMY7gwIf9PDPapYx6rHi670pREX5t3_d6298,2019
 supermemory/resources/connections.py,sha256=-DabGIc4_3qFvFRmBOdHGtu4NkaUOaYz3y50CjpqMKQ,33199
-supermemory/resources/memories.py,sha256=7Xg6GptloqKEz_eUxSMJT6nS0Orw_ifYnDtWUG5-r1Y,26453
-supermemory/resources/search.py,sha256=9JIv99mPiAlWCEZ41QxAzN4bteCwyo6UCEL3Our-flo,12546
+supermemory/resources/memories.py,sha256=sG4YD7Vkz6wRUE0cyNu1W0c7DoxZPnfteizV6T5bEWU,30772
+supermemory/resources/search.py,sha256=Lp1SchUinbM9AyvKghz4SCqFEohr5KZTegWMqF4po2I,28497
 supermemory/resources/settings.py,sha256=tLM7ya1CEYI_TO8DMP_KLxXHqsxOeq3R3Xs4CQnvPuU,11855
-supermemory/types/__init__.py,sha256=ufEnLZv6LSfCqlxj6R7HDKYZvbnDQdYMpMBTfY8cj6c,2351
+supermemory/types/__init__.py,sha256=xCyl1ivjR-Viae5zOWa8jmzs24ueiSz3Fw_yIAUjFGk,2875
 supermemory/types/connection_create_params.py,sha256=bYYKu3ns60PX6Mt34UQUpYwThB3SBZsKn5tW0c46DUM,630
 supermemory/types/connection_create_response.py,sha256=i4sb0DSRs7wVVd8xDBOtr7vw-YbaeZ7MydlQLYvlvJs,468
 supermemory/types/connection_delete_by_id_response.py,sha256=guD1vxqV2wiQnwnWCZSQH0z2HYXQOtvicRzouPVkHXA,243
@@ -50,12 +50,18 @@ supermemory/types/memory_list_params.py,sha256=nE4fnYdubdjbGy5-7BxmSms6owZZIbv8P
 supermemory/types/memory_list_response.py,sha256=Lq2ChggQ1YCFQLi2M9u61hxRwGf2ib3p9_X8mywJF78,2620
 supermemory/types/memory_update_params.py,sha256=kyNU53my_W0wVpxgjPMY8IPDi3ccjhqYKkI1OiL6MKQ,1514
 supermemory/types/memory_update_response.py,sha256=fvfO9lGM8xv2EUOQfOSxqig6fx6-ykq7syW69er_2ng,225
+supermemory/types/memory_upload_file_params.py,sha256=jE3IxTOsFiuVQsi8b-ql5Q4ZT5HJG2X1ysL8mHCgdLQ,447
+supermemory/types/memory_upload_file_response.py,sha256=KTq6AExBMz7eMt8az1TgMSSNMTktKk0d0xItCwHRNl0,233
+supermemory/types/search_documents_params.py,sha256=ZugNc4gg8a8O_CqGL_zlHpMpEQRe91ACtTSHwGm0fsw,3134
+supermemory/types/search_documents_response.py,sha256=dCQ1UUOALmfPqnUpX_-_kFbV4eHPFcuT1b7AVtLq5y4,1464
 supermemory/types/search_execute_params.py,sha256=8JRtcQ7G1TmG9JW-f1XwNmvT1llM6FsPx0kkQN1Ellw,3130
 supermemory/types/search_execute_response.py,sha256=U1Fh4JX433A442Di9nnaQq6ts1olDdz3-SSbKzIFBPc,1460
+supermemory/types/search_memories_params.py,sha256=4SI8Z3ji_E_yqKmY5Nl-mL-7xODmRVV3TPsAeVefekU,1860
+supermemory/types/search_memories_response.py,sha256=oXy9qe9Ri-WAUcpU3RzwuHgH-_DAwppyu33Bzfm8BZY,3048
 supermemory/types/setting_get_response.py,sha256=WvgAb9zGMsMnAhLiYk6h5NBptnq0D06TnuoI4EJg5Ds,1648
 supermemory/types/setting_update_params.py,sha256=KsreaS35v25aRKBY5vHna3hZ31U3b1Q5ruQLoM0gcyE,1710
 supermemory/types/setting_update_response.py,sha256=F__RcFFWiiSw11IV8PsWn6POEb1crDwO8QwHEQToVuQ,1806
-supermemory-3.0.0a25.dist-info/METADATA,sha256=S80mW0mqvXO9FiSMoQMyzD8DSFXM6-ZG7yp6txOMVAk,13809
-supermemory-3.0.0a25.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-supermemory-3.0.0a25.dist-info/licenses/LICENSE,sha256=M2NcpYEBpakciOULpWzo-xO2Lincf74gGwfaU00Sct0,11341
-supermemory-3.0.0a25.dist-info/RECORD,,
+supermemory-3.0.0a27.dist-info/METADATA,sha256=nslcHNub7EZOR02lIG2-SdZeBYl7qlEwsoqGCRytTjk,14689
+supermemory-3.0.0a27.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+supermemory-3.0.0a27.dist-info/licenses/LICENSE,sha256=M2NcpYEBpakciOULpWzo-xO2Lincf74gGwfaU00Sct0,11341
+supermemory-3.0.0a27.dist-info/RECORD,,