Support for case insensitive query search something like "$regex" instead of "$contains"
Labels: name: area: vector store, name: auto:improvement, name: integration: chroma

### Issue you'd like to raise.

To get documents from collections (vector db) there is a method:

```python
class Collection(BaseModel):
    name: str
    id: UUID
    metadata: Optional[CollectionMetadata] = None
    _client: "API" = PrivateAttr()
    _embedding_function: Optional[EmbeddingFunction] = PrivateAttr()

    def __init__(
        self,
        client: "API",
        name: str,
        id: UUID,
        embedding_function: Optional[EmbeddingFunction] = ef.DefaultEmbeddingFunction(),
        metadata: Optional[CollectionMetadata] = None,
    ):
        self._client = client
        self._embedding_function = embedding_function
        super().__init__(name=name, metadata=metadata, id=id)

    '''
    '''
    def get(
            self,
            ids: Optional[OneOrMany[ID]] = None,
            where: Optional[Where] = None,
            limit: Optional[int] = None,
            offset: Optional[int] = None,
            where_document: Optional[WhereDocument] = None,
            include: Include = ["metadatas", "documents"],
        ) -> GetResult:
            """Get embeddings and their associate data from the data store. If no ids or where filter is provided returns
            all embeddings up to limit starting at offset.
    
            Args:
                ids: The ids of the embeddings to get. Optional.
                where: A Where type dict used to filter results by. E.g. `{"$and": ["color" : "red", "price": {"$gte": 4.20}]}`. Optional.
                limit: The number of documents to return. Optional.
                offset: The offset to start returning results from. Useful for paging results with limit. Optional.
                where_document: A WhereDocument type dict used to filter by the documents. E.g. `{$contains: {"text": "hello"}}`. Optional.
                include: A list of what to include in the results. Can contain `"embeddings"`, `"metadatas"`, `"documents"`. Ids are always included. Defaults to `["metadatas", "documents"]`. Optional.
    
            Returns:
                GetResult: A GetResult object containing the results.
    
            """
            where = validate_where(where) if where else None
            where_document = (
                validate_where_document(where_document) if where_document else None
            )
            ids = validate_ids(maybe_cast_one_to_many(ids)) if ids else None
            include = validate_include(include, allow_distances=False)
            return self._client._get(
                self.id,
                ids,
                where,
                None,
                limit,
                offset,
                where_document=where_document,
                include=include,
            )
```

To query documents by searching for a particular term in the document `where_document = {"$contains": "langchain"}` can be passed to the `get()` method. This value for the key/operator `$contains` is case sensitive. How to search for keywords irrespective of case?

### Suggestion:

I want to extract entities from a sentence and pass it get documents from the chromadb that contains that words. But this entities need to be case sensitive. If the LLM outputs a different case like for example, the document contains the keyword: "Langchain", but asking llm to extract the entity from the sentence it isnt always sure that it will generate "Langchain", it can output: "langchain". This can be handled if the first letter of the entities generated is capitalized. But this may not work for keywords like OpenCV.