Add files using upload-large-folder tool

python/user_packages/Python313/site-packages/chromadb-1.5.9.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

python/user_packages/Python313/site-packages/chromadb/api/__init__.py

@@ -0,0 +1,973 @@
+from chromadb.api.types import *  # noqa: F401, F403
+from chromadb.execution.expression import (  # noqa: F401, F403
+    Search,
+    Key,
+    K,
+    SearchWhere,
+    And,
+    Or,
+    Eq,
+    Ne,
+    Gt,
+    Gte,
+    Lt,
+    Lte,
+    In,
+    Nin,
+    Regex,
+    NotRegex,
+    Contains,
+    NotContains,
+    Limit,
+    Select,
+    Rank,
+    Abs,
+    Div,
+    Exp,
+    Log,
+    Max,
+    Min,
+    Mul,
+    Knn,
+    Rrf,
+    Sub,
+    Sum,
+    Val,
+    Aggregate,
+    MinK,
+    MaxK,
+    GroupBy,
+)
+
+from abc import ABC, abstractmethod
+from typing import Sequence, Optional, List, Dict, Any, Tuple
+from uuid import UUID
+
+from overrides import override
+from chromadb.api.collection_configuration import (
+    CreateCollectionConfiguration,
+    UpdateCollectionConfiguration,
+)
+from chromadb.config import DEFAULT_DATABASE, DEFAULT_TENANT
+from chromadb.api.types import (
+    CollectionMetadata,
+    DeleteResult,
+    Documents,
+    Embeddable,
+    EmbeddingFunction,
+    DataLoader,
+    Embeddings,
+    IDs,
+    Include,
+    IncludeMetadataDocumentsDistances,
+    IncludeMetadataDocuments,
+    Loadable,
+    Metadatas,
+    ReadLevel,
+    Schema,
+    URIs,
+    Where,
+    QueryResult,
+    GetResult,
+    WhereDocument,
+    SearchResult,
+    DefaultEmbeddingFunction,
+)
+
+from chromadb.auth import UserIdentity
+from chromadb.config import Component, Settings
+from chromadb.types import Database, Tenant, Collection as CollectionModel
+from chromadb.api.models.Collection import Collection
+from chromadb.api.models.AttachedFunction import AttachedFunction
+
+# Re-export the async version
+from chromadb.api.async_api import (  # noqa: F401
+    AsyncBaseAPI as AsyncBaseAPI,
+    AsyncClientAPI as AsyncClientAPI,
+    AsyncAdminAPI as AsyncAdminAPI,
+    AsyncServerAPI as AsyncServerAPI,
+)
+
+
+class BaseAPI(ABC):
+    @abstractmethod
+    def heartbeat(self) -> int:
+        """Get the current time in nanoseconds since epoch.
+        Used to check if the server is alive.
+
+        Returns:
+            int: The current time in nanoseconds since epoch
+
+        """
+        pass
+
+    #
+    # COLLECTION METHODS
+    #
+    @abstractmethod
+    def count_collections(self) -> int:
+        """Count the number of collections.
+
+        Returns:
+            int: The number of collections.
+
+        Examples:
+            ```python
+            client.count_collections()
+            # 1
+            ```
+        """
+        pass
+
+    def _modify(
+        self,
+        id: UUID,
+        new_name: Optional[str] = None,
+        new_metadata: Optional[CollectionMetadata] = None,
+        new_configuration: Optional[UpdateCollectionConfiguration] = None,
+    ) -> None:
+        """[Internal] Modify a collection by UUID. Can update the name and/or metadata.
+
+        Args:
+            id: The internal UUID of the collection to modify.
+            new_name: The new name of the collection.
+                                If None, the existing name will remain. Defaults to None.
+            new_metadata: The new metadata to associate with the collection.
+                                      Defaults to None.
+            new_configuration: The new configuration to associate with the collection.
+                                      Defaults to None.
+        """
+        pass
+
+    @abstractmethod
+    def delete_collection(
+        self,
+        name: str,
+    ) -> None:
+        """Delete a collection with the given name.
+        Args:
+            name: The name of the collection to delete.
+
+        Raises:
+            ValueError: If the collection does not exist.
+
+        Examples:
+            ```python
+            client.delete_collection("my_collection")
+            ```
+        """
+        pass
+
+    #
+    # ITEM METHODS
+    #
+
+    @abstractmethod
+    def _add(
+        self,
+        ids: IDs,
+        collection_id: UUID,
+        embeddings: Embeddings,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+    ) -> bool:
+        """[Internal] Add embeddings to a collection specified by UUID.
+        If (some) ids already exist, only the new embeddings will be added.
+
+        Args:
+            ids: The ids to associate with the embeddings.
+            collection_id: The UUID of the collection to add the embeddings to.
+            embedding: The sequence of embeddings to add.
+            metadata: The metadata to associate with the embeddings. Defaults to None.
+            documents: The documents to associate with the embeddings. Defaults to None.
+            uris: URIs of data sources for each embedding. Defaults to None.
+
+        Returns:
+            True if the embeddings were added successfully.
+        """
+        pass
+
+    @abstractmethod
+    def _update(
+        self,
+        collection_id: UUID,
+        ids: IDs,
+        embeddings: Optional[Embeddings] = None,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+    ) -> bool:
+        """[Internal] Update entries in a collection specified by UUID.
+
+        Args:
+            collection_id: The UUID of the collection to update the embeddings in.
+            ids: The IDs of the entries to update.
+            embeddings: The sequence of embeddings to update. Defaults to None.
+            metadatas: The metadata to associate with the embeddings. Defaults to None.
+            documents: The documents to associate with the embeddings. Defaults to None.
+            uris: URIs of data sources for each embedding. Defaults to None.
+        Returns:
+            True if the embeddings were updated successfully.
+        """
+        pass
+
+    @abstractmethod
+    def _upsert(
+        self,
+        collection_id: UUID,
+        ids: IDs,
+        embeddings: Embeddings,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+    ) -> bool:
+        """[Internal] Add or update entries in the a collection specified by UUID.
+        If an entry with the same id already exists, it will be updated,
+        otherwise it will be added.
+
+        Args:
+            collection_id: The collection to add the embeddings to
+            ids: The ids to associate with the embeddings. Defaults to None.
+            embeddings: The sequence of embeddings to add
+            metadatas: The metadata to associate with the embeddings. Defaults to None.
+            documents: The documents to associate with the embeddings. Defaults to None.
+            uris: URIs of data sources for each embedding. Defaults to None.
+        """
+        pass
+
+    @abstractmethod
+    def _count(self, collection_id: UUID) -> int:
+        """[Internal] Returns the number of entries in a collection specified by UUID.
+
+        Args:
+            collection_id: The UUID of the collection to count the embeddings in.
+
+        Returns:
+            int: The number of embeddings in the collection
+
+        """
+        pass
+
+    @abstractmethod
+    def _peek(self, collection_id: UUID, n: int = 10) -> GetResult:
+        """[Internal] Returns the first n entries in a collection specified by UUID.
+
+        Args:
+            collection_id: The UUID of the collection to peek into.
+            n: The number of entries to peek. Defaults to 10.
+
+        Returns:
+            GetResult: The first n entries in the collection.
+
+        """
+
+        pass
+
+    @abstractmethod
+    def _get(
+        self,
+        collection_id: UUID,
+        ids: Optional[IDs] = None,
+        where: Optional[Where] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        where_document: Optional[WhereDocument] = None,
+        include: Include = IncludeMetadataDocuments,
+    ) -> GetResult:
+        """[Internal] Returns entries from a collection specified by UUID.
+
+        Args:
+            ids: The IDs of the entries to get. Defaults to None.
+            where: Conditional filtering on metadata. Defaults to None.
+            limit: The maximum number of entries to return. Defaults to None.
+            offset: The number of entries to skip before returning. Defaults to None.
+            where_document: Conditional filtering on documents. Defaults to None.
+            include: The fields to include in the response.
+                          Defaults to ["metadatas", "documents"].
+        Returns:
+            GetResult: The entries in the collection that match the query.
+
+        """
+        pass
+
+    @abstractmethod
+    def _delete(
+        self,
+        collection_id: UUID,
+        ids: Optional[IDs],
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        limit: Optional[int] = None,
+    ) -> DeleteResult:
+        """[Internal] Deletes entries from a collection specified by UUID.
+
+        Args:
+            collection_id: The UUID of the collection to delete the entries from.
+            ids: The IDs of the entries to delete. Defaults to None.
+            where: Conditional filtering on metadata. Defaults to None.
+            where_document: Conditional filtering on documents. Defaults to None.
+            limit: Maximum number of records to delete. Can only be used with
+                where or where_document. Defaults to None (no limit).
+
+        Returns:
+            DeleteResult: A dict containing the number of records deleted.
+        """
+        pass
+
+    @abstractmethod
+    def _query(
+        self,
+        collection_id: UUID,
+        query_embeddings: Embeddings,
+        ids: Optional[IDs] = None,
+        n_results: int = 10,
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        include: Include = IncludeMetadataDocumentsDistances,
+    ) -> QueryResult:
+        """[Internal] Performs a nearest neighbors query on a collection specified by UUID.
+
+        Args:
+            collection_id: The UUID of the collection to query.
+            query_embeddings: The embeddings to use as the query.
+            ids: The IDs to filter by during the query. Defaults to None.
+            n_results: The number of results to return. Defaults to 10.
+            where: Conditional filtering on metadata. Defaults to None.
+            where_document: Conditional filtering on documents. Defaults to None.
+            include: The fields to include in the response.
+                          Defaults to ["metadatas", "documents", "distances"].
+
+        Returns:
+            QueryResult: The results of the query.
+        """
+        pass
+
+    @abstractmethod
+    def reset(self) -> bool:
+        """Resets the database. This will delete all collections and entries.
+
+        Returns:
+            bool: True if the database was reset successfully.
+        """
+        pass
+
+    @abstractmethod
+    def get_version(self) -> str:
+        """Get the version of Chroma.
+
+        Returns:
+            str: The version of Chroma
+
+        """
+        pass
+
+    @abstractmethod
+    def get_settings(self) -> Settings:
+        """Get the settings used to initialize.
+
+        Returns:
+            Settings: The settings used to initialize.
+
+        """
+        pass
+
+    @abstractmethod
+    def get_max_batch_size(self) -> int:
+        """Return the maximum number of records that can be created or mutated in a single call."""
+        pass
+
+    @abstractmethod
+    def get_user_identity(self) -> UserIdentity:
+        """Resolve the tenant and databases for the client. Returns the default
+        values if can't be resolved.
+
+        """
+        pass
+
+
+class ClientAPI(BaseAPI, ABC):
+    tenant: str
+    database: str
+
+    @abstractmethod
+    def list_collections(
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+    ) -> Sequence[Collection]:
+        """List all collections.
+        Args:
+            limit: The maximum number of entries to return. Defaults to None.
+            offset: The number of entries to skip before returning. Defaults to None.
+
+        Returns:
+            Sequence[Collection]: A list of collections
+
+        Examples:
+            ```python
+            client.list_collections()
+            # [collection(name="my_collection", metadata={})]
+            ```
+        """
+        pass
+
+    @abstractmethod
+    def create_collection(
+        self,
+        name: str,
+        schema: Optional[Schema] = None,
+        configuration: Optional[CreateCollectionConfiguration] = None,
+        metadata: Optional[CollectionMetadata] = None,
+        embedding_function: Optional[
+            EmbeddingFunction[Embeddable]
+        ] = DefaultEmbeddingFunction(),  # type: ignore
+        data_loader: Optional[DataLoader[Loadable]] = None,
+        get_or_create: bool = False,
+    ) -> Collection:
+        """Create a new collection with the given name and metadata.
+        Args:
+            name: The name of the collection to create.
+            metadata: Optional metadata to associate with the collection.
+            embedding_function: Optional function to use to embed documents.
+                                Uses the default embedding function if not provided.
+            get_or_create: If True, return the existing collection if it exists.
+            data_loader: Optional function to use to load records (documents, images, etc.)
+
+        Returns:
+            Collection: The newly created collection.
+
+        Raises:
+            ValueError: If the collection already exists and get_or_create is False.
+            ValueError: If the collection name is invalid.
+
+        Examples:
+            ```python
+            client.create_collection("my_collection")
+            # collection(name="my_collection", metadata={})
+
+            client.create_collection("my_collection", metadata={"foo": "bar"})
+            # collection(name="my_collection", metadata={"foo": "bar"})
+            ```
+        """
+        pass
+
+    @abstractmethod
+    def get_collection(
+        self,
+        name: str,
+        embedding_function: Optional[
+            EmbeddingFunction[Embeddable]
+        ] = DefaultEmbeddingFunction(),  # type: ignore
+        data_loader: Optional[DataLoader[Loadable]] = None,
+    ) -> Collection:
+        """Get a collection with the given name.
+        Args:
+            name: The name of the collection to get
+            embedding_function: Optional function to use to embed documents.
+                                Uses the default embedding function if not provided.
+            data_loader: Optional function to use to load records (documents, images, etc.)
+
+        Returns:
+            Collection: The collection
+
+        Raises:
+            ValueError: If the collection does not exist
+
+        Examples:
+            ```python
+            client.get_collection("my_collection")
+            # collection(name="my_collection", metadata={})
+            ```
+        """
+        pass
+
+    @abstractmethod
+    def get_collection_by_id(
+        self,
+        id: UUID,
+        embedding_function: Optional[
+            EmbeddingFunction[Embeddable]
+        ] = DefaultEmbeddingFunction(),  # type: ignore
+        data_loader: Optional[DataLoader[Loadable]] = None,
+    ) -> Collection:
+        """Get a collection by its ID.
+
+        Args:
+            id: The UUID of the collection to get.
+            embedding_function: Optional function to use to embed documents.
+                                Uses the default embedding function if not provided.
+            data_loader: Optional function to use to load records (documents, images, etc.)
+
+        Returns:
+            Collection: The collection
+
+        Raises:
+            NotFoundError: If no collection with the given ID exists.
+
+        Examples:
+            ```python
+            client.get_collection_by_id(uuid.UUID("..."))
+            # collection(name="my_collection", metadata={})
+            ```
+        """
+        pass
+
+    @abstractmethod
+    def get_or_create_collection(
+        self,
+        name: str,
+        schema: Optional[Schema] = None,
+        configuration: Optional[CreateCollectionConfiguration] = None,
+        metadata: Optional[CollectionMetadata] = None,
+        embedding_function: Optional[
+            EmbeddingFunction[Embeddable]
+        ] = DefaultEmbeddingFunction(),  # type: ignore
+        data_loader: Optional[DataLoader[Loadable]] = None,
+    ) -> Collection:
+        """Get or create a collection with the given name and metadata.
+        Args:
+            name: The name of the collection to get or create
+            metadata: Optional metadata to associate with the collection. If
+            the collection already exists, the metadata provided is ignored.
+            If the collection does not exist, the new collection will be created
+            with the provided metadata.
+            embedding_function: Optional function to use to embed documents
+            data_loader: Optional function to use to load records (documents, images, etc.)
+
+        Returns:
+            The collection
+
+        Examples:
+            ```python
+            client.get_or_create_collection("my_collection")
+            # collection(name="my_collection", metadata={})
+            ```
+        """
+        pass
+
+    @abstractmethod
+    def set_tenant(self, tenant: str, database: str = DEFAULT_DATABASE) -> None:
+        """Set the tenant and database for the client. Raises an error if the tenant or
+        database does not exist.
+
+        Args:
+            tenant: The tenant to set.
+            database: The database to set.
+
+        """
+        pass
+
+    @abstractmethod
+    def set_database(self, database: str) -> None:
+        """Set the database for the client. Raises an error if the database does not exist.
+
+        Args:
+            database: The database to set.
+
+        """
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def clear_system_cache() -> None:
+        """Clear the system cache so that new systems can be created for an existing path.
+        This should only be used for testing purposes."""
+        pass
+
+
+class AdminAPI(ABC):
+    @abstractmethod
+    def create_database(self, name: str, tenant: str = DEFAULT_TENANT) -> None:
+        """Create a new database. Raises an error if the database already exists.
+
+        Args:
+            database: The name of the database to create.
+
+        """
+        pass
+
+    @abstractmethod
+    def get_database(self, name: str, tenant: str = DEFAULT_TENANT) -> Database:
+        """Get a database. Raises an error if the database does not exist.
+
+        Args:
+            database: The name of the database to get.
+            tenant: The tenant of the database to get.
+
+        """
+        pass
+
+    @abstractmethod
+    def delete_database(self, name: str, tenant: str = DEFAULT_TENANT) -> None:
+        """Delete a database. Raises an error if the database does not exist.
+
+        Args:
+            database: The name of the database to delete.
+            tenant: The tenant of the database to delete.
+
+        """
+        pass
+
+    @abstractmethod
+    def list_databases(
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        tenant: str = DEFAULT_TENANT,
+    ) -> Sequence[Database]:
+        """List all databases for a tenant. Raises an error if the tenant does not exist.
+
+        Args:
+            tenant: The tenant to list databases for.
+
+        """
+        pass
+
+    @abstractmethod
+    def create_tenant(self, name: str) -> None:
+        """Create a new tenant. Raises an error if the tenant already exists.
+
+        Args:
+            tenant: The name of the tenant to create.
+
+        """
+        pass
+
+    @abstractmethod
+    def get_tenant(self, name: str) -> Tenant:
+        """Get a tenant. Raises an error if the tenant does not exist.
+
+        Args:
+            tenant: The name of the tenant to get.
+
+        """
+        pass
+
+
+class ServerAPI(BaseAPI, AdminAPI, Component):
+    """An API instance that extends the relevant Base API methods by passing
+    in a tenant and database. This is the root component of the Chroma System"""
+
+    @abstractmethod
+    @override
+    def count_collections(
+        self, tenant: str = DEFAULT_TENANT, database: str = DEFAULT_DATABASE
+    ) -> int:
+        pass
+
+    @abstractmethod
+    def list_collections(
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> Sequence[CollectionModel]:
+        pass
+
+    @abstractmethod
+    def create_collection(
+        self,
+        name: str,
+        schema: Optional[Schema] = None,
+        configuration: Optional[CreateCollectionConfiguration] = None,
+        metadata: Optional[CollectionMetadata] = None,
+        get_or_create: bool = False,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        pass
+
+    @abstractmethod
+    def get_collection(
+        self,
+        name: str,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        pass
+
+    @abstractmethod
+    def get_collection_by_id(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        """Get a collection by its ID.
+
+        Args:
+            collection_id: The UUID of the collection to retrieve.
+            tenant: The tenant to search within.
+            database: The database to search within.
+
+        Returns:
+            CollectionModel: The collection with the given ID.
+
+        Raises:
+            NotFoundError: If no collection with the given ID exists.
+        """
+        pass
+
+    @abstractmethod
+    def get_or_create_collection(
+        self,
+        name: str,
+        schema: Optional[Schema] = None,
+        configuration: Optional[CreateCollectionConfiguration] = None,
+        metadata: Optional[CollectionMetadata] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        pass
+
+    @abstractmethod
+    @override
+    def delete_collection(
+        self,
+        name: str,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> None:
+        pass
+
+    @abstractmethod
+    @override
+    def _modify(
+        self,
+        id: UUID,
+        new_name: Optional[str] = None,
+        new_metadata: Optional[CollectionMetadata] = None,
+        new_configuration: Optional[UpdateCollectionConfiguration] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> None:
+        pass
+
+    @abstractmethod
+    def _fork(
+        self,
+        collection_id: UUID,
+        new_name: str,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        pass
+
+    @abstractmethod
+    def _fork_count(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> int:
+        pass
+
+    @abstractmethod
+    def _get_indexing_status(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> "IndexingStatus":
+        pass
+
+    @abstractmethod
+    def _search(
+        self,
+        collection_id: UUID,
+        searches: List[Search],
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+        read_level: ReadLevel = ReadLevel.INDEX_AND_WAL,
+    ) -> SearchResult:
+        pass
+
+    @abstractmethod
+    @override
+    def _count(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+        read_level: ReadLevel = ReadLevel.INDEX_AND_WAL,
+    ) -> int:
+        pass
+
+    @abstractmethod
+    @override
+    def _peek(
+        self,
+        collection_id: UUID,
+        n: int = 10,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> GetResult:
+        pass
+
+    @abstractmethod
+    @override
+    def _get(
+        self,
+        collection_id: UUID,
+        ids: Optional[IDs] = None,
+        where: Optional[Where] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        where_document: Optional[WhereDocument] = None,
+        include: Include = IncludeMetadataDocuments,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> GetResult:
+        pass
+
+    @abstractmethod
+    @override
+    def _add(
+        self,
+        ids: IDs,
+        collection_id: UUID,
+        embeddings: Embeddings,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        pass
+
+    @abstractmethod
+    @override
+    def _update(
+        self,
+        collection_id: UUID,
+        ids: IDs,
+        embeddings: Optional[Embeddings] = None,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        pass
+
+    @abstractmethod
+    @override
+    def _upsert(
+        self,
+        collection_id: UUID,
+        ids: IDs,
+        embeddings: Embeddings,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        pass
+
+    @abstractmethod
+    @override
+    def _query(
+        self,
+        collection_id: UUID,
+        query_embeddings: Embeddings,
+        ids: Optional[IDs] = None,
+        n_results: int = 10,
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        include: Include = IncludeMetadataDocumentsDistances,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> QueryResult:
+        pass
+
+    @abstractmethod
+    @override
+    def _delete(
+        self,
+        collection_id: UUID,
+        ids: Optional[IDs] = None,
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        limit: Optional[int] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> DeleteResult:
+        pass
+
+    @abstractmethod
+    def attach_function(
+        self,
+        function_id: str,
+        name: str,
+        input_collection_id: UUID,
+        output_collection: str,
+        params: Optional[Dict[str, Any]] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> Tuple["AttachedFunction", bool]:
+        """Attach a function to a collection.
+
+        Args:
+            function_id: Built-in function identifier
+            name: Unique name for this attached function
+            input_collection_id: Source collection that triggers the function
+            output_collection: Target collection where function output is stored
+            params: Optional dictionary with function-specific parameters
+            tenant: The tenant name
+            database: The database name
+
+        Returns:
+            Tuple of (AttachedFunction, created) where created is True if newly created,
+            False if already existed (idempotent request)
+        """
+        pass
+
+    @abstractmethod
+    def get_attached_function(
+        self,
+        name: str,
+        input_collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> "AttachedFunction":
+        """Get an attached function by name for a specific collection.
+
+        Args:
+            name: Name of the attached function
+            input_collection_id: The collection ID
+            tenant: The tenant name
+            database: The database name
+
+        Returns:
+            AttachedFunction: The attached function object
+
+        Raises:
+            NotFoundError: If the attached function doesn't exist
+        """
+        pass
+
+    @abstractmethod
+    def detach_function(
+        self,
+        name: str,
+        input_collection_id: UUID,
+        delete_output: bool = False,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        """Detach a function and prevent any further runs.
+
+        Args:
+            name: Name of the attached function to remove
+            input_collection_id: ID of the input collection
+            delete_output: Whether to also delete the output collection
+            tenant: The tenant name
+            database: The database name
+
+        Returns:
+            bool: True if successful
+        """
+        pass

python/user_packages/Python313/site-packages/chromadb/api/async_api.py

@@ -0,0 +1,850 @@
+from abc import ABC, abstractmethod
+from typing import Sequence, Optional, List
+from uuid import UUID
+
+from overrides import override
+from chromadb.api.collection_configuration import (
+    CreateCollectionConfiguration,
+    UpdateCollectionConfiguration,
+)
+from chromadb.auth import UserIdentity
+from chromadb.api.models.AsyncCollection import AsyncCollection
+from chromadb.config import DEFAULT_DATABASE, DEFAULT_TENANT
+from chromadb.api.types import (
+    CollectionMetadata,
+    DeleteResult,
+    Documents,
+    Embeddable,
+    EmbeddingFunction,
+    DataLoader,
+    Embeddings,
+    IDs,
+    Include,
+    IndexingStatus,
+    Loadable,
+    Metadatas,
+    ReadLevel,
+    Schema,
+    URIs,
+    Where,
+    QueryResult,
+    GetResult,
+    WhereDocument,
+    IncludeMetadataDocuments,
+    IncludeMetadataDocumentsDistances,
+    SearchResult,
+    DefaultEmbeddingFunction,
+)
+from chromadb.execution.expression.plan import Search
+from chromadb.config import Component, Settings
+from chromadb.types import Database, Tenant, Collection as CollectionModel
+
+
+class AsyncBaseAPI(ABC):
+    @abstractmethod
+    async def heartbeat(self) -> int:
+        """Get the current time in nanoseconds since epoch.
+        Used to check if the server is alive.
+
+        Returns:
+            int: The current time in nanoseconds since epoch
+
+        """
+        pass
+
+    #
+    # COLLECTION METHODS
+    #
+
+    @abstractmethod
+    async def count_collections(self) -> int:
+        """Count the number of collections.
+
+        Returns:
+            int: The number of collections.
+
+        Examples:
+            ```python
+            await client.count_collections()
+            # 1
+            ```
+        """
+        pass
+
+    @abstractmethod
+    async def _modify(
+        self,
+        id: UUID,
+        new_name: Optional[str] = None,
+        new_metadata: Optional[CollectionMetadata] = None,
+        new_configuration: Optional[UpdateCollectionConfiguration] = None,
+    ) -> None:
+        """[Internal] Modify a collection by UUID. Can update the name and/or metadata.
+
+        Args:
+            id: The internal UUID of the collection to modify.
+            new_name: The new name of the collection.
+                                If None, the existing name will remain. Defaults to None.
+            new_metadata: The new metadata to associate with the collection.
+                                      Defaults to None.
+            new_configuration: The new configuration to associate with the collection.
+                                      Defaults to None.
+        """
+        pass
+
+    @abstractmethod
+    async def delete_collection(
+        self,
+        name: str,
+    ) -> None:
+        """Delete a collection with the given name.
+        Args:
+            name: The name of the collection to delete.
+
+        Raises:
+            ValueError: If the collection does not exist.
+
+        Examples:
+            ```python
+            await client.delete_collection("my_collection")
+            ```
+        """
+        pass
+
+    #
+    # ITEM METHODS
+    #
+
+    @abstractmethod
+    async def _add(
+        self,
+        ids: IDs,
+        collection_id: UUID,
+        embeddings: Embeddings,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+    ) -> bool:
+        """[Internal] Add embeddings to a collection specified by UUID.
+        If (some) ids already exist, only the new embeddings will be added.
+
+        Args:
+            ids: The ids to associate with the embeddings.
+            collection_id: The UUID of the collection to add the embeddings to.
+            embedding: The sequence of embeddings to add.
+            metadata: The metadata to associate with the embeddings. Defaults to None.
+            documents: The documents to associate with the embeddings. Defaults to None.
+            uris: URIs of data sources for each embedding. Defaults to None.
+
+        Returns:
+            True if the embeddings were added successfully.
+        """
+        pass
+
+    @abstractmethod
+    async def _update(
+        self,
+        collection_id: UUID,
+        ids: IDs,
+        embeddings: Optional[Embeddings] = None,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+    ) -> bool:
+        """[Internal] Update entries in a collection specified by UUID.
+
+        Args:
+            collection_id: The UUID of the collection to update the embeddings in.
+            ids: The IDs of the entries to update.
+            embeddings: The sequence of embeddings to update. Defaults to None.
+            metadatas: The metadata to associate with the embeddings. Defaults to None.
+            documents: The documents to associate with the embeddings. Defaults to None.
+            uris: URIs of data sources for each embedding. Defaults to None.
+        Returns:
+            True if the embeddings were updated successfully.
+        """
+        pass
+
+    @abstractmethod
+    async def _upsert(
+        self,
+        collection_id: UUID,
+        ids: IDs,
+        embeddings: Embeddings,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+    ) -> bool:
+        """[Internal] Add or update entries in the a collection specified by UUID.
+        If an entry with the same id already exists, it will be updated,
+        otherwise it will be added.
+
+        Args:
+            collection_id: The collection to add the embeddings to
+            ids: The ids to associate with the embeddings. Defaults to None.
+            embeddings: The sequence of embeddings to add
+            metadatas: The metadata to associate with the embeddings. Defaults to None.
+            documents: The documents to associate with the embeddings. Defaults to None.
+            uris: URIs of data sources for each embedding. Defaults to None.
+        """
+        pass
+
+    @abstractmethod
+    async def _count(self, collection_id: UUID) -> int:
+        """[Internal] Returns the number of entries in a collection specified by UUID.
+
+        Args:
+            collection_id: The UUID of the collection to count the embeddings in.
+
+        Returns:
+            int: The number of embeddings in the collection
+
+        """
+        pass
+
+    @abstractmethod
+    async def _peek(self, collection_id: UUID, n: int = 10) -> GetResult:
+        """[Internal] Returns the first n entries in a collection specified by UUID.
+
+        Args:
+            collection_id: The UUID of the collection to peek into.
+            n: The number of entries to peek. Defaults to 10.
+
+        Returns:
+            GetResult: The first n entries in the collection.
+
+        """
+
+        pass
+
+    @abstractmethod
+    async def _get(
+        self,
+        collection_id: UUID,
+        ids: Optional[IDs] = None,
+        where: Optional[Where] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        where_document: Optional[WhereDocument] = None,
+        include: Include = IncludeMetadataDocuments,
+    ) -> GetResult:
+        """[Internal] Returns entries from a collection specified by UUID.
+
+        Args:
+            ids: The IDs of the entries to get. Defaults to None.
+            where: Conditional filtering on metadata. Defaults to None.
+            limit: The maximum number of entries to return. Defaults to None.
+            offset: The number of entries to skip before returning. Defaults to None.
+            where_document: Conditional filtering on documents. Defaults to None.
+            include: The fields to include in the response.
+                          Defaults to ["embeddings", "metadatas", "documents"].
+        Returns:
+            GetResult: The entries in the collection that match the query.
+
+        """
+        pass
+
+    @abstractmethod
+    async def _delete(
+        self,
+        collection_id: UUID,
+        ids: Optional[IDs],
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        limit: Optional[int] = None,
+    ) -> DeleteResult:
+        """[Internal] Deletes entries from a collection specified by UUID.
+
+        Args:
+            collection_id: The UUID of the collection to delete the entries from.
+            ids: The IDs of the entries to delete. Defaults to None.
+            where: Conditional filtering on metadata. Defaults to None.
+            where_document: Conditional filtering on documents. Defaults to None.
+            limit: Maximum number of records to delete. Can only be used with
+                where or where_document. Defaults to None (no limit).
+
+        Returns:
+            DeleteResult: A dict containing the number of records deleted.
+        """
+        pass
+
+    @abstractmethod
+    async def _query(
+        self,
+        collection_id: UUID,
+        query_embeddings: Embeddings,
+        ids: Optional[IDs] = None,
+        n_results: int = 10,
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        include: Include = IncludeMetadataDocumentsDistances,
+    ) -> QueryResult:
+        """[Internal] Performs a nearest neighbors query on a collection specified by UUID.
+
+        Args:
+            collection_id: The UUID of the collection to query.
+            query_embeddings: The embeddings to use as the query.
+            n_results: The number of results to return. Defaults to 10.
+            where: Conditional filtering on metadata. Defaults to None.
+            where_document: Conditional filtering on documents. Defaults to None.
+            include: The fields to include in the response.
+                          Defaults to ["embeddings", "metadatas", "documents", "distances"].
+
+        Returns:
+            QueryResult: The results of the query.
+        """
+        pass
+
+    @abstractmethod
+    async def reset(self) -> bool:
+        """Resets the database. This will delete all collections and entries.
+
+        Returns:
+            bool: True if the database was reset successfully.
+        """
+        pass
+
+    @abstractmethod
+    async def get_version(self) -> str:
+        """Get the version of Chroma.
+
+        Returns:
+            str: The version of Chroma
+
+        """
+        pass
+
+    @abstractmethod
+    def get_settings(self) -> Settings:
+        """Get the settings used to initialize.
+
+        Returns:
+            Settings: The settings used to initialize.
+
+        """
+        pass
+
+    @abstractmethod
+    async def get_max_batch_size(self) -> int:
+        """Return the maximum number of records that can be created or mutated in a single call."""
+        pass
+
+    @abstractmethod
+    async def get_user_identity(self) -> UserIdentity:
+        """Resolve the tenant and databases for the client. Returns the default
+        values if can't be resolved.
+
+        """
+        pass
+
+
+class AsyncClientAPI(AsyncBaseAPI, ABC):
+    tenant: str
+    database: str
+
+    @abstractmethod
+    async def list_collections(
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+    ) -> Sequence[AsyncCollection]:
+        """List all collections.
+        Args:
+            limit: The maximum number of entries to return. Defaults to None.
+            offset: The number of entries to skip before returning. Defaults to None.
+
+        Returns:
+            Sequence[AsyncCollection]: A list of collections.
+
+        Examples:
+            ```python
+            await client.list_collections()
+            # [collection(name="my_collection", metadata={})]
+            ```
+        """
+        pass
+
+    @abstractmethod
+    async def create_collection(
+        self,
+        name: str,
+        schema: Optional[Schema] = None,
+        configuration: Optional[CreateCollectionConfiguration] = None,
+        metadata: Optional[CollectionMetadata] = None,
+        embedding_function: Optional[
+            EmbeddingFunction[Embeddable]
+        ] = DefaultEmbeddingFunction(),  # type: ignore
+        data_loader: Optional[DataLoader[Loadable]] = None,
+        get_or_create: bool = False,
+    ) -> AsyncCollection:
+        """Create a new collection with the given name and metadata.
+        Args:
+            name: The name of the collection to create.
+            metadata: Optional metadata to associate with the collection.
+            embedding_function: Optional function to use to embed documents.
+                                Uses the default embedding function if not provided.
+            get_or_create: If True, return the existing collection if it exists.
+            data_loader: Optional function to use to load records (documents, images, etc.)
+
+        Returns:
+            Collection: The newly created collection.
+
+        Raises:
+            ValueError: If the collection already exists and get_or_create is False.
+            ValueError: If the collection name is invalid.
+
+        Examples:
+            ```python
+            await client.create_collection("my_collection")
+            # collection(name="my_collection", metadata={})
+
+            await client.create_collection("my_collection", metadata={"foo": "bar"})
+            # collection(name="my_collection", metadata={"foo": "bar"})
+            ```
+        """
+        pass
+
+    @abstractmethod
+    async def get_collection(
+        self,
+        name: str,
+        embedding_function: Optional[
+            EmbeddingFunction[Embeddable]
+        ] = DefaultEmbeddingFunction(),  # type: ignore
+        data_loader: Optional[DataLoader[Loadable]] = None,
+    ) -> AsyncCollection:
+        """Get a collection with the given name.
+        Args:
+            name: The name of the collection to get
+            embedding_function: Optional function to use to embed documents.
+                                Uses the default embedding function if not provided.
+            data_loader: Optional function to use to load records (documents, images, etc.)
+
+        Returns:
+            Collection: The collection
+
+        Raises:
+            ValueError: If the collection does not exist
+
+        Examples:
+            ```python
+            await client.get_collection("my_collection")
+            # collection(name="my_collection", metadata={})
+            ```
+        """
+        pass
+
+    @abstractmethod
+    async def get_collection_by_id(
+        self,
+        id: UUID,
+        embedding_function: Optional[
+            EmbeddingFunction[Embeddable]
+        ] = DefaultEmbeddingFunction(),  # type: ignore
+        data_loader: Optional[DataLoader[Loadable]] = None,
+    ) -> AsyncCollection:
+        """Get a collection by its ID.
+
+        Args:
+            id: The UUID of the collection to get.
+            embedding_function: Optional function to use to embed documents.
+                                Uses the default embedding function if not provided.
+            data_loader: Optional function to use to load records (documents, images, etc.)
+
+        Returns:
+            Collection: The collection
+
+        Raises:
+            NotFoundError: If no collection with the given ID exists.
+
+        Examples:
+            ```python
+            await client.get_collection_by_id(uuid.UUID("..."))
+            # collection(name="my_collection", metadata={})
+            ```
+        """
+        pass
+
+    @abstractmethod
+    async def get_or_create_collection(
+        self,
+        name: str,
+        schema: Optional[Schema] = None,
+        configuration: Optional[CreateCollectionConfiguration] = None,
+        metadata: Optional[CollectionMetadata] = None,
+        embedding_function: Optional[
+            EmbeddingFunction[Embeddable]
+        ] = DefaultEmbeddingFunction(),  # type: ignore
+        data_loader: Optional[DataLoader[Loadable]] = None,
+    ) -> AsyncCollection:
+        """Get or create a collection with the given name and metadata.
+        Args:
+            name: The name of the collection to get or create
+            metadata: Optional metadata to associate with the collection. If
+            the collection already exists, the metadata provided is ignored.
+            If the collection does not exist, the new collection will be created
+            with the provided metadata.
+            embedding_function: Optional function to use to embed documents
+            data_loader: Optional function to use to load records (documents, images, etc.)
+
+        Returns:
+            The collection
+
+        Examples:
+            ```python
+            await client.get_or_create_collection("my_collection")
+            # collection(name="my_collection", metadata={})
+            ```
+        """
+        pass
+
+    @abstractmethod
+    async def set_tenant(self, tenant: str, database: str = DEFAULT_DATABASE) -> None:
+        """Set the tenant and database for the client. Raises an error if the tenant or
+        database does not exist.
+
+        Args:
+            tenant: The tenant to set.
+            database: The database to set.
+
+        """
+        pass
+
+    @abstractmethod
+    async def set_database(self, database: str) -> None:
+        """Set the database for the client. Raises an error if the database does not exist.
+
+        Args:
+            database: The database to set.
+
+        """
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def clear_system_cache() -> None:
+        """Clear the system cache so that new systems can be created for an existing path.
+        This should only be used for testing purposes."""
+        pass
+
+
+class AsyncAdminAPI(ABC):
+    @abstractmethod
+    async def create_database(self, name: str, tenant: str = DEFAULT_TENANT) -> None:
+        """Create a new database. Raises an error if the database already exists.
+
+        Args:
+            database: The name of the database to create.
+
+        """
+        pass
+
+    @abstractmethod
+    async def get_database(self, name: str, tenant: str = DEFAULT_TENANT) -> Database:
+        """Get a database. Raises an error if the database does not exist.
+
+        Args:
+            database: The name of the database to get.
+            tenant: The tenant of the database to get.
+
+        """
+        pass
+
+    @abstractmethod
+    async def delete_database(self, name: str, tenant: str = DEFAULT_TENANT) -> None:
+        """Delete a database. Raises an error if the database does not exist.
+
+        Args:
+            database: The name of the database to delete.
+            tenant: The tenant of the database to delete.
+
+        """
+        pass
+
+    @abstractmethod
+    async def list_databases(
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        tenant: str = DEFAULT_TENANT,
+    ) -> Sequence[Database]:
+        """List all databases for a tenant. Raises an error if the tenant does not exist.
+
+        Args:
+            tenant: The tenant to list databases for.
+
+        """
+        pass
+
+    @abstractmethod
+    async def create_tenant(self, name: str) -> None:
+        """Create a new tenant. Raises an error if the tenant already exists.
+
+        Args:
+            tenant: The name of the tenant to create.
+
+        """
+        pass
+
+    @abstractmethod
+    async def get_tenant(self, name: str) -> Tenant:
+        """Get a tenant. Raises an error if the tenant does not exist.
+
+        Args:
+            tenant: The name of the tenant to get.
+
+        """
+        pass
+
+
+class AsyncServerAPI(AsyncBaseAPI, AsyncAdminAPI, Component):
+    """An API instance that extends the relevant Base API methods by passing
+    in a tenant and database. This is the root component of the Chroma System"""
+
+    @abstractmethod
+    async def list_collections(
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> Sequence[CollectionModel]:
+        pass
+
+    @abstractmethod
+    @override
+    async def count_collections(
+        self, tenant: str = DEFAULT_TENANT, database: str = DEFAULT_DATABASE
+    ) -> int:
+        pass
+
+    @abstractmethod
+    async def create_collection(
+        self,
+        name: str,
+        schema: Optional[Schema] = None,
+        configuration: Optional[CreateCollectionConfiguration] = None,
+        metadata: Optional[CollectionMetadata] = None,
+        get_or_create: bool = False,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        pass
+
+    @abstractmethod
+    async def get_collection(
+        self,
+        name: str,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        pass
+
+    @abstractmethod
+    async def get_collection_by_id(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        """Get a collection by its ID.
+
+        Args:
+            collection_id: The UUID of the collection to retrieve.
+            tenant: The tenant to search within.
+            database: The database to search within.
+
+        Returns:
+            CollectionModel: The collection with the given ID.
+
+        Raises:
+            NotFoundError: If no collection with the given ID exists.
+        """
+        pass
+
+    @abstractmethod
+    async def get_or_create_collection(
+        self,
+        name: str,
+        schema: Optional[Schema] = None,
+        configuration: Optional[CreateCollectionConfiguration] = None,
+        metadata: Optional[CollectionMetadata] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        pass
+
+    @abstractmethod
+    @override
+    async def delete_collection(
+        self,
+        name: str,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> None:
+        pass
+
+    @abstractmethod
+    @override
+    async def _modify(
+        self,
+        id: UUID,
+        new_name: Optional[str] = None,
+        new_metadata: Optional[CollectionMetadata] = None,
+        new_configuration: Optional[UpdateCollectionConfiguration] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> None:
+        pass
+
+    @abstractmethod
+    async def _fork(
+        self,
+        collection_id: UUID,
+        new_name: str,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        pass
+
+    @abstractmethod
+    async def _fork_count(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> int:
+        pass
+
+    @abstractmethod
+    async def _get_indexing_status(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> "IndexingStatus":
+        pass
+
+    @abstractmethod
+    async def _search(
+        self,
+        collection_id: UUID,
+        searches: List[Search],
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+        read_level: ReadLevel = ReadLevel.INDEX_AND_WAL,
+    ) -> SearchResult:
+        pass
+
+    @abstractmethod
+    @override
+    async def _count(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+        read_level: ReadLevel = ReadLevel.INDEX_AND_WAL,
+    ) -> int:
+        pass
+
+    @abstractmethod
+    @override
+    async def _peek(
+        self,
+        collection_id: UUID,
+        n: int = 10,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> GetResult:
+        pass
+
+    @abstractmethod
+    @override
+    async def _get(
+        self,
+        collection_id: UUID,
+        ids: Optional[IDs] = None,
+        where: Optional[Where] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        where_document: Optional[WhereDocument] = None,
+        include: Include = IncludeMetadataDocuments,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> GetResult:
+        pass
+
+    @abstractmethod
+    @override
+    async def _add(
+        self,
+        ids: IDs,
+        collection_id: UUID,
+        embeddings: Embeddings,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        pass
+
+    @abstractmethod
+    @override
+    async def _update(
+        self,
+        collection_id: UUID,
+        ids: IDs,
+        embeddings: Optional[Embeddings] = None,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        pass
+
+    @abstractmethod
+    @override
+    async def _upsert(
+        self,
+        collection_id: UUID,
+        ids: IDs,
+        embeddings: Embeddings,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        pass
+
+    @abstractmethod
+    @override
+    async def _query(
+        self,
+        collection_id: UUID,
+        query_embeddings: Embeddings,
+        ids: Optional[IDs] = None,
+        n_results: int = 10,
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        include: Include = IncludeMetadataDocumentsDistances,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> QueryResult:
+        pass
+
+    @abstractmethod
+    @override
+    async def _delete(
+        self,
+        collection_id: UUID,
+        ids: Optional[IDs] = None,
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        limit: Optional[int] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> DeleteResult:
+        pass

python/user_packages/Python313/site-packages/chromadb/api/async_client.py

@@ -0,0 +1,569 @@
+import httpx
+from typing import Optional, Sequence
+from uuid import UUID
+from overrides import override
+
+from chromadb.auth import UserIdentity
+from chromadb.auth.utils import maybe_set_tenant_and_database
+from chromadb.api import AsyncAdminAPI, AsyncClientAPI, AsyncServerAPI
+from chromadb.api.collection_configuration import (
+    CreateCollectionConfiguration,
+    UpdateCollectionConfiguration,
+    validate_embedding_function_conflict_on_create,
+    validate_embedding_function_conflict_on_get,
+)
+from chromadb.api.models.AsyncCollection import AsyncCollection
+from chromadb.api.shared_system_client import SharedSystemClient
+from chromadb.api.types import (
+    CollectionMetadata,
+    DataLoader,
+    Documents,
+    Embeddable,
+    EmbeddingFunction,
+    Embeddings,
+    GetResult,
+    IDs,
+    Include,
+    IncludeMetadataDocuments,
+    IncludeMetadataDocumentsDistances,
+    Loadable,
+    Metadatas,
+    QueryResult,
+    Schema,
+    URIs,
+    DefaultEmbeddingFunction,
+    DeleteResult,
+)
+from chromadb.config import DEFAULT_DATABASE, DEFAULT_TENANT, Settings, System
+from chromadb.errors import ChromaError
+from chromadb.types import Database, Tenant, Where, WhereDocument
+
+
+class AsyncClient(SharedSystemClient, AsyncClientAPI):
+    """A client for Chroma. This is the main entrypoint for interacting with Chroma.
+    A client internally stores its tenant and database and proxies calls to a
+    Server API instance of Chroma. It treats the Server API and corresponding System
+    as a singleton, so multiple clients connecting to the same resource will share the
+    same API instance.
+
+    Client implementations should be implement their own API-caching strategies.
+    """
+
+    # An internal admin client for verifying that databases and tenants exist
+    _admin_client: AsyncAdminAPI
+
+    tenant: str = DEFAULT_TENANT
+    database: str = DEFAULT_DATABASE
+
+    _server: AsyncServerAPI
+
+    @classmethod
+    async def create(
+        cls,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+        settings: Settings = Settings(),
+    ) -> "AsyncClient":
+        # Create an admin client for verifying that databases and tenants exist
+        self = cls(settings=settings)
+        SharedSystemClient._populate_data_from_system(self._system)
+
+        self.tenant = tenant
+        self.database = database
+
+        # Get the root system component we want to interact with
+        self._server = self._system.instance(AsyncServerAPI)
+
+        user_identity = await self.get_user_identity()
+
+        maybe_tenant, maybe_database = maybe_set_tenant_and_database(
+            user_identity,
+            overwrite_singleton_tenant_database_access_from_auth=settings.chroma_overwrite_singleton_tenant_database_access_from_auth,
+            user_provided_tenant=tenant,
+            user_provided_database=database,
+        )
+        if maybe_tenant:
+            self.tenant = maybe_tenant
+        if maybe_database:
+            self.database = maybe_database
+
+        self._admin_client = AsyncAdminClient.from_system(self._system)
+        await self._validate_tenant_database(tenant=self.tenant, database=self.database)
+
+        self._submit_client_start_event()
+
+        return self
+
+    @classmethod
+    # (we can't override and use from_system() because it's synchronous)
+    async def from_system_async(
+        cls,
+        system: System,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> "AsyncClient":
+        """Create a client from an existing system. This is useful for testing and debugging."""
+        return await AsyncClient.create(tenant, database, system.settings)
+
+    @classmethod
+    @override
+    def from_system(
+        cls,
+        system: System,
+    ) -> "SharedSystemClient":
+        """AsyncClient cannot be created synchronously. Use .from_system_async() instead."""
+        raise NotImplementedError(
+            "AsyncClient cannot be created synchronously. Use .from_system_async() instead."
+        )
+
+    @override
+    async def get_user_identity(self) -> UserIdentity:
+        return await self._server.get_user_identity()
+
+    @override
+    async def set_tenant(self, tenant: str, database: str = DEFAULT_DATABASE) -> None:
+        await self._validate_tenant_database(tenant=tenant, database=database)
+        self.tenant = tenant
+        self.database = database
+
+    @override
+    async def set_database(self, database: str) -> None:
+        await self._validate_tenant_database(tenant=self.tenant, database=database)
+        self.database = database
+
+    async def _validate_tenant_database(self, tenant: str, database: str) -> None:
+        try:
+            await self._admin_client.get_tenant(name=tenant)
+        except httpx.ConnectError:
+            raise ValueError(
+                "Could not connect to a Chroma server. Are you sure it is running?"
+            )
+        # Propagate ChromaErrors
+        except ChromaError as e:
+            raise e
+        except Exception:
+            raise ValueError(
+                f"Could not connect to tenant {tenant}. Are you sure it exists?"
+            )
+
+        try:
+            await self._admin_client.get_database(name=database, tenant=tenant)
+        except httpx.ConnectError:
+            raise ValueError(
+                "Could not connect to a Chroma server. Are you sure it is running?"
+            )
+
+    # region BaseAPI Methods
+    # Note - we could do this in less verbose ways, but they break type checking
+    @override
+    async def heartbeat(self) -> int:
+        return await self._server.heartbeat()
+
+    @override
+    async def list_collections(
+        self, limit: Optional[int] = None, offset: Optional[int] = None
+    ) -> Sequence[AsyncCollection]:
+        models = await self._server.list_collections(
+            limit, offset, tenant=self.tenant, database=self.database
+        )
+        return [AsyncCollection(client=self._server, model=model) for model in models]
+
+    @override
+    async def count_collections(self) -> int:
+        return await self._server.count_collections(
+            tenant=self.tenant, database=self.database
+        )
+
+    @override
+    async def create_collection(
+        self,
+        name: str,
+        schema: Optional[Schema] = None,
+        configuration: Optional[CreateCollectionConfiguration] = None,
+        metadata: Optional[CollectionMetadata] = None,
+        embedding_function: Optional[
+            EmbeddingFunction[Embeddable]
+        ] = DefaultEmbeddingFunction(),  # type: ignore
+        data_loader: Optional[DataLoader[Loadable]] = None,
+        get_or_create: bool = False,
+    ) -> AsyncCollection:
+        if configuration is None:
+            configuration = {}
+
+        configuration_ef = configuration.get("embedding_function")
+
+        validate_embedding_function_conflict_on_create(
+            embedding_function, configuration_ef
+        )
+
+        # If ef provided in function params and collection config ef is None,
+        # set the collection config ef to the function params
+        if embedding_function is not None and configuration_ef is None:
+            configuration["embedding_function"] = embedding_function
+
+        model = await self._server.create_collection(
+            name=name,
+            schema=schema,
+            configuration=configuration,
+            metadata=metadata,
+            tenant=self.tenant,
+            database=self.database,
+            get_or_create=get_or_create,
+        )
+        return AsyncCollection(
+            client=self._server,
+            model=model,
+            embedding_function=embedding_function,
+            data_loader=data_loader,
+        )
+
+    @override
+    async def get_collection(
+        self,
+        name: str,
+        embedding_function: Optional[
+            EmbeddingFunction[Embeddable]
+        ] = DefaultEmbeddingFunction(),  # type: ignore
+        data_loader: Optional[DataLoader[Loadable]] = None,
+    ) -> AsyncCollection:
+        model = await self._server.get_collection(
+            name=name,
+            tenant=self.tenant,
+            database=self.database,
+        )
+        persisted_ef_config = model.configuration_json.get("embedding_function")
+
+        validate_embedding_function_conflict_on_get(
+            embedding_function, persisted_ef_config
+        )
+
+        return AsyncCollection(
+            client=self._server,
+            model=model,
+            embedding_function=embedding_function,
+            data_loader=data_loader,
+        )
+
+    @override
+    async def get_collection_by_id(
+        self,
+        id: UUID,
+        embedding_function: Optional[
+            EmbeddingFunction[Embeddable]
+        ] = DefaultEmbeddingFunction(),  # type: ignore
+        data_loader: Optional[DataLoader[Loadable]] = None,
+    ) -> AsyncCollection:
+        """Get a collection by its ID.
+
+        Args:
+            id: The UUID of the collection.
+            embedding_function: Optional embedding function for the collection.
+            data_loader: Optional data loader for documents with URIs.
+
+        Returns:
+            AsyncCollection: The requested collection.
+
+        Raises:
+            ValueError: If the embedding function conflicts with configuration.
+        """
+        model = await self._server.get_collection_by_id(
+            collection_id=id,
+            tenant=self.tenant,
+            database=self.database,
+        )
+        persisted_ef_config = model.configuration_json.get("embedding_function")
+
+        validate_embedding_function_conflict_on_get(
+            embedding_function, persisted_ef_config
+        )
+
+        return AsyncCollection(
+            client=self._server,
+            model=model,
+            embedding_function=embedding_function,
+            data_loader=data_loader,
+        )
+
+    @override
+    async def get_or_create_collection(
+        self,
+        name: str,
+        schema: Optional[Schema] = None,
+        configuration: Optional[CreateCollectionConfiguration] = None,
+        metadata: Optional[CollectionMetadata] = None,
+        embedding_function: Optional[
+            EmbeddingFunction[Embeddable]
+        ] = DefaultEmbeddingFunction(),  # type: ignore
+        data_loader: Optional[DataLoader[Loadable]] = None,
+    ) -> AsyncCollection:
+        if configuration is None:
+            configuration = {}
+
+        configuration_ef = configuration.get("embedding_function")
+
+        validate_embedding_function_conflict_on_create(
+            embedding_function, configuration_ef
+        )
+
+        if embedding_function is not None and configuration_ef is None:
+            configuration["embedding_function"] = embedding_function
+        model = await self._server.get_or_create_collection(
+            name=name,
+            schema=schema,
+            configuration=configuration,
+            metadata=metadata,
+            tenant=self.tenant,
+            database=self.database,
+        )
+
+        persisted_ef_config = model.configuration_json.get("embedding_function")
+
+        validate_embedding_function_conflict_on_get(
+            embedding_function, persisted_ef_config
+        )
+
+        return AsyncCollection(
+            client=self._server,
+            model=model,
+            embedding_function=embedding_function,
+            data_loader=data_loader,
+        )
+
+    @override
+    async def _modify(
+        self,
+        id: UUID,
+        new_name: Optional[str] = None,
+        new_metadata: Optional[CollectionMetadata] = None,
+        new_configuration: Optional[UpdateCollectionConfiguration] = None,
+    ) -> None:
+        return await self._server._modify(
+            id=id,
+            new_name=new_name,
+            new_metadata=new_metadata,
+            new_configuration=new_configuration,
+            tenant=self.tenant,
+            database=self.database,
+        )
+
+    @override
+    async def delete_collection(
+        self,
+        name: str,
+    ) -> None:
+        return await self._server.delete_collection(
+            name=name,
+            tenant=self.tenant,
+            database=self.database,
+        )
+
+    #
+    # ITEM METHODS
+    #
+
+    @override
+    async def _add(
+        self,
+        ids: IDs,
+        collection_id: UUID,
+        embeddings: Embeddings,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+    ) -> bool:
+        return await self._server._add(
+            ids=ids,
+            collection_id=collection_id,
+            embeddings=embeddings,
+            metadatas=metadatas,
+            documents=documents,
+            uris=uris,
+            tenant=self.tenant,
+            database=self.database,
+        )
+
+    @override
+    async def _update(
+        self,
+        collection_id: UUID,
+        ids: IDs,
+        embeddings: Optional[Embeddings] = None,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+    ) -> bool:
+        return await self._server._update(
+            collection_id=collection_id,
+            ids=ids,
+            embeddings=embeddings,
+            metadatas=metadatas,
+            documents=documents,
+            uris=uris,
+            tenant=self.tenant,
+            database=self.database,
+        )
+
+    @override
+    async def _upsert(
+        self,
+        collection_id: UUID,
+        ids: IDs,
+        embeddings: Embeddings,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+    ) -> bool:
+        return await self._server._upsert(
+            collection_id=collection_id,
+            ids=ids,
+            embeddings=embeddings,
+            metadatas=metadatas,
+            documents=documents,
+            uris=uris,
+            tenant=self.tenant,
+            database=self.database,
+        )
+
+    @override
+    async def _count(self, collection_id: UUID) -> int:
+        return await self._server._count(
+            collection_id=collection_id,
+        )
+
+    @override
+    async def _peek(self, collection_id: UUID, n: int = 10) -> GetResult:
+        return await self._server._peek(
+            collection_id=collection_id,
+            n=n,
+        )
+
+    @override
+    async def _get(
+        self,
+        collection_id: UUID,
+        ids: Optional[IDs] = None,
+        where: Optional[Where] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        where_document: Optional[WhereDocument] = None,
+        include: Include = IncludeMetadataDocuments,
+    ) -> GetResult:
+        return await self._server._get(
+            collection_id=collection_id,
+            ids=ids,
+            where=where,
+            limit=limit,
+            offset=offset,
+            where_document=where_document,
+            include=include,
+            tenant=self.tenant,
+            database=self.database,
+        )
+
+    async def _delete(
+        self,
+        collection_id: UUID,
+        ids: Optional[IDs],
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        limit: Optional[int] = None,
+    ) -> DeleteResult:
+        return await self._server._delete(
+            collection_id=collection_id,
+            ids=ids,
+            where=where,
+            where_document=where_document,
+            limit=limit,
+            tenant=self.tenant,
+            database=self.database,
+        )
+
+    @override
+    async def _query(
+        self,
+        collection_id: UUID,
+        query_embeddings: Embeddings,
+        ids: Optional[IDs] = None,
+        n_results: int = 10,
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        include: Include = IncludeMetadataDocumentsDistances,
+    ) -> QueryResult:
+        return await self._server._query(
+            collection_id=collection_id,
+            query_embeddings=query_embeddings,
+            ids=ids,
+            n_results=n_results,
+            where=where,
+            where_document=where_document,
+            include=include,
+            tenant=self.tenant,
+            database=self.database,
+        )
+
+    @override
+    async def reset(self) -> bool:
+        return await self._server.reset()
+
+    @override
+    async def get_version(self) -> str:
+        return await self._server.get_version()
+
+    @override
+    def get_settings(self) -> Settings:
+        return self._server.get_settings()
+
+    @override
+    async def get_max_batch_size(self) -> int:
+        return await self._server.get_max_batch_size()
+
+    # endregion
+
+
+class AsyncAdminClient(SharedSystemClient, AsyncAdminAPI):
+    _server: AsyncServerAPI
+
+    def __init__(self, settings: Settings = Settings()) -> None:
+        super().__init__(settings)
+        self._server = self._system.instance(AsyncServerAPI)
+
+    @override
+    async def create_database(self, name: str, tenant: str = DEFAULT_TENANT) -> None:
+        return await self._server.create_database(name=name, tenant=tenant)
+
+    @override
+    async def get_database(self, name: str, tenant: str = DEFAULT_TENANT) -> Database:
+        return await self._server.get_database(name=name, tenant=tenant)
+
+    @override
+    async def delete_database(self, name: str, tenant: str = DEFAULT_TENANT) -> None:
+        return await self._server.delete_database(name=name, tenant=tenant)
+
+    @override
+    async def list_databases(
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        tenant: str = DEFAULT_TENANT,
+    ) -> Sequence[Database]:
+        return await self._server.list_databases(
+            limit=limit, offset=offset, tenant=tenant
+        )
+
+    @override
+    async def create_tenant(self, name: str) -> None:
+        return await self._server.create_tenant(name=name)
+
+    @override
+    async def get_tenant(self, name: str) -> Tenant:
+        return await self._server.get_tenant(name=name)
+
+    @classmethod
+    @override
+    def from_system(
+        cls,
+        system: System,
+    ) -> "AsyncAdminClient":
+        SharedSystemClient._populate_data_from_system(system)
+        instance = cls(settings=system.settings)
+        return instance

python/user_packages/Python313/site-packages/chromadb/api/async_fastapi.py

@@ -0,0 +1,848 @@
+import asyncio
+from uuid import UUID
+import urllib.parse
+import orjson
+from typing import Any, Mapping, Optional, cast, Tuple, Sequence, Dict, List
+import logging
+import httpx
+from overrides import override
+from chromadb import __version__
+from chromadb.auth import UserIdentity
+from chromadb.api.async_api import AsyncServerAPI
+from chromadb.api.base_http_client import BaseHTTPClient
+from chromadb.api.collection_configuration import (
+    CreateCollectionConfiguration,
+    UpdateCollectionConfiguration,
+    create_collection_configuration_to_json,
+    update_collection_configuration_to_json,
+)
+from chromadb.config import DEFAULT_DATABASE, DEFAULT_TENANT, System, Settings
+from chromadb.telemetry.opentelemetry import (
+    OpenTelemetryClient,
+    OpenTelemetryGranularity,
+    trace_method,
+)
+from chromadb.telemetry.product import ProductTelemetryClient
+from chromadb.utils.async_to_sync import async_to_sync
+from chromadb.types import Database, Tenant, Collection as CollectionModel
+from chromadb.execution.expression.plan import Search
+
+from chromadb.api.types import (
+    DeleteResult,
+    Documents,
+    Embeddings,
+    IDs,
+    Include,
+    IndexingStatus,
+    Schema,
+    Metadatas,
+    ReadLevel,
+    URIs,
+    Where,
+    WhereDocument,
+    GetResult,
+    QueryResult,
+    SearchResult,
+    CollectionMetadata,
+    optional_embeddings_to_base64_strings,
+    validate_batch,
+    convert_np_embeddings_to_list,
+    IncludeMetadataDocuments,
+    IncludeMetadataDocumentsDistances,
+)
+
+from chromadb.api.types import (
+    IncludeMetadataDocumentsEmbeddings,
+    serialize_metadata,
+    deserialize_metadata,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+class AsyncFastAPI(BaseHTTPClient, AsyncServerAPI):
+    # We make one client per event loop to avoid unexpected issues if a client
+    # is shared between event loops.
+    # For example, if a client is constructed in the main thread, then passed
+    # (or a returned Collection is passed) to a new thread, the client would
+    # normally throw an obscure asyncio error.
+    # Mixing asyncio and threading in this manner usually discouraged, but
+    # this gives a better user experience with practically no downsides.
+    # https://github.com/encode/httpx/issues/2058
+    _clients: Dict[int, httpx.AsyncClient] = {}
+
+    def __init__(self, system: System):
+        super().__init__(system)
+
+        system.settings.require("chroma_server_host")
+        system.settings.require("chroma_server_http_port")
+
+        self._opentelemetry_client = self.require(OpenTelemetryClient)
+        self._product_telemetry_client = self.require(ProductTelemetryClient)
+        self._settings = system.settings
+
+        self._api_url = AsyncFastAPI.resolve_url(
+            chroma_server_host=str(system.settings.chroma_server_host),
+            chroma_server_http_port=system.settings.chroma_server_http_port,
+            chroma_server_ssl_enabled=system.settings.chroma_server_ssl_enabled,
+            default_api_path=system.settings.chroma_server_api_default_path,
+        )
+
+    async def __aenter__(self) -> "AsyncFastAPI":
+        self._get_client()
+        return self
+
+    async def _cleanup(self) -> None:
+        while len(self._clients) > 0:
+            (_, client) = self._clients.popitem()
+            await client.aclose()
+
+    async def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
+        await self._cleanup()
+
+    @override
+    def stop(self) -> None:
+        super().stop()
+
+        @async_to_sync
+        async def sync_cleanup() -> None:
+            await self._cleanup()
+
+        sync_cleanup()
+
+    def _get_client(self) -> httpx.AsyncClient:
+        # Ideally this would use anyio to be compatible with both
+        # asyncio and trio, but anyio does not expose any way to identify
+        # the current event loop.
+        # We attempt to get the loop assuming the environment is asyncio, and
+        # otherwise gracefully fall back to using a singleton client.
+        loop_hash = None
+        try:
+            loop = asyncio.get_event_loop()
+            loop_hash = loop.__hash__()
+        except RuntimeError:
+            loop_hash = 0
+
+        if loop_hash not in self._clients:
+            headers = (self._settings.chroma_server_headers or {}).copy()
+            headers["Content-Type"] = "application/json"
+            headers["User-Agent"] = (
+                "Chroma Python Client v"
+                + __version__
+                + " (https://github.com/chroma-core/chroma)"
+            )
+
+            self._clients[loop_hash] = httpx.AsyncClient(
+                timeout=None,
+                headers=headers,
+                verify=self._settings.chroma_server_ssl_verify or False,
+                limits=self.http_limits,
+            )
+
+        return self._clients[loop_hash]
+
+    @override
+    def get_request_headers(self) -> Mapping[str, str]:
+        return dict(self._get_client().headers)
+
+    @override
+    def get_api_url(self) -> str:
+        return self._api_url
+
+    async def _make_request(
+        self, method: str, path: str, **kwargs: Dict[str, Any]
+    ) -> Any:
+        # If the request has json in kwargs, use orjson to serialize it,
+        # remove it from kwargs, and add it to the content parameter
+        # This is because httpx uses a slower json serializer
+        if "json" in kwargs:
+            data = orjson.dumps(kwargs.pop("json"), option=orjson.OPT_SERIALIZE_NUMPY)
+            kwargs["content"] = data
+
+        # Unlike requests, httpx does not automatically escape the path
+        escaped_path = urllib.parse.quote(path, safe="/", encoding=None, errors=None)
+        url = self._api_url + escaped_path
+
+        response = await self._get_client().request(method, url, **cast(Any, kwargs))
+        BaseHTTPClient._raise_chroma_error(response)
+        return orjson.loads(response.text)
+
+    @trace_method("AsyncFastAPI.heartbeat", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def heartbeat(self) -> int:
+        response = await self._make_request("get", "")
+        return int(response["nanosecond heartbeat"])
+
+    @trace_method("AsyncFastAPI.create_database", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def create_database(
+        self,
+        name: str,
+        tenant: str = DEFAULT_TENANT,
+    ) -> None:
+        await self._make_request(
+            "post",
+            f"/tenants/{tenant}/databases",
+            json={"name": name},
+        )
+
+    @trace_method("AsyncFastAPI.get_database", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def get_database(
+        self,
+        name: str,
+        tenant: str = DEFAULT_TENANT,
+    ) -> Database:
+        response = await self._make_request(
+            "get",
+            f"/tenants/{tenant}/databases/{name}",
+            params={"tenant": tenant},
+        )
+
+        return Database(
+            id=response["id"], name=response["name"], tenant=response["tenant"]
+        )
+
+    @trace_method("AsyncFastAPI.delete_database", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def delete_database(
+        self,
+        name: str,
+        tenant: str = DEFAULT_TENANT,
+    ) -> None:
+        await self._make_request(
+            "delete",
+            f"/tenants/{tenant}/databases/{name}",
+        )
+
+    @trace_method("AsyncFastAPI.list_databases", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def list_databases(
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        tenant: str = DEFAULT_TENANT,
+    ) -> Sequence[Database]:
+        response = await self._make_request(
+            "get",
+            f"/tenants/{tenant}/databases",
+            params=BaseHTTPClient._clean_params(
+                {
+                    "limit": limit,
+                    "offset": offset,
+                }
+            ),
+        )
+
+        return [
+            Database(id=db["id"], name=db["name"], tenant=db["tenant"])
+            for db in response
+        ]
+
+    @trace_method("AsyncFastAPI.create_tenant", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def create_tenant(self, name: str) -> None:
+        await self._make_request(
+            "post",
+            "/tenants",
+            json={"name": name},
+        )
+
+    @trace_method("AsyncFastAPI.get_tenant", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def get_tenant(self, name: str) -> Tenant:
+        resp_json = await self._make_request(
+            "get",
+            "/tenants/" + name,
+        )
+
+        return Tenant(name=resp_json["name"])
+
+    @trace_method("AsyncFastAPI.get_user_identity", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def get_user_identity(self) -> UserIdentity:
+        return UserIdentity(**(await self._make_request("get", "/auth/identity")))
+
+    @trace_method("AsyncFastAPI.list_collections", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def list_collections(
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> Sequence[CollectionModel]:
+        resp_json = await self._make_request(
+            "get",
+            f"/tenants/{tenant}/databases/{database}/collections",
+            params=BaseHTTPClient._clean_params(
+                {
+                    "limit": limit,
+                    "offset": offset,
+                }
+            ),
+        )
+
+        models = [
+            CollectionModel.from_json(json_collection) for json_collection in resp_json
+        ]
+        return models
+
+    @trace_method("AsyncFastAPI.count_collections", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def count_collections(
+        self, tenant: str = DEFAULT_TENANT, database: str = DEFAULT_DATABASE
+    ) -> int:
+        resp_json = await self._make_request(
+            "get",
+            f"/tenants/{tenant}/databases/{database}/collections_count",
+        )
+
+        return cast(int, resp_json)
+
+    @trace_method("AsyncFastAPI.create_collection", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def create_collection(
+        self,
+        name: str,
+        schema: Optional[Schema] = None,
+        configuration: Optional[CreateCollectionConfiguration] = None,
+        metadata: Optional[CollectionMetadata] = None,
+        get_or_create: bool = False,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        """Creates a collection"""
+        config_json = (
+            create_collection_configuration_to_json(configuration, metadata)
+            if configuration
+            else None
+        )
+        serialized_schema = schema.serialize_to_json() if schema else None
+        resp_json = await self._make_request(
+            "post",
+            f"/tenants/{tenant}/databases/{database}/collections",
+            json={
+                "name": name,
+                "metadata": metadata,
+                "configuration": config_json,
+                "schema": serialized_schema,
+                "get_or_create": get_or_create,
+            },
+        )
+        model = CollectionModel.from_json(resp_json)
+
+        return model
+
+    @trace_method("AsyncFastAPI.get_collection", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def get_collection(
+        self,
+        name: str,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        resp_json = await self._make_request(
+            "get",
+            f"/tenants/{tenant}/databases/{database}/collections/{name}",
+        )
+
+        model = CollectionModel.from_json(resp_json)
+
+        return model
+
+    @trace_method(
+        "AsyncFastAPI.get_collection_by_id", OpenTelemetryGranularity.OPERATION
+    )
+    @override
+    async def get_collection_by_id(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        """Returns a collection by its ID"""
+        resp_json = await self._make_request(
+            "get",
+            f"/tenants/{tenant}/databases/{database}/collections/by-id/{collection_id}",
+        )
+
+        model = CollectionModel.from_json(resp_json)
+
+        return model
+
+    @trace_method(
+        "AsyncFastAPI.get_or_create_collection", OpenTelemetryGranularity.OPERATION
+    )
+    @override
+    async def get_or_create_collection(
+        self,
+        name: str,
+        schema: Optional[Schema] = None,
+        configuration: Optional[CreateCollectionConfiguration] = None,
+        metadata: Optional[CollectionMetadata] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        return await self.create_collection(
+            name=name,
+            schema=schema,
+            configuration=configuration,
+            metadata=metadata,
+            get_or_create=True,
+            tenant=tenant,
+            database=database,
+        )
+
+    @trace_method("AsyncFastAPI._modify", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def _modify(
+        self,
+        id: UUID,
+        new_name: Optional[str] = None,
+        new_metadata: Optional[CollectionMetadata] = None,
+        new_configuration: Optional[UpdateCollectionConfiguration] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> None:
+        await self._make_request(
+            "put",
+            f"/tenants/{tenant}/databases/{database}/collections/{id}",
+            json={
+                "new_metadata": new_metadata,
+                "new_name": new_name,
+                "new_configuration": update_collection_configuration_to_json(
+                    new_configuration
+                )
+                if new_configuration
+                else None,
+            },
+        )
+
+    @trace_method("AsyncFastAPI._fork", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def _fork(
+        self,
+        collection_id: UUID,
+        new_name: str,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        resp_json = await self._make_request(
+            "post",
+            f"/tenants/{tenant}/databases/{database}/collections/{collection_id}/fork",
+            json={"new_name": new_name},
+        )
+        model = CollectionModel.from_json(resp_json)
+        return model
+
+    @trace_method("AsyncFastAPI._fork_count", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def _fork_count(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> int:
+        resp_json = await self._make_request(
+            "get",
+            f"/tenants/{tenant}/databases/{database}/collections/{collection_id}/fork_count",
+        )
+        return int(resp_json["count"])
+
+    @trace_method(
+        "AsyncFastAPI._get_indexing_status", OpenTelemetryGranularity.OPERATION
+    )
+    @override
+    async def _get_indexing_status(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> IndexingStatus:
+        resp_json = await self._make_request(
+            "get",
+            f"/tenants/{tenant}/databases/{database}/collections/{collection_id}/indexing_status",
+        )
+        return IndexingStatus(
+            num_indexed_ops=resp_json["num_indexed_ops"],
+            num_unindexed_ops=resp_json["num_unindexed_ops"],
+            total_ops=resp_json["total_ops"],
+            op_indexing_progress=resp_json["op_indexing_progress"],
+        )
+
+    @trace_method("AsyncFastAPI._search", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def _search(
+        self,
+        collection_id: UUID,
+        searches: List[Search],
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+        read_level: ReadLevel = ReadLevel.INDEX_AND_WAL,
+    ) -> SearchResult:
+        """Performs hybrid search on a collection"""
+        payload = {
+            "searches": [s.to_dict() for s in searches],
+            "read_level": read_level,
+        }
+
+        resp_json = await self._make_request(
+            "post",
+            f"/tenants/{tenant}/databases/{database}/collections/{collection_id}/search",
+            json=payload,
+        )
+
+        metadata_batches = resp_json.get("metadatas", None)
+        if metadata_batches is not None:
+            resp_json["metadatas"] = [
+                [
+                    deserialize_metadata(metadata) if metadata is not None else None
+                    for metadata in metadatas
+                ]
+                if metadatas is not None
+                else None
+                for metadatas in metadata_batches
+            ]
+
+        return SearchResult(resp_json)
+
+    @trace_method("AsyncFastAPI.delete_collection", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def delete_collection(
+        self,
+        name: str,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> None:
+        await self._make_request(
+            "delete",
+            f"/tenants/{tenant}/databases/{database}/collections/{name}",
+        )
+
+    @trace_method("AsyncFastAPI._count", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def _count(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+        read_level: ReadLevel = ReadLevel.INDEX_AND_WAL,
+    ) -> int:
+        """Returns the number of embeddings in the database"""
+        resp_json = await self._make_request(
+            "get",
+            f"/tenants/{tenant}/databases/{database}/collections/{collection_id}/count",
+            params={"read_level": read_level.value},
+        )
+
+        return cast(int, resp_json)
+
+    @trace_method("AsyncFastAPI._peek", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def _peek(
+        self,
+        collection_id: UUID,
+        n: int = 10,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> GetResult:
+        resp = await self._get(
+            collection_id,
+            tenant=tenant,
+            database=database,
+            limit=n,
+            include=IncludeMetadataDocumentsEmbeddings,
+        )
+
+        return resp
+
+    @trace_method("AsyncFastAPI._get", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def _get(
+        self,
+        collection_id: UUID,
+        ids: Optional[IDs] = None,
+        where: Optional[Where] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        where_document: Optional[WhereDocument] = None,
+        include: Include = IncludeMetadataDocuments,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> GetResult:
+        # Servers do not support the "data" include, as that is hydrated on the client side
+        filtered_include = [i for i in include if i != "data"]
+
+        resp_json = await self._make_request(
+            "post",
+            f"/tenants/{tenant}/databases/{database}/collections/{collection_id}/get",
+            json={
+                "ids": ids,
+                "where": where,
+                "limit": limit,
+                "offset": offset,
+                "where_document": where_document,
+                "include": filtered_include,
+            },
+        )
+
+        metadatas = resp_json.get("metadatas", None)
+        if metadatas is not None:
+            metadatas = [
+                deserialize_metadata(metadata) if metadata is not None else None
+                for metadata in metadatas
+            ]
+
+        return GetResult(
+            ids=resp_json["ids"],
+            embeddings=resp_json.get("embeddings", None),
+            metadatas=metadatas,
+            documents=resp_json.get("documents", None),
+            data=None,
+            uris=resp_json.get("uris", None),
+            included=include,
+        )
+
+    @trace_method("AsyncFastAPI._delete", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def _delete(
+        self,
+        collection_id: UUID,
+        ids: Optional[IDs] = None,
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        limit: Optional[int] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> DeleteResult:
+        body: dict = {"where": where, "ids": ids, "where_document": where_document}
+        if limit is not None:
+            body["limit"] = limit
+        resp = await self._make_request(
+            "post",
+            f"/tenants/{tenant}/databases/{database}/collections/{collection_id}/delete",
+            json=body,
+        )
+        return DeleteResult(deleted=resp.get("deleted", 0) if resp else 0)
+
+    @trace_method("AsyncFastAPI._submit_batch", OpenTelemetryGranularity.ALL)
+    async def _submit_batch(
+        self,
+        batch: Tuple[
+            IDs,
+            Optional[Embeddings],
+            Optional[Metadatas],
+            Optional[Documents],
+            Optional[URIs],
+        ],
+        url: str,
+    ) -> Any:
+        """
+        Submits a batch of embeddings to the database
+        """
+        supports_base64_encoding = await self.supports_base64_encoding()
+
+        serialized_metadatas = None
+        if batch[2] is not None:
+            serialized_metadatas = [
+                serialize_metadata(metadata) if metadata is not None else None
+                for metadata in batch[2]
+            ]
+
+        data = {
+            "ids": batch[0],
+            "embeddings": optional_embeddings_to_base64_strings(batch[1])
+            if supports_base64_encoding
+            else batch[1],
+            "metadatas": serialized_metadatas,
+            "documents": batch[3],
+            "uris": batch[4],
+        }
+
+        return await self._make_request(
+            "post",
+            url,
+            json=data,
+        )
+
+    @trace_method("AsyncFastAPI._add", OpenTelemetryGranularity.ALL)
+    @override
+    async def _add(
+        self,
+        ids: IDs,
+        collection_id: UUID,
+        embeddings: Embeddings,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        batch = (
+            ids,
+            embeddings,
+            metadatas,
+            documents,
+            uris,
+        )
+        validate_batch(batch, {"max_batch_size": await self.get_max_batch_size()})
+        await self._submit_batch(
+            batch,
+            f"/tenants/{tenant}/databases/{database}/collections/{str(collection_id)}/add",
+        )
+        return True
+
+    @trace_method("AsyncFastAPI._update", OpenTelemetryGranularity.ALL)
+    @override
+    async def _update(
+        self,
+        collection_id: UUID,
+        ids: IDs,
+        embeddings: Optional[Embeddings] = None,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        batch = (
+            ids,
+            embeddings if embeddings is not None else None,
+            metadatas,
+            documents,
+            uris,
+        )
+        validate_batch(batch, {"max_batch_size": await self.get_max_batch_size()})
+
+        await self._submit_batch(
+            batch,
+            f"/tenants/{tenant}/databases/{database}/collections/{str(collection_id)}/update",
+        )
+
+        return True
+
+    @trace_method("AsyncFastAPI._upsert", OpenTelemetryGranularity.ALL)
+    @override
+    async def _upsert(
+        self,
+        collection_id: UUID,
+        ids: IDs,
+        embeddings: Embeddings,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        batch = (
+            ids,
+            embeddings,
+            metadatas,
+            documents,
+            uris,
+        )
+        validate_batch(batch, {"max_batch_size": await self.get_max_batch_size()})
+        await self._submit_batch(
+            batch,
+            f"/tenants/{tenant}/databases/{database}/collections/{str(collection_id)}/upsert",
+        )
+        return True
+
+    @trace_method("AsyncFastAPI._query", OpenTelemetryGranularity.ALL)
+    @override
+    async def _query(
+        self,
+        collection_id: UUID,
+        query_embeddings: Embeddings,
+        ids: Optional[IDs] = None,
+        n_results: int = 10,
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        include: Include = IncludeMetadataDocumentsDistances,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> QueryResult:
+        # Servers do not support the "data" include, as that is hydrated on the client side
+        filtered_include = [i for i in include if i != "data"]
+
+        resp_json = await self._make_request(
+            "post",
+            f"/tenants/{tenant}/databases/{database}/collections/{collection_id}/query",
+            json={
+                "ids": ids,
+                "query_embeddings": convert_np_embeddings_to_list(query_embeddings)
+                if query_embeddings is not None
+                else None,
+                "n_results": n_results,
+                "where": where,
+                "where_document": where_document,
+                "include": filtered_include,
+            },
+        )
+
+        metadata_batches = resp_json.get("metadatas", None)
+        if metadata_batches is not None:
+            metadata_batches = [
+                [
+                    deserialize_metadata(metadata) if metadata is not None else None
+                    for metadata in metadatas
+                ]
+                if metadatas is not None
+                else None
+                for metadatas in metadata_batches
+            ]
+
+        return QueryResult(
+            ids=resp_json["ids"],
+            distances=resp_json.get("distances", None),
+            embeddings=resp_json.get("embeddings", None),
+            metadatas=metadata_batches,
+            documents=resp_json.get("documents", None),
+            uris=resp_json.get("uris", None),
+            data=None,
+            included=include,
+        )
+
+    @trace_method("AsyncFastAPI.reset", OpenTelemetryGranularity.ALL)
+    @override
+    async def reset(self) -> bool:
+        resp_json = await self._make_request("post", "/reset")
+        return cast(bool, resp_json)
+
+    @trace_method("AsyncFastAPI.get_version", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def get_version(self) -> str:
+        resp_json = await self._make_request("get", "/version")
+        return cast(str, resp_json)
+
+    @override
+    def get_settings(self) -> Settings:
+        return self._settings
+
+    @trace_method(
+        "AsyncFastAPI.get_pre_flight_checks", OpenTelemetryGranularity.OPERATION
+    )
+    async def get_pre_flight_checks(self) -> Any:
+        if self.pre_flight_checks is None:
+            resp_json = await self._make_request("get", "/pre-flight-checks")
+            self.pre_flight_checks = resp_json
+        return self.pre_flight_checks
+
+    @trace_method(
+        "AsyncFastAPI.supports_base64_encoding", OpenTelemetryGranularity.OPERATION
+    )
+    async def supports_base64_encoding(self) -> bool:
+        pre_flight_checks = await self.get_pre_flight_checks()
+        b64_encoding_enabled = cast(
+            bool, pre_flight_checks.get("supports_base64_encoding", False)
+        )
+        return b64_encoding_enabled
+
+    @trace_method("AsyncFastAPI.get_max_batch_size", OpenTelemetryGranularity.OPERATION)
+    @override
+    async def get_max_batch_size(self) -> int:
+        pre_flight_checks = await self.get_pre_flight_checks()
+        max_batch_size = cast(int, pre_flight_checks.get("max_batch_size", -1))
+        return max_batch_size

python/user_packages/Python313/site-packages/chromadb/api/base_http_client.py

@@ -0,0 +1,145 @@
+from typing import Any, Dict, Mapping, Optional, TypeVar
+from urllib.parse import quote, urlparse, urlunparse
+import logging
+import orjson as json
+import httpx
+
+import chromadb.errors as errors
+from chromadb.config import Component, Settings, System
+
+logger = logging.getLogger(__name__)
+
+
+# inherits from Component so that it can create an init function to use system
+# this way it can build limits from the settings in System
+class BaseHTTPClient(Component):
+    _settings: Settings
+    pre_flight_checks: Any = None
+    DEFAULT_KEEPALIVE_SECS: float = 40.0
+
+    def __init__(self, system: System):
+        super().__init__(system)
+        self._settings = system.settings
+        keepalive_setting = self._settings.chroma_http_keepalive_secs
+        self.keepalive_secs: Optional[float] = (
+            keepalive_setting
+            if keepalive_setting is not None
+            else BaseHTTPClient.DEFAULT_KEEPALIVE_SECS
+        )
+        self._http_limits = self._build_limits()
+
+    def _build_limits(self) -> httpx.Limits:
+        limit_kwargs: Dict[str, Any] = {}
+        if self.keepalive_secs is not None:
+            limit_kwargs["keepalive_expiry"] = self.keepalive_secs
+
+        max_connections = self._settings.chroma_http_max_connections
+        if max_connections is not None:
+            limit_kwargs["max_connections"] = max_connections
+
+        max_keepalive_connections = self._settings.chroma_http_max_keepalive_connections
+        if max_keepalive_connections is not None:
+            limit_kwargs["max_keepalive_connections"] = max_keepalive_connections
+
+        return httpx.Limits(**limit_kwargs)
+
+    @property
+    def http_limits(self) -> httpx.Limits:
+        return self._http_limits
+
+    @staticmethod
+    def _validate_host(host: str) -> None:
+        parsed = urlparse(host)
+        if "/" in host and parsed.scheme not in {"http", "https"}:
+            raise ValueError(
+                "Invalid URL. " f"Unrecognized protocol - {parsed.scheme}."
+            )
+        if "/" in host and (not host.startswith("http")):
+            raise ValueError(
+                "Invalid URL. "
+                "Seems that you are trying to pass URL as a host but without \
+                  specifying the protocol. "
+                "Please add http:// or https:// to the host."
+            )
+
+    @staticmethod
+    def resolve_url(
+        chroma_server_host: str,
+        chroma_server_ssl_enabled: Optional[bool] = False,
+        default_api_path: Optional[str] = "",
+        chroma_server_http_port: Optional[int] = 8000,
+    ) -> str:
+        _skip_port = False
+        _chroma_server_host = chroma_server_host
+        BaseHTTPClient._validate_host(_chroma_server_host)
+        if _chroma_server_host.startswith("http"):
+            logger.debug("Skipping port as the user is passing a full URL")
+            _skip_port = True
+        parsed = urlparse(_chroma_server_host)
+
+        scheme = "https" if chroma_server_ssl_enabled else parsed.scheme or "http"
+        net_loc = parsed.netloc or parsed.hostname or chroma_server_host
+        port = (
+            ":" + str(parsed.port or chroma_server_http_port) if not _skip_port else ""
+        )
+        path = parsed.path or default_api_path
+
+        if not path or path == net_loc:
+            path = default_api_path if default_api_path else ""
+        if not path.endswith(default_api_path or ""):
+            path = path + default_api_path if default_api_path else ""
+        full_url = urlunparse(
+            (scheme, f"{net_loc}{port}", quote(path.replace("//", "/")), "", "", "")
+        )
+
+        return full_url
+
+    # requests removes None values from the built query string, but httpx includes it as an empty value
+    T = TypeVar("T", bound=Dict[Any, Any])
+
+    @staticmethod
+    def _clean_params(params: T) -> T:
+        """Remove None values from provided dict."""
+        return {k: v for k, v in params.items() if v is not None}  # type: ignore
+
+    @staticmethod
+    def _raise_chroma_error(resp: httpx.Response) -> None:
+        """Raises an error if the response is not ok, using a ChromaError if possible."""
+        try:
+            resp.raise_for_status()
+            return
+        except httpx.HTTPStatusError:
+            pass
+
+        chroma_error = None
+        try:
+            body = json.loads(resp.text)
+            if "error" in body:
+                if body["error"] in errors.error_types:
+                    chroma_error = errors.error_types[body["error"]](body["message"])
+
+                    trace_id = resp.headers.get("chroma-trace-id")
+                    if trace_id:
+                        chroma_error.trace_id = trace_id
+
+        except BaseException:
+            pass
+
+        if chroma_error:
+            raise chroma_error
+
+        try:
+            resp.raise_for_status()
+        except httpx.HTTPStatusError:
+            trace_id = resp.headers.get("chroma-trace-id")
+            if trace_id:
+                raise Exception(f"{resp.text} (trace ID: {trace_id})")
+            raise (Exception(resp.text))
+
+    def get_request_headers(self) -> Mapping[str, str]:
+        """Return headers used for HTTP requests."""
+        return {}
+
+    def get_api_url(self) -> str:
+        """Return the API URL for this client."""
+        return ""

python/user_packages/Python313/site-packages/chromadb/api/client.py

@@ -0,0 +1,731 @@
+from typing import Optional, Sequence
+from types import TracebackType
+from uuid import UUID
+
+from overrides import override
+import httpx
+from chromadb.api import AdminAPI, ClientAPI, ServerAPI
+from chromadb.api.collection_configuration import (
+    CreateCollectionConfiguration,
+    UpdateCollectionConfiguration,
+    validate_embedding_function_conflict_on_create,
+    validate_embedding_function_conflict_on_get,
+)
+from chromadb.api.shared_system_client import SharedSystemClient
+from chromadb.api.types import (
+    CollectionMetadata,
+    DataLoader,
+    Documents,
+    Embeddable,
+    EmbeddingFunction,
+    Embeddings,
+    GetResult,
+    IDs,
+    Include,
+    Loadable,
+    Metadatas,
+    QueryResult,
+    Schema,
+    URIs,
+    IncludeMetadataDocuments,
+    IncludeMetadataDocumentsDistances,
+    DefaultEmbeddingFunction,
+    DeleteResult,
+)
+from chromadb.auth import UserIdentity
+from chromadb.auth.utils import maybe_set_tenant_and_database
+from chromadb.config import Settings, System
+from chromadb.config import DEFAULT_TENANT, DEFAULT_DATABASE
+from chromadb.api.models.Collection import Collection
+from chromadb.errors import ChromaAuthError, ChromaError
+from chromadb.types import Database, Tenant, Where, WhereDocument
+
+
+class Client(SharedSystemClient, ClientAPI):
+    """A client for Chroma. This is the main entrypoint for interacting with Chroma.
+    A client internally stores its tenant and database and proxies calls to a
+    Server API instance of Chroma. It treats the Server API and corresponding System
+    as a singleton, so multiple clients connecting to the same resource will share the
+    same API instance.
+
+    Client implementations should be implement their own API-caching strategies.
+    """
+
+    tenant: str = DEFAULT_TENANT
+    database: str = DEFAULT_DATABASE
+
+    _server: ServerAPI
+    # An internal admin client for verifying that databases and tenants exist
+    _admin_client: AdminAPI
+    _closed: bool = False
+
+    # region Initialization
+    def __init__(
+        self,
+        tenant: Optional[str] = DEFAULT_TENANT,
+        database: Optional[str] = DEFAULT_DATABASE,
+        settings: Settings = Settings(),
+    ) -> None:
+        super().__init__(settings=settings)
+        try:
+            if tenant is not None:
+                self.tenant = tenant
+            if database is not None:
+                self.database = database
+
+            # Get the root system component we want to interact with
+            self._server = self._system.instance(ServerAPI)
+
+            user_identity = self.get_user_identity()
+
+            maybe_tenant, maybe_database = maybe_set_tenant_and_database(
+                user_identity,
+                overwrite_singleton_tenant_database_access_from_auth=settings.chroma_overwrite_singleton_tenant_database_access_from_auth,
+                user_provided_tenant=tenant,
+                user_provided_database=database,
+            )
+
+            # this should not happen unless types are invalidated
+            if maybe_tenant is None and tenant is None:
+                raise ChromaAuthError(
+                    "Could not determine a tenant from the current authentication method. Please provide a tenant."
+                )
+            if maybe_database is None and database is None:
+                raise ChromaAuthError(
+                    "Could not determine a database name from the current authentication method. Please provide a database name."
+                )
+
+            if maybe_tenant:
+                self.tenant = maybe_tenant
+            if maybe_database:
+                self.database = maybe_database
+
+            # Create an admin client for verifying that databases and tenants exist
+            self._admin_client = AdminClient.from_system(self._system)
+            self._validate_tenant_database(tenant=self.tenant, database=self.database)
+
+            self._submit_client_start_event()
+        except Exception:
+            # If init fails after refcount was incremented, release references
+            # to avoid a resource leak (the caller never receives the object to
+            # call close() on it).
+            if hasattr(self, "_admin_client"):
+                SharedSystemClient._release_system(self._admin_client._identifier)
+            SharedSystemClient._release_system(self._identifier)
+            raise
+
+    @classmethod
+    @override
+    def from_system(
+        cls,
+        system: System,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> "Client":
+        SharedSystemClient._populate_data_from_system(system)
+        instance = cls(tenant=tenant, database=database, settings=system.settings)
+        return instance
+
+    # endregion
+
+    @override
+    def get_user_identity(self) -> UserIdentity:
+        try:
+            return self._server.get_user_identity()
+        except httpx.ConnectError:
+            raise ValueError(
+                "Could not connect to a Chroma server. Are you sure it is running?"
+            )
+        # Propagate ChromaErrors
+        except ChromaError as e:
+            raise e
+        except Exception as e:
+            raise ValueError(str(e))
+
+    # region BaseAPI Methods
+    # Note - we could do this in less verbose ways, but they break type checking
+    @override
+    def heartbeat(self) -> int:
+        """Return the server time in nanoseconds since epoch."""
+        return self._server.heartbeat()
+
+    @override
+    def list_collections(
+        self, limit: Optional[int] = None, offset: Optional[int] = None
+    ) -> Sequence[Collection]:
+        """List collections for the current tenant and database, with pagination.
+
+        Returns:
+            Sequence[Collection]: Collection objects for the current tenant.
+        """
+        return [
+            Collection(client=self._server, model=model)
+            for model in self._server.list_collections(
+                limit, offset, tenant=self.tenant, database=self.database
+            )
+        ]
+
+    @override
+    def count_collections(self) -> int:
+        """Return the number of collections in the current database."""
+        return self._server.count_collections(
+            tenant=self.tenant, database=self.database
+        )
+
+    @override
+    def create_collection(
+        self,
+        name: str,
+        schema: Optional[Schema] = None,
+        configuration: Optional[CreateCollectionConfiguration] = None,
+        metadata: Optional[CollectionMetadata] = None,
+        embedding_function: Optional[
+            EmbeddingFunction[Embeddable]
+        ] = DefaultEmbeddingFunction(),  # type: ignore
+        data_loader: Optional[DataLoader[Loadable]] = None,
+        get_or_create: bool = False,
+    ) -> Collection:
+        """Create a collection with optional configuration and metadata.
+
+        If using a schema, do not provide `embedding_function`. Instead,
+        provide the `embedding_function` as part of the schema.
+
+        Args:
+            name: Collection name.
+            schema: Optional collection schema for indexes and encryption.
+            configuration: Optional collection configuration.
+            metadata: Optional collection metadata.
+            embedding_function: Optional embedding function for the collection.
+            data_loader: Optional data loader for documents with URIs.
+            get_or_create: Whether to return an existing collection if present.
+
+        Returns:
+            Collection: The created collection.
+
+        Raises:
+            ValueError: If the embedding function conflicts with configuration.
+        """
+        if configuration is None:
+            configuration = {}
+
+        configuration_ef = configuration.get("embedding_function")
+
+        validate_embedding_function_conflict_on_create(
+            embedding_function, configuration_ef
+        )
+
+        # If ef provided in function params and collection config ef is None,
+        # set the collection config ef to the function params
+        if embedding_function is not None and configuration_ef is None:
+            configuration["embedding_function"] = embedding_function
+
+        model = self._server.create_collection(
+            name=name,
+            schema=schema,
+            metadata=metadata,
+            tenant=self.tenant,
+            database=self.database,
+            get_or_create=get_or_create,
+            configuration=configuration,
+        )
+        return Collection(
+            client=self._server,
+            model=model,
+            embedding_function=embedding_function,
+            data_loader=data_loader,
+        )
+
+    @override
+    def get_collection(
+        self,
+        name: str,
+        embedding_function: Optional[
+            EmbeddingFunction[Embeddable]
+        ] = DefaultEmbeddingFunction(),  # type: ignore
+        data_loader: Optional[DataLoader[Loadable]] = None,
+    ) -> Collection:
+        """Get a collection by name.
+
+        Args:
+            name: Collection name.
+            embedding_function: Optional embedding function for the collection.
+            data_loader: Optional data loader for documents with URIs.
+
+        Returns:
+            Collection: The requested collection.
+
+        Raises:
+            ValueError: If the embedding function conflicts with configuration.
+        """
+        model = self._server.get_collection(
+            name=name,
+            tenant=self.tenant,
+            database=self.database,
+        )
+        persisted_ef_config = model.configuration_json.get("embedding_function")
+
+        validate_embedding_function_conflict_on_get(
+            embedding_function, persisted_ef_config
+        )
+
+        return Collection(
+            client=self._server,
+            model=model,
+            embedding_function=embedding_function,
+            data_loader=data_loader,
+        )
+
+    @override
+    def get_collection_by_id(
+        self,
+        id: UUID,
+        embedding_function: Optional[
+            EmbeddingFunction[Embeddable]
+        ] = DefaultEmbeddingFunction(),  # type: ignore
+        data_loader: Optional[DataLoader[Loadable]] = None,
+    ) -> Collection:
+        """Get a collection by its ID.
+
+        Args:
+            id: The UUID of the collection.
+            embedding_function: Optional embedding function for the collection.
+            data_loader: Optional data loader for documents with URIs.
+
+        Returns:
+            Collection: The requested collection.
+
+        Raises:
+            ValueError: If the embedding function conflicts with configuration.
+        """
+        model = self._server.get_collection_by_id(
+            collection_id=id,
+            tenant=self.tenant,
+            database=self.database,
+        )
+        persisted_ef_config = model.configuration_json.get("embedding_function")
+
+        validate_embedding_function_conflict_on_get(
+            embedding_function, persisted_ef_config
+        )
+
+        return Collection(
+            client=self._server,
+            model=model,
+            embedding_function=embedding_function,
+            data_loader=data_loader,
+        )
+
+    @override
+    def get_or_create_collection(
+        self,
+        name: str,
+        schema: Optional[Schema] = None,
+        configuration: Optional[CreateCollectionConfiguration] = None,
+        metadata: Optional[CollectionMetadata] = None,
+        embedding_function: Optional[
+            EmbeddingFunction[Embeddable]
+        ] = DefaultEmbeddingFunction(),  # type: ignore
+        data_loader: Optional[DataLoader[Loadable]] = None,
+    ) -> Collection:
+        """Get an existing collection or create a new one.
+
+        If the collection does not exist, it will be created. If the collection
+        already exists, the schema, configuration, and metadata arguments
+        will be ignored.
+
+        Args:
+            name: Collection name.
+            schema: Optional collection schema for indexes and encryption.
+            configuration: Optional collection configuration.
+            metadata: Optional collection metadata.
+            embedding_function: Optional embedding function for the collection.
+            data_loader: Optional data loader for URI-backed data.
+
+        Returns:
+            Collection: The existing or newly created collection.
+
+        Raises:
+            ValueError: If the embedding function does not match the collection's embedding function.
+        """
+        if configuration is None:
+            configuration = {}
+
+        configuration_ef = configuration.get("embedding_function")
+
+        validate_embedding_function_conflict_on_create(
+            embedding_function, configuration_ef
+        )
+
+        if embedding_function is not None and configuration_ef is None:
+            configuration["embedding_function"] = embedding_function
+        model = self._server.get_or_create_collection(
+            name=name,
+            schema=schema,
+            metadata=metadata,
+            tenant=self.tenant,
+            database=self.database,
+            configuration=configuration,
+        )
+
+        persisted_ef_config = model.configuration_json.get("embedding_function")
+
+        validate_embedding_function_conflict_on_get(
+            embedding_function, persisted_ef_config
+        )
+
+        return Collection(
+            client=self._server,
+            model=model,
+            embedding_function=embedding_function,
+            data_loader=data_loader,
+        )
+
+    @override
+    def _modify(
+        self,
+        id: UUID,
+        new_name: Optional[str] = None,
+        new_metadata: Optional[CollectionMetadata] = None,
+        new_configuration: Optional[UpdateCollectionConfiguration] = None,
+    ) -> None:
+        return self._server._modify(
+            id=id,
+            tenant=self.tenant,
+            database=self.database,
+            new_name=new_name,
+            new_metadata=new_metadata,
+            new_configuration=new_configuration,
+        )
+
+    @override
+    def delete_collection(
+        self,
+        name: str,
+    ) -> None:
+        return self._server.delete_collection(
+            name=name,
+            tenant=self.tenant,
+            database=self.database,
+        )
+
+    #
+    # ITEM METHODS
+    #
+
+    @override
+    def _add(
+        self,
+        ids: IDs,
+        collection_id: UUID,
+        embeddings: Embeddings,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+    ) -> bool:
+        return self._server._add(
+            ids=ids,
+            tenant=self.tenant,
+            database=self.database,
+            collection_id=collection_id,
+            embeddings=embeddings,
+            metadatas=metadatas,
+            documents=documents,
+            uris=uris,
+        )
+
+    @override
+    def _update(
+        self,
+        collection_id: UUID,
+        ids: IDs,
+        embeddings: Optional[Embeddings] = None,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+    ) -> bool:
+        return self._server._update(
+            collection_id=collection_id,
+            tenant=self.tenant,
+            database=self.database,
+            ids=ids,
+            embeddings=embeddings,
+            metadatas=metadatas,
+            documents=documents,
+            uris=uris,
+        )
+
+    @override
+    def _upsert(
+        self,
+        collection_id: UUID,
+        ids: IDs,
+        embeddings: Embeddings,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+    ) -> bool:
+        return self._server._upsert(
+            collection_id=collection_id,
+            tenant=self.tenant,
+            database=self.database,
+            ids=ids,
+            embeddings=embeddings,
+            metadatas=metadatas,
+            documents=documents,
+            uris=uris,
+        )
+
+    @override
+    def _count(self, collection_id: UUID) -> int:
+        return self._server._count(
+            collection_id=collection_id,
+            tenant=self.tenant,
+            database=self.database,
+        )
+
+    @override
+    def _peek(self, collection_id: UUID, n: int = 10) -> GetResult:
+        return self._server._peek(
+            collection_id=collection_id,
+            n=n,
+            tenant=self.tenant,
+            database=self.database,
+        )
+
+    @override
+    def _get(
+        self,
+        collection_id: UUID,
+        ids: Optional[IDs] = None,
+        where: Optional[Where] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        where_document: Optional[WhereDocument] = None,
+        include: Include = IncludeMetadataDocuments,
+    ) -> GetResult:
+        return self._server._get(
+            collection_id=collection_id,
+            tenant=self.tenant,
+            database=self.database,
+            ids=ids,
+            where=where,
+            limit=limit,
+            offset=offset,
+            where_document=where_document,
+            include=include,
+        )
+
+    def _delete(
+        self,
+        collection_id: UUID,
+        ids: Optional[IDs],
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        limit: Optional[int] = None,
+    ) -> DeleteResult:
+        return self._server._delete(
+            collection_id=collection_id,
+            tenant=self.tenant,
+            database=self.database,
+            ids=ids,
+            where=where,
+            where_document=where_document,
+            limit=limit,
+        )
+
+    @override
+    def _query(
+        self,
+        collection_id: UUID,
+        query_embeddings: Embeddings,
+        ids: Optional[IDs] = None,
+        n_results: int = 10,
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        include: Include = IncludeMetadataDocumentsDistances,
+    ) -> QueryResult:
+        return self._server._query(
+            collection_id=collection_id,
+            ids=ids,
+            tenant=self.tenant,
+            database=self.database,
+            query_embeddings=query_embeddings,
+            n_results=n_results,
+            where=where,
+            where_document=where_document,
+            include=include,
+        )
+
+    @override
+    def reset(self) -> bool:
+        return self._server.reset()
+
+    @override
+    def get_version(self) -> str:
+        return self._server.get_version()
+
+    @override
+    def get_settings(self) -> Settings:
+        return self._server.get_settings()
+
+    @override
+    def get_max_batch_size(self) -> int:
+        return self._server.get_max_batch_size()
+
+    # endregion
+
+    # region ClientAPI Methods
+
+    @override
+    def set_tenant(self, tenant: str, database: str = DEFAULT_DATABASE) -> None:
+        self._validate_tenant_database(tenant=tenant, database=database)
+        self.tenant = tenant
+        self.database = database
+
+    @override
+    def set_database(self, database: str) -> None:
+        self._validate_tenant_database(tenant=self.tenant, database=database)
+        self.database = database
+
+    def close(self) -> None:
+        """Close the client and release all resources.
+
+        This method decrements the reference count for the underlying System.
+        When the last client using a shared System calls close(), the System
+        is stopped and all resources (database connections, etc.) are released.
+
+        This is particularly important for PersistentClient to avoid SQLite
+        file locking issues.
+
+        Note: If multiple clients share the same System (e.g., multiple PersistentClient
+        instances with the same path), the System will only be stopped when the last
+        client is closed. This allows safe use of context managers with multiple clients.
+
+        Example:
+            >>> client = chromadb.PersistentClient(path="./chroma_db")
+            >>> # ... use client ...
+            >>> client.close()
+
+            Or using context manager:
+            >>> with chromadb.PersistentClient(path="./chroma_db") as client:
+            ...     # ... use client ...
+        """
+        # Make close() idempotent - a second call is a safe no-op
+        if self._closed:
+            return
+        self._closed = True
+
+        # Release the internal admin client's reference first, since it also
+        # incremented the refcount for the shared system on creation.
+        if hasattr(self, "_admin_client"):
+            SharedSystemClient._release_system(self._admin_client._identifier)
+
+        # Release our own reference; stops system if this was the last client
+        SharedSystemClient._release_system(self._identifier)
+
+    def __enter__(self) -> "Client":
+        """Context manager entry."""
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        """Context manager exit."""
+        self.close()
+
+    def _validate_tenant_database(self, tenant: str, database: str) -> None:
+        try:
+            self._admin_client.get_tenant(name=tenant)
+        except httpx.ConnectError:
+            raise ValueError(
+                "Could not connect to a Chroma server. Are you sure it is running?"
+            )
+        # Propagate ChromaErrors
+        except ChromaError as e:
+            raise e
+        except Exception:
+            raise ValueError(
+                f"Could not connect to tenant {tenant}. Are you sure it exists?"
+            )
+
+        try:
+            self._admin_client.get_database(name=database, tenant=tenant)
+        except httpx.ConnectError:
+            raise ValueError(
+                "Could not connect to a Chroma server. Are you sure it is running?"
+            )
+
+    # endregion
+
+
+class AdminClient(SharedSystemClient, AdminAPI):
+    """Admin client for managing tenants and databases."""
+
+    _server: ServerAPI
+
+    def __init__(self, settings: Settings = Settings()) -> None:
+        super().__init__(settings)
+        self._server = self._system.instance(ServerAPI)
+
+    @override
+    def create_database(self, name: str, tenant: str = DEFAULT_TENANT) -> None:
+        """Create a database in a tenant.
+
+        Args:
+            name: Database name.
+            tenant: Tenant that owns the database.
+        """
+        return self._server.create_database(name=name, tenant=tenant)
+
+    @override
+    def get_database(self, name: str, tenant: str = DEFAULT_TENANT) -> Database:
+        """Get a database by name.
+
+        Args:
+            name: Database name.
+            tenant: Tenant that owns the database.
+
+        Returns:
+            Database: The database record.
+        """
+        return self._server.get_database(name=name, tenant=tenant)
+
+    @override
+    def delete_database(self, name: str, tenant: str = DEFAULT_TENANT) -> None:
+        """Delete a database by name.
+
+        Args:
+            name: Database name.
+            tenant: Tenant that owns the database.
+        """
+        return self._server.delete_database(name=name, tenant=tenant)
+
+    @override
+    def list_databases(
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        tenant: str = DEFAULT_TENANT,
+    ) -> Sequence[Database]:
+        return self._server.list_databases(limit, offset, tenant=tenant)
+
+    @override
+    def create_tenant(self, name: str) -> None:
+        return self._server.create_tenant(name=name)
+
+    @override
+    def get_tenant(self, name: str) -> Tenant:
+        return self._server.get_tenant(name=name)
+
+    @classmethod
+    @override
+    def from_system(
+        cls,
+        system: System,
+    ) -> "AdminClient":
+        SharedSystemClient._populate_data_from_system(system)
+        instance = cls(settings=system.settings)
+        return instance

python/user_packages/Python313/site-packages/chromadb/api/collection_configuration.py

@@ -0,0 +1,882 @@
+from typing import TypedDict, Dict, Any, Optional, cast, get_args
+import json
+from chromadb.api.types import (
+    Space,
+    CollectionMetadata,
+    UpdateMetadata,
+    EmbeddingFunction,
+)
+from chromadb.utils.embedding_functions import (
+    known_embedding_functions,
+    register_embedding_function,
+)
+from multiprocessing import cpu_count
+import warnings
+
+from chromadb.api.types import Schema
+
+
+class HNSWConfiguration(TypedDict, total=False):
+    space: Space
+    ef_construction: int
+    max_neighbors: int
+    ef_search: int
+    num_threads: int
+    batch_size: int
+    sync_threshold: int
+    resize_factor: float
+
+
+class SpannConfiguration(TypedDict, total=False):
+    search_nprobe: int
+    write_nprobe: int
+    space: Space
+    ef_construction: int
+    ef_search: int
+    max_neighbors: int
+    reassign_neighbor_count: int
+    split_threshold: int
+    merge_threshold: int
+
+
+class CollectionConfiguration(TypedDict, total=True):
+    hnsw: Optional[HNSWConfiguration]
+    spann: Optional[SpannConfiguration]
+    embedding_function: Optional[EmbeddingFunction]  # type: ignore
+
+
+def load_collection_configuration_from_json_str(
+    config_json_str: str,
+) -> CollectionConfiguration:
+    config_json_map = json.loads(config_json_str)
+    return load_collection_configuration_from_json(config_json_map)
+
+
+# TODO: make warnings prettier and add link to migration docs
+def load_collection_configuration_from_json(
+    config_json_map: Dict[str, Any]
+) -> CollectionConfiguration:
+    if (
+        config_json_map.get("spann") is not None
+        and config_json_map.get("hnsw") is not None
+    ):
+        raise ValueError("hnsw and spann cannot both be provided")
+
+    hnsw_config = None
+    spann_config = None
+    ef_config = None
+
+    # Process vector index configuration (HNSW or SPANN)
+    if config_json_map.get("hnsw") is not None:
+        hnsw_config = cast(HNSWConfiguration, config_json_map["hnsw"])
+    if config_json_map.get("spann") is not None:
+        spann_config = cast(SpannConfiguration, config_json_map["spann"])
+
+    # Process embedding function configuration
+    if config_json_map.get("embedding_function") is not None:
+        ef_config = config_json_map["embedding_function"]
+        if ef_config["type"] == "legacy":
+            warnings.warn(
+                "legacy embedding function config",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            ef = None
+        else:
+            try:
+                ef_name = ef_config["name"]
+            except KeyError:
+                raise ValueError(
+                    f"Embedding function name not found in config: {ef_config}"
+                )
+            try:
+                ef = known_embedding_functions[ef_name]
+            except KeyError:
+                raise ValueError(
+                    f"Embedding function {ef_name} not found. Add @register_embedding_function decorator to the class definition."
+                )
+            try:
+                ef = ef.build_from_config(ef_config["config"])  # type: ignore
+            except Exception as e:
+                raise ValueError(
+                    f"Could not build embedding function {ef_config['name']} from config {ef_config['config']}: {e}"
+                )
+    else:
+        ef = None
+
+    return CollectionConfiguration(
+        hnsw=hnsw_config,
+        spann=spann_config,
+        embedding_function=ef,  # type: ignore
+    )
+
+
+def collection_configuration_to_json_str(config: CollectionConfiguration) -> str:
+    return json.dumps(collection_configuration_to_json(config))
+
+
+def collection_configuration_to_json(config: CollectionConfiguration) -> Dict[str, Any]:
+    if isinstance(config, dict):
+        hnsw_config = config.get("hnsw")
+        spann_config = config.get("spann")
+        ef = config.get("embedding_function")
+    else:
+        try:
+            hnsw_config = config.get_parameter("hnsw").value
+        except ValueError:
+            hnsw_config = None
+        try:
+            spann_config = config.get_parameter("spann").value
+        except ValueError:
+            spann_config = None
+        try:
+            ef = config.get_parameter("embedding_function").value
+        except ValueError:
+            ef = None
+
+    ef_config: Dict[str, Any] | None = None
+    if hnsw_config is not None:
+        try:
+            hnsw_config = cast(HNSWConfiguration, hnsw_config)
+        except Exception as e:
+            raise ValueError(f"not a valid hnsw config: {e}")
+    if spann_config is not None:
+        try:
+            spann_config = cast(SpannConfiguration, spann_config)
+        except Exception as e:
+            raise ValueError(f"not a valid spann config: {e}")
+
+    if ef is None:
+        ef = None
+        ef_config = {"type": "legacy"}
+
+    if ef is not None:
+        try:
+            if ef.is_legacy():
+                ef_config = {"type": "legacy"}
+            else:
+                ef_config = {
+                    "name": ef.name(),
+                    "type": "known",
+                    "config": ef.get_config(),
+                }
+                register_embedding_function(type(ef))  # type: ignore
+        except Exception as e:
+            warnings.warn(
+                f"legacy embedding function config: {e}",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            ef = None
+            ef_config = {"type": "legacy"}
+
+    return {
+        "hnsw": hnsw_config,
+        "spann": spann_config,
+        "embedding_function": ef_config,
+    }
+
+
+class CreateHNSWConfiguration(TypedDict, total=False):
+    space: Space
+    ef_construction: int
+    max_neighbors: int
+    ef_search: int
+    num_threads: int
+    batch_size: int
+    sync_threshold: int
+    resize_factor: float
+
+
+def json_to_create_hnsw_configuration(
+    json_map: Dict[str, Any]
+) -> CreateHNSWConfiguration:
+    config: CreateHNSWConfiguration = {}
+    if "space" in json_map:
+        space_value = json_map["space"]
+        if space_value in get_args(Space):
+            config["space"] = space_value
+        else:
+            raise ValueError(f"not a valid space: {space_value}")
+    if "ef_construction" in json_map:
+        config["ef_construction"] = json_map["ef_construction"]
+    if "max_neighbors" in json_map:
+        config["max_neighbors"] = json_map["max_neighbors"]
+    if "ef_search" in json_map:
+        config["ef_search"] = json_map["ef_search"]
+    if "num_threads" in json_map:
+        config["num_threads"] = json_map["num_threads"]
+    if "batch_size" in json_map:
+        config["batch_size"] = json_map["batch_size"]
+    if "sync_threshold" in json_map:
+        config["sync_threshold"] = json_map["sync_threshold"]
+    if "resize_factor" in json_map:
+        config["resize_factor"] = json_map["resize_factor"]
+    return config
+
+
+class CreateSpannConfiguration(TypedDict, total=False):
+    search_nprobe: int
+    write_nprobe: int
+    space: Space
+    ef_construction: int
+    ef_search: int
+    max_neighbors: int
+    reassign_neighbor_count: int
+    split_threshold: int
+    merge_threshold: int
+
+
+def json_to_create_spann_configuration(
+    json_map: Dict[str, Any]
+) -> CreateSpannConfiguration:
+    config: CreateSpannConfiguration = {}
+    if "search_nprobe" in json_map:
+        config["search_nprobe"] = json_map["search_nprobe"]
+    if "write_nprobe" in json_map:
+        config["write_nprobe"] = json_map["write_nprobe"]
+    if "space" in json_map:
+        space_value = json_map["space"]
+        if space_value in get_args(Space):
+            config["space"] = space_value
+        else:
+            raise ValueError(f"not a valid space: {space_value}")
+    if "ef_construction" in json_map:
+        config["ef_construction"] = json_map["ef_construction"]
+    if "ef_search" in json_map:
+        config["ef_search"] = json_map["ef_search"]
+    if "max_neighbors" in json_map:
+        config["max_neighbors"] = json_map["max_neighbors"]
+    return config
+
+
+class CreateCollectionConfiguration(TypedDict, total=False):
+    hnsw: Optional[CreateHNSWConfiguration]
+    spann: Optional[CreateSpannConfiguration]
+    embedding_function: Optional[EmbeddingFunction]  # type: ignore
+
+
+def create_collection_configuration_from_legacy_collection_metadata(
+    metadata: CollectionMetadata,
+) -> CreateCollectionConfiguration:
+    """Create a CreateCollectionConfiguration from legacy collection metadata"""
+    return create_collection_configuration_from_legacy_metadata_dict(metadata)
+
+
+def create_collection_configuration_from_legacy_metadata_dict(
+    metadata: Dict[str, Any],
+) -> CreateCollectionConfiguration:
+    """Create a CreateCollectionConfiguration from legacy collection metadata"""
+    old_to_new = {
+        "hnsw:space": "space",
+        "hnsw:construction_ef": "ef_construction",
+        "hnsw:M": "max_neighbors",
+        "hnsw:search_ef": "ef_search",
+        "hnsw:num_threads": "num_threads",
+        "hnsw:batch_size": "batch_size",
+        "hnsw:sync_threshold": "sync_threshold",
+        "hnsw:resize_factor": "resize_factor",
+    }
+    json_map = {}
+    for name, value in metadata.items():
+        if name in old_to_new:
+            json_map[old_to_new[name]] = value
+    hnsw_config = json_to_create_hnsw_configuration(json_map)
+    hnsw_config = populate_create_hnsw_defaults(hnsw_config)
+
+    return CreateCollectionConfiguration(hnsw=hnsw_config)
+
+
+# TODO: make warnings prettier and add link to migration docs
+def load_create_collection_configuration_from_json(
+    json_map: Dict[str, Any]
+) -> CreateCollectionConfiguration:
+    if json_map.get("hnsw") is not None and json_map.get("spann") is not None:
+        raise ValueError("hnsw and spann cannot both be provided")
+
+    result = CreateCollectionConfiguration()
+
+    # Handle vector index configuration
+    if json_map.get("hnsw") is not None:
+        result["hnsw"] = json_to_create_hnsw_configuration(json_map["hnsw"])
+
+    if json_map.get("spann") is not None:
+        result["spann"] = json_to_create_spann_configuration(json_map["spann"])
+
+    # Handle embedding function configuration
+    if json_map.get("embedding_function") is not None:
+        ef_config = json_map["embedding_function"]
+        if ef_config["type"] == "legacy":
+            warnings.warn(
+                "legacy embedding function config",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        else:
+            ef = known_embedding_functions[ef_config["name"]]
+            result["embedding_function"] = ef.build_from_config(ef_config["config"])
+
+    return result
+
+
+def create_collection_configuration_to_json_str(
+    config: CreateCollectionConfiguration,
+    metadata: Optional[CollectionMetadata] = None,
+) -> str:
+    """Convert a CreateCollection configuration to a JSON-serializable string"""
+    return json.dumps(create_collection_configuration_to_json(config, metadata))
+
+
+# TODO: make warnings prettier and add link to migration docs
+def create_collection_configuration_to_json(
+    config: CreateCollectionConfiguration,
+    metadata: Optional[CollectionMetadata] = None,
+) -> Dict[str, Any]:
+    """Convert a CreateCollection configuration to a JSON-serializable dict"""
+    ef_config: Dict[str, Any] | None = None
+    hnsw_config = config.get("hnsw")
+    spann_config = config.get("spann")
+    if hnsw_config is not None:
+        try:
+            hnsw_config = cast(CreateHNSWConfiguration, hnsw_config)
+        except Exception as e:
+            raise ValueError(f"not a valid hnsw config: {e}")
+    if spann_config is not None:
+        try:
+            spann_config = cast(CreateSpannConfiguration, spann_config)
+        except Exception as e:
+            raise ValueError(f"not a valid spann config: {e}")
+
+    if hnsw_config is not None and spann_config is not None:
+        raise ValueError("hnsw and spann cannot both be provided")
+
+    if config.get("embedding_function") is None:
+        ef = None
+        ef_config = {"type": "legacy"}
+        return {
+            "hnsw": hnsw_config,
+            "spann": spann_config,
+            "embedding_function": ef_config,
+        }
+
+    try:
+        ef = cast(EmbeddingFunction, config.get("embedding_function"))  # type: ignore
+        if ef.is_legacy():
+            ef_config = {"type": "legacy"}
+        else:
+            # default space logic: if neither hnsw nor spann config is provided and metadata doesn't have space,
+            # then populate space from ef
+            # otherwise dont use default space from ef
+
+            # then validate the space afterwards based on the supported spaces of the embedding function,
+            # warn if space is not supported
+
+            if hnsw_config is None and spann_config is None:
+                if metadata is None or metadata.get("hnsw:space") is None:
+                    # this populates space from ef if not provided in either config
+                    hnsw_config = CreateHNSWConfiguration(space=ef.default_space())
+
+            # if hnsw config or spann config exists but space is not provided, populate it from ef
+            if hnsw_config is not None and hnsw_config.get("space") is None:
+                hnsw_config["space"] = ef.default_space()
+            if spann_config is not None and spann_config.get("space") is None:
+                spann_config["space"] = ef.default_space()
+
+            # Validate space compatibility with embedding function
+            if hnsw_config is not None:
+                if hnsw_config.get("space") not in ef.supported_spaces():
+                    warnings.warn(
+                        f"space {hnsw_config.get('space')} is not supported by {ef.name()}. Supported spaces: {ef.supported_spaces()}",
+                        UserWarning,
+                        stacklevel=2,
+                    )
+            if spann_config is not None:
+                if spann_config.get("space") not in ef.supported_spaces():
+                    warnings.warn(
+                        f"space {spann_config.get('space')} is not supported by {ef.name()}. Supported spaces: {ef.supported_spaces()}",
+                        UserWarning,
+                        stacklevel=2,
+                    )
+
+            # only validate space from metadata if config is not provided
+            if (
+                hnsw_config is None
+                and spann_config is None
+                and metadata is not None
+                and metadata.get("hnsw:space") is not None
+            ):
+                if metadata.get("hnsw:space") not in ef.supported_spaces():
+                    warnings.warn(
+                        f"space {metadata.get('hnsw:space')} is not supported by {ef.name()}. Supported spaces: {ef.supported_spaces()}",
+                        UserWarning,
+                        stacklevel=2,
+                    )
+
+            ef_config = {
+                "name": ef.name(),
+                "type": "known",
+                "config": ef.get_config(),
+            }
+            register_embedding_function(type(ef))  # type: ignore
+    except Exception as e:
+        warnings.warn(
+            f"legacy embedding function config: {e}",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        ef = None
+        ef_config = {"type": "legacy"}
+
+    return {
+        "hnsw": hnsw_config,
+        "spann": spann_config,
+        "embedding_function": ef_config,
+    }
+
+
+def populate_create_hnsw_defaults(
+    config: CreateHNSWConfiguration, ef: Optional[EmbeddingFunction] = None  # type: ignore
+) -> CreateHNSWConfiguration:
+    """Populate a CreateHNSW configuration with default values"""
+    if config.get("space") is None:
+        config["space"] = ef.default_space() if ef else "l2"
+    if config.get("ef_construction") is None:
+        config["ef_construction"] = 100
+    if config.get("max_neighbors") is None:
+        config["max_neighbors"] = 16
+    if config.get("ef_search") is None:
+        config["ef_search"] = 100
+    if config.get("num_threads") is None:
+        config["num_threads"] = cpu_count()
+    if config.get("batch_size") is None:
+        config["batch_size"] = 100
+    if config.get("sync_threshold") is None:
+        config["sync_threshold"] = 1000
+    if config.get("resize_factor") is None:
+        config["resize_factor"] = 1.2
+    return config
+
+
+class UpdateHNSWConfiguration(TypedDict, total=False):
+    ef_search: int
+    num_threads: int
+    batch_size: int
+    sync_threshold: int
+    resize_factor: float
+
+
+def json_to_update_hnsw_configuration(
+    json_map: Dict[str, Any]
+) -> UpdateHNSWConfiguration:
+    config: UpdateHNSWConfiguration = {}
+    if "ef_search" in json_map:
+        config["ef_search"] = json_map["ef_search"]
+    if "num_threads" in json_map:
+        config["num_threads"] = json_map["num_threads"]
+    if "batch_size" in json_map:
+        config["batch_size"] = json_map["batch_size"]
+    if "sync_threshold" in json_map:
+        config["sync_threshold"] = json_map["sync_threshold"]
+    if "resize_factor" in json_map:
+        config["resize_factor"] = json_map["resize_factor"]
+    return config
+
+
+class UpdateSpannConfiguration(TypedDict, total=False):
+    search_nprobe: int
+    ef_search: int
+
+
+def json_to_update_spann_configuration(
+    json_map: Dict[str, Any]
+) -> UpdateSpannConfiguration:
+    config: UpdateSpannConfiguration = {}
+    if "search_nprobe" in json_map:
+        config["search_nprobe"] = json_map["search_nprobe"]
+    if "ef_search" in json_map:
+        config["ef_search"] = json_map["ef_search"]
+    return config
+
+
+class UpdateCollectionConfiguration(TypedDict, total=False):
+    hnsw: Optional[UpdateHNSWConfiguration]
+    spann: Optional[UpdateSpannConfiguration]
+    embedding_function: Optional[EmbeddingFunction]  # type: ignore
+
+
+def update_collection_configuration_from_legacy_collection_metadata(
+    metadata: CollectionMetadata,
+) -> UpdateCollectionConfiguration:
+    """Create an UpdateCollectionConfiguration from legacy collection metadata"""
+    old_to_new = {
+        "hnsw:search_ef": "ef_search",
+        "hnsw:num_threads": "num_threads",
+        "hnsw:batch_size": "batch_size",
+        "hnsw:sync_threshold": "sync_threshold",
+        "hnsw:resize_factor": "resize_factor",
+    }
+    json_map = {}
+    for name, value in metadata.items():
+        if name in old_to_new:
+            json_map[old_to_new[name]] = value
+    hnsw_config = json_to_update_hnsw_configuration(json_map)
+    return UpdateCollectionConfiguration(hnsw=hnsw_config)
+
+
+def update_collection_configuration_from_legacy_update_metadata(
+    metadata: UpdateMetadata,
+) -> UpdateCollectionConfiguration:
+    """Create an UpdateCollectionConfiguration from legacy update metadata"""
+    old_to_new = {
+        "hnsw:search_ef": "ef_search",
+        "hnsw:num_threads": "num_threads",
+        "hnsw:batch_size": "batch_size",
+        "hnsw:sync_threshold": "sync_threshold",
+        "hnsw:resize_factor": "resize_factor",
+    }
+    json_map = {}
+    for name, value in metadata.items():
+        if name in old_to_new:
+            json_map[old_to_new[name]] = value
+    hnsw_config = json_to_update_hnsw_configuration(json_map)
+    return UpdateCollectionConfiguration(hnsw=hnsw_config)
+
+
+def update_collection_configuration_to_json_str(
+    config: UpdateCollectionConfiguration,
+) -> str:
+    """Convert an UpdateCollectionConfiguration to a JSON-serializable string"""
+    json_dict = update_collection_configuration_to_json(config)
+    return json.dumps(json_dict)
+
+
+def update_collection_configuration_to_json(
+    config: UpdateCollectionConfiguration,
+) -> Dict[str, Any]:
+    """Convert an UpdateCollectionConfiguration to a JSON-serializable dict"""
+    hnsw_config = config.get("hnsw")
+    spann_config = config.get("spann")
+    ef = config.get("embedding_function")
+    if hnsw_config is None and spann_config is None and ef is None:
+        return {}
+
+    if hnsw_config is not None:
+        try:
+            hnsw_config = cast(UpdateHNSWConfiguration, hnsw_config)
+        except Exception as e:
+            raise ValueError(f"not a valid hnsw config: {e}")
+
+    if spann_config is not None:
+        try:
+            spann_config = cast(UpdateSpannConfiguration, spann_config)
+        except Exception as e:
+            raise ValueError(f"not a valid spann config: {e}")
+
+    ef_config: Dict[str, Any] | None = None
+    if ef is not None:
+        if ef.is_legacy():
+            ef_config = {"type": "legacy"}
+        else:
+            ef.validate_config(ef.get_config())
+            ef_config = {
+                "name": ef.name(),
+                "type": "known",
+                "config": ef.get_config(),
+            }
+            register_embedding_function(type(ef))  # type: ignore
+    else:
+        ef_config = None
+
+    return {
+        "hnsw": hnsw_config,
+        "spann": spann_config,
+        "embedding_function": ef_config,
+    }
+
+
+def load_update_collection_configuration_from_json_str(
+    json_str: str,
+) -> UpdateCollectionConfiguration:
+    json_map = json.loads(json_str)
+    return load_update_collection_configuration_from_json(json_map)
+
+
+# TODO: make warnings prettier and add link to migration docs
+def load_update_collection_configuration_from_json(
+    json_map: Dict[str, Any]
+) -> UpdateCollectionConfiguration:
+    """Convert a JSON dict to an UpdateCollectionConfiguration"""
+    if json_map.get("hnsw") is not None and json_map.get("spann") is not None:
+        raise ValueError("hnsw and spann cannot both be provided")
+
+    result = UpdateCollectionConfiguration()
+
+    # Handle vector index configurations
+    if json_map.get("hnsw") is not None:
+        result["hnsw"] = json_to_update_hnsw_configuration(json_map["hnsw"])
+
+    if json_map.get("spann") is not None:
+        result["spann"] = json_to_update_spann_configuration(json_map["spann"])
+
+    # Handle embedding function
+    if json_map.get("embedding_function") is not None:
+        if json_map["embedding_function"]["type"] == "legacy":
+            warnings.warn(
+                "legacy embedding function config",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        else:
+            ef = known_embedding_functions[json_map["embedding_function"]["name"]]
+            result["embedding_function"] = ef.build_from_config(
+                json_map["embedding_function"]["config"]
+            )
+
+    return result
+
+
+def overwrite_hnsw_configuration(
+    existing_hnsw_config: HNSWConfiguration, update_hnsw_config: UpdateHNSWConfiguration
+) -> HNSWConfiguration:
+    """Overwrite a HNSWConfiguration with a new configuration"""
+    # Create a copy of the existing config and update with new values
+    result = dict(existing_hnsw_config)
+    update_fields = [
+        "ef_search",
+        "num_threads",
+        "batch_size",
+        "sync_threshold",
+        "resize_factor",
+    ]
+
+    for field in update_fields:
+        if field in update_hnsw_config:
+            result[field] = update_hnsw_config[field]  # type: ignore
+
+    return cast(HNSWConfiguration, result)
+
+
+def overwrite_spann_configuration(
+    existing_spann_config: SpannConfiguration,
+    update_spann_config: UpdateSpannConfiguration,
+) -> SpannConfiguration:
+    """Overwrite a SpannConfiguration with a new configuration"""
+    result = dict(existing_spann_config)
+    update_fields = [
+        "search_nprobe",
+        "ef_search",
+    ]
+
+    for field in update_fields:
+        if field in update_spann_config:
+            result[field] = update_spann_config[field]  # type: ignore
+
+    return cast(SpannConfiguration, result)
+
+
+# TODO: make warnings prettier and add link to migration docs
+def overwrite_embedding_function(
+    existing_embedding_function: EmbeddingFunction,  # type: ignore
+    update_embedding_function: EmbeddingFunction,  # type: ignore
+) -> EmbeddingFunction:  # type: ignore
+    """Overwrite an EmbeddingFunction with a new configuration"""
+    # Check for legacy embedding functions
+    if existing_embedding_function.is_legacy() or update_embedding_function.is_legacy():
+        warnings.warn(
+            "cannot update legacy embedding function config",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return existing_embedding_function
+
+    # Validate function compatibility
+    if existing_embedding_function.name() != update_embedding_function.name():
+        raise ValueError(
+            f"Cannot update embedding function: incompatible types "
+            f"({existing_embedding_function.name()} vs {update_embedding_function.name()})"
+        )
+
+    # Validate and apply the configuration update
+    update_embedding_function.validate_config_update(
+        existing_embedding_function.get_config(), update_embedding_function.get_config()
+    )
+    return update_embedding_function
+
+
+def overwrite_collection_configuration(
+    existing_config: CollectionConfiguration,
+    update_config: UpdateCollectionConfiguration,
+) -> CollectionConfiguration:
+    """Overwrite a CollectionConfiguration with a new configuration"""
+    update_spann = update_config.get("spann")
+    update_hnsw = update_config.get("hnsw")
+    if update_spann is not None and update_hnsw is not None:
+        raise ValueError("hnsw and spann cannot both be provided")
+
+    # Handle HNSW configuration update
+
+    updated_hnsw_config = existing_config.get("hnsw")
+    if updated_hnsw_config is not None and update_hnsw is not None:
+        updated_hnsw_config = overwrite_hnsw_configuration(
+            updated_hnsw_config, update_hnsw
+        )
+
+    # Handle SPANN configuration update
+    updated_spann_config = existing_config.get("spann")
+    if updated_spann_config is not None and update_spann is not None:
+        updated_spann_config = overwrite_spann_configuration(
+            updated_spann_config, update_spann
+        )
+
+    # Handle embedding function update
+    updated_embedding_function = existing_config.get("embedding_function")
+    update_ef = update_config.get("embedding_function")
+    if update_ef is not None:
+        if updated_embedding_function is not None:
+            updated_embedding_function = overwrite_embedding_function(
+                updated_embedding_function, update_ef
+            )
+        else:
+            updated_embedding_function = update_ef
+
+    return CollectionConfiguration(
+        hnsw=updated_hnsw_config,
+        spann=updated_spann_config,
+        embedding_function=updated_embedding_function,
+    )
+
+
+def validate_embedding_function_conflict_on_create(
+    embedding_function: Optional[EmbeddingFunction],  # type: ignore
+    configuration_ef: Optional[EmbeddingFunction],  # type: ignore
+) -> None:
+    """
+    Validates that there are no conflicting embedding functions between function parameter
+    and collection configuration.
+
+    Args:
+        embedding_function: The embedding function provided as a parameter
+        configuration_ef: The embedding function from collection configuration
+
+    Returns:
+        bool: True if there is a conflict, False otherwise
+    """
+    # If ef provided in function params and collection config, check if they are the same
+    # If not, there's a conflict
+    # ef is by default "default" if not provided, so ignore that case.
+    if embedding_function is not None and configuration_ef is not None:
+        if (
+            embedding_function.name() != "default"
+            and embedding_function.name() != configuration_ef.name()
+        ):
+            raise ValueError(
+                f"Multiple embedding functions provided. Please provide only one. Embedding function conflict: {embedding_function.name()} vs {configuration_ef.name()}"
+            )
+    return None
+
+
+# The reason to use the config on get, rather than build the ef is because
+# if there is an issue with deserializing the config, an error shouldn't be raised
+# at get time. CollectionCommon.py will raise an error at _embed time if there is an issue deserializing.
+def validate_embedding_function_conflict_on_get(
+    embedding_function: Optional[EmbeddingFunction],  # type: ignore
+    persisted_ef_config: Optional[Dict[str, Any]],
+) -> None:
+    """
+    Validates that there are no conflicting embedding functions between function parameter
+    and collection configuration.
+    """
+    if persisted_ef_config is not None and embedding_function is not None:
+        if (
+            embedding_function.name() != "default"
+            and persisted_ef_config.get("name") is not None
+            and persisted_ef_config.get("name") != embedding_function.name()
+        ):
+            raise ValueError(
+                f"An embedding function already exists in the collection configuration, and a new one is provided. If this is intentional, please embed documents separately. Embedding function conflict: new: {embedding_function.name()} vs persisted: {persisted_ef_config.get('name')}"
+            )
+    return None
+
+
+def update_schema_from_collection_configuration(
+    schema: "Schema", configuration: "UpdateCollectionConfiguration"
+) -> "Schema":
+    """
+    Updates a schema with configuration changes.
+    Only updates fields that are present in the configuration update.
+
+    Args:
+        schema: The existing Schema object
+        configuration: The configuration updates to apply
+
+    Returns:
+        Updated Schema object
+    """
+
+    # Get the vector index from defaults and #embedding key
+    if (
+        schema.defaults.float_list is None
+        or schema.defaults.float_list.vector_index is None
+    ):
+        raise ValueError("Schema is missing defaults.float_list.vector_index")
+
+    embedding_key = "#embedding"
+    if embedding_key not in schema.keys:
+        raise ValueError(f"Schema is missing keys[{embedding_key}]")
+
+    embedding_value_types = schema.keys[embedding_key]
+    if (
+        embedding_value_types.float_list is None
+        or embedding_value_types.float_list.vector_index is None
+    ):
+        raise ValueError(
+            f"Schema is missing keys[{embedding_key}].float_list.vector_index"
+        )
+
+    # Update vector index config in both locations
+    for vector_index in [
+        schema.defaults.float_list.vector_index,
+        embedding_value_types.float_list.vector_index,
+    ]:
+        if "hnsw" in configuration and configuration["hnsw"] is not None:
+            # Update HNSW config
+            if vector_index.config.hnsw is None:
+                raise ValueError("Trying to update HNSW config but schema has SPANN")
+
+            hnsw_config = vector_index.config.hnsw
+            update_hnsw = configuration["hnsw"]
+
+            # Only update fields that are present in the update
+            if "ef_search" in update_hnsw:
+                hnsw_config.ef_search = update_hnsw["ef_search"]
+            if "num_threads" in update_hnsw:
+                hnsw_config.num_threads = update_hnsw["num_threads"]
+            if "batch_size" in update_hnsw:
+                hnsw_config.batch_size = update_hnsw["batch_size"]
+            if "sync_threshold" in update_hnsw:
+                hnsw_config.sync_threshold = update_hnsw["sync_threshold"]
+            if "resize_factor" in update_hnsw:
+                hnsw_config.resize_factor = update_hnsw["resize_factor"]
+
+        elif "spann" in configuration and configuration["spann"] is not None:
+            # Update SPANN config
+            if vector_index.config.spann is None:
+                raise ValueError("Trying to update SPANN config but schema has HNSW")
+
+            spann_config = vector_index.config.spann
+            update_spann = configuration["spann"]
+
+            # Only update fields that are present in the update
+            if "search_nprobe" in update_spann:
+                spann_config.search_nprobe = update_spann["search_nprobe"]
+            if "ef_search" in update_spann:
+                spann_config.ef_search = update_spann["ef_search"]
+
+        # Update embedding function if present
+        if (
+            "embedding_function" in configuration
+            and configuration["embedding_function"] is not None
+        ):
+            vector_index.config.embedding_function = configuration["embedding_function"]
+
+    return schema

python/user_packages/Python313/site-packages/chromadb/api/configuration.py

@@ -0,0 +1,410 @@
+from abc import abstractmethod
+import json
+from overrides import override
+from typing import (
+    Any,
+    ClassVar,
+    Dict,
+    List,
+    Optional,
+    Protocol,
+    Union,
+    TypeVar,
+    cast,
+)
+from typing_extensions import Self
+from multiprocessing import cpu_count
+
+from chromadb.serde import JSONSerializable
+
+# TODO: move out of API
+
+
+class StaticParameterError(Exception):
+    """Represents an error that occurs when a static parameter is set."""
+
+    pass
+
+
+class InvalidConfigurationError(ValueError):
+    """Represents an error that occurs when a configuration is invalid."""
+
+    pass
+
+
+ParameterValue = Union[str, int, float, bool, "ConfigurationInternal"]
+
+
+class ParameterValidator(Protocol):
+    """Represents an abstract parameter validator."""
+
+    @abstractmethod
+    def __call__(self, value: ParameterValue) -> bool:
+        """Returns whether the given value is valid."""
+        raise NotImplementedError()
+
+
+class ConfigurationDefinition:
+    """Represents the definition of a configuration."""
+
+    name: str
+    validator: ParameterValidator
+    is_static: bool
+    default_value: ParameterValue
+
+    def __init__(
+        self,
+        name: str,
+        validator: ParameterValidator,
+        is_static: bool,
+        default_value: ParameterValue,
+    ):
+        self.name = name
+        self.validator = validator
+        self.is_static = is_static
+        self.default_value = default_value
+
+
+class ConfigurationParameter:
+    """Represents a parameter of a configuration."""
+
+    name: str
+    value: ParameterValue
+
+    def __init__(self, name: str, value: ParameterValue):
+        self.name = name
+        self.value = value
+
+    def __repr__(self) -> str:
+        return f"ConfigurationParameter({self.name}, {self.value})"
+
+    def __eq__(self, __value: object) -> bool:
+        if not isinstance(__value, ConfigurationParameter):
+            return NotImplemented
+        return self.name == __value.name and self.value == __value.value
+
+
+T = TypeVar("T", bound="ConfigurationInternal")
+
+
+class ConfigurationInternal(JSONSerializable["ConfigurationInternal"]):
+    """Represents an abstract configuration, used internally by Chroma."""
+
+    # The internal data structure used to store the parameters
+    # All expected parameters must be present with defaults or None values at initialization
+    parameter_map: Dict[str, ConfigurationParameter]
+    definitions: ClassVar[Dict[str, ConfigurationDefinition]]
+
+    def __init__(self, parameters: Optional[List[ConfigurationParameter]] = None):
+        """Initializes a new instance of the Configuration class. Respecting defaults and
+        validators."""
+        self.parameter_map = {}
+        if parameters is not None:
+            for parameter in parameters:
+                if parameter.name not in self.definitions:
+                    raise ValueError(f"Invalid parameter name: {parameter.name}")
+
+                definition = self.definitions[parameter.name]
+                # Handle the case where we have a recursive configuration definition
+                if isinstance(parameter.value, dict):
+                    child_type = globals().get(parameter.value.get("_type", None))
+                    if child_type is None:
+                        raise ValueError(
+                            f"Invalid configuration type: {parameter.value}"
+                        )
+                    parameter.value = child_type.from_json(parameter.value)
+                if not isinstance(parameter.value, type(definition.default_value)):
+                    raise ValueError(f"Invalid parameter value: {parameter.value}")
+
+                parameter_validator = definition.validator
+                if not parameter_validator(parameter.value):
+                    raise ValueError(f"Invalid parameter value: {parameter.value}")
+                self.parameter_map[parameter.name] = parameter
+        # Apply the defaults for any missing parameters
+        for name, definition in self.definitions.items():
+            if name not in self.parameter_map:
+                self.parameter_map[name] = ConfigurationParameter(
+                    name=name, value=definition.default_value
+                )
+
+        self.configuration_validator()
+
+    def __repr__(self) -> str:
+        return f"Configuration({self.parameter_map.values()})"
+
+    def __eq__(self, __value: object) -> bool:
+        if not isinstance(__value, ConfigurationInternal):
+            return NotImplemented
+        return self.parameter_map == __value.parameter_map
+
+    @abstractmethod
+    def configuration_validator(self) -> None:
+        """Perform custom validation when parameters are dependent on each other.
+
+        Raises an InvalidConfigurationError if the configuration is invalid.
+        """
+        pass
+
+    def get_parameters(self) -> List[ConfigurationParameter]:
+        """Returns the parameters of the configuration."""
+        return list(self.parameter_map.values())
+
+    def get_parameter(self, name: str) -> ConfigurationParameter:
+        """Returns the parameter with the given name, or except if it doesn't exist."""
+        if name not in self.parameter_map:
+            raise ValueError(
+                f"Invalid parameter name: {name} for configuration {self.__class__.__name__}"
+            )
+        param_value = cast(ConfigurationParameter, self.parameter_map.get(name))
+        return param_value
+
+    def set_parameter(self, name: str, value: Union[str, int, float, bool]) -> None:
+        """Sets the parameter with the given name to the given value."""
+        if name not in self.definitions:
+            raise ValueError(f"Invalid parameter name: {name}")
+        definition = self.definitions[name]
+        parameter = self.parameter_map[name]
+        if definition.is_static:
+            raise StaticParameterError(f"Cannot set static parameter: {name}")
+        if not definition.validator(value):
+            raise ValueError(f"Invalid value for parameter {name}: {value}")
+        parameter.value = value
+
+    @override
+    def to_json_str(self) -> str:
+        """Returns the JSON representation of the configuration."""
+        return json.dumps(self.to_json())
+
+    @classmethod
+    @override
+    def from_json_str(cls, json_str: str) -> Self:
+        """Returns a configuration from the given JSON string."""
+        try:
+            config_json = json.loads(json_str)
+        except json.JSONDecodeError:
+            raise ValueError(
+                f"Unable to decode configuration from JSON string: {json_str}"
+            )
+        return cls.from_json(config_json) if config_json else cls()
+
+    @override
+    def to_json(self) -> Dict[str, Any]:
+        """Returns the JSON compatible dictionary representation of the configuration."""
+        json_dict = {
+            name: parameter.value.to_json()
+            if isinstance(parameter.value, ConfigurationInternal)
+            else parameter.value
+            for name, parameter in self.parameter_map.items()
+        }
+        # What kind of configuration is this?
+        json_dict["_type"] = self.__class__.__name__
+        return json_dict
+
+    @classmethod
+    @override
+    def from_json(cls, json_map: Dict[str, Any]) -> Self:
+        """Returns a configuration from the given JSON string."""
+        if cls.__name__ != json_map.get("_type", None):
+            raise ValueError(
+                f"Trying to instantiate configuration of type {cls.__name__} from JSON with type {json_map['_type']}"
+            )
+        parameters = []
+        for name, value in json_map.items():
+            # Type value is only for storage
+            if name == "_type":
+                continue
+            parameters.append(ConfigurationParameter(name=name, value=value))
+        return cls(parameters=parameters)
+
+
+class HNSWConfigurationInternal(ConfigurationInternal):
+    """Internal representation of the HNSW configuration.
+    Used for validation, defaults, serialization and deserialization."""
+
+    definitions = {
+        "space": ConfigurationDefinition(
+            name="space",
+            validator=lambda value: isinstance(value, str)
+            and value in ["l2", "ip", "cosine"],
+            is_static=True,
+            default_value="l2",
+        ),
+        "ef_construction": ConfigurationDefinition(
+            name="ef_construction",
+            validator=lambda value: isinstance(value, int) and value >= 1,
+            is_static=True,
+            default_value=100,
+        ),
+        "ef_search": ConfigurationDefinition(
+            name="ef_search",
+            validator=lambda value: isinstance(value, int) and value >= 1,
+            is_static=False,
+            default_value=100,
+        ),
+        "num_threads": ConfigurationDefinition(
+            name="num_threads",
+            validator=lambda value: isinstance(value, int) and value >= 1,
+            is_static=False,
+            default_value=cpu_count(),  # By default use all cores available
+        ),
+        "M": ConfigurationDefinition(
+            name="M",
+            validator=lambda value: isinstance(value, int) and value >= 1,
+            is_static=True,
+            default_value=16,
+        ),
+        "resize_factor": ConfigurationDefinition(
+            name="resize_factor",
+            validator=lambda value: isinstance(value, float) and value >= 1,
+            is_static=True,
+            default_value=1.2,
+        ),
+        "batch_size": ConfigurationDefinition(
+            name="batch_size",
+            validator=lambda value: isinstance(value, int) and value >= 1,
+            is_static=True,
+            default_value=100,
+        ),
+        "sync_threshold": ConfigurationDefinition(
+            name="sync_threshold",
+            validator=lambda value: isinstance(value, int) and value >= 1,
+            is_static=True,
+            default_value=1000,
+        ),
+    }
+
+    @override
+    def configuration_validator(self) -> None:
+        batch_size = self.parameter_map.get("batch_size")
+        sync_threshold = self.parameter_map.get("sync_threshold")
+
+        if (
+            batch_size
+            and sync_threshold
+            and cast(int, batch_size.value) > cast(int, sync_threshold.value)
+        ):
+            raise InvalidConfigurationError(
+                "batch_size must be less than or equal to sync_threshold"
+            )
+
+    @classmethod
+    def from_legacy_params(cls, params: Dict[str, Any]) -> Self:
+        """Returns an HNSWConfiguration from a metadata dict containing legacy HNSW parameters. Used for migration."""
+
+        # We maintain this map to avoid a circular import with HnswParams, and
+        # because then names won't change since we intend to deprecate HNSWParams
+        # in favor of this type of configuration.
+        old_to_new = {
+            "hnsw:space": "space",
+            "hnsw:construction_ef": "ef_construction",
+            "hnsw:search_ef": "ef_search",
+            "hnsw:M": "M",
+            "hnsw:num_threads": "num_threads",
+            "hnsw:resize_factor": "resize_factor",
+            "hnsw:batch_size": "batch_size",
+            "hnsw:sync_threshold": "sync_threshold",
+        }
+
+        parameters = []
+        for name, value in params.items():
+            if name not in old_to_new:
+                raise ValueError(f"Invalid legacy HNSW parameter name: {name}")
+            parameters.append(
+                ConfigurationParameter(name=old_to_new[name], value=value)
+            )
+        return cls(parameters)
+
+
+# This is the user-facing interface for HNSW index configuration parameters.
+# Internally, we pass around HNSWConfigurationInternal objects, which perform
+# validation, serialization and deserialization. Users don't need to know
+# about that and instead get a clean constructor with default arguments.
+class HNSWConfigurationInterface(HNSWConfigurationInternal):
+    """HNSW index configuration parameters.
+    See https://docs.trychroma.com/guides#changing-the-distance-function for more information.
+    """
+
+    def __init__(
+        self,
+        space: str = "l2",
+        ef_construction: int = 100,
+        ef_search: int = 100,
+        num_threads: int = cpu_count(),
+        M: int = 16,
+        resize_factor: float = 1.2,
+        batch_size: int = 100,
+        sync_threshold: int = 1000,
+    ):
+        parameters = [
+            ConfigurationParameter(name="space", value=space),
+            ConfigurationParameter(name="ef_construction", value=ef_construction),
+            ConfigurationParameter(name="ef_search", value=ef_search),
+            ConfigurationParameter(name="num_threads", value=num_threads),
+            ConfigurationParameter(name="M", value=M),
+            ConfigurationParameter(name="resize_factor", value=resize_factor),
+            ConfigurationParameter(name="batch_size", value=batch_size),
+            ConfigurationParameter(name="sync_threshold", value=sync_threshold),
+        ]
+
+        super().__init__(parameters=parameters)
+
+
+# Alias for user convenience - the user doesn't need to know this is an 'Interface'
+HNSWConfiguration = HNSWConfigurationInterface
+
+
+class CollectionConfigurationInternal(ConfigurationInternal):
+    """Internal representation of the collection configuration.
+    Used for validation, defaults, and serialization / deserialization."""
+
+    definitions = {
+        "hnsw_configuration": ConfigurationDefinition(
+            name="hnsw_configuration",
+            validator=lambda value: isinstance(value, HNSWConfigurationInternal),
+            is_static=True,
+            default_value=HNSWConfigurationInternal(),
+        ),
+    }
+
+    @override
+    def configuration_validator(self) -> None:
+        pass
+
+
+# This is the user-facing interface for HNSW index configuration parameters.
+# Internally, we pass around HNSWConfigurationInternal objects, which perform
+# validation, serialization and deserialization. Users don't need to know
+# about that and instead get a clean constructor with default arguments.
+class CollectionConfigurationInterface(CollectionConfigurationInternal):
+    """Configuration parameters for creating a collection."""
+
+    def __init__(self, hnsw_configuration: Optional[HNSWConfigurationInternal]):
+        """Initializes a new instance of the CollectionConfiguration class.
+        Args:
+            hnsw_configuration: The HNSW configuration to use for the collection.
+        """
+        if hnsw_configuration is None:
+            hnsw_configuration = HNSWConfigurationInternal()
+        parameters = [
+            ConfigurationParameter(name="hnsw_configuration", value=hnsw_configuration)
+        ]
+        super().__init__(parameters=parameters)
+
+
+# Alias for user convenience - the user doesn't need to know this is an 'Interface'.
+CollectionConfiguration = CollectionConfigurationInterface
+
+
+class EmbeddingsQueueConfigurationInternal(ConfigurationInternal):
+    definitions = {
+        "automatically_purge": ConfigurationDefinition(
+            name="automatically_purge",
+            validator=lambda value: isinstance(value, bool),
+            is_static=False,
+            default_value=True,
+        ),
+    }
+
+    @override
+    def configuration_validator(self) -> None:
+        pass

python/user_packages/Python313/site-packages/chromadb/api/fastapi.py

@@ -0,0 +1,915 @@
+import orjson
+import logging
+from typing import Any, Dict, Mapping, Optional, cast, Tuple, List
+from typing import Sequence
+from uuid import UUID
+import httpx
+import urllib.parse
+from overrides import override
+
+from chromadb.api.models.AttachedFunction import AttachedFunction
+
+from chromadb.api.collection_configuration import (
+    CreateCollectionConfiguration,
+    UpdateCollectionConfiguration,
+    update_collection_configuration_to_json,
+    create_collection_configuration_to_json,
+)
+from chromadb import __version__
+from chromadb.api.base_http_client import BaseHTTPClient
+from chromadb.types import Database, Tenant, Collection as CollectionModel
+from chromadb.api import ServerAPI
+from chromadb.execution.expression.plan import Search
+
+from chromadb.api.types import (
+    DeleteResult,
+    Documents,
+    Embeddings,
+    IDs,
+    Include,
+    IndexingStatus,
+    Schema,
+    Metadatas,
+    ReadLevel,
+    URIs,
+    Where,
+    WhereDocument,
+    GetResult,
+    QueryResult,
+    SearchResult,
+    CollectionMetadata,
+    validate_batch,
+    convert_np_embeddings_to_list,
+    IncludeMetadataDocuments,
+    IncludeMetadataDocumentsDistances,
+)
+
+from chromadb.api.types import (
+    IncludeMetadataDocumentsEmbeddings,
+    optional_embeddings_to_base64_strings,
+    serialize_metadata,
+    deserialize_metadata,
+)
+from chromadb.auth import UserIdentity
+from chromadb.auth import (
+    ClientAuthProvider,
+)
+from chromadb.config import DEFAULT_DATABASE, DEFAULT_TENANT, Settings, System
+from chromadb.telemetry.opentelemetry import (
+    OpenTelemetryClient,
+    OpenTelemetryGranularity,
+    trace_method,
+)
+from chromadb.telemetry.product import ProductTelemetryClient
+
+logger = logging.getLogger(__name__)
+
+
+class FastAPI(BaseHTTPClient, ServerAPI):
+    def __init__(self, system: System):
+        super().__init__(system)
+        system.settings.require("chroma_server_host")
+        system.settings.require("chroma_server_http_port")
+
+        self._opentelemetry_client = self.require(OpenTelemetryClient)
+        self._product_telemetry_client = self.require(ProductTelemetryClient)
+        self._settings = system.settings
+
+        self._api_url = FastAPI.resolve_url(
+            chroma_server_host=str(system.settings.chroma_server_host),
+            chroma_server_http_port=system.settings.chroma_server_http_port,
+            chroma_server_ssl_enabled=system.settings.chroma_server_ssl_enabled,
+            default_api_path=system.settings.chroma_server_api_default_path,
+        )
+
+        if self._settings.chroma_server_ssl_verify is not None:
+            self._session = httpx.Client(
+                timeout=None,
+                limits=self.http_limits,
+                verify=self._settings.chroma_server_ssl_verify,
+            )
+        else:
+            self._session = httpx.Client(timeout=None, limits=self.http_limits)
+
+        self._header = system.settings.chroma_server_headers or {}
+        self._header["Content-Type"] = "application/json"
+        self._header["User-Agent"] = (
+            "Chroma Python Client v"
+            + __version__
+            + " (https://github.com/chroma-core/chroma)"
+        )
+
+        if self._header is not None:
+            self._session.headers.update(self._header)
+
+        if system.settings.chroma_client_auth_provider:
+            self._auth_provider = self.require(ClientAuthProvider)
+            _headers = self._auth_provider.authenticate()
+            for header, value in _headers.items():
+                self._session.headers[header] = value.get_secret_value()
+
+    @override
+    def get_request_headers(self) -> Mapping[str, str]:
+        return dict(self._session.headers)
+
+    @override
+    def get_api_url(self) -> str:
+        return self._api_url
+
+    def _make_request(self, method: str, path: str, **kwargs: Dict[str, Any]) -> Any:
+        # If the request has json in kwargs, use orjson to serialize it,
+        # remove it from kwargs, and add it to the content parameter
+        # This is because httpx uses a slower json serializer
+        if "json" in kwargs:
+            data = orjson.dumps(kwargs.pop("json"), option=orjson.OPT_SERIALIZE_NUMPY)
+            kwargs["content"] = data
+
+        # Unlike requests, httpx does not automatically escape the path
+        escaped_path = urllib.parse.quote(path, safe="/", encoding=None, errors=None)
+        url = self._api_url + escaped_path
+
+        response = self._session.request(method, url, **cast(Any, kwargs))
+        BaseHTTPClient._raise_chroma_error(response)
+        return orjson.loads(response.text)
+
+    @trace_method("FastAPI.heartbeat", OpenTelemetryGranularity.OPERATION)
+    @override
+    def heartbeat(self) -> int:
+        """Returns the current server time in nanoseconds to check if the server is alive"""
+        resp_json = self._make_request("get", "/heartbeat")
+        return int(resp_json["nanosecond heartbeat"])
+
+    # Migrated to rust in distributed.
+    @trace_method("FastAPI.create_database", OpenTelemetryGranularity.OPERATION)
+    @override
+    def create_database(
+        self,
+        name: str,
+        tenant: str = DEFAULT_TENANT,
+    ) -> None:
+        """Creates a database"""
+        self._make_request(
+            "post",
+            f"/tenants/{tenant}/databases",
+            json={"name": name},
+        )
+
+    # Migrated to rust in distributed.
+    @trace_method("FastAPI.get_database", OpenTelemetryGranularity.OPERATION)
+    @override
+    def get_database(
+        self,
+        name: str,
+        tenant: str = DEFAULT_TENANT,
+    ) -> Database:
+        """Returns a database"""
+        resp_json = self._make_request(
+            "get",
+            f"/tenants/{tenant}/databases/{name}",
+        )
+        return Database(
+            id=resp_json["id"], name=resp_json["name"], tenant=resp_json["tenant"]
+        )
+
+    @trace_method("FastAPI.delete_database", OpenTelemetryGranularity.OPERATION)
+    @override
+    def delete_database(
+        self,
+        name: str,
+        tenant: str = DEFAULT_TENANT,
+    ) -> None:
+        """Deletes a database"""
+        self._make_request(
+            "delete",
+            f"/tenants/{tenant}/databases/{name}",
+        )
+
+    @trace_method("FastAPI.list_databases", OpenTelemetryGranularity.OPERATION)
+    @override
+    def list_databases(
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        tenant: str = DEFAULT_TENANT,
+    ) -> Sequence[Database]:
+        """Returns a list of all databases"""
+        json_databases = self._make_request(
+            "get",
+            f"/tenants/{tenant}/databases",
+            params=BaseHTTPClient._clean_params(
+                {
+                    "limit": limit,
+                    "offset": offset,
+                }
+            ),
+        )
+        databases = [
+            Database(id=db["id"], name=db["name"], tenant=db["tenant"])
+            for db in json_databases
+        ]
+        return databases
+
+    @trace_method("FastAPI.create_tenant", OpenTelemetryGranularity.OPERATION)
+    @override
+    def create_tenant(self, name: str) -> None:
+        self._make_request("post", "/tenants", json={"name": name})
+
+    @trace_method("FastAPI.get_tenant", OpenTelemetryGranularity.OPERATION)
+    @override
+    def get_tenant(self, name: str) -> Tenant:
+        resp_json = self._make_request("get", "/tenants/" + name)
+        return Tenant(name=resp_json["name"])
+
+    @trace_method("FastAPI.get_user_identity", OpenTelemetryGranularity.OPERATION)
+    @override
+    def get_user_identity(self) -> UserIdentity:
+        return UserIdentity(**self._make_request("get", "/auth/identity"))
+
+    @trace_method("FastAPI.list_collections", OpenTelemetryGranularity.OPERATION)
+    @override
+    def list_collections(
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> Sequence[CollectionModel]:
+        """Returns a list of all collections"""
+        json_collections = self._make_request(
+            "get",
+            f"/tenants/{tenant}/databases/{database}/collections",
+            params=BaseHTTPClient._clean_params(
+                {
+                    "limit": limit,
+                    "offset": offset,
+                }
+            ),
+        )
+        collection_models = [
+            CollectionModel.from_json(json_collection)
+            for json_collection in json_collections
+        ]
+
+        return collection_models
+
+    @trace_method("FastAPI.count_collections", OpenTelemetryGranularity.OPERATION)
+    @override
+    def count_collections(
+        self, tenant: str = DEFAULT_TENANT, database: str = DEFAULT_DATABASE
+    ) -> int:
+        """Returns a count of collections"""
+        resp_json = self._make_request(
+            "get",
+            f"/tenants/{tenant}/databases/{database}/collections_count",
+        )
+        return cast(int, resp_json)
+
+    @trace_method("FastAPI.create_collection", OpenTelemetryGranularity.OPERATION)
+    @override
+    def create_collection(
+        self,
+        name: str,
+        schema: Optional[Schema] = None,
+        configuration: Optional[CreateCollectionConfiguration] = None,
+        metadata: Optional[CollectionMetadata] = None,
+        get_or_create: bool = False,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        """Creates a collection"""
+        config_json = (
+            create_collection_configuration_to_json(configuration, metadata)
+            if configuration
+            else None
+        )
+        serialized_schema = schema.serialize_to_json() if schema else None
+        resp_json = self._make_request(
+            "post",
+            f"/tenants/{tenant}/databases/{database}/collections",
+            json={
+                "name": name,
+                "metadata": metadata,
+                "configuration": config_json,
+                "schema": serialized_schema,
+                "get_or_create": get_or_create,
+            },
+        )
+        model = CollectionModel.from_json(resp_json)
+
+        return model
+
+    @trace_method("FastAPI.get_collection", OpenTelemetryGranularity.OPERATION)
+    @override
+    def get_collection(
+        self,
+        name: str,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        """Returns a collection"""
+        resp_json = self._make_request(
+            "get",
+            f"/tenants/{tenant}/databases/{database}/collections/{name}",
+        )
+
+        model = CollectionModel.from_json(resp_json)
+        return model
+
+    @trace_method("FastAPI.get_collection_by_id", OpenTelemetryGranularity.OPERATION)
+    @override
+    def get_collection_by_id(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        """Returns a collection by its ID"""
+        resp_json = self._make_request(
+            "get",
+            f"/tenants/{tenant}/databases/{database}/collections/by-id/{collection_id}",
+        )
+
+        model = CollectionModel.from_json(resp_json)
+        return model
+
+    @trace_method(
+        "FastAPI.get_or_create_collection", OpenTelemetryGranularity.OPERATION
+    )
+    @override
+    def get_or_create_collection(
+        self,
+        name: str,
+        schema: Optional[Schema] = None,
+        configuration: Optional[CreateCollectionConfiguration] = None,
+        metadata: Optional[CollectionMetadata] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        return self.create_collection(
+            name=name,
+            metadata=metadata,
+            configuration=configuration,
+            schema=schema,
+            get_or_create=True,
+            tenant=tenant,
+            database=database,
+        )
+
+    @trace_method("FastAPI._modify", OpenTelemetryGranularity.OPERATION)
+    @override
+    def _modify(
+        self,
+        id: UUID,
+        new_name: Optional[str] = None,
+        new_metadata: Optional[CollectionMetadata] = None,
+        new_configuration: Optional[UpdateCollectionConfiguration] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> None:
+        """Updates a collection"""
+        self._make_request(
+            "put",
+            f"/tenants/{tenant}/databases/{database}/collections/{id}",
+            json={
+                "new_metadata": new_metadata,
+                "new_name": new_name,
+                "new_configuration": update_collection_configuration_to_json(
+                    new_configuration
+                )
+                if new_configuration
+                else None,
+            },
+        )
+
+    @trace_method("FastAPI._fork", OpenTelemetryGranularity.OPERATION)
+    @override
+    def _fork(
+        self,
+        collection_id: UUID,
+        new_name: str,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        """Forks a collection"""
+        resp_json = self._make_request(
+            "post",
+            f"/tenants/{tenant}/databases/{database}/collections/{collection_id}/fork",
+            json={"new_name": new_name},
+        )
+        model = CollectionModel.from_json(resp_json)
+        return model
+
+    @trace_method("FastAPI._fork_count", OpenTelemetryGranularity.OPERATION)
+    @override
+    def _fork_count(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> int:
+        """Gets the number of forks for a collection"""
+        resp_json = self._make_request(
+            "get",
+            f"/tenants/{tenant}/databases/{database}/collections/{collection_id}/fork_count",
+        )
+        return int(resp_json["count"])
+
+    @trace_method("FastAPI._get_indexing_status", OpenTelemetryGranularity.OPERATION)
+    @override
+    def _get_indexing_status(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> IndexingStatus:
+        resp_json = self._make_request(
+            "get",
+            f"/tenants/{tenant}/databases/{database}/collections/{collection_id}/indexing_status",
+        )
+        return IndexingStatus(
+            num_indexed_ops=resp_json["num_indexed_ops"],
+            num_unindexed_ops=resp_json["num_unindexed_ops"],
+            total_ops=resp_json["total_ops"],
+            op_indexing_progress=resp_json["op_indexing_progress"],
+        )
+
+    @trace_method("FastAPI._search", OpenTelemetryGranularity.OPERATION)
+    @override
+    def _search(
+        self,
+        collection_id: UUID,
+        searches: List[Search],
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+        read_level: ReadLevel = ReadLevel.INDEX_AND_WAL,
+    ) -> SearchResult:
+        """Performs hybrid search on a collection"""
+        # Convert Search objects to dictionaries
+        payload = {
+            "searches": [s.to_dict() for s in searches],
+            "read_level": read_level,
+        }
+
+        resp_json = self._make_request(
+            "post",
+            f"/tenants/{tenant}/databases/{database}/collections/{collection_id}/search",
+            json=payload,
+        )
+
+        # Deserialize metadatas: convert transport format to SparseVector instances
+        metadata_batches = resp_json.get("metadatas", None)
+        if metadata_batches is not None:
+            # SearchResult has nested structure: List[Optional[List[Optional[Metadata]]]]
+            resp_json["metadatas"] = [
+                [
+                    deserialize_metadata(metadata) if metadata is not None else None
+                    for metadata in metadatas
+                ]
+                if metadatas is not None
+                else None
+                for metadatas in metadata_batches
+            ]
+
+        return SearchResult(resp_json)
+
+    @trace_method("FastAPI.delete_collection", OpenTelemetryGranularity.OPERATION)
+    @override
+    def delete_collection(
+        self,
+        name: str,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> None:
+        """Deletes a collection"""
+        self._make_request(
+            "delete",
+            f"/tenants/{tenant}/databases/{database}/collections/{name}",
+        )
+
+    @trace_method("FastAPI._count", OpenTelemetryGranularity.OPERATION)
+    @override
+    def _count(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+        read_level: ReadLevel = ReadLevel.INDEX_AND_WAL,
+    ) -> int:
+        """Returns the number of embeddings in the database"""
+        resp_json = self._make_request(
+            "get",
+            f"/tenants/{tenant}/databases/{database}/collections/{collection_id}/count",
+            params={"read_level": read_level.value},
+        )
+        return cast(int, resp_json)
+
+    @trace_method("FastAPI._peek", OpenTelemetryGranularity.OPERATION)
+    @override
+    def _peek(
+        self,
+        collection_id: UUID,
+        n: int = 10,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> GetResult:
+        return cast(
+            GetResult,
+            self._get(
+                collection_id,
+                tenant=tenant,
+                database=database,
+                limit=n,
+                include=IncludeMetadataDocumentsEmbeddings,
+            ),
+        )
+
+    @trace_method("FastAPI._get", OpenTelemetryGranularity.OPERATION)
+    @override
+    def _get(
+        self,
+        collection_id: UUID,
+        ids: Optional[IDs] = None,
+        where: Optional[Where] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        where_document: Optional[WhereDocument] = None,
+        include: Include = IncludeMetadataDocuments,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> GetResult:
+        # Servers do not support receiving "data", as that is hydrated by the client as a loadable
+        filtered_include = [i for i in include if i != "data"]
+
+        resp_json = self._make_request(
+            "post",
+            f"/tenants/{tenant}/databases/{database}/collections/{collection_id}/get",
+            json={
+                "ids": ids,
+                "where": where,
+                "limit": limit,
+                "offset": offset,
+                "where_document": where_document,
+                "include": filtered_include,
+            },
+        )
+
+        # Deserialize metadatas: convert transport format to SparseVector instances
+        metadatas = resp_json.get("metadatas", None)
+        if metadatas is not None:
+            metadatas = [
+                deserialize_metadata(metadata) if metadata is not None else None
+                for metadata in metadatas
+            ]
+
+        return GetResult(
+            ids=resp_json["ids"],
+            embeddings=resp_json.get("embeddings", None),
+            metadatas=metadatas,
+            documents=resp_json.get("documents", None),
+            data=None,
+            uris=resp_json.get("uris", None),
+            included=include,
+        )
+
+    @trace_method("FastAPI._delete", OpenTelemetryGranularity.OPERATION)
+    @override
+    def _delete(
+        self,
+        collection_id: UUID,
+        ids: Optional[IDs] = None,
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        limit: Optional[int] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> DeleteResult:
+        """Deletes embeddings from the database"""
+        body: dict = {
+            "ids": ids,
+            "where": where,
+            "where_document": where_document,
+        }
+        if limit is not None:
+            body["limit"] = limit
+        resp = self._make_request(
+            "post",
+            f"/tenants/{tenant}/databases/{database}/collections/{collection_id}/delete",
+            json=body,
+        )
+        return DeleteResult(deleted=resp.get("deleted", 0) if resp else 0)
+
+    @trace_method("FastAPI._submit_batch", OpenTelemetryGranularity.ALL)
+    def _submit_batch(
+        self,
+        batch: Tuple[
+            IDs,
+            Optional[Embeddings],
+            Optional[Metadatas],
+            Optional[Documents],
+            Optional[URIs],
+        ],
+        url: str,
+    ) -> None:
+        """
+        Submits a batch of embeddings to the database
+        """
+        # Serialize metadatas: convert SparseVector instances to transport format
+        serialized_metadatas = None
+        if batch[2] is not None:
+            serialized_metadatas = [
+                serialize_metadata(metadata) if metadata is not None else None
+                for metadata in batch[2]
+            ]
+
+        data = {
+            "ids": batch[0],
+            "embeddings": optional_embeddings_to_base64_strings(batch[1])
+            if self.supports_base64_encoding()
+            else batch[1],
+            "metadatas": serialized_metadatas,
+            "documents": batch[3],
+            "uris": batch[4],
+        }
+
+        self._make_request("post", url, json=data)
+
+    @trace_method("FastAPI._add", OpenTelemetryGranularity.ALL)
+    @override
+    def _add(
+        self,
+        ids: IDs,
+        collection_id: UUID,
+        embeddings: Embeddings,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        """
+        Adds a batch of embeddings to the database
+        - pass in column oriented data lists
+        """
+        batch = (
+            ids,
+            embeddings,
+            metadatas,
+            documents,
+            uris,
+        )
+        validate_batch(batch, {"max_batch_size": self.get_max_batch_size()})
+        self._submit_batch(
+            batch,
+            f"/tenants/{tenant}/databases/{database}/collections/{str(collection_id)}/add",
+        )
+        return True
+
+    @trace_method("FastAPI._update", OpenTelemetryGranularity.ALL)
+    @override
+    def _update(
+        self,
+        collection_id: UUID,
+        ids: IDs,
+        embeddings: Optional[Embeddings] = None,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        """
+        Updates a batch of embeddings in the database
+        - pass in column oriented data lists
+        """
+        batch = (
+            ids,
+            embeddings if embeddings is not None else None,
+            metadatas,
+            documents,
+            uris,
+        )
+        validate_batch(batch, {"max_batch_size": self.get_max_batch_size()})
+        self._submit_batch(
+            batch,
+            f"/tenants/{tenant}/databases/{database}/collections/{str(collection_id)}/update",
+        )
+        return True
+
+    @trace_method("FastAPI._upsert", OpenTelemetryGranularity.ALL)
+    @override
+    def _upsert(
+        self,
+        collection_id: UUID,
+        ids: IDs,
+        embeddings: Embeddings,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        """
+        Upserts a batch of embeddings in the database
+        - pass in column oriented data lists
+        """
+        batch = (
+            ids,
+            embeddings,
+            metadatas,
+            documents,
+            uris,
+        )
+        validate_batch(batch, {"max_batch_size": self.get_max_batch_size()})
+        self._submit_batch(
+            batch,
+            f"/tenants/{tenant}/databases/{database}/collections/{str(collection_id)}/upsert",
+        )
+        return True
+
+    @trace_method("FastAPI._query", OpenTelemetryGranularity.ALL)
+    @override
+    def _query(
+        self,
+        collection_id: UUID,
+        query_embeddings: Embeddings,
+        ids: Optional[IDs] = None,
+        n_results: int = 10,
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        include: Include = IncludeMetadataDocumentsDistances,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> QueryResult:
+        # Clients do not support receiving "data", as that is hydrated by the client as a loadable
+        filtered_include = [i for i in include if i != "data"]
+
+        """Gets the nearest neighbors of a single embedding"""
+        resp_json = self._make_request(
+            "post",
+            f"/tenants/{tenant}/databases/{database}/collections/{collection_id}/query",
+            json={
+                "ids": ids,
+                "query_embeddings": convert_np_embeddings_to_list(query_embeddings)
+                if query_embeddings is not None
+                else None,
+                "n_results": n_results,
+                "where": where,
+                "where_document": where_document,
+                "include": filtered_include,
+            },
+        )
+
+        # Deserialize metadatas: convert transport format to SparseVector instances
+        metadata_batches = resp_json.get("metadatas", None)
+        if metadata_batches is not None:
+            metadata_batches = [
+                [
+                    deserialize_metadata(metadata) if metadata is not None else None
+                    for metadata in metadatas
+                ]
+                if metadatas is not None
+                else None
+                for metadatas in metadata_batches
+            ]
+
+        return QueryResult(
+            ids=resp_json["ids"],
+            distances=resp_json.get("distances", None),
+            embeddings=resp_json.get("embeddings", None),
+            metadatas=metadata_batches,
+            documents=resp_json.get("documents", None),
+            uris=resp_json.get("uris", None),
+            data=None,
+            included=include,
+        )
+
+    @trace_method("FastAPI.reset", OpenTelemetryGranularity.ALL)
+    @override
+    def reset(self) -> bool:
+        """Resets the database"""
+        resp_json = self._make_request("post", "/reset")
+        return cast(bool, resp_json)
+
+    @trace_method("FastAPI.get_version", OpenTelemetryGranularity.OPERATION)
+    @override
+    def get_version(self) -> str:
+        """Returns the version of the server"""
+        resp_json = self._make_request("get", "/version")
+        return cast(str, resp_json)
+
+    @override
+    def get_settings(self) -> Settings:
+        """Returns the settings of the client"""
+        return self._settings
+
+    @trace_method("FastAPI.get_pre_flight_checks", OpenTelemetryGranularity.OPERATION)
+    def get_pre_flight_checks(self) -> Any:
+        if self.pre_flight_checks is None:
+            resp_json = self._make_request("get", "/pre-flight-checks")
+            self.pre_flight_checks = resp_json
+        return self.pre_flight_checks
+
+    @trace_method(
+        "FastAPI.supports_base64_encoding", OpenTelemetryGranularity.OPERATION
+    )
+    def supports_base64_encoding(self) -> bool:
+        pre_flight_checks = self.get_pre_flight_checks()
+        b64_encoding_enabled = cast(
+            bool, pre_flight_checks.get("supports_base64_encoding", False)
+        )
+        return b64_encoding_enabled
+
+    @trace_method("FastAPI.get_max_batch_size", OpenTelemetryGranularity.OPERATION)
+    @override
+    def get_max_batch_size(self) -> int:
+        pre_flight_checks = self.get_pre_flight_checks()
+        max_batch_size = cast(int, pre_flight_checks.get("max_batch_size", -1))
+        return max_batch_size
+
+    @trace_method("FastAPI.attach_function", OpenTelemetryGranularity.ALL)
+    @override
+    def attach_function(
+        self,
+        function_id: str,
+        name: str,
+        input_collection_id: UUID,
+        output_collection: str,
+        params: Optional[Dict[str, Any]] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> Tuple["AttachedFunction", bool]:
+        """Attach a function to a collection."""
+        resp_json = self._make_request(
+            "post",
+            f"/tenants/{tenant}/databases/{database}/collections/{input_collection_id}/functions/attach",
+            json={
+                "name": name,
+                "function_id": function_id,
+                "output_collection": output_collection,
+                "params": params,
+            },
+        )
+
+        attached_function = AttachedFunction(
+            client=self,
+            id=UUID(resp_json["attached_function"]["id"]),
+            name=resp_json["attached_function"]["name"],
+            function_name=resp_json["attached_function"]["function_name"],
+            input_collection_id=input_collection_id,
+            output_collection=output_collection,
+            params=params,
+            tenant=tenant,
+            database=database,
+        )
+        created = resp_json.get(
+            "created", True
+        )  # Default to True for backwards compatibility
+        return (attached_function, created)
+
+    @trace_method("FastAPI.get_attached_function", OpenTelemetryGranularity.ALL)
+    @override
+    def get_attached_function(
+        self,
+        name: str,
+        input_collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> "AttachedFunction":
+        """Get an attached function by name for a specific collection."""
+        resp_json = self._make_request(
+            "get",
+            f"/tenants/{tenant}/databases/{database}/collections/{input_collection_id}/functions/{name}",
+        )
+
+        af = resp_json["attached_function"]
+        return AttachedFunction(
+            client=self,
+            id=UUID(af["id"]),
+            name=af["name"],
+            function_name=af["function_name"],
+            input_collection_id=input_collection_id,
+            output_collection=af["output_collection"],
+            params=af.get("params"),
+            tenant=tenant,
+            database=database,
+        )
+
+    @trace_method("FastAPI.detach_function", OpenTelemetryGranularity.ALL)
+    @override
+    def detach_function(
+        self,
+        name: str,
+        input_collection_id: UUID,
+        delete_output: bool = False,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        """Detach a function and prevent any further runs."""
+        resp_json = self._make_request(
+            "post",
+            f"/tenants/{tenant}/databases/{database}/collections/{input_collection_id}/attached_functions/{name}/detach",
+            json={
+                "delete_output": delete_output,
+            },
+        )
+        return cast(bool, resp_json["success"])

python/user_packages/Python313/site-packages/chromadb/api/functions.py

@@ -0,0 +1,33 @@
+"""Attachable function definitions for ChromaDB collections.
+
+This module provides function constants that can be attached to collections
+to perform automatic computations on collection data.
+
+Example:
+    >>> from chromadb.api.functions import STATISTICS_FUNCTION
+    >>> attached_fn = collection.attach_function(
+    ...     function=STATISTICS_FUNCTION,
+    ...     name="my_stats",
+    ...     output_collection="my_stats_output"
+    ... )
+"""
+
+from enum import Enum
+
+
+class Function(str, Enum):
+    """Available functions that can be attached to collections."""
+
+    STATISTICS = "statistics"
+    """Computes metadata value frequencies for a collection."""
+
+    RECORD_COUNTER = "record_counter"
+    """Counts records in a collection."""
+
+    # Used only for failure testing - not a real function
+    _NONEXISTENT_TEST_ONLY = "nonexistent_function"
+
+
+# Convenience aliases for cleaner imports
+STATISTICS_FUNCTION = Function.STATISTICS
+RECORD_COUNTER_FUNCTION = Function.RECORD_COUNTER

python/user_packages/Python313/site-packages/chromadb/api/rust.py

@@ -0,0 +1,704 @@
+from typing import TYPE_CHECKING
+
+from chromadb import (
+    CollectionMetadata,
+    Embeddings,
+    GetResult,
+    IDs,
+    Where,
+    WhereDocument,
+    Include,
+    Documents,
+    Metadatas,
+    QueryResult,
+    URIs,
+)
+from chromadb.api import ServerAPI
+
+if TYPE_CHECKING:
+    from chromadb.api.models.AttachedFunction import AttachedFunction
+from chromadb.api.collection_configuration import (
+    CreateCollectionConfiguration,
+    UpdateCollectionConfiguration,
+    create_collection_configuration_to_json_str,
+    update_collection_configuration_to_json_str,
+)
+from chromadb.auth import UserIdentity
+from chromadb.config import DEFAULT_DATABASE, DEFAULT_TENANT, Settings, System
+from chromadb.telemetry.product import ProductTelemetryClient
+from chromadb.telemetry.product.events import (
+    CollectionAddEvent,
+    CollectionDeleteEvent,
+    CollectionGetEvent,
+    CollectionUpdateEvent,
+    CollectionQueryEvent,
+    ClientCreateCollectionEvent,
+)
+
+from chromadb.api.types import (
+    DeleteResult,
+    IncludeMetadataDocuments,
+    IncludeMetadataDocumentsDistances,
+    IncludeMetadataDocumentsEmbeddings,
+    ReadLevel,
+    Schema,
+    SearchResult,
+)
+
+# TODO(hammadb): Unify imports across types vs root __init__.py
+from chromadb.types import Database, Tenant, Collection as CollectionModel
+from chromadb.execution.expression.plan import Search
+import chromadb_rust_bindings
+
+
+from typing import Optional, Sequence, List, Dict, Any, Tuple
+from overrides import override
+from uuid import UUID
+import json
+import platform
+
+if platform.system() != "Windows":
+    import resource
+elif platform.system() == "Windows":
+    import ctypes
+
+
+# RustBindingsAPI is an implementation of ServerAPI which shims
+# the Rust bindings to the Python API, providing a full implementation
+# of the API. It could be that bindings was a direct implementation of
+# ServerAPI, but in order to prevent propagating the bindings types
+# into the Python API, we have to shim it here so we can convert into
+# the legacy Python types.
+# TODO(hammadb): Propagate the types from the bindings into the Python API
+# and remove the python-level types entirely.
+class RustBindingsAPI(ServerAPI):
+    bindings: chromadb_rust_bindings.Bindings
+    hnsw_cache_size: int
+    product_telemetry_client: ProductTelemetryClient
+
+    def __init__(self, system: System):
+        super().__init__(system)
+        self.product_telemetry_client = self.require(ProductTelemetryClient)
+
+        if platform.system() != "Windows":
+            max_file_handles = resource.getrlimit(resource.RLIMIT_NOFILE)[0]
+        else:
+            max_file_handles = ctypes.windll.msvcrt._getmaxstdio()  # type: ignore
+        self.hnsw_cache_size = (
+            max_file_handles
+            # This is integer division in Python 3, and not a comment.
+            # Each HNSW index has 4 data files and 1 metadata file
+            // 5
+        )
+
+    @override
+    def start(self) -> None:
+        # Construct the SqliteConfig
+        # TOOD: We should add a "config converter"
+        if self._system.settings.require("is_persistent"):
+            persist_path = self._system.settings.require("persist_directory")
+            sqlite_persist_path = persist_path + "/chroma.sqlite3"
+        else:
+            persist_path = None
+            sqlite_persist_path = None
+        hash_type = self._system.settings.require("migrations_hash_algorithm")
+        hash_type_bindings = (
+            chromadb_rust_bindings.MigrationHash.MD5
+            if hash_type == "md5"
+            else chromadb_rust_bindings.MigrationHash.SHA256
+        )
+        migration_mode = self._system.settings.require("migrations")
+        migration_mode_bindings = (
+            chromadb_rust_bindings.MigrationMode.Apply
+            if migration_mode == "apply"
+            else chromadb_rust_bindings.MigrationMode.Validate
+        )
+        sqlite_config = chromadb_rust_bindings.SqliteDBConfig(
+            hash_type=hash_type_bindings,
+            migration_mode=migration_mode_bindings,
+            url=sqlite_persist_path,
+        )
+
+        self.bindings = chromadb_rust_bindings.Bindings(
+            allow_reset=self._system.settings.require("allow_reset"),
+            sqlite_db_config=sqlite_config,
+            persist_path=persist_path,
+            hnsw_cache_size=self.hnsw_cache_size,
+        )
+
+    @override
+    def stop(self) -> None:
+        del self.bindings
+
+    # ////////////////////////////// Admin API //////////////////////////////
+
+    @override
+    def create_database(self, name: str, tenant: str = DEFAULT_TENANT) -> None:
+        return self.bindings.create_database(name, tenant)
+
+    @override
+    def get_database(self, name: str, tenant: str = DEFAULT_TENANT) -> Database:
+        database = self.bindings.get_database(name, tenant)
+        return {
+            "id": database.id,
+            "name": database.name,
+            "tenant": database.tenant,
+        }
+
+    @override
+    def delete_database(self, name: str, tenant: str = DEFAULT_TENANT) -> None:
+        return self.bindings.delete_database(name, tenant)
+
+    @override
+    def list_databases(
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        tenant: str = DEFAULT_TENANT,
+    ) -> Sequence[Database]:
+        databases = self.bindings.list_databases(limit, offset, tenant)
+        return [
+            {
+                "id": database.id,
+                "name": database.name,
+                "tenant": database.tenant,
+            }
+            for database in databases
+        ]
+
+    @override
+    def create_tenant(self, name: str) -> None:
+        return self.bindings.create_tenant(name)
+
+    @override
+    def get_tenant(self, name: str) -> Tenant:
+        tenant = self.bindings.get_tenant(name)
+        return Tenant(name=tenant.name)
+
+    # ////////////////////////////// Base API //////////////////////////////
+
+    @override
+    def heartbeat(self) -> int:
+        return self.bindings.heartbeat()
+
+    @override
+    def count_collections(
+        self, tenant: str = DEFAULT_TENANT, database: str = DEFAULT_DATABASE
+    ) -> int:
+        return self.bindings.count_collections(tenant, database)
+
+    @override
+    def list_collections(
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> Sequence[CollectionModel]:
+        collections = self.bindings.list_collections(limit, offset, tenant, database)
+        return [
+            CollectionModel(
+                id=collection.id,
+                name=collection.name,
+                serialized_schema=collection.schema,
+                configuration_json=collection.configuration,
+                metadata=collection.metadata,
+                dimension=collection.dimension,
+                tenant=collection.tenant,
+                database=collection.database,
+            )
+            for collection in collections
+        ]
+
+    @override
+    def create_collection(
+        self,
+        name: str,
+        schema: Optional[Schema] = None,
+        configuration: Optional[CreateCollectionConfiguration] = None,
+        metadata: Optional[CollectionMetadata] = None,
+        get_or_create: bool = False,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        # TODO: This event doesn't capture the get_or_create case appropriately
+        # TODO: Re-enable embedding function tracking in create_collection
+        self.product_telemetry_client.capture(
+            ClientCreateCollectionEvent(
+                collection_uuid=str(id),
+                # embedding_function=embedding_function.__class__.__name__,
+            )
+        )
+        if configuration:
+            configuration_json_str = create_collection_configuration_to_json_str(
+                configuration, metadata
+            )
+        else:
+            configuration_json_str = None
+
+        if schema:
+            schema_str = json.dumps(schema.serialize_to_json())
+        else:
+            schema_str = None
+
+        collection = self.bindings.create_collection(
+            name,
+            configuration_json_str,
+            schema_str,
+            metadata,
+            get_or_create,
+            tenant,
+            database,
+        )
+        collection_model = CollectionModel(
+            id=collection.id,
+            name=collection.name,
+            configuration_json=collection.configuration,
+            serialized_schema=collection.schema,
+            metadata=collection.metadata,
+            dimension=collection.dimension,
+            tenant=collection.tenant,
+            database=collection.database,
+        )
+        return collection_model
+
+    @override
+    def get_collection(
+        self,
+        name: str,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        collection = self.bindings.get_collection(name, tenant, database)
+        return CollectionModel(
+            id=collection.id,
+            name=collection.name,
+            configuration_json=collection.configuration,
+            serialized_schema=collection.schema,
+            metadata=collection.metadata,
+            dimension=collection.dimension,
+            tenant=collection.tenant,
+            database=collection.database,
+        )
+
+    @override
+    def get_collection_by_id(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        collection = self.bindings.get_collection_by_id(str(collection_id), tenant, database)
+        return CollectionModel(
+            id=collection.id,
+            name=collection.name,
+            configuration_json=collection.configuration,
+            serialized_schema=collection.schema,
+            metadata=collection.metadata,
+            dimension=collection.dimension,
+            tenant=collection.tenant,
+            database=collection.database,
+        )
+
+    @override
+    def get_or_create_collection(
+        self,
+        name: str,
+        schema: Optional[Schema] = None,
+        configuration: Optional[CreateCollectionConfiguration] = None,
+        metadata: Optional[CollectionMetadata] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        return self.create_collection(
+            name, schema, configuration, metadata, True, tenant, database
+        )
+
+    @override
+    def delete_collection(
+        self,
+        name: str,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> None:
+        self.bindings.delete_collection(name, tenant, database)
+
+    @override
+    def _modify(
+        self,
+        id: UUID,
+        new_name: Optional[str] = None,
+        new_metadata: Optional[CollectionMetadata] = None,
+        new_configuration: Optional[UpdateCollectionConfiguration] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> None:
+        if new_configuration:
+            new_configuration_json_str = update_collection_configuration_to_json_str(
+                new_configuration
+            )
+        else:
+            new_configuration_json_str = None
+        self.bindings.update_collection(
+            str(id), new_name, new_metadata, new_configuration_json_str
+        )
+
+    @override
+    def _fork(
+        self,
+        collection_id: UUID,
+        new_name: str,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        raise NotImplementedError(
+            "Collection forking is not implemented for Local Chroma"
+        )
+
+    @override
+    def _fork_count(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> int:
+        raise NotImplementedError(
+            "Fork count is not implemented for Local Chroma"
+        )
+
+    @override
+    def _get_indexing_status(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> "IndexingStatus":
+        raise NotImplementedError("Indexing status is not implemented for Local Chroma")
+
+    @override
+    def _search(
+        self,
+        collection_id: UUID,
+        searches: List[Search],
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+        read_level: ReadLevel = ReadLevel.INDEX_AND_WAL,
+    ) -> SearchResult:
+        raise NotImplementedError("Search is not implemented for Local Chroma")
+
+    @override
+    def _count(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+        read_level: ReadLevel = ReadLevel.INDEX_AND_WAL,
+    ) -> int:
+        return self.bindings.count(str(collection_id), tenant, database)
+
+    @override
+    def _peek(
+        self,
+        collection_id: UUID,
+        n: int = 10,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> GetResult:
+        return self._get(
+            collection_id,
+            limit=n,
+            tenant=tenant,
+            database=database,
+            include=IncludeMetadataDocumentsEmbeddings,
+        )
+
+    @override
+    def _get(
+        self,
+        collection_id: UUID,
+        ids: Optional[IDs] = None,
+        where: Optional[Where] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        where_document: Optional[WhereDocument] = None,
+        include: Include = IncludeMetadataDocuments,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> GetResult:
+        ids_amount = len(ids) if ids else 0
+        self.product_telemetry_client.capture(
+            CollectionGetEvent(
+                collection_uuid=str(collection_id),
+                ids_count=ids_amount,
+                limit=limit if limit else 0,
+                include_metadata=ids_amount if "metadatas" in include else 0,
+                include_documents=ids_amount if "documents" in include else 0,
+                include_uris=ids_amount if "uris" in include else 0,
+            )
+        )
+
+        rust_response = self.bindings.get(
+            str(collection_id),
+            ids,
+            json.dumps(where) if where else None,
+            limit,
+            offset or 0,
+            json.dumps(where_document) if where_document else None,
+            include,
+            tenant,
+            database,
+        )
+
+        return GetResult(
+            ids=rust_response.ids,
+            embeddings=rust_response.embeddings,
+            documents=rust_response.documents,
+            uris=rust_response.uris,
+            included=include,
+            data=None,
+            metadatas=rust_response.metadatas,
+        )
+
+    @override
+    def _add(
+        self,
+        ids: IDs,
+        collection_id: UUID,
+        embeddings: Embeddings,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        self.product_telemetry_client.capture(
+            CollectionAddEvent(
+                collection_uuid=str(collection_id),
+                add_amount=len(ids),
+                with_metadata=len(ids) if metadatas is not None else 0,
+                with_documents=len(ids) if documents is not None else 0,
+                with_uris=len(ids) if uris is not None else 0,
+            )
+        )
+
+        return self.bindings.add(
+            ids,
+            str(collection_id),
+            embeddings,
+            metadatas,
+            documents,
+            uris,
+            tenant,
+            database,
+        )
+
+    @override
+    def _update(
+        self,
+        collection_id: UUID,
+        ids: IDs,
+        embeddings: Optional[Embeddings] = None,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        self.product_telemetry_client.capture(
+            CollectionUpdateEvent(
+                collection_uuid=str(collection_id),
+                update_amount=len(ids),
+                with_embeddings=len(embeddings) if embeddings else 0,
+                with_metadata=len(metadatas) if metadatas else 0,
+                with_documents=len(documents) if documents else 0,
+                with_uris=len(uris) if uris else 0,
+            )
+        )
+
+        return self.bindings.update(
+            str(collection_id),
+            ids,
+            embeddings,
+            metadatas,
+            documents,
+            uris,
+            tenant,
+            database,
+        )
+
+    @override
+    def _upsert(
+        self,
+        collection_id: UUID,
+        ids: IDs,
+        embeddings: Embeddings,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        return self.bindings.upsert(
+            str(collection_id),
+            ids,
+            embeddings,
+            metadatas,
+            documents,
+            uris,
+            tenant,
+            database,
+        )
+
+    @override
+    def _query(
+        self,
+        collection_id: UUID,
+        query_embeddings: Embeddings,
+        ids: Optional[IDs] = None,
+        n_results: int = 10,
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        include: Include = IncludeMetadataDocumentsDistances,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> QueryResult:
+        query_amount = len(query_embeddings)
+        filtered_ids_amount = len(ids) if ids else 0
+        self.product_telemetry_client.capture(
+            CollectionQueryEvent(
+                collection_uuid=str(collection_id),
+                query_amount=query_amount,
+                filtered_ids_amount=filtered_ids_amount,
+                n_results=n_results,
+                with_metadata_filter=query_amount if where is not None else 0,
+                with_document_filter=query_amount if where_document is not None else 0,
+                include_metadatas=query_amount if "metadatas" in include else 0,
+                include_documents=query_amount if "documents" in include else 0,
+                include_uris=query_amount if "uris" in include else 0,
+                include_distances=query_amount if "distances" in include else 0,
+            )
+        )
+
+        rust_response = self.bindings.query(
+            str(collection_id),
+            ids,
+            query_embeddings,
+            n_results,
+            json.dumps(where) if where else None,
+            json.dumps(where_document) if where_document else None,
+            include,
+            tenant,
+            database,
+        )
+
+        return QueryResult(
+            ids=rust_response.ids,
+            embeddings=rust_response.embeddings,
+            documents=rust_response.documents,
+            uris=rust_response.uris,
+            included=include,
+            data=None,
+            metadatas=rust_response.metadatas,
+            distances=rust_response.distances,
+        )
+
+    @override
+    def _delete(
+        self,
+        collection_id: UUID,
+        ids: Optional[IDs] = None,
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        limit: Optional[int] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> DeleteResult:
+        deleted = self.bindings.delete(
+            str(collection_id),
+            ids,
+            json.dumps(where) if where else None,
+            json.dumps(where_document) if where_document else None,
+            limit,
+            tenant,
+            database,
+        )
+
+        self.product_telemetry_client.capture(
+            CollectionDeleteEvent(
+                collection_uuid=str(collection_id),
+                delete_amount=deleted,
+            )
+        )
+
+        return DeleteResult(deleted=deleted)
+
+    @override
+    def reset(self) -> bool:
+        return self.bindings.reset()
+
+    @override
+    def get_version(self) -> str:
+        return self.bindings.get_version()
+
+    @override
+    def get_settings(self) -> Settings:
+        return self._system.settings
+
+    @override
+    def get_max_batch_size(self) -> int:
+        return self.bindings.get_max_batch_size()
+
+    @override
+    def attach_function(
+        self,
+        function_id: str,
+        name: str,
+        input_collection_id: UUID,
+        output_collection: str,
+        params: Optional[Dict[str, Any]] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> Tuple["AttachedFunction", bool]:
+        """Attached functions are not supported in the Rust bindings (local embedded mode)."""
+        raise NotImplementedError(
+            "Attached functions are only supported when connecting to a Chroma server via HttpClient. "
+            "The Rust bindings (embedded mode) do not support attached function operations."
+        )
+
+    @override
+    def get_attached_function(
+        self,
+        name: str,
+        input_collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> "AttachedFunction":
+        """Attached functions are not supported in the Rust bindings (local embedded mode)."""
+        raise NotImplementedError(
+            "Attached functions are only supported when connecting to a Chroma server via HttpClient. "
+            "The Rust bindings (embedded mode) do not support attached function operations."
+        )
+
+    @override
+    def detach_function(
+        self,
+        name: str,
+        input_collection_id: UUID,
+        delete_output: bool = False,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        """Attached functions are not supported in the Rust bindings (local embedded mode)."""
+        raise NotImplementedError(
+            "Attached functions are only supported when connecting to a Chroma server via HttpClient. "
+            "The Rust bindings (embedded mode) do not support attached function operations."
+        )
+
+    # TODO: Remove this if it's not planned to be used
+    @override
+    def get_user_identity(self) -> UserIdentity:
+        return UserIdentity(
+            user_id="",
+            tenant=DEFAULT_TENANT,
+            databases=[DEFAULT_DATABASE],
+        )

python/user_packages/Python313/site-packages/chromadb/api/segment.py

@@ -0,0 +1,1127 @@
+from typing import TYPE_CHECKING
+
+from tenacity import retry, stop_after_attempt, retry_if_exception, wait_fixed
+from chromadb.api import ServerAPI
+
+if TYPE_CHECKING:
+    from chromadb.api.models.AttachedFunction import AttachedFunction
+from chromadb.api.collection_configuration import (
+    CreateCollectionConfiguration,
+    UpdateCollectionConfiguration,
+    create_collection_configuration_to_json,
+)
+from chromadb.auth import UserIdentity
+from chromadb.config import DEFAULT_DATABASE, DEFAULT_TENANT, Settings, System
+from chromadb.db.system import SysDB
+from chromadb.quota import QuotaEnforcer, Action
+from chromadb.rate_limit import RateLimitEnforcer
+from chromadb.segment import SegmentManager
+from chromadb.execution.executor.abstract import Executor
+from chromadb.execution.expression.operator import Scan, Filter, Limit, KNN, Projection
+from chromadb.execution.expression.plan import CountPlan, GetPlan, KNNPlan
+from chromadb.telemetry.opentelemetry import (
+    add_attributes_to_current_span,
+    OpenTelemetryClient,
+    OpenTelemetryGranularity,
+    trace_method,
+)
+from chromadb.telemetry.product import ProductTelemetryClient
+from chromadb.ingest import Producer
+from chromadb.types import Collection as CollectionModel
+from chromadb import __version__
+from chromadb.errors import (
+    InvalidDimensionException,
+    NotFoundError,
+    VersionMismatchError,
+)
+from chromadb.api.types import (
+    CollectionMetadata,
+    IDs,
+    Embeddings,
+    Metadatas,
+    Documents,
+    ReadLevel,
+    Schema,
+    URIs,
+    Where,
+    WhereDocument,
+    Include,
+    GetResult,
+    QueryResult,
+    SearchResult,
+    validate_metadata,
+    validate_update_metadata,
+    validate_where,
+    validate_where_document,
+    validate_batch,
+    IncludeMetadataDocuments,
+    IncludeMetadataDocumentsDistances,
+    DeleteResult,
+)
+from chromadb.telemetry.product.events import (
+    CollectionAddEvent,
+    CollectionDeleteEvent,
+    CollectionGetEvent,
+    CollectionUpdateEvent,
+    CollectionQueryEvent,
+    ClientCreateCollectionEvent,
+)
+
+import chromadb.types as t
+from typing import (
+    Optional,
+    Sequence,
+    Generator,
+    List,
+    Any,
+    Dict,
+    Callable,
+    TypeVar,
+    Tuple,
+)
+from overrides import override
+from uuid import UUID, uuid4
+from functools import wraps
+import time
+import logging
+import re
+from chromadb.execution.expression.plan import Search
+
+T = TypeVar("T", bound=Callable[..., Any])
+
+logger = logging.getLogger(__name__)
+
+
+# mimics s3 bucket requirements for naming
+def check_index_name(index_name: str) -> None:
+    msg = (
+        "Expected collection name that "
+        "(1) contains 3-63 characters, "
+        "(2) starts and ends with an alphanumeric character, "
+        "(3) otherwise contains only alphanumeric characters, underscores or hyphens (-), "
+        "(4) contains no two consecutive periods (..) and "
+        "(5) is not a valid IPv4 address, "
+        f"got {index_name}"
+    )
+    if len(index_name) < 3 or len(index_name) > 63:
+        raise ValueError(msg)
+    if not re.match("^[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9]$", index_name):
+        raise ValueError(msg)
+    if ".." in index_name:
+        raise ValueError(msg)
+    if re.match("^[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}$", index_name):
+        raise ValueError(msg)
+
+
+def rate_limit(func: T) -> T:
+    @wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        self = args[0]
+        return self._rate_limit_enforcer.rate_limit(func)(*args, **kwargs)
+
+    return wrapper  # type: ignore
+
+
+class SegmentAPI(ServerAPI):
+    """API implementation utilizing the new segment-based internal architecture"""
+
+    _settings: Settings
+    _sysdb: SysDB
+    _manager: SegmentManager
+    _executor: Executor
+    _producer: Producer
+    _product_telemetry_client: ProductTelemetryClient
+    _opentelemetry_client: OpenTelemetryClient
+    _tenant_id: str
+    _topic_ns: str
+    _rate_limit_enforcer: RateLimitEnforcer
+
+    def __init__(self, system: System):
+        super().__init__(system)
+        self._settings = system.settings
+        self._sysdb = self.require(SysDB)
+        self._manager = self.require(SegmentManager)
+        self._executor = self.require(Executor)
+        self._quota_enforcer = self.require(QuotaEnforcer)
+        self._product_telemetry_client = self.require(ProductTelemetryClient)
+        self._opentelemetry_client = self.require(OpenTelemetryClient)
+        self._producer = self.require(Producer)
+        self._rate_limit_enforcer = self._system.require(RateLimitEnforcer)
+
+    @override
+    def heartbeat(self) -> int:
+        return int(time.time_ns())
+
+    @trace_method("SegmentAPI.create_database", OpenTelemetryGranularity.OPERATION)
+    @override
+    def create_database(self, name: str, tenant: str = DEFAULT_TENANT) -> None:
+        if len(name) < 3:
+            raise ValueError("Database name must be at least 3 characters long")
+
+        self._quota_enforcer.enforce(
+            action=Action.CREATE_DATABASE,
+            tenant=tenant,
+            name=name,
+        )
+
+        self._sysdb.create_database(
+            id=uuid4(),
+            name=name,
+            tenant=tenant,
+        )
+
+    @trace_method("SegmentAPI.get_database", OpenTelemetryGranularity.OPERATION)
+    @override
+    def get_database(self, name: str, tenant: str = DEFAULT_TENANT) -> t.Database:
+        return self._sysdb.get_database(name=name, tenant=tenant)
+
+    @trace_method("SegmentAPI.delete_database", OpenTelemetryGranularity.OPERATION)
+    @override
+    def delete_database(self, name: str, tenant: str = DEFAULT_TENANT) -> None:
+        self._sysdb.delete_database(name=name, tenant=tenant)
+
+    @trace_method("SegmentAPI.list_databases", OpenTelemetryGranularity.OPERATION)
+    @override
+    def list_databases(
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        tenant: str = DEFAULT_TENANT,
+    ) -> Sequence[t.Database]:
+        return self._sysdb.list_databases(limit=limit, offset=offset, tenant=tenant)
+
+    @trace_method("SegmentAPI.create_tenant", OpenTelemetryGranularity.OPERATION)
+    @override
+    def create_tenant(self, name: str) -> None:
+        if len(name) < 3:
+            raise ValueError("Tenant name must be at least 3 characters long")
+
+        self._sysdb.create_tenant(
+            name=name,
+        )
+
+    @override
+    def get_user_identity(self) -> UserIdentity:
+        return UserIdentity(
+            user_id="",
+            tenant=DEFAULT_TENANT,
+            databases=[DEFAULT_DATABASE],
+        )
+
+    @trace_method("SegmentAPI.get_tenant", OpenTelemetryGranularity.OPERATION)
+    @override
+    def get_tenant(self, name: str) -> t.Tenant:
+        return self._sysdb.get_tenant(name=name)
+
+    # TODO: Actually fix CollectionMetadata type to remove type: ignore flags. This is
+    # necessary because changing the value type from `Any` to`` `Union[str, int, float]`
+    # causes the system to somehow convert all values to strings.
+    @trace_method("SegmentAPI.create_collection", OpenTelemetryGranularity.OPERATION)
+    @override
+    @rate_limit
+    def create_collection(
+        self,
+        name: str,
+        schema: Optional[Schema] = None,
+        configuration: Optional[CreateCollectionConfiguration] = None,
+        metadata: Optional[CollectionMetadata] = None,
+        get_or_create: bool = False,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        if metadata is not None:
+            validate_metadata(metadata)
+
+        # TODO: remove backwards compatibility in naming requirements
+        check_index_name(name)
+
+        self._quota_enforcer.enforce(
+            action=Action.CREATE_COLLECTION,
+            tenant=tenant,
+            name=name,
+            metadata=metadata,
+        )
+
+        id = uuid4()
+
+        model = CollectionModel(
+            id=id,
+            name=name,
+            metadata=metadata,
+            serialized_schema=None,
+            configuration_json=create_collection_configuration_to_json(
+                configuration or CreateCollectionConfiguration(), metadata
+            ),
+            tenant=tenant,
+            database=database,
+            dimension=None,
+        )
+
+        # TODO: Let sysdb create the collection directly from the model
+        coll, created = self._sysdb.create_collection(
+            id=model.id,
+            name=model.name,
+            schema=schema,
+            configuration=configuration or CreateCollectionConfiguration(),
+            segments=[],  # Passing empty till backend changes are deployed.
+            metadata=model.metadata,
+            dimension=None,  # This is lazily populated on the first add
+            get_or_create=get_or_create,
+            tenant=tenant,
+            database=database,
+        )
+
+        if created:
+            segments = self._manager.prepare_segments_for_new_collection(coll)
+            for segment in segments:
+                self._sysdb.create_segment(segment)
+        else:
+            logger.debug(
+                f"Collection {name} already exists, returning existing collection."
+            )
+
+        # TODO: This event doesn't capture the get_or_create case appropriately
+        # TODO: Re-enable embedding function tracking in create_collection
+        self._product_telemetry_client.capture(
+            ClientCreateCollectionEvent(
+                collection_uuid=str(id),
+                # embedding_function=embedding_function.__class__.__name__,
+            )
+        )
+        add_attributes_to_current_span({"collection_uuid": str(id)})
+
+        return coll
+
+    @trace_method(
+        "SegmentAPI.get_or_create_collection", OpenTelemetryGranularity.OPERATION
+    )
+    @override
+    @rate_limit
+    def get_or_create_collection(
+        self,
+        name: str,
+        schema: Optional[Schema] = None,
+        configuration: Optional[CreateCollectionConfiguration] = None,
+        metadata: Optional[CollectionMetadata] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        return self.create_collection(
+            name=name,
+            schema=schema,
+            metadata=metadata,
+            configuration=configuration,
+            get_or_create=True,
+            tenant=tenant,
+            database=database,
+        )
+
+    # TODO: Actually fix CollectionMetadata type to remove type: ignore flags. This is
+    # necessary because changing the value type from `Any` to`` `Union[str, int, float]`
+    # causes the system to somehow convert all values to strings
+    @trace_method("SegmentAPI.get_collection", OpenTelemetryGranularity.OPERATION)
+    @override
+    @rate_limit
+    def get_collection(
+        self,
+        name: Optional[str] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        existing = self._sysdb.get_collections(
+            name=name, tenant=tenant, database=database
+        )
+
+        if existing:
+            return existing[0]
+        else:
+            raise NotFoundError(f"Collection {name} does not exist.")
+
+    @trace_method("SegmentAPI.get_collection_by_id", OpenTelemetryGranularity.OPERATION)
+    @override
+    @rate_limit
+    def get_collection_by_id(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        existing = self._sysdb.get_collections(
+            id=collection_id, tenant=tenant, database=database
+        )
+
+        if existing:
+            return existing[0]
+        else:
+            raise NotFoundError(f"Collection {collection_id} does not exist.")
+
+    @trace_method("SegmentAPI.list_collection", OpenTelemetryGranularity.OPERATION)
+    @override
+    @rate_limit
+    def list_collections(
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> Sequence[CollectionModel]:
+        self._quota_enforcer.enforce(
+            action=Action.LIST_COLLECTIONS,
+            tenant=tenant,
+            limit=limit,
+        )
+
+        return self._sysdb.get_collections(
+            limit=limit, offset=offset, tenant=tenant, database=database
+        )
+
+    @trace_method("SegmentAPI.count_collections", OpenTelemetryGranularity.OPERATION)
+    @override
+    @rate_limit
+    def count_collections(
+        self,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> int:
+        return self._sysdb.count_collections(tenant=tenant, database=database)
+
+    @trace_method("SegmentAPI._modify", OpenTelemetryGranularity.OPERATION)
+    @override
+    @rate_limit
+    def _modify(
+        self,
+        id: UUID,
+        new_name: Optional[str] = None,
+        new_metadata: Optional[CollectionMetadata] = None,
+        new_configuration: Optional[UpdateCollectionConfiguration] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> None:
+        if new_name:
+            # backwards compatibility in naming requirements (for now)
+            check_index_name(new_name)
+
+        if new_metadata:
+            validate_update_metadata(new_metadata)
+
+        # Ensure the collection exists
+        _ = self._get_collection(id)
+
+        self._quota_enforcer.enforce(
+            action=Action.UPDATE_COLLECTION,
+            tenant=tenant,
+            name=new_name,
+            metadata=new_metadata,
+        )
+
+        # TODO eventually we'll want to use OptionalArgument and Unspecified in the
+        # signature of `_modify` but not changing the API right now.
+        if new_name and new_metadata and new_configuration:
+            self._sysdb.update_collection(
+                id,
+                name=new_name,
+                metadata=new_metadata,
+                configuration=new_configuration,
+            )
+        elif new_name and new_metadata:
+            self._sysdb.update_collection(id, name=new_name, metadata=new_metadata)
+        elif new_name and new_configuration:
+            self._sysdb.update_collection(
+                id, name=new_name, configuration=new_configuration
+            )
+        elif new_metadata and new_configuration:
+            self._sysdb.update_collection(
+                id, metadata=new_metadata, configuration=new_configuration
+            )
+        elif new_name:
+            self._sysdb.update_collection(id, name=new_name)
+        elif new_metadata:
+            self._sysdb.update_collection(id, metadata=new_metadata)
+        elif new_configuration:
+            self._sysdb.update_collection(id, configuration=new_configuration)
+
+    @override
+    def _fork(
+        self,
+        collection_id: UUID,
+        new_name: str,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> CollectionModel:
+        raise NotImplementedError(
+            "Collection forking is not implemented for SegmentAPI"
+        )
+
+    @override
+    def _fork_count(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> int:
+        raise NotImplementedError(
+            "Fork count is not implemented for SegmentAPI"
+        )
+
+    @override
+    def _get_indexing_status(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> "IndexingStatus":
+        raise NotImplementedError("Indexing status is not implemented for SegmentAPI")
+
+    @override
+    def _search(
+        self,
+        collection_id: UUID,
+        searches: List[Search],
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+        read_level: ReadLevel = ReadLevel.INDEX_AND_WAL,
+    ) -> SearchResult:
+        raise NotImplementedError("Search is not implemented for SegmentAPI")
+
+    @trace_method("SegmentAPI.delete_collection", OpenTelemetryGranularity.OPERATION)
+    @override
+    @rate_limit
+    def delete_collection(
+        self,
+        name: str,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> None:
+        existing = self._sysdb.get_collections(
+            name=name, tenant=tenant, database=database
+        )
+
+        if existing:
+            self._manager.delete_segments(existing[0].id)
+            self._sysdb.delete_collection(
+                existing[0].id, tenant=tenant, database=database
+            )
+        else:
+            raise ValueError(f"Collection {name} does not exist.")
+
+    @trace_method("SegmentAPI._add", OpenTelemetryGranularity.OPERATION)
+    @override
+    @rate_limit
+    def _add(
+        self,
+        ids: IDs,
+        collection_id: UUID,
+        embeddings: Embeddings,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        coll = self._get_collection(collection_id)
+        self._manager.hint_use_collection(collection_id, t.Operation.ADD)
+        validate_batch(
+            (ids, embeddings, metadatas, documents, uris),
+            {"max_batch_size": self.get_max_batch_size()},
+        )
+        records_to_submit = list(
+            _records(
+                t.Operation.ADD,
+                ids=ids,
+                embeddings=embeddings,
+                metadatas=metadatas,
+                documents=documents,
+                uris=uris,
+            )
+        )
+        self._validate_embedding_record_set(coll, records_to_submit)
+
+        self._quota_enforcer.enforce(
+            action=Action.ADD,
+            tenant=tenant,
+            ids=ids,
+            embeddings=embeddings,
+            metadatas=metadatas,
+            documents=documents,
+            uris=uris,
+            collection_id=collection_id,
+        )
+
+        self._producer.submit_embeddings(collection_id, records_to_submit)
+
+        self._product_telemetry_client.capture(
+            CollectionAddEvent(
+                collection_uuid=str(collection_id),
+                add_amount=len(ids),
+                with_metadata=len(ids) if metadatas is not None else 0,
+                with_documents=len(ids) if documents is not None else 0,
+                with_uris=len(ids) if uris is not None else 0,
+            )
+        )
+        return True
+
+    @trace_method("SegmentAPI._update", OpenTelemetryGranularity.OPERATION)
+    @override
+    @rate_limit
+    def _update(
+        self,
+        collection_id: UUID,
+        ids: IDs,
+        embeddings: Optional[Embeddings] = None,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        coll = self._get_collection(collection_id)
+        self._manager.hint_use_collection(collection_id, t.Operation.UPDATE)
+        validate_batch(
+            (ids, embeddings, metadatas, documents, uris),
+            {"max_batch_size": self.get_max_batch_size()},
+        )
+        records_to_submit = list(
+            _records(
+                t.Operation.UPDATE,
+                ids=ids,
+                embeddings=embeddings,
+                metadatas=metadatas,
+                documents=documents,
+                uris=uris,
+            )
+        )
+        self._validate_embedding_record_set(coll, records_to_submit)
+
+        self._quota_enforcer.enforce(
+            action=Action.UPDATE,
+            tenant=tenant,
+            ids=ids,
+            embeddings=embeddings,
+            metadatas=metadatas,
+            documents=documents,
+            uris=uris,
+        )
+
+        self._producer.submit_embeddings(collection_id, records_to_submit)
+
+        self._product_telemetry_client.capture(
+            CollectionUpdateEvent(
+                collection_uuid=str(collection_id),
+                update_amount=len(ids),
+                with_embeddings=len(embeddings) if embeddings else 0,
+                with_metadata=len(metadatas) if metadatas else 0,
+                with_documents=len(documents) if documents else 0,
+                with_uris=len(uris) if uris else 0,
+            )
+        )
+
+        return True
+
+    @trace_method("SegmentAPI._upsert", OpenTelemetryGranularity.OPERATION)
+    @override
+    @rate_limit
+    def _upsert(
+        self,
+        collection_id: UUID,
+        ids: IDs,
+        embeddings: Embeddings,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        uris: Optional[URIs] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        coll = self._get_collection(collection_id)
+        self._manager.hint_use_collection(collection_id, t.Operation.UPSERT)
+        validate_batch(
+            (ids, embeddings, metadatas, documents, uris),
+            {"max_batch_size": self.get_max_batch_size()},
+        )
+        records_to_submit = list(
+            _records(
+                t.Operation.UPSERT,
+                ids=ids,
+                embeddings=embeddings,
+                metadatas=metadatas,
+                documents=documents,
+                uris=uris,
+            )
+        )
+        self._validate_embedding_record_set(coll, records_to_submit)
+
+        self._quota_enforcer.enforce(
+            action=Action.UPSERT,
+            tenant=tenant,
+            ids=ids,
+            embeddings=embeddings,
+            metadatas=metadatas,
+            documents=documents,
+            uris=uris,
+            collection_id=collection_id,
+        )
+
+        self._producer.submit_embeddings(collection_id, records_to_submit)
+
+        return True
+
+    @trace_method("SegmentAPI._get", OpenTelemetryGranularity.OPERATION)
+    @retry(  # type: ignore[misc]
+        retry=retry_if_exception(lambda e: isinstance(e, VersionMismatchError)),
+        wait=wait_fixed(2),
+        stop=stop_after_attempt(5),
+        reraise=True,
+    )
+    @override
+    @rate_limit
+    def _get(
+        self,
+        collection_id: UUID,
+        ids: Optional[IDs] = None,
+        where: Optional[Where] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        where_document: Optional[WhereDocument] = None,
+        include: Include = IncludeMetadataDocuments,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> GetResult:
+        add_attributes_to_current_span(
+            {
+                "collection_id": str(collection_id),
+                "ids_count": len(ids) if ids else 0,
+            }
+        )
+
+        scan = self._scan(collection_id)
+
+        # TODO: Replace with unified validation
+        if where is not None:
+            validate_where(where)
+
+        if where_document is not None:
+            validate_where_document(where_document)
+
+        self._quota_enforcer.enforce(
+            action=Action.GET,
+            tenant=tenant,
+            ids=ids,
+            where=where,
+            where_document=where_document,
+            limit=limit,
+        )
+
+        ids_amount = len(ids) if ids else 0
+        self._product_telemetry_client.capture(
+            CollectionGetEvent(
+                collection_uuid=str(collection_id),
+                ids_count=ids_amount,
+                limit=limit if limit else 0,
+                include_metadata=ids_amount if "metadatas" in include else 0,
+                include_documents=ids_amount if "documents" in include else 0,
+                include_uris=ids_amount if "uris" in include else 0,
+            )
+        )
+
+        return self._executor.get(
+            GetPlan(
+                scan,
+                Filter(ids, where, where_document),
+                Limit(offset or 0, limit),
+                Projection(
+                    "documents" in include,
+                    "embeddings" in include,
+                    "metadatas" in include,
+                    False,
+                    "uris" in include,
+                ),
+            )
+        )
+
+    @trace_method("SegmentAPI._delete", OpenTelemetryGranularity.OPERATION)
+    @override
+    @rate_limit
+    def _delete(
+        self,
+        collection_id: UUID,
+        ids: Optional[IDs] = None,
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        limit: Optional[int] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> DeleteResult:
+        add_attributes_to_current_span(
+            {
+                "collection_id": str(collection_id),
+                "ids_count": len(ids) if ids else 0,
+            }
+        )
+
+        # TODO: Replace with unified validation
+        if where is not None:
+            validate_where(where)
+
+        if where_document is not None:
+            validate_where_document(where_document)
+
+        # You must have at least one of non-empty ids, where, or where_document.
+        if (
+            (ids is None or (ids is not None and len(ids) == 0))
+            and (where is None or (where is not None and len(where) == 0))
+            and (
+                where_document is None
+                or (where_document is not None and len(where_document) == 0)
+            )
+        ):
+            raise ValueError(
+                """
+                You must provide either ids, where, or where_document to delete. If
+                you want to delete all data in a collection you can delete the
+                collection itself using the delete_collection method. Or alternatively,
+                you can get() all the relevant ids and then delete them.
+                """
+            )
+
+        scan = self._scan(collection_id)
+
+        self._quota_enforcer.enforce(
+            action=Action.DELETE,
+            tenant=tenant,
+            ids=ids,
+            where=where,
+            where_document=where_document,
+        )
+
+        self._manager.hint_use_collection(collection_id, t.Operation.DELETE)
+
+        if (where or where_document) or not ids:
+            ids_to_delete = self._executor.get(
+                GetPlan(scan, Filter(ids, where, where_document))
+            )["ids"]
+        else:
+            ids_to_delete = ids
+
+        # Apply limit if specified (validated upstream, but enforce defensively)
+        if limit is not None:
+            if not isinstance(limit, int) or isinstance(limit, bool) or limit < 0:
+                raise ValueError("limit must be a non-negative integer")
+            if where is None and where_document is None:
+                raise ValueError(
+                    "limit can only be specified when a where or where_document clause is provided"
+                )
+            ids_to_delete = ids_to_delete[:limit]
+
+        if len(ids_to_delete) == 0:
+            return DeleteResult(deleted=0)
+
+        records_to_submit = list(
+            _records(operation=t.Operation.DELETE, ids=ids_to_delete)
+        )
+        self._validate_embedding_record_set(scan.collection, records_to_submit)
+        self._producer.submit_embeddings(collection_id, records_to_submit)
+
+        deleted_count = len(ids_to_delete)
+
+        self._product_telemetry_client.capture(
+            CollectionDeleteEvent(
+                collection_uuid=str(collection_id), delete_amount=deleted_count
+            )
+        )
+
+        return DeleteResult(deleted=deleted_count)
+
+    @trace_method("SegmentAPI._count", OpenTelemetryGranularity.OPERATION)
+    @retry(  # type: ignore[misc]
+        retry=retry_if_exception(lambda e: isinstance(e, VersionMismatchError)),
+        wait=wait_fixed(2),
+        stop=stop_after_attempt(5),
+        reraise=True,
+    )
+    @override
+    @rate_limit
+    def _count(
+        self,
+        collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+        read_level: ReadLevel = ReadLevel.INDEX_AND_WAL,
+    ) -> int:
+        add_attributes_to_current_span({"collection_id": str(collection_id)})
+        return self._executor.count(CountPlan(self._scan(collection_id)))
+
+    @trace_method("SegmentAPI._query", OpenTelemetryGranularity.OPERATION)
+    # We retry on version mismatch errors because the version of the collection
+    # may have changed between the time we got the version and the time we
+    # actually query the collection on the FE. We are fine with fixed
+    # wait time because the version mismatch error is not a error due to
+    # network issues or other transient issues. It is a result of the
+    # collection being updated between the time we got the version and
+    # the time we actually query the collection on the FE.
+    @retry(  # type: ignore[misc]
+        retry=retry_if_exception(lambda e: isinstance(e, VersionMismatchError)),
+        wait=wait_fixed(2),
+        stop=stop_after_attempt(5),
+        reraise=True,
+    )
+    @override
+    @rate_limit
+    def _query(
+        self,
+        collection_id: UUID,
+        query_embeddings: Embeddings,
+        ids: Optional[IDs] = None,
+        n_results: int = 10,
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        include: Include = IncludeMetadataDocumentsDistances,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> QueryResult:
+        add_attributes_to_current_span(
+            {
+                "collection_id": str(collection_id),
+                "n_results": n_results,
+                "where": str(where),
+            }
+        )
+
+        query_amount = len(query_embeddings)
+        ids_amount = len(ids) if ids else 0
+        self._product_telemetry_client.capture(
+            CollectionQueryEvent(
+                collection_uuid=str(collection_id),
+                query_amount=query_amount,
+                filtered_ids_amount=ids_amount,
+                n_results=n_results,
+                with_metadata_filter=query_amount if where is not None else 0,
+                with_document_filter=query_amount if where_document is not None else 0,
+                include_metadatas=query_amount if "metadatas" in include else 0,
+                include_documents=query_amount if "documents" in include else 0,
+                include_uris=query_amount if "uris" in include else 0,
+                include_distances=query_amount if "distances" in include else 0,
+            )
+        )
+
+        # TODO: Replace with unified validation
+        if where is not None:
+            validate_where(where)
+        if where_document is not None:
+            validate_where_document(where_document)
+
+        scan = self._scan(collection_id)
+        for embedding in query_embeddings:
+            self._validate_dimension(scan.collection, len(embedding), update=False)
+
+        self._quota_enforcer.enforce(
+            action=Action.QUERY,
+            tenant=tenant,
+            where=where,
+            where_document=where_document,
+            query_embeddings=query_embeddings,
+            n_results=n_results,
+        )
+
+        return self._executor.knn(
+            KNNPlan(
+                scan,
+                KNN(query_embeddings, n_results),
+                Filter(None, where, where_document),
+                Projection(
+                    "documents" in include,
+                    "embeddings" in include,
+                    "metadatas" in include,
+                    "distances" in include,
+                    "uris" in include,
+                ),
+            )
+        )
+
+    @trace_method("SegmentAPI._peek", OpenTelemetryGranularity.OPERATION)
+    @override
+    @rate_limit
+    def _peek(
+        self,
+        collection_id: UUID,
+        n: int = 10,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> GetResult:
+        add_attributes_to_current_span({"collection_id": str(collection_id)})
+        return self._get(collection_id, limit=n)  # type: ignore
+
+    @override
+    def get_version(self) -> str:
+        return __version__
+
+    @override
+    def reset_state(self) -> None:
+        pass
+
+    @override
+    def reset(self) -> bool:
+        self._system.reset_state()
+        return True
+
+    @override
+    def get_settings(self) -> Settings:
+        return self._settings
+
+    @override
+    def get_max_batch_size(self) -> int:
+        return self._producer.max_batch_size
+
+    @override
+    def attach_function(
+        self,
+        function_id: str,
+        name: str,
+        input_collection_id: UUID,
+        output_collection: str,
+        params: Optional[Dict[str, Any]] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> Tuple["AttachedFunction", bool]:
+        """Attached functions are not supported in the Segment API (local embedded mode)."""
+        raise NotImplementedError(
+            "Attached functions are only supported when connecting to a Chroma server via HttpClient. "
+            "The Segment API (embedded mode) does not support attached function operations."
+        )
+
+    @override
+    def get_attached_function(
+        self,
+        name: str,
+        input_collection_id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> "AttachedFunction":
+        """Attached functions are not supported in the Segment API (local embedded mode)."""
+        raise NotImplementedError(
+            "Attached functions are only supported when connecting to a Chroma server via HttpClient. "
+            "The Segment API (embedded mode) does not support attached function operations."
+        )
+
+    @override
+    def detach_function(
+        self,
+        name: str,
+        input_collection_id: UUID,
+        delete_output: bool = False,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> bool:
+        """Attached functions are not supported in the Segment API (local embedded mode)."""
+        raise NotImplementedError(
+            "Attached functions are only supported when connecting to a Chroma server via HttpClient. "
+            "The Segment API (embedded mode) does not support attached function operations."
+        )
+
+    # TODO: This could potentially cause race conditions in a distributed version of the
+    # system, since the cache is only local.
+    # TODO: promote collection -> topic to a base class method so that it can be
+    # used for channel assignment in the distributed version of the system.
+    @trace_method(
+        "SegmentAPI._validate_embedding_record_set", OpenTelemetryGranularity.ALL
+    )
+    def _validate_embedding_record_set(
+        self, collection: t.Collection, records: List[t.OperationRecord]
+    ) -> None:
+        """Validate the dimension of an embedding record before submitting it to the system."""
+        add_attributes_to_current_span({"collection_id": str(collection["id"])})
+        for record in records:
+            if record["embedding"] is not None:
+                self._validate_dimension(
+                    collection, len(record["embedding"]), update=True
+                )
+
+    # This method is intentionally left untraced because otherwise it can emit thousands of spans for requests containing many embeddings.
+    def _validate_dimension(
+        self, collection: t.Collection, dim: int, update: bool
+    ) -> None:
+        """Validate that a collection supports records of the given dimension. If update
+        is true, update the collection if the collection doesn't already have a
+        dimension."""
+        if collection["dimension"] is None:
+            if update:
+                id = collection.id
+                self._sysdb.update_collection(id=id, dimension=dim)
+                collection["dimension"] = dim
+        elif collection["dimension"] != dim:
+            raise InvalidDimensionException(
+                f"Embedding dimension {dim} does not match collection dimensionality {collection['dimension']}"
+            )
+        else:
+            return  # all is well
+
+    @trace_method("SegmentAPI._get_collection", OpenTelemetryGranularity.ALL)
+    def _get_collection(self, collection_id: UUID) -> t.Collection:
+        collections = self._sysdb.get_collections(id=collection_id)
+        if not collections or len(collections) == 0:
+            raise NotFoundError(f"Collection {collection_id} does not exist.")
+        return collections[0]
+
+    @trace_method("SegmentAPI._scan", OpenTelemetryGranularity.OPERATION)
+    def _scan(self, collection_id: UUID) -> Scan:
+        collection_and_segments = self._sysdb.get_collection_with_segments(
+            collection_id
+        )
+        # For now collection should have exactly one segment per scope:
+        # - Local scopes: vector, metadata
+        # - Distributed scopes: vector, metadata, record
+        scope_to_segment = {
+            segment["scope"]: segment for segment in collection_and_segments["segments"]
+        }
+        return Scan(
+            collection=collection_and_segments["collection"],
+            knn=scope_to_segment[t.SegmentScope.VECTOR],
+            metadata=scope_to_segment[t.SegmentScope.METADATA],
+            # Local chroma do not have record segment, and this is not used by the local executor
+            record=scope_to_segment.get(t.SegmentScope.RECORD, None),  # type: ignore[arg-type]
+        )
+
+
+def _records(
+    operation: t.Operation,
+    ids: IDs,
+    embeddings: Optional[Embeddings] = None,
+    metadatas: Optional[Metadatas] = None,
+    documents: Optional[Documents] = None,
+    uris: Optional[URIs] = None,
+) -> Generator[t.OperationRecord, None, None]:
+    """Convert parallel lists of embeddings, metadatas and documents to a sequence of
+    SubmitEmbeddingRecords"""
+
+    # Presumes that callers were invoked via  Collection model, which means
+    # that we know that the embeddings, metadatas and documents have already been
+    # normalized and are guaranteed to be consistently named lists.
+
+    if embeddings == []:
+        embeddings = None
+
+    for i, id in enumerate(ids):
+        metadata = None
+        if metadatas:
+            metadata = metadatas[i]
+
+        if documents:
+            document = documents[i]
+            if metadata:
+                metadata = {**metadata, "chroma:document": document}
+            else:
+                metadata = {"chroma:document": document}
+
+        if uris:
+            uri = uris[i]
+            if metadata:
+                metadata = {**metadata, "chroma:uri": uri}
+            else:
+                metadata = {"chroma:uri": uri}
+
+        record = t.OperationRecord(
+            id=id,
+            embedding=embeddings[i] if embeddings is not None else None,
+            encoding=t.ScalarEncoding.FLOAT32,  # Hardcode for now
+            metadata=metadata,
+            operation=operation,
+        )
+        yield record

python/user_packages/Python313/site-packages/chromadb/api/shared_system_client.py

@@ -0,0 +1,193 @@
+from typing import ClassVar, Dict, Optional
+import logging
+import threading
+import uuid
+from chromadb.api import ServerAPI
+from chromadb.api.base_http_client import BaseHTTPClient
+from chromadb.config import Settings, System
+from chromadb.telemetry.product import ProductTelemetryClient
+from chromadb.telemetry.product.events import ClientStartEvent
+
+logger = logging.getLogger(__name__)
+
+
+class SharedSystemClient:
+    _identifier_to_system: ClassVar[Dict[str, System]] = {}
+    _identifier_to_refcount: ClassVar[Dict[str, int]] = {}
+    _refcount_lock: ClassVar[threading.Lock] = threading.Lock()
+    _identifier: str
+
+    def __init__(
+        self,
+        settings: Settings = Settings(),
+    ) -> None:
+        self._identifier = SharedSystemClient._get_identifier_from_settings(settings)
+        SharedSystemClient._create_system_if_not_exists(self._identifier, settings)
+        SharedSystemClient._increment_refcount(self._identifier)
+
+    @classmethod
+    def _create_system_if_not_exists(
+        cls, identifier: str, settings: Settings
+    ) -> System:
+        if identifier not in cls._identifier_to_system:
+            new_system = System(settings)
+            cls._identifier_to_system[identifier] = new_system
+
+            new_system.instance(ProductTelemetryClient)
+            new_system.instance(ServerAPI)
+
+            new_system.start()
+        else:
+            previous_system = cls._identifier_to_system[identifier]
+
+            # For now, the settings must match
+            if previous_system.settings != settings:
+                raise ValueError(
+                    f"An instance of Chroma already exists for {identifier} with different settings"
+                )
+
+        return cls._identifier_to_system[identifier]
+
+    @staticmethod
+    def _get_identifier_from_settings(settings: Settings) -> str:
+        identifier = ""
+        api_impl = settings.chroma_api_impl
+
+        if api_impl is None:
+            raise ValueError("Chroma API implementation must be set in settings")
+        elif api_impl in [
+            "chromadb.api.segment.SegmentAPI",
+            "chromadb.api.rust.RustBindingsAPI",
+        ]:
+            if settings.is_persistent:
+                identifier = settings.persist_directory
+            else:
+                identifier = (
+                    "ephemeral"  # TODO: support pathing and  multiple ephemeral clients
+                )
+        elif api_impl in [
+            "chromadb.api.fastapi.FastAPI",
+            "chromadb.api.async_fastapi.AsyncFastAPI",
+        ]:
+            # FastAPI clients can all use unique system identifiers since their configurations can be independent, e.g. different auth tokens
+            identifier = str(uuid.uuid4())
+        else:
+            raise ValueError(f"Unsupported Chroma API implementation {api_impl}")
+
+        return identifier
+
+    @staticmethod
+    def _populate_data_from_system(system: System) -> str:
+        identifier = SharedSystemClient._get_identifier_from_settings(system.settings)
+        SharedSystemClient._identifier_to_system[identifier] = system
+        return identifier
+
+    @classmethod
+    def from_system(cls, system: System) -> "SharedSystemClient":
+        """Create a client from an existing system. This is useful for testing and debugging."""
+
+        SharedSystemClient._populate_data_from_system(system)
+        instance = cls(system.settings)
+        return instance
+
+    @classmethod
+    def _increment_refcount(cls, identifier: str) -> None:
+        """Increment the reference count for a system identifier."""
+        with cls._refcount_lock:
+            if identifier not in cls._identifier_to_refcount:
+                cls._identifier_to_refcount[identifier] = 0
+            cls._identifier_to_refcount[identifier] += 1
+
+    @classmethod
+    def _decrement_refcount(cls, identifier: str) -> int:
+        """Decrement the reference count for a system identifier and return the new count."""
+        with cls._refcount_lock:
+            if identifier in cls._identifier_to_refcount:
+                cls._identifier_to_refcount[identifier] -= 1
+                count = cls._identifier_to_refcount[identifier]
+                if count <= 0:
+                    del cls._identifier_to_refcount[identifier]
+                return count
+            return 0
+
+    @classmethod
+    def _release_system(cls, identifier: str) -> None:
+        """Decrement refcount and stop the system if this was the last reference.
+
+        This consolidates the "decrement + conditional stop" pattern used in
+        both Client.close() and the Client.__init__ exception handler.
+        """
+        refcount = cls._decrement_refcount(identifier)
+        if refcount <= 0:
+            system = cls._identifier_to_system.pop(identifier, None)
+            if system is not None:
+                system.stop()
+
+    @staticmethod
+    def clear_system_cache() -> None:
+        SharedSystemClient._identifier_to_system = {}
+        SharedSystemClient._identifier_to_refcount = {}
+
+    @property
+    def _system(self) -> System:
+        return SharedSystemClient._identifier_to_system[self._identifier]
+
+    def _submit_client_start_event(self) -> None:
+        telemetry_client = self._system.instance(ProductTelemetryClient)
+        telemetry_client.capture(ClientStartEvent())
+
+    @staticmethod
+    def get_chroma_cloud_api_key_from_clients() -> Optional[str]:
+        """
+        Try to extract api key from existing client instances by checking httpx session headers.
+
+        Requirements to pull api key:
+        - must be a BaseHTTPClient instance (ignore RustBindingsAPI and SegmentAPI)
+        - must have "api.trychroma.com" or "gcp.trychroma.com" in the _api_url (ignore local/self-hosted instances)
+        - must have "x-chroma-token" or "X-Chroma-Token" in the headers
+
+        Returns:
+            The first api key found, or None if no client instances have api keys set.
+        """
+
+        api_keys: list[str] = []
+        systems_snapshot = list(SharedSystemClient._identifier_to_system.values())
+        for system in systems_snapshot:
+            try:
+                server_api = system.instance(ServerAPI)
+
+                if not isinstance(server_api, BaseHTTPClient):
+                    # RustBindingsAPI and SegmentAPI don't have HTTP headers
+                    continue
+
+                # Only pull api key if the url contains the chroma cloud url
+                api_url = server_api.get_api_url()
+                if (
+                    "api.trychroma.com" not in api_url
+                    and "gcp.trychroma.com" not in api_url
+                ):
+                    continue
+
+                headers = server_api.get_request_headers()
+                api_key = None
+                for key, value in headers.items():
+                    if key.lower() == "x-chroma-token":
+                        api_key = value
+                        break
+
+                if api_key:
+                    api_keys.append(api_key)
+            except Exception:
+                # If we can't access the ServerAPI instance, continue to the next
+                continue
+
+        if not api_keys:
+            return None
+
+        # log if multiple viable api keys found
+        if len(api_keys) > 1:
+            logger.info(
+                f"Multiple Chroma Cloud clients found, using API key starting with {api_keys[0][:8]}..."
+            )
+
+        return api_keys[0]

python/user_packages/Python313/site-packages/chromadb/auth/__init__.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from enum import Enum
+from typing import (
+    Any,
+    List,
+    Optional,
+    Dict,
+    Tuple,
+    TypeVar,
+)
+from dataclasses import dataclass
+
+from pydantic import SecretStr
+
+from chromadb.config import (
+    Component,
+    System,
+)
+
+T = TypeVar("T")
+S = TypeVar("S")
+
+
+class AuthError(Exception):
+    pass
+
+
+ClientAuthHeaders = Dict[str, SecretStr]
+
+
+class ClientAuthProvider(Component):
+    """
+    ClientAuthProvider is responsible for providing authentication headers for
+    client requests. Client implementations (in our case, just the FastAPI
+    client) must inject these headers into their requests.
+    """
+
+    def __init__(self, system: System) -> None:
+        super().__init__(system)
+
+    @abstractmethod
+    def authenticate(self) -> ClientAuthHeaders:
+        pass
+
+
+@dataclass
+class UserIdentity:
+    """
+    UserIdentity represents the identity of a user. In general, not all fields
+    will be populated, and the fields that are populated will depend on the
+    authentication provider.
+
+    The idea is that the AuthenticationProvider is responsible for populating
+    _all_ information known about the user, and the AuthorizationProvider is
+    responsible for making decisions based on that information.
+    """
+
+    user_id: str
+    tenant: Optional[str] = None
+    databases: Optional[List[str]] = None
+    # This can be used for any additional auth context which needs to be
+    # propagated from the authentication provider to the authorization
+    # provider.
+    attributes: Optional[Dict[str, Any]] = None
+
+
+class ServerAuthenticationProvider(Component):
+    """
+    ServerAuthenticationProvider is responsible for authenticating requests. If
+    a ServerAuthenticationProvider is configured, it will be called by the
+    server to authenticate requests. If no ServerAuthenticationProvider is
+    configured, all requests will be authenticated.
+
+    The ServerAuthenticationProvider should return a UserIdentity object if the
+    request is authenticated for use by the ServerAuthorizationProvider.
+    """
+
+    def __init__(self, system: System) -> None:
+        super().__init__(system)
+        self._ignore_auth_paths: Dict[
+            str, List[str]
+        ] = system.settings.chroma_server_auth_ignore_paths
+        self.overwrite_singleton_tenant_database_access_from_auth = (
+            system.settings.chroma_overwrite_singleton_tenant_database_access_from_auth
+        )
+
+    @abstractmethod
+    def authenticate_or_raise(self, headers: Dict[str, str]) -> UserIdentity:
+        pass
+
+    def ignore_operation(self, verb: str, path: str) -> bool:
+        if (
+            path in self._ignore_auth_paths.keys()
+            and verb.upper() in self._ignore_auth_paths[path]
+        ):
+            return True
+        return False
+
+    def read_creds_or_creds_file(self) -> List[str]:
+        _creds_file = None
+        _creds = None
+
+        if self._system.settings.chroma_server_authn_credentials_file:
+            _creds_file = str(
+                self._system.settings["chroma_server_authn_credentials_file"]
+            )
+        if self._system.settings.chroma_server_authn_credentials:
+            _creds = str(self._system.settings["chroma_server_authn_credentials"])
+        if not _creds_file and not _creds:
+            raise ValueError(
+                "No credentials file or credentials found in "
+                "[chroma_server_authn_credentials]."
+            )
+        if _creds_file and _creds:
+            raise ValueError(
+                "Both credentials file and credentials found."
+                "Please provide only one."
+            )
+        if _creds:
+            return [c for c in _creds.split("\n") if c]
+        elif _creds_file:
+            with open(_creds_file, "r") as f:
+                return f.readlines()
+        raise ValueError("Should never happen")
+
+    def singleton_tenant_database_if_applicable(
+        self, user: Optional[UserIdentity]
+    ) -> Tuple[Optional[str], Optional[str]]:
+        """
+        If settings.chroma_overwrite_singleton_tenant_database_access_from_auth
+        is False, this function always returns (None, None).
+
+        If settings.chroma_overwrite_singleton_tenant_database_access_from_auth
+        is True, follows the following logic:
+        - If the user only has access to a single tenant, this function will
+          return that tenant as its first return value.
+        - If the user only has access to a single database, this function will
+          return that database as its second return value. If the user has
+          access to multiple tenants and/or databases, including "*", this
+          function will return None for the corresponding value(s).
+        - If the user has access to multiple tenants and/or databases this
+          function will return None for the corresponding value(s).
+        """
+        if not self.overwrite_singleton_tenant_database_access_from_auth or not user:
+            return None, None
+        tenant = None
+        database = None
+        if user.tenant and user.tenant != "*":
+            tenant = user.tenant
+        if user.databases and len(user.databases) == 1 and user.databases[0] != "*":
+            database = user.databases[0]
+        return tenant, database
+
+
+class AuthzAction(str, Enum):
+    """
+    The set of actions that can be authorized by the authorization provider.
+    """
+
+    RESET = "system:reset"
+    CREATE_TENANT = "tenant:create_tenant"
+    GET_TENANT = "tenant:get_tenant"
+    CREATE_DATABASE = "db:create_database"
+    GET_DATABASE = "db:get_database"
+    DELETE_DATABASE = "db:delete_database"
+    LIST_DATABASES = "db:list_databases"
+    LIST_COLLECTIONS = "db:list_collections"
+    COUNT_COLLECTIONS = "db:count_collections"
+    CREATE_COLLECTION = "db:create_collection"
+    GET_OR_CREATE_COLLECTION = "db:get_or_create_collection"
+    GET_COLLECTION = "collection:get_collection"
+    DELETE_COLLECTION = "collection:delete_collection"
+    UPDATE_COLLECTION = "collection:update_collection"
+    ADD = "collection:add"
+    DELETE = "collection:delete"
+    GET = "collection:get"
+    QUERY = "collection:query"
+    COUNT = "collection:count"
+    UPDATE = "collection:update"
+    UPSERT = "collection:upsert"
+
+
+@dataclass
+class AuthzResource:
+    """
+    The resource being accessed in an authorization request.
+    """
+
+    tenant: Optional[str]
+    database: Optional[str]
+    collection: Optional[str]
+
+
+class ServerAuthorizationProvider(Component):
+    """
+    ServerAuthorizationProvider is responsible for authorizing requests. If a
+    ServerAuthorizationProvider is configured, it will be called by the server
+    to authorize requests. If no ServerAuthorizationProvider is configured, all
+    requests will be authorized.
+
+    ServerAuthorizationProvider should raise an exception if the request is not
+    authorized.
+    """
+
+    def __init__(self, system: System) -> None:
+        super().__init__(system)
+
+    @abstractmethod
+    def authorize_or_raise(
+        self, user: UserIdentity, action: AuthzAction, resource: AuthzResource
+    ) -> None:
+        pass
+
+    def read_config_or_config_file(self) -> List[str]:
+        _config_file = None
+        _config = None
+        if self._system.settings.chroma_server_authz_config_file:
+            _config_file = self._system.settings["chroma_server_authz_config_file"]
+        if self._system.settings.chroma_server_authz_config:
+            _config = str(self._system.settings["chroma_server_authz_config"])
+        if not _config_file and not _config:
+            raise ValueError(
+                "No authz configuration file or authz configuration found."
+            )
+        if _config_file and _config:
+            raise ValueError(
+                "Both authz configuration file and authz configuration found."
+                "Please provide only one."
+            )
+        if _config:
+            return [c for c in _config.split("\n") if c]
+        elif _config_file:
+            with open(_config_file, "r") as f:
+                return f.readlines()
+        raise ValueError("Should never happen")

python/user_packages/Python313/site-packages/chromadb/cli/cli.py

@@ -0,0 +1,56 @@
+import re
+import sys
+
+import chromadb_rust_bindings
+import requests
+from packaging.version import parse
+
+import chromadb
+
+
+def build_cli_args(**kwargs):
+    args = []
+    for key, value in kwargs.items():
+        if isinstance(value, bool):
+            if value:
+                args.append(f"--{key}")
+        elif value is not None:
+            args.extend([f"--{key}", str(value)])
+    return args
+
+
+def update():
+    try:
+        url = f"https://api.github.com/repos/chroma-core/chroma/releases"
+        response = requests.get(url)
+        response.raise_for_status()
+        releases = response.json()
+
+        version_pattern = re.compile(r'^\d+\.\d+\.\d+$')
+        numeric_releases = [r["tag_name"] for r in releases if version_pattern.fullmatch(r["tag_name"])]
+
+        if not numeric_releases:
+            print("Couldn't fetch the latest Chroma version")
+            return
+
+        latest = max(numeric_releases, key=parse)
+        if latest == chromadb.__version__:
+            print("Your Chroma version is up-to-date")
+            return
+
+        print(
+            f"A new version of Chroma is available!\nIf you're using pip, run 'pip install --upgrade chromadb' to upgrade to version {latest}")
+
+    except Exception as e:
+        print("Couldn't fetch the latest Chroma version")
+
+
+def app():
+    args = sys.argv
+    if ["chroma", "update"] in args:
+        update()
+        return
+    try:
+        chromadb_rust_bindings.cli(args)
+    except KeyboardInterrupt:
+        pass

python/user_packages/Python313/site-packages/chromadb/cli/utils.py

@@ -0,0 +1,40 @@
+from typing import Any, Dict
+
+import os
+import yaml
+
+
+def set_log_file_path(
+    log_config_path: str, new_filename: str = "chroma.log"
+) -> Dict[str, Any]:
+    """This works with the standard log_config.yml file.
+    It will not work with custom log configs that may use different handlers"""
+    with open(f"{log_config_path}", "r") as file:
+        log_config = yaml.safe_load(file)
+    for handler in log_config["handlers"].values():
+        if handler.get("class") == "logging.handlers.RotatingFileHandler":
+            handler["filename"] = new_filename
+
+    return log_config
+
+
+def get_directory_size(directory: str) -> int:
+    """Get the size of a directory in bytes"""
+    total = 0
+    with os.scandir(directory) as it:
+        for entry in it:
+            if entry.is_file():
+                total += entry.stat().st_size
+            elif entry.is_dir():
+                total += get_directory_size(entry.path)
+    return total
+
+
+# https://stackoverflow.com/a/1094933
+def sizeof_fmt(num: int, suffix: str = "B") -> str:
+    n: float = float(num)
+    for unit in ("", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi"):
+        if abs(n) < 1024.0:
+            return f"{n:3.1f}{unit}{suffix}"
+        n /= 1024.0
+    return f"{n:.1f}Yi{suffix}"

python/user_packages/Python313/site-packages/chromadb/db/__init__.py

@@ -0,0 +1,122 @@
+from abc import abstractmethod
+from typing import List, Sequence, Optional, Tuple
+from uuid import UUID
+from chromadb.api.types import (
+    Embeddings,
+    Documents,
+    IDs,
+    Metadatas,
+    Metadata,
+    Where,
+    WhereDocument,
+)
+from chromadb.config import Component
+
+
+class DB(Component):
+    @abstractmethod
+    def create_collection(
+        self,
+        name: str,
+        metadata: Optional[Metadata] = None,
+        get_or_create: bool = False,
+    ) -> Sequence:  # type: ignore
+        pass
+
+    @abstractmethod
+    def get_collection(self, name: str) -> Sequence:  # type: ignore
+        pass
+
+    @abstractmethod
+    def list_collections(
+        self, limit: Optional[int] = None, offset: Optional[int] = None
+    ) -> Sequence:  # type: ignore
+        pass
+
+    @abstractmethod
+    def count_collections(self) -> int:
+        pass
+
+    @abstractmethod
+    def update_collection(
+        self,
+        id: UUID,
+        new_name: Optional[str] = None,
+        new_metadata: Optional[Metadata] = None,
+    ) -> None:
+        pass
+
+    @abstractmethod
+    def delete_collection(self, name: str) -> None:
+        pass
+
+    @abstractmethod
+    def get_collection_uuid_from_name(self, collection_name: str) -> UUID:
+        pass
+
+    @abstractmethod
+    def add(
+        self,
+        collection_uuid: UUID,
+        embeddings: Embeddings,
+        metadatas: Optional[Metadatas],
+        documents: Optional[Documents],
+        ids: List[str],
+    ) -> List[UUID]:
+        pass
+
+    @abstractmethod
+    def get(
+        self,
+        where: Optional[Where] = None,
+        collection_name: Optional[str] = None,
+        collection_uuid: Optional[UUID] = None,
+        ids: Optional[IDs] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        where_document: Optional[WhereDocument] = None,
+        columns: Optional[List[str]] = None,
+    ) -> Sequence:  # type: ignore
+        pass
+
+    @abstractmethod
+    def update(
+        self,
+        collection_uuid: UUID,
+        ids: IDs,
+        embeddings: Optional[Embeddings] = None,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+    ) -> bool:
+        pass
+
+    @abstractmethod
+    def count(self, collection_id: UUID) -> int:
+        pass
+
+    @abstractmethod
+    def delete(
+        self,
+        where: Optional[Where] = None,
+        collection_uuid: Optional[UUID] = None,
+        ids: Optional[IDs] = None,
+        where_document: Optional[WhereDocument] = None,
+    ) -> None:
+        pass
+
+    @abstractmethod
+    def get_nearest_neighbors(
+        self,
+        collection_uuid: UUID,
+        where: Optional[Where] = None,
+        embeddings: Optional[Embeddings] = None,
+        n_results: int = 10,
+        where_document: Optional[WhereDocument] = None,
+    ) -> Tuple[List[List[UUID]], List[List[float]]]:
+        pass
+
+    @abstractmethod
+    def get_by_ids(
+        self, uuids: List[UUID], columns: Optional[List[str]] = None
+    ) -> Sequence:  # type: ignore
+        pass

python/user_packages/Python313/site-packages/chromadb/db/base.py

@@ -0,0 +1,180 @@
+from typing import Any, Optional, Sequence, Tuple, Type
+from types import TracebackType
+from typing_extensions import Protocol, Self, Literal
+from abc import ABC, abstractmethod
+from threading import local
+from overrides import override, EnforceOverrides
+import pypika
+import pypika.queries
+from chromadb.config import System, Component
+from uuid import UUID
+from itertools import islice, count
+
+
+class Cursor(Protocol):
+    """Reifies methods we use from a DBAPI2 Cursor since DBAPI2 is not typed."""
+
+    def execute(self, sql: str, params: Optional[Tuple[Any, ...]] = None) -> Self:
+        ...
+
+    def executescript(self, script: str) -> Self:
+        ...
+
+    def executemany(
+        self, sql: str, params: Optional[Sequence[Tuple[Any, ...]]] = None
+    ) -> Self:
+        ...
+
+    def fetchone(self) -> Tuple[Any, ...]:
+        ...
+
+    def fetchall(self) -> Sequence[Tuple[Any, ...]]:
+        ...
+
+
+class TxWrapper(ABC, EnforceOverrides):
+    """Wrapper class for DBAPI 2.0 Connection objects, with which clients can implement transactions.
+    Makes two guarantees that basic DBAPI 2.0 connections do not:
+
+    - __enter__ returns a Cursor object consistently (instead of a Connection like some do)
+    - Always re-raises an exception if one was thrown from the body
+    """
+
+    @abstractmethod
+    def __enter__(self) -> Cursor:
+        pass
+
+    @abstractmethod
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_value: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> Literal[False]:
+        pass
+
+
+class SqlDB(Component):
+    """DBAPI 2.0 interface wrapper to ensure consistent behavior between implementations"""
+
+    def __init__(self, system: System):
+        super().__init__(system)
+
+    @abstractmethod
+    def tx(self) -> TxWrapper:
+        """Return a transaction wrapper"""
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def querybuilder() -> Type[pypika.Query]:
+        """Return a PyPika Query builder of an appropriate subtype for this database
+        implementation (see
+        https://pypika.readthedocs.io/en/latest/3_advanced.html#handling-different-database-platforms)
+        """
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def parameter_format() -> str:
+        """Return the appropriate parameter format for this database implementation.
+        Will be called with str.format(i) where i is the numeric index of the parameter.
+        """
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def uuid_to_db(uuid: Optional[UUID]) -> Optional[Any]:
+        """Convert a UUID to a value that can be passed to the DB driver"""
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def uuid_from_db(value: Optional[Any]) -> Optional[UUID]:
+        """Convert a value from the DB driver to a UUID"""
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def unique_constraint_error() -> Type[BaseException]:
+        """Return the exception type that the DB raises when a unique constraint is
+        violated"""
+        pass
+
+    def param(self, idx: int) -> pypika.Parameter:
+        """Return a PyPika Parameter object for the given index"""
+        return pypika.Parameter(self.parameter_format().format(idx))
+
+
+_context = local()
+
+
+class ParameterValue(pypika.Parameter):  # type: ignore
+    """
+    Wrapper class for PyPika paramters that allows the values for Parameters
+    to be expressed inline while building a query. See get_sql() for
+    detailed usage information.
+    """
+
+    def __init__(self, value: Any):
+        self.value = value
+
+    @override
+    def get_sql(self, **kwargs: Any) -> str:
+        if isinstance(self.value, (list, tuple)):
+            _context.values.extend(self.value)
+            indexes = islice(_context.generator, len(self.value))
+            placeholders = ", ".join(_context.formatstr.format(i) for i in indexes)
+            val = f"({placeholders})"
+        else:
+            _context.values.append(self.value)
+            val = _context.formatstr.format(next(_context.generator))
+
+        return str(val)
+
+
+def get_sql(
+    query: pypika.queries.QueryBuilder, formatstr: str = "?"
+) -> Tuple[str, Tuple[Any, ...]]:
+    """
+    Wrapper for pypika's get_sql method that allows the values for Parameters
+    to be expressed inline while building a query, and that returns a tuple of the
+    SQL string and parameters. This makes it easier to construct complex queries
+    programmatically and automatically matches up the generated SQL with the required
+    parameter vector.
+
+    Doing so requires using the ParameterValue class defined in this module instead
+    of the base pypika.Parameter class.
+
+    Usage Example:
+
+        q = (
+            pypika.Query().from_("table")
+            .select("col1")
+            .where("col2"==ParameterValue("foo"))
+            .where("col3"==ParameterValue("bar"))
+        )
+
+        sql, params = get_sql(q)
+
+        cursor.execute(sql, params)
+
+    Note how it is not necessary to construct the parameter vector manually... it
+    will always be generated with the parameter values in the same order as emitted
+    SQL string.
+
+    The format string should match the parameter format for the database being used.
+    It will be called with str.format(i) where i is the numeric index of the parameter.
+    For example, Postgres requires parameters like `:1`, `:2`, etc. so the format string
+    should be `":{}"`.
+
+    See https://pypika.readthedocs.io/en/latest/2_tutorial.html#parametrized-queries for more
+    information on parameterized queries in PyPika.
+    """
+
+    _context.values = []
+    _context.generator = count(1)
+    _context.formatstr = formatstr
+    sql = query.get_sql()
+    params = tuple(_context.values)
+    return sql, params

python/user_packages/Python313/site-packages/chromadb/db/migrations.py

@@ -0,0 +1,276 @@
+import sys
+from typing import Sequence
+from typing_extensions import TypedDict, NotRequired
+from importlib_resources.abc import Traversable
+import re
+import hashlib
+from chromadb.db.base import SqlDB, Cursor
+from abc import abstractmethod
+from chromadb.config import System, Settings
+from chromadb.telemetry.opentelemetry import (
+    OpenTelemetryClient,
+    OpenTelemetryGranularity,
+    trace_method,
+)
+
+
+class MigrationFile(TypedDict):
+    path: NotRequired[Traversable]
+    dir: str
+    filename: str
+    version: int
+    scope: str
+
+
+class Migration(MigrationFile):
+    hash: str
+    sql: str
+
+
+class UninitializedMigrationsError(Exception):
+    def __init__(self) -> None:
+        super().__init__("Migrations have not been initialized")
+
+
+class UnappliedMigrationsError(Exception):
+    def __init__(self, dir: str, version: int):
+        self.dir = dir
+        self.version = version
+        super().__init__(
+            f"Unapplied migrations in {dir}, starting with version {version}"
+        )
+
+
+class InconsistentVersionError(Exception):
+    def __init__(self, dir: str, db_version: int, source_version: int):
+        super().__init__(
+            f"Inconsistent migration versions in {dir}:"
+            + f"db version was {db_version}, source version was {source_version}."
+            + " Has the migration sequence been modified since being applied to the DB?"
+        )
+
+
+class InconsistentHashError(Exception):
+    def __init__(self, path: str, db_hash: str, source_hash: str):
+        super().__init__(
+            f"Inconsistent hashes in {path}:"
+            + f"db hash was {db_hash}, source has was {source_hash}."
+            + " Was the migration file modified after being applied to the DB?"
+        )
+
+
+class InvalidHashError(Exception):
+    def __init__(self, alg: str):
+        super().__init__(f"Invalid hash algorithm specified: {alg}")
+
+
+class InvalidMigrationFilename(Exception):
+    pass
+
+
+class MigratableDB(SqlDB):
+    """Simple base class for databases which support basic migrations.
+
+    Migrations are SQL files stored as package resources and accessed via
+    importlib_resources.
+
+    All migrations in the same directory are assumed to be dependent on previous
+    migrations in the same directory, where "previous" is defined on lexographical
+    ordering of filenames.
+
+    Migrations have a ascending numeric version number and a hash of the file contents.
+    When migrations are applied, the hashes of previous migrations are checked to ensure
+    that the database is consistent with the source repository. If they are not, an
+    error is thrown and no migrations will be applied.
+
+    Migration files must follow the naming convention:
+    <version>.<description>.<scope>.sql, where <version> is a 5-digit zero-padded
+    integer, <description> is a short textual description, and <scope> is a short string
+    identifying the database implementation.
+    """
+
+    _settings: Settings
+
+    def __init__(self, system: System) -> None:
+        self._settings = system.settings
+        self._opentelemetry_client = system.require(OpenTelemetryClient)
+        super().__init__(system)
+
+    @staticmethod
+    @abstractmethod
+    def migration_scope() -> str:
+        """The database implementation to use for migrations (e.g, sqlite, pgsql)"""
+        pass
+
+    @abstractmethod
+    def migration_dirs(self) -> Sequence[Traversable]:
+        """Directories containing the migration sequences that should be applied to this
+        DB."""
+        pass
+
+    @abstractmethod
+    def setup_migrations(self) -> None:
+        """Idempotently creates the migrations table"""
+        pass
+
+    @abstractmethod
+    def migrations_initialized(self) -> bool:
+        """Return true if the migrations table exists"""
+        pass
+
+    @abstractmethod
+    def db_migrations(self, dir: Traversable) -> Sequence[Migration]:
+        """Return a list of all migrations already applied to this database, from the
+        given source directory, in ascending order."""
+        pass
+
+    @abstractmethod
+    def apply_migration(self, cur: Cursor, migration: Migration) -> None:
+        """Apply a single migration to the database"""
+        pass
+
+    def initialize_migrations(self) -> None:
+        """Initialize migrations for this DB"""
+        migrate = self._settings.require("migrations")
+
+        if migrate == "validate":
+            self.validate_migrations()
+
+        if migrate == "apply":
+            self.apply_migrations()
+
+    @trace_method("MigratableDB.validate_migrations", OpenTelemetryGranularity.ALL)
+    def validate_migrations(self) -> None:
+        """Validate all migrations and throw an exception if there are any unapplied
+        migrations in the source repo."""
+        if not self.migrations_initialized():
+            raise UninitializedMigrationsError()
+        for dir in self.migration_dirs():
+            db_migrations = self.db_migrations(dir)
+            source_migrations = find_migrations(
+                dir,
+                self.migration_scope(),
+                self._settings.require("migrations_hash_algorithm"),
+            )
+            unapplied_migrations = verify_migration_sequence(
+                db_migrations, source_migrations
+            )
+            if len(unapplied_migrations) > 0:
+                version = unapplied_migrations[0]["version"]
+                raise UnappliedMigrationsError(dir=dir.name, version=version)
+
+    @trace_method("MigratableDB.apply_migrations", OpenTelemetryGranularity.ALL)
+    def apply_migrations(self) -> None:
+        """Validate existing migrations, and apply all new ones."""
+        self.setup_migrations()
+        for dir in self.migration_dirs():
+            db_migrations = self.db_migrations(dir)
+            source_migrations = find_migrations(
+                dir,
+                self.migration_scope(),
+                self._settings.require("migrations_hash_algorithm"),
+            )
+            unapplied_migrations = verify_migration_sequence(
+                db_migrations, source_migrations
+            )
+            with self.tx() as cur:
+                for migration in unapplied_migrations:
+                    self.apply_migration(cur, migration)
+
+
+# Format is <version>-<name>.<scope>.sql
+# e.g, 00001-users.sqlite.sql
+filename_regex = re.compile(r"(\d+)-(.+)\.(.+)\.sql")
+
+
+def _parse_migration_filename(
+    dir: str, filename: str, path: Traversable
+) -> MigrationFile:
+    """Parse a migration filename into a MigrationFile object"""
+    match = filename_regex.match(filename)
+    if match is None:
+        raise InvalidMigrationFilename("Invalid migration filename: " + filename)
+    version, _, scope = match.groups()
+    return {
+        "path": path,
+        "dir": dir,
+        "filename": filename,
+        "version": int(version),
+        "scope": scope,
+    }
+
+
+def verify_migration_sequence(
+    db_migrations: Sequence[Migration],
+    source_migrations: Sequence[Migration],
+) -> Sequence[Migration]:
+    """Given a list of migrations already applied to a database, and a list of
+    migrations from the source code, validate that the applied migrations are correct
+    and match the expected migrations.
+
+    Throws an exception if any migrations are missing, out of order, or if the source
+    hash does not match.
+
+    Returns a list of all unapplied migrations, or an empty list if all migrations are
+    applied and the database is up to date."""
+
+    for db_migration, source_migration in zip(db_migrations, source_migrations):
+        if db_migration["version"] != source_migration["version"]:
+            raise InconsistentVersionError(
+                dir=db_migration["dir"],
+                db_version=db_migration["version"],
+                source_version=source_migration["version"],
+            )
+
+        if db_migration["hash"] != source_migration["hash"]:
+            raise InconsistentHashError(
+                path=db_migration["dir"] + "/" + db_migration["filename"],
+                db_hash=db_migration["hash"],
+                source_hash=source_migration["hash"],
+            )
+
+    return source_migrations[len(db_migrations) :]
+
+
+def find_migrations(
+    dir: Traversable, scope: str, hash_alg: str = "md5"
+) -> Sequence[Migration]:
+    """Return a list of all migration present in the given directory, in ascending
+    order. Filter by scope."""
+    files = [
+        _parse_migration_filename(dir.name, t.name, t)
+        for t in dir.iterdir()
+        if t.name.endswith(".sql")
+    ]
+    files = list(filter(lambda f: f["scope"] == scope, files))
+    files = sorted(files, key=lambda f: f["version"])
+    return [_read_migration_file(f, hash_alg) for f in files]
+
+
+def _read_migration_file(file: MigrationFile, hash_alg: str) -> Migration:
+    """Read a migration file"""
+    if "path" not in file or not file["path"].is_file():
+        raise FileNotFoundError(
+            f"No migration file found for dir {file['dir']} with filename {file['filename']} and scope {file['scope']} at version {file['version']}"
+        )
+    sql = file["path"].read_text()
+
+    if hash_alg == "md5":
+        hash = (
+            hashlib.md5(sql.encode("utf-8"), usedforsecurity=False).hexdigest()
+            if sys.version_info >= (3, 9)
+            else hashlib.md5(sql.encode("utf-8")).hexdigest()
+        )
+    elif hash_alg == "sha256":
+        hash = hashlib.sha256(sql.encode("utf-8")).hexdigest()
+    else:
+        raise InvalidHashError(alg=hash_alg)
+
+    return {
+        "hash": hash,
+        "sql": sql,
+        "dir": file["dir"],
+        "filename": file["filename"],
+        "version": file["version"],
+        "scope": file["scope"],
+    }

python/user_packages/Python313/site-packages/chromadb/db/system.py

@@ -0,0 +1,189 @@
+from abc import abstractmethod
+from typing import Optional, Sequence, Tuple
+from uuid import UUID
+from chromadb.api.collection_configuration import (
+    CreateCollectionConfiguration,
+    UpdateCollectionConfiguration,
+)
+from chromadb.api.types import Schema
+from chromadb.types import (
+    Collection,
+    CollectionAndSegments,
+    Database,
+    Tenant,
+    Metadata,
+    Segment,
+    SegmentScope,
+    OptionalArgument,
+    Unspecified,
+    UpdateMetadata,
+)
+from chromadb.config import DEFAULT_DATABASE, DEFAULT_TENANT, Component
+
+
+class SysDB(Component):
+    """Data interface for Chroma's System database"""
+
+    @abstractmethod
+    def create_database(
+        self, id: UUID, name: str, tenant: str = DEFAULT_TENANT
+    ) -> None:
+        """Create a new database in the System database. Raises an Error if the Database
+        already exists."""
+        pass
+
+    @abstractmethod
+    def get_database(self, name: str, tenant: str = DEFAULT_TENANT) -> Database:
+        """Get a database by name and tenant. Raises an Error if the Database does not
+        exist."""
+        pass
+
+    @abstractmethod
+    def delete_database(self, name: str, tenant: str = DEFAULT_TENANT) -> None:
+        """Delete a database."""
+        pass
+
+    @abstractmethod
+    def list_databases(
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        tenant: str = DEFAULT_TENANT,
+    ) -> Sequence[Database]:
+        """List all databases for a tenant."""
+        pass
+
+    @abstractmethod
+    def create_tenant(self, name: str) -> None:
+        """Create a new tenant in the System database. The name must be unique.
+        Raises an Error if the Tenant already exists."""
+        pass
+
+    @abstractmethod
+    def get_tenant(self, name: str) -> Tenant:
+        """Get a tenant by name. Raises an Error if the Tenant does not exist."""
+        pass
+
+    # TODO: Investigate and remove this method, as segment creation is done as
+    # part of collection creation.
+    @abstractmethod
+    def create_segment(self, segment: Segment) -> None:
+        """Create a new segment in the System database. Raises an Error if the ID
+        already exists."""
+        pass
+
+    @abstractmethod
+    def delete_segment(self, collection: UUID, id: UUID) -> None:
+        """Delete a segment from the System database."""
+        pass
+
+    @abstractmethod
+    def get_segments(
+        self,
+        collection: UUID,
+        id: Optional[UUID] = None,
+        type: Optional[str] = None,
+        scope: Optional[SegmentScope] = None,
+    ) -> Sequence[Segment]:
+        """Find segments by id, type, scope or collection."""
+        pass
+
+    @abstractmethod
+    def update_segment(
+        self,
+        collection: UUID,
+        id: UUID,
+        metadata: OptionalArgument[Optional[UpdateMetadata]] = Unspecified(),
+    ) -> None:
+        """Update a segment. Unspecified fields will be left unchanged. For the
+        metadata, keys with None values will be removed and keys not present in the
+        UpdateMetadata dict will be left unchanged."""
+        pass
+
+    @abstractmethod
+    def create_collection(
+        self,
+        id: UUID,
+        name: str,
+        schema: Optional[Schema],
+        configuration: CreateCollectionConfiguration,
+        segments: Sequence[Segment],
+        metadata: Optional[Metadata] = None,
+        dimension: Optional[int] = None,
+        get_or_create: bool = False,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> Tuple[Collection, bool]:
+        """Create a new collection and associated resources
+        in the SysDB. If get_or_create is True, the
+        collection will be created if one with the same name does not exist.
+        The metadata will be updated using the same protocol as update_collection. If get_or_create
+        is False and the collection already exists, an error will be raised.
+
+        Returns a tuple of the created collection and a boolean indicating whether the
+        collection was created or not.
+        """
+        pass
+
+    @abstractmethod
+    def delete_collection(
+        self,
+        id: UUID,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+    ) -> None:
+        """Delete a collection, all associated segments and any associate resources (log stream)
+        from the SysDB and the system at large."""
+        pass
+
+    @abstractmethod
+    def get_collections(
+        self,
+        id: Optional[UUID] = None,
+        name: Optional[str] = None,
+        tenant: str = DEFAULT_TENANT,
+        database: str = DEFAULT_DATABASE,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+    ) -> Sequence[Collection]:
+        """Find collections by id or name. If name is provided, tenant and database must also be provided."""
+        pass
+
+    @abstractmethod
+    def count_collections(
+        self,
+        tenant: str = DEFAULT_TENANT,
+        database: Optional[str] = None,
+    ) -> int:
+        """Gets the number of collections for the (tenant, database) combination."""
+        pass
+
+    @abstractmethod
+    def get_collection_with_segments(
+        self, collection_id: UUID
+    ) -> CollectionAndSegments:
+        """Get a consistent snapshot of a collection by id. This will return a collection with segment
+        information that matches the collection version and log position.
+        """
+        pass
+
+    @abstractmethod
+    def update_collection(
+        self,
+        id: UUID,
+        name: OptionalArgument[str] = Unspecified(),
+        dimension: OptionalArgument[Optional[int]] = Unspecified(),
+        metadata: OptionalArgument[Optional[UpdateMetadata]] = Unspecified(),
+        configuration: OptionalArgument[
+            Optional[UpdateCollectionConfiguration]
+        ] = Unspecified(),
+    ) -> None:
+        """Update a collection. Unspecified fields will be left unchanged. For metadata,
+        keys with None values will be removed and keys not present in the UpdateMetadata
+        dict will be left unchanged."""
+        pass
+
+    @abstractmethod
+    def get_collection_size(self, id: UUID) -> int:
+        """Returns the number of records in a collection."""
+        pass

python/user_packages/Python313/site-packages/chromadb/ingest/__init__.py

@@ -0,0 +1,121 @@
+from abc import abstractmethod
+from typing import Callable, Optional, Sequence
+from chromadb.types import (
+    OperationRecord,
+    LogRecord,
+    SeqId,
+    Vector,
+    ScalarEncoding,
+)
+from chromadb.config import Component
+from uuid import UUID
+import numpy as np
+
+
+def encode_vector(vector: Vector, encoding: ScalarEncoding) -> bytes:
+    """Encode a vector into a byte array."""
+
+    if encoding == ScalarEncoding.FLOAT32:
+        return np.array(vector, dtype=np.float32).tobytes()
+    elif encoding == ScalarEncoding.INT32:
+        return np.array(vector, dtype=np.int32).tobytes()
+    else:
+        raise ValueError(f"Unsupported encoding: {encoding.value}")
+
+
+def decode_vector(vector: bytes, encoding: ScalarEncoding) -> Vector:
+    """Decode a byte array into a vector"""
+
+    if encoding == ScalarEncoding.FLOAT32:
+        return np.frombuffer(vector, dtype=np.float32)
+    elif encoding == ScalarEncoding.INT32:
+        return np.frombuffer(vector, dtype=np.float32)
+    else:
+        raise ValueError(f"Unsupported encoding: {encoding.value}")
+
+
+class Producer(Component):
+    """Interface for writing embeddings to an ingest stream"""
+
+    @abstractmethod
+    def delete_log(self, collection_id: UUID) -> None:
+        pass
+
+    @abstractmethod
+    def purge_log(self, collection_id: UUID) -> None:
+        """Truncates the log for the given collection, removing all seen records."""
+        pass
+
+    @abstractmethod
+    def submit_embedding(
+        self, collection_id: UUID, embedding: OperationRecord
+    ) -> SeqId:
+        """Add an embedding record to the given collections log. Returns the SeqID of the record."""
+        pass
+
+    @abstractmethod
+    def submit_embeddings(
+        self, collection_id: UUID, embeddings: Sequence[OperationRecord]
+    ) -> Sequence[SeqId]:
+        """Add a batch of embedding records to the given collections log. Returns the SeqIDs of
+        the records. The returned SeqIDs will be in the same order as the given
+        SubmitEmbeddingRecords. However, it is not guaranteed that the SeqIDs will be
+        processed in the same order as the given SubmitEmbeddingRecords. If the number
+        of records exceeds the maximum batch size, an exception will be thrown."""
+        pass
+
+    @property
+    @abstractmethod
+    def max_batch_size(self) -> int:
+        """Return the maximum number of records that can be submitted in a single call
+        to submit_embeddings."""
+        pass
+
+
+ConsumerCallbackFn = Callable[[Sequence[LogRecord]], None]
+
+
+class Consumer(Component):
+    """Interface for reading embeddings off an ingest stream"""
+
+    @abstractmethod
+    def subscribe(
+        self,
+        collection_id: UUID,
+        consume_fn: ConsumerCallbackFn,
+        start: Optional[SeqId] = None,
+        end: Optional[SeqId] = None,
+        id: Optional[UUID] = None,
+    ) -> UUID:
+        """Register a function that will be called to receive embeddings for a given
+        collections log stream. The given function may be called any number of times, with any number of
+        records, and may be called concurrently.
+
+        Only records between start (exclusive) and end (inclusive) SeqIDs will be
+        returned. If start is None, the first record returned will be the next record
+        generated, not including those generated before creating the subscription. If
+        end is None, the consumer will consume indefinitely, otherwise it will
+        automatically be unsubscribed when the end SeqID is reached.
+
+        If the function throws an exception, the function may be called again with the
+        same or different records.
+
+        Takes an optional UUID as a unique subscription ID. If no ID is provided, a new
+        ID will be generated and returned."""
+        pass
+
+    @abstractmethod
+    def unsubscribe(self, subscription_id: UUID) -> None:
+        """Unregister a subscription. The consume function will no longer be invoked,
+        and resources associated with the subscription will be released."""
+        pass
+
+    @abstractmethod
+    def min_seqid(self) -> SeqId:
+        """Return the minimum possible SeqID in this implementation."""
+        pass
+
+    @abstractmethod
+    def max_seqid(self) -> SeqId:
+        """Return the maximum possible SeqID in this implementation."""
+        pass

python/user_packages/Python313/site-packages/chromadb/logservice/logservice.py

@@ -0,0 +1,181 @@
+import sys
+
+from chromadb.proto.utils import RetryOnRpcErrorClientInterceptor
+import grpc
+import time
+from chromadb.ingest import (
+    Producer,
+    Consumer,
+    ConsumerCallbackFn,
+)
+from chromadb.proto.convert import to_proto_submit
+from chromadb.proto.logservice_pb2 import PushLogsRequest, PullLogsRequest, LogRecord
+from chromadb.proto.logservice_pb2_grpc import LogServiceStub
+from chromadb.telemetry.opentelemetry.grpc import OtelInterceptor
+from chromadb.types import (
+    OperationRecord,
+    SeqId,
+)
+from chromadb.config import System
+from chromadb.telemetry.opentelemetry import (
+    OpenTelemetryClient,
+    OpenTelemetryGranularity,
+    add_attributes_to_current_span,
+    trace_method,
+)
+from overrides import override
+from typing import Sequence, Optional, cast
+from uuid import UUID
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class LogService(Producer, Consumer):
+    """
+    Distributed Chroma Log Service
+    """
+
+    _log_service_stub: LogServiceStub
+    _request_timeout_seconds: int
+    _channel: grpc.Channel
+    _log_service_url: str
+    _log_service_port: int
+
+    def __init__(self, system: System):
+        self._log_service_url = system.settings.require("chroma_logservice_host")
+        self._log_service_port = system.settings.require("chroma_logservice_port")
+        self._request_timeout_seconds = system.settings.require(
+            "chroma_logservice_request_timeout_seconds"
+        )
+        self._opentelemetry_client = system.require(OpenTelemetryClient)
+        super().__init__(system)
+
+    @trace_method("LogService.start", OpenTelemetryGranularity.ALL)
+    @override
+    def start(self) -> None:
+        self._channel = grpc.insecure_channel(
+            f"{self._log_service_url}:{self._log_service_port}",
+        )
+        interceptors = [OtelInterceptor(), RetryOnRpcErrorClientInterceptor()]
+        self._channel = grpc.intercept_channel(self._channel, *interceptors)
+        self._log_service_stub = LogServiceStub(self._channel)  # type: ignore
+        super().start()
+
+    @trace_method("LogService.stop", OpenTelemetryGranularity.ALL)
+    @override
+    def stop(self) -> None:
+        self._channel.close()
+        super().stop()
+
+    @trace_method("LogService.reset_state", OpenTelemetryGranularity.ALL)
+    @override
+    def reset_state(self) -> None:
+        super().reset_state()
+
+    @trace_method("LogService.delete_log", OpenTelemetryGranularity.ALL)
+    @override
+    def delete_log(self, collection_id: UUID) -> None:
+        raise NotImplementedError("Not implemented")
+
+    @trace_method("LogService.purge_log", OpenTelemetryGranularity.ALL)
+    @override
+    def purge_log(self, collection_id: UUID) -> None:
+        raise NotImplementedError("Not implemented")
+
+    @trace_method("LogService.submit_embedding", OpenTelemetryGranularity.ALL)
+    @override
+    def submit_embedding(
+        self, collection_id: UUID, embedding: OperationRecord
+    ) -> SeqId:
+        if not self._running:
+            raise RuntimeError("Component not running")
+
+        return self.submit_embeddings(collection_id, [embedding])[0]
+
+    @trace_method("LogService.submit_embeddings", OpenTelemetryGranularity.ALL)
+    @override
+    def submit_embeddings(
+        self, collection_id: UUID, embeddings: Sequence[OperationRecord]
+    ) -> Sequence[SeqId]:
+        logger.info(
+            f"Submitting {len(embeddings)} embeddings to log for collection {collection_id}"
+        )
+
+        add_attributes_to_current_span(
+            {
+                "records_count": len(embeddings),
+            }
+        )
+
+        if not self._running:
+            raise RuntimeError("Component not running")
+
+        if len(embeddings) == 0:
+            return []
+
+        # push records to the log service
+        counts = []
+        protos_to_submit = [to_proto_submit(record) for record in embeddings]
+        counts.append(
+            self.push_logs(
+                collection_id,
+                cast(Sequence[OperationRecord], protos_to_submit),
+            )
+        )
+
+        # This returns counts, which is completely incorrect
+        # TODO: Fix this
+        return counts
+
+    @trace_method("LogService.subscribe", OpenTelemetryGranularity.ALL)
+    @override
+    def subscribe(
+        self,
+        collection_id: UUID,
+        consume_fn: ConsumerCallbackFn,
+        start: Optional[SeqId] = None,
+        end: Optional[SeqId] = None,
+        id: Optional[UUID] = None,
+    ) -> UUID:
+        logger.info(f"Subscribing to log for {collection_id}, noop for logservice")
+        return UUID(int=0)
+
+    @trace_method("LogService.unsubscribe", OpenTelemetryGranularity.ALL)
+    @override
+    def unsubscribe(self, subscription_id: UUID) -> None:
+        logger.info(f"Unsubscribing from {subscription_id}, noop for logservice")
+
+    @override
+    def min_seqid(self) -> SeqId:
+        return 0
+
+    @override
+    def max_seqid(self) -> SeqId:
+        return sys.maxsize
+
+    @property
+    @override
+    def max_batch_size(self) -> int:
+        return 100
+
+    def push_logs(self, collection_id: UUID, records: Sequence[OperationRecord]) -> int:
+        request = PushLogsRequest(collection_id=str(collection_id), records=records)
+        response = self._log_service_stub.PushLogs(
+            request, timeout=self._request_timeout_seconds
+        )
+        return response.record_count  # type: ignore
+
+    def pull_logs(
+        self, collection_id: UUID, start_offset: int, batch_size: int
+    ) -> Sequence[LogRecord]:
+        request = PullLogsRequest(
+            collection_id=str(collection_id),
+            start_from_offset=start_offset,
+            batch_size=batch_size,
+            end_timestamp=time.time_ns(),
+        )
+        response = self._log_service_stub.PullLogs(
+            request, timeout=self._request_timeout_seconds
+        )
+        return response.records  # type: ignore

python/user_packages/Python313/site-packages/chromadb/proto/.gitignore

@@ -0,0 +1,2 @@
+*_pb2.py*
+*_pb2_grpc.py

python/user_packages/Python313/site-packages/chromadb/proto/convert.py

@@ -0,0 +1,688 @@
+from typing import Dict, Optional, Sequence, Tuple, TypedDict, Union, cast
+from uuid import UUID
+import json
+
+import numpy as np
+from numpy.typing import NDArray
+
+import chromadb.proto.chroma_pb2 as chroma_pb
+import chromadb.proto.query_executor_pb2 as query_pb
+from chromadb.api.collection_configuration import (
+    collection_configuration_to_json_str,
+)
+from chromadb.api.types import Embedding, Where, WhereDocument
+from chromadb.execution.expression.operator import (
+    KNN,
+    Filter,
+    Limit,
+    Projection,
+    Scan,
+)
+from chromadb.execution.expression.plan import CountPlan, GetPlan, KNNPlan
+from chromadb.types import (
+    Collection,
+    LogRecord,
+    Metadata,
+    Operation,
+    OperationRecord,
+    RequestVersionContext,
+    ScalarEncoding,
+    Segment,
+    SegmentScope,
+    SeqId,
+    UpdateMetadata,
+    Vector,
+    VectorEmbeddingRecord,
+    VectorQueryResult,
+)
+
+
+class ProjectionRecord(TypedDict):
+    id: str
+    document: Optional[str]
+    embedding: Optional[Vector]
+    metadata: Optional[Metadata]
+
+
+class KNNProjectionRecord(TypedDict):
+    record: ProjectionRecord
+    distance: Optional[float]
+
+
+# TODO: Unit tests for this file, handling optional states etc
+def to_proto_vector(vector: Vector, encoding: ScalarEncoding) -> chroma_pb.Vector:
+    if encoding == ScalarEncoding.FLOAT32:
+        as_bytes = np.array(vector, dtype=np.float32).tobytes()
+        proto_encoding = chroma_pb.ScalarEncoding.FLOAT32
+    elif encoding == ScalarEncoding.INT32:
+        as_bytes = np.array(vector, dtype=np.int32).tobytes()
+        proto_encoding = chroma_pb.ScalarEncoding.INT32
+    else:
+        raise ValueError(
+            f"Unknown encoding {encoding}, expected one of {ScalarEncoding.FLOAT32} \
+            or {ScalarEncoding.INT32}"
+        )
+
+    return chroma_pb.Vector(
+        dimension=vector.size, vector=as_bytes, encoding=proto_encoding
+    )
+
+
+def from_proto_vector(vector: chroma_pb.Vector) -> Tuple[Embedding, ScalarEncoding]:
+    encoding = vector.encoding
+    as_array: Union[NDArray[np.int32], NDArray[np.float32]]
+    if encoding == chroma_pb.ScalarEncoding.FLOAT32:
+        as_array = np.frombuffer(vector.vector, dtype=np.float32)
+        out_encoding = ScalarEncoding.FLOAT32
+    elif encoding == chroma_pb.ScalarEncoding.INT32:
+        as_array = np.frombuffer(vector.vector, dtype=np.int32)
+        out_encoding = ScalarEncoding.INT32
+    else:
+        raise ValueError(
+            f"Unknown encoding {encoding}, expected one of \
+            {chroma_pb.ScalarEncoding.FLOAT32} or {chroma_pb.ScalarEncoding.INT32}"
+        )
+
+    return (as_array, out_encoding)
+
+
+def from_proto_operation(operation: chroma_pb.Operation) -> Operation:
+    if operation == chroma_pb.Operation.ADD:
+        return Operation.ADD
+    elif operation == chroma_pb.Operation.UPDATE:
+        return Operation.UPDATE
+    elif operation == chroma_pb.Operation.UPSERT:
+        return Operation.UPSERT
+    elif operation == chroma_pb.Operation.DELETE:
+        return Operation.DELETE
+    else:
+        # TODO: full error
+        raise RuntimeError(f"Unknown operation {operation}")
+
+
+def from_proto_metadata(metadata: chroma_pb.UpdateMetadata) -> Optional[Metadata]:
+    return cast(Optional[Metadata], _from_proto_metadata_handle_none(metadata, False))
+
+
+def from_proto_update_metadata(
+    metadata: chroma_pb.UpdateMetadata,
+) -> Optional[UpdateMetadata]:
+    return cast(
+        Optional[UpdateMetadata], _from_proto_metadata_handle_none(metadata, True)
+    )
+
+
+def _from_proto_metadata_handle_none(
+    metadata: chroma_pb.UpdateMetadata, is_update: bool
+) -> Optional[Union[UpdateMetadata, Metadata]]:
+    if not metadata.metadata:
+        return None
+    out_metadata: Dict[str, Union[str, int, float, bool, None]] = {}
+    for key, value in metadata.metadata.items():
+        if value.HasField("bool_value"):
+            out_metadata[key] = value.bool_value
+        elif value.HasField("string_value"):
+            out_metadata[key] = value.string_value
+        elif value.HasField("int_value"):
+            out_metadata[key] = value.int_value
+        elif value.HasField("float_value"):
+            out_metadata[key] = value.float_value
+        elif is_update:
+            out_metadata[key] = None
+        else:
+            raise ValueError(f"Metadata key {key} value cannot be None")
+    return out_metadata
+
+
+def to_proto_update_metadata(metadata: UpdateMetadata) -> chroma_pb.UpdateMetadata:
+    return chroma_pb.UpdateMetadata(
+        metadata={k: to_proto_metadata_update_value(v) for k, v in metadata.items()}
+    )
+
+
+def from_proto_submit(
+    operation_record: chroma_pb.OperationRecord, seq_id: SeqId
+) -> LogRecord:
+    embedding, encoding = from_proto_vector(operation_record.vector)
+    record = LogRecord(
+        log_offset=seq_id,
+        record=OperationRecord(
+            id=operation_record.id,
+            embedding=embedding,
+            encoding=encoding,
+            metadata=from_proto_update_metadata(operation_record.metadata),
+            operation=from_proto_operation(operation_record.operation),
+        ),
+    )
+    return record
+
+
+def from_proto_segment(segment: chroma_pb.Segment) -> Segment:
+    return Segment(
+        id=UUID(hex=segment.id),
+        type=segment.type,
+        scope=from_proto_segment_scope(segment.scope),
+        collection=UUID(hex=segment.collection),
+        metadata=from_proto_metadata(segment.metadata)
+        if segment.HasField("metadata")
+        else None,
+        file_paths={
+            name: [path for path in paths.paths]
+            for name, paths in segment.file_paths.items()
+        },
+    )
+
+
+def to_proto_segment(segment: Segment) -> chroma_pb.Segment:
+    return chroma_pb.Segment(
+        id=segment["id"].hex,
+        type=segment["type"],
+        scope=to_proto_segment_scope(segment["scope"]),
+        collection=segment["collection"].hex,
+        metadata=None
+        if segment["metadata"] is None
+        else to_proto_update_metadata(segment["metadata"]),
+        file_paths={
+            name: chroma_pb.FilePaths(paths=paths)
+            for name, paths in segment["file_paths"].items()
+        },
+    )
+
+
+def from_proto_segment_scope(segment_scope: chroma_pb.SegmentScope) -> SegmentScope:
+    if segment_scope == chroma_pb.SegmentScope.VECTOR:
+        return SegmentScope.VECTOR
+    elif segment_scope == chroma_pb.SegmentScope.METADATA:
+        return SegmentScope.METADATA
+    elif segment_scope == chroma_pb.SegmentScope.RECORD:
+        return SegmentScope.RECORD
+    else:
+        raise RuntimeError(f"Unknown segment scope {segment_scope}")
+
+
+def to_proto_segment_scope(segment_scope: SegmentScope) -> chroma_pb.SegmentScope:
+    if segment_scope == SegmentScope.VECTOR:
+        return chroma_pb.SegmentScope.VECTOR
+    elif segment_scope == SegmentScope.METADATA:
+        return chroma_pb.SegmentScope.METADATA
+    elif segment_scope == SegmentScope.RECORD:
+        return chroma_pb.SegmentScope.RECORD
+    else:
+        raise RuntimeError(f"Unknown segment scope {segment_scope}")
+
+
+def to_proto_metadata_update_value(
+    value: Union[str, int, float, bool, None]
+) -> chroma_pb.UpdateMetadataValue:
+    # Be careful with the order here. Since bools are a subtype of int in python,
+    # isinstance(value, bool) and isinstance(value, int) both return true
+    # for a value of bool type.
+    if isinstance(value, bool):
+        return chroma_pb.UpdateMetadataValue(bool_value=value)
+    elif isinstance(value, str):
+        return chroma_pb.UpdateMetadataValue(string_value=value)
+    elif isinstance(value, int):
+        return chroma_pb.UpdateMetadataValue(int_value=value)
+    elif isinstance(value, float):
+        return chroma_pb.UpdateMetadataValue(float_value=value)
+    # None is used to delete the metadata key.
+    elif value is None:
+        return chroma_pb.UpdateMetadataValue()
+    else:
+        raise ValueError(
+            f"Unknown metadata value type {type(value)}, expected one of str, int, \
+            float, or None"
+        )
+
+
+def from_proto_collection(collection: chroma_pb.Collection) -> Collection:
+    return Collection(
+        id=UUID(hex=collection.id),
+        name=collection.name,
+        configuration_json=json.loads(collection.configuration_json_str),
+        metadata=from_proto_metadata(collection.metadata)
+        if collection.HasField("metadata")
+        else None,
+        dimension=collection.dimension
+        if collection.HasField("dimension") and collection.dimension
+        else None,
+        database=collection.database,
+        tenant=collection.tenant,
+        version=collection.version,
+        log_position=collection.log_position,
+    )
+
+
+def to_proto_collection(collection: Collection) -> chroma_pb.Collection:
+    return chroma_pb.Collection(
+        id=collection["id"].hex,
+        name=collection["name"],
+        configuration_json_str=collection_configuration_to_json_str(
+            collection.get_configuration()
+        ),
+        metadata=None
+        if collection["metadata"] is None
+        else to_proto_update_metadata(collection["metadata"]),
+        dimension=collection["dimension"],
+        tenant=collection["tenant"],
+        database=collection["database"],
+        log_position=collection["log_position"],
+        version=collection["version"],
+    )
+
+
+def to_proto_operation(operation: Operation) -> chroma_pb.Operation:
+    if operation == Operation.ADD:
+        return chroma_pb.Operation.ADD
+    elif operation == Operation.UPDATE:
+        return chroma_pb.Operation.UPDATE
+    elif operation == Operation.UPSERT:
+        return chroma_pb.Operation.UPSERT
+    elif operation == Operation.DELETE:
+        return chroma_pb.Operation.DELETE
+    else:
+        raise ValueError(
+            f"Unknown operation {operation}, expected one of {Operation.ADD}, \
+            {Operation.UPDATE}, {Operation.UPDATE}, or {Operation.DELETE}"
+        )
+
+
+def to_proto_submit(
+    submit_record: OperationRecord,
+) -> chroma_pb.OperationRecord:
+    vector = None
+    if submit_record["embedding"] is not None and submit_record["encoding"] is not None:
+        vector = to_proto_vector(submit_record["embedding"], submit_record["encoding"])
+
+    metadata = None
+    if submit_record["metadata"] is not None:
+        metadata = to_proto_update_metadata(submit_record["metadata"])
+
+    return chroma_pb.OperationRecord(
+        id=submit_record["id"],
+        vector=vector,
+        metadata=metadata,
+        operation=to_proto_operation(submit_record["operation"]),
+    )
+
+
+def from_proto_vector_embedding_record(
+    embedding_record: chroma_pb.VectorEmbeddingRecord,
+) -> VectorEmbeddingRecord:
+    return VectorEmbeddingRecord(
+        id=embedding_record.id,
+        embedding=from_proto_vector(embedding_record.vector)[0],
+    )
+
+
+def to_proto_vector_embedding_record(
+    embedding_record: VectorEmbeddingRecord,
+    encoding: ScalarEncoding,
+) -> chroma_pb.VectorEmbeddingRecord:
+    return chroma_pb.VectorEmbeddingRecord(
+        id=embedding_record["id"],
+        vector=to_proto_vector(embedding_record["embedding"], encoding),
+    )
+
+
+def from_proto_vector_query_result(
+    vector_query_result: chroma_pb.VectorQueryResult,
+) -> VectorQueryResult:
+    return VectorQueryResult(
+        id=vector_query_result.id,
+        distance=vector_query_result.distance,
+        embedding=from_proto_vector(vector_query_result.vector)[0],
+    )
+
+
+def from_proto_request_version_context(
+    request_version_context: chroma_pb.RequestVersionContext,
+) -> RequestVersionContext:
+    return RequestVersionContext(
+        collection_version=request_version_context.collection_version,
+        log_position=request_version_context.log_position,
+    )
+
+
+def to_proto_request_version_context(
+    request_version_context: RequestVersionContext,
+) -> chroma_pb.RequestVersionContext:
+    return chroma_pb.RequestVersionContext(
+        collection_version=request_version_context["collection_version"],
+        log_position=request_version_context["log_position"],
+    )
+
+
+def to_proto_where(where: Where) -> chroma_pb.Where:
+    response = chroma_pb.Where()
+    if len(where) != 1:
+        raise ValueError(f"Expected where to have exactly one operator, got {where}")
+
+    for key, value in where.items():
+        if not isinstance(key, str):
+            raise ValueError(f"Expected where key to be a str, got {key}")
+
+        if key == "$and" or key == "$or":
+            if not isinstance(value, list):
+                raise ValueError(
+                    f"Expected where value for $and or $or to be a list of where expressions, got {value}"
+                )
+            children: chroma_pb.WhereChildren = chroma_pb.WhereChildren(
+                children=[to_proto_where(w) for w in value]
+            )
+            if key == "$and":
+                children.operator = chroma_pb.BooleanOperator.AND
+            else:
+                children.operator = chroma_pb.BooleanOperator.OR
+
+            response.children.CopyFrom(children)
+            return response
+
+        # At this point we know we're at a direct comparison. It can either
+        # be of the form {"key": "value"} or {"key": {"$operator": "value"}}.
+
+        dc = chroma_pb.DirectComparison()
+        dc.key = key
+
+        if not isinstance(value, dict):
+            # {'key': 'value'} case
+            if type(value) is str:
+                ssc = chroma_pb.SingleStringComparison()
+                ssc.value = value
+                ssc.comparator = chroma_pb.GenericComparator.EQ
+                dc.single_string_operand.CopyFrom(ssc)
+            elif type(value) is bool:
+                sbc = chroma_pb.SingleBoolComparison()
+                sbc.value = value
+                sbc.comparator = chroma_pb.GenericComparator.EQ
+                dc.single_bool_operand.CopyFrom(sbc)
+            elif type(value) is int:
+                sic = chroma_pb.SingleIntComparison()
+                sic.value = value
+                sic.generic_comparator = chroma_pb.GenericComparator.EQ
+                dc.single_int_operand.CopyFrom(sic)
+            elif type(value) is float:
+                sdc = chroma_pb.SingleDoubleComparison()
+                sdc.value = value
+                sdc.generic_comparator = chroma_pb.GenericComparator.EQ
+                dc.single_double_operand.CopyFrom(sdc)
+            else:
+                raise ValueError(
+                    f"Expected where value to be a string, int, or float, got {value}"
+                )
+        else:
+            for operator, operand in value.items():
+                if operator in ["$in", "$nin"]:
+                    if not isinstance(operand, list):
+                        raise ValueError(
+                            f"Expected where value for $in or $nin to be a list of values, got {value}"
+                        )
+                    if len(operand) == 0 or not all(
+                        isinstance(x, type(operand[0])) for x in operand
+                    ):
+                        raise ValueError(
+                            f"Expected where operand value to be a non-empty list, and all values to be of the same type "
+                            f"got {operand}"
+                        )
+                    list_operator = None
+                    if operator == "$in":
+                        list_operator = chroma_pb.ListOperator.IN
+                    else:
+                        list_operator = chroma_pb.ListOperator.NIN
+                    if type(operand[0]) is str:
+                        slo = chroma_pb.StringListComparison()
+                        for x in operand:
+                            slo.values.extend([x])  # type: ignore
+                        slo.list_operator = list_operator
+                        dc.string_list_operand.CopyFrom(slo)
+                    elif type(operand[0]) is bool:
+                        blo = chroma_pb.BoolListComparison()
+                        for x in operand:
+                            blo.values.extend([x])  # type: ignore
+                        blo.list_operator = list_operator
+                        dc.bool_list_operand.CopyFrom(blo)
+                    elif type(operand[0]) is int:
+                        ilo = chroma_pb.IntListComparison()
+                        for x in operand:
+                            ilo.values.extend([x])  # type: ignore
+                        ilo.list_operator = list_operator
+                        dc.int_list_operand.CopyFrom(ilo)
+                    elif type(operand[0]) is float:
+                        dlo = chroma_pb.DoubleListComparison()
+                        for x in operand:
+                            dlo.values.extend([x])  # type: ignore
+                        dlo.list_operator = list_operator
+                        dc.double_list_operand.CopyFrom(dlo)
+                    else:
+                        raise ValueError(
+                            f"Expected where operand value to be a list of strings, ints, or floats, got {operand}"
+                        )
+                elif operator in ["$eq", "$ne", "$gt", "$lt", "$gte", "$lte"]:
+                    # Direct comparison to a single value.
+                    if type(operand) is str:
+                        ssc = chroma_pb.SingleStringComparison()
+                        ssc.value = operand
+                        if operator == "$eq":
+                            ssc.comparator = chroma_pb.GenericComparator.EQ
+                        elif operator == "$ne":
+                            ssc.comparator = chroma_pb.GenericComparator.NE
+                        else:
+                            raise ValueError(
+                                f"Expected where operator to be $eq or $ne, got {operator}"
+                            )
+                        dc.single_string_operand.CopyFrom(ssc)
+                    elif type(operand) is bool:
+                        sbc = chroma_pb.SingleBoolComparison()
+                        sbc.value = operand
+                        if operator == "$eq":
+                            sbc.comparator = chroma_pb.GenericComparator.EQ
+                        elif operator == "$ne":
+                            sbc.comparator = chroma_pb.GenericComparator.NE
+                        else:
+                            raise ValueError(
+                                f"Expected where operator to be $eq or $ne, got {operator}"
+                            )
+                        dc.single_bool_operand.CopyFrom(sbc)
+                    elif type(operand) is int:
+                        sic = chroma_pb.SingleIntComparison()
+                        sic.value = operand
+                        if operator == "$eq":
+                            sic.generic_comparator = chroma_pb.GenericComparator.EQ
+                        elif operator == "$ne":
+                            sic.generic_comparator = chroma_pb.GenericComparator.NE
+                        elif operator == "$gt":
+                            sic.number_comparator = chroma_pb.NumberComparator.GT
+                        elif operator == "$lt":
+                            sic.number_comparator = chroma_pb.NumberComparator.LT
+                        elif operator == "$gte":
+                            sic.number_comparator = chroma_pb.NumberComparator.GTE
+                        elif operator == "$lte":
+                            sic.number_comparator = chroma_pb.NumberComparator.LTE
+                        else:
+                            raise ValueError(
+                                f"Expected where operator to be one of $eq, $ne, $gt, $lt, $gte, $lte, got {operator}"
+                            )
+                        dc.single_int_operand.CopyFrom(sic)
+                    elif type(operand) is float:
+                        sfc = chroma_pb.SingleDoubleComparison()
+                        sfc.value = operand
+                        if operator == "$eq":
+                            sfc.generic_comparator = chroma_pb.GenericComparator.EQ
+                        elif operator == "$ne":
+                            sfc.generic_comparator = chroma_pb.GenericComparator.NE
+                        elif operator == "$gt":
+                            sfc.number_comparator = chroma_pb.NumberComparator.GT
+                        elif operator == "$lt":
+                            sfc.number_comparator = chroma_pb.NumberComparator.LT
+                        elif operator == "$gte":
+                            sfc.number_comparator = chroma_pb.NumberComparator.GTE
+                        elif operator == "$lte":
+                            sfc.number_comparator = chroma_pb.NumberComparator.LTE
+                        else:
+                            raise ValueError(
+                                f"Expected where operator to be one of $eq, $ne, $gt, $lt, $gte, $lte, got {operator}"
+                            )
+                        dc.single_double_operand.CopyFrom(sfc)
+                    else:
+                        raise ValueError(
+                            f"Expected where operand value to be a string, int, or float, got {operand}"
+                        )
+                else:
+                    # This case should never happen, as we've already
+                    # handled the case for direct comparisons.
+                    pass
+
+        response.direct_comparison.CopyFrom(dc)
+    return response
+
+
+def to_proto_where_document(where_document: WhereDocument) -> chroma_pb.WhereDocument:
+    response = chroma_pb.WhereDocument()
+    if len(where_document) != 1:
+        raise ValueError(
+            f"Expected where_document to have exactly one operator, got {where_document}"
+        )
+
+    for operator, operand in where_document.items():
+        if operator == "$and" or operator == "$or":
+            # Nested "$and" or "$or" expression.
+            if not isinstance(operand, list):
+                raise ValueError(
+                    f"Expected where_document value for $and or $or to be a list of where_document expressions, got {operand}"
+                )
+            children: chroma_pb.WhereDocumentChildren = chroma_pb.WhereDocumentChildren(
+                children=[to_proto_where_document(w) for w in operand]
+            )
+            if operator == "$and":
+                children.operator = chroma_pb.BooleanOperator.AND
+            else:
+                children.operator = chroma_pb.BooleanOperator.OR
+
+            response.children.CopyFrom(children)
+        else:
+            # Direct "$contains" or "$not_contains" comparison to a single
+            # value.
+            if not isinstance(operand, str):
+                raise ValueError(
+                    f"Expected where_document operand to be a string, got {operand}"
+                )
+            dwd = chroma_pb.DirectWhereDocument()
+            dwd.document = operand
+            if operator == "$contains":
+                dwd.operator = chroma_pb.WhereDocumentOperator.CONTAINS
+            elif operator == "$not_contains":
+                dwd.operator = chroma_pb.WhereDocumentOperator.NOT_CONTAINS
+            else:
+                raise ValueError(
+                    f"Expected where_document operator to be one of $contains, $not_contains, got {operator}"
+                )
+            response.direct.CopyFrom(dwd)
+
+    return response
+
+
+def to_proto_scan(scan: Scan) -> query_pb.ScanOperator:
+    return query_pb.ScanOperator(
+        collection=to_proto_collection(scan.collection),
+        knn=to_proto_segment(scan.knn),
+        metadata=to_proto_segment(scan.metadata),
+        record=to_proto_segment(scan.record),
+    )
+
+
+def to_proto_filter(filter: Filter) -> query_pb.FilterOperator:
+    return query_pb.FilterOperator(
+        ids=chroma_pb.UserIds(ids=filter.user_ids)
+        if filter.user_ids is not None
+        else None,
+        where=to_proto_where(filter.where) if filter.where else None,
+        where_document=to_proto_where_document(filter.where_document)
+        if filter.where_document
+        else None,
+    )
+
+
+def to_proto_knn(knn: KNN) -> query_pb.KNNOperator:
+    return query_pb.KNNOperator(
+        embeddings=[
+            to_proto_vector(vector=embedding, encoding=ScalarEncoding.FLOAT32)
+            for embedding in knn.embeddings
+        ],
+        fetch=knn.fetch,
+    )
+
+
+def to_proto_limit(limit: Limit) -> query_pb.LimitOperator:
+    return query_pb.LimitOperator(offset=limit.offset, limit=limit.limit)
+
+
+def to_proto_projection(projection: Projection) -> query_pb.ProjectionOperator:
+    return query_pb.ProjectionOperator(
+        document=projection.document,
+        embedding=projection.embedding,
+        metadata=projection.metadata,
+    )
+
+
+def to_proto_knn_projection(projection: Projection) -> query_pb.KNNProjectionOperator:
+    return query_pb.KNNProjectionOperator(
+        projection=to_proto_projection(projection), distance=projection.rank
+    )
+
+
+def to_proto_count_plan(count: CountPlan) -> query_pb.CountPlan:
+    return query_pb.CountPlan(scan=to_proto_scan(count.scan))
+
+
+def from_proto_count_result(result: query_pb.CountResult) -> int:
+    return result.count
+
+
+def to_proto_get_plan(get: GetPlan) -> query_pb.GetPlan:
+    return query_pb.GetPlan(
+        scan=to_proto_scan(get.scan),
+        filter=to_proto_filter(get.filter),
+        limit=to_proto_limit(get.limit),
+        projection=to_proto_projection(get.projection),
+    )
+
+
+def from_proto_projection_record(record: query_pb.ProjectionRecord) -> ProjectionRecord:
+    return ProjectionRecord(
+        id=record.id,
+        document=record.document if record.document else None,
+        embedding=from_proto_vector(record.embedding)[0]
+        if record.embedding is not None
+        else None,
+        metadata=from_proto_metadata(record.metadata),
+    )
+
+
+def from_proto_get_result(result: query_pb.GetResult) -> Sequence[ProjectionRecord]:
+    return [from_proto_projection_record(record) for record in result.records]
+
+
+def to_proto_knn_plan(knn: KNNPlan) -> query_pb.KNNPlan:
+    return query_pb.KNNPlan(
+        scan=to_proto_scan(knn.scan),
+        filter=to_proto_filter(knn.filter),
+        knn=to_proto_knn(knn.knn),
+        projection=to_proto_knn_projection(knn.projection),
+    )
+
+
+def from_proto_knn_projection_record(
+    record: query_pb.KNNProjectionRecord,
+) -> KNNProjectionRecord:
+    return KNNProjectionRecord(
+        record=from_proto_projection_record(record.record), distance=record.distance
+    )
+
+
+def from_proto_knn_batch_result(
+    results: query_pb.KNNBatchResult,
+) -> Sequence[Sequence[KNNProjectionRecord]]:
+    return [
+        [from_proto_knn_projection_record(record) for record in result.records]
+        for result in results.results
+    ]

python/user_packages/Python313/site-packages/chromadb/proto/utils.py

@@ -0,0 +1,68 @@
+from typing import Optional, Set
+import grpc
+from tenacity import retry, stop_after_attempt, wait_exponential_jitter, retry_if_result
+from opentelemetry.trace import Span
+
+
+class RetryOnRpcErrorClientInterceptor(
+    grpc.UnaryUnaryClientInterceptor, grpc.UnaryStreamClientInterceptor
+):
+    """
+    A gRPC client interceptor that retries RPCs on specific status codes. By default, it retries on UNAVAILABLE and UNKNOWN status codes.
+
+    This interceptor should be placed after the OpenTelemetry interceptor in the interceptor list.
+    """
+
+    max_attempts: int
+    retryable_status_codes: Set[grpc.StatusCode]
+
+    def __init__(
+        self,
+        max_attempts: int = 5,
+        retryable_status_codes: Set[grpc.StatusCode] = set(
+            [grpc.StatusCode.UNAVAILABLE, grpc.StatusCode.UNKNOWN]
+        ),
+    ) -> None:
+        self.max_attempts = max_attempts
+        self.retryable_status_codes = retryable_status_codes
+
+    def _intercept_call(self, continuation, client_call_details, request_or_iterator):
+        sleep_span: Optional[Span] = None
+
+        def before_sleep(_):
+            from chromadb.telemetry.opentelemetry import tracer
+
+            nonlocal sleep_span
+            if tracer is not None:
+                sleep_span = tracer.start_span("Waiting to retry RPC")
+
+        @retry(
+            wait=wait_exponential_jitter(0.1, jitter=0.1),
+            stop=stop_after_attempt(self.max_attempts),
+            retry=retry_if_result(lambda x: x.code() in self.retryable_status_codes),
+            before_sleep=before_sleep,
+        )
+        def wrapped(*args, **kwargs):
+            nonlocal sleep_span
+            if sleep_span is not None:
+                sleep_span.end()
+                sleep_span = None
+            return continuation(*args, **kwargs)
+
+        return wrapped(client_call_details, request_or_iterator)
+
+    def intercept_unary_unary(self, continuation, client_call_details, request):
+        return self._intercept_call(continuation, client_call_details, request)
+
+    def intercept_unary_stream(self, continuation, client_call_details, request):
+        return self._intercept_call(continuation, client_call_details, request)
+
+    def intercept_stream_unary(
+        self, continuation, client_call_details, request_iterator
+    ):
+        return self._intercept_call(continuation, client_call_details, request_iterator)
+
+    def intercept_stream_stream(
+        self, continuation, client_call_details, request_iterator
+    ):
+        return self._intercept_call(continuation, client_call_details, request_iterator)

python/user_packages/Python313/site-packages/chromadb/quota/__init__.py

@@ -0,0 +1,71 @@
+from abc import abstractmethod
+from enum import Enum
+from typing import Dict, Any, Optional
+from uuid import UUID
+
+from chromadb.api.types import (
+    Embeddings,
+    Metadatas,
+    Documents,
+    URIs,
+    IDs,
+    CollectionMetadata,
+    Where,
+    WhereDocument,
+)
+from chromadb.config import Component, System
+
+
+class Action(str, Enum):
+    CREATE_DATABASE = "create_database"
+    CREATE_COLLECTION = "create_collection"
+    LIST_COLLECTIONS = "list_collections"
+    UPDATE_COLLECTION = "update_collection"
+    ADD = "add"
+    GET = "get"
+    DELETE = "delete"
+    UPDATE = "update"
+    UPSERT = "upsert"
+    QUERY = "query"
+
+
+class QuotaEnforcer(Component):
+    """
+    Exposes hooks to enforce quotas.
+    """
+
+    def __init__(self, system: System) -> None:
+        super().__init__(system)
+
+    @abstractmethod
+    def set_context(self, context: Dict[str, Any]) -> None:
+        """
+        Sets the context for a given request.
+        """
+        pass
+
+    @abstractmethod
+    def enforce(
+        self,
+        action: Action,
+        tenant: str,
+        metadatas: Optional[Metadatas] = None,
+        documents: Optional[Documents] = None,
+        embeddings: Optional[Embeddings] = None,
+        uris: Optional[URIs] = None,
+        ids: Optional[IDs] = None,
+        name: Optional[str] = None,
+        new_name: Optional[str] = None,
+        metadata: Optional[CollectionMetadata] = None,
+        new_metadata: Optional[CollectionMetadata] = None,
+        limit: Optional[int] = None,
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        n_results: Optional[int] = None,
+        query_embeddings: Optional[Embeddings] = None,
+        collection_id: Optional[UUID] = None,
+    ) -> None:
+        """
+        Enforces a quota.
+        """
+        pass

python/user_packages/Python313/site-packages/chromadb/rate_limit/__init__.py

@@ -0,0 +1,36 @@
+from abc import abstractmethod
+from typing import Awaitable, Callable, TypeVar, Any
+from chromadb.config import Component, System
+
+T = TypeVar("T", bound=Callable[..., Any])
+A = TypeVar("A", bound=Awaitable[Any])
+
+
+class RateLimitEnforcer(Component):
+    """
+    Rate limit enforcer.
+
+    Implemented as a wrapper around server functions to block requests if rate limits are exceeded.
+    """
+
+    def __init__(self, system: System) -> None:
+        super().__init__(system)
+
+    @abstractmethod
+    def rate_limit(self, func: T) -> T:
+        pass
+
+
+class AsyncRateLimitEnforcer(Component):
+    """
+    Rate limit enforcer.
+
+    Implemented as a wrapper around async functions to block requests if rate limits are exceeded.
+    """
+
+    def __init__(self, system: System) -> None:
+        super().__init__(system)
+
+    @abstractmethod
+    def rate_limit(self, func: A) -> A:
+        pass

python/user_packages/Python313/site-packages/chromadb/segment/__init__.py

@@ -0,0 +1,125 @@
+from typing import Optional, Sequence, TypeVar
+from abc import abstractmethod
+from chromadb.types import (
+    Collection,
+    MetadataEmbeddingRecord,
+    Operation,
+    RequestVersionContext,
+    VectorEmbeddingRecord,
+    Where,
+    WhereDocument,
+    VectorQuery,
+    VectorQueryResult,
+    Segment,
+    SeqId,
+    Metadata,
+)
+from chromadb.config import Component, System
+from uuid import UUID
+from enum import Enum
+
+
+class SegmentType(Enum):
+    SQLITE = "urn:chroma:segment/metadata/sqlite"
+    HNSW_LOCAL_MEMORY = "urn:chroma:segment/vector/hnsw-local-memory"
+    HNSW_LOCAL_PERSISTED = "urn:chroma:segment/vector/hnsw-local-persisted"
+    HNSW_DISTRIBUTED = "urn:chroma:segment/vector/hnsw-distributed"
+    BLOCKFILE_RECORD = "urn:chroma:segment/record/blockfile"
+    BLOCKFILE_METADATA = "urn:chroma:segment/metadata/blockfile"
+
+
+class SegmentImplementation(Component):
+    @abstractmethod
+    def __init__(self, sytstem: System, segment: Segment):
+        pass
+
+    @abstractmethod
+    def count(self, request_version_context: RequestVersionContext) -> int:
+        """Get the number of embeddings in this segment"""
+        pass
+
+    @abstractmethod
+    def max_seqid(self) -> SeqId:
+        """Get the maximum SeqID currently indexed by this segment"""
+        pass
+
+    @staticmethod
+    def propagate_collection_metadata(metadata: Metadata) -> Optional[Metadata]:
+        """Given an arbitrary metadata map (e.g, from a collection), validate it and
+        return metadata (if any) that is applicable and should be applied to the
+        segment. Validation errors will be reported to the user."""
+        return None
+
+    @abstractmethod
+    def delete(self) -> None:
+        """Delete the segment and all its data"""
+        ...
+
+
+S = TypeVar("S", bound=SegmentImplementation)
+
+
+class MetadataReader(SegmentImplementation):
+    """Embedding Metadata segment interface"""
+
+    @abstractmethod
+    def get_metadata(
+        self,
+        request_version_context: RequestVersionContext,
+        where: Optional[Where] = None,
+        where_document: Optional[WhereDocument] = None,
+        ids: Optional[Sequence[str]] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        include_metadata: bool = True,
+    ) -> Sequence[MetadataEmbeddingRecord]:
+        """Query for embedding metadata."""
+        pass
+
+
+class VectorReader(SegmentImplementation):
+    """Embedding Vector segment interface"""
+
+    @abstractmethod
+    def get_vectors(
+        self,
+        request_version_context: RequestVersionContext,
+        ids: Optional[Sequence[str]] = None,
+    ) -> Sequence[VectorEmbeddingRecord]:
+        """Get embeddings from the segment. If no IDs are provided, all embeddings are
+        returned."""
+        pass
+
+    @abstractmethod
+    def query_vectors(
+        self, query: VectorQuery
+    ) -> Sequence[Sequence[VectorQueryResult]]:
+        """Given a vector query, return the top-k nearest neighbors for vector in the
+        query."""
+        pass
+
+
+class SegmentManager(Component):
+    """Interface for a pluggable strategy for creating, retrieving and instantiating
+    segments as required"""
+
+    @abstractmethod
+    def prepare_segments_for_new_collection(
+        self, collection: Collection
+    ) -> Sequence[Segment]:
+        """Return the segments required for a new collection. Returns only segment data,
+        does not persist to the SysDB"""
+        pass
+
+    @abstractmethod
+    def delete_segments(self, collection_id: UUID) -> Sequence[UUID]:
+        """Delete any local state for all the segments associated with a collection, and
+        returns a sequence of their IDs. Does not update the SysDB."""
+        pass
+
+    @abstractmethod
+    def hint_use_collection(self, collection_id: UUID, hint_type: Operation) -> None:
+        """Signal to the segment manager that a collection is about to be used, so that
+        it can preload segments as needed. This is only a hint, and implementations are
+        free to ignore it."""
+        pass

python/user_packages/Python313/site-packages/chromadb/server/__init__.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+from chromadb.config import Settings
+
+
+class Server(ABC):
+    @abstractmethod
+    def __init__(self, settings: Settings):
+        pass

python/user_packages/Python313/site-packages/chromadb/telemetry/README.md

@@ -0,0 +1,10 @@
+# Telemetry
+
+This directory holds all the telemetry for Chroma.
+
+- `product/` contains anonymized product telemetry which we, Chroma, collect so we can
+  understand usage patterns. For more information, see https://docs.trychroma.com/telemetry.
+- `opentelemetry/` contains all of the config for Chroma's [OpenTelemetry](https://opentelemetry.io/docs/instrumentation/python/getting-started/)
+  setup. These metrics are *not* sent back to Chroma -- anyone operating a Chroma instance
+  can use the OpenTelemetry metrics and traces to understand how their instance of Chroma
+  is behaving.