diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml index 71f633f2ce9..0679c4110c4 100644 --- a/.github/workflows/pr.yml +++ b/.github/workflows/pr.yml @@ -194,6 +194,18 @@ jobs: uses: ./.github/workflows/_go-tests.yml secrets: inherit + typo-check: + name: Check for typos + runs-on: blacksmith-4vcpu-ubuntu-2404 + steps: + - name: Checkout chroma-core/chroma + uses: actions/checkout@v4 + + - name: Run typo check + uses: crate-ci/typos@v1.36.2 + with: + config: typos.toml + lint: name: Lint runs-on: blacksmith-4vcpu-ubuntu-2404 diff --git a/.github/workflows/release-dev-javascript-client.yml b/.github/workflows/release-dev-javascript-client.yml index 4ad96d0b839..9db31bfb4bb 100644 --- a/.github/workflows/release-dev-javascript-client.yml +++ b/.github/workflows/release-dev-javascript-client.yml @@ -25,7 +25,7 @@ jobs: echo "Push to main branch, releasing dev version to GH packages" echo "NPM_SCRIPT=release_dev" >> "$GITHUB_ENV" else - echo "The ref does not point to main, exiting workflow" # we alredy make the check above but this is a good practice + echo "The ref does not point to main, exiting workflow" # we already make the check above but this is a good practice exit 1 fi - name: Checkout diff --git a/bin/test.py b/bin/test.py index 61607b99146..3cb809ab08c 100644 --- a/bin/test.py +++ b/bin/test.py @@ -1,5 +1,5 @@ # Sanity check script to ensure that the Chroma client can connect -# and is capable of recieving data. +# and is capable of receiving data. import chromadb # run in in-memory mode diff --git a/chromadb/__init__.py b/chromadb/__init__.py index 26c3eb4f15a..3edc81e74f6 100644 --- a/chromadb/__init__.py +++ b/chromadb/__init__.py @@ -148,7 +148,7 @@ def EphemeralClient( settings = Settings() settings.is_persistent = False - # Make sure paramaters are the correct types -- users can pass anything. + # Make sure parameters are the correct types -- users can pass anything. tenant = str(tenant) database = str(database) @@ -175,7 +175,7 @@ def PersistentClient( settings.persist_directory = str(path) settings.is_persistent = True - # Make sure paramaters are the correct types -- users can pass anything. + # Make sure parameters are the correct types -- users can pass anything. tenant = str(tenant) database = str(database) @@ -189,7 +189,7 @@ def RustClient( database: str = DEFAULT_DATABASE, ) -> ClientAPI: """ - Creates an ephemeral or persistance instance of Chroma that saves to disk. + Creates an ephemeral or persistent instance of Chroma that saves to disk. This is useful for testing and development, but not recommended for production use. Args: @@ -204,7 +204,7 @@ def RustClient( settings.is_persistent = path is not None settings.persist_directory = path or "" - # Make sure paramaters are the correct types -- users can pass anything. + # Make sure parameters are the correct types -- users can pass anything. tenant = str(tenant) database = str(database) @@ -353,7 +353,7 @@ def CloudClient( if settings is None: settings = Settings() - # Make sure paramaters are the correct types -- users can pass anything. + # Make sure parameters are the correct types -- users can pass anything. tenant = tenant or os.environ.get("CHROMA_TENANT") if tenant is not None: tenant = str(tenant) @@ -392,7 +392,7 @@ def Client( database: The database to use for this client. Defaults to the default database. """ - # Make sure paramaters are the correct types -- users can pass anything. + # Make sure parameters are the correct types -- users can pass anything. tenant = str(tenant) database = str(database) diff --git a/chromadb/api/models/AsyncCollection.py b/chromadb/api/models/AsyncCollection.py index af72d515d3d..204a49c0c0b 100644 --- a/chromadb/api/models/AsyncCollection.py +++ b/chromadb/api/models/AsyncCollection.py @@ -464,7 +464,7 @@ async def delete( Args: ids: The ids of the embeddings to delete - where: A Where type dict used to filter the delection by. E.g. `{"$and": [{"color" : "red"}, {"price": {"$gte": 4.20}}]}`. Optional. + where: A Where type dict used to filter the deletion by. E.g. `{"$and": [{"color" : "red"}, {"price": {"$gte": 4.20}}]}`. Optional. where_document: A WhereDocument type dict used to filter the deletion by the document content. E.g. `{"$contains": "hello"}`. Optional. Returns: diff --git a/chromadb/api/models/Collection.py b/chromadb/api/models/Collection.py index 13bc47e0874..a1dee2f95bb 100644 --- a/chromadb/api/models/Collection.py +++ b/chromadb/api/models/Collection.py @@ -469,7 +469,7 @@ def delete( Args: ids: The ids of the embeddings to delete - where: A Where type dict used to filter the delection by. E.g. `{"$and": [{"color" : "red"}, {"price": {"$gte": 4.20}]}}`. Optional. + where: A Where type dict used to filter the deletion by. E.g. `{"$and": [{"color" : "red"}, {"price": {"$gte": 4.20}]}}`. Optional. where_document: A WhereDocument type dict used to filter the deletion by the document content. E.g. `{"$contains": "hello"}`. Optional. Returns: diff --git a/chromadb/api/models/CollectionCommon.py b/chromadb/api/models/CollectionCommon.py index 93dd10e96d8..f8b3106d6fa 100644 --- a/chromadb/api/models/CollectionCommon.py +++ b/chromadb/api/models/CollectionCommon.py @@ -251,7 +251,7 @@ def _validate_and_prepare_get_request( validate_ids(ids=unpacked_ids) validate_filter_set(filter_set=filters) - validate_include(include=include, dissalowed=["distances"]) + validate_include(include=include, disallowed=["distances"]) if "data" in include and self._data_loader is None: raise ValueError( @@ -260,7 +260,7 @@ def _validate_and_prepare_get_request( # Prepare request_include = include - # We need to include uris in the result from the API to load datas + # We need to include uris in the result from the API to load data if "data" in include and "uris" not in include: request_include.append("uris") @@ -322,7 +322,7 @@ def _validate_and_prepare_query_request( request_where = filters["where"] request_where_document = filters["where_document"] - # We need to manually include uris in the result from the API to load datas + # We need to manually include uris in the result from the API to load data request_include = include if "data" in request_include and "uris" not in request_include: request_include.append("uris") diff --git a/chromadb/api/rust.py b/chromadb/api/rust.py index 3cb21687918..3b1e582e871 100644 --- a/chromadb/api/rust.py +++ b/chromadb/api/rust.py @@ -86,7 +86,7 @@ def __init__(self, system: System): @override def start(self) -> None: # Construct the SqliteConfig - # TOOD: We should add a "config converter" + # TODO: 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" diff --git a/chromadb/api/segment.py b/chromadb/api/segment.py index fc9e6266cf4..6e78fbe7db9 100644 --- a/chromadb/api/segment.py +++ b/chromadb/api/segment.py @@ -428,7 +428,7 @@ def _search( database: str = DEFAULT_DATABASE, ) -> SearchResult: raise NotImplementedError( - "Seach is not implemented for SegmentAPI" + "Search is not implemented for SegmentAPI" ) @trace_method("SegmentAPI.delete_collection", OpenTelemetryGranularity.OPERATION) diff --git a/chromadb/api/types.py b/chromadb/api/types.py index cd98b0a2176..d8289f26118 100644 --- a/chromadb/api/types.py +++ b/chromadb/api/types.py @@ -1029,7 +1029,7 @@ def validate_where_document(where_document: WhereDocument) -> None: ) -def validate_include(include: Include, dissalowed: Optional[Include] = None) -> None: +def validate_include(include: Include, disallowed: Optional[Include] = None) -> None: """Validates include to ensure it is a list of strings. Since get does not allow distances, allow_distances is used to control if distances is allowed""" @@ -1046,9 +1046,9 @@ def validate_include(include: Include, dissalowed: Optional[Include] = None) -> f"Expected include item to be one of {', '.join(valid_items)}, got {item}" ) - if dissalowed is not None and any(item == e for e in dissalowed): + if disallowed is not None and any(item == e for e in disallowed): raise ValueError( - f"Include item cannot be one of {', '.join(dissalowed)}, got {item}" + f"Include item cannot be one of {', '.join(disallowed)}, got {item}" ) diff --git a/chromadb/auth/token_authn/__init__.py b/chromadb/auth/token_authn/__init__.py index 00c6ae3a449..9709fc8b29a 100644 --- a/chromadb/auth/token_authn/__init__.py +++ b/chromadb/auth/token_authn/__init__.py @@ -39,7 +39,7 @@ class TokenTransportHeader(str, Enum): """ - Accceptable token transport headers. + Acceptable token transport headers. """ # I don't love having this enum here -- it's weird to have an enum diff --git a/chromadb/config.py b/chromadb/config.py index d2a4a87b725..c9205a98e86 100644 --- a/chromadb/config.py +++ b/chromadb/config.py @@ -491,7 +491,7 @@ def reset_state(self) -> None: def get_class(fqn: str, type: Type[C]) -> Type[C]: - """Given a fully qualifed class name, import the module and return the class""" + """Given a fully qualified class name, import the module and return the class""" module_name, class_name = fqn.rsplit(".", 1) module = importlib.import_module(module_name) cls = getattr(module, class_name) diff --git a/chromadb/db/base.py b/chromadb/db/base.py index a9a5269c196..e82c1e250cf 100644 --- a/chromadb/db/base.py +++ b/chromadb/db/base.py @@ -111,7 +111,7 @@ def param(self, idx: int) -> pypika.Parameter: class ParameterValue(pypika.Parameter): # type: ignore """ - Wrapper class for PyPika paramters that allows the values for Parameters + Wrapper class for PyPika parameters that allows the values for Parameters to be expressed inline while building a query. See get_sql() for detailed usage information. """ diff --git a/chromadb/db/migrations.py b/chromadb/db/migrations.py index b4c15d0b19c..f92bf9c9ba1 100644 --- a/chromadb/db/migrations.py +++ b/chromadb/db/migrations.py @@ -75,7 +75,7 @@ class MigratableDB(SqlDB): 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 + migrations in the same directory, where "previous" is defined on lexicographical ordering of filenames. Migrations have a ascending numeric version number and a hash of the file contents. diff --git a/chromadb/db/mixins/sysdb.py b/chromadb/db/mixins/sysdb.py index 83d2244dde4..0919cf52dc0 100644 --- a/chromadb/db/mixins/sysdb.py +++ b/chromadb/db/mixins/sysdb.py @@ -857,7 +857,7 @@ def _insert_metadata( ) -> None: # It would be cleaner to use something like ON CONFLICT UPDATE here But that is # very difficult to do in a portable way (e.g sqlite and postgres have - # completely different sytnax) + # completely different syntax) add_attributes_to_current_span( { "num_keys": len(metadata), diff --git a/chromadb/experimental/density_relevance.ipynb b/chromadb/experimental/density_relevance.ipynb index c99ad533e82..97c71315e1f 100644 --- a/chromadb/experimental/density_relevance.ipynb +++ b/chromadb/experimental/density_relevance.ipynb @@ -1,542 +1,542 @@ { - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Density based retrieval relevance\n", - "\n", - "An important aspect of using embeddings-based retreival systems like Chroma is knowing whether there are relevant results to a given query in the existing dataset. As application developers, we would like to know when the system doesn't have enough information to complete a given query or task - we want to know what we don't know. \n", - "\n", - "This is particularly important in the case of retrieval-augmented generation, since it's [often been observed](https://arxiv.org/abs/2302.00093) that supplying irrelevant context serves to confuse the generative model, leading to the degredation of application performance in ways that are difficult to detect. \n", - "\n", - "Unlike a relational database which will not return results if none match the query, a vector search based retrieval system will return the $k$ nearest neighbors to any given query, whether they are relevant or not. \n", - "\n", - "One possible approach one might take is to tune a distance threshold, and reject any results which fall further away from the query. This might be suitable for certain kind of fixed datasets, but in practice such thresholds tend to be very brittle, and often serve to exclude many relevant results while not always excluding irrelevant ones. Additionally, the threshold will need to be continously adapted as the data changes. Additionally, such distance thresholds are not comparable across embedding models for a given dataset, nor across datasets for a given embedding model. \n", - "\n", - "We would prefer to find a data driven approach which can:\n", - "- produce a uniform and comparable measure of relevance for any dataset \n", - "- automatically adapt as the underlying data changes \n", - "- is relatively inexpensive to compute\n", - "\n", - "This notebook demonstrates one possible such approach, which relies on the distribution of distances (pseudo 'density') between points in a given dataset. For a given result, we use compute the percentile the result's distance to the query falls into with respect to the overall distribution of distances in the dataset. This approach produces a uniform measure of relevance for any dataset, and is relatively cheap to compute, and can be computed online as data mutates. \n", - "\n", - "This approach is still very preliminary, and we welcome contributions and alternative approaches - some ideas are listed at the end of this notebook." - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Preliminaries" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Install required packages\n", - "\n", - "import sys\n", - "!{sys.executable} -m pip install chromadb numpy umap-learn[plot] matplotlib tqdm datasets" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Dataset\n", - "\n", - "As a demonstration we use the [SciQ dataset](https://arxiv.org/abs/1707.06209), available from [HuggingFace](https://huggingface.co/datasets/sciq). \n", - "\n", - "Dataset description, from HuggingFace:\n", - "\n", - "> The SciQ dataset contains 13,679 crowdsourced science exam questions about Physics, Chemistry and Biology, among others. The questions are in multiple-choice format with 4 answer options each. For the majority of the questions, an additional paragraph with supporting evidence for the correct answer is provided." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Found cached dataset sciq (/Users/antontroynikov/.cache/huggingface/datasets/sciq/default/0.1.0/50e5c6e3795b55463819d399ec417bfd4c3c621105e00295ddb5f3633d708493)\n", - "Loading cached processed dataset at /Users/antontroynikov/.cache/huggingface/datasets/sciq/default/0.1.0/50e5c6e3795b55463819d399ec417bfd4c3c621105e00295ddb5f3633d708493/cache-9181e6e3516ba4ed.arrow\n" - ] + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Density based retrieval relevance\n", + "\n", + "An important aspect of using embeddings-based retrieval systems like Chroma is knowing whether there are relevant results to a given query in the existing dataset. As application developers, we would like to know when the system doesn't have enough information to complete a given query or task - we want to know what we don't know. \n", + "\n", + "This is particularly important in the case of retrieval-augmented generation, since it's [often been observed](https://arxiv.org/abs/2302.00093) that supplying irrelevant context serves to confuse the generative model, leading to the degradation of application performance in ways that are difficult to detect. \n", + "\n", + "Unlike a relational database which will not return results if none match the query, a vector search based retrieval system will return the $k$ nearest neighbors to any given query, whether they are relevant or not. \n", + "\n", + "One possible approach one might take is to tune a distance threshold, and reject any results which fall further away from the query. This might be suitable for certain kind of fixed datasets, but in practice such thresholds tend to be very brittle, and often serve to exclude many relevant results while not always excluding irrelevant ones. Additionally, the threshold will need to be continuously adapted as the data changes. Additionally, such distance thresholds are not comparable across embedding models for a given dataset, nor across datasets for a given embedding model. \n", + "\n", + "We would prefer to find a data driven approach which can:\n", + "- produce a uniform and comparable measure of relevance for any dataset \n", + "- automatically adapt as the underlying data changes \n", + "- is relatively inexpensive to compute\n", + "\n", + "This notebook demonstrates one possible such approach, which relies on the distribution of distances (pseudo 'density') between points in a given dataset. For a given result, we use compute the percentile the result's distance to the query falls into with respect to the overall distribution of distances in the dataset. This approach produces a uniform measure of relevance for any dataset, and is relatively cheap to compute, and can be computed online as data mutates. \n", + "\n", + "This approach is still very preliminary, and we welcome contributions and alternative approaches - some ideas are listed at the end of this notebook." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Preliminaries" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Install required packages\n", + "\n", + "import sys\n", + "!{sys.executable} -m pip install chromadb numpy umap-learn[plot] matplotlib tqdm datasets" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Dataset\n", + "\n", + "As a demonstration we use the [SciQ dataset](https://arxiv.org/abs/1707.06209), available from [HuggingFace](https://huggingface.co/datasets/sciq). \n", + "\n", + "Dataset description, from HuggingFace:\n", + "\n", + "> The SciQ dataset contains 13,679 crowdsourced science exam questions about Physics, Chemistry and Biology, among others. The questions are in multiple-choice format with 4 answer options each. For the majority of the questions, an additional paragraph with supporting evidence for the correct answer is provided." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Found cached dataset sciq (/Users/antontroynikov/.cache/huggingface/datasets/sciq/default/0.1.0/50e5c6e3795b55463819d399ec417bfd4c3c621105e00295ddb5f3633d708493)\n", + "Loading cached processed dataset at /Users/antontroynikov/.cache/huggingface/datasets/sciq/default/0.1.0/50e5c6e3795b55463819d399ec417bfd4c3c621105e00295ddb5f3633d708493/cache-9181e6e3516ba4ed.arrow\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of questions with support: 10481\n" + ] + } + ], + "source": [ + "# Get the SciQ dataset from HuggingFace\n", + "from datasets import load_dataset\n", + "\n", + "dataset = load_dataset(\"sciq\", split=\"train\")\n", + "\n", + "# Filter the dataset to only include questions with a support\n", + "dataset = dataset.filter(lambda x: x['support'] != '')\n", + "\n", + "print(\"Number of questions with support: \", len(dataset))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Data loading \n", + "\n", + "We load the dataset into a local persistent instance of Chroma, into a collection called `sciq`. We use Chroma's [default embedding function](https://docs.trychroma.com/embeddings#default-all-minilm-l6-v2), all-MiniLM-L6-v2 from [sentence transformers](https://www.sbert.net/)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import chromadb\n", + "from chromadb.config import Settings\n", + "\n", + "chroma_client = chromadb.PersistentClient(path=\"./chroma)\")\n", + "\n", + "collection = chroma_client.get_or_create_collection(name=\"sciq\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Load the data into Chroma and persist, if it hasn't already been loaded and previously. " + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0df53f502e3a450783f7cbc3b3c658ea", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/11 [00:00" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from umap.umap_ import UMAP\n", + "import umap.plot as umap_plot\n", + "import numpy as np\n", + "\n", + "mapper = UMAP().fit(support_embeddings)\n", + "umap_plot.points(mapper, values=np.array(flat_dists), show_legend=False, theme='inferno')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Computing the density function over distances \n", + "\n", + "Using the returned distances, we compute the density function using `numpy`. " + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute a density function over the distances\n", + "import numpy as np\n", + "hist, bin_edges = np.histogram(flat_dists, bins=100, density=True)\n", + "cumulative_density = np.cumsum(hist) / np.sum(hist)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the density function\n", + "import matplotlib.pyplot as plt\n", + "plt.plot(bin_edges[1:], hist, label=\"Density\")\n", + "plt.plot(bin_edges[1:], cumulative_density, label=\"Cumulative Density\")\n", + "plt.legend(loc=\"upper right\")\n", + "plt.xlabel(\"Distance\")\n", + "plt.show()\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Computing relevance using the density function\n", + "\n", + "We use the percentile a given query falls into with respect to the overall distribution of distances between elements of the dataset, to estimate its relevance. Intuitively, results which are less relevant to the query, should be in higher percentiles than those which are more relevant. \n", + "\n", + "By using the distribution of distances in this way, we eliminate the need to tune an explicit distance threshold, and can instead reason in terms of likelihoods. We could either apply a threshold to the percentile-based relevance directly, or else feed this information into a re-ranking model, or take a sampling approach. " + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_percentile(dist):\n", + " index = np.searchsorted(bin_edges[1:], dist, side='right')\n", + " return cumulative_density[index - 1]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluation\n", + "\n", + "We evaluate the percentile based relevance score using the SciQ dataset. \n", + "\n", + "1. We query the collection of supporting sentences using the questions from the dataset, returning the 10 nearest results, along with their distances.\n", + "2. We check the results for whether the supporting sentence is present or absent. If it's present in the results, we record the percentile that the support falls into, otherwise we record the percentile of the nearest result. " + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "question_results = collection.query(query_texts=dataset['question'], n_results=10, include=['documents', 'distances'])" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "support_percentiles = []\n", + "missing_support_percentiles = []\n", + "for i, q in enumerate(dataset['question']):\n", + " support = dataset['support'][i]\n", + " if support in question_results['documents'][i]:\n", + " support_index = question_results['documents'][i].index(support)\n", + " percentile = compute_percentile(question_results['distances'][i][support_index])\n", + " support_percentiles.append(percentile)\n", + " else:\n", + " missing_support_percentiles.append(compute_percentile(question_results['distances'][i][0]))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualization\n", + "\n", + "We plot histograms of the percentiles for the cases where the support was found, and the case where it wasn't. A lower percentile is more relevant. " + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot normalized histograms of the percentiles\n", + "plt.hist(support_percentiles, bins=20, density=True, alpha=0.5, label='Support')\n", + "plt.hist(missing_support_percentiles, bins=20, density=True, alpha=0.5, label='No support')\n", + "plt.legend(loc='upper right')\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Preliminary results\n", + "\n", + "While we don't observe a clear separation of the two classes, we do note that in general, supports tend to be in lower percentiles, and hence more relevant, than results which aren't the support. \n", + "\n", + "One possible confounding factor is that in some cases, the result does contain the answer to the query question, but is not itself the support for that question. " + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Question: What type of organism is commonly used in preparation of foods such as cheese and yogurt? \n", + "Support: Mesophiles grow best in moderate temperature, typically between 25°C and 40°C (77°F and 104°F). Mesophiles are often found living in or on the bodies of humans or other animals. The optimal growth temperature of many pathogenic mesophiles is 37°C (98°F), the normal human body temperature. Mesophilic organisms have important uses in food preparation, including cheese, yogurt, beer and wine. \n", + "Top result: Bacteria can be used to make cheese from milk. The bacteria turn the milk sugars into lactic acid. The acid is what causes the milk to curdle to form cheese. Bacteria are also involved in producing other foods. Yogurt is made by using bacteria to ferment milk ( Figure below ). Fermenting cabbage with bacteria produces sauerkraut.\n", + "\n", + "Question: Changes from a less-ordered state to a more-ordered state (such as a liquid to a solid) are always what? \n", + "Support: Summary Changes of state are examples of phase changes, or phase transitions. All phase changes are accompanied by changes in the energy of a system. Changes from a more-ordered state to a less-ordered state (such as a liquid to a gas) areendothermic. Changes from a less-ordered state to a more-ordered state (such as a liquid to a solid) are always exothermic. The conversion of a solid to a liquid is called fusion (or melting). The energy required to melt 1 mol of a substance is its enthalpy of fusion (ΔHfus). The energy change required to vaporize 1 mol of a substance is the enthalpy of vaporization (ΔHvap). The direct conversion of a solid to a gas is sublimation. The amount of energy needed to sublime 1 mol of a substance is its enthalpy of sublimation (ΔHsub) and is the sum of the enthalpies of fusion and vaporization. Plots of the temperature of a substance versus heat added or versus heating time at a constant rate of heating are calledheating curves. Heating curves relate temperature changes to phase transitions. A superheated liquid, a liquid at a temperature and pressure at which it should be a gas, is not stable. A cooling curve is not exactly the reverse of the heating curve because many liquids do not freeze at the expected temperature. Instead, they form a supercooled liquid, a metastable liquid phase that exists below the normal melting point. Supercooled liquids usually crystallize on standing, or adding a seed crystal of the same or another substance can induce crystallization. \n", + "Top result: Under the right pressure conditions, lowering the temperature of a substance in the liquid state causes the substance to solidify. The opposite effect occurs if the temperature is increased.\n", + "\n", + "Question: Kilauea in hawaii is the world’s most continuously active volcano. very active volcanoes characteristically eject red-hot rocks and lava rather than this? \n", + "Support: Example 3.5 Calculating Projectile Motion: Hot Rock Projectile Kilauea in Hawaii is the world’s most continuously active volcano. Very active volcanoes characteristically eject red-hot rocks and lava rather than smoke and ash. Suppose a large rock is ejected from the volcano with a speed of 25.0 m/s and at an angle 35.0º above the horizontal, as shown in Figure 3.40. The rock strikes the side of the volcano at an altitude 20.0 m lower than its starting point. (a) Calculate the time it takes the rock to follow this path. (b) What are the magnitude and direction of the rock’s velocity at impact?. \n", + "Top result: Volcanoes can be active, dormant, or extinct.\n", + "\n", + "Question: When a meteoroid reaches earth, what is the remaining object called? \n", + "Support: Meteoroids are smaller than asteroids, ranging from the size of boulders to the size of sand grains. When meteoroids enter Earth’s atmosphere, they vaporize, creating a trail of glowing gas called a meteor. If any of the meteoroid reaches Earth, the remaining object is called a meteorite. \n", + "Top result: A meteoroid is dragged toward Earth by gravity and enters the atmosphere. Friction with the atmosphere heats the object quickly, so it starts to vaporize. As it flies through the atmosphere, it leaves a trail of glowing gases. The object is now a meteor. Most meteors vaporize in the atmosphere. They never reach Earth’s surface. Large meteoroids may not burn up entirely in the atmosphere. A small core may remain and hit Earth’s surface. This is called a meteorite .\n", + "\n", + "Question: What kind of a reaction occurs when a substance reacts quickly with oxygen? \n", + "Support: A combustion reaction occurs when a substance reacts quickly with oxygen (O 2 ). For example, in the Figure below , charcoal is combining with oxygen. Combustion is commonly called burning, and the substance that burns is usually referred to as fuel. The products of a complete combustion reaction include carbon dioxide (CO 2 ) and water vapor (H 2 O). The reaction typically gives off heat and light as well. The general equation for a complete combustion reaction is:. \n", + "Top result: A combustion reaction occurs when a substance reacts quickly with oxygen (O 2 ). You can see an example of a combustion reaction in Figure below . Combustion is commonly called burning. The substance that burns is usually referred to as fuel. The products of a combustion reaction include carbon dioxide (CO 2 ) and water (H 2 O). The reaction typically gives off heat and light as well. The general equation for a combustion reaction can be represented by:.\n", + "\n", + "Question: Organisms categorized by what species descriptor demonstrate a version of allopatric speciation and have limited regions of overlap with one another, but where they overlap they interbreed successfully?. \n", + "Support: Ring species Ring species demonstrate a version of allopatric speciation. Imagine populations of the species A. Over the geographic range of A there exist a number of subpopulations. These subpopulations (A1 to A5) and (Aa to Ae) have limited regions of overlap with one another but where they overlap they interbreed successfully. But populations A5 and Ae no longer interbreed successfully – are these populations separate species?  In this case, there is no clear-cut answer, but it is likely that in the link between the various populations will be broken and one or more species may form in the future. Consider the black bear Ursus americanus. Originally distributed across all of North America, its distribution is now much more fragmented. Isolated populations are free to adapt to their own particular environments and migration between populations is limited. Clearly the environment in Florida is different from that in Mexico, Alaska, or Newfoundland. Different environments will favor different adaptations. If, over time, these populations were to come back into contact with one another, they might or might not be able to interbreed successfully - reproductive isolation may occur and one species may become many. \n", + "Top result: Allopatric speciation occurs when groups from the same species are geographically isolated for long periods. Imagine all the ways that plants or animals could be isolated from each other:.\n", + "\n", + "Question: Zinc is more easily oxidized than iron because zinc has a lower reduction potential. since zinc has a lower reduction potential, it is a more what? \n", + "Support: One way to keep iron from corroding is to keep it painted. The layer of paint prevents the water and oxygen necessary for rust formation from coming into contact with the iron. As long as the paint remains intact, the iron is protected from corrosion. Other strategies include alloying the iron with other metals. For example, stainless steel is mostly iron with a bit of chromium. The chromium tends to collect near the surface, where it forms an oxide layer that protects the iron. Zinc-plated or galvanized iron uses a different strategy. Zinc is more easily oxidized than iron because zinc has a lower reduction potential. Since zinc has a lower reduction potential, it is a more active metal. Thus, even if the zinc coating is scratched, the zinc will still oxidize before the iron. This suggests that this approach should work with other active metals. Another important way to protect metal is to make it the cathode in a galvanic cell. This is cathodic protection and can be used for metals other than just iron. For example, the rusting of underground iron storage tanks and pipes can be prevented or greatly reduced by connecting them to a more active metal such as zinc or magnesium (Figure 17.18). This is also used to protect the metal parts in water heaters. The more active metals (lower reduction potential) are called sacrificial anodes because as they get used up as they corrode (oxidize) at the anode. The metal being protected serves as the cathode, and so does not oxidize (corrode). When the anodes are properly monitored and periodically replaced, the useful lifetime of the iron storage tank can be greatly extended. \n", + "Top result: In the reaction above, the zinc is being oxidized by losing electrons. However, there must be another substance present that gains those electrons and in this case that is the sulfur. In other words, the sulfur is causing the zinc to be oxidized. Sulfur is called the oxidizing agent. The zinc causes the sulfur to gain electrons and become reduced and so the zinc is called the reducing agent. The oxidizing agent is a substance that causes oxidation by accepting electrons. The reducing agent is a substance that causes reduction by losing electrons. The simplest way to think of this is that the oxidizing agent is the substance that is reduced, while the reducing agent is the substance that is oxidized. The sample problem below shows how to analyze a redox reaction.\n", + "\n", + "Question: What are used to write nuclear equations for radioactive decay? \n", + "Support: Nuclear symbols are used to write nuclear equations for radioactive decay. Let’s consider the example of the beta-minus decay of thorium-234 to protactinium-234. This reaction is represented by the equation:. \n", + "Top result: Nuclear symbols are used to write nuclear equations for radioactive decay. Let’s consider an example. Uranium-238 undergoes alpha decay to become thorium-234. (The numbers following the chemical names refer to the number of protons plus neutrons. ) In this reaction, uranium-238 loses two protons and two neutrons to become the element thorium-234. The reaction can be represented by this nuclear equation:.\n", + "\n", + "Question: What is controlled by regulatory proteins that bind to regulatory elements on dna? \n", + "Support: Gene transcription is controlled by regulatory proteins that bind to regulatory elements on DNA. The proteins usually either activate or repress transcription. \n", + "Top result: As shown in Figure below , transcription is controlled by regulatory proteins . The proteins bind to regions of DNA, called regulatory elements , which are located near promoters. After regulatory proteins bind to regulatory elements, they can interact with RNA polymerase, the enzyme that transcribes DNA to mRNA. Regulatory proteins are typically either activators or repressors.\n", + "\n", + "Question: What occurs when the immune system attacks a harmless substance that enters the body from the outside? \n", + "Support: An allergy occurs when the immune system attacks a harmless substance that enters the body from the outside. A substance that causes an allergy is called an allergen. It is the immune system, not the allergen, that causes the symptoms of an allergy. \n", + "Top result: The second line of defense attacks pathogens that manage to enter the body. It includes the inflammatory response and phagocytosis by nonspecific leukocytes.\n", + "\n", + "Question: The plants alternation between haploid and diploud generations allow it to do what? \n", + "Support: All plants have a characteristic life cycle that includes alternation of generations . Plants alternate between haploid and diploid generations. Alternation of generations allows for both asexual and sexual reproduction. Asexual reproduction with spores produces haploid individuals called gametophytes . Sexual reproduction with gametes and fertilization produces diploid individuals called sporophytes . A typical plant’s life cycle is diagrammed in Figure below . \n", + "Top result: Plants alternate between diploid-cell plants and haploid-cell plants. This is called alternation of generations , because the plant type alternates from generation to generation. In alternation of generations, the plant alternates between a sporophyte that has diploid cells and a gametophyte that has haploid cells.\n", + "\n" + ] + } + ], + "source": [ + "for i, q in enumerate(dataset['question'][:20]):\n", + " support = dataset['support'][i]\n", + " top_result = question_results['documents'][i][0]\n", + "\n", + " if support != top_result:\n", + " print(f\"Question: {q} \\nSupport: {support} \\nTop result: {top_result}\\n\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Conclusion\n", + "\n", + "This notebook presents one possible approach to computing a relevance score for embeddings-based retrieval, based on the distribution of distances between embeddings in the dataset. We have done some initial evaluation, but there is a lot left to do. \n", + "\n", + "Some things to try include:\n", + "- Construct the distance distribution on the basis of the query-support pairs, rather than between nearest neighbor supports. \n", + "- Additional evaluations comparing different embedding models for the same dataset, as well as datasets with less redundancy. \n", + "- Using the distance distribution to deduplicate data, by finding low-percentile outliers. One idea is to use an LLM in the loop to create summaries of document pairs, creating a single point from several which are near one another. \n", + "- Using relevance as a signal for automatically fine-tuning embedding space. One approach may be to learn an affine transform based on question/answer pairs, to increase the relevance of the correct points relative to others. \n", + "\n", + "We welcome contributions and ideas! " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "chroma", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + }, + "orig_nbformat": 4 }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of questions with support: 10481\n" - ] - } - ], - "source": [ - "# Get the SciQ dataset from HuggingFace\n", - "from datasets import load_dataset\n", - "\n", - "dataset = load_dataset(\"sciq\", split=\"train\")\n", - "\n", - "# Filter the dataset to only include questions with a support\n", - "dataset = dataset.filter(lambda x: x['support'] != '')\n", - "\n", - "print(\"Number of questions with support: \", len(dataset))" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Data loading \n", - "\n", - "We load the dataset into a local persistent instance of Chroma, into a collection called `sciq`. We use Chroma's [default embedding function](https://docs.trychroma.com/embeddings#default-all-minilm-l6-v2), all-MiniLM-L6-v2 from [sentence tranformers](https://www.sbert.net/)." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "import chromadb\n", - "from chromadb.config import Settings\n", - "\n", - "chroma_client = chromadb.PersistentClient(path=\"./chroma)\")\n", - "\n", - "collection = chroma_client.get_or_create_collection(name=\"sciq\")" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Load the data into Chroma and persist, if it hasn't already been loaded and previously. " - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0df53f502e3a450783f7cbc3b3c658ea", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/11 [00:00" - ] - }, - "execution_count": 49, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from umap.umap_ import UMAP\n", - "import umap.plot as umap_plot\n", - "import numpy as np\n", - "\n", - "mapper = UMAP().fit(support_embeddings)\n", - "umap_plot.points(mapper, values=np.array(flat_dists), show_legend=False, theme='inferno')" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Computing the density function over distances \n", - "\n", - "Using the returned distances, we compute the density function using `numpy`. " - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [], - "source": [ - "# Compute a density function over the distances\n", - "import numpy as np\n", - "hist, bin_edges = np.histogram(flat_dists, bins=100, density=True)\n", - "cumulative_density = np.cumsum(hist) / np.sum(hist)" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Plot the density function\n", - "import matplotlib.pyplot as plt\n", - "plt.plot(bin_edges[1:], hist, label=\"Density\")\n", - "plt.plot(bin_edges[1:], cumulative_density, label=\"Cumulative Density\")\n", - "plt.legend(loc=\"upper right\")\n", - "plt.xlabel(\"Distance\")\n", - "plt.show()\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Computing relevance using the density function\n", - "\n", - "We use the percentile a given query falls into with respect to the overall distribution of distances between elements of the dataset, to estimate its relevance. Intuitively, results which are less relevant to the query, should be in higher percentiles than those which are more relevant. \n", - "\n", - "By using the distribution of distances in this way, we eliminate the need to tune an explicit distance threshold, and can instead reason in terms of likelihoods. We could either apply a threshold to the percentile-based relevance directly, or else feed this information into a re-ranking model, or take a sampling approach. " - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [], - "source": [ - "def compute_percentile(dist):\n", - " index = np.searchsorted(bin_edges[1:], dist, side='right')\n", - " return cumulative_density[index - 1]" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Evaluation\n", - "\n", - "We evaluate the percentile based relevance score using the SciQ dataset. \n", - "\n", - "1. We query the collection of supporting sentences using the questions from the dataset, returning the 10 nearest results, along with their distances.\n", - "2. We check the results for whether the supporting sentence is present or absent. If it's present in the results, we record the percentile that the support falls into, otherwise we record the percentile of the nearest result. " - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [], - "source": [ - "question_results = collection.query(query_texts=dataset['question'], n_results=10, include=['documents', 'distances'])" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [], - "source": [ - "support_percentiles = []\n", - "missing_support_percentiles = []\n", - "for i, q in enumerate(dataset['question']):\n", - " support = dataset['support'][i]\n", - " if support in question_results['documents'][i]:\n", - " support_index = question_results['documents'][i].index(support)\n", - " percentile = compute_percentile(question_results['distances'][i][support_index])\n", - " support_percentiles.append(percentile)\n", - " else:\n", - " missing_support_percentiles.append(compute_percentile(question_results['distances'][i][0]))" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Visualization\n", - "\n", - "We plot histograms of the percentiles for the cases where the support was found, and the case where it wasn't. A lower percentile is more relevant. " - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Plot normalized histograms of the percentiles\n", - "plt.hist(support_percentiles, bins=20, density=True, alpha=0.5, label='Support')\n", - "plt.hist(missing_support_percentiles, bins=20, density=True, alpha=0.5, label='No support')\n", - "plt.legend(loc='upper right')\n", - "plt.show()" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Preliminary results\n", - "\n", - "While we don't observe a clear separation of the two classes, we do note that in general, supports tend to be in lower percentiles, and hence more relevant, than results which aren't the support. \n", - "\n", - "One possible confounding factor is that in some cases, the result does contain the answer to the query question, but is not itself the support for that question. " - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Question: What type of organism is commonly used in preparation of foods such as cheese and yogurt? \n", - "Support: Mesophiles grow best in moderate temperature, typically between 25°C and 40°C (77°F and 104°F). Mesophiles are often found living in or on the bodies of humans or other animals. The optimal growth temperature of many pathogenic mesophiles is 37°C (98°F), the normal human body temperature. Mesophilic organisms have important uses in food preparation, including cheese, yogurt, beer and wine. \n", - "Top result: Bacteria can be used to make cheese from milk. The bacteria turn the milk sugars into lactic acid. The acid is what causes the milk to curdle to form cheese. Bacteria are also involved in producing other foods. Yogurt is made by using bacteria to ferment milk ( Figure below ). Fermenting cabbage with bacteria produces sauerkraut.\n", - "\n", - "Question: Changes from a less-ordered state to a more-ordered state (such as a liquid to a solid) are always what? \n", - "Support: Summary Changes of state are examples of phase changes, or phase transitions. All phase changes are accompanied by changes in the energy of a system. Changes from a more-ordered state to a less-ordered state (such as a liquid to a gas) areendothermic. Changes from a less-ordered state to a more-ordered state (such as a liquid to a solid) are always exothermic. The conversion of a solid to a liquid is called fusion (or melting). The energy required to melt 1 mol of a substance is its enthalpy of fusion (ΔHfus). The energy change required to vaporize 1 mol of a substance is the enthalpy of vaporization (ΔHvap). The direct conversion of a solid to a gas is sublimation. The amount of energy needed to sublime 1 mol of a substance is its enthalpy of sublimation (ΔHsub) and is the sum of the enthalpies of fusion and vaporization. Plots of the temperature of a substance versus heat added or versus heating time at a constant rate of heating are calledheating curves. Heating curves relate temperature changes to phase transitions. A superheated liquid, a liquid at a temperature and pressure at which it should be a gas, is not stable. A cooling curve is not exactly the reverse of the heating curve because many liquids do not freeze at the expected temperature. Instead, they form a supercooled liquid, a metastable liquid phase that exists below the normal melting point. Supercooled liquids usually crystallize on standing, or adding a seed crystal of the same or another substance can induce crystallization. \n", - "Top result: Under the right pressure conditions, lowering the temperature of a substance in the liquid state causes the substance to solidify. The opposite effect occurs if the temperature is increased.\n", - "\n", - "Question: Kilauea in hawaii is the world’s most continuously active volcano. very active volcanoes characteristically eject red-hot rocks and lava rather than this? \n", - "Support: Example 3.5 Calculating Projectile Motion: Hot Rock Projectile Kilauea in Hawaii is the world’s most continuously active volcano. Very active volcanoes characteristically eject red-hot rocks and lava rather than smoke and ash. Suppose a large rock is ejected from the volcano with a speed of 25.0 m/s and at an angle 35.0º above the horizontal, as shown in Figure 3.40. The rock strikes the side of the volcano at an altitude 20.0 m lower than its starting point. (a) Calculate the time it takes the rock to follow this path. (b) What are the magnitude and direction of the rock’s velocity at impact?. \n", - "Top result: Volcanoes can be active, dormant, or extinct.\n", - "\n", - "Question: When a meteoroid reaches earth, what is the remaining object called? \n", - "Support: Meteoroids are smaller than asteroids, ranging from the size of boulders to the size of sand grains. When meteoroids enter Earth’s atmosphere, they vaporize, creating a trail of glowing gas called a meteor. If any of the meteoroid reaches Earth, the remaining object is called a meteorite. \n", - "Top result: A meteoroid is dragged toward Earth by gravity and enters the atmosphere. Friction with the atmosphere heats the object quickly, so it starts to vaporize. As it flies through the atmosphere, it leaves a trail of glowing gases. The object is now a meteor. Most meteors vaporize in the atmosphere. They never reach Earth’s surface. Large meteoroids may not burn up entirely in the atmosphere. A small core may remain and hit Earth’s surface. This is called a meteorite .\n", - "\n", - "Question: What kind of a reaction occurs when a substance reacts quickly with oxygen? \n", - "Support: A combustion reaction occurs when a substance reacts quickly with oxygen (O 2 ). For example, in the Figure below , charcoal is combining with oxygen. Combustion is commonly called burning, and the substance that burns is usually referred to as fuel. The products of a complete combustion reaction include carbon dioxide (CO 2 ) and water vapor (H 2 O). The reaction typically gives off heat and light as well. The general equation for a complete combustion reaction is:. \n", - "Top result: A combustion reaction occurs when a substance reacts quickly with oxygen (O 2 ). You can see an example of a combustion reaction in Figure below . Combustion is commonly called burning. The substance that burns is usually referred to as fuel. The products of a combustion reaction include carbon dioxide (CO 2 ) and water (H 2 O). The reaction typically gives off heat and light as well. The general equation for a combustion reaction can be represented by:.\n", - "\n", - "Question: Organisms categorized by what species descriptor demonstrate a version of allopatric speciation and have limited regions of overlap with one another, but where they overlap they interbreed successfully?. \n", - "Support: Ring species Ring species demonstrate a version of allopatric speciation. Imagine populations of the species A. Over the geographic range of A there exist a number of subpopulations. These subpopulations (A1 to A5) and (Aa to Ae) have limited regions of overlap with one another but where they overlap they interbreed successfully. But populations A5 and Ae no longer interbreed successfully – are these populations separate species?  In this case, there is no clear-cut answer, but it is likely that in the link between the various populations will be broken and one or more species may form in the future. Consider the black bear Ursus americanus. Originally distributed across all of North America, its distribution is now much more fragmented. Isolated populations are free to adapt to their own particular environments and migration between populations is limited. Clearly the environment in Florida is different from that in Mexico, Alaska, or Newfoundland. Different environments will favor different adaptations. If, over time, these populations were to come back into contact with one another, they might or might not be able to interbreed successfully - reproductive isolation may occur and one species may become many. \n", - "Top result: Allopatric speciation occurs when groups from the same species are geographically isolated for long periods. Imagine all the ways that plants or animals could be isolated from each other:.\n", - "\n", - "Question: Zinc is more easily oxidized than iron because zinc has a lower reduction potential. since zinc has a lower reduction potential, it is a more what? \n", - "Support: One way to keep iron from corroding is to keep it painted. The layer of paint prevents the water and oxygen necessary for rust formation from coming into contact with the iron. As long as the paint remains intact, the iron is protected from corrosion. Other strategies include alloying the iron with other metals. For example, stainless steel is mostly iron with a bit of chromium. The chromium tends to collect near the surface, where it forms an oxide layer that protects the iron. Zinc-plated or galvanized iron uses a different strategy. Zinc is more easily oxidized than iron because zinc has a lower reduction potential. Since zinc has a lower reduction potential, it is a more active metal. Thus, even if the zinc coating is scratched, the zinc will still oxidize before the iron. This suggests that this approach should work with other active metals. Another important way to protect metal is to make it the cathode in a galvanic cell. This is cathodic protection and can be used for metals other than just iron. For example, the rusting of underground iron storage tanks and pipes can be prevented or greatly reduced by connecting them to a more active metal such as zinc or magnesium (Figure 17.18). This is also used to protect the metal parts in water heaters. The more active metals (lower reduction potential) are called sacrificial anodes because as they get used up as they corrode (oxidize) at the anode. The metal being protected serves as the cathode, and so does not oxidize (corrode). When the anodes are properly monitored and periodically replaced, the useful lifetime of the iron storage tank can be greatly extended. \n", - "Top result: In the reaction above, the zinc is being oxidized by losing electrons. However, there must be another substance present that gains those electrons and in this case that is the sulfur. In other words, the sulfur is causing the zinc to be oxidized. Sulfur is called the oxidizing agent. The zinc causes the sulfur to gain electrons and become reduced and so the zinc is called the reducing agent. The oxidizing agent is a substance that causes oxidation by accepting electrons. The reducing agent is a substance that causes reduction by losing electrons. The simplest way to think of this is that the oxidizing agent is the substance that is reduced, while the reducing agent is the substance that is oxidized. The sample problem below shows how to analyze a redox reaction.\n", - "\n", - "Question: What are used to write nuclear equations for radioactive decay? \n", - "Support: Nuclear symbols are used to write nuclear equations for radioactive decay. Let’s consider the example of the beta-minus decay of thorium-234 to protactinium-234. This reaction is represented by the equation:. \n", - "Top result: Nuclear symbols are used to write nuclear equations for radioactive decay. Let’s consider an example. Uranium-238 undergoes alpha decay to become thorium-234. (The numbers following the chemical names refer to the number of protons plus neutrons. ) In this reaction, uranium-238 loses two protons and two neutrons to become the element thorium-234. The reaction can be represented by this nuclear equation:.\n", - "\n", - "Question: What is controlled by regulatory proteins that bind to regulatory elements on dna? \n", - "Support: Gene transcription is controlled by regulatory proteins that bind to regulatory elements on DNA. The proteins usually either activate or repress transcription. \n", - "Top result: As shown in Figure below , transcription is controlled by regulatory proteins . The proteins bind to regions of DNA, called regulatory elements , which are located near promoters. After regulatory proteins bind to regulatory elements, they can interact with RNA polymerase, the enzyme that transcribes DNA to mRNA. Regulatory proteins are typically either activators or repressors.\n", - "\n", - "Question: What occurs when the immune system attacks a harmless substance that enters the body from the outside? \n", - "Support: An allergy occurs when the immune system attacks a harmless substance that enters the body from the outside. A substance that causes an allergy is called an allergen. It is the immune system, not the allergen, that causes the symptoms of an allergy. \n", - "Top result: The second line of defense attacks pathogens that manage to enter the body. It includes the inflammatory response and phagocytosis by nonspecific leukocytes.\n", - "\n", - "Question: The plants alternation between haploid and diploud generations allow it to do what? \n", - "Support: All plants have a characteristic life cycle that includes alternation of generations . Plants alternate between haploid and diploid generations. Alternation of generations allows for both asexual and sexual reproduction. Asexual reproduction with spores produces haploid individuals called gametophytes . Sexual reproduction with gametes and fertilization produces diploid individuals called sporophytes . A typical plant’s life cycle is diagrammed in Figure below . \n", - "Top result: Plants alternate between diploid-cell plants and haploid-cell plants. This is called alternation of generations , because the plant type alternates from generation to generation. In alternation of generations, the plant alternates between a sporophyte that has diploid cells and a gametophyte that has haploid cells.\n", - "\n" - ] - } - ], - "source": [ - "for i, q in enumerate(dataset['question'][:20]):\n", - " support = dataset['support'][i]\n", - " top_result = question_results['documents'][i][0]\n", - "\n", - " if support != top_result:\n", - " print(f\"Question: {q} \\nSupport: {support} \\nTop result: {top_result}\\n\")" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Conclusion\n", - "\n", - "This notebook presents one possible approach to computing a relevance score for embeddings-based retreival, based on the distribution of distances between embeddings in the dataset. We have done some initial evaluation, but there is a lot left to do. \n", - "\n", - "Some things to try include:\n", - "- Construct the distance distribution on the basis of the query-support pairs, rather than between nearest neighbor supports. \n", - "- Additional evaluations comparing different embedding models for the same dataset, as well as datasets with less redundancy. \n", - "- Using the distance distribution to deduplicate data, by finding low-percentile outliers. One idea is to use an LLM in the loop to create summaries of document pairs, creating a single point from several which are near one another. \n", - "- Using relevance as a signal for automatically fine-tuning embedding space. One approach may be to learn an affine transform based on question/answer pairs, to increase the relevance of the correct points relative to others. \n", - "\n", - "We welcome contributions and ideas! " - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "chroma", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -} + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file diff --git a/chromadb/segment/distributed/__init__.py b/chromadb/segment/distributed/__init__.py index beb48102ac6..4acba5ea3b3 100644 --- a/chromadb/segment/distributed/__init__.py +++ b/chromadb/segment/distributed/__init__.py @@ -36,7 +36,7 @@ class Member: class MemberlistProvider(Component, EnforceOverrides): - """Returns the latest memberlist and provdes a callback for when it changes. This + """Returns the latest memberlist and provides a callback for when it changes. This callback may be called from a different thread than the one that called. Callers should ensure that they are thread-safe.""" diff --git a/chromadb/segment/impl/metadata/sqlite.py b/chromadb/segment/impl/metadata/sqlite.py index 22544f1948f..035335b5ff0 100644 --- a/chromadb/segment/impl/metadata/sqlite.py +++ b/chromadb/segment/impl/metadata/sqlite.py @@ -159,7 +159,7 @@ def get_metadata( ) # If there is a query that touches the metadata table, it uses - # where and where_document filters, we treat this case seperately + # where and where_document filters, we treat this case separately if where is not None or where_document is not None: metadata_q = ( self._db.querybuilder() diff --git a/chromadb/segment/impl/vector/local_hnsw.py b/chromadb/segment/impl/vector/local_hnsw.py index 8861ef98d43..1a1de0b28dc 100644 --- a/chromadb/segment/impl/vector/local_hnsw.py +++ b/chromadb/segment/impl/vector/local_hnsw.py @@ -221,7 +221,7 @@ def _init_index(self, dimensionality: int) -> None: @trace_method("LocalHnswSegment._ensure_index", OpenTelemetryGranularity.ALL) def _ensure_index(self, n: int, dim: int) -> None: - """Create or resize the index as necessary to accomodate N new records""" + """Create or resize the index as necessary to accommodate N new records""" if not self._index: self._dimensionality = dim self._init_index(dim) diff --git a/chromadb/test/auth/test_auth_utils.py b/chromadb/test/auth/test_auth_utils.py index 1f4d084a80a..4e6d88307d7 100644 --- a/chromadb/test/auth/test_auth_utils.py +++ b/chromadb/test/auth/test_auth_utils.py @@ -15,7 +15,7 @@ def user_identity() -> UserIdentity: ) -def test_doesnt_overrite_from_auth(user_identity: UserIdentity) -> None: +def test_doesnt_overwrite_from_auth(user_identity: UserIdentity) -> None: resolved_tenant, resolved_database = maybe_set_tenant_and_database( user_identity=user_identity, overwrite_singleton_tenant_database_access_from_auth=False, @@ -63,7 +63,7 @@ def test_errors_when_provided_tenant_and_database_dont_match_from_auth( ) -def test_doesnt_overrite_from_auth_when_ambiguous(user_identity: UserIdentity) -> None: +def test_doesnt_overwrite_from_auth_when_ambiguous(user_identity: UserIdentity) -> None: user_identity.tenant = "*" user_identity.databases = ["*"] resolved_tenant, resolved_database = maybe_set_tenant_and_database( diff --git a/chromadb/test/client/test_multiple_clients_concurrency.py b/chromadb/test/client/test_multiple_clients_concurrency.py index a9e855fb435..6d854c197b3 100644 --- a/chromadb/test/client/test_multiple_clients_concurrency.py +++ b/chromadb/test/client/test_multiple_clients_concurrency.py @@ -21,7 +21,7 @@ def test_multiple_clients_concurrently(client_factories: ClientFactories) -> Non collections = [f"collection{i}" for i in range(COLLECTION_COUNT)] - # Create N clients, each on a seperate thread, each with their own database + # Create N clients, each on a separate thread, each with their own database def run_target(n: int) -> None: thread_client = client_factories.create_client( tenant=DEFAULT_TENANT, diff --git a/chromadb/test/configurations/test_collection_configuration.py b/chromadb/test/configurations/test_collection_configuration.py index f8f9ea81db8..d0b8b2f9c34 100644 --- a/chromadb/test/configurations/test_collection_configuration.py +++ b/chromadb/test/configurations/test_collection_configuration.py @@ -896,7 +896,7 @@ def test_invalid_configuration() -> None: def test_collection_load_with_invalid_configuration(client: ClientAPI) -> None: """ - When an invalid confiugration is used, collection create, get, list_collections should all pass + When an invalid configuration is used, collection create, get, list_collections should all pass Only when trying to use the collection should an error be reaised """ client.reset() diff --git a/chromadb/test/conftest.py b/chromadb/test/conftest.py index 87c0d48cd0a..01ca0fde679 100644 --- a/chromadb/test/conftest.py +++ b/chromadb/test/conftest.py @@ -562,7 +562,7 @@ def fastapi_fixture_admin_and_singleton_tenant_db_user() -> ( @pytest.fixture() def integration() -> Generator[System, None, None]: - """Fixture generator for returning a client configured via environmenet + """Fixture generator for returning a client configured via environment variables, intended for externally configured integration tests """ settings = Settings( @@ -576,7 +576,7 @@ def integration() -> Generator[System, None, None]: @pytest.fixture() def async_integration() -> Generator[System, None, None]: - """Fixture generator for returning a client configured via environmenet + """Fixture generator for returning a client configured via environment variables, intended for externally configured integration tests """ settings = Settings( diff --git a/chromadb/test/property/invariants.py b/chromadb/test/property/invariants.py index 17f7d0018e7..68e9fe17e77 100644 --- a/chromadb/test/property/invariants.py +++ b/chromadb/test/property/invariants.py @@ -403,7 +403,7 @@ def ann_accuracy( atol=accuracy_threshold, ) if unexpected_id: - # If the ID is unexpcted, but the distance is correct, then we + # If the ID is unexpected, but the distance is correct, then we # have a duplicate in the data. In this case, we should not reduce recall. if correct_distance: missing -= 1 diff --git a/chromadb/test/property/strategies.py b/chromadb/test/property/strategies.py index 5ed57ebf44c..d34178d3cb1 100644 --- a/chromadb/test/property/strategies.py +++ b/chromadb/test/property/strategies.py @@ -360,7 +360,7 @@ def collections( has_documents = draw(st.booleans()) assert has_documents is not None # For cluster tests, we want to avoid generating documents and where_document - # clauses of length < 3. We also don't want them to contain certan special + # clauses of length < 3. We also don't want them to contain certain special # characters like _ and % that implicitly involve searching for a regex in sqlite. if not NOT_CLUSTER_ONLY: if has_documents and add_filterable_data: @@ -434,7 +434,7 @@ def metadata( def document(draw: st.DrawFn, collection: Collection) -> types.Document: """Strategy for generating documents that could be a part of the given collection""" # For cluster tests, we want to avoid generating documents of length < 3. - # We also don't want them to contain certan special + # We also don't want them to contain certain special # characters like _ and % that implicitly involve searching for a regex in sqlite. if not NOT_CLUSTER_ONLY: # Blacklist certain unicode characters that affect sqlite processing. @@ -612,7 +612,7 @@ def where_clause(draw: st.DrawFn, collection: Collection) -> types.Where: def where_doc_clause(draw: st.DrawFn, collection: Collection) -> types.WhereDocument: """Generate a where_document filter that could be used against the given collection""" # For cluster tests, we want to avoid generating where_document - # clauses of length < 3. We also don't want them to contain certan special + # clauses of length < 3. We also don't want them to contain certain special # characters like _ and % that implicitly involve searching for a regex in sqlite. if not NOT_CLUSTER_ONLY: if collection.known_document_keywords: diff --git a/chromadb/test/property/test_collections_with_database_tenant.py b/chromadb/test/property/test_collections_with_database_tenant.py index d52e84ed1c0..0ed31ed8778 100644 --- a/chromadb/test/property/test_collections_with_database_tenant.py +++ b/chromadb/test/property/test_collections_with_database_tenant.py @@ -106,7 +106,7 @@ def set_api_tenant_database(self, tenant: str, database: str) -> None: self.client.set_tenant(tenant, database) # For calls to create_database, and create_tenant we may want to override the tenant and database - # This is a leaky abstraction that exists soley for the purpose of + # This is a leaky abstraction that exists solely for the purpose of # test_collections_with_database_tenant_override.py def overwrite_tenant(self, tenant: str) -> str: return tenant diff --git a/chromadb/utils/__init__.py b/chromadb/utils/__init__.py index fe6bb81853b..d53fb9928c3 100644 --- a/chromadb/utils/__init__.py +++ b/chromadb/utils/__init__.py @@ -5,7 +5,7 @@ def get_class(fqn: str, type: Type[C]) -> Type[C]: - """Given a fully qualifed class name, import the module and return the class""" + """Given a fully qualified class name, import the module and return the class""" module_name, class_name = fqn.rsplit(".", 1) module = importlib.import_module(module_name) cls = getattr(module, class_name) diff --git a/chromadb/utils/embedding_functions/jina_embedding_function.py b/chromadb/utils/embedding_functions/jina_embedding_function.py index 05bdf7ef0c3..2d2893f8d24 100644 --- a/chromadb/utils/embedding_functions/jina_embedding_function.py +++ b/chromadb/utils/embedding_functions/jina_embedding_function.py @@ -144,7 +144,7 @@ def _build_payload(self, input: Embeddable, is_query: bool) -> Dict[str, Any]: if self.normalized is not None: payload["normalized"] = self.normalized - # overwrite parameteres when query payload is used + # overwrite parameters when query payload is used if is_query and self.query_config is not None: for key, value in self.query_config.items(): payload[key] = value diff --git a/clients/js/README.md b/clients/js/README.md index 0496046f6e9..8d1bf12b1c9 100644 --- a/clients/js/README.md +++ b/clients/js/README.md @@ -4,7 +4,7 @@ Chroma is the open-source embedding database. Chroma makes it easy to build LLM This package gives you a JS/TS interface to talk to a backend Chroma DB over REST. -**Note:** JS client version 3._ is only compatible with chromadb v1.0.6 and newer or Chroma Cloud. For prior version compatiblity, please use JS client version 2._. +**Note:** JS client version 3._ is only compatible with chromadb v1.0.6 and newer or Chroma Cloud. For prior version compatibility, please use JS client version 2._. [Learn more about Chroma](https://github.com/chroma-core/chroma) diff --git a/clients/js/packages/chromadb-client/README.md b/clients/js/packages/chromadb-client/README.md index e75e158de7c..03101d3978b 100644 --- a/clients/js/packages/chromadb-client/README.md +++ b/clients/js/packages/chromadb-client/README.md @@ -2,7 +2,7 @@ Chroma is the open-source embedding database. Chroma makes it easy to build LLM apps by making knowledge, facts, and skills pluggable for LLMs. -**Note:** JS client version 3._ is only compatible with chromadb v1.0.6 and newer or Chroma Cloud. For prior version compatiblity, please use JS client version 2._. +**Note:** JS client version 3._ is only compatible with chromadb v1.0.6 and newer or Chroma Cloud. For prior version compatibility, please use JS client version 2._. **This package provides embedding libraries as peer dependencies**, allowing you to manage your own versions of embedding libraries and keep your dependency tree lean by not bundling dependencies you don't use. For a thick client with bundled embedding functions, install `chromadb`. diff --git a/clients/js/packages/chromadb/src/cli.ts b/clients/js/packages/chromadb/src/cli.ts index abfe2b9d726..293cdd5ad53 100644 --- a/clients/js/packages/chromadb/src/cli.ts +++ b/clients/js/packages/chromadb/src/cli.ts @@ -3,61 +3,61 @@ import semver from "semver"; import binding from "./bindings"; interface NpmPackageData { - "dist-tags": { - latest: string; - [tag: string]: string; - }; + "dist-tags": { + latest: string; + [tag: string]: string; + }; } const getLatestVersion = async (packageName: string): Promise => { - const response = await fetch(`https://registry.npmjs.org/${packageName}`); - if (!response.ok) { - throw new Error(`Failed to fetch package data: ${response.statusText}`); - } - const data: NpmPackageData = await response.json(); - return data["dist-tags"].latest; + const response = await fetch(`https://registry.npmjs.org/${packageName}`); + if (!response.ok) { + throw new Error(`Failed to fetch package data: ${response.statusText}`); + } + const data: NpmPackageData = await response.json(); + return data["dist-tags"].latest; }; const update = async (): Promise => { - try { - const installedVersion = process.env.CHROMADB_VERSION || "0.0.0"; - const latestVersion = await getLatestVersion("chromadb"); - - if (semver.lt(installedVersion, latestVersion)) { - console.log(`\nA new chromadb version (${latestVersion}) is available!`); - console.log("\n\x1b[4mUpdat with npm\x1b[0m"); - console.log("npm install chromadb@latest"); - - console.log("\n\x1b[4mUpdat with pnpm\x1b[0m"); - console.log("pnpm add chromadb@latest"); - - console.log("\n\x1b[4mUpdat with yarn\x1b[0m"); - console.log("yarn add chromadb@latest"); - - console.log("\n\x1b[4mUpdat with bun\x1b[0m"); - console.log("bun add chromadb@latest\n"); - } else { - console.log( - `\nYour chromadb version (${latestVersion}) is up-to-date!\n`, - ); - } - } catch (error) { - console.error("Error checking versions:", error); - } + try { + const installedVersion = process.env.CHROMADB_VERSION || "0.0.0"; + const latestVersion = await getLatestVersion("chromadb"); + + if (semver.lt(installedVersion, latestVersion)) { + console.log(`\nA new chromadb version (${latestVersion}) is available!`); + console.log("\n\x1b[4mUpdate with npm\x1b[0m"); + console.log("npm install chromadb@latest"); + + console.log("\n\x1b[4mUpdate with pnpm\x1b[0m"); + console.log("pnpm add chromadb@latest"); + + console.log("\n\x1b[4mUpdate with yarn\x1b[0m"); + console.log("yarn add chromadb@latest"); + + console.log("\n\x1b[4mUpdate with bun\x1b[0m"); + console.log("bun add chromadb@latest\n"); + } else { + console.log( + `\nYour chromadb version (${latestVersion}) is up-to-date!\n`, + ); + } + } catch (error) { + console.error("Error checking versions:", error); + } }; const main = async () => { - const args: string[] = process.argv.slice(2); - if (args.length > 0 && args[0] === "update") { - await update(); - return; - } + const args: string[] = process.argv.slice(2); + if (args.length > 0 && args[0] === "update") { + await update(); + return; + } - process.on("SIGINT", () => { - process.exit(0); - }); + process.on("SIGINT", () => { + process.exit(0); + }); - binding.cli(["chroma", ...args]); + binding.cli(["chroma", ...args]); }; main().finally(); diff --git a/clients/new-js/packages/chromadb/src/api/sdk.gen.ts b/clients/new-js/packages/chromadb/src/api/sdk.gen.ts index 586c8170a12..1cdb7e427af 100644 --- a/clients/new-js/packages/chromadb/src/api/sdk.gen.ts +++ b/clients/new-js/packages/chromadb/src/api/sdk.gen.ts @@ -300,7 +300,7 @@ export class DefaultService { } /** - * Search records from a collection with hybrid criterias. + * Search records from a collection with hybrid criteria. */ public static collectionSearch(options: Options) { return (options.client ?? _heyApiClient).post({ diff --git a/clients/new-js/packages/chromadb/src/cli.ts b/clients/new-js/packages/chromadb/src/cli.ts index abfe2b9d726..293cdd5ad53 100644 --- a/clients/new-js/packages/chromadb/src/cli.ts +++ b/clients/new-js/packages/chromadb/src/cli.ts @@ -3,61 +3,61 @@ import semver from "semver"; import binding from "./bindings"; interface NpmPackageData { - "dist-tags": { - latest: string; - [tag: string]: string; - }; + "dist-tags": { + latest: string; + [tag: string]: string; + }; } const getLatestVersion = async (packageName: string): Promise => { - const response = await fetch(`https://registry.npmjs.org/${packageName}`); - if (!response.ok) { - throw new Error(`Failed to fetch package data: ${response.statusText}`); - } - const data: NpmPackageData = await response.json(); - return data["dist-tags"].latest; + const response = await fetch(`https://registry.npmjs.org/${packageName}`); + if (!response.ok) { + throw new Error(`Failed to fetch package data: ${response.statusText}`); + } + const data: NpmPackageData = await response.json(); + return data["dist-tags"].latest; }; const update = async (): Promise => { - try { - const installedVersion = process.env.CHROMADB_VERSION || "0.0.0"; - const latestVersion = await getLatestVersion("chromadb"); - - if (semver.lt(installedVersion, latestVersion)) { - console.log(`\nA new chromadb version (${latestVersion}) is available!`); - console.log("\n\x1b[4mUpdat with npm\x1b[0m"); - console.log("npm install chromadb@latest"); - - console.log("\n\x1b[4mUpdat with pnpm\x1b[0m"); - console.log("pnpm add chromadb@latest"); - - console.log("\n\x1b[4mUpdat with yarn\x1b[0m"); - console.log("yarn add chromadb@latest"); - - console.log("\n\x1b[4mUpdat with bun\x1b[0m"); - console.log("bun add chromadb@latest\n"); - } else { - console.log( - `\nYour chromadb version (${latestVersion}) is up-to-date!\n`, - ); - } - } catch (error) { - console.error("Error checking versions:", error); - } + try { + const installedVersion = process.env.CHROMADB_VERSION || "0.0.0"; + const latestVersion = await getLatestVersion("chromadb"); + + if (semver.lt(installedVersion, latestVersion)) { + console.log(`\nA new chromadb version (${latestVersion}) is available!`); + console.log("\n\x1b[4mUpdate with npm\x1b[0m"); + console.log("npm install chromadb@latest"); + + console.log("\n\x1b[4mUpdate with pnpm\x1b[0m"); + console.log("pnpm add chromadb@latest"); + + console.log("\n\x1b[4mUpdate with yarn\x1b[0m"); + console.log("yarn add chromadb@latest"); + + console.log("\n\x1b[4mUpdate with bun\x1b[0m"); + console.log("bun add chromadb@latest\n"); + } else { + console.log( + `\nYour chromadb version (${latestVersion}) is up-to-date!\n`, + ); + } + } catch (error) { + console.error("Error checking versions:", error); + } }; const main = async () => { - const args: string[] = process.argv.slice(2); - if (args.length > 0 && args[0] === "update") { - await update(); - return; - } + const args: string[] = process.argv.slice(2); + if (args.length > 0 && args[0] === "update") { + await update(); + return; + } - process.on("SIGINT", () => { - process.exit(0); - }); + process.on("SIGINT", () => { + process.exit(0); + }); - binding.cli(["chroma", ...args]); + binding.cli(["chroma", ...args]); }; main().finally(); diff --git a/docs/cip/CIP-10112023_Authorization.md b/docs/cip/CIP-10112023_Authorization.md index 1be1e4c51b6..05460c2eeb8 100644 --- a/docs/cip/CIP-10112023_Authorization.md +++ b/docs/cip/CIP-10112023_Authorization.md @@ -82,7 +82,7 @@ Authorization response provides authorization provider evaluation response. It r ##### ChromaAuthzMiddleware -The `ChromaAuthzMiddleware` is an abstraction for the server-side middleware. At the time of writing we only support FastAPI. The middleware interface supports several methods: +The `ChromaAuthzMiddleware` is an abstraction for the server-side middleware. At the time of writing we only support FastAPI. The middleware interface supports several methods: - `authorize` - authorizes the request against the authorization provider. - `ignore_operation` - determines whether or not the operation should be ignored by the middleware @@ -90,7 +90,7 @@ The `ChromaAuthzMiddleware` is an abstraction for the server-side middleware. At ##### AuthorizationError -Error thrown when an authorization request is disallowed/denied by the authorization provider. Depending on authorization provider's implementation such error may also be thrown when the authorization provider is not available or an internal error ocurred. +Error thrown when an authorization request is disallowed/denied by the authorization provider. Depending on authorization provider's implementation such error may also be thrown when the authorization provider is not available or an internal error occurred. Client semantics of this error is a 403 Unauthorized error being returned over HTTP interface. @@ -102,12 +102,11 @@ The AuthorizationContext is composed of three components as defined in #Basic Au - Resource - Action - ```json { -"user": {"id": "API Token or User Id"}, -"resource": {"namespace": "*", "id": "collection_id","type": "database"}, -"action": {"id":"get_or_create"}, + "user": { "id": "API Token or User Id" }, + "resource": { "namespace": "*", "id": "collection_id", "type": "database" }, + "action": { "id": "get_or_create" } } ``` @@ -283,7 +282,6 @@ users: tokens: - token: my_api_token secret: my_api_secret - ``` ## **Compatibility, Deprecation, and Migration Plan** diff --git a/docs/cip/CIP_Chroma_Improvment_Proposals.md b/docs/cip/CIP_Chroma_Improvement_Proposals.md similarity index 100% rename from docs/cip/CIP_Chroma_Improvment_Proposals.md rename to docs/cip/CIP_Chroma_Improvement_Proposals.md diff --git a/docs/docs.trychroma.com/README.md b/docs/docs.trychroma.com/README.md index 846120bc35e..b1f86a28490 100644 --- a/docs/docs.trychroma.com/README.md +++ b/docs/docs.trychroma.com/README.md @@ -6,21 +6,23 @@ Chroma's docs are designed to be as extensible as possible with little-to-no mag This repo is a [NextJS](https://nextjs.org/) + [Markdoc](https://markdoc.dev/) project. -It also incldues [Shadcn](https://ui.shadcn.com/) with [Tailwind](https://tailwindcss.com/) for components and styling. +It also includes [Shadcn](https://ui.shadcn.com/) with [Tailwind](https://tailwindcss.com/) for components and styling. # Features todo + - [ ] add accordion for troubleshooting - [ ] keep tab state in query params -- [ ] bring in codgen and make it easy +- [ ] bring in codegen and make it easy - [ ] swag element in light/dark mode. eg the graphic on the index route - [ ] turn on algolia once indexed - [ ] turn back on "edit on github" button when public # Content todo -- [ ] add more examples +- [ ] add more examples ### Features + - Breadcrumbs - Table of Contents - Sidenav with a "folder" structure @@ -35,12 +37,13 @@ It also incldues [Shadcn](https://ui.shadcn.com/) with [Tailwind](https://tailwi ### Content structure Chroma's documentation must be: + - well structured - easy to understand - easy to navigate - easy to search -Too much of documentation, in AI in particular, is written in a way that is confusing and just downright poor techincal communication. +Too much of documentation, in AI in particular, is written in a way that is confusing and just downright poor technical communication. Chroma's docs are designed to "ladder complexity" and guide users through a beginner-intermediate-advanced journey. @@ -57,7 +60,6 @@ yarn dev # run nextjs The docs are deployed to Vercel. - ### JS Docs Autogen diff --git a/docs/docs.trychroma.com/markdoc/content/docs/cli/update.md b/docs/docs.trychroma.com/markdoc/content/docs/cli/update.md index e22f1d08715..ddd11844a90 100644 --- a/docs/docs.trychroma.com/markdoc/content/docs/cli/update.md +++ b/docs/docs.trychroma.com/markdoc/content/docs/cli/update.md @@ -5,6 +5,6 @@ name: Update the CLI # Update -The `chroma update` command wil inform you if you should update your CLI installation. +The `chroma update` command will inform you if you should update your CLI installation. -If you run the CLI via our Python or JavaScript packages, the `update` command will inform you if a new `chromadb` version is availble. When you update your `chromadb` package, you will also get the latest version of the CLI bundled with it. +If you run the CLI via our Python or JavaScript packages, the `update` command will inform you if a new `chromadb` version is available. When you update your `chromadb` package, you will also get the latest version of the CLI bundled with it. diff --git a/docs/docs.trychroma.com/markdoc/content/docs/overview/about.md b/docs/docs.trychroma.com/markdoc/content/docs/overview/about.md index 7dae30ab4fc..5170cb29aa7 100644 --- a/docs/docs.trychroma.com/markdoc/content/docs/overview/about.md +++ b/docs/docs.trychroma.com/markdoc/content/docs/overview/about.md @@ -47,4 +47,4 @@ Chroma raised an $18M seed round led by Astasia Myers from Quiet Capital. Joinin Chroma raised a pre-seed in May 2022, led by Anthony Goldbloom (Kaggle) from AIX Ventures, James Cham from Bloomberg Beta, and Nat Friedman and Daniel Gross (AI Grant). -We're excited to work with a deep set of investors and enterpreneurs who have invested in and built some of the most successful open-source projects in the world. +We're excited to work with a deep set of investors and entrepreneurs who have invested in and built some of the most successful open-source projects in the world. diff --git a/docs/docs.trychroma.com/markdoc/content/docs/overview/migration.md b/docs/docs.trychroma.com/markdoc/content/docs/overview/migration.md index 74d849ee0a6..1e32618805d 100644 --- a/docs/docs.trychroma.com/markdoc/content/docs/overview/migration.md +++ b/docs/docs.trychroma.com/markdoc/content/docs/overview/migration.md @@ -212,7 +212,7 @@ CHROMA_SERVER_AUTH_PROVIDER="chromadb.auth.basic.BasicAuthServerProvider" _Note: Only one of `AUTH_CREDENTIALS` and `AUTH_CREDENTIALS_FILE` can be set, but this guide shows how to migrate both._ -And your corresponding client configation: +And your corresponding client configuration: ```yaml CHROMA_CLIENT_AUTH_PROVIDER="chromadb.auth.token.TokenAuthClientProvider" @@ -248,7 +248,7 @@ CHROMA_SERVER_AUTH_TOKEN_TRANSPORT_HEADER="AUTHORIZATION" _Note: Only one of `AUTH_CREDENTIALS` and `AUTH_CREDENTIALS_FILE` can be set, but this guide shows how to migrate both._ -And your corresponding client configation: +And your corresponding client configuration: ```yaml CHROMA_CLIENT_AUTH_PROVIDER="chromadb.auth.token.TokenAuthClientProvider" diff --git a/docs/docs.trychroma.com/markdoc/content/docs/querying-collections/query-and-get.md b/docs/docs.trychroma.com/markdoc/content/docs/querying-collections/query-and-get.md index 56311f1d470..01462bc1b5b 100644 --- a/docs/docs.trychroma.com/markdoc/content/docs/querying-collections/query-and-get.md +++ b/docs/docs.trychroma.com/markdoc/content/docs/querying-collections/query-and-get.md @@ -206,7 +206,7 @@ const results = await collection.query({ }); ``` -On `.query` and `.get` results, you can use the `.rows()` method, to get them in row-based format. That is, you will get an array of records, each with its `id`, `document`, `metdata` (etc.) fields. +On `.query` and `.get` results, you can use the `.rows()` method, to get them in row-based format. That is, you will get an array of records, each with its `id`, `document`, `metadata` (etc.) fields. ```typescript const results = await collection.get({ ids: ["id1", "id2", ...]}); @@ -216,7 +216,7 @@ records.forEach((record) => { }) ``` -You can also pass to `.get` and `.query` type arguments for the shape of your metadata. This will give you type inferrence for you metadata objects: +You can also pass to `.get` and `.query` type arguments for the shape of your metadata. This will give you type inference for you metadata objects: ```typescript const results = await collection.get<{page: number; title: string}>({ diff --git a/docs/docs.trychroma.com/markdoc/content/guides/deploy/performance.md b/docs/docs.trychroma.com/markdoc/content/guides/deploy/performance.md index 5a77b54c313..336b5140601 100644 --- a/docs/docs.trychroma.com/markdoc/content/guides/deploy/performance.md +++ b/docs/docs.trychroma.com/markdoc/content/guides/deploy/performance.md @@ -44,7 +44,7 @@ Therefore, users should always plan on having enough RAM provisioned to accommod To analyze how much RAM is required, we launched an an instance of Chroma on variously sized EC2 instances, then inserted embeddings until each system became non-responsive. As expected, this failure point corresponded linearly to RAM and embedding count. -For 1024 dimensional embeddings, with three metadata records and a small document per embedding, this works out to `N = R * 0.245` where `N` is the max collection size in millions, and `R` is the amount of system RAM required in gigabytes. Remember, you wil also need reserve at least a gigabyte for the system’s other needs, in addition to the memory required by Chroma. +For 1024 dimensional embeddings, with three metadata records and a small document per embedding, this works out to `N = R * 0.245` where `N` is the max collection size in millions, and `R` is the amount of system RAM required in gigabytes. Remember, you will also need to reserve at least a gigabyte for the system’s other needs, in addition to the memory required by Chroma. This pattern holds true up through about 7 million embeddings, which is as far as we tested. At this point Chroma is still fast and stable, and we did not find a strict upper bound on the size of a Chroma database. diff --git a/docs/docs.trychroma.com/markdoc/content/integrations/embedding-models/google-gemini.md b/docs/docs.trychroma.com/markdoc/content/integrations/embedding-models/google-gemini.md index 680959c8769..c24b6796130 100644 --- a/docs/docs.trychroma.com/markdoc/content/integrations/embedding-models/google-gemini.md +++ b/docs/docs.trychroma.com/markdoc/content/integrations/embedding-models/google-gemini.md @@ -28,7 +28,7 @@ collection = client.create_collection(name="name", embedding_function=google_ef) collection = client.get_collection(name="name", embedding_function=google_ef) ``` -You can view a more [complete example](https://github.com/chroma-core/chroma/tree/main/examples/gemini) chatting over documents with Gemini embedding and langauge models. +You can view a more [complete example](https://github.com/chroma-core/chroma/tree/main/examples/gemini) chatting over documents with Gemini embedding and language models. For more info - please visit the [official Google python docs](https://ai.google.dev/tutorials/python_quickstart). diff --git a/docs/docs.trychroma.com/markdoc/content/integrations/frameworks/openlit.md b/docs/docs.trychroma.com/markdoc/content/integrations/frameworks/openlit.md index 3d493beee09..db435c7b881 100644 --- a/docs/docs.trychroma.com/markdoc/content/integrations/frameworks/openlit.md +++ b/docs/docs.trychroma.com/markdoc/content/integrations/frameworks/openlit.md @@ -20,6 +20,7 @@ pip install openlit ``` ### Step 2: Initialize OpenLIT in your Application + Integrating OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **two lines of code**: ```python @@ -31,7 +32,7 @@ openlit.init() To forward telemetry data to an HTTP OTLP endpoint, such as the OpenTelemetry Collector, set the `otlp_endpoint` parameter with the desired endpoint. Alternatively, you can configure the endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable as recommended in the OpenTelemetry documentation. > 💡 Info: If you don't provide `otlp_endpoint` function argument or set the `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable, OpenLIT directs the trace directly to your console, which can be useful during development. -To send telemetry to OpenTelemetry backends requiring authentication, set the `otlp_headers` parameter with its desired value. Alternatively, you can configure the endpoint by setting the `OTEL_EXPORTER_OTLP_HEADERS` environment variable as recommended in the OpenTelemetry documentation. +> To send telemetry to OpenTelemetry backends requiring authentication, set the `otlp_headers` parameter with its desired value. Alternatively, you can configure the endpoint by setting the `OTEL_EXPORTER_OTLP_HEADERS` environment variable as recommended in the OpenTelemetry documentation. ### Step 3: Visualize and Optimize! @@ -41,8 +42,7 @@ With the LLM Observability data now being collected by OpenLIT, the next step is To begin exploring your LLM Application's performance data within the OpenLIT UI, please see the [Quickstart Guide](https://docs.openlit.io/latest/quickstart). -If you want to integrate and send metrics and traces to your existing observability tools like Promethues+Jaeger, Grafana or more, refer to the [Official Documentation for OpenLIT Connections](https://docs.openlit.io/latest/connections/intro) for detailed instructions. - +If you want to integrate and send metrics and traces to your existing observability tools like Prometheus+Jaeger, Grafana or more, refer to the [Official Documentation for OpenLIT Connections](https://docs.openlit.io/latest/connections/intro) for detailed instructions. ## Support diff --git a/docs/docs.trychroma.com/markdoc/content/reference/python/client.md b/docs/docs.trychroma.com/markdoc/content/reference/python/client.md index 42371a12ea6..1db1b432d06 100644 --- a/docs/docs.trychroma.com/markdoc/content/reference/python/client.md +++ b/docs/docs.trychroma.com/markdoc/content/reference/python/client.md @@ -378,7 +378,7 @@ Get or create a collection with the given name and metadata. - `name` - The name of the collection to get or create - `metadata` - Optional metadata to associate with the collection. If - the collection alredy exists, the metadata will be ignored. If the collection does not exist, the + the collection already exists, the metadata will be 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.) diff --git a/docs/docs.trychroma.com/public/cloud-art.svg b/docs/docs.trychroma.com/public/cloud-art.svg index 41e1f4a5424..7aa0e09717c 100644 --- a/docs/docs.trychroma.com/public/cloud-art.svg +++ b/docs/docs.trychroma.com/public/cloud-art.svg @@ -9,6 +9,6 @@ - + diff --git a/docs/docs.trychroma.com/public/computer.svg b/docs/docs.trychroma.com/public/computer.svg index 32ee61c5497..c1c7edb81f8 100644 --- a/docs/docs.trychroma.com/public/computer.svg +++ b/docs/docs.trychroma.com/public/computer.svg @@ -739,7 +739,7 @@ - + diff --git a/docs/docs.trychroma.com/public/llms-docs-cli-update.txt b/docs/docs.trychroma.com/public/llms-docs-cli-update.txt index b0764c91862..b0e7d983871 100644 --- a/docs/docs.trychroma.com/public/llms-docs-cli-update.txt +++ b/docs/docs.trychroma.com/public/llms-docs-cli-update.txt @@ -1,5 +1,5 @@ # Update -The `chroma update` command wil inform you if you should update your CLI installation. +The `chroma update` command will inform you if you should update your CLI installation. -If you run the CLI via our Python or JavaScript packages, the `update` command will inform you if a new `chromadb` version is availble. When you update your `chromadb` package, you will also get the latest version of the CLI bundled with it. \ No newline at end of file +If you run the CLI via our Python or JavaScript packages, the `update` command will inform you if a new `chromadb` version is available. When you update your `chromadb` package, you will also get the latest version of the CLI bundled with it. \ No newline at end of file diff --git a/docs/docs.trychroma.com/public/llms-docs-overview-about.txt b/docs/docs.trychroma.com/public/llms-docs-overview-about.txt index 426069c15d3..a60c1633a46 100644 --- a/docs/docs.trychroma.com/public/llms-docs-overview-about.txt +++ b/docs/docs.trychroma.com/public/llms-docs-overview-about.txt @@ -38,4 +38,4 @@ Chroma raised an $18M seed round led by Astasia Myers from Quiet Capital. Joinin Chroma raised a pre-seed in May 2022, led by Anthony Goldbloom (Kaggle) from AIX Ventures, James Cham from Bloomberg Beta, and Nat Friedman and Daniel Gross (AI Grant). -We're excited to work with a deep set of investors and enterpreneurs who have invested in and built some of the most successful open-source projects in the world. \ No newline at end of file +We're excited to work with a deep set of investors and entrepreneurs who have invested in and built some of the most successful open-source projects in the world. \ No newline at end of file diff --git a/docs/docs.trychroma.com/public/llms-docs-overview-contributing.txt b/docs/docs.trychroma.com/public/llms-docs-overview-contributing.txt index 0903f5ed02b..07158aa890b 100644 --- a/docs/docs.trychroma.com/public/llms-docs-overview-contributing.txt +++ b/docs/docs.trychroma.com/public/llms-docs-overview-contributing.txt @@ -32,7 +32,7 @@ CHORE: Maintenance and other tasks that do not modify source or test files ### CIPs -Chroma Improvement Proposals or CIPs (pronounced "Chips") are the way to propose new features or large changes to Chroma. If you plan to make a large change to Chroma please submit a CIP first so that the core Chroma team as well as the community can discuss the proposed change and provide feedback. A CIP should provide a concise technical specification of the feature and a rationale for why it is needed. The CIP should be submitted as a pull request to the [CIPs folder](https://github.com/chroma-core/chroma/tree/main/docs/cip). The CIP will be reviewed by the Chroma team and if approved will be merged into the repository. To learn more about writing a CIP you can read the [guide](https://github.com/chroma-core/chroma/blob/main/docs/cip/CIP_Chroma_Improvment_Proposals.md). CIPs are not required for small changes such as bug fixes or documentation updates. +Chroma Improvement Proposals or CIPs (pronounced "Chips") are the way to propose new features or large changes to Chroma. If you plan to make a large change to Chroma please submit a CIP first so that the core Chroma team as well as the community can discuss the proposed change and provide feedback. A CIP should provide a concise technical specification of the feature and a rationale for why it is needed. The CIP should be submitted as a pull request to the [CIPs folder](https://github.com/chroma-core/chroma/tree/main/docs/cip). The CIP will be reviewed by the Chroma team and if approved will be merged into the repository. To learn more about writing a CIP you can read the [guide](https://github.com/chroma-core/chroma/blob/main/docs/cip/CIP_Chroma_Improvement_Proposals.md). CIPs are not required for small changes such as bug fixes or documentation updates. A CIP starts in the "Proposed" state, then moves to "Under Review" once the Chroma team has reviewed it and is considering it for implementation. Once the CIP is approved it will move to the "Accepted" state and the implementation can begin. Once the implementation is complete the CIP will move to the "Implemented" state. If the CIP is not approved it will move to the "Rejected" state. If the CIP is withdrawn by the author it will move to the "Withdrawn" state. diff --git a/docs/docs.trychroma.com/public/llms-docs-overview-migration.txt b/docs/docs.trychroma.com/public/llms-docs-overview-migration.txt index 53055988e7c..57cb3f4b1a4 100644 --- a/docs/docs.trychroma.com/public/llms-docs-overview-migration.txt +++ b/docs/docs.trychroma.com/public/llms-docs-overview-migration.txt @@ -204,7 +204,7 @@ CHROMA_SERVER_AUTH_PROVIDER="chromadb.auth.basic.BasicAuthServerProvider" _Note: Only one of `AUTH_CREDENTIALS` and `AUTH_CREDENTIALS_FILE` can be set, but this guide shows how to migrate both._ -And your corresponding client configation: +And your corresponding client configuration: ```yaml CHROMA_CLIENT_AUTH_PROVIDER="chromadb.auth.token.TokenAuthClientProvider" @@ -240,7 +240,7 @@ CHROMA_SERVER_AUTH_TOKEN_TRANSPORT_HEADER="AUTHORIZATION" _Note: Only one of `AUTH_CREDENTIALS` and `AUTH_CREDENTIALS_FILE` can be set, but this guide shows how to migrate both._ -And your corresponding client configation: +And your corresponding client configuration: ```yaml CHROMA_CLIENT_AUTH_PROVIDER="chromadb.auth.token.TokenAuthClientProvider" diff --git a/docs/docs.trychroma.com/public/llms-docs-querying-collections-query-and-get.txt b/docs/docs.trychroma.com/public/llms-docs-querying-collections-query-and-get.txt index 68f272c079e..d07269dcd0a 100644 --- a/docs/docs.trychroma.com/public/llms-docs-querying-collections-query-and-get.txt +++ b/docs/docs.trychroma.com/public/llms-docs-querying-collections-query-and-get.txt @@ -189,7 +189,7 @@ class GetResult { const results = await collection.query({ queryTexts: ["first query", "second query"] }) ``` -On `.query` and `.get` results, you can use the `.rows()` method, to get them in row-based format. That is, you will get an array of records, each with its `id`, `document`, `metdata` (etc.) fields. +On `.query` and `.get` results, you can use the `.rows()` method, to get them in row-based format. That is, you will get an array of records, each with its `id`, `document`, `metadata` (etc.) fields. ```typescript const results = await collection.get({ ids: ["id1", "id2", ...]}); @@ -199,7 +199,7 @@ records.forEach((record) => { }) ``` -You can also pass to `.get` and `.query` type arguments for the shape of your metadata. This will give you type inferrence for you metadata objects: +You can also pass to `.get` and `.query` type arguments for the shape of your metadata. This will give you type inference for you metadata objects: ```typescript const results = await collection.get<{page: number; title: string}>({ diff --git a/docs/docs.trychroma.com/public/llms-full.text b/docs/docs.trychroma.com/public/llms-full.text index c4e509869c9..fba2d88d1b7 100644 --- a/docs/docs.trychroma.com/public/llms-full.text +++ b/docs/docs.trychroma.com/public/llms-full.text @@ -551,9 +551,9 @@ chroma install --list ``` # Update -The `chroma update` command wil inform you if you should update your CLI installation. +The `chroma update` command will inform you if you should update your CLI installation. -If you run the CLI via our Python or JavaScript packages, the `update` command will inform you if a new `chromadb` version is availble. When you update your `chromadb` package, you will also get the latest version of the CLI bundled with it. +If you run the CLI via our Python or JavaScript packages, the `update` command will inform you if a new `chromadb` version is available. When you update your `chromadb` package, you will also get the latest version of the CLI bundled with it. # Vacuuming Vacuuming shrinks and optimizes your database. @@ -1867,7 +1867,7 @@ Chroma raised an $18M seed round led by Astasia Myers from Quiet Capital. Joinin Chroma raised a pre-seed in May 2022, led by Anthony Goldbloom (Kaggle) from AIX Ventures, James Cham from Bloomberg Beta, and Nat Friedman and Daniel Gross (AI Grant). -We're excited to work with a deep set of investors and enterpreneurs who have invested in and built some of the most successful open-source projects in the world. +We're excited to work with a deep set of investors and entrepreneurs who have invested in and built some of the most successful open-source projects in the world. # Architecture Chroma is designed with a modular architecture that prioritizes performance and ease of use. It scales seamlessly from local development to large-scale production, while exposing a consistent API across all deployment modes. @@ -2000,7 +2000,7 @@ CHORE: Maintenance and other tasks that do not modify source or test files ### CIPs -Chroma Improvement Proposals or CIPs (pronounced "Chips") are the way to propose new features or large changes to Chroma. If you plan to make a large change to Chroma please submit a CIP first so that the core Chroma team as well as the community can discuss the proposed change and provide feedback. A CIP should provide a concise technical specification of the feature and a rationale for why it is needed. The CIP should be submitted as a pull request to the [CIPs folder](https://github.com/chroma-core/chroma/tree/main/docs/cip). The CIP will be reviewed by the Chroma team and if approved will be merged into the repository. To learn more about writing a CIP you can read the [guide](https://github.com/chroma-core/chroma/blob/main/docs/cip/CIP_Chroma_Improvment_Proposals.md). CIPs are not required for small changes such as bug fixes or documentation updates. +Chroma Improvement Proposals or CIPs (pronounced "Chips") are the way to propose new features or large changes to Chroma. If you plan to make a large change to Chroma please submit a CIP first so that the core Chroma team as well as the community can discuss the proposed change and provide feedback. A CIP should provide a concise technical specification of the feature and a rationale for why it is needed. The CIP should be submitted as a pull request to the [CIPs folder](https://github.com/chroma-core/chroma/tree/main/docs/cip). The CIP will be reviewed by the Chroma team and if approved will be merged into the repository. To learn more about writing a CIP you can read the [guide](https://github.com/chroma-core/chroma/blob/main/docs/cip/CIP_Chroma_Improvement_Proposals.md). CIPs are not required for small changes such as bug fixes or documentation updates. A CIP starts in the "Proposed" state, then moves to "Under Review" once the Chroma team has reviewed it and is considering it for implementation. Once the CIP is approved it will move to the "Accepted" state and the implementation can begin. Once the implementation is complete the CIP will move to the "Implemented" state. If the CIP is not approved it will move to the "Rejected" state. If the CIP is withdrawn by the author it will move to the "Withdrawn" state. @@ -2658,7 +2658,7 @@ CHROMA_SERVER_AUTH_PROVIDER="chromadb.auth.basic.BasicAuthServerProvider" _Note: Only one of `AUTH_CREDENTIALS` and `AUTH_CREDENTIALS_FILE` can be set, but this guide shows how to migrate both._ -And your corresponding client configation: +And your corresponding client configuration: ```yaml CHROMA_CLIENT_AUTH_PROVIDER="chromadb.auth.token.TokenAuthClientProvider" @@ -2694,7 +2694,7 @@ CHROMA_SERVER_AUTH_TOKEN_TRANSPORT_HEADER="AUTHORIZATION" _Note: Only one of `AUTH_CREDENTIALS` and `AUTH_CREDENTIALS_FILE` can be set, but this guide shows how to migrate both._ -And your corresponding client configation: +And your corresponding client configuration: ```yaml CHROMA_CLIENT_AUTH_PROVIDER="chromadb.auth.token.TokenAuthClientProvider" @@ -3817,7 +3817,7 @@ class GetResult { const results = await collection.query({ queryTexts: ["first query", "second query"] }) ``` -On `.query` and `.get` results, you can use the `.rows()` method, to get them in row-based format. That is, you will get an array of records, each with its `id`, `document`, `metdata` (etc.) fields. +On `.query` and `.get` results, you can use the `.rows()` method, to get them in row-based format. That is, you will get an array of records, each with its `id`, `document`, `metadata` (etc.) fields. ```typescript const results = await collection.get({ ids: ["id1", "id2", ...]}); @@ -3827,7 +3827,7 @@ records.forEach((record) => { }) ``` -You can also pass to `.get` and `.query` type arguments for the shape of your metadata. This will give you type inferrence for you metadata objects: +You can also pass to `.get` and `.query` type arguments for the shape of your metadata. This will give you type inference for you metadata objects: ```typescript const results = await collection.get<{page: number; title: string}>({ @@ -5329,7 +5329,7 @@ Therefore, users should always plan on having enough RAM provisioned to accommod To analyze how much RAM is required, we launched an an instance of Chroma on variously sized EC2 instances, then inserted embeddings until each system became non-responsive. As expected, this failure point corresponded linearly to RAM and embedding count. -For 1024 dimensional embeddings, with three metadata records and a small document per embedding, this works out to `N = R * 0.245` where `N` is the max collection size in millions, and `R` is the amount of system RAM required in gigabytes. Remember, you wil also need reserve at least a gigabyte for the system’s other needs, in addition to the memory required by Chroma. +For 1024 dimensional embeddings, with three metadata records and a small document per embedding, this works out to `N = R * 0.245` where `N` is the max collection size in millions, and `R` is the amount of system RAM required in gigabytes. Remember, you will also need to reserve at least a gigabyte for the system’s other needs, in addition to the memory required by Chroma. This pattern holds true up through about 7 million embeddings, which is as far as we tested. At this point Chroma is still fast and stable, and we did not find a strict upper bound on the size of a Chroma database. @@ -5753,7 +5753,7 @@ collection = client.create_collection(name="name", embedding_function=google_ef) collection = client.get_collection(name="name", embedding_function=google_ef) ``` -You can view a more [complete example](https://github.com/chroma-core/chroma/tree/main/examples/gemini) chatting over documents with Gemini embedding and langauge models. +You can view a more [complete example](https://github.com/chroma-core/chroma/tree/main/examples/gemini) chatting over documents with Gemini embedding and language models. For more info - please visit the [official Google python docs](https://ai.google.dev/tutorials/python_quickstart). @@ -7081,7 +7081,7 @@ With the LLM Observability data now being collected by OpenLIT, the next step is To begin exploring your LLM Application's performance data within the OpenLIT UI, please see the [Quickstart Guide](https://docs.openlit.io/latest/quickstart). -If you want to integrate and send metrics and traces to your existing observability tools like Promethues+Jaeger, Grafana or more, refer to the [Official Documentation for OpenLIT Connections](https://docs.openlit.io/latest/connections/intro) for detailed instructions. +If you want to integrate and send metrics and traces to your existing observability tools like Prometheus+Jaeger, Grafana or more, refer to the [Official Documentation for OpenLIT Connections](https://docs.openlit.io/latest/connections/intro) for detailed instructions. ## Support @@ -8625,7 +8625,7 @@ Get or create a collection with the given name and metadata. - `name` - The name of the collection to get or create - `metadata` - Optional metadata to associate with the collection. If - the collection alredy exists, the metadata will be ignored. If the collection does not exist, the + the collection already exists, the metadata will be 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.) diff --git a/docs/docs.trychroma.com/public/llms-guides-deploy-performance.txt b/docs/docs.trychroma.com/public/llms-guides-deploy-performance.txt index 0d47153049f..484f5195e0c 100644 --- a/docs/docs.trychroma.com/public/llms-guides-deploy-performance.txt +++ b/docs/docs.trychroma.com/public/llms-guides-deploy-performance.txt @@ -37,7 +37,7 @@ Therefore, users should always plan on having enough RAM provisioned to accommod To analyze how much RAM is required, we launched an an instance of Chroma on variously sized EC2 instances, then inserted embeddings until each system became non-responsive. As expected, this failure point corresponded linearly to RAM and embedding count. -For 1024 dimensional embeddings, with three metadata records and a small document per embedding, this works out to `N = R * 0.245` where `N` is the max collection size in millions, and `R` is the amount of system RAM required in gigabytes. Remember, you wil also need reserve at least a gigabyte for the system’s other needs, in addition to the memory required by Chroma. +For 1024 dimensional embeddings, with three metadata records and a small document per embedding, this works out to `N = R * 0.245` where `N` is the max collection size in millions, and `R` is the amount of system RAM required in gigabytes. Remember, you will also need to reserve at least a gigabyte for the system’s other needs, in addition to the memory required by Chroma. This pattern holds true up through about 7 million embeddings, which is as far as we tested. At this point Chroma is still fast and stable, and we did not find a strict upper bound on the size of a Chroma database. diff --git a/docs/docs.trychroma.com/public/llms-integrations-embedding-models-google-gemini.txt b/docs/docs.trychroma.com/public/llms-integrations-embedding-models-google-gemini.txt index 49a0d83389b..e561c3d28c2 100644 --- a/docs/docs.trychroma.com/public/llms-integrations-embedding-models-google-gemini.txt +++ b/docs/docs.trychroma.com/public/llms-integrations-embedding-models-google-gemini.txt @@ -26,7 +26,7 @@ collection = client.create_collection(name="name", embedding_function=google_ef) collection = client.get_collection(name="name", embedding_function=google_ef) ``` -You can view a more [complete example](https://github.com/chroma-core/chroma/tree/main/examples/gemini) chatting over documents with Gemini embedding and langauge models. +You can view a more [complete example](https://github.com/chroma-core/chroma/tree/main/examples/gemini) chatting over documents with Gemini embedding and language models. For more info - please visit the [official Google python docs](https://ai.google.dev/tutorials/python_quickstart). diff --git a/docs/docs.trychroma.com/public/llms-integrations-frameworks-openlit.txt b/docs/docs.trychroma.com/public/llms-integrations-frameworks-openlit.txt index 85059d78952..91760f0619b 100644 --- a/docs/docs.trychroma.com/public/llms-integrations-frameworks-openlit.txt +++ b/docs/docs.trychroma.com/public/llms-integrations-frameworks-openlit.txt @@ -41,7 +41,7 @@ With the LLM Observability data now being collected by OpenLIT, the next step is To begin exploring your LLM Application's performance data within the OpenLIT UI, please see the [Quickstart Guide](https://docs.openlit.io/latest/quickstart). -If you want to integrate and send metrics and traces to your existing observability tools like Promethues+Jaeger, Grafana or more, refer to the [Official Documentation for OpenLIT Connections](https://docs.openlit.io/latest/connections/intro) for detailed instructions. +If you want to integrate and send metrics and traces to your existing observability tools like Prometheus+Jaeger, Grafana or more, refer to the [Official Documentation for OpenLIT Connections](https://docs.openlit.io/latest/connections/intro) for detailed instructions. ## Support diff --git a/docs/docs.trychroma.com/public/llms-reference-python-client.txt b/docs/docs.trychroma.com/public/llms-reference-python-client.txt index 7e4c8065b09..e28bb68a597 100644 --- a/docs/docs.trychroma.com/public/llms-reference-python-client.txt +++ b/docs/docs.trychroma.com/public/llms-reference-python-client.txt @@ -373,7 +373,7 @@ Get or create a collection with the given name and metadata. - `name` - The name of the collection to get or create - `metadata` - Optional metadata to associate with the collection. If - the collection alredy exists, the metadata will be ignored. If the collection does not exist, the + the collection already exists, the metadata will be 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.) diff --git a/examples/README.md b/examples/README.md index 7b6da2326db..52299e4a6ae 100644 --- a/examples/README.md +++ b/examples/README.md @@ -4,11 +4,12 @@ This folder will contain an ever-growing set of examples. -The key with examples is that they should *always* work. The failure mode of examples folders is that they get quickly deprecated. +The key with examples is that they should _always_ work. The failure mode of examples folders is that they get quickly deprecated. Examples are: + - Easy to maintain -- Easy to maintain examples are __simple__ +- Easy to maintain examples are **simple** - Use case examples are fine, technology is better ``` @@ -23,11 +24,13 @@ folder structure > 💡 Feel free to open a PR with an example you would like to see ### Basic Functionality + - [x] Examples of using different embedding models -- [x] Local persistance demo +- [x] Local persistence demo - [x] Where filtering demo ### Advanced Functionality + - [ ] Clustering - [ ] Projections - [ ] Fine tuning @@ -35,11 +38,13 @@ folder structure ### Use With #### LLM Application Code + - [ ] Langchain - [ ] LlamaIndex -- [ ] Semantic Kernal +- [ ] Semantic Kernel #### App Frameworks + - [ ] Streamlit - [ ] Gradio - [ ] Nextjs @@ -47,18 +52,21 @@ folder structure - [ ] FastAPI #### Inference Services + - [ ] Brev.dev - [ ] Banana.dev - [ ] Modal ### LLM providers/services + - [ ] OpenAI - [ ] Anthropic - [ ] Cohere - [ ] Google PaLM - [ ] Hugging Face -*** +--- ### Inspiration + - The [OpenAI Cookbook](https://github.com/openai/openai-cookbook) gets a lot of things right diff --git a/examples/basic_functionality/local_persistence.ipynb b/examples/basic_functionality/local_persistence.ipynb index e05d638824c..50e28c744eb 100644 --- a/examples/basic_functionality/local_persistence.ipynb +++ b/examples/basic_functionality/local_persistence.ipynb @@ -1,188 +1,188 @@ { - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Local Peristence Demo\n", - "This notebook demonstrates how to configure Chroma to persist to disk, then load it back in. " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import chromadb" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# Create a new Chroma client with persistence enabled. \n", - "persist_directory = \"db\"\n", - "\n", - "client = chromadb.PersistentClient(path=persist_directory)\n", - "\n", - "# Create a new chroma collection\n", - "collection_name = \"peristed_collection\"\n", - "collection = client.get_or_create_collection(name=collection_name)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# Add some data to the collection\n", - "collection.add(\n", - " embeddings=[\n", - " [1.1, 2.3, 3.2],\n", - " [4.5, 6.9, 4.4],\n", - " [1.1, 2.3, 3.2],\n", - " [4.5, 6.9, 4.4],\n", - " [1.1, 2.3, 3.2],\n", - " [4.5, 6.9, 4.4],\n", - " [1.1, 2.3, 3.2],\n", - " [4.5, 6.9, 4.4],\n", - " ],\n", - " metadatas=[\n", - " {\"uri\": \"img1.png\", \"style\": \"style1\"},\n", - " {\"uri\": \"img2.png\", \"style\": \"style2\"},\n", - " {\"uri\": \"img3.png\", \"style\": \"style1\"},\n", - " {\"uri\": \"img4.png\", \"style\": \"style1\"},\n", - " {\"uri\": \"img5.png\", \"style\": \"style1\"},\n", - " {\"uri\": \"img6.png\", \"style\": \"style1\"},\n", - " {\"uri\": \"img7.png\", \"style\": \"style1\"},\n", - " {\"uri\": \"img8.png\", \"style\": \"style1\"},\n", - " ],\n", - " documents=[\"doc1\", \"doc2\", \"doc3\", \"doc4\", \"doc5\", \"doc6\", \"doc7\", \"doc8\"],\n", - " ids=[\"id1\", \"id2\", \"id3\", \"id4\", \"id5\", \"id6\", \"id7\", \"id8\"],\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# Create a new client with the same settings\n", - "client = chromadb.PersistentClient(path=persist_directory)\n", - "\n", - "# Load the collection\n", - "collection = client.get_collection(collection_name)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'ids': [['id1']], 'distances': [[5.1159076593562386e-15]], 'metadatas': [[{'style': 'style1', 'uri': 'img1.png'}]], 'embeddings': None, 'documents': [['doc1']]}\n" - ] - } - ], - "source": [ - "# Query the collection\n", - "results = collection.query(\n", - " query_embeddings=[[1.1, 2.3, 3.2]],\n", - " n_results=1\n", - ")\n", - "\n", - "print(results)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'ids': ['id1', 'id2', 'id3', 'id4', 'id5', 'id6', 'id7', 'id8'],\n", - " 'embeddings': [[1.100000023841858, 2.299999952316284, 3.200000047683716],\n", - " [4.5, 6.900000095367432, 4.400000095367432],\n", - " [1.100000023841858, 2.299999952316284, 3.200000047683716],\n", - " [4.5, 6.900000095367432, 4.400000095367432],\n", - " [1.100000023841858, 2.299999952316284, 3.200000047683716],\n", - " [4.5, 6.900000095367432, 4.400000095367432],\n", - " [1.100000023841858, 2.299999952316284, 3.200000047683716],\n", - " [4.5, 6.900000095367432, 4.400000095367432]],\n", - " 'metadatas': [{'style': 'style1', 'uri': 'img1.png'},\n", - " {'style': 'style2', 'uri': 'img2.png'},\n", - " {'style': 'style1', 'uri': 'img3.png'},\n", - " {'style': 'style1', 'uri': 'img4.png'},\n", - " {'style': 'style1', 'uri': 'img5.png'},\n", - " {'style': 'style1', 'uri': 'img6.png'},\n", - " {'style': 'style1', 'uri': 'img7.png'},\n", - " {'style': 'style1', 'uri': 'img8.png'}],\n", - " 'documents': ['doc1', 'doc2', 'doc3', 'doc4', 'doc5', 'doc6', 'doc7', 'doc8']}" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "collection.get(include=[\"embeddings\", \"metadatas\", \"documents\"])" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "# Clean up\n", - "! rm -rf db" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "chroma", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.8" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "88f09714c9334832bac29166716f9f6a879ee2a4ed4822c1d4120cb2393b58dd" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Local Persistence Demo\n", + "This notebook demonstrates how to configure Chroma to persist to disk, then load it back in. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import chromadb" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a new Chroma client with persistence enabled. \n", + "persist_directory = \"db\"\n", + "\n", + "client = chromadb.PersistentClient(path=persist_directory)\n", + "\n", + "# Create a new chroma collection\n", + "collection_name = \"peristed_collection\"\n", + "collection = client.get_or_create_collection(name=collection_name)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Add some data to the collection\n", + "collection.add(\n", + " embeddings=[\n", + " [1.1, 2.3, 3.2],\n", + " [4.5, 6.9, 4.4],\n", + " [1.1, 2.3, 3.2],\n", + " [4.5, 6.9, 4.4],\n", + " [1.1, 2.3, 3.2],\n", + " [4.5, 6.9, 4.4],\n", + " [1.1, 2.3, 3.2],\n", + " [4.5, 6.9, 4.4],\n", + " ],\n", + " metadatas=[\n", + " {\"uri\": \"img1.png\", \"style\": \"style1\"},\n", + " {\"uri\": \"img2.png\", \"style\": \"style2\"},\n", + " {\"uri\": \"img3.png\", \"style\": \"style1\"},\n", + " {\"uri\": \"img4.png\", \"style\": \"style1\"},\n", + " {\"uri\": \"img5.png\", \"style\": \"style1\"},\n", + " {\"uri\": \"img6.png\", \"style\": \"style1\"},\n", + " {\"uri\": \"img7.png\", \"style\": \"style1\"},\n", + " {\"uri\": \"img8.png\", \"style\": \"style1\"},\n", + " ],\n", + " documents=[\"doc1\", \"doc2\", \"doc3\", \"doc4\", \"doc5\", \"doc6\", \"doc7\", \"doc8\"],\n", + " ids=[\"id1\", \"id2\", \"id3\", \"id4\", \"id5\", \"id6\", \"id7\", \"id8\"],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a new client with the same settings\n", + "client = chromadb.PersistentClient(path=persist_directory)\n", + "\n", + "# Load the collection\n", + "collection = client.get_collection(collection_name)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'ids': [['id1']], 'distances': [[5.1159076593562386e-15]], 'metadatas': [[{'style': 'style1', 'uri': 'img1.png'}]], 'embeddings': None, 'documents': [['doc1']]}\n" + ] + } + ], + "source": [ + "# Query the collection\n", + "results = collection.query(\n", + " query_embeddings=[[1.1, 2.3, 3.2]],\n", + " n_results=1\n", + ")\n", + "\n", + "print(results)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'ids': ['id1', 'id2', 'id3', 'id4', 'id5', 'id6', 'id7', 'id8'],\n", + " 'embeddings': [[1.100000023841858, 2.299999952316284, 3.200000047683716],\n", + " [4.5, 6.900000095367432, 4.400000095367432],\n", + " [1.100000023841858, 2.299999952316284, 3.200000047683716],\n", + " [4.5, 6.900000095367432, 4.400000095367432],\n", + " [1.100000023841858, 2.299999952316284, 3.200000047683716],\n", + " [4.5, 6.900000095367432, 4.400000095367432],\n", + " [1.100000023841858, 2.299999952316284, 3.200000047683716],\n", + " [4.5, 6.900000095367432, 4.400000095367432]],\n", + " 'metadatas': [{'style': 'style1', 'uri': 'img1.png'},\n", + " {'style': 'style2', 'uri': 'img2.png'},\n", + " {'style': 'style1', 'uri': 'img3.png'},\n", + " {'style': 'style1', 'uri': 'img4.png'},\n", + " {'style': 'style1', 'uri': 'img5.png'},\n", + " {'style': 'style1', 'uri': 'img6.png'},\n", + " {'style': 'style1', 'uri': 'img7.png'},\n", + " {'style': 'style1', 'uri': 'img8.png'}],\n", + " 'documents': ['doc1', 'doc2', 'doc3', 'doc4', 'doc5', 'doc6', 'doc7', 'doc8']}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "collection.get(include=[\"embeddings\", \"metadatas\", \"documents\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Clean up\n", + "! rm -rf db" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "chroma", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "88f09714c9334832bac29166716f9f6a879ee2a4ed4822c1d4120cb2393b58dd" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file diff --git a/examples/basic_functionality/start_here.ipynb b/examples/basic_functionality/start_here.ipynb index 1487e491a5a..4f88d521bca 100644 --- a/examples/basic_functionality/start_here.ipynb +++ b/examples/basic_functionality/start_here.ipynb @@ -1,268 +1,268 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Basic embedding retrieval with Chroma\n", - "\n", - "This notebook demonstrates the most basic use of Chroma to store and retrieve information using embeddings. This core building block is at the heart of many powerful AI applications.\n", - "\n", - "## What are embeddings?\n", - "\n", - "Embeddings are the A.I-native way to represent any kind of data, making them the perfect fit for working with all kinds of A.I-powered tools and algorithms. They can represent text, images, and soon audio and video.\n", - "\n", - "To create an embedding, data is fed into an embedding model, which outputs vectors of numbers. The model is trained in such a way that 'similar' data, e.g. text with similar meanings, or images with similar content, will produce vectors which are nearer to one another, than those which are dissimilar.\n", - "\n", - "## Embeddings and retrieval\n", - "\n", - "We can use the similarity property of embeddings to search for and retrieve information. For example, we can find documents relevant to a particular topic, or images similar to a given image. Rather than searching for keywords or tags, we can search by finding data with similar semantic meaning.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Note: you may need to restart the kernel to use updated packages.\n" - ] - } - ], - "source": [ - "%pip install -Uq chromadb numpy datasets tqdm ipywidgets" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Example Dataset\n", - "\n", - "As a demonstration we use the [SciQ dataset](https://arxiv.org/abs/1707.06209), available from [HuggingFace](https://huggingface.co/datasets/sciq).\n", - "\n", - "Dataset description, from HuggingFace:\n", - "\n", - "> The SciQ dataset contains 13,679 crowdsourced science exam questions about Physics, Chemistry and Biology, among others. The questions are in multiple-choice format with 4 answer options each. For the majority of the questions, an additional paragraph with supporting evidence for the correct answer is provided.\n", - "\n", - "In this notebook, we will demonstrate how to retrieve supporting evidence for a given question.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of questions with support: 10481\n" - ] - } - ], - "source": [ - "# Get the SciQ dataset from HuggingFace\n", - "from datasets import load_dataset\n", - "\n", - "dataset = load_dataset(\"sciq\", split=\"train\")\n", - "\n", - "# Filter the dataset to only include questions with a support\n", - "dataset = dataset.filter(lambda x: x[\"support\"] != \"\")\n", - "\n", - "print(\"Number of questions with support: \", len(dataset))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Loading the data into Chroma\n", - "\n", - "Chroma comes with a built-in embedding model, which makes it simple to load text. \n", - "We can load the SciQ dataset into Chroma with just a few lines of code.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# Import Chroma and instantiate a client. The default Chroma client is ephemeral, meaning it will not save to disk.\n", - "import chromadb\n", - "\n", - "client = chromadb.Client()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# Create a new Chroma collection to store the supporting evidence. We don't need to specify an embedding fuction, and the default will be used.\n", - "collection = client.create_collection(\"sciq_supports\")" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6a36ed0079c34128bb4c007feacc6ad1", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Adding documents: 0%| | 0/11 [00:00 The SciQ dataset contains 13,679 crowdsourced science exam questions about Physics, Chemistry and Biology, among others. The questions are in multiple-choice format with 4 answer options each. For the majority of the questions, an additional paragraph with supporting evidence for the correct answer is provided.\n", + "\n", + "In this notebook, we will demonstrate how to retrieve supporting evidence for a given question.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of questions with support: 10481\n" + ] + } + ], + "source": [ + "# Get the SciQ dataset from HuggingFace\n", + "from datasets import load_dataset\n", + "\n", + "dataset = load_dataset(\"sciq\", split=\"train\")\n", + "\n", + "# Filter the dataset to only include questions with a support\n", + "dataset = dataset.filter(lambda x: x[\"support\"] != \"\")\n", + "\n", + "print(\"Number of questions with support: \", len(dataset))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading the data into Chroma\n", + "\n", + "Chroma comes with a built-in embedding model, which makes it simple to load text. \n", + "We can load the SciQ dataset into Chroma with just a few lines of code.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Import Chroma and instantiate a client. The default Chroma client is ephemeral, meaning it will not save to disk.\n", + "import chromadb\n", + "\n", + "client = chromadb.Client()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a new Chroma collection to store the supporting evidence. We don't need to specify an embedding function, and the default will be used.\n", + "collection = client.create_collection(\"sciq_supports\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6a36ed0079c34128bb4c007feacc6ad1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Adding documents: 0%| | 0/11 [00:00> SingleColumn let key_offset_bytes = K::offset_size(item_count); let value_offset_bytes = bit_util::round_upto_multiple_of_64((item_count + 1) * 4); - // validitiy sizing + // validity sizing let value_validity_bytes = V::validity_size(item_count); let total_size = bit_util::round_upto_multiple_of_64(prefix_size) diff --git a/rust/blockstore/src/arrow/block/value/data_record_value.rs b/rust/blockstore/src/arrow/block/value/data_record_value.rs index 613eb57952a..36ca477ecfb 100644 --- a/rust/blockstore/src/arrow/block/value/data_record_value.rs +++ b/rust/blockstore/src/arrow/block/value/data_record_value.rs @@ -41,10 +41,10 @@ impl ArrowWriteableValue for &DataRecord<'_> { fn offset_size(item_count: usize) -> usize { let id_offset = bit_util::round_upto_multiple_of_64((item_count + 1) * 4); - let metdata_offset = bit_util::round_upto_multiple_of_64((item_count + 1) * 4); + let metadata_offset = bit_util::round_upto_multiple_of_64((item_count + 1) * 4); let document_offset = bit_util::round_upto_multiple_of_64((item_count + 1) * 4); - id_offset + metdata_offset + document_offset + id_offset + metadata_offset + document_offset } fn validity_size(item_count: usize) -> usize { diff --git a/rust/blockstore/src/arrow/block/value/uint32array_value.rs b/rust/blockstore/src/arrow/block/value/uint32array_value.rs index 933145a0761..0126eba0127 100644 --- a/rust/blockstore/src/arrow/block/value/uint32array_value.rs +++ b/rust/blockstore/src/arrow/block/value/uint32array_value.rs @@ -105,7 +105,7 @@ impl<'referred_data> ArrowReadableValue<'referred_data> for &'referred_data [u32 let start = list_array.value_offsets()[index] as usize; let end = list_array.value_offsets()[index + 1] as usize; - // 9/17 In order to support backwards compatability before #2729 (https://github.com/chroma-core/chroma/pull/2729) + // 9/17 In order to support backwards compatibility before #2729 (https://github.com/chroma-core/chroma/pull/2729) // which had this stored as a Int32Array, we first try to downcast to a UInt32Array and then if that fails // we downcast to a Int32Array, if that fails we panic. let u32array = list_array.values().as_any().downcast_ref::(); diff --git a/rust/blockstore/src/arrow/blockfile.rs b/rust/blockstore/src/arrow/blockfile.rs index f94d069571d..1cdae8e7d3a 100644 --- a/rust/blockstore/src/arrow/blockfile.rs +++ b/rust/blockstore/src/arrow/blockfile.rs @@ -11,7 +11,7 @@ use crate::arrow::root::CURRENT_VERSION; use crate::arrow::sparse_index::SparseIndexWriter; use crate::key::CompositeKey; use crate::key::KeyWrapper; -use chroma_cache::AysncPartitionedMutex; +use chroma_cache::AsyncPartitionedMutex; use chroma_error::ChromaError; use chroma_error::ErrorCodes; use chroma_storage::admissioncontrolleds3::StorageRequestPriority; @@ -33,7 +33,7 @@ pub struct ArrowUnorderedBlockfileWriter { block_deltas: Arc>>, root: RootWriter, id: Uuid, - deltas_mutex: Arc>, + deltas_mutex: Arc>, } // TODO: method visibility should not be pub(crate) @@ -87,7 +87,7 @@ impl ArrowUnorderedBlockfileWriter { block_deltas, root: root_writer, id, - deltas_mutex: Arc::new(AysncPartitionedMutex::new(())), + deltas_mutex: Arc::new(AsyncPartitionedMutex::new(())), } } @@ -106,7 +106,7 @@ impl ArrowUnorderedBlockfileWriter { block_deltas, root: new_root, id, - deltas_mutex: Arc::new(AysncPartitionedMutex::new(())), + deltas_mutex: Arc::new(AsyncPartitionedMutex::new(())), } } @@ -811,7 +811,7 @@ mod tests { arrow::config::TEST_MAX_BLOCK_SIZE_BYTES, arrow::provider::ArrowBlockfileProvider, }; use crate::{BlockfileReader, BlockfileWriter, BlockfileWriterOptions}; - use chroma_cache::{new_cache_for_test, AysncPartitionedMutex}; + use chroma_cache::{new_cache_for_test, AsyncPartitionedMutex}; use chroma_storage::{local::LocalStorage, Storage}; use chroma_types::{CollectionUuid, DataRecord, DatabaseUuid, MetadataValue, SegmentUuid}; use futures::{StreamExt, TryStreamExt}; @@ -1883,13 +1883,13 @@ mod tests { let n = 2000; for i in 0..n { let key = format!("{:04}", i); - let mut metdata = HashMap::new(); - metdata.insert("key".to_string(), MetadataValue::Str("value".to_string())); + let mut metadata = HashMap::new(); + metadata.insert("key".to_string(), MetadataValue::Str("value".to_string())); let value = DataRecord { id: &key, embedding: &[i as f32], document: None, - metadata: Some(metdata), + metadata: Some(metadata), }; writer.set("key", key.as_str(), &value).await.unwrap(); } @@ -2265,7 +2265,7 @@ mod tests { block_deltas, root: root_writer, id: Uuid::new_v4(), - deltas_mutex: Arc::new(AysncPartitionedMutex::new(())), + deltas_mutex: Arc::new(AsyncPartitionedMutex::new(())), }; let n = 2000; diff --git a/rust/blockstore/src/arrow/sparse_index.rs b/rust/blockstore/src/arrow/sparse_index.rs index 3cd28a0fa62..fe1ae4149f1 100644 --- a/rust/blockstore/src/arrow/sparse_index.rs +++ b/rust/blockstore/src/arrow/sparse_index.rs @@ -10,7 +10,7 @@ use thiserror::Error; use uuid::Uuid; // ============ -// Sparse Index Delimeter +// Sparse Index Delimiter // ============ /// A sentinel blockfilekey wrapper to represent the start blocks range diff --git a/rust/blockstore/src/key.rs b/rust/blockstore/src/key.rs index a2569ec5b4a..96151d04d27 100644 --- a/rust/blockstore/src/key.rs +++ b/rust/blockstore/src/key.rs @@ -25,7 +25,7 @@ pub enum KeyWrapper { impl KeyWrapper { pub(crate) fn get_size(&self) -> usize { match self { - // TOOD: use key trait if possible + // TODO: use key trait if possible KeyWrapper::String(s) => s.len(), KeyWrapper::Float32(_) => 4, KeyWrapper::Bool(_) => 1, diff --git a/rust/cache/src/async_partitioned_mutex.rs b/rust/cache/src/async_partitioned_mutex.rs index 04e3cb30213..ee54d62a322 100644 --- a/rust/cache/src/async_partitioned_mutex.rs +++ b/rust/cache/src/async_partitioned_mutex.rs @@ -7,7 +7,7 @@ use std::{ }; #[derive(Clone, Debug)] -pub struct AysncPartitionedMutex +pub struct AsyncPartitionedMutex where K: Hash + Eq, H: Hasher + Default, @@ -21,7 +21,7 @@ where // TODO: A sensible value for this. const DEFAULT_NUM_PARTITIONS: usize = 32768; -impl AysncPartitionedMutex +impl AsyncPartitionedMutex where K: Hash + Eq, H: Hasher + Default, diff --git a/rust/config/src/assignment/rendezvous_hash.rs b/rust/config/src/assignment/rendezvous_hash.rs index dd40cfd8097..0d6d77fc14a 100644 --- a/rust/config/src/assignment/rendezvous_hash.rs +++ b/rust/config/src/assignment/rendezvous_hash.rs @@ -147,7 +147,7 @@ mod tests { fn test_even_distribution() { let key_count = 1000; let member_count = 10; - // Probablity of a key get assigned to a particular member, assuming perfect hashing + // Probability of a key get assigned to a particular member, assuming perfect hashing let prob = 1_f64 / member_count as f64; // Expected number of keys assigned to a member let expected = key_count as f64 * prob; @@ -180,7 +180,7 @@ mod tests { let k = 3; let key_count = 1000; let member_count = 10; - // Probablity of a key get assigned to a particular member, assuming perfect hashing + // Probability of a key get assigned to a particular member, assuming perfect hashing let prob = k as f64 / member_count as f64; // Expected number of keys assigned to a member let expected = key_count as f64 * prob; diff --git a/rust/distance/src/types.rs b/rust/distance/src/types.rs index ea3117a5a4b..7bde34fe1b6 100644 --- a/rust/distance/src/types.rs +++ b/rust/distance/src/types.rs @@ -231,7 +231,7 @@ impl From for DistanceFunction { } impl DistanceFunction { - // TOOD: Should we error if mismatched dimensions? + // TODO: Should we error if mismatched dimensions? pub fn distance(&self, a: &[f32], b: &[f32]) -> f32 { // TODO: Figure out why the compiler is not auto vectorizing these // by default. diff --git a/rust/frontend/src/config.rs b/rust/frontend/src/config.rs index 4a01d4e0e47..6ceaf9b8de8 100644 --- a/rust/frontend/src/config.rs +++ b/rust/frontend/src/config.rs @@ -197,7 +197,7 @@ impl FrontendServerConfig { } pub fn single_node_default() -> Self { - // TOOD: unify this with load_from_path to get the env overrides + // TODO: unify this with load_from_path to get the env overrides let config = DefaultConfigurationsFolder::get(DEFAULT_SINGLE_NODE_CONFIG_FILENAME) .expect("Failed to load default single node frontend config"); let config_data = config.data; diff --git a/rust/frontend/src/get_collection_with_segments_provider.rs b/rust/frontend/src/get_collection_with_segments_provider.rs index 20575522ab5..26e7659f8a3 100644 --- a/rust/frontend/src/get_collection_with_segments_provider.rs +++ b/rust/frontend/src/get_collection_with_segments_provider.rs @@ -1,5 +1,5 @@ use backon::ConstantBuilder; -use chroma_cache::{AysncPartitionedMutex, Cache, CacheError, Weighted}; +use chroma_cache::{AsyncPartitionedMutex, Cache, CacheError, Weighted}; use chroma_config::Configurable; use chroma_error::{ChromaError, ErrorCodes}; use chroma_sysdb::SysDb; @@ -67,7 +67,7 @@ impl Configurable for CollectionsWithSegm >(&config.cache) .await?; let sysdb_rpc_lock = - AysncPartitionedMutex::with_parallelism(config.permitted_parallelism as usize, ()); + AsyncPartitionedMutex::with_parallelism(config.permitted_parallelism as usize, ()); let retry_backoff = ConstantBuilder::default() .with_delay(Duration::from_millis( @@ -108,7 +108,7 @@ pub struct CollectionsWithSegmentsProvider { pub(crate) collections_with_segments_cache: Arc>, pub(crate) cache_ttl_secs: u32, - pub(crate) sysdb_rpc_lock: chroma_cache::AysncPartitionedMutex, + pub(crate) sysdb_rpc_lock: chroma_cache::AsyncPartitionedMutex, pub(crate) retry_backoff: ConstantBuilder, } diff --git a/rust/frontend/src/impls/service_based_frontend.rs b/rust/frontend/src/impls/service_based_frontend.rs index 99095cef6d0..cb4a58d4dc5 100644 --- a/rust/frontend/src/impls/service_based_frontend.rs +++ b/rust/frontend/src/impls/service_based_frontend.rs @@ -1772,7 +1772,7 @@ impl Configurable<(FrontendConfig, System)> for ServiceBasedFrontend { let mut log = Log::try_from_config(&(config.log.clone(), system.clone()), registry).await?; let max_batch_size = log.get_max_batch_size().await?; - // Create compation manager and pass handle to log service if configured + // Create compaction manager and pass handle to log service if configured if let Log::Sqlite(sqlite_log) = &log { let compaction_manager = LocalCompactionManager::try_from_config(&LocalCompactionManagerConfig {}, registry) diff --git a/rust/frontend/src/quota/mod.rs b/rust/frontend/src/quota/mod.rs index 5894f4292fc..dfa962d9d50 100644 --- a/rust/frontend/src/quota/mod.rs +++ b/rust/frontend/src/quota/mod.rs @@ -250,7 +250,7 @@ pub enum UsageType { IdSizeBytes, // Max id size in bytes NameSizeBytes, // Max name size in bytes (e.g. collection, database) LimitValue, // Max number of results to return - RankKnnLimit, // Max limit in rank knn expresion + RankKnnLimit, // Max limit in rank knn expression NumResults, // Number of results NumQueryEmbeddings, // Number of query embeddings CollectionSizeRecords, // Number of records in the collection diff --git a/rust/frontend/src/server.rs b/rust/frontend/src/server.rs index da37bee5303..0c029bec130 100644 --- a/rust/frontend/src/server.rs +++ b/rust/frontend/src/server.rs @@ -2119,7 +2119,7 @@ pub struct SearchRequestPayload { searches: Vec, } -/// Search records from a collection with hybrid criterias. +/// Search records from a collection with hybrid criteria. #[utoipa::path( post, path = "/api/v2/tenants/{tenant}/databases/{database}/collections/{collection_id}/search", @@ -2167,7 +2167,7 @@ async fn collection_search( .with_search_payloads(payload.searches.as_slice()); let quota_override = server.quota_enforcer.enforce("a_payload).await?; let _guard = server.scorecard_request(&[ - // TODO: Make this a read operation once we stablize this + // TODO: Make this a read operation once we stabilize this // "op:read", "op:search", format!("tenant:{}", tenant).as_str(), diff --git a/rust/garbage_collector/tests/proptest_helpers/segment_file_strategies.rs b/rust/garbage_collector/tests/proptest_helpers/segment_file_strategies.rs index 6ff870c9e04..a65b2ad0f6f 100644 --- a/rust/garbage_collector/tests/proptest_helpers/segment_file_strategies.rs +++ b/rust/garbage_collector/tests/proptest_helpers/segment_file_strategies.rs @@ -398,7 +398,7 @@ impl SegmentFilePaths { } } -/// A group of the three segment types. Note that the files generated for each segment type may not corelate with what the real system would create (e.g. the metadata segment may have HNSW files). +/// A group of the three segment types. Note that the files generated for each segment type may not correlate with what the real system would create (e.g. the metadata segment may have HNSW files). /// /// This grouping is used instead of generating a variable number of segments as the latter is quite difficult to construct with proptest (there's no transform for `Vec> -> BoxedStrategy>`). #[derive(Clone, Debug)] diff --git a/rust/index/benches/literal.rs b/rust/index/benches/literal.rs index 163c017a882..5714183733e 100644 --- a/rust/index/benches/literal.rs +++ b/rust/index/benches/literal.rs @@ -246,7 +246,7 @@ fn bench_literal(criterion: &mut Criterion) { .expect("Blockfile should be writable"); let flusher = runtime .block_on(full_text_writer.commit()) - .expect("Changes should be commitable"); + .expect("Changes should be committable"); runtime .block_on(flusher.flush()) .expect("Changes should be flushable"); diff --git a/rust/index/src/hnsw_provider.rs b/rust/index/src/hnsw_provider.rs index 2020fafa12b..db50790360d 100644 --- a/rust/index/src/hnsw_provider.rs +++ b/rust/index/src/hnsw_provider.rs @@ -5,7 +5,7 @@ use super::{HnswIndex, HnswIndexConfig, Index, IndexConfig, IndexUuid}; use crate::hnsw::WrappedHnswError; use async_trait::async_trait; -use chroma_cache::AysncPartitionedMutex; +use chroma_cache::AsyncPartitionedMutex; use chroma_cache::Cache; use chroma_config::registry::Registry; use chroma_config::Configurable; @@ -46,7 +46,7 @@ type CacheKey = CollectionUuid; // 1. get index version v1 // 2. get index version v2 (> v1) // 3. get index version v1 (can happen due to an inflight query -// that started before compaction of v2 occured) -- this will +// that started before compaction of v2 occurred) -- this will // evict v2 even though it is more recent and will be used again in future. // Once we have versioning propagated throughout the system we can make // this better. We can also do a deferred eviction for such entries when @@ -56,7 +56,7 @@ pub struct HnswIndexProvider { cache: Arc>, pub temporary_storage_path: PathBuf, storage: Storage, - pub write_mutex: AysncPartitionedMutex, + pub write_mutex: AsyncPartitionedMutex, // TODO(tanujnay112): This feature flag is a temporary measure to gate // the hnsw loading from memory feature. Remove this after that feature // stabilizes. @@ -149,7 +149,7 @@ impl HnswIndexProvider { cache, storage, temporary_storage_path: storage_path, - write_mutex: AysncPartitionedMutex::with_parallelism( + write_mutex: AsyncPartitionedMutex::with_parallelism( permitted_parallelism as usize, (), ), diff --git a/rust/index/src/spann/types.rs b/rust/index/src/spann/types.rs index 59269864c34..a9d93629702 100644 --- a/rust/index/src/spann/types.rs +++ b/rust/index/src/spann/types.rs @@ -11,7 +11,7 @@ use chroma_blockstore::{ provider::{BlockfileProvider, CreateError, OpenError}, BlockfileFlusher, BlockfileReader, BlockfileWriter, BlockfileWriterOptions, }; -use chroma_cache::AysncPartitionedMutex; +use chroma_cache::AsyncPartitionedMutex; use chroma_config::{registry::Registry, Configurable}; use chroma_distance::{normalize, DistanceFunction}; use chroma_error::{ChromaError, ErrorCodes}; @@ -308,7 +308,7 @@ pub struct SpannIndexWriter { blockfile_provider: BlockfileProvider, // Posting list of the centroids. pub posting_list_writer: BlockfileWriter, - pub posting_list_partitioned_mutex: Arc>, + pub posting_list_partitioned_mutex: Arc>, pub next_head_id: Arc, // Version number of each point. // TODO(Sanket): Finer grained locking for this map in future if perf is not satisfactory. @@ -451,7 +451,7 @@ impl SpannIndexWriter { hnsw_provider, blockfile_provider, posting_list_writer, - posting_list_partitioned_mutex: Arc::new(AysncPartitionedMutex::new(())), + posting_list_partitioned_mutex: Arc::new(AsyncPartitionedMutex::new(())), next_head_id: Arc::new(AtomicU32::new(next_head_id)), versions_map: Arc::new(tokio::sync::RwLock::new(versions_map)), dimensionality, diff --git a/rust/index/src/sparse/writer.rs b/rust/index/src/sparse/writer.rs index b372d49b0d8..c118b8d45d4 100644 --- a/rust/index/src/sparse/writer.rs +++ b/rust/index/src/sparse/writer.rs @@ -104,7 +104,7 @@ impl<'me> SparseWriter<'me> { let mut delta_guard = self.delta.lock().await; for (dimension_id, updates) in delta_guard.drain() { let encoded_dimension = encode_u32(dimension_id); - let (commited_blocks, mut offset_values) = match self.old_reader.as_ref() { + let (committed_blocks, mut offset_values) = match self.old_reader.as_ref() { Some(reader) => { let blocks = reader.get_blocks(&encoded_dimension).await?.collect(); let offset_values = reader @@ -115,7 +115,7 @@ impl<'me> SparseWriter<'me> { } None => (HashMap::new(), BTreeMap::new()), }; - for &offset in commited_blocks.keys() { + for &offset in committed_blocks.keys() { self.max_writer .delete::<_, f32>(&encoded_dimension, offset) .await?; diff --git a/rust/index/src/types.rs b/rust/index/src/types.rs index 7f870a7460a..0233b9a5322 100644 --- a/rust/index/src/types.rs +++ b/rust/index/src/types.rs @@ -71,7 +71,7 @@ pub trait PersistentIndex: Index { Self: Sized; // This function is used to load the index from memory without using disk. - // TODO(tanujnay112): Replace `load` from above with this once we stablize + // TODO(tanujnay112): Replace `load` from above with this once we stabilize // loading HNSW via memory. fn load_from_hnsw_data( hnsw_data: hnswlib::HnswData, diff --git a/rust/load/src/bit_difference.rs b/rust/load/src/bit_difference.rs index 5afab4778c6..dc80a1f91e6 100644 --- a/rust/load/src/bit_difference.rs +++ b/rust/load/src/bit_difference.rs @@ -404,7 +404,7 @@ mod tests { assert_eq!(EMBEDDING_SIZE, MANY_WORDS.len()); } - mod synthethic { + mod synthetic { use std::time::Instant; use super::*; diff --git a/rust/log-service/src/lib.rs b/rust/log-service/src/lib.rs index fa91c122997..b8aa6ed2fb2 100644 --- a/rust/log-service/src/lib.rs +++ b/rust/log-service/src/lib.rs @@ -2099,7 +2099,7 @@ impl RootConfig { /// # Notes /// The default location is the current working directory, with the filename chroma_config.yaml. /// The environment variables are prefixed with CHROMA_ and are uppercase. - /// Values in the envionment variables take precedence over values in the YAML file. + /// Values in the environment variables take precedence over values in the YAML file. pub fn load() -> Self { Self::load_from_path(DEFAULT_CONFIG_PATH) } @@ -2118,7 +2118,7 @@ impl RootConfig { /// - If the environment variables contain invalid values. /// # Notes /// The environment variables are prefixed with CHROMA_ and are uppercase. - /// Values in the envionment variables take precedence over values in the YAML file. + /// Values in the environment variables take precedence over values in the YAML file. // NOTE: Copied to ../load/src/config.rs. pub fn load_from_path(path: &str) -> Self { println!("loading config from {path}"); diff --git a/rust/log-service/src/state_hash_table.rs b/rust/log-service/src/state_hash_table.rs index 8ea8f3a3eab..9923ca33408 100644 --- a/rust/log-service/src/state_hash_table.rs +++ b/rust/log-service/src/state_hash_table.rs @@ -211,7 +211,7 @@ impl StateHashTable { /// Return a seemingly-arbitrary key from the hash table or None if there's no keys in the hash /// table. This is meant to be used for draining a server of waiters. #[allow(dead_code)] - pub fn arbitary_key(&self) -> Option { + pub fn arbitrary_key(&self) -> Option { self.entries .lock() .unwrap() diff --git a/rust/mdac/src/scorecard.rs b/rust/mdac/src/scorecard.rs index 87158f961a0..a5521eeaac3 100644 --- a/rust/mdac/src/scorecard.rs +++ b/rust/mdac/src/scorecard.rs @@ -323,7 +323,7 @@ pub struct ScorecardTicket { /////////////////////////////////////////// RuleEvaluator ////////////////////////////////////////// -/// A rule evaluator takes a set of rules and choses all rules that match a set of tags. It is +/// A rule evaluator takes a set of rules and chooses all rules that match a set of tags. It is /// logically akin to filtering the powerset of all rules to take the first matching rule for each /// member of the powerset. #[derive(Debug)] diff --git a/rust/memberlist/src/memberlist_provider.rs b/rust/memberlist/src/memberlist_provider.rs index 4c4c2da7640..556f686fab0 100644 --- a/rust/memberlist/src/memberlist_provider.rs +++ b/rust/memberlist/src/memberlist_provider.rs @@ -149,9 +149,9 @@ impl CustomResourceMemberlistProvider { Api::::namespaced(self.kube_client.clone(), &self.kube_ns); let field_selector = format!("metadata.name={}", self.memberlist_name); - let conifg = Config::default().fields(&field_selector); + let config = Config::default().fields(&field_selector); - let stream = watcher(memberlist_cr_client, conifg) + let stream = watcher(memberlist_cr_client, config) .default_backoff() .applied_objects(); let stream = stream.then(|event| async move { diff --git a/rust/segment/src/blockfile_record.rs b/rust/segment/src/blockfile_record.rs index be6bd1fd94e..1fc363e0d1b 100644 --- a/rust/segment/src/blockfile_record.rs +++ b/rust/segment/src/blockfile_record.rs @@ -796,7 +796,7 @@ impl RecordSegmentReader<'_> { let id_to_user_id = id_to_user_id_result?; let id_to_data = id_to_data_result?; - let exising_max_offset_id = + let existing_max_offset_id = match max_offset_id_bf_reader.get("", MAX_OFFSET_ID).await { Ok(Some(max_offset_id)) => max_offset_id, Ok(None) | Err(_) => 0, @@ -806,7 +806,7 @@ impl RecordSegmentReader<'_> { user_id_to_id, id_to_user_id, id_to_data, - exising_max_offset_id, + existing_max_offset_id, ) } 0 => { diff --git a/rust/segment/src/distributed_spann.rs b/rust/segment/src/distributed_spann.rs index 2c082f5f30b..f2cf20b5d72 100644 --- a/rust/segment/src/distributed_spann.rs +++ b/rust/segment/src/distributed_spann.rs @@ -1017,7 +1017,7 @@ mod test { .versions_map .get_range(.., ..) .await - .expect("Error gettting all data from reader") + .expect("Error getting all data from reader") .collect::>(); versions_map.sort_by(|a, b| a.1.cmp(&b.1)); assert_eq!( diff --git a/rust/segment/src/local_hnsw.rs b/rust/segment/src/local_hnsw.rs index c81041df73e..6f680a5b54c 100644 --- a/rust/segment/src/local_hnsw.rs +++ b/rust/segment/src/local_hnsw.rs @@ -446,7 +446,7 @@ pub enum LocalHnswSegmentWriterError { HnswIndexResizeError, #[error("Error applying log chunk")] HnswIndexDeleteError, - #[error("Error converting persistant path to string")] + #[error("Error converting persistent path to string")] PersistPathError, #[error("Error updating max sequence id")] QueryBuilderError(#[from] sea_query::error::Error), diff --git a/rust/segment/src/sqlite_metadata.rs b/rust/segment/src/sqlite_metadata.rs index 9c5c5a2263f..8a7e1e0ee77 100644 --- a/rust/segment/src/sqlite_metadata.rs +++ b/rust/segment/src/sqlite_metadata.rs @@ -571,7 +571,7 @@ impl IntoSqliteExpr for MetadataExpression { MetadataValue::Float(f) => (EmbeddingMetadata::FloatValue, Expr::val(*f)), MetadataValue::Str(s) => (EmbeddingMetadata::StringValue, Expr::val(s)), MetadataValue::SparseVector(_) => { - unimplemented!("Comparision with sparse vector is not allowed") + unimplemented!("Comparison with sparse vector is not allowed") } }; let scol = Expr::col((EmbeddingMetadata::Table, col)); diff --git a/rust/segment/src/test.rs b/rust/segment/src/test.rs index b4025bec350..e3c0c586e7f 100644 --- a/rust/segment/src/test.rs +++ b/rust/segment/src/test.rs @@ -114,7 +114,7 @@ impl TestDistributedSegment { &self.blockfile_provider, ) .await - .expect("Should be able to initiaize record writer."); + .expect("Should be able to initialize record writer."); record_writer .apply_materialized_log_chunk(&None, &materialized_logs) .await diff --git a/rust/segment/src/types.rs b/rust/segment/src/types.rs index 09f1894ea4f..5ed46df92bc 100644 --- a/rust/segment/src/types.rs +++ b/rust/segment/src/types.rs @@ -23,11 +23,11 @@ use super::distributed_hnsw::DistributedHNSWSegmentWriter; // Materializes metadata from update metadata, populating the delete list // and upsert list. fn materialize_update_metadata( - update_metdata: &UpdateMetadata, + update_metadata: &UpdateMetadata, ) -> Result<(Metadata, DeletedMetadata), MetadataValueConversionError> { let mut metadata = Metadata::new(); let mut deleted_metadata = DeletedMetadata::new(); - for (key, value) in update_metdata { + for (key, value) in update_metadata { if *value == UpdateMetadataValue::None { deleted_metadata.insert(key.clone()); continue; diff --git a/rust/system/src/execution/dispatcher.rs b/rust/system/src/execution/dispatcher.rs index bdf74a62d57..af8671a5907 100644 --- a/rust/system/src/execution/dispatcher.rs +++ b/rust/system/src/execution/dispatcher.rs @@ -50,8 +50,8 @@ use tracing::{trace_span, Instrument, Span}; ## Implementation notes - The dispatcher has a queue of tasks that it distributes to worker threads - A worker thread sends a TaskRequestMessage to the dispatcher when it is ready for a new task -- If no task is available for the worker thread, the dispatcher will place that worker's reciever - in a queue and send a task to the worker when it recieves another one +- If no task is available for the worker thread, the dispatcher will place that worker's receiver + in a queue and send a task to the worker when it receives another one - The reason to introduce this abstraction is to allow us to control fairness and dynamically adjust system utilization. It also makes mechanisms like pausing/stopping work easier. It would have likely been more performant to use the Tokio MT runtime, but we chose to use @@ -429,7 +429,7 @@ mod tests { #[derive(Debug)] struct MockIoDispatchUser { pub dispatcher: ComponentHandle, - counter: Arc, // We expect to recieve DISPATCH_COUNT messages + counter: Arc, // We expect to receive DISPATCH_COUNT messages sent_tasks: Arc>>, received_tasks: Arc>>, } @@ -497,7 +497,7 @@ mod tests { #[derive(Debug)] struct MockDispatchUser { pub dispatcher: ComponentHandle, - counter: Arc, // We expect to recieve DISPATCH_COUNT messages + counter: Arc, // We expect to receive DISPATCH_COUNT messages sent_tasks: Arc>>, received_tasks: Arc>>, } @@ -584,7 +584,7 @@ mod tests { assert_eq!(counter.load(Ordering::SeqCst), DISPATCH_COUNT); // The sent tasks should be equal to the received tasks assert_eq!(*sent_tasks.lock(), *received_tasks.lock()); - // The length of the sent/recieved tasks should be equal to the number of dispatched tasks + // The length of the sent/received tasks should be equal to the number of dispatched tasks assert_eq!(sent_tasks.lock().len(), DISPATCH_COUNT); assert_eq!(received_tasks.lock().len(), DISPATCH_COUNT); } @@ -618,7 +618,7 @@ mod tests { assert_eq!(counter.load(Ordering::SeqCst), DISPATCH_COUNT); // The sent tasks should be equal to the received tasks assert_eq!(*sent_tasks.lock(), *received_tasks.lock()); - // The length of the sent/recieved tasks should be equal to the number of dispatched tasks + // The length of the sent/received tasks should be equal to the number of dispatched tasks assert_eq!(sent_tasks.lock().len(), DISPATCH_COUNT); assert_eq!(received_tasks.lock().len(), DISPATCH_COUNT); } diff --git a/rust/types/src/data_chunk.rs b/rust/types/src/data_chunk.rs index 3e1ea2a57a7..55797974525 100644 --- a/rust/types/src/data_chunk.rs +++ b/rust/types/src/data_chunk.rs @@ -82,20 +82,20 @@ impl Chunk { /// The iterator returns a tuple of the element and its index /// # Returns /// An iterator over the visible elements in the data chunk - pub fn iter(&self) -> DataChunkIteraror<'_, T> { - DataChunkIteraror { + pub fn iter(&self) -> DataChunkIterator<'_, T> { + DataChunkIterator { chunk: self, index: 0, } } } -pub struct DataChunkIteraror<'a, T> { +pub struct DataChunkIterator<'a, T> { chunk: &'a Chunk, index: usize, } -impl<'a, T> Iterator for DataChunkIteraror<'a, T> { +impl<'a, T> Iterator for DataChunkIterator<'a, T> { type Item = (&'a T, usize); fn next(&mut self) -> Option { diff --git a/rust/types/src/execution/operator.rs b/rust/types/src/execution/operator.rs index a635ddaca30..b2a026f48d9 100644 --- a/rust/types/src/execution/operator.rs +++ b/rust/types/src/execution/operator.rs @@ -17,7 +17,7 @@ use super::error::QueryConversionError; pub type InitialInput = (); -/// The `Scan` opeartor pins the data used by all downstream operators +/// The `Scan` operator pins the data used by all downstream operators /// /// # Parameters /// - `collection_and_segments`: The consistent snapshot of collection diff --git a/rust/types/src/execution/plan.rs b/rust/types/src/execution/plan.rs index 070a057f23c..9eacc9cf47a 100644 --- a/rust/types/src/execution/plan.rs +++ b/rust/types/src/execution/plan.rs @@ -22,7 +22,7 @@ pub enum PlanToProtoError { Scan(#[from] ScanToProtoError), } -/// The `Count` plan shoud ouutput the total number of records in the collection +/// The `Count` plan should ouutput the total number of records in the collection #[derive(Clone)] pub struct Count { pub scan: Scan, diff --git a/rust/types/src/metadata.rs b/rust/types/src/metadata.rs index 4ea878f1cd4..cb0b975e5d1 100644 --- a/rust/types/src/metadata.rs +++ b/rust/types/src/metadata.rs @@ -734,7 +734,7 @@ impl WhereConversionError { /// unifying them together, and the structure of the unified AST should be identical to the one here. /// Currently both `where` and `where_document` clauses will be translated into `Where`, and if both are /// present we simply create a conjunction of both clauses as the actual filter. This is consistent with -/// the semantics we used to have when the `where` and `where_document` clauses are treated seperately. +/// the semantics we used to have when the `where` and `where_document` clauses are treated separately. // TODO: Remove this note once the `where` clause and `where_document` clause is unified in the API level. #[derive(Clone, Debug, PartialEq, ToSchema)] pub enum Where { diff --git a/rust/types/src/record.rs b/rust/types/src/record.rs index aba2d5c62ae..eea3c712fea 100644 --- a/rust/types/src/record.rs +++ b/rust/types/src/record.rs @@ -119,12 +119,12 @@ impl TryFrom for chroma_proto::OperationRecord { if let Some(doc) = operation_record.document { // NOTE: The proto record does not have a document field so we need to hide document in metadata - let mut patched_metdata = metadata.take().unwrap_or_default(); - patched_metdata.insert( + let mut patched_metadata = metadata.take().unwrap_or_default(); + patched_metadata.insert( CHROMA_DOCUMENT_KEY.to_string(), UpdateMetadataValue::Str(doc), ); - metadata = Some(patched_metdata); + metadata = Some(patched_metadata); } let proto_metadata = metadata.map(Into::into); diff --git a/rust/types/src/regex/mod.rs b/rust/types/src/regex/mod.rs index 20507523066..1d5b772f02f 100644 --- a/rust/types/src/regex/mod.rs +++ b/rust/types/src/regex/mod.rs @@ -13,7 +13,7 @@ use thiserror::Error; /// will perform all necessary validation to check this. /// /// We would like to leverage the regex_syntax crate to provide basic parsing and simplification -/// of regex expression, and in the process guard against unsupported features by examing the +/// of regex expression, and in the process guard against unsupported features by examining the /// parsed syntax tree. #[derive(Clone, Debug)] pub struct ChromaRegex { @@ -30,7 +30,7 @@ pub enum ChromaRegexError { #[error("Unexpected regex error: {0}")] Regex(String), // NOTE: regex_syntax::Error is a large type, so we only store its error message here. - #[error("Regex syntax errror: {0}")] + #[error("Regex syntax error: {0}")] RegexSyntax(String), } @@ -43,7 +43,7 @@ impl ChromaRegex { } pub fn regex(&self) -> Result { // NOTE: Although this method return a Result<_, _> type, in practice it should always - // be Ok(_) becasue we validate the pattern during struct construction. Specifically, + // be Ok(_) because we validate the pattern during struct construction. Specifically, // we verify that the pattern can be properly parsed and is thus a valid pattern supported // by the regex crate. Regex::new(&self.pattern).map_err(|e| ChromaRegexError::Regex(e.to_string())) diff --git a/rust/types/src/signed_rbm.rs b/rust/types/src/signed_rbm.rs index 8a815d76a22..741af456996 100644 --- a/rust/types/src/signed_rbm.rs +++ b/rust/types/src/signed_rbm.rs @@ -5,7 +5,7 @@ use roaring::RoaringBitmap; /// This enum helps to delay the evaluation of set minus in metadata filtering: /// - `Include(rbm)` suggests the result contains the specified ids in `rbm`. /// For example, `: {$eq: }` will result in a `Include()`. -/// - `Exclude(rbm)` suggests the result exludes the specified ids in `rbm`. +/// - `Exclude(rbm)` suggests the result excludes the specified ids in `rbm`. /// For example, `: {$ne: }` will result in a `Exclude()` /// /// Without this, we need to figure out the set of existing ids when we evaluate `$ne`, `$nin`, and `$not_contains`, @@ -13,7 +13,7 @@ use roaring::RoaringBitmap; /// /// `{$and: [{: {$gt: }}, {: {$ne: }}]}` /// -/// The naive way is to evaluate the `$gt` and `$ne` seperately and take the conjunction, but this requires +/// The naive way is to evaluate the `$gt` and `$ne` separately and take the conjunction, but this requires /// us to know the full set of existing ids because it is needed to evaluate `$ne`. /// However, we can first evaluate `$gt` and then exclude the offset ids for records with metadata `k1=v1`. /// This behavior is captured in the `BitAnd::bitand` operator of `SignedRoaringBitmap`: diff --git a/rust/wal3/README.md b/rust/wal3/README.md index b9de7483f28..fc25c7137dc 100644 --- a/rust/wal3/README.md +++ b/rust/wal3/README.md @@ -1,16 +1,15 @@ -wal3 -==== +# wal3 -wal3 is the write-ahead (lightweight) logging library. It implements a linearlizable log that is -built entirely on top of object storage. It relies upon the atomicity of object storage to provide -the If-Match header. This allows us to create a log entirely on top of object storage without any +wal3 is the write-ahead (lightweight) logging library. It implements a linearizable log that is +built entirely on top of object storage. It relies upon the atomicity of object storage to provide +the If-Match header. This allows us to create a log entirely on top of object storage without any other sources of locking or coordination. -This log is designed to provide high throughput with a single writer and multiple readers, but it will remain correct and available even if multiple writers are present. Mostly this is intended to recover from a crashed or underperforming writer without risking the correctness of the log. +This log is designed to provide high throughput with a single writer and multiple readers, but it will remain correct and available even if multiple writers are present. Mostly this is intended to recover from a crashed or underperforming writer without risking the correctness of the log. # Design -wal3 is designed to work on object storage. It is intended to to be lightweight, to allow a single +wal3 is designed to work on object storage. It is intended to be lightweight, to allow a single machine to multiplex many logs simultaneously over a variety of paths. At a high level wal3's logged records are in a large number of immutable files on object storage ("fragments"), and wal3 maintains multiple files that track which files compose the log and in which order. Those files are organized in a tree for performance. The root is the "manifest" (mutable) and the interior nodes are the "snapshots" (immutable). @@ -18,7 +17,7 @@ At a high level wal3's logged records are in a large number of immutable files o ## Interface wal3 presents separate reader and writer interfaces in order to allow readers and writers to scale -separately. Readers can read the log without blocking writers and writers can append to the log +separately. Readers can read the log without blocking writers and writers can append to the log without blocking readers. ```text @@ -57,8 +56,8 @@ impl LogReader { } ``` -The astute reader will note that this log is in process. It is meant to be run under leader -election, with all writes routed to the log, just as one would do running a server. The leader +The astute reader will note that this log is in process. It is meant to be run under leader +election, with all writes routed to the log, just as one would do running a server. The leader election need only be best effort---if two writers write to the log at the same time, at most one will succeed. @@ -68,49 +67,49 @@ wal3 is built around the following data structures: - A log is the unit of data isolation in wal3 and the unit of API instantiation. - A `Fragment` is a single, immutable file that contains a subsequence of data for a log. -- A `Manifest` is a file that contains the metadata for the log. The current state of the log is the list of fragments. +- A `Manifest` is a file that contains the metadata for the log. The current state of the log is the list of fragments. - A `Cursor` holds a position in the log, pinning that position and all subsequent positions from being garbage collected. -The manifest ties the log together. It transitively contains a complete reference to every file +The manifest ties the log together. It transitively contains a complete reference to every file that has been written to the log and not yet garbage collected. ### A Note about Setsums -wal3 uses a cryptographic hash to create a setsum of the data in the log. This setsum is an -associative and commutative hash function that is used to verify the integrity of the log. Because +wal3 uses a cryptographic hash to create a setsum of the data in the log. This setsum is an +associative and commutative hash function that is used to verify the integrity of the log. Because of the way the hash function is constructed, it is possible to compute a new setsum from an existing -setsum and the setsum of a new fragment. This allows us to get cryptographic-strength integrity -checking of the log. We go into this at length in the verifiability section below. +setsum and the setsum of a new fragment. This allows us to get cryptographic-strength integrity +checking of the log. We go into this at length in the verifiability section below. ### Manifest Structure The Manifest is a JSON file that contains the following fields: -- setsum: A setsum of the log data. This is the setsum of everything in the log. Every update to +- setsum: A setsum of the log data. This is the setsum of everything in the log. Every update to the log computes a new setsum and updates the manifest to reflect the checksum. -- pruned: A setsum of the log data that has been pruned and thrown away. The fragments of +- pruned: A setsum of the log data that has been pruned and thrown away. The fragments of the log plus the `pruned` value must equal `setsum` -- fragments: A list of fragments. Each fragment contains the following fields: - - path: The path to the fragment relative to the root of the log. The full path is specified - here so that any bugs or changes in the path layout don't invalidate past logs. - - fragment_seq_no: The sequence number of the fragment. This is used to order the fragments - within a log. - - start: The lowest log position in the fragment. Note that this embeds time and space. - - limit: The lowest log position after the fragment. Note that this embeds time and space. - - setsum: The setsum of the log fragment. -- snapshots: A list of snapshots. These are like interior nodes of a B+ tree and refer to - fragments that are further in the past. Each snapshot contains the following fields: - - path_to_snapshot: The path to the snapshot relative to the root of the log. Similar to fragments, the - full path is specified so that any bugs or changes in the path layout don't invalidate - previously-written logs. - - depth: The maximum number of snapshots between this snapshot and the fragments that serve as - leaf nodes for the tree. - - setsum: The setsum of the snapshot. This uniquely identifies the data to the degree that - sha3 does not collide. - - start: The offset of the first record maintained by this snapshot. - - limit: The offset of the first record too new to be maintained within this snapshot. -- writer: A plain-text string for debugging which process wrote the manifest. +- fragments: A list of fragments. Each fragment contains the following fields: + - path: The path to the fragment relative to the root of the log. The full path is specified + here so that any bugs or changes in the path layout don't invalidate past logs. + - fragment_seq_no: The sequence number of the fragment. This is used to order the fragments + within a log. + - start: The lowest log position in the fragment. Note that this embeds time and space. + - limit: The lowest log position after the fragment. Note that this embeds time and space. + - setsum: The setsum of the log fragment. +- snapshots: A list of snapshots. These are like interior nodes of a B+ tree and refer to + fragments that are further in the past. Each snapshot contains the following fields: + - path_to_snapshot: The path to the snapshot relative to the root of the log. Similar to fragments, the + full path is specified so that any bugs or changes in the path layout don't invalidate + previously-written logs. + - depth: The maximum number of snapshots between this snapshot and the fragments that serve as + leaf nodes for the tree. + - setsum: The setsum of the snapshot. This uniquely identifies the data to the degree that + sha3 does not collide. + - start: The offset of the first record maintained by this snapshot. + - limit: The offset of the first record too new to be maintained within this snapshot. +- writer: A plain-text string for debugging which process wrote the manifest. Invariants of the manifest: @@ -119,28 +118,28 @@ Invariants of the manifest: - fragments.seq_no is sequential. - fragment.start < fragment.limit for all fragments. - fragment.start is strictly increasing. -- The range (fragment.start, fragment.limit) is disjoint for all fragments in a manifest. No other +- The range (fragment.start, fragment.limit) is disjoint for all fragments in a manifest. No other fragment will have overlap with log position. - snapshot.start < snapshot.limit for all snapshots. - snapshot.start is strictly increasing. -- The range (snapshot.start, snapshot.limit) is disjoint for all snapshots in a manifest. No other - snapshot will have overlap with log position. Children of the snapshot will be wholely contained +- The range (snapshot.start, snapshot.limit) is disjoint for all snapshots in a manifest. No other + snapshot will have overlap with log position. Children of the snapshot will be wholly contained within the snapshot. ### Cursor Structure A cursor is a JSON file that contains the following fields: -- position: A LogPosition of the cursor. -- epoch_us: A timestamp corresponding to when the cursor was written. This is the number of +- position: A LogPosition of the cursor. +- epoch_us: A timestamp corresponding to when the cursor was written. This is the number of microseconds since UNIX epoch. -- writer: A plain-text string for debugging which process wrote the cursor. +- writer: A plain-text string for debugging which process wrote the cursor. ### Garbage File A garbage file specifies the set of snapshot pointers to delete, a range of fragments to delete, and -the set of new snapshots to create. Conceptually it corresponds to a cleaving of the tree -maintained within snapshots such that the oldest snapshots get pruned. The garbage file also embeds +the set of new snapshots to create. Conceptually it corresponds to a cleaving of the tree +maintained within snapshots such that the oldest snapshots get pruned. The garbage file also embeds the setsums of the garbage so that a manifest can be adjusted and scrubbed prior to enacting the deletions specified in the file. @@ -150,11 +149,11 @@ on the manifest. ## Object Store Layout wal3 is designed to maximize object store performance of object stores like S3 because it writes -logs in a way that scales. Concretely, we leverage the behavior that S3 and similar services -institute rate limiting per prefix. For example, given the following log files in an S3 bucket, +logs in a way that scales. Concretely, we leverage the behavior that S3 and similar services +institute rate limiting per prefix. For example, given the following log files in an S3 bucket, we will group fragments in groups of 5000 and the manifest will be in a separate prefix. -The following shows numbers every 5000. I'd zero-pad to 16 hex digits for the sequence number and +The following shows numbers every 5000. I'd zero-pad to 16 hex digits for the sequence number and bucket fragments in groups of 4096 so the bits align and look pretty in the bucket prefix. ```text @@ -194,12 +193,12 @@ wal3/garbage/GARBAGE The write path is: -2. The writer calls `push_work` to submit work to the fragment manager. This enqueues the work. -3. The writer calls `take_work` from the fragment manager. If there is a batch of sufficient size +2. The writer calls `push_work` to submit work to the fragment manager. This enqueues the work. +3. The writer calls `take_work` from the fragment manager. If there is a batch of sufficient size and a free fragment, it will assign the work to that fragment and return the work to be written. - Go to 4. If there is no batch, skip to step 3a. - a. Enqueue and wait for some other task to signal that the work is ready. Go to 6. -4. Flush the work from take_work to object storage. This will call assign-timestamp on the + Go to 4. If there is no batch, skip to step 3a. + a. Enqueue and wait for some other task to signal that the work is ready. Go to 6. +4. Flush the work from take_work to object storage. This will call assign-timestamp on the manifest manager. 5. The writer creates a change to the manifest---the new fragment and its setsum---and calls `apply_fragment` on the manifest manager. @@ -207,19 +206,19 @@ The write path is: ## Cursoring -wal3's scan API intentionally resembles a cursor API. To facilitate easy use of the scan API, wal3 -has an explicit cursor store. Although it is possible to store cursors anywhere, using the built-in -wal3 cursor store has one advantage: wal3 uses cursors to drive garbage collection. Each cursor +wal3's scan API intentionally resembles a cursor API. To facilitate easy use of the scan API, wal3 +has an explicit cursor store. Although it is possible to store cursors anywhere, using the built-in +wal3 cursor store has one advantage: wal3 uses cursors to drive garbage collection. Each cursor pins a position in the stream of appends, and preserves every append subsequent to the cursor. Cursors are integral to utility of wal3 to Chroma, so we'll briefly revisit how Chroma's log works -today to see how it could work with Chroma. In Chroma, the log maintains two positions: The -compaction offset and the tail of the log. At any time, a reader must brute force or scan the data -on the log to be strongly consistent. To counteract this from growing without bound, compaction +today to see how it could work with Chroma. In Chroma, the log maintains two positions: The +compaction offset and the tail of the log. At any time, a reader must brute force or scan the data +on the log to be strongly consistent. To counteract this from growing without bound, compaction periodically rewrites a snapshot of the data that merges the last compaction's output with all data on the log. -In wal3 terminology, the compaction offset is a cursor. It pins the log in place. Cursors are just +In wal3 terminology, the compaction offset is a cursor. It pins the log in place. Cursors are just files stored in object storage like so: ```text @@ -227,21 +226,21 @@ wal3/cursor/compaction.json wal3/cursor/emergency.json ``` -Here we see two cursors: One for compaction and one named emergency. The emergency cursor could +Here we see two cursors: One for compaction and one named emergency. The emergency cursor could e.g. have been from an emergency situation in which data needs to be retained regardless of -compaction activity. wal3 garbage collects solely those objects in the past for all cursors. +compaction activity. wal3 garbage collects solely those objects in the past for all cursors. The cursor API needs to expose a compare-and-swap like interface for its update so that the client -can move cursors safely. This means that when writing a cursor, you must provide a witness to the +can move cursors safely. This means that when writing a cursor, you must provide a witness to the previous cursor. ### Separate Files -The cursor store intentionally uses separate files from the manifest. This means that writing an +The cursor store intentionally uses separate files from the manifest. This means that writing an emergency, "Pin the log in a hurry," cursor does not require contending on the manifest to write it. The alternative design is to embed cursors within the manifest and use conditional swaps to install -the manifest. The advantage of separate files is operational simplicity. The advantage of using a -manifest is that it allows for a single atomic operation to update the manifest and cursor. As of +the manifest. The advantage of separate files is operational simplicity. The advantage of using a +manifest is that it allows for a single atomic operation to update the manifest and cursor. As of today there's no reason to atomically update the cursor and manifest, but being able to adjust cursors independently of the manifest allows for more flexibility in the design of the log. @@ -249,88 +248,88 @@ cursors independently of the manifest allows for more flexibility in the design The cursor store is used to inhibit garbage collection. -The garbage collection dance for the log is driven by a process external to wal3. It goes something +The garbage collection dance for the log is driven by a process external to wal3. It goes something like: -Phase 1: Compute garbage +Phase 1: Compute garbage 1. Read all cursors 2. Read the manifest 3. Select the minimum timestamp across all cursors as the garbage collection cutoff, optionally taking an even lower garbage collection cutoff as an argument. 4. Write a list of snapshots and fragments that hold data strictly less than the cutoff to a file - named `gc/GARBAGE`. There can be only one gc in progress at a time, so gc is kicked off by - running transitioning the `gc/GARBAGE` from an empty file to a file with content. AWS S3 does + named `gc/GARBAGE`. There can be only one gc in progress at a time, so gc is kicked off by + running transitioning the `gc/GARBAGE` from an empty file to a file with content. AWS S3 does not support if-match on delete, so the garbage file will overwritten with an empty file each time GC is done rather than being deleted. -Phase 2: Update manifest +Phase 2: Update manifest 5. Wait until the writer writes a manifest that does not contain the garbage's fragments. -Phase 3: Delete garbage +Phase 3: Delete garbage 6. Wait a sufficiently long time so that readers cannot see the fragments. 7. Delete the contents of the garbage file. 8. Transition the garbage file to empty. If this process crashes at any point before 4 is complete, the garbage collector has effectively -taken no stateful action. If the process crashes after the garbage file is written, step 5 will +taken no stateful action. If the process crashes after the garbage file is written, step 5 will synchronize with the writer to ensure that the garbage file is not deleted until the writer no longer references it. The point of doing this in three phases is to ensure that deleting of garbage happens in just one -service: The service calling phase3. Phases 1 and 2 could technically live together, but were +service: The service calling phase3. Phases 1 and 2 could technically live together, but were separated so as to make the minimal amount of I/O to update the manifest. ## Timing Assumptions -wal3 is designed to be used in a distributed system where clocks are not synchronized. Further, S3 -and other object storage providers do not provide cross-object transactional guarantees. This means -that our garbage collection needs to beware several timing issues. To resolve these, we will set a -system parameter known as the garbage collection interval. Every timing assumption should relate -some quantifiable measurement to this interval. If we assume that these other measurements occur +wal3 is designed to be used in a distributed system where clocks are not synchronized. Further, S3 +and other object storage providers do not provide cross-object transactional guarantees. This means +that our garbage collection needs to beware several timing issues. To resolve these, we will set a +system parameter known as the garbage collection interval. Every timing assumption should relate +some quantifiable measurement to this interval. If we assume that these other measurements occur sufficiently frequently and the garbage collection occurs significantly infrequently, we effectively -guarantee system safety. Therefore: +guarantee system safety. Therefore: - A writer must be sufficiently up-to-date that it has loaded a link in the manifest chain that is - not yet garbage collected. This is because a writer that believes it can write to fragment SeqNo=N + not yet garbage collected. This is because a writer that believes it can write to fragment SeqNo=N must be sure that fragment SeqNo=N has never existed; if it existed and was garbage collected, the - log breaks. Verifiers will detect this case, but it's effectively a split brain and should be - avoided. To avoid this, writers must complete all operations within the garbage collection + log breaks. Verifiers will detect this case, but it's effectively a split brain and should be + avoided. To avoid this, writers must complete all operations within the garbage collection interval. - A reader writing a _new_ cursor, or a cursor that goes back in time must complete the operation in less than the garbage collection interval and then check for a concurrent garbage collection - before it considers the operation complete. If the reader somehow hangs between loading a log + before it considers the operation complete. If the reader somehow hangs between loading a log offset and writing the cursor for more than the garbage collection interval, the cursor will - reference garbage collected data. The reader will fail. + reference garbage collected data. The reader will fail. This garbage collection interval is step 6 in the garbage collection dance above. ## Zero-Action Recovery -The structure of wal3 is such that it is possible to recover from a crash without any action. Every -write to S3 leaves the log in a consistent state. The only thing that can happen on crash is that +The structure of wal3 is such that it is possible to recover from a crash without any action. Every +write to S3 leaves the log in a consistent state. The only thing that can happen on crash is that there is additional work for garbage collection---files that were written but not linked into the -manifest. This is a simple matter of running the garbage collector. +manifest. This is a simple matter of running the garbage collector. ## End-to-End Walkthrough of the Write Path and Garbage Collection An end-to-end walkthrough of the write path is as follows: -0. The writer is initialized with a set of options. This includes the object store to write to, +0. The writer is initialized with a set of options. This includes the object store to write to, and any other configuration such as throttling. -1. The writer reads the existing manifest. If there is no manifest, it creates a new initial +1. The writer reads the existing manifest. If there is no manifest, it creates a new initial manifest and writes it to the object store. -2. A client calls `writer.append` with a message. The writer adds work to the fragment manager. +2. A client calls `writer.append` with a message. The writer adds work to the fragment manager. 3. If there is sufficient work available or sufficient time has passed and there is a fragment that can be written to, the writer takes a batch of work from the fragment manager and writes it to a single fragment. 4. The writer then creates a change to the manifest and applies it to the manifest manager using - `apply_fragment`. Internally, the manifest manager allows fragments to be applied in their - appropriate order. It streams speculative writes to the manifest. + `apply_fragment`. Internally, the manifest manager allows fragments to be applied in their + appropriate order. It streams speculative writes to the manifest. 5. When there is capacity to write the manifest, the manifest manager writes the manifest to the - object store. The write is durable and readable by all readers. + object store. The write is durable and readable by all readers. Garbage collection is a separate process that runs in the background: @@ -339,29 +338,29 @@ Garbage collection is a separate process that runs in the background: cutoff. 2. Write the `gc/GARBAGE` file with list of fragments and snapshots to delete. 3. Call into the primary writer service to request that it write a new manifest to the log, using - the normal write protocol. This will fail prevent a failure due to log contention. + the normal write protocol. This will fail prevent a failure due to log contention. 4. Verify that the files listed in 3 _are no longer referenced_. 5. Delete the files that were affirmatively verified. -The big idea is to use positive, affirmative signals to delete files. There's a slight step of +The big idea is to use positive, affirmative signals to delete files. There's a slight step of synchronization between writer and garbage collector; an alternative design to consider would be to have the garbage collector stomp on a manifest and let the writer pick up the pieces, but that requires strictly more computer work to recover and leads to a sub-par experience. # Non-Obvious Design Considerations -wal3 is designed to be a simple, linearizable log on top of object storage. This section details +wal3 is designed to be a simple, linearizable log on top of object storage. This section details non-obvious consequences of its design. ## Manifest Compaction -The manifest is a chain of writes, each of which adds a new file to the previous write. Look at +The manifest is a chain of writes, each of which adds a new file to the previous write. Look at this another way and the number of bytes written to object storage for the manifest is quadratic in -the number of writes to the manifest. This is a problem because each manifest write is +the number of writes to the manifest. This is a problem because each manifest write is incrementally more expensive than the previous write. To compensate, the manifest writer periodically writes a snapshot of the manifest that contains a -prefix of the manifest that it won't rewrite. This is a form of fragmentation. +prefix of the manifest that it won't rewrite. This is a form of fragmentation. The direct way to handle this would be to write a snapshot every N writes and embed the snapshots. @@ -379,36 +378,36 @@ The direct way to handle this would be to write a snapshot every N writes and em This requires writing a new snapshot everytime a new manifest that exceeds the size is written. This would be the straight-forward way to handle this, except that it requires writing SNAPSHOT.x -before writing MANIFEST and a naive implementation would introduce latency. The manifest writer +before writing MANIFEST and a naive implementation would introduce latency. The manifest writer is a hot path and we don't want to introduce an extra round trip. Instead, we are able to leverage the fact that a manifest's prefix is immutable and under control of -the writer. The writer can write a snapshot of the manifest at any time, and then use it in the -first manifest that it starts writing after the snapshot completes. The question then becomes what +the writer. The writer can write a snapshot of the manifest at any time, and then use it in the +first manifest that it starts writing after the snapshot completes. The question then becomes what the structure of the manifest/snapshot/fragment pointer-rich data structure looks like. Back-of-the-envelope calculations show that a single manifest is not sufficiently large to hold a -whole log efficiently. The same calculations show that a tree of manifests composing a single root +whole log efficiently. The same calculations show that a tree of manifests composing a single root node with a single level of interior nodes and a single level of leaves is sufficient to capture any log that we currently design for from a stationary perspective. -Keeping a perfectly balanced tree is hard, however. And since the root of the multi-rooted tree is +Keeping a perfectly balanced tree is hard, however. And since the root of the multi-rooted tree is a manifest, we rewrite the indirect pointers to the tree each time that we write a new manifest. The bulk of this manifest is the indirect pointers to the interior nodes of the tree. -We can do better, however, by recognizing that the tree is skewed in its access pattern. Readers +We can do better, however, by recognizing that the tree is skewed in its access pattern. Readers that read the whole tree will not be bothered by having to walk a tree of manifests, but readers that are looking to do a query of the tail of the log should be able to do so without having to walk multiple manifests. To this end, we introduce a second level of indirection in the manifest so that we will have a root, -two levels of interior nodes, and a level of leaves. The root will point to the interior nodes, the +two levels of interior nodes, and a level of leaves. The root will point to the interior nodes, the first level of interior nodes point to the second level, and that level points to the leaves. This is, strictly speaking, an optimization, but one that will allow us to scale the log to beyond -all forseeable current requirements. 20-25 pointers in the root, or 2kB are all that's needed to +all foreseeable current requirements. 20-25 pointers in the root, or 2kB are all that's needed to capture a log that's more than a petabyte in size if the log is written at maximum batch size. -Compare that to 5k pointers or 329kB for a single manifest. We're dealing with kilobytes per +Compare that to 5k pointers or 329kB for a single manifest. We're dealing with kilobytes per manifest for a log that's petabytes, but when each manifest targets < 1MB in size, the difference at write time is apparent in the latency. @@ -433,8 +432,8 @@ root ### Interplay Between Snapshots and Setsum -The setsum protects the snapshot mechanism. Each pointer to a snapshot embeds within the pointer -itself a reference to the setsum of the pointed-to snapshot. The following example shows how to +The setsum protects the snapshot mechanism. Each pointer to a snapshot embeds within the pointer +itself a reference to the setsum of the pointed-to snapshot. The following example shows how to balance setsums. ```text @@ -449,9 +448,9 @@ balance setsums. setsum(A - J) = setsum(A - D) + setsum(E - J) ``` -To compact the manifest's pointers A-D, wal3 would write a new snapshot under `setsum(A-D)`. Once +To compact the manifest's pointers A-D, wal3 would write a new snapshot under `setsum(A-D)`. Once that snapshot is written, the manifest next manifest to write replaces the fragments A, B, C, D with -a single snapshot.A-D. The setsum of the new manifest is setsum(A-D) + setsum(E-J), which conserves +a single snapshot.A-D. The setsum of the new manifest is setsum(A-D) + setsum(E-J), which conserves the setsum(A-J), providing some measure of proof that integrity is assured and no data is lost from the log when compacting. @@ -461,71 +460,71 @@ There is no data/fragment file stored in S3 that is ever mutated or overwritten correctly-functioning wal3 instance. We can make use of this structural sharing to allow cheap snapshots of the entire log that simply -incur garbage collection costs. These snapshots can be used to enable applications to do long-lived +incur garbage collection costs. These snapshots can be used to enable applications to do long-lived reads of a subset of the log without having to race with garbage collection, and without having to -stall garbage collection for everyone. The subset to be scanned gets pinned temporarily and +stall garbage collection for everyone. The subset to be scanned gets pinned temporarily and addressed at the first garbage collection after the snapshot is removed. ## Sealing the Log The log provides an additional seal method (not provided on the writer, but will be a separate -sealer class) by which a log can be marked as "sealed". A sealed log is a log that will not accept -any further writes. The seal is a JSON blob in the manifest that is checked by the writer before it +sealer class) by which a log can be marked as "sealed". A sealed log is a log that will not accept +any further writes. The seal is a JSON blob in the manifest that is checked by the writer before it writes a new manifest. -The purpose of the seal is to allow for the log to be migrated to a new log. The seal is a way to -consistently ensure that writes are in total order. The new log gets initialized only after sealing +The purpose of the seal is to allow for the log to be migrated to a new log. The seal is a way to +consistently ensure that writes are in total order. The new log gets initialized only after sealing the old log. # Failure Scenarios -wal3 is designed to be resilient to failure. This section details the failure scenarios that wal3 +wal3 is designed to be resilient to failure. This section details the failure scenarios that wal3 might encounter and how to recover from them. The only failure scenarios to consider that are unique to wal3 are a faulty writer and a faulty -garbage collector. No other process writes to object storage, so no other process can be faulty and +garbage collector. No other process writes to object storage, so no other process can be faulty and cause an invalid state for readers; they only impact their own behavior. -Our model is that processes can crash and restart at any time. A crashed process will have no way +Our model is that processes can crash and restart at any time. A crashed process will have no way of recovering anything except what it has previously written to object storage. While bugs will happen, a faulty writer or garbage collector is assumed to not be maliciously, -arbitrarily faulty. We hand-wave this situation to state that these bugs will be detectable by -non-faulty software when they influence the setsum or invariants of the log. And if no invariants +arbitrarily faulty. We hand-wave this situation to state that these bugs will be detectable by +non-faulty software when they influence the setsum or invariants of the log. And if no invariants are violated, is it a bug? ## Faulty Writer -A writer that fails will fail at any step in the process of writing to object storage. The write +A writer that fails will fail at any step in the process of writing to object storage. The write protocol is such that until a manifest is written to refer to the new fragment, the fragment is not -considered durable. In the event a fragment gets "orphaned" because the manifest fails, it will be -rewritten by the next valid writer. This means that a writer can crash at any time and restart, and +considered durable. In the event a fragment gets "orphaned" because the manifest fails, it will be +rewritten by the next valid writer. This means that a writer can crash at any time and restart, and the log will have garbage, but not refer to the garbage. The more malicious faulty writer scenario would be a writer writing manifests that drop fragments or -refer to something that was erroneously garbage collected. This is a very hard problem to solve in -the general case. In the specific case of wal3, we assume that the checksums over the log are +refer to something that was erroneously garbage collected. This is a very hard problem to solve in +the general case. In the specific case of wal3, we assume that the checksums over the log are sufficient to detect most corruption. Writes are always sequenced so that invariants are preserved. ## Faulty Garbage Collector -The garbage collector is a separate process that runs in the background. It is assumed to be move -slowly and carefully. The garbage collector can fail in two ways: +The garbage collector is a separate process that runs in the background. It is assumed to be move +slowly and carefully. The garbage collector can fail in two ways: -- Fail to erase data it should. This is not a problem as it doesn't affect data durability. Such +- Fail to erase data it should. This is not a problem as it doesn't affect data durability. Such bugs will be prioritized, but they are not critical. -- Erase data it shouldn't. This is a fundamental problem to be addressed. +- Erase data it shouldn't. This is a fundamental problem to be addressed. The garbage collector can erase data it shouldn't if it erases data that is still referenced by the manifest that the garbage collector is collecting. Because there's not much to be done except be careful writing this code, the garbage collector is a -three-phase process. The first phase lists all files in object storage that are present under the -log prefix, but that are not present in the compacted manifest. The naive way to do this would be +three-phase process. The first phase lists all files in object storage that are present under the +log prefix, but that are not present in the compacted manifest. The naive way to do this would be to list all files in the manifest in a hash map and then list all files in the log prefix and write -files not in the hash map. We will not be clever about this. We will simply consider every the +files not in the hash map. We will not be clever about this. We will simply consider every the oldest N files (N so that there's not an unbounded number) in the bucket and write them to a file if they are eligible for garbage collection because: @@ -533,7 +532,7 @@ they are eligible for garbage collection because: 2. The file is not referenced transitively by any cursor. A second pass, called a verifier, reads the output of the first pass and complains loudly if sanity -checks don't pass. For example, the verifier checks that the setsums of the new log balance. +checks don't pass. For example, the verifier checks that the setsums of the new log balance. ## Faulty Object Storage @@ -541,50 +540,51 @@ The last consideration for failure is faulty object storage itself. There's not much that can be done here except detection. -wal3 uses a cryptographic hash to verify the integrity of the log. This hash will detect both -missing fragments and corrupted fragments. If the hash fails, the log is corrupted and must be -recovered. This will be a human endeavor. +wal3 uses a cryptographic hash to verify the integrity of the log. This hash will detect both +missing fragments and corrupted fragments. If the hash fails, the log is corrupted and must be +recovered. This will be a human endeavor. ## Dropped Async Tasks -In Rust, web servers and the like will drop tasks associated with dropped file handles. If that -task were one that was driving the log foward, such an abort would cause the log to hang. This is +In Rust, web servers and the like will drop tasks associated with dropped file handles. If that +task were one that was driving the log forward, such an abort would cause the log to hang. This is unacceptable, so every file write that can block other writes if it's cancelled is carefully scheduled on a background, uncancellable task. # Verification -wal3 is built to be empirically verifiable. In this section we walk through the wal3 verification +wal3 is built to be empirically verifiable. In this section we walk through the wal3 verification story and how to verify that a log like wal3 is correct in steady state operation. -The verification story is simple: A log has a cryptographic checksum that can be incrementally +The verification story is simple: A log has a cryptographic checksum that can be incrementally adjusted so that every manifest is checksummed end-to-end with a checksum nearly as strong as sha3. -Each time a new fragment is written to the log, the fragment gets checksummed. This checksum gets -added to the checksum in the manifest. Each time a fragment is garbage collected, the checksum of +Each time a new fragment is written to the log, the fragment gets checksummed. This checksum gets +added to the checksum in the manifest. Each time a fragment is garbage collected, the checksum of the fragment gets removed from the manifest. The checksum itself has the following properties: -- It is cryptographic. While close in properties to sha3, the deviation has not been proven to not + +- It is cryptographic. While close in properties to sha3, the deviation has not been proven to not undermine security. -- It is incremental. Set addition, set subtraction, set union, and set difference are all O(1) +- It is incremental. Set addition, set subtraction, set union, and set difference are all O(1) operations, regardless of the size of the sets of data. -- It is commutative. The order in which fragments are added to the set does not matter. +- It is commutative. The order in which fragments are added to the set does not matter. - [setsum is its own crate](https://crates.io/crates/setsum). -This construction gives a very strong property: In steady state it is easy to detect durability -events due to their most likely cause: New software. By working 100% of the time, the checksum +This construction gives a very strong property: In steady state it is easy to detect durability +events due to their most likely cause: New software. By working 100% of the time, the checksum gives wal3 operators the ability to scrub the entire log and know that if the setsum holds, the data -is as it was written. This gives us the ability to know the integrity of the log holds at all +is as it was written. This gives us the ability to know the integrity of the log holds at all times. This is not the end of the verification story, however, as it only ensures that data at rest is not -subject to a durability event. Data movement is how things become non-durable. To verify that the +subject to a durability event. Data movement is how things become non-durable. To verify that the log is not dropping writes before they make it under the setsum, we need end-to-end verification. -End-to-end verification is simple: Write a message to the log and then read it back. Failure to -read the same message from the log means that something went wrong. Reading the same message twice -means something went wrong, too. In short, anything other than a 1:1 mapping of writes to reads +End-to-end verification is simple: Write a message to the log and then read it back. Failure to +read the same message from the log means that something went wrong. Reading the same message twice +means something went wrong, too. In short, anything other than a 1:1 mapping of writes to reads will indicate a problem. To do this, we will construct an end-to-end, variable throughput test that we can run against wal3 @@ -592,26 +592,27 @@ to ensure that data written is readable exactly as written. # Multiple wal3 Instances -Thus far we've presented wal3 as if it is a singleton. In this section, we look at considerations +Thus far we've presented wal3 as if it is a singleton. In this section, we look at considerations for maintaining a herd of wal3 instances in a single object store bucket. ## Serverless Behavior First off, wal3 is intended to run multiple wal3 instances in parallel and open at the same time. -The over head per wal3 instance is single digit megabytes (manifest and a buffer of writes), meaning -that we can handle hundreds or thousands of concurrent logs per server. We cannot open every log -for every customer on a single machine and have it fit memory. We will have to open and close logs. +The overhead per wal3 instance is single digit megabytes (manifest and a buffer of writes), meaning +that we can handle hundreds or thousands of concurrent logs per server. We cannot open every log +for every customer on a single machine and have it fit memory. We will have to open and close logs. Therefore the following considerations fall out: + - Opening and closing of logs must not be expensive. - Opening and closing of logs must be provably safe. These come from the design of wal3 and are covered above. -There's one additional non-obvious constraint: We could, in theory, write `\forall log \in logs +There's one additional non-obvious constraint: We could, in theory, write `\forall log \in logs query_log_size()` to determine which logs have data, but this will require O(logs) read activity to -object store. This becomes expensive as the number of logs grows, especially if logs are not -written to regularly. To facilitate this, we need a mechanism that scales O(logs written) instead +object store. This becomes expensive as the number of logs grows, especially if logs are not +written to regularly. To facilitate this, we need a mechanism that scales O(logs written) instead of the more general O(logs). Conceptually, we're essentially looking for a way to aggregate the information about which @@ -619,37 +620,37 @@ logs were written when, so that we can compact and garbage collect logs and keep usage for cleaning up proportional to the cost of making the mess. The insight we'll make use of here is, essentially, that the logs written by a single server can be -summarized with a fraction of the resources of the server. For starters, we don't need to write as -much data to say a log has data as we write to that log. If each append to a log is approximately +summarized with a fraction of the resources of the server. For starters, we don't need to write as +much data to say a log has data as we write to that log. If each append to a log is approximately 4 kB+ (a reasonable document size with a vector), we can track the dirty log by name using at most -48 B; an 85x reduction. But it goes further---we only need to persist that 48B record once per +48 B; an 85x reduction. But it goes further---we only need to persist that 48B record once per fragment write, not once per append. -This means that we can track the dirty logs with a single 48B record per fragment. Where to put -that record? We need some way to record them as they happen and then scan/roll-up the records into +This means that we can track the dirty logs with a single 48B record per fragment. Where to put +that record? We need some way to record them as they happen and then scan/roll-up the records into a summary of dirty logs at all times. Viewed another way, we have a stream of events that we need to record approximately in order. -What if we just put it in another log? wal3 is already configured to dynamically batch and write -log data to object storage in an efficient manner. Further, we know a single machine's multiplicity +What if we just put it in another log? wal3 is already configured to dynamically batch and write +log data to object storage in an efficient manner. Further, we know a single machine's multiplicity of logs can be sustained by the throughput of a single log by the math above. The protocol for discovering dirty logs, then, is to write to a "dirty" log and roll-up the dirty -log for compaction. This requires either processing logs in FIFO order out of the dirty log (to -roll up the collections to compact), or somehow compacting the data. The following techniques give +log for compaction. This requires either processing logs in FIFO order out of the dirty log (to +roll up the collections to compact), or somehow compacting the data. The following techniques give sufficient generality to handle every case we need: - Forcibly compact things that are at the head of the log. - Re-write dirty log entries at the end of the log so they can be collected from the beginning. To facilitate this, we will store the reinsertion count and initial insertion time as well as chroma -collection ID when inserting the dirty log entry. This allows us to roll up the dirty log by simply +collection ID when inserting the dirty log entry. This allows us to roll up the dirty log by simply reading the first N records, picking those that are too old, picking those that are too big, and then reinsert any that are not selected by this algorithm. -Thus each wal3 log service will independently manage its own dirty log. This allows us to scale -because each log server will maintain its own independent dirty log. This does raise the +Thus each wal3 log service will independently manage its own dirty log. This allows us to scale +because each log server will maintain its own independent dirty log. This does raise the operational complexity of getting logs to compact. ## Failure @@ -659,7 +660,7 @@ Failure to write the dirty log is not a problem because it will simply fail the ## Scaling Changing the number of logs requires a hashing scheme that maps N compactor nodes onto M log service -nodes. Because the dirty log doesn't drop that a collection is dirty until it advances, it suffices +nodes. Because the dirty log doesn't drop that a collection is dirty until it advances, it suffices to make every compactor pull from every log during times of change. I'd like to make it more efficient than that. diff --git a/rust/wal3/src/lib.rs b/rust/wal3/src/lib.rs index a67e41c17f6..be8fa4a8882 100644 --- a/rust/wal3/src/lib.rs +++ b/rust/wal3/src/lib.rs @@ -54,7 +54,7 @@ pub enum Error { // - The operation does not need to be retried because it is durable, but we need to internally // propagate state to correct for the log contention. // - The operation needs to be retried because there was explicit contention writing the - // fragement. We need to retry, but can return this error to the user. + // fragment. We need to retry, but can return this error to the user. // - The operation is in an ambiguous state and we cannot advise the user either way. Fail the // write and let a higher level protocol handle it. // diff --git a/rust/wal3/src/manifest.rs b/rust/wal3/src/manifest.rs index 4723be30fa5..a4775ad89de 100644 --- a/rust/wal3/src/manifest.rs +++ b/rust/wal3/src/manifest.rs @@ -40,9 +40,9 @@ pub fn unprefixed_snapshot_path(setsum: Setsum) -> String { pub fn snapshot_setsum(path: &str) -> Result { let setsum = path .strip_prefix("snapshot/SNAPSHOT.") - .ok_or_else(|| Error::CorruptManifest(format!("unparseable snapshot path: {}", path,)))?; + .ok_or_else(|| Error::CorruptManifest(format!("unparsable snapshot path: {}", path,)))?; let setsum = Setsum::from_hexdigest(setsum).ok_or_else(|| { - Error::CorruptManifest(format!("unparseable snapshot setsum in {}", path,)) + Error::CorruptManifest(format!("unparsable snapshot setsum in {}", path,)) })?; Ok(setsum) } @@ -921,7 +921,7 @@ impl Manifest { // Sanity check that new manifest contains valid range of logs // From the scrub above we know the manifest is continuous, so we only need to check endpoints if new.oldest_timestamp() > garbage.first_to_keep { - tracing::error!("Manifest after garbage collection does not contain the first log to keep: needs logs since position {:?} to be present, but the smallest log postion available is {:?}", garbage.first_to_keep, new.oldest_timestamp()); + tracing::error!("Manifest after garbage collection does not contain the first log to keep: needs logs since position {:?} to be present, but the smallest log position available is {:?}", garbage.first_to_keep, new.oldest_timestamp()); return Err(Error::CorruptManifest( "Manifest corruption detected after GC: missing first log to keep".to_string(), )); diff --git a/rust/wal3/src/manifest_manager.rs b/rust/wal3/src/manifest_manager.rs index 1ed87c3ef96..e0095c19b04 100644 --- a/rust/wal3/src/manifest_manager.rs +++ b/rust/wal3/src/manifest_manager.rs @@ -100,7 +100,7 @@ impl Staging { } Err(err) => { notifiers.push(notifier); - tracing::error!("could not apply garabage: {err:?}"); + tracing::error!("could not apply garbage: {err:?}"); for notifier in notifiers { let _ = notifier.send(Some(err.clone())); } @@ -156,7 +156,7 @@ impl Staging { return None; } Err(err) => { - tracing::error!("could not apply garabage: {err:?}"); + tracing::error!("could not apply garbage: {err:?}"); let _ = notifier.send(Some(err)); return None; } diff --git a/rust/wal3/src/writer.rs b/rust/wal3/src/writer.rs index 0ac21119dc6..111f00148ed 100644 --- a/rust/wal3/src/writer.rs +++ b/rust/wal3/src/writer.rs @@ -866,7 +866,7 @@ impl OnceLogWriter { } } - /// Perform phase 2 of grabage collection. + /// Perform phase 2 of garbage collection. /// /// Pre-conditions: /// - manifest/MANIFEST exists. diff --git a/rust/wal3/tests/test_k8s_integration_0_properties.rs b/rust/wal3/tests/test_k8s_integration_0_properties.rs index a29ff991a0b..83e88af551e 100644 --- a/rust/wal3/tests/test_k8s_integration_0_properties.rs +++ b/rust/wal3/tests/test_k8s_integration_0_properties.rs @@ -138,7 +138,7 @@ proptest::proptest! { for offset in start.offset()..=limit.offset() { let position = LogPosition::from_offset(offset); eprintln!("position = {position:?}"); - let Some(garbage) = rt.block_on(Garbage::new(&storage, "manifests_gargage", &manifest, &throttle, &cache, position)).unwrap() else { + let Some(garbage) = rt.block_on(Garbage::new(&storage, "manifests_garage", &manifest, &throttle, &cache, position)).unwrap() else { continue; }; eprintln!("garbage = {garbage:#?}"); @@ -205,7 +205,7 @@ proptest::proptest! { for offset in start.offset()..=limit.offset() { let position = LogPosition::from_offset(offset); eprintln!("position = {position:?}"); - let garbage = rt.block_on(Garbage::new(&storage, "manifests_with_snapshots_gargage", &manifest, &throttle, &cache, position)).unwrap(); + let garbage = rt.block_on(Garbage::new(&storage, "manifests_with_snapshots_garage", &manifest, &throttle, &cache, position)).unwrap(); let Some(garbage) = garbage else { continue; }; diff --git a/rust/worker/src/config.rs b/rust/worker/src/config.rs index 43b3f12a91e..4b531655b5f 100644 --- a/rust/worker/src/config.rs +++ b/rust/worker/src/config.rs @@ -14,7 +14,7 @@ const DEFAULT_CONFIG_PATH: &str = "./chroma_config.yaml"; /// The RootConfig for all chroma services this is a YAML file that /// is shared between all services, and secondarily, fields can be /// populated from environment variables. The environment variables -/// are prefixed with CHROMA_ and are uppercase. Values in the envionment +/// are prefixed with CHROMA_ and are uppercase. Values in the environment /// variables take precedence over values in the YAML file. /// By default, it is read from the current working directory, /// with the filename chroma_config.yaml. @@ -41,7 +41,7 @@ impl RootConfig { /// # Notes /// The default location is the current working directory, with the filename chroma_config.yaml. /// The environment variables are prefixed with CHROMA_ and are uppercase. - /// Values in the envionment variables take precedence over values in the YAML file. + /// Values in the environment variables take precedence over values in the YAML file. pub fn load() -> Self { Self::load_from_path(DEFAULT_CONFIG_PATH) } @@ -60,7 +60,7 @@ impl RootConfig { /// - If the environment variables contain invalid values. /// # Notes /// The environment variables are prefixed with CHROMA_ and are uppercase. - /// Values in the envionment variables take precedence over values in the YAML file. + /// Values in the environment variables take precedence over values in the YAML file. // NOTE: Copied to ../load/src/config.rs. pub fn load_from_path(path: &str) -> Self { // Unfortunately, figment doesn't support environment variables with underscores. So we have to map and replace them. @@ -104,7 +104,7 @@ impl Default for RootConfig { /// - my_ip: The IP address of the worker service. Used for memberlist assignment. Must be provided. /// - assignment_policy: The assignment policy to use. Must be provided. /// # Notes -/// In order to set the enviroment variables, you must prefix them with CHROMA_WORKER__. +/// In order to set the environment variables, you must prefix them with CHROMA_WORKER__. /// For example, to set my_ip, you would set CHROMA_WORKER__MY_IP. /// Each submodule that needs to be configured from the config object should implement the Configurable trait and /// have its own field in this struct for its Config struct. @@ -197,7 +197,7 @@ impl QueryServiceConfig { /// - my_ip: The IP address of the worker service. Used for memberlist assignment. Must be provided. /// - assignment_policy: The assignment policy to use. Must be provided. /// # Notes -/// In order to set the enviroment variables, you must prefix them with CHROMA_COMPACTOR__. +/// In order to set the environment variables, you must prefix them with CHROMA_COMPACTOR__. /// For example, to set my_ip, you would set CHROMA_COMPACTOR__MY_IP. /// Each submodule that needs to be configured from the config object should implement the Configurable trait and /// have its own field in this struct for its Config struct. diff --git a/rust/worker/src/execution/operators/count_records.rs b/rust/worker/src/execution/operators/count_records.rs index 87165ac62ef..7915af9ed8e 100644 --- a/rust/worker/src/execution/operators/count_records.rs +++ b/rust/worker/src/execution/operators/count_records.rs @@ -82,7 +82,7 @@ impl Operator for CountRecordsOperator { match *e { RecordSegmentReaderCreationError::UninitializedSegment => { tracing::info!("[CountQueryOrchestrator] Record segment is uninitialized; using {} records from log", input.log_records.len()); - // This means there no compaction has occured. + // This means there no compaction has occurred. // So we can just traverse the log records // and count the number of records. let mut seen_id_set = HashSet::new(); diff --git a/rust/worker/src/execution/operators/filter.rs b/rust/worker/src/execution/operators/filter.rs index 131cf3e9bd9..86516fbe02e 100644 --- a/rust/worker/src/execution/operators/filter.rs +++ b/rust/worker/src/execution/operators/filter.rs @@ -86,7 +86,7 @@ impl ChromaError for FilterError { } } -/// This sturct provides an abstraction over the materialized logs that is similar to the metadata segment +/// This struct provides an abstraction over the materialized logs that is similar to the metadata segment pub(crate) struct MetadataLogReader<'me> { // This maps metadata keys to `BTreeMap`s, which further map values to offset ids // This mimics the layout in the metadata segment @@ -568,13 +568,13 @@ impl Operator for Filter { let log_metadata_provider = MetadataProvider::Log(&metadata_log_reader); - let metadata_segement_reader = Box::pin(MetadataSegmentReader::from_segment( + let metadata_segment_reader = Box::pin(MetadataSegmentReader::from_segment( &input.metadata_segment, &input.blockfile_provider, )) .await?; let compact_metadata_provider = - MetadataProvider::CompactData(&metadata_segement_reader, &record_segment_reader); + MetadataProvider::CompactData(&metadata_segment_reader, &record_segment_reader); // Get offset ids corresponding to user ids let (user_allowed_log_offset_ids, user_allowed_compact_offset_ids) = @@ -1482,14 +1482,14 @@ mod tests { .unwrap(); let log_metadata_provider = MetadataProvider::Log(&metadata_log_reader); - let metadata_segement_reader = Box::pin(MetadataSegmentReader::from_segment( + let metadata_segment_reader = Box::pin(MetadataSegmentReader::from_segment( &filter_input.metadata_segment, &filter_input.blockfile_provider, )) .await .unwrap(); let compact_metadata_provider = - MetadataProvider::CompactData(&metadata_segement_reader, &record_segment_reader); + MetadataProvider::CompactData(&metadata_segment_reader, &record_segment_reader); let match_all = r".*"; assert_eq!( diff --git a/rust/worker/src/execution/operators/partition_log.rs b/rust/worker/src/execution/operators/partition_log.rs index 1a098a08795..118d5a27cc6 100644 --- a/rust/worker/src/execution/operators/partition_log.rs +++ b/rust/worker/src/execution/operators/partition_log.rs @@ -27,7 +27,7 @@ impl PartitionInput { /// # Parameters /// * `records` - The records to partition. /// * `max_partition_size` - The maximum size of a partition. Since we are trying to - /// partition the records by id, which can casue the partition size to be larger than this + /// partition the records by id, which can cause the partition size to be larger than this /// value. pub fn new(records: Chunk, max_partition_size: usize) -> Self { PartitionInput { @@ -73,7 +73,7 @@ impl PartitionOperator { map.entry(key).or_insert_with(Vec::new).push(index); } let mut result = Vec::new(); - // Create a new DataChunk for each parition of records with partition_size without + // Create a new DataChunk for each partition of records with partition_size without // data copying. let mut current_batch_size = 0; let mut new_partition = true; diff --git a/rust/worker/src/execution/operators/projection.rs b/rust/worker/src/execution/operators/projection.rs index d96688fbc8a..dd232fe64d3 100644 --- a/rust/worker/src/execution/operators/projection.rs +++ b/rust/worker/src/execution/operators/projection.rs @@ -46,7 +46,7 @@ pub enum ProjectionError { RecordReader(#[from] RecordSegmentReaderCreationError), #[error("Error reading record segment: {0}")] RecordSegment(#[from] Box), - #[error("Error reading unitialized record segment")] + #[error("Error reading uninitialized record segment")] RecordSegmentUninitialized, #[error("Error reading phantom record: {0}")] RecordSegmentPhantomRecord(u32), diff --git a/rust/worker/src/execution/operators/register.rs b/rust/worker/src/execution/operators/register.rs index 90f936df5bb..0023f69f8ca 100644 --- a/rust/worker/src/execution/operators/register.rs +++ b/rust/worker/src/execution/operators/register.rs @@ -131,7 +131,7 @@ impl Operator for RegisterOperator { ) .await; - // We must make sure that the log postion in sysdb is always greater than or equal to the log position + // We must make sure that the log position in sysdb is always greater than or equal to the log position // in the log service. If the log position in sysdb is less than the log position in the log service, // the we may lose data in compaction. let sysdb_registration_result = match result { diff --git a/rust/worker/src/execution/operators/sparse_index_knn.rs b/rust/worker/src/execution/operators/sparse_index_knn.rs index 2ddc5de2664..246279a407b 100644 --- a/rust/worker/src/execution/operators/sparse_index_knn.rs +++ b/rust/worker/src/execution/operators/sparse_index_knn.rs @@ -51,13 +51,13 @@ impl Operator for SparseIndexKnn { &self, input: &SparseIndexKnnInput, ) -> Result { - let metadata_segement_reader = Box::pin(MetadataSegmentReader::from_segment( + let metadata_segment_reader = Box::pin(MetadataSegmentReader::from_segment( &input.metadata_segment, &input.blockfile_provider, )) .await?; - let Some(sparse_reader) = metadata_segement_reader.sparse_index_reader else { + let Some(sparse_reader) = metadata_segment_reader.sparse_index_reader else { return Ok(SparseIndexKnnOutput { records: Vec::new(), }); diff --git a/rust/worker/src/execution/orchestration/compact.rs b/rust/worker/src/execution/orchestration/compact.rs index bf6f78d19ed..b9cce84ea1f 100644 --- a/rust/worker/src/execution/orchestration/compact.rs +++ b/rust/worker/src/execution/orchestration/compact.rs @@ -172,7 +172,7 @@ pub enum CompactionError { ApplyLog(#[from] ApplyLogToSegmentWriterOperatorError), #[error("Error sending message through channel: {0}")] Channel(#[from] ChannelError), - #[error("Error commiting segment writers: {0}")] + #[error("Error committing segment writers: {0}")] Commit(#[from] CommitSegmentWriterOperatorError), #[error("Error fetching logs: {0}")] FetchLog(#[from] FetchLogError), @@ -952,7 +952,7 @@ impl Handler> for CompactOrchestrator tracing::info!("Pulled Logs Up To Offset: {:?}", self.pulled_log_offset); } None => { - tracing::warn!("No logs were pulled from the log service, this can happen when the log compaction offset is behing the sysdb."); + tracing::warn!("No logs were pulled from the log service, this can happen when the log compaction offset is behind the sysdb."); if let Some(collection) = self.collection.get() { self.terminate_with_result( Ok(CompactionResponse::RequireCompactionOffsetRepair { @@ -994,7 +994,7 @@ impl Handler> None => return, }; tracing::info!("Sourced Records: {}", output.len()); - // Each record should corresond to a log + // Each record should correspond to a log self.total_records_post_compaction = output.len() as u64; if output.is_empty() { let writers = match self.ok_or_terminate(self.get_segment_writers(), ctx).await { @@ -1132,7 +1132,7 @@ impl Handler return, }; - // If the flusher recieved is a record segment flusher, get the number of keys for the blockfile and set it on the orchestrator + // If the flusher received is a record segment flusher, get the number of keys for the blockfile and set it on the orchestrator if let ChromaSegmentFlusher::RecordSegment(record_segment_flusher) = &message.flusher { self.total_records_post_compaction = record_segment_flusher.count(); } @@ -1246,7 +1246,7 @@ mod tests { false, ) .await - .expect("Colleciton create should be successful"); + .expect("Collection create should be successful"); let mut in_memory_log = InMemoryLog::new(); add_delete_generator .generate_vec(1..=120) diff --git a/sample_apps/generative_benchmarking/data/chroma_docs.json b/sample_apps/generative_benchmarking/data/chroma_docs.json index 7a0dde70005..b55c5948c04 100644 --- a/sample_apps/generative_benchmarking/data/chroma_docs.json +++ b/sample_apps/generative_benchmarking/data/chroma_docs.json @@ -6,10 +6,10 @@ "3f4cbbd5-71ca-403d-a56c-5e5550686b4a": " are excluded by default for performance and the `ids` are always returned. You can specify which of these you want returned by passing an array of included field names to the includes parameter of the query or get method. Note that embeddings will be returned as a 2-d numpy array in `.get` and a python list of 2-d numpy arrays in `.query`.\n\n{% TabbedCodeBlock %}\n\n{% Tab label=\"python\" %}\n```python\n# Only get documents and ids\ncollection.get(\n include=[\"documents\"]\n)\n\ncollection.query(\n query_embeddings=[[11.1, 12.1, 13.1],[1.1, 2.3, 3.2], ...],\n include=[\"documents\"]\n)\n```\n{% /Tab %}\n\n{% Tab label=\"typescript\" %}\n```typescript\n// Only get documents and ids\nawait collection.get({\n include: [\"documents\"]\n})\n\nawait collection.query({\n query_embeddings: [[11.1, 12.1, 13.1], [1.1, 2.3, 3.2], ...],\n include: [\"documents\"]\n})\n```\n", "0ceea0de-622a-4131-8ea9-06b8f0862ca8": "# About\n\nWe are hiring software engineers and applied research scientists.\n\n## Who we are\n\nChroma as a project is coordinated by a small team of full-time employees who work at a company also called Chroma.\n\nWe work in the sunny Mission District in San Francisco.\n\nChroma was co-founded by [Jeff Huber](https://twitter.com/jeffreyhuber) (left, CEO) and [Anton Troynikov](https://twitter.com/atroyn) (right, now Advisor).\n\n\n## Our commitment to open source\n\nChroma is a company that builds the open-source project also called Chroma.\n\nWe are committed to building open source software because we believe in the flourishing of humanity that will be unlocked through the democratization of robust, safe, and aligned AI systems. These tools need to be available to a new developer just starting in ML as well as the organizations that scale ML to millions (and billions) of users. Open source is about expanding the horizon of what\u2019s possible.\n\nChroma is a _commercial_ open source company. What does that mean? We believe that organizing financially sustainable teams of people to work to manage, push and integrate the project enriches the health of the project and the community.\n\n", "cdaf0d8b-60d4-4d4d-8938-7e252609f2f0": "It is important that our values around this are very clear!\n\n- We are committed to building Chroma as a ubiquitous open source standard\n- A successful Chroma-based commercial product is essential for the success of the technology, and is a win-win for everyone. Simply put, many organizations will not adopt Chroma without the option of a commercially hosted solution; and the project must be backed by a company with a viable business model. We want to build an awesome project and an awesome business.\n- We will decide what we provide exclusively in the commercial product based on clear, consistent criteria.\n\nWhat code will be open source? As a general rule, any feature which an individual developer would find useful will be 100% open source forever. This approach, popularized by Gitlab, is called [buyer-based open source](https://about.gitlab.com/company/stewardship/). We believe that this is essential to accomplishing our mission.\n\nCurrently we don\u2019t have any specific plans to monetize Chroma, we are working on a hosted service that will be launched as a free technical preview to make it easier for developers to get going. We are 100% focused on building valuable open source software with the community and for the community.\n\n\n## Our", - "71152c82-ebab-4f09-93b9-e9933faaadf2": " investors\n\nChroma raised an $18M seed round led by Astasia Myers from Quiet Capital. Joining the round are angels including Naval Ravikant, Max and Jack Altman, Jordan Tigani (Motherduck), Guillermo Rauch (Vercel), Akshay Kothari (Notion), Amjad Masad (Replit), Spencer Kimball (CockroachDB), and other founders and leaders from ScienceIO, Gumroad, MongoDB, Scale, Hugging Face, Jasper and more.\n\nChroma raised a pre-seed in May 2022, led by Anthony Goldbloom (Kaggle) from AIX Ventures, James Cham from Bloomberg Beta, and Nat Friedman and Daniel Gross (AI Grant).\n\nWe're excited to work with a deep set of investors and enterpreneurs who have invested in and built some of the most successful open-source projects in the world.\n\n# Contributing\n\nWe welcome all contributions, bug reports, bug fixes, documentation improvements, enhancements, and ideas.\n\n## Getting Started\nHere are some helpful links to get you started with contributing to Chroma\n\n- The Chroma codebase is hosted on [Github](https://github.com/chroma-core/chroma)\n- Issues are", + "71152c82-ebab-4f09-93b9-e9933faaadf2": " investors\n\nChroma raised an $18M seed round led by Astasia Myers from Quiet Capital. Joining the round are angels including Naval Ravikant, Max and Jack Altman, Jordan Tigani (Motherduck), Guillermo Rauch (Vercel), Akshay Kothari (Notion), Amjad Masad (Replit), Spencer Kimball (CockroachDB), and other founders and leaders from ScienceIO, Gumroad, MongoDB, Scale, Hugging Face, Jasper and more.\n\nChroma raised a pre-seed in May 2022, led by Anthony Goldbloom (Kaggle) from AIX Ventures, James Cham from Bloomberg Beta, and Nat Friedman and Daniel Gross (AI Grant).\n\nWe're excited to work with a deep set of investors and entrepreneurs who have invested in and built some of the most successful open-source projects in the world.\n\n# Contributing\n\nWe welcome all contributions, bug reports, bug fixes, documentation improvements, enhancements, and ideas.\n\n## Getting Started\nHere are some helpful links to get you started with contributing to Chroma\n\n- The Chroma codebase is hosted on [Github](https://github.com/chroma-core/chroma)\n- Issues are", "47aea36d-4fbe-40ea-a0fb-5b02290eb5b7": " tracked on [Github Issues](https://github.com/chroma-core/chroma/issues). Please report any issues you find there making sure to fill out the correct [form for the type of issue you are reporting](https://github.com/chroma-core/chroma/issues/new/choose).\n- In order to run Chroma locally you can follow the [Development Instructions](https://github.com/chroma-core/chroma/blob/main/DEVELOP.md).\n- If you want to contribute and aren't sure where to get started you can search for issues with the [Good first issue](https://github.com/chroma-core/chroma/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22) tag or take a look at our [Roadmap](https://docs.trychroma.com/roadmap).\n- The Chroma documentation (including this page!) is hosted on [Github](https://github.com/chroma-core/docs) as well. If you find any issues with the documentation please report them on the Github Issues page for the documentation [here](https://github.com/chroma-core/docs/issues).\n\n\n## Contributing Code and Ideas\n\n### Pull Requests\nIn order to submit a", "9aaaed58-cf0f-4623-b6b6-4718a6190710": " change to Chroma please submit a [Pull Request](https://github.com/chroma-core/chroma/compare) against Chroma or the documentation. The pull request will be reviewed by the Chroma team and if approved, will be merged into the repository. We will do our best to review pull requests in a timely manner but please be patient as we are a small team. We will work to integrate your proposed changes as quickly as possible if they align with the goals of the project. We ask that you label your pull request with a title prefix that indicates the type of change you are proposing. The following prefixes are used:\n\n```\nENH: Enhancement, new functionality\nBUG: Bug fix\nDOC: Additions/updates to documentation\nTST: Additions/updates to tests\nBLD: Updates to the build process/scripts\nPERF: Performance improvement\nTYP: Type annotations\nCLN: Code cleanup\nCHORE: Maintenance and other tasks that do not modify source or test files\n```\n\n\n### CIPs\nChroma Improvement Proposals or CIPs (pronounced \"Chips\") are the way to propose new features or large changes to Chroma. If you plan to make a large change to", - "8e14f0d2-fe83-46f3-a456-044a0b9e4949": " Chroma please submit a CIP first so that the core Chroma team as well as the community can discuss the proposed change and provide feedback. A CIP should provide a concise technical specification of the feature and a rationale for why it is needed. The CIP should be submitted as a pull request to the [CIPs folder](https://github.com/chroma-core/chroma/tree/main/docs). The CIP will be reviewed by the Chroma team and if approved will be merged into the repository. To learn more about writing a CIP you can read the [guide](https://github.com/chroma-core/chroma/blob/main/docs/CIP_Chroma_Improvment_Proposals.md). CIPs are not required for small changes such as bug fixes or documentation updates.\n\nA CIP starts in the \"Proposed\" state, then moves to \"Under Review\" once the Chroma team has reviewed it and is considering it for implementation. Once the CIP is approved it will move to the \"Accepted\" state and the implementation can begin. Once the implementation is complete the CIP will move to the \"Implemented\" state. If the CIP is not approved it will move to the \"Rejected\" state. If the", + "8e14f0d2-fe83-46f3-a456-044a0b9e4949": " Chroma please submit a CIP first so that the core Chroma team as well as the community can discuss the proposed change and provide feedback. A CIP should provide a concise technical specification of the feature and a rationale for why it is needed. The CIP should be submitted as a pull request to the [CIPs folder](https://github.com/chroma-core/chroma/tree/main/docs). The CIP will be reviewed by the Chroma team and if approved will be merged into the repository. To learn more about writing a CIP you can read the [guide](https://github.com/chroma-core/chroma/blob/main/docs/CIP_Chroma_Improvement_Proposals.md). CIPs are not required for small changes such as bug fixes or documentation updates.\n\nA CIP starts in the \"Proposed\" state, then moves to \"Under Review\" once the Chroma team has reviewed it and is considering it for implementation. Once the CIP is approved it will move to the \"Accepted\" state and the implementation can begin. Once the implementation is complete the CIP will move to the \"Implemented\" state. If the CIP is not approved it will move to the \"Rejected\" state. If the", "9a0748a6-859e-4210-95a4-684775989f7b": " CIP is withdrawn by the author it will move to the \"Withdrawn\" state.\n\n\n### Discord\nFor less fleshed out ideas you want to discuss with the community, you can join our [Discord](https://discord.gg/Fk2pH7k6) and chat with us in the #feature-ideas channel. We are always happy to discuss new ideas and features with the community.\n\n\n# Getting Started\n\nChroma is an AI-native open-source vector database. It comes with everything you need to get started built in, and runs on your machine. A [hosted version](https://trychroma.com/signup) is now available for early access!\n\n### 1. Install\n\n{% Tabs %}\n\n{% Tab label=\"python\" %}\n\n```terminal\npip install chromadb\n```\n\n{% /Tab %}\n\n{% Tab label=\"typescript\" %}\n\n{% TabbedUseCaseCodeBlock language=\"Terminal\" %}\n\n{% Tab label=\"yarn\" %}\n```terminal\nyarn add chromadb chromadb-default-embed \n```\n{% /Tab %}\n\n{% Tab label=\"npm\" %}\n```terminal\nnpm install --save chromadb chromadb-default-embed\n```\n{% /Tab %}\n\n{% Tab", "e00d6a02-5557-44f0-b349-dc2a646f71cc": " label=\"pnpm\" %}\n```terminal\npnpm add chromadb chromadb-default-embed \n```\n{% /Tab %}\n\n{% /TabbedUseCaseCodeBlock %}\n\nInstall chroma via `pip` to easily run the backend server. Here are [instructions](https://pip.pypa.io/en/stable/installation/) for installing and running `pip`. Alternatively, you can also run Chroma in a [Docker](../../production/containers/docker) container.\n\n```terminal\npip install chromadb\n```\n\n{% /Tab %}\n\n{% /Tabs %}\n\n### 2. Create a Chroma Client\n\n{% Tabs %}\n\n{% Tab label=\"python\" %}\n```python\nimport chromadb\nchroma_client = chromadb.Client()\n```\n{% /Tab %}\n{% Tab label=\"typescript\" %}\n\nRun the Chroma backend:\n\n{% TabbedUseCaseCodeBlock language=\"Terminal\" %}\n\n{% Tab label=\"CLI\" %}\n```terminal\nchroma run --path ./getting-started \n```\n{% /Tab %}\n\n{% Tab label=\"Docker\" %}\n```terminal\ndocker pull chromadb/chroma\ndocker run -p 8000:8000 chromadb/chroma---\n\n\n# Chrom", "60d8e1e8-6f20-48fc-9ad0-290dca7c8980": "a\n\n**Chroma is the open-source AI application database**. Chroma makes it easy to build LLM apps by making knowledge, facts, and skills pluggable for LLMs.\n\n{% Banner type=\"tip\" %}\nNew to Chroma? Check out the [getting started guide](./getting-started)\n{% /Banner %}\n\n![Chroma Computer](/computer.svg)\n\nChroma gives you everything you need for retrieval:\n\n- Store embeddings and their metadata\n- Vector search\n- Full-text search\n- Document storage\n- Metadata filtering\n- Multi-modal retrieval\n\nChroma runs as a server and provides `Python` and `JavaScript/TypeScript` client SDKs. Check out the [Colab demo](https://colab.research.google.com/drive/1QEzFyqnoFxq7LUGyP1vzR4iLt9PpCDXv?usp=sharing) (yes, it can run in a Jupyter notebook).\n\nChroma is licensed under [Apache 2.0](https://github.com/chroma-core/chroma/blob/main/LICENSE)\n\n### Python\nIn Python, Chroma can run in a python script or as a server. Install Chroma", @@ -52,7 +52,7 @@ "4d586c67-5473-4d1d-9204-17ac4c9fe6f8": "` - If the collection does not exist.\n\n\n**Examples**:\n\n ```python\n client.delete_collection(\"my_collection\")\n ```\n\n## reset\n\n```python\ndef reset() -> bool\n```\n\nResets the database. This will delete all collections and entries.\n\n**Returns**:\n\n- `bool` - True if the database was reset successfully.\n\n## get\\_version\n\n```python\ndef get_version() -> str\n```\n\nGet the version of Chroma.\n\n**Returns**:\n\n- `str` - The version of Chroma\n\n## get\\_settings\n\n```python\ndef get_settings() -> Settings\n```\n\nGet the settings used to initialize.\n\n**Returns**:\n\n- `Settings` - The settings used to initialize.\n\n## get\\_max\\_batch\\_size\n\n```python\ndef get_max_batch_size() -> int\n```\n\nReturn the maximum number of records that can be created or mutated in a single call.\n\n***\n\n# ClientClient Methods\n\n```python\nclass ClientAPI(BaseAPI, ABC)\n```\n\n## list\\_collections\n\n```python\ndef list_collections(limit: Optional[int] = None,\n offset: Optional[int] = None) -> Sequence[CollectionName]\n```\n\nList all collections names.\n\n", "8dd1648f-92f8-4af9-b324-0cba868ecd9d": "**Arguments**:\n\n- `limit` - The maximum number of entries to return. Defaults to None.\n- `offset` - The number of entries to skip before returning. Defaults to None.\n\n\n**Returns**:\n\n- `Sequence[CollectionName]` - A list of collection names. `CollectionName` is a string.\n\n\n**Examples**:\n\n```python\nclient.list_collections()\n# ['my_collection']\n```\n\n## create_collection\n\n```python\ndef create_collection(name: str,\n configuration: Optional[CollectionConfiguration] = None,\n metadata: Optional[CollectionMetadata] = None,\n embedding_function: Optional[EmbeddingFunction[\n Embeddable]] = ef.DefaultEmbeddingFunction(),\n data_loader: Optional[DataLoader[Loadable]] = None,\n get_or_create: bool = False) -> Collection\n```\n\nCreate a new collection with the given name and metadata.\n\n**Arguments**:\n\n- `name` - The name of the collection to create.\n- `metadata` - Optional metadata to associate with the collection.\n- `embedding_function` - Optional function to use to embed documents.\n Uses the default embedding function if not provided.\n- `get_or_create` - If True, return the existing collection", "e50c7c13-3d39-4595-964a-544b1c3a71d5": " if it exists.\n- `data_loader` - Optional function to use to load records (documents, images, etc.)\n\n\n**Returns**:\n\n- `Collection` - The newly created collection.\n\n\n**Raises**:\n\n- `ValueError` - If the collection already exists and get_or_create is False.\n- `ValueError` - If the collection name is invalid.\n\n\n**Examples**:\n\n```python\nclient.create_collection(\"my_collection\")\n# collection(name=\"my_collection\", metadata={})\n\nclient.create_collection(\"my_collection\", metadata={\"foo\": \"bar\"})\n# collection(name=\"my_collection\", metadata={\"foo\": \"bar\"})\n```\n\n## get_collection\n\n```python\ndef get_collection(\n name: str,\n id: Optional[UUID] = None,\n embedding_function: Optional[\n EmbeddingFunction[Embeddable]] = ef.DefaultEmbeddingFunction(),\n data_loader: Optional[DataLoader[Loadable]] = None) -> Collection\n```\n\nGet a collection with the given name.\n\n**Arguments**:\n\n- `id` - The UUID of the collection to get. Id and Name are simultaneously used for lookup if provided.\n- `name` - The name of the collection to get\n- `embedding_function`", - "65c10865-cb97-454f-b8f0-e4093fc97fed": " - Optional function to use to embed documents.\n Uses the default embedding function if not provided.\n- `data_loader` - Optional function to use to load records (documents, images, etc.)\n\n\n**Returns**:\n\n- `Collection` - The collection\n\n\n**Raises**:\n\n- `ValueError` - If the collection does not exist\n\n\n**Examples**:\n\n ```python\n client.get_collection(\"my_collection\")\n # collection(name=\"my_collection\", metadata={})\n ```\n\n## get\\_or\\_create\\_collection\n\n```python\ndef get_or_create_collection(\n name: str,\n configuration: Optional[CollectionConfiguration] = None,\n metadata: Optional[CollectionMetadata] = None,\n embedding_function: Optional[\n EmbeddingFunction[Embeddable]] = ef.DefaultEmbeddingFunction(),\n data_loader: Optional[DataLoader[Loadable]] = None) -> Collection\n```\n\nGet or create a collection with the given name and metadata.\n\n**Arguments**:\n\n- `name` - The name of the collection to get or create\n- `metadata` - Optional metadata to associate with the collection. If\n the collection alredy exists, the metadata will be ignored. If the collection does", + "65c10865-cb97-454f-b8f0-e4093fc97fed": " - Optional function to use to embed documents.\n Uses the default embedding function if not provided.\n- `data_loader` - Optional function to use to load records (documents, images, etc.)\n\n\n**Returns**:\n\n- `Collection` - The collection\n\n\n**Raises**:\n\n- `ValueError` - If the collection does not exist\n\n\n**Examples**:\n\n ```python\n client.get_collection(\"my_collection\")\n # collection(name=\"my_collection\", metadata={})\n ```\n\n## get\\_or\\_create\\_collection\n\n```python\ndef get_or_create_collection(\n name: str,\n configuration: Optional[CollectionConfiguration] = None,\n metadata: Optional[CollectionMetadata] = None,\n embedding_function: Optional[\n EmbeddingFunction[Embeddable]] = ef.DefaultEmbeddingFunction(),\n data_loader: Optional[DataLoader[Loadable]] = None) -> Collection\n```\n\nGet or create a collection with the given name and metadata.\n\n**Arguments**:\n\n- `name` - The name of the collection to get or create\n- `metadata` - Optional metadata to associate with the collection. If\n the collection already exists, the metadata will be ignored. If the collection does", "69e0f556-2a2a-4488-8d19-f7aa16c156b2": " not exist, the\n new collection will be created with the provided metadata.\n- `embedding_function` - Optional function to use to embed documents\n- `data_loader` - Optional function to use to load records (documents, images, etc.)\n\n\n**Returns**:\n\n The collection\n\n\n**Examples**:\n\n ```python\n client.get_or_create_collection(\"my_collection\")\n # collection(name=\"my_collection\", metadata={})\n ```\n\n## set_tenant\n\n```python\ndef set_tenant(tenant: str, database: str = DEFAULT_DATABASE) -> None\n```\n\nSet the tenant and database for the client. Raises an error if the tenant or\ndatabase does not exist.\n\n**Arguments**:\n\n- `tenant` - The tenant to set.\n- `database` - The database to set.\n\n## set_database\n\n```python\ndef set_database(database: str) -> None\n```\n\nSet the database for the client. Raises an error if the database does not exist.\n\n**Arguments**:\n\n- `database` - The database to set.\n\n## clear_system_cache\n\n```python\n@staticmethod\ndef clear_system_cache() -> None\n```\n\nClear the system cache so that new systems can be created for an", "8fa305d2-fca2-4fde-b144-289a03ebed00": " existing path.\nThis should only be used for testing purposes.\n\n***\n\n# AdminClient Methods\n\n```python\nclass AdminAPI(ABC)\n```\n\n## create_database\n\n```python\ndef create_database(name: str, tenant: str = DEFAULT_TENANT) -> None\n```\n\nCreate a new database. Raises an error if the database already exists.\n\n**Arguments**:\n\n- `database` - The name of the database to create.\n\n## get_database\n\n```python\ndef get_database(name: str, tenant: str = DEFAULT_TENANT) -> Database\n```\n\nGet a database. Raises an error if the database does not exist.\n\n**Arguments**:\n\n- `database` - The name of the database to get.\n- `tenant` - The tenant of the database to get.\n\n## delete_database\n\n```python\ndef delete_database(name: str, tenant: str = DEFAULT_TENANT) -> None\n```\n\nDelete a database and all associated collections. Raises an error if the database does not exist.\n\n**Arguments**:\n\n- `database` - The name of the database to delete.\n- `tenant` - The tenant of the database to delete.\n\n## list_databases\n\n```python\ndef list_databases(limit:", "6f623338-7220-4823-be53-b07cabde1e69": " Optional[int] = None, offset: Optional[int] = None, tenant: str = DEFAULT_TENANT) -> Sequence[Database]\n```\n\nList databases for a tenant.\n\n**Arguments**:\n\n- `limit` - The maximum number of entries to return. Defaults to None.\n- `offset` - The number of entries to skip before returning. Defaults to None.\n- `tenant` - The tenant to list databases for.\n\n## create_tenant\n\n```python\ndef create_tenant(name: str) -> None\n```\n\nCreate a new tenant. Raises an error if the tenant already exists.\n\n**Arguments**:\n\n- `tenant` - The name of the tenant to create.\n\n## get_tenant\n\n```python\ndef get_tenant(name: str) -> Tenant\n```\n\nGet a tenant. Raises an error if the tenant does not exist.\n\n**Arguments**:\n\n- `tenant` - The name of the tenant to get.\n\n***\n\n# ServerClient Methods\n\n```python\nclass ServerAPI(BaseAPI, AdminAPI, Component)\n```\n\nAn API instance that extends the relevant Base API methods by passing\nin a tenant and database. This is the root component of the Chroma System\n\n---\ntitle: Collection\n---\n\n#", @@ -62,7 +62,7 @@ "10407513-0352-48d5-a962-1f380d6ffec5": " None,\n include: Include = [\"metadatas\", \"documents\",\n \"distances\"]) -> QueryResult\n```\n\nGet the n_results nearest neighbor embeddings for provided query_embeddings or query_texts.\n\n**Arguments**:\n\n- `query_embeddings` - The embeddings to get the closest neighbors of. Optional.\n- `query_texts` - The document texts to get the closest neighbors of. Optional.\n- `n_results` - The number of neighbors to return for each query_embedding or query_texts. Optional.\n- `where` - A Where type dict used to filter results by. E.g. `{\"color\" : \"red\", \"price\": 4.20}`. Optional.\n- `where_document` - A WhereDocument type dict used to filter by the documents. E.g. `{$contains: {\"text\": \"hello\"}}`. Optional.\n- `include` - A list of what to include in the results. Can contain `\"embeddings\"`, `\"metadatas\"`, `\"documents\"`, `\"distances\"`. Ids are always included. Defaults to `[\"metadatas\", \"documents\", \"distances\"]`. Optional.\n\n\n**Returns**:\n\n- `QueryResult` - A QueryResult object containing the", "ad8892c2-cf94-465d-ab03-79638af8c609": " results.\n\n\n**Raises**:\n\n- `ValueError` - If you don't provide either query_embeddings or query_texts\n- `ValueError` - If you provide both query_embeddings and query_texts\n\n## modify\n\n```python\ndef modify(name: Optional[str] = None,\n metadata: Optional[CollectionMetadata] = None) -> None\n```\n\nModify the collection name or metadata\n\n**Arguments**:\n\n- `name` - The updated name for the collection. Optional.\n- `metadata` - The updated metadata for the collection. Optional.\n\n\n**Returns**:\n\n None\n\n## update\n\n```python\ndef update(ids: OneOrMany[ID],\n embeddings: Optional[OneOrMany[Embedding]] = None,\n metadatas: Optional[OneOrMany[Metadata]] = None,\n documents: Optional[OneOrMany[Document]] = None) -> None\n```\n\nUpdate the embeddings, metadatas or documents for provided ids.\n\n**Arguments**:\n\n- `ids` - The ids of the embeddings to update\n- `embeddings` - The embeddings to add. If None, embeddings will be computed based on the documents using the embedding_function set for the Collection. Optional.\n- `metad", "7ca0bc18-158f-477c-84c8-e47088a9253d": "atas` - The metadata to associate with the embeddings. When querying, you can filter on this metadata. Optional.\n- `documents` - The documents to associate with the embeddings. Optional.\n\n\n**Returns**:\n\n None\n\n## upsert\n\n```python\ndef upsert(ids: OneOrMany[ID],\n embeddings: Optional[OneOrMany[Embedding]] = None,\n metadatas: Optional[OneOrMany[Metadata]] = None,\n documents: Optional[OneOrMany[Document]] = None) -> None\n```\n\nUpdate the embeddings, metadatas or documents for provided ids, or create them if they don't exist.\n\n**Arguments**:\n\n- `ids` - The ids of the embeddings to update\n- `embeddings` - The embeddings to add. If None, embeddings will be computed based on the documents using the embedding_function set for the Collection. Optional.\n- `metadatas` - The metadata to associate with the embeddings. When querying, you can filter on this metadata. Optional.\n- `documents` - The documents to associate with the embeddings. Optional.\n\n\n**Returns**:\n\n None\n\n## delete\n\n```python\ndef delete(ids: Optional[IDs] = None,\n", - "d9522f64-ccb3-4438-a110-4b22a7d574bc": " where: Optional[Where] = None,\n where_document: Optional[WhereDocument] = None) -> None\n```\n\nDelete the embeddings based on ids and/or a where filter\n\n**Arguments**:\n\n- `ids` - The ids of the embeddings to delete\n- `where` - A Where type dict used to filter the delection by. E.g. `{\"color\" : \"red\", \"price\": 4.20}`. Optional.\n- `where_document` - A WhereDocument type dict used to filter the deletion by the document content. E.g. `{$contains: {\"text\": \"hello\"}}`. Optional.\n\n\n**Returns**:\n\n None", + "d9522f64-ccb3-4438-a110-4b22a7d574bc": " where: Optional[Where] = None,\n where_document: Optional[WhereDocument] = None) -> None\n```\n\nDelete the embeddings based on ids and/or a where filter\n\n**Arguments**:\n\n- `ids` - The ids of the embeddings to delete\n- `where` - A Where type dict used to filter the deletion by. E.g. `{\"color\" : \"red\", \"price\": 4.20}`. Optional.\n- `where_document` - A WhereDocument type dict used to filter the deletion by the document content. E.g. `{$contains: {\"text\": \"hello\"}}`. Optional.\n\n\n**Returns**:\n\n None", "2d7637e9-510a-492d-b213-7e4edb4ceca8": "# Embedding Functions\n\n## Default: all-MiniLM-L6-v2\n\nBy default, Chroma uses the [Sentence Transformers](https://www.sbert.net/) `all-MiniLM-L6-v2` model to create embeddings. This embedding model can create sentence and document embeddings that can be used for a wide variety of tasks. This embedding function runs locally on your machine, and may require you download the model files (this will happen automatically).\n\n{% TabbedCodeBlock %}\n\n{% Tab label=\"python\" %}\n```python\nfrom chromadb.utils import embedding_functions\ndefault_ef = embedding_functions.DefaultEmbeddingFunction()\n```\n{% /Tab %}\n\n{% Tab label=\"typescript\" %}\n```typescript\nimport { DefaultEmbeddingFunction } from \"chromadb\";\nconst defaultEF = new DefaultEmbeddingFunction();\n```\n{% /Tab %}\n\n{% /TabbedCodeBlock %}\n\nEmbedding functions can be linked to a collection and used whenever you call `add`, `update`, `upsert` or `query`. You can also use them directly which can be handy for debugging.\n\n{% TabbedCodeBlock %}\n\n{% Tab label=\"python\" %}\n```python\nval = default_ef([\"foo\"])\nprint(val)", "be0cbc2f-da01-4e8f-9d84-0e6a2fde6455": " # [[0.05035809800028801, 0.0626462921500206, -0.061827320605516434...]]\n```\n{% /Tab %}\n\n{% Tab label=\"typescript\" %}\n```typescript\nconst val = defaultEf.generate([\"foo\"]);\nconsole.log(val); // [[0.05035809800028801, 0.0626462921500206, -0.061827320605516434...]]\n```\n{% /Tab %}\n\n{% /TabbedCodeBlock %}\n\n## Sentence Transformers\n\nChroma can also use any [Sentence Transformers](https://www.sbert.net/) model to create embeddings.\n\nYou can pass in an optional `model_name` argument, which lets you choose which Sentence Transformers model to use. By default, Chroma uses `all-MiniLM-L6-v2`. You can see a list of all available models [here](https://www.sbert.net/docs/pretrained_models.html).\n\n{% TabbedCodeBlock %}\n\n{% Tab label=\"python\" %}\n```python\nsentence_transformer_ef = embedding_functions.SentenceTransformerEmbeddingFunction(\n model_name=\"all-MiniLM-L6-v2\"\n)\n```\n{% /Tab %}\n\n", "070fe511-a8db-4ec8-b85c-64bf36bc8188": "{% Tab label=\"typescript\" %}\n```typescript\nimport { DefaultEmbeddingFunction } from \"chromadb\";\nconst modelName = \"all-MiniLM-L6-v2\";\nconst defaultEF = new DefaultEmbeddingFunction(modelName);\n```\n{% /Tab %}\n\n{% /TabbedCodeBlock %}\n\n## Custom Embedding Functions\n\nYou can create your own embedding function to use with Chroma, it just needs to implement the `EmbeddingFunction` protocol.\n\n{% TabbedCodeBlock %}\n\n{% Tab label=\"python\" %}\n```python\nfrom chromadb import Documents, EmbeddingFunction, Embeddings\n\nclass MyEmbeddingFunction(EmbeddingFunction):\n def __call__(self, input: Documents) -> Embeddings:\n # embed the documents somehow\n return embeddings\n```\n{% /Tab %}\n\n{% Tab label=\"typescript\" %}\n```typescript\nclass MyEmbeddingFunction {\n private api_key: string;\n\n constructor(api_key: string) {\n this.api_key = api_key;\n }\n\n public async generate(texts: string[]): Promise {\n // do things to turn texts into embeddings with an api_key perhaps\n return embeddings;\n }\n}\n```\n\n# Multimodal", @@ -74,7 +74,7 @@ "b3f09f7d-8a32-4a7b-9b00-3ebce7a2e998": "Anthropic MCP](./frameworks/anthropic-mcp) | \u2713 | Coming Soon! |\n\n---\nid: 'cohere'\nname: 'Cohere'\n---\n\n# Cohere\n\nChroma also provides a convenient wrapper around Cohere's embedding API. This embedding function runs remotely on Cohere\u2019s servers, and requires an API key. You can get an API key by signing up for an account at [Cohere](https://dashboard.cohere.ai/welcome/register).\n\n{% Tabs %}\n{% Tab label=\"python\" %}\n\nThis embedding function relies on the `cohere` python package, which you can install with `pip install cohere`.\n\n```python\nimport chromadb.utils.embedding_functions as embedding_functions\ncohere_ef = embedding_functions.CohereEmbeddingFunction(api_key=\"YOUR_API_KEY\", model_name=\"large\")\ncohere_ef(input=[\"document1\",\"document2\"])\n```\n\n{% /Tab %}\n\n{% Tab label=\"typescript\" %}\n\n```typescript\nimport { CohereEmbeddingFunction } from 'chromadb';\n\nconst embedder = new CohereEmbeddingFunction(\"apiKey\")\n\n// use directly\nconst embeddings = embedder.generate([\"document1\",\"document2\"])\n\n// pass documents to query for", "a13ea680-48f9-49c5-809b-a944d87a11aa": " .add and .query\nconst collection = await client.createCollection({name: \"name\", embeddingFunction: embedder})\nconst collectionGet = await client.getCollection({name:\"name\", embeddingFunction: embedder})\n```\n\n{% /Tab %}\n\n{% /Tabs %}\n\nYou can pass in an optional `model_name` argument, which lets you choose which Cohere embeddings model to use. By default, Chroma uses `large` model. You can see the available models under `Get embeddings` section [here](https://docs.cohere.ai/reference/embed).\n\n### Multilingual model example\n\n{% TabbedCodeBlock %}\n\n{% Tab label=\"python\" %}\n\n```python\ncohere_ef = embedding_functions.CohereEmbeddingFunction(\n api_key=\"YOUR_API_KEY\",\n model_name=\"multilingual-22-12\")\n\nmultilingual_texts = [ 'Hello from Cohere!', '\u0645\u0631\u062d\u0628\u064b\u0627 \u0645\u0646 \u0643\u0648\u0647\u064a\u0631!',\n 'Hallo von Cohere!', 'Bonjour de Cohere!',\n '\u00a1Hola desde Cohere!', 'Ol\u00e1 do Cohere!',\n 'Ciao da Cohere!', '\u60a8\u597d\uff0c\u6765\u81ea Cohere\uff01',\n '\u0915\u094b\u0939", "e4e9f6d7-2f12-4b79-af87-9e9f3e8d42a7": "\u093f\u0905\u0930 \u0938\u0947 \u0928\u092e\u0938\u094d\u0924\u0947!' ]\n\ncohere_ef(input=multilingual_texts)\n\n```\n\n{% /Tab %}\n\n{% Tab label=\"typescript\" %}\n\n```typescript\nimport { CohereEmbeddingFunction } from 'chromadb';\n\nconst embedder = new CohereEmbeddingFunction(\"apiKey\")\n\nmultilingual_texts = [ 'Hello from Cohere!', '\u0645\u0631\u062d\u0628\u064b\u0627 \u0645\u0646 \u0643\u0648\u0647\u064a\u0631!',\n 'Hallo von Cohere!', 'Bonjour de Cohere!',\n '\u00a1Hola desde Cohere!', 'Ol\u00e1 do Cohere!',\n 'Ciao da Cohere!', '\u60a8\u597d\uff0c\u6765\u81ea Cohere\uff01',\n '\u0915\u094b\u0939\u093f\u0905\u0930 \u0938\u0947 \u0928\u092e\u0938\u094d\u0924\u0947!' ]\n\nconst embeddings = embedder.generate(multilingual_texts)\n\n```\n\n{% /Tab %}\n\n{% /TabbedCodeBlock %}\n\nFor more information on multilingual model you can read [here](https://docs.cohere.ai/docs/multilingual-language-models).\n\n---\nid: google-gemini\nname: \"Google Gemini\"\n---\n\n# Google Gemini\n\nChroma provides a convenient wrapper around Google's Generative AI embedding API. This embedding", - "6ab6b522-8557-4225-b7bf-9a5c94a3c55a": " function runs remotely on Google's servers, and requires an API key.\n\nYou can get an API key by signing up for an account at [Google MakerSuite](https://makersuite.google.com/).\n\n{% Tabs %}\n\n{% Tab label=\"python\" %}\n\nThis embedding function relies on the `google-generativeai` python package, which you can install with `pip install google-generativeai`.\n\n```python\n# import\nimport chromadb.utils.embedding_functions as embedding_functions\n\n# use directly\ngoogle_ef = embedding_functions.GoogleGenerativeAiEmbeddingFunction(api_key=\"YOUR_API_KEY\")\ngoogle_ef([\"document1\",\"document2\"])\n\n# pass documents to query for .add and .query\ncollection = client.create_collection(name=\"name\", embedding_function=google_ef)\ncollection = client.get_collection(name=\"name\", embedding_function=google_ef)\n```\n\nYou can view a more [complete example](https://github.com/chroma-core/chroma/tree/main/examples/gemini) chatting over documents with Gemini embedding and langauge models.\n\nFor more info - please visit the [official Google python docs](https://ai.google.dev/tutorials/python_quickstart).\n\n{% /Tab %}\n\n{% Tab label=\"typescript\" %}\n\nThis embedding function relies", + "6ab6b522-8557-4225-b7bf-9a5c94a3c55a": " function runs remotely on Google's servers, and requires an API key.\n\nYou can get an API key by signing up for an account at [Google MakerSuite](https://makersuite.google.com/).\n\n{% Tabs %}\n\n{% Tab label=\"python\" %}\n\nThis embedding function relies on the `google-generativeai` python package, which you can install with `pip install google-generativeai`.\n\n```python\n# import\nimport chromadb.utils.embedding_functions as embedding_functions\n\n# use directly\ngoogle_ef = embedding_functions.GoogleGenerativeAiEmbeddingFunction(api_key=\"YOUR_API_KEY\")\ngoogle_ef([\"document1\",\"document2\"])\n\n# pass documents to query for .add and .query\ncollection = client.create_collection(name=\"name\", embedding_function=google_ef)\ncollection = client.get_collection(name=\"name\", embedding_function=google_ef)\n```\n\nYou can view a more [complete example](https://github.com/chroma-core/chroma/tree/main/examples/gemini) chatting over documents with Gemini embedding and language models.\n\nFor more info - please visit the [official Google python docs](https://ai.google.dev/tutorials/python_quickstart).\n\n{% /Tab %}\n\n{% Tab label=\"typescript\" %}\n\nThis embedding function relies", "97331935-c3c2-480a-ad00-2528a711ec2f": " on the `@google/generative-ai` npm package, which you can install with e.g. `npm install @google/generative-ai`.\n\n```typescript\nimport { ChromaClient, GoogleGenerativeAiEmbeddingFunction } from \"chromadb\";\nconst embedder = new GoogleGenerativeAiEmbeddingFunction({\n googleApiKey: \"\",\n});\n\n// use directly\nconst embeddings = await embedder.generate([\"document1\", \"document2\"]);\n\n// pass documents to query for .add and .query\nconst collection = await client.createCollection({\n name: \"name\",\n embeddingFunction: embedder,\n});\nconst collectionGet = await client.getCollection({\n name: \"name\",\n embeddingFunction: embedder,\n});\n```\n\nYou can view a more [complete example using Node](https://github.com/chroma-core/chroma/blob/main/clients/js/examples/node/app.js).\n\nFor more info - please visit the [official Google JS docs](https://ai.google.dev/tutorials/node_quickstart).\n\n{% /Tab %}\n\n{% /Tabs %}\n\n---\nid: hugging-face-server\nname: 'Hugging Face Server'\n---\n\n# Hugging Face Server\n\nChroma provides a convenient wrapper for Hugging", "df4e7fb5-5a08-4199-b424-528cb4b5c338": "Face Text Embedding Server, a standalone server that provides text embeddings via a REST API. You can read more about it [**here**](https://github.com/huggingface/text-embeddings-inference).\n\n## Setting Up The Server\n\nTo run the embedding server locally you can run the following command from the root of the Chroma repository. The docker compose command will run Chroma and the embedding server together.\n\n```terminal\ndocker compose -f examples/server_side_embeddings/huggingface/docker-compose.yml up -d\n```\n\nor\n\n```terminal\ndocker run -p 8001:80 -d -rm --name huggingface-embedding-server ghcr.io/huggingface/text-embeddings-inference:cpu-0.3.0 --model-id BAAI/bge-small-en-v1.5 --revision -main\n```\n\n{% Banner type=\"note\" %}\nThe above docker command will run the server with the `BAAI/bge-small-en-v1.5` model. You can find more information about running the server in docker [**here**](https://github.com/huggingface/text-embeddings-inference#docker).\n{% /Banner %}\n\n## Usage\n\n{% TabbedCode", "cf53149b-6ba8-4d81-a77a-4ee713da83e2": "Block %}\n\n{% Tab label=\"python\" %}\n\n```python\nfrom chromadb.utils.embedding_functions import HuggingFaceEmbeddingServer\nhuggingface_ef = HuggingFaceEmbeddingServer(url=\"http://localhost:8001/embed\")\n```\n\n{% /Tab %}\n\n{% Tab label=\"typescript\" %}\n\n\n```typescript\nimport {HuggingFaceEmbeddingServerFunction} from 'chromadb';\nconst embedder = new HuggingFaceEmbeddingServerFunction({url:\"http://localhost:8001/embed\"})\n\n// use directly\nconst embeddings = embedder.generate([\"document1\",\"document2\"])\n\n// pass documents to query for .add and .query\nlet collection = await client.createCollection({name: \"name\", embeddingFunction: embedder})\ncollection = await client.getCollection({name: \"name\", embeddingFunction: embedder})\n```\n\n{% /Tab %}\n{% /TabbedCodeBlock %}\n\nThe embedding model is configured on the server side. Check the docker-compose file in `examples/server_side_embeddings/huggingface/docker-compose.yml` for an example of how to configure the server.\n\n---\nid: hugging-face\nname: Hugging Face\n---\n\n# Hugging Face\n\nChroma also provides a convenient", @@ -108,7 +108,7 @@ "ce0fa44c-2d74-45d9-be31-aa5bc589f5fc": " Python\n\n- [LangChain + Chroma](https://blog.langchain.dev/langchain-chroma/) on the LangChain blog\n- [Harrison's `chroma-langchain` demo repo](https://github.com/hwchase17/chroma-langchain)\n - [question answering over documents](https://github.com/hwchase17/chroma-langchain/blob/master/qa.ipynb) - ([Replit version](https://replit.com/@swyx/LangChainChromaStarter#main.py))\n - [to use Chroma as a persistent database](https://github.com/hwchase17/chroma-langchain/blob/master/persistent-qa.ipynb)\n- Tutorials\n - [Chroma and LangChain tutorial](https://github.com/grumpyp/chroma-langchain-tutorial) - The demo showcases how to pull data from the English Wikipedia using their API. The project also demonstrates how to vectorize data in chunks and get embeddings using OpenAI embeddings model.\n - [Create a Voice-based ChatGPT Clone That Can Search on the Internet and local files](https://betterprogramming.pub/how-to-create-a-voice-based-chatgpt-clone-that-can-search-on", "335fa782-393f-4111-9706-90c96a19f23c": "-the-internet-24d7f570ea8)\n- [LangChain's Chroma Documentation](https://python.langchain.com/docs/integrations/vectorstores/chroma)\n\n\n## Langchain - JS\n\n- [LangChainJS Chroma Documentation](https://js.langchain.com/docs/modules/indexes/vector_stores/integrations/chroma)\n\n---\nid: llamaindex\nname: LlamaIndex\n---\n\n# LlamaIndex\n\n- `LlamaIndex` [Vector Store page](https://docs.llamaindex.ai/en/stable/examples/vector_stores/ChromaIndexDemo.html)\n- [Demo](https://github.com/jerryjliu/llama_index/blob/main/docs/examples/vector_stores/ChromaIndexDemo.ipynb)\n- [Chroma Loader on Llamahub](https://llamahub.ai/l/chroma)\n\n---\nid: openlit\nname: OpenLIT\n---\n\n# OpenLIT\n\n[OpenLIT](https://github.com/openlit/openlit) is an OpenTelemetry-native LLM Application Observability tool and includes OpenTelemetry auto-instrumention for Chroma with just a single line of code helping you ensure your applications are monitored seamlessly, providing", "8252b2c5-9835-407e-8424-baa46bfc2a7c": " critical insights to improve performance, operations and reliability.\n\nFor more information on how to use OpenLIT, see the [OpenLIT docs](https://docs.openlit.io/).\n\n## Getting Started\n\n### Step 1: Install OpenLIT\n\nOpen your command line or terminal and run:\n\n```bash\npip install openlit\n```\n\n### Step 2: Initialize OpenLIT in your Application\nIntegrating OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **two lines of code**:\n\n```python\nimport openlit\n\nopenlit.init()\n```\n\nTo forward telemetry data to an HTTP OTLP endpoint, such as the OpenTelemetry Collector, set the `otlp_endpoint` parameter with the desired endpoint. Alternatively, you can configure the endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable as recommended in the OpenTelemetry documentation.\n\n> \ud83d\udca1 Info: If you don't provide `otlp_endpoint` function argument or set the `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable, OpenLIT directs the trace directly to your console, which can be useful during development.\nTo send telemetry to OpenTelemetry backends requiring authentication, set", - "84bafda8-31cb-40c7-a32a-18618ecaa877": " the `otlp_headers` parameter with its desired value. Alternatively, you can configure the endpoint by setting the `OTEL_EXPORTER_OTLP_HEADERS` environment variable as recommended in the OpenTelemetry documentation.\n\n### Step 3: Visualize and Optimize!\n\n![](https://github.com/openlit/.github/blob/main/profile/assets/openlit-client-1.png?raw=true)\n\nWith the LLM Observability data now being collected by OpenLIT, the next step is to visualize and analyze this data to get insights into your LLM application\u2019s performance, behavior, and identify areas of improvement.\n\nTo begin exploring your LLM Application's performance data within the OpenLIT UI, please see the [Quickstart Guide](https://docs.openlit.io/latest/quickstart).\n\nIf you want to integrate and send metrics and traces to your existing observability tools like Promethues+Jaeger, Grafana or more, refer to the [Official Documentation for OpenLIT Connections](https://docs.openlit.io/latest/connections/intro) for detailed instructions.\n\n\n## Support\n\nFor any question or issue with integration you can reach out to the OpenLIT team on [Slack](https://join.slack.com/t/openlit/shared_invite", + "84bafda8-31cb-40c7-a32a-18618ecaa877": " the `otlp_headers` parameter with its desired value. Alternatively, you can configure the endpoint by setting the `OTEL_EXPORTER_OTLP_HEADERS` environment variable as recommended in the OpenTelemetry documentation.\n\n### Step 3: Visualize and Optimize!\n\n![](https://github.com/openlit/.github/blob/main/profile/assets/openlit-client-1.png?raw=true)\n\nWith the LLM Observability data now being collected by OpenLIT, the next step is to visualize and analyze this data to get insights into your LLM application\u2019s performance, behavior, and identify areas of improvement.\n\nTo begin exploring your LLM Application's performance data within the OpenLIT UI, please see the [Quickstart Guide](https://docs.openlit.io/latest/quickstart).\n\nIf you want to integrate and send metrics and traces to your existing observability tools like Prometheus+Jaeger, Grafana or more, refer to the [Official Documentation for OpenLIT Connections](https://docs.openlit.io/latest/connections/intro) for detailed instructions.\n\n\n## Support\n\nFor any question or issue with integration you can reach out to the OpenLIT team on [Slack](https://join.slack.com/t/openlit/shared_invite", "bfb638d9-8fbf-4c90-89bc-fe7a0d254c3f": "/zt-2etnfttwg-TjP_7BZXfYg84oAukY8QRQ) or via [email](mailto:contact@openlit.io).\n\n---\nid: openLLMetry\nname: OpenLLMetry\n---\n\n# OpenLLMetry\n\n[OpenLLMetry](https://www.traceloop.com/openllmetry) provides observability for systems using Chroma. It allows tracing calls to Chroma, OpenAI, and other services.\nIt gives visibility to query and index calls as well as LLM prompts and completions.\nFor more information on how to use OpenLLMetry, see the [OpenLLMetry docs](https://www.traceloop.com/docs/openllmetry).\n\n![](/openllmetry.png)\n\n### Example\n\nInstall OpenLLMetry SDK by running:\n\n```terminal\npip install traceloop-sdk\n```\n\nThen, initialize the SDK in your application:\n\n```python\nfrom traceloop.sdk import Traceloop\n\nTraceloop.init()\n```\n\n### Configuration\n\nOpenLLMetry can be configured to send traces to any observability platform that supports OpenTelemetry - Datadog,", "f7c0810c-7946-459e-9518-123610ec2ab7": " Honeycomb, Dynatrace, New Relic, etc. See the [OpenLLMetry docs](https://www.traceloop.com/openllmetry/provider/chroma) for more information.\n\n---\nid: streamlit\nname: Streamlit\n---\n\n# Streamlit\n\nStreamlit is an open-source Python library that makes it easy to create and share beautiful, custom web apps for machine learning and data science. In just a few minutes you can build and deploy powerful data apps.\n\n![](https://img.shields.io/github/stars/streamlit/streamlit.svg?style=social&label=Star&maxAge=2400)\n\n[Apache 2.0 License](https://github.com/streamlit/streamlit/blob/develop/LICENSE)  • [Site](https://streamlit.io/)\n\n{% special_table %}\n{% /special_table %}\n\n| Languages | Docs | Github |\n|--|--|--|\n| Python | [Docs](https://docs.streamlit.io/) | [Code](https://github.com/streamlit/streamlit)\n\n### Install\n\nInstall Streamlit: {% br %}{% /br %}\n`pip install streamlit`\n\nInstall `streamlit-chromadb-connection`, which connects your Stream", "3872c15c-c37b-4ed9-8db1-afa801f5facc": "lit app to Chroma through [`st.connection`](https://docs.streamlit.io/1.11.0/library/api-reference/connections/st.connection): {% br %}{% /br %}\n`pip install streamlit-chromadb-connection`\n\n### Main Benefits\n\n- Easy to get started with Streamlit's straightforward syntax\n- Built-in [chatbot functionality](https://docs.streamlit.io/library/api-reference/chat)\n- Pre-built integration with Chroma via `streamlit-chromadb-connection`\n- Deploy apps for free on [Streamlit Community Cloud](https://share.streamlit.io/)\n\n### Simple Example\n\n#### Python\n\n```python\nimport streamlit as st\nfrom streamlit_chromadb_connection.chromadb_connection import ChromadbConnection\n\nconfiguration = {\n \"client\": \"PersistentClient\",\n \"path\": \"/tmp/.chroma\"\n}\n\ncollection_name = \"documents_collection\"\n\nconn = st.connection(\"chromadb\",\n type=ChromaDBConnection,\n **configuration)\ndocuments_collection_df = conn.get_collection_data(collection_name)\nst.dataframe(documents_collection_df)\n```\n\n### Resources\n\n- [Instructions for using `streamlit-chromadb-connection` to connect your Streamlit app to Chroma](", @@ -123,8 +123,8 @@ "3b3f9ddd-a500-41c6-a04c-3f603401c3c3": " of our effort to enhance performance in Local Chroma by using NumPy arrays for internal representation of embeddings.\n\n### v0.5.6\n\nChroma internally uses a write-ahead log. In all versions prior to v0.5.6, this log was never pruned. This resulted in the data directory being much larger than it needed to be, as well as the directory size not decreasing by the expected amount after deleting a collection.\n\nIn v0.5.6 the write-ahead log is pruned automatically. However, this is not enabled by default for existing databases. After upgrading, you should run `chroma utils vacuum` once to reduce your database size and enable continuous pruning. See the [CLI reference](/reference/cli#vacuuming) for more details.\n\nThis does not need to be run regularly and does not need to be run on new databases created with v0.5.6 or later.\n\n### v0.5.1\n\nOn the Python client, the `max_batch_size` property was removed. It wasn't previously documented, but if you were reading it, you should now use `get_max_batch_size()`.\n\nThe first time this is run, it makes a HTTP request. We made this", "cf57fea2-9b57-497c-a374-acacfb30e669": " a method to make it more clear that it's potentially a blocking operation.\n\n### Auth overhaul - April 20, 2024\n\n**If you are not using Chroma's [built-in auth system](https://docs.trychroma.com/deployment/auth), you do not need to take any action.**\n\nThis release overhauls and simplifies our authentication and authorization systems.\nIf you are you using Chroma's built-in auth system, you will need to update your configuration and\nany code you wrote to implement your own authentication or authorization providers.\nThis change is mostly to pay down some of Chroma's technical debt and make future changes easier,\nbut it also changes and simplifies user configuration.\nIf you are not using Chroma's built-in auth system, you do not need to take any action.\n\nPreviously, Chroma's authentication and authorization relied on many objects with many configuration options, including:\n\n- `chroma_server_auth_provider`\n- `chroma_server_auth_configuration_provider`\n- `chroma_server_auth_credentials_provider`\n- `chroma_client_auth_credentials_provider`\n- `chroma_client_auth_protocol_adapter`\n\nand others.\n\nWe have consolidated these into three classes:\n\n- `ClientAuthProvider`\n- `ServerAuthenticationProvider`\n-", "3410b4a9-aa3c-4f33-bbdc-f129d6e19658": " `ServerAuthorizationProvider`\n\n`ClientAuthProvider`s are now responsible for their own configuration and credential management. Credentials can be given to them with the `chroma_client_auth_credentials` setting. The value for `chroma_client_auth_credentials` depends on the `ServerAuthenticationProvider`; for `TokenAuthenticationServerProvider` it should just be the token, and for `BasicAuthenticationServerProvider` it should be `username:password`.\n\n`ServerAuthenticationProvider`s are responsible for turning a request's authorization information into a `UserIdentity` containing any information necessary to make an authorization decision. They are now responsible for their own configuration and credential management. Configured via the `chroma_server_authn_credentials` and `chroma_server_authn_credentials_file` settings.\n\n`ServerAuthorizationProvider`s are responsible for turning information about the request and the `UserIdentity` which issued the request into an authorization decision. Configured via the `chroma_server_authz_config` and `chroma_server_authz_config_file` settings.\n\n_Either `_authn_credentials` or `authn_credentials_file` can be set, never both. Same for `authz_config` and `authz_config_file`. The value of the config (or data in the config file", - "fd932b28-8294-4c18-9d1c-112fe17fc909": ") will depend on your authn and authz providers. See [here](https://github.com/chroma-core/chroma/tree/main/examples/basic_functionality/authz) for more information._\n\nThe two auth systems Chroma ships with are `Basic` and `Token`. We have a small migration guide for each.\n\n#### Basic\n\nIf you're using `Token` auth, your server configuration might look like:\n\n```yaml\nCHROMA_SERVER_AUTH_CREDENTIALS=\"admin:admin\"\nCHROMA_SERVER_AUTH_CREDENTIALS_FILE=\"./example_file\"\nCHROMA_SERVER_AUTH_CREDENTIALS_PROVIDER=\"chromadb.auth.providers.HtpasswdConfigurationServerAuthCredentialsProvider\"\nCHROMA_SERVER_AUTH_PROVIDER=\"chromadb.auth.basic.BasicAuthServerProvider\"\n```\n\n_Note: Only one of `AUTH_CREDENTIALS` and `AUTH_CREDENTIALS_FILE` can be set, but this guide shows how to migrate both._\n\nAnd your corresponding client configation:\n\n```yaml\nCHROMA_CLIENT_AUTH_PROVIDER=\"chromadb.auth.token.TokenAuthClientProvider\"\nCHROMA_CLIENT_AUTH_CREDENTIALS=\"admin:admin\"\n```\n\nTo migrate to the new server configuration, simply change it to:\n\n```yaml\nCHROMA_SERVER_AUTHN_PROVIDER", - "81cc20f6-4fa6-4a3c-afd7-071930407c85": "=\"chromadb.auth.token_authn.TokenAuthenticationServerProvider\"\nCHROMA_SERVER_AUTHN_CREDENTIALS=\"test-token\"\nCHROMA_SERVER_AUTHN_CREDENTIALS_FILE=\"./example_file\"\n```\n\nNew client configuration:\n\n```yaml\nCHROMA_CLIENT_AUTH_CREDENTIALS=\"test-token\"\nCHROMA_CLIENT_AUTH_PROVIDER=\"chromadb.auth.basic_authn.BasicAuthClientProvider\"\n```\n\n#### Token\n\nIf you're using `Token` auth, your server configuration might look like:\n\n```yaml\nCHROMA_SERVER_AUTH_CREDENTIALS=\"test-token\"\nCHROMA_SERVER_AUTH_CREDENTIALS_FILE=\"./example_file\"\nCHROMA_SERVER_AUTH_CREDENTIALS_PROVIDER=\"chromadb.auth.token.TokenConfigServerAuthCredentialsProvider\"\nCHROMA_SERVER_AUTH_PROVIDER=\"chromadb.auth.token.TokenAuthServerProvider\"\nCHROMA_SERVER_AUTH_TOKEN_TRANSPORT_HEADER=\"AUTHORIZATION\"\n```\n\n_Note: Only one of `AUTH_CREDENTIALS` and `AUTH_CREDENTIALS_FILE` can be set, but this guide shows how to migrate both._\n\nAnd your corresponding client configation:\n\n```yaml\nCHROMA_CLIENT_AUTH_PROVIDER=\"chromadb.auth.token.TokenAuthClientProvider\"\nCHROMA_CLIENT_AUTH_CREDENTIALS=\"test-token\"\n", + "fd932b28-8294-4c18-9d1c-112fe17fc909": ") will depend on your authn and authz providers. See [here](https://github.com/chroma-core/chroma/tree/main/examples/basic_functionality/authz) for more information._\n\nThe two auth systems Chroma ships with are `Basic` and `Token`. We have a small migration guide for each.\n\n#### Basic\n\nIf you're using `Token` auth, your server configuration might look like:\n\n```yaml\nCHROMA_SERVER_AUTH_CREDENTIALS=\"admin:admin\"\nCHROMA_SERVER_AUTH_CREDENTIALS_FILE=\"./example_file\"\nCHROMA_SERVER_AUTH_CREDENTIALS_PROVIDER=\"chromadb.auth.providers.HtpasswdConfigurationServerAuthCredentialsProvider\"\nCHROMA_SERVER_AUTH_PROVIDER=\"chromadb.auth.basic.BasicAuthServerProvider\"\n```\n\n_Note: Only one of `AUTH_CREDENTIALS` and `AUTH_CREDENTIALS_FILE` can be set, but this guide shows how to migrate both._\n\nAnd your corresponding client configuration:\n\n```yaml\nCHROMA_CLIENT_AUTH_PROVIDER=\"chromadb.auth.token.TokenAuthClientProvider\"\nCHROMA_CLIENT_AUTH_CREDENTIALS=\"admin:admin\"\n```\n\nTo migrate to the new server configuration, simply change it to:\n\n```yaml\nCHROMA_SERVER_AUTHN_PROVIDER", + "81cc20f6-4fa6-4a3c-afd7-071930407c85": "=\"chromadb.auth.token_authn.TokenAuthenticationServerProvider\"\nCHROMA_SERVER_AUTHN_CREDENTIALS=\"test-token\"\nCHROMA_SERVER_AUTHN_CREDENTIALS_FILE=\"./example_file\"\n```\n\nNew client configuration:\n\n```yaml\nCHROMA_CLIENT_AUTH_CREDENTIALS=\"test-token\"\nCHROMA_CLIENT_AUTH_PROVIDER=\"chromadb.auth.basic_authn.BasicAuthClientProvider\"\n```\n\n#### Token\n\nIf you're using `Token` auth, your server configuration might look like:\n\n```yaml\nCHROMA_SERVER_AUTH_CREDENTIALS=\"test-token\"\nCHROMA_SERVER_AUTH_CREDENTIALS_FILE=\"./example_file\"\nCHROMA_SERVER_AUTH_CREDENTIALS_PROVIDER=\"chromadb.auth.token.TokenConfigServerAuthCredentialsProvider\"\nCHROMA_SERVER_AUTH_PROVIDER=\"chromadb.auth.token.TokenAuthServerProvider\"\nCHROMA_SERVER_AUTH_TOKEN_TRANSPORT_HEADER=\"AUTHORIZATION\"\n```\n\n_Note: Only one of `AUTH_CREDENTIALS` and `AUTH_CREDENTIALS_FILE` can be set, but this guide shows how to migrate both._\n\nAnd your corresponding client configuration:\n\n```yaml\nCHROMA_CLIENT_AUTH_PROVIDER=\"chromadb.auth.token.TokenAuthClientProvider\"\nCHROMA_CLIENT_AUTH_CREDENTIALS=\"test-token\"\n", "dd3aa7d4-4c37-456e-9c25-3c0e3f1b0e0d": "CHROMA_CLIENT_AUTH_TOKEN_TRANSPORT_HEADER=\"AUTHORIZATION\"\n```\n\nTo migrate to the new server configuration, simply change it to:\n\n```yaml\nCHROMA_SERVER_AUTHN_PROVIDER=\"chromadb.auth.token_authn.TokenAuthenticationServerProvider\"\nCHROMA_SERVER_AUTHN_CREDENTIALS=\"test-token\"\nCHROMA_SERVER_AUTHN_CREDENTIALS_FILE=\"./example_file\"\nCHROMA_AUTH_TOKEN_TRANSPORT_HEADER=\"AUTHORIZATION\"\n```\n\nNew client configuration:\n\n```yaml\nCHROMA_CLIENT_AUTH_CREDENTIALS=\"test-token\"\nCHROMA_CLIENT_AUTH_PROVIDER=\"chromadb.auth.token_authn.TokenAuthClientProvider\"\nCHROMA_AUTH_TOKEN_TRANSPORT_HEADER=\"AUTHORIZATION\"\n```\n\n#### Reference of changed configuration values\n\n- Overall config\n - `chroma_client_auth_token_transport_header`: renamed to `chroma_auth_token_transport_header`.\n - `chroma_server_auth_token_transport_header`: renamed to `chroma_auth_token_transport_header`.\n- Client config\n - `chroma_client_auth_credentials_provider`: deleted. Functionality is now in `chroma_client_auth_provider`.\n - `chroma_client_auth_protocol_adapter`: deleted. Functionality is now in `chroma_client_auth_provider`.\n - `", "9a0748dd-aa48-4d7f-b272-73a3fceec226": "chroma_client_auth_credentials_file`: deleted. Functionality is now in `chroma_client_auth_credentials`.\n - These changes also apply to the Typescript client.\n- Server authn\n - `chroma_server_auth_provider`: Renamed to `chroma_server_authn_provider`.\n - `chroma_server_auth_configuration_provider`: deleted. Functionality is now in `chroma_server_authn_provider`.\n - `chroma_server_auth_credentials_provider`: deleted. Functionality is now in `chroma_server_authn_provider`.\n - `chroma_server_auth_credentials_file`: renamed to `chroma_server_authn_credentials_file`.\n - `chroma_server_auth_credentials`: renamed to `chroma_server_authn_credentials`.\n - `chroma_server_auth_configuration_file`: renamed to `chroma_server_authn_configuration_file`.\n- Server authz\n - `chroma_server_authz_ignore_paths`: deleted. Functionality is now in `chroma_server_auth_ignore_paths`.\n\nTo see the full changes, you can read the [PR](https://github.com/chroma-core/chroma/pull/1970/files) or reach out to the Chroma team on [Discord](https://discord.gg/MMeYNT", "709ff2d5-38e9-481c-8d9f-c16859933de3": "mh3x).\n\n### Migration to 0.4.16 - November 7, 2023\n\nThis release adds support for multi-modal embeddings, with an accompanying change to the definitions of `EmbeddingFunction`.\nThis change mainly affects users who have implemented their own `EmbeddingFunction` classes. If you are using Chroma's built-in embedding functions, you do not need to take any action.\n\n**EmbeddingFunction**\n\nPreviously, `EmbeddingFunction`s were defined as:\n\n```python\nclass EmbeddingFunction(Protocol):\n def __call__(self, texts: Documents) -> Embeddings:\n ...\n```\n\nAfter this update, `EmbeddingFunction`s are defined as:\n\n```python\nEmbeddable = Union[Documents, Images]\nD = TypeVar(\"D\", bound=Embeddable, contravariant=True)\n\nclass EmbeddingFunction(Protocol[D]):\n def __call__(self, input: D) -> Embeddings:\n ...\n```\n\nThe key differences are:\n\n- `EmbeddingFunction` is now generic, and takes a type parameter `D` which is a subtype of `Embeddable`. This allows us to define `EmbeddingFunction`s which can embed multiple modalities.\n- `", @@ -156,7 +156,7 @@ "36e7fc5b-5e21-49df-8a09-75dfdc07e48a": " monitor your application's interactions with the Chroma server:\n- [OpenLLMetry Integration](../../integrations/frameworks/openllmetry).\n- [OpenLIT Integration](../../integrations/frameworks/openlit).\n\n# Single-Node Chroma: Performance and Limitations\n\n\nThe single-node version of Chroma is designed to be easy to deploy and maintain, while still providing robust performance that satisfies a broad range of production applications.\n\nTo help you understand when single-node Chroma is a good fit for your use case, we have performed a series of stress tests and performance experiments to probe the system\u2019s capabilities and discover its limitations and edge cases. We analyzed these boundaries across a range of hardware configurations, to determine what sort of deployment is appropriate for different workloads.\n\nThis document describes these findings, as well as some general principles for getting the most out of your Chroma deployment.\n\n## Results Summary\n\nRoughly speaking, here is the sort of performance you can expect from Chroma on different EC2 instance types with a very typical workload:\n\n- 1024 dimensional embeddings\n- Small documents (100-200 words)\n- Three metadata fields per record.\n\n| Instance Type | System RAM | Approx. Max Collection Size | Mean Latency", "e5e609ca-a7ce-4729-8738-0cb41beb71a7": " (insert) | 99.9% Latency (insert) | Mean Latency (query) | 99.9% Latency (query) | Monthly Cost |\n|-----------------|------------|-----------------------------|-----------------------|------------------------|----------------------|-----------------------|--------------|\n| **t3.small** | 2 | 250,000 | 55ms | 250ms | 22ms | 72ms | $15.936 |\n| **t3.medium** | 4 | 700,000 | 37ms | 120ms | 14ms | 41ms | $31.072 |\n| **t3.large** | 8 | 1,700,000 | 30ms | 100ms | 13ms | 35ms | $61.344 |\n| **t3.xlarge** | 16 | 3,600,000 | 30ms | 100ms | 13ms | 30ms | $121.888 |\n| **t3.2xlarge** ", "ac408ae9-0135-4e3b-9e6a-695cafcb2c1c": " | 32 | 7,500,000 | 30ms | 100ms | 13ms | 30ms | $242.976 |\n| **r7i.2xlarge** | 64 | 15,000,000 | 13ms | 50ms | 7ms | 13ms | $386.944 |\n\n{% br %}{% /br %}\n\nDeploying Chroma on a system with less than 2GB of RAM is **not** recommended.\n\nNote that the latency figures in this table are for small collections. Latency increases as collections grow: see [Latency and collection size](./performance#latency-and-collection-size) below for a full analysis.\n\n## Memory and collection size\n\nChroma uses a fork of [`hnswlib`](https://github.com/nmslib/hnswlib) to efficiently index and search over embedding vectors. The HNSW algorithm requires that the embedding index reside in system RAM to query or update.\n\nAs such, the amount of available system memory defines an upper bound on the size of a Chroma collection (or multiple collections, if they are being used concurrently", - "e69e12c2-a605-456f-b2f7-bdf6ace96e96": ".) If a collection grows larger than available memory, insert and query latency spike rapidly as the operating system begins swapping memory to disk. The memory layout of the index is not amenable to swapping, and the system quickly becomes unusable.\n\nTherefore, users should always plan on having enough RAM provisioned to accommodate the anticipated total number of embeddings.\n\nTo analyze how much RAM is required, we launched an an instance of Chroma on variously sized EC2 instances, then inserted embeddings until each system became non-responsive. As expected, this failure point corresponded linearly to RAM and embedding count.\n\nFor 1024 dimensional embeddings, with three metadata records and a small document per embedding, this works out to `N = R * 0.245` where `N` is the max collection size in millions, and `R` is the amount of system RAM required in gigabytes. Remember, you wil also need reserve at least a gigabyte for the system\u2019s other needs, in addition to the memory required by Chroma.\n\nThis pattern holds true up through about 7 million embeddings, which is as far as we tested. At this point Chroma is still fast and stable, and we did not find a strict upper bound on the size of", + "e69e12c2-a605-456f-b2f7-bdf6ace96e96": ".) If a collection grows larger than available memory, insert and query latency spike rapidly as the operating system begins swapping memory to disk. The memory layout of the index is not amenable to swapping, and the system quickly becomes unusable.\n\nTherefore, users should always plan on having enough RAM provisioned to accommodate the anticipated total number of embeddings.\n\nTo analyze how much RAM is required, we launched an an instance of Chroma on variously sized EC2 instances, then inserted embeddings until each system became non-responsive. As expected, this failure point corresponded linearly to RAM and embedding count.\n\nFor 1024 dimensional embeddings, with three metadata records and a small document per embedding, this works out to `N = R * 0.245` where `N` is the max collection size in millions, and `R` is the amount of system RAM required in gigabytes. Remember, you will also need to reserve at least a gigabyte for the system\u2019s other needs, in addition to the memory required by Chroma.\n\nThis pattern holds true up through about 7 million embeddings, which is as far as we tested. At this point Chroma is still fast and stable, and we did not find a strict upper bound on the size of", "9a2c19c0-5b0f-47d8-9e4a-376b0a5d2084": " a Chroma database.\n\n## Disk space and collection size\n\nChroma durably persists each collection to disk. The amount of space required is a combination of the space required to save the HNSW embedding index, and the space required by the sqlite database used to store documents and embedding metadata.\n\nThe calculations for persisting the HNSW index are similar to that for calculating RAM size. As a rule of thumb, just make sure a system\u2019s storage is at least as big as its RAM, plus several gigabytes to account for the overhead of the operating system and other applications.\n\nThe amount of space required by the sqlite database is highly variable, and depends entirely on whether documents and metadata are being saved in Chroma, and if so, how large they are. Fully exploring all permutations of this are beyond the scope of the experiments we were able to run.\n\nHowever, as a single data point, the sqlite database for a collection with ~40k documents of 1000 words each, and ~600k metadata entries was about 1.7gb.\n\nThere is no strict upper bound on the size of the metadata database: sqlite itself supports databases into the terabyte range, and can page to disk effectively.\n\nIn most realistic use cases,", "914223eb-b2cd-4f7a-9edc-0c617b3afefd": " it\u2019s likely that the size and performance of the HNSW index in RAM becomes the limiting factor on a Chroma collection\u2019s size long before the metadata database does.\n\n## Latency and collection size\n\nAs collections get larger and the size of the index grows, inserts and queries both take longer to complete. The rate of increase starts out fairly flat then grow roughly linearly, with the inflection point and slope depending on the quantity and speed of CPUs available.\n\n### Query Latency\n\n![query-latency](/query-latency.png)\n\n### Insert Latency\n\n![insert-latency](/insert-latency.png)\n\n{% note type=\"tip\" title=\"\" %}\nIf you\u2019re using multiple collections, performance looks quite similar, based on the total number of embeddings across collections. Splitting collections into multiple smaller collections doesn\u2019t help, but it doesn\u2019t hurt, either, as long as they all fit in memory at once.\n{% /note %}\n\n## Concurrency\n\nAlthough aspects of HNSW\u2019s algorithm are multithreaded internally, only one thread can read or write to a given index at a time. For the most part, single-node Chroma is fundamentally single threaded. If an operation is executed while another is still in progress", "8946b92d-8e9c-424f-9078-7a91f61baa36": ", it blocks until the first one is complete.\n\nThis means that under concurrent load, the average latency of each request will increase.\n\nWhen writing, the increased latency is more pronounced with larger batch sizes, as the system is more completely saturated. We have experimentally verified this: as the number of concurrent writers is increased, average latency increases linearly.\n\n![concurrent-writes](/concurrent-writes.png)\n\n![concurrent-queries](/concurrent-queries.png)\n\nDespite the effect on latency, Chroma does remain stable with high concurrent load. Too many concurrent users can eventually increase latency to the point where the system does not perform acceptably, but this typically only happens with larger batch sizes. As the above graphs shows, the system remains usable with dozens to hundreds of operations per second.\n\nSee the [Insert Throughput](./performance#insert-throughput) section below for a discussion of optimizing user count for maximum throughput when the concurrency is under your control, such as when inserting bulk data.\n\n# CPU speed, core count & type\n\nAs a CPU bound application, it\u2019s not surprising that CPU speed and type makes a difference for average latency.\n\nAs the data demonstrates, although it is not fully parallelized, Chroma can", diff --git a/sample_apps/generative_benchmarking/generate_benchmark.ipynb b/sample_apps/generative_benchmarking/generate_benchmark.ipynb index 77129e8387c..50c86d7779e 100644 --- a/sample_apps/generative_benchmarking/generate_benchmark.ipynb +++ b/sample_apps/generative_benchmarking/generate_benchmark.ipynb @@ -1,609 +1,609 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Generate Custom Benchmark\n", - "\n", - "This notebook walks through how to generate a custom benchmark based on your data.\n", - "\n", - "We will be using OpenAI for our embedding model and LLM, but this can easily be switched out:\n", - "- Various embedding functions are provided in `embedding_functions.py`\n", - "- LLM prompts are provided in `llm_functions.py`\n", - "\n", - "NOTE: When switching out embedding models, you will need to make a new collection for your new embeddings. Then, embed the same documents and queries with the embedding model of your choice. \n", - "\n", - "Use the same golden dataset of queries when comparing embedding models on the same data.\n", - "\n", - "Cells that should be modified when switching out embedding models are labeled as **[Modify]**" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 1. Setup" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 1.1 Install & Import\n", - "\n", - "Install the necessary packages." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "%pip install -r requirements.txt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Import modules." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "%load_ext autoreload\n", - "%autoreload 2\n", - "\n", - "import chromadb\n", - "import pandas as pd\n", - "import numpy as np\n", - "import json\n", - "import os\n", - "import dotenv\n", - "from pathlib import Path\n", - "from datetime import datetime\n", - "from openai import OpenAI as OpenAIClient\n", - "from anthropic import Anthropic as AnthropicClient\n", - "from functions.llm import *\n", - "from functions.embed import *\n", - "from functions.chroma import *\n", - "from functions.evaluate import *\n", - "from functions.visualize import *\n", - "from functions.types import *\n", - "\n", - "dotenv.load_dotenv()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 1.2 Set Variables" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We use pre-chunked [Chroma Docs](https://docs.trychroma.com/docs/overview/introduction) as an example. To run this notebook with your own data, uncomment the commented out lines and fill in.\n", - "\n", - "**[Modify]** `COLLECTION_NAME` when you change your embedding model" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "with open('data/chroma_docs.json', 'r') as f:\n", - " corpus = json.load(f)\n", - "\n", - "context = \"This is a technical support bot for Chroma, a vector database company often used by developers for building AI applications.\"\n", - "example_queries = \"\"\"\n", - " how to add to a collection\n", - " filter by metadata\n", - " retrieve embeddings when querying\n", - " how to use openai embedding function when adding to collection\n", - " \"\"\"\n", - "\n", - "COLLECTION_NAME = \"chroma-docs-openai-large\" # change this collection name whenever you switch embedding models\n", - "\n", - "# Generate a Benchmark with your own data:\n", - "\n", - "# with open('filepath/to/your/data.json', 'r') as f:\n", - "# corpus = json.load(f)\n", - "\n", - "# context = \"FILL IN WITH CONTEXT RELEVANT TO YOUR USE CASE\"\n", - "# example_queries = \"FILL IN WITH EXAMPLE QUERIES\"\n", - "\n", - "# COLLECTION_NAME = \"YOUR COLLECTION NAME\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 1.2 Load API Keys\n", - "\n", - "To use Chroma Cloud, you can sign up for a Chroma Cloud account [here](https://www.trychroma.com/) and create a new database." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# Embedding Model & LLM\n", - "OPENAI_API_KEY = os.getenv(\"OPENAI_API_KEY\")\n", - "\n", - "# If you want to use Chroma Cloud, uncomment and fill in the following:\n", - "# CHROMA_TENANT = \"YOUR CHROMA TENANT ID\"\n", - "# X_CHROMA_TOKEN = \"YOUR CHROMA API KEY\"\n", - "# DATABASE_NAME = \"YOUR CHROMA DATABASE NAME\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 1.3 Set Clients\n", - "\n", - "Initialize the clients." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "chroma_client = chromadb.Client()\n", - "\n", - "# If you want to use Chroma Cloud, uncomment the following line:\n", - "# chroma_client = chromadb.HttpClient(\n", - "# ssl=True,\n", - "# host='api.trychroma.com',\n", - "# tenant=CHROMA_TENANT,\n", - "# database=DATABASE_NAME,\n", - "# headers={\n", - "# 'x-chroma-token': X_CHROMA_TOKEN\n", - "# }\n", - "# )\n", - "\n", - "openai_client = OpenAIClient(api_key=OPENAI_API_KEY)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 2. Create Chroma Collection\n", - "\n", - "If you already have a Chroma Collection for your data, skip to **2.3**." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 2.1 Load in Your Data" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "corpus_ids = list(corpus.keys())\n", - "corpus_documents = [corpus[key] for key in corpus_ids]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 2.2 Embed Data & Add to Chroma Collection\n", - "\n", - "Embed your documents using an embedding model of your choice. We use Openai's text-embedding-3-large here, but have other functions available in `embed.py`. You may also define your own embedding function.\n", - "\n", - "We use batching and multi-threading for efficiency.\n", - "\n", - "**[Modify]** embedding function (`openai_embed_in_batches`) to the embedding model you wish to use" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "corpus_embeddings = openai_embed_in_batches(\n", - " openai_client=openai_client,\n", - " texts=corpus_documents,\n", - " model=\"text-embedding-3-large\",\n", - ")\n", - "\n", - "corpus_collection = chroma_client.get_or_create_collection(\n", - " name=COLLECTION_NAME,\n", - " metadata={\"hnsw:space\": \"cosine\"}\n", - ")\n", - "\n", - "collection_add_in_batches(\n", - " collection=corpus_collection,\n", - " ids=corpus_ids,\n", - " texts=corpus_documents,\n", - " embeddings=corpus_embeddings,\n", - ")\n", - "\n", - "corpus = {\n", - " id: {\n", - " 'document': document,\n", - " 'embedding': embedding\n", - " }\n", - " for id, document, embedding in zip(corpus_ids, corpus_documents, corpus_embeddings)\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "corpus_collection = chroma_client.get_collection(\n", - " name=COLLECTION_NAME\n", - ")\n", - "\n", - "corpus = get_collection_items(\n", - " collection=corpus_collection\n", - ")\n", - "\n", - "corpus_ids = [key for key in corpus.keys()]\n", - "corpus_documents = [corpus[key]['document'] for key in corpus_ids]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 3. Filter Documents for Quality\n", - "\n", - "We begin by filtering our documents prior to query generation, this step ensures that we avoid generating queries from irrelevant or incomplete documents." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 3.1 Set Criteria\n", - "\n", - "We use the following criteria:\n", - "- `relevance` checks whether the document is relevant to the specified context\n", - "- `completeness` checks for overall quality of the document\n", - "\n", - "You can modify the criteria as you see fit." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "relevance = f\"The document is relevant to the following context: {context}\"\n", - "completeness = \"The document is complete, meaning that it contains useful information to answer queries and does not only serve as an introduction to the main content that users may be looking for.\"\n", - "\n", - "criteria = [relevance, completeness]\n", - "criteria_labels = [\"relevance\", \"completeness\"]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 3.2 Filter Documents\n", - "\n", - "We filter our documents using gpt-4o-mini. Batching functions are also available in `llm.py`." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "filtered_document_ids = filter_documents(\n", - " client=openai_client,\n", - " model=\"gpt-4o-mini\",\n", - " documents=corpus_documents,\n", - " ids=corpus_ids,\n", - " criteria=criteria,\n", - " criteria_labels=criteria_labels\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "passed_documents = [corpus[id]['document'] for id in filtered_document_ids]\n", - "\n", - "failed_document_ids = [id for id in corpus_ids if id not in filtered_document_ids]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 3.3 View Results" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(f\"Number of documents passed: {len(filtered_document_ids)}\")\n", - "print(f\"Number of documents failed: {len(failed_document_ids)}\")\n", - "print(\"-\"*80)\n", - "print(\"Example of passed document:\")\n", - "print(corpus[filtered_document_ids[0]]['document'])\n", - "print(\"-\"*80)\n", - "print(\"Example of failed document:\")\n", - "print(corpus[failed_document_ids[0]]['document'])\n", - "print(\"-\"*80)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 4. Generate Golden Dataset\n", - "\n", - "Using our filtered documents, we can genereate a golden dataset of queries." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 4.1 Create Custom Prompt\n", - "\n", - "We will use `context` and `example_queries` for query generation." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 4.2 Generate Queries\n", - "\n", - "Generate queries with gpt-4o. Batching functions are available in `llm.py`." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "golden_dataset = create_golden_dataset(\n", - " client=openai_client,\n", - " model=\"gpt-4o\",\n", - " documents=passed_documents,\n", - " ids=filtered_document_ids,\n", - " context=context,\n", - " example_queries=example_queries\n", - ")\n", - "\n", - "golden_dataset.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 5. Evaluate\n", - "\n", - "Now that we have our golden dataset, we will can run our evaluation." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 5.1 Prepare Inputs" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "queries = golden_dataset['query'].tolist()\n", - "ids = golden_dataset['id'].tolist()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Embed generated queries.\n", - "\n", - "**[Modify]** embedding function (`openai_embed_in_batches`) to the embedding model you wish to use" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "query_embeddings = openai_embed_in_batches(\n", - " openai_client=openai_client,\n", - " texts=queries,\n", - " model=\"text-embedding-3-large\"\n", - ")\n", - "\n", - "query_embeddings_lookup_dict = {\n", - " id: QueryItem(\n", - " text=query,\n", - " embedding=embedding\n", - " )\n", - " for id, query, embedding in zip(ids, queries, query_embeddings)\n", - "}\n", - "\n", - "query_embeddings_lookup = QueryLookup(lookup=query_embeddings_lookup_dict)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create our qrels (query relevance labels) dataframe. In this case, each query and its corresponding document share the same id." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "qrels = pd.DataFrame(\n", - " {\n", - " \"query-id\": ids,\n", - " \"corpus-id\": ids,\n", - " \"score\": 1\n", - " }\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 5.2 Run Benchmark" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Processing batches: 100%|██████████| 1/1 [00:00<00:00, 18.79it/s]" - ] + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Generate Custom Benchmark\n", + "\n", + "This notebook walks through how to generate a custom benchmark based on your data.\n", + "\n", + "We will be using OpenAI for our embedding model and LLM, but this can easily be switched out:\n", + "- Various embedding functions are provided in `embedding_functions.py`\n", + "- LLM prompts are provided in `llm_functions.py`\n", + "\n", + "NOTE: When switching out embedding models, you will need to make a new collection for your new embeddings. Then, embed the same documents and queries with the embedding model of your choice. \n", + "\n", + "Use the same golden dataset of queries when comparing embedding models on the same data.\n", + "\n", + "Cells that should be modified when switching out embedding models are labeled as **[Modify]**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Setup" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1 Install & Import\n", + "\n", + "Install the necessary packages." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%pip install -r requirements.txt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Import modules." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import chromadb\n", + "import pandas as pd\n", + "import numpy as np\n", + "import json\n", + "import os\n", + "import dotenv\n", + "from pathlib import Path\n", + "from datetime import datetime\n", + "from openai import OpenAI as OpenAIClient\n", + "from anthropic import Anthropic as AnthropicClient\n", + "from functions.llm import *\n", + "from functions.embed import *\n", + "from functions.chroma import *\n", + "from functions.evaluate import *\n", + "from functions.visualize import *\n", + "from functions.types import *\n", + "\n", + "dotenv.load_dotenv()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2 Set Variables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We use pre-chunked [Chroma Docs](https://docs.trychroma.com/docs/overview/introduction) as an example. To run this notebook with your own data, uncomment the commented out lines and fill in.\n", + "\n", + "**[Modify]** `COLLECTION_NAME` when you change your embedding model" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "with open('data/chroma_docs.json', 'r') as f:\n", + " corpus = json.load(f)\n", + "\n", + "context = \"This is a technical support bot for Chroma, a vector database company often used by developers for building AI applications.\"\n", + "example_queries = \"\"\"\n", + " how to add to a collection\n", + " filter by metadata\n", + " retrieve embeddings when querying\n", + " how to use openai embedding function when adding to collection\n", + " \"\"\"\n", + "\n", + "COLLECTION_NAME = \"chroma-docs-openai-large\" # change this collection name whenever you switch embedding models\n", + "\n", + "# Generate a Benchmark with your own data:\n", + "\n", + "# with open('filepath/to/your/data.json', 'r') as f:\n", + "# corpus = json.load(f)\n", + "\n", + "# context = \"FILL IN WITH CONTEXT RELEVANT TO YOUR USE CASE\"\n", + "# example_queries = \"FILL IN WITH EXAMPLE QUERIES\"\n", + "\n", + "# COLLECTION_NAME = \"YOUR COLLECTION NAME\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2 Load API Keys\n", + "\n", + "To use Chroma Cloud, you can sign up for a Chroma Cloud account [here](https://www.trychroma.com/) and create a new database." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Embedding Model & LLM\n", + "OPENAI_API_KEY = os.getenv(\"OPENAI_API_KEY\")\n", + "\n", + "# If you want to use Chroma Cloud, uncomment and fill in the following:\n", + "# CHROMA_TENANT = \"YOUR CHROMA TENANT ID\"\n", + "# X_CHROMA_TOKEN = \"YOUR CHROMA API KEY\"\n", + "# DATABASE_NAME = \"YOUR CHROMA DATABASE NAME\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3 Set Clients\n", + "\n", + "Initialize the clients." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "chroma_client = chromadb.Client()\n", + "\n", + "# If you want to use Chroma Cloud, uncomment the following line:\n", + "# chroma_client = chromadb.HttpClient(\n", + "# ssl=True,\n", + "# host='api.trychroma.com',\n", + "# tenant=CHROMA_TENANT,\n", + "# database=DATABASE_NAME,\n", + "# headers={\n", + "# 'x-chroma-token': X_CHROMA_TOKEN\n", + "# }\n", + "# )\n", + "\n", + "openai_client = OpenAIClient(api_key=OPENAI_API_KEY)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Create Chroma Collection\n", + "\n", + "If you already have a Chroma Collection for your data, skip to **2.3**." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.1 Load in Your Data" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "corpus_ids = list(corpus.keys())\n", + "corpus_documents = [corpus[key] for key in corpus_ids]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.2 Embed Data & Add to Chroma Collection\n", + "\n", + "Embed your documents using an embedding model of your choice. We use Openai's text-embedding-3-large here, but have other functions available in `embed.py`. You may also define your own embedding function.\n", + "\n", + "We use batching and multi-threading for efficiency.\n", + "\n", + "**[Modify]** embedding function (`openai_embed_in_batches`) to the embedding model you wish to use" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "corpus_embeddings = openai_embed_in_batches(\n", + " openai_client=openai_client,\n", + " texts=corpus_documents,\n", + " model=\"text-embedding-3-large\",\n", + ")\n", + "\n", + "corpus_collection = chroma_client.get_or_create_collection(\n", + " name=COLLECTION_NAME,\n", + " metadata={\"hnsw:space\": \"cosine\"}\n", + ")\n", + "\n", + "collection_add_in_batches(\n", + " collection=corpus_collection,\n", + " ids=corpus_ids,\n", + " texts=corpus_documents,\n", + " embeddings=corpus_embeddings,\n", + ")\n", + "\n", + "corpus = {\n", + " id: {\n", + " 'document': document,\n", + " 'embedding': embedding\n", + " }\n", + " for id, document, embedding in zip(corpus_ids, corpus_documents, corpus_embeddings)\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "corpus_collection = chroma_client.get_collection(\n", + " name=COLLECTION_NAME\n", + ")\n", + "\n", + "corpus = get_collection_items(\n", + " collection=corpus_collection\n", + ")\n", + "\n", + "corpus_ids = [key for key in corpus.keys()]\n", + "corpus_documents = [corpus[key]['document'] for key in corpus_ids]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Filter Documents for Quality\n", + "\n", + "We begin by filtering our documents prior to query generation, this step ensures that we avoid generating queries from irrelevant or incomplete documents." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.1 Set Criteria\n", + "\n", + "We use the following criteria:\n", + "- `relevance` checks whether the document is relevant to the specified context\n", + "- `completeness` checks for overall quality of the document\n", + "\n", + "You can modify the criteria as you see fit." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "relevance = f\"The document is relevant to the following context: {context}\"\n", + "completeness = \"The document is complete, meaning that it contains useful information to answer queries and does not only serve as an introduction to the main content that users may be looking for.\"\n", + "\n", + "criteria = [relevance, completeness]\n", + "criteria_labels = [\"relevance\", \"completeness\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.2 Filter Documents\n", + "\n", + "We filter our documents using gpt-4o-mini. Batching functions are also available in `llm.py`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "filtered_document_ids = filter_documents(\n", + " client=openai_client,\n", + " model=\"gpt-4o-mini\",\n", + " documents=corpus_documents,\n", + " ids=corpus_ids,\n", + " criteria=criteria,\n", + " criteria_labels=criteria_labels\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "passed_documents = [corpus[id]['document'] for id in filtered_document_ids]\n", + "\n", + "failed_document_ids = [id for id in corpus_ids if id not in filtered_document_ids]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.3 View Results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(f\"Number of documents passed: {len(filtered_document_ids)}\")\n", + "print(f\"Number of documents failed: {len(failed_document_ids)}\")\n", + "print(\"-\"*80)\n", + "print(\"Example of passed document:\")\n", + "print(corpus[filtered_document_ids[0]]['document'])\n", + "print(\"-\"*80)\n", + "print(\"Example of failed document:\")\n", + "print(corpus[failed_document_ids[0]]['document'])\n", + "print(\"-\"*80)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Generate Golden Dataset\n", + "\n", + "Using our filtered documents, we can generate a golden dataset of queries." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.1 Create Custom Prompt\n", + "\n", + "We will use `context` and `example_queries` for query generation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.2 Generate Queries\n", + "\n", + "Generate queries with gpt-4o. Batching functions are available in `llm.py`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "golden_dataset = create_golden_dataset(\n", + " client=openai_client,\n", + " model=\"gpt-4o\",\n", + " documents=passed_documents,\n", + " ids=filtered_document_ids,\n", + " context=context,\n", + " example_queries=example_queries\n", + ")\n", + "\n", + "golden_dataset.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Evaluate\n", + "\n", + "Now that we have our golden dataset, we will can run our evaluation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5.1 Prepare Inputs" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "queries = golden_dataset['query'].tolist()\n", + "ids = golden_dataset['id'].tolist()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Embed generated queries.\n", + "\n", + "**[Modify]** embedding function (`openai_embed_in_batches`) to the embedding model you wish to use" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "query_embeddings = openai_embed_in_batches(\n", + " openai_client=openai_client,\n", + " texts=queries,\n", + " model=\"text-embedding-3-large\"\n", + ")\n", + "\n", + "query_embeddings_lookup_dict = {\n", + " id: QueryItem(\n", + " text=query,\n", + " embedding=embedding\n", + " )\n", + " for id, query, embedding in zip(ids, queries, query_embeddings)\n", + "}\n", + "\n", + "query_embeddings_lookup = QueryLookup(lookup=query_embeddings_lookup_dict)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create our qrels (query relevance labels) dataframe. In this case, each query and its corresponding document share the same id." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "qrels = pd.DataFrame(\n", + " {\n", + " \"query-id\": ids,\n", + " \"corpus-id\": ids,\n", + " \"score\": 1\n", + " }\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5.2 Run Benchmark" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Processing batches: 100%|██████████| 1/1 [00:00<00:00, 18.79it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NDCG@1: 0.61364\n", + "NDCG@3: 0.7224\n", + "NDCG@5: 0.75956\n", + "NDCG@10: 0.76766\n", + "MAP@1: 0.61364\n", + "MAP@3: 0.69697\n", + "MAP@5: 0.71742\n", + "MAP@10: 0.72121\n", + "Recall@1: 0.61364\n", + "Recall@3: 0.79545\n", + "Recall@5: 0.88636\n", + "Recall@10: 0.90909\n", + "P@1: 0.61364\n", + "P@3: 0.26515\n", + "P@5: 0.17727\n", + "P@10: 0.09091\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "results = run_benchmark(\n", + " query_embeddings_lookup=query_embeddings_lookup,\n", + " collection=corpus_collection,\n", + " qrels=qrels\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Save results.\n", + "\n", + "This is helpful for comparison (e.g. comparing different embedding models).\n", + "\n", + "**[Modify]** \"model\" to the model you are using" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "timestamp = datetime.now().strftime(\"%Y-%m-%d--%H-%M-%S\")\n", + "results_to_save = {\n", + " \"model\": \"text-embedding-3-large\",\n", + " \"results\": results\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "results_dir = Path(\"results\")\n", + "\n", + "with open(os.path.join(results_dir, f'{timestamp}.json'), 'w') as f:\n", + " json.dump(results_to_save, f)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.6" + } }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "NDCG@1: 0.61364\n", - "NDCG@3: 0.7224\n", - "NDCG@5: 0.75956\n", - "NDCG@10: 0.76766\n", - "MAP@1: 0.61364\n", - "MAP@3: 0.69697\n", - "MAP@5: 0.71742\n", - "MAP@10: 0.72121\n", - "Recall@1: 0.61364\n", - "Recall@3: 0.79545\n", - "Recall@5: 0.88636\n", - "Recall@10: 0.90909\n", - "P@1: 0.61364\n", - "P@3: 0.26515\n", - "P@5: 0.17727\n", - "P@10: 0.09091\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "results = run_benchmark(\n", - " query_embeddings_lookup=query_embeddings_lookup,\n", - " collection=corpus_collection,\n", - " qrels=qrels\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Save results.\n", - "\n", - "This is helpful for comparison (e.g. comparing different embedding models).\n", - "\n", - "**[Modify]** \"model\" to the model you are using" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "timestamp = datetime.now().strftime(\"%Y-%m-%d--%H-%M-%S\")\n", - "results_to_save = {\n", - " \"model\": \"text-embedding-3-large\",\n", - " \"results\": results\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "results_dir = Path(\"results\")\n", - "\n", - "with open(os.path.join(results_dir, f'{timestamp}.json'), 'w') as f:\n", - " json.dump(results_to_save, f)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.6" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file diff --git a/typos.toml b/typos.toml new file mode 100644 index 00000000000..2f768887a03 --- /dev/null +++ b/typos.toml @@ -0,0 +1,58 @@ +[default] +check-file = true +check-filename = true +extend-ignore-re = [] + +[default.extend-words] +"nin" = "nin" # Chroma operator +"americanus" = "americanus" # Valid Latin word +"TYP" = "TYP" # PR title prefix for type annotations +"ratatui" = "ratatui" # The name of a Rust crate + +[default.extend-identifiers] +"CHROMA_OT" = "CHROMA_OT" # The name of an environment variable +"flate2" = "flate2" # The name of a Rust crate +"NDArray" = "NDArray" # The name of a Numpy class +"091c0ba34f0a" = "091c0ba34f0a" # Go module pseudo-version hash fragment +"bc3834ca7abd" = "bc3834ca7abd" # Go module pseudo-version hash fragment + +[files] +extend-exclude = [ + "**/proptest-regressions/**/*.txt", + "**/*.proptest-regressions", + "examples/gemini/documents/state_of_the_union_2023.txt", + "examples/chat_with_your_documents/documents/state_of_the_union_2023.txt" +] + +[type.jupyter] +extend-glob = ["*.ipynb"] +extend-ignore-re = [ + "[a-fA-F0-9]{8,}", # Long hex strings (IDs, hashes) + "[a-zA-Z0-9_-]{8,}", # Cell IDs and other identifiers + "IPY_MODEL_[a-fA-F0-9]+", # Jupyter widget model IDs + "\\\\u001b\\[[0-9;]+m", # ANSI escape sequences +] + +[type.go-mod] +extend-glob = ["**/go.mod", "**/go.sum"] +extend-ignore-re = [ + "[a-fA-F0-9]{12,}", # Git commit hashes in go.mod + "[a-f0-9]{40}", # Full 40-character git commit hashes + "v[0-9]+\\.[0-9]+\\.[0-9]+-[0-9]{8,}-[0-9a-f]{12,}", # Module pseudo-version identifiers +] + +[type.shell] +extend-glob = ["*.sh", "*.bash"] +extend-ignore-re = [ + "\\$![a-z]+", # Bash special parameters like $!ba +] + +[type.python-test] +extend-glob = ["**/test/**/*.py", "**/test_*.py", "**/*_test.py"] +extend-ignore-re = [ + "[a-zA-Z0-9]{8,}", # Random test data strings + "[a-zA-Z0-9_-]{3,}", # Quoted random identifiers in test data +] + +[type.rust] +extend-words = { helo = "helo" } # Used in FTS tests \ No newline at end of file