gllm-datastore-binary 0.5.45__cp311-cp311-macosx_13_0_arm64.whl

gllm_datastore/data_store/chroma/query.pyi

@@ -0,0 +1,266 @@
+import logging
+from chromadb.types import Where, WhereDocument
+from dataclasses import dataclass
+from enum import StrEnum
+from gllm_datastore.core.filters.schema import FilterOperator as FilterOperator, QueryFilter as QueryFilter
+from gllm_datastore.data_store.chroma.query_translator import ChromaQueryTranslator as ChromaQueryTranslator
+from typing import Any
+
+DEFAULT_NUM_CANDIDATES: int
+
+class ChromaCollectionKeys:
+    """Constants for ChromaDB collection method keyword arguments.
+
+    This class provides constants for all string literals used in ChromaDB
+    collection method calls (get, delete, query, etc.) to avoid magic strings
+    and improve maintainability.
+
+    Attributes:
+        WHERE (str): Keyword for metadata filtering condition.
+        WHERE_DOCUMENT (str): Keyword for document content filtering condition.
+        IDS (str): Keyword for filtering by document IDs.
+        INCLUDE (str): Keyword for specifying fields to include in results.
+        LIMIT (str): Keyword for limiting the number of results.
+        METADATA_PREFIX (str): Prefix for metadata field keys.
+    """
+    WHERE: str
+    WHERE_DOCUMENT: str
+    IDS: str
+    INCLUDE: str
+    LIMIT: str
+    METADATA_PREFIX: str
+
+class ChromaOperators(StrEnum):
+    """Constants for ChromaDB query operators.
+
+    This class provides constants for all operator string literals used in
+    ChromaDB query expressions to avoid magic strings and improve maintainability.
+
+    Attributes:
+        AND (str): Logical AND operator for combining filters.
+        OR (str): Logical OR operator for combining filters.
+        NE (str): Not equal comparison operator.
+        GT (str): Greater than comparison operator.
+        LT (str): Less than comparison operator.
+        GTE (str): Greater than or equal comparison operator.
+        LTE (str): Less than or equal comparison operator.
+        IN (str): Array membership operator (value in list).
+        NIN (str): Array non-membership operator (value not in list).
+        TEXT_CONTAINS (str): Document content substring match operator.
+        NOT_CONTAINS (str): Document content substring exclusion operator.
+    """
+    AND: str
+    OR: str
+    NE: str
+    GT: str
+    LT: str
+    GTE: str
+    LTE: str
+    IN: str
+    NIN: str
+    TEXT_CONTAINS: str
+    NOT_CONTAINS: str
+
+class ChromaOperatorMapper:
+    """Maps FilterOperator to ChromaDB operators and provides inverse operator mappings.
+
+    This class encapsulates operator translation logic.
+
+    Attributes:
+        OPERATOR_TO_CHROMA (dict[FilterOperator, str]): Mapping from FilterOperator to ChromaDB operators.
+        OPERATOR_INVERSE (dict[FilterOperator, FilterOperator]): Mapping from FilterOperator to its inverse operator.
+    """
+    OPERATOR_TO_CHROMA: dict[FilterOperator, str]
+    OPERATOR_INVERSE: dict[FilterOperator, FilterOperator]
+    @classmethod
+    def get_inverse_operator(cls, operator: FilterOperator) -> FilterOperator | None:
+        """Get the inverse operator for a given FilterOperator.
+
+        Args:
+            operator (FilterOperator): The operator to get the inverse for.
+
+        Returns:
+            FilterOperator | None: The inverse operator, or None if no inverse exists.
+        """
+    @classmethod
+    def has_inverse(cls, operator: FilterOperator) -> bool:
+        """Check if an operator has an inverse mapping.
+
+        Args:
+            operator (FilterOperator): The operator to check.
+
+        Returns:
+            bool: True if the operator has an inverse, False otherwise.
+        """
+
+@dataclass
+class ChromaQueryComponents:
+    """ChromaDB query components extracted from a QueryFilter.
+
+    Attributes:
+        where_condition (Where | None): Where clause for metadata filters, or None.
+        where_document (WhereDocument | None): WhereDocument clause for content filters, or None.
+        id_values (list[str] | None): List of IDs for id filters, or None.
+    """
+    where_condition: Where | None
+    where_document: WhereDocument | None
+    id_values: list[str] | None
+    def to_dict(self) -> dict[str, Any] | None:
+        """Convert to ChromaDB kwargs dict, omitting None values.
+
+        Returns:
+            dict[str, Any] | None: Dictionary with non-None components,
+                or None if all components are None/empty.
+        """
+
+def sanitize_metadata(metadata: dict[str, Any] | None, logger: logging.Logger) -> dict[str, Any]:
+    '''Sanitize metadata by removing list values that ChromaDB doesn\'t support.
+
+    ChromaDB only supports str, int, float, or bool as metadata values.
+    This function filters out list values and logs warnings for each removed key.
+
+    Examples:
+        1. Remove list values:
+            ```python
+            logger = logging.getLogger(__name__)
+            input_meta = {"status": "active", "tags": ["a", "b"], "age": 30}
+            out = sanitize_metadata(input_meta, logger)
+            # out -> {"status": "active", "age": 30}
+            ```
+
+        2. Handle None input:
+            ```python
+            out = sanitize_metadata(None, logging.getLogger(__name__))
+            # out -> {}
+            ```
+
+    Args:
+        metadata (dict[str, Any] | None): Metadata dictionary to sanitize.
+        logger (logging.Logger): Logger instance for warning messages.
+
+    Returns:
+        dict[str, Any]: Sanitized metadata with list values removed.
+    '''
+def build_chroma_get_kwargs(filters: QueryFilter | None, query_translator: ChromaQueryTranslator, include: list[str] | None = None, limit: int | None = None, **additional_kwargs: Any) -> dict[str, Any]:
+    '''Build kwargs dictionary for ChromaDB collection.get() operations.
+
+    This function processes filters and builds a kwargs dictionary that includes
+    where, where_document, ids, include, and limit parameters as needed.
+
+    Examples:
+        1. Build kwargs with metadata and content filters:
+            ```python
+            from gllm_datastore.core.filters import filter as F
+            from gllm_datastore.data_store.chroma.query_translator import ChromaQueryTranslator
+
+            translator = ChromaQueryTranslator()
+            filters = F.and_(
+                F.eq("metadata.status", "active"),
+                F.text_contains("content", "python"),
+            )
+
+            out = build_chroma_get_kwargs(filters, translator, include=["documents"], limit=10)
+            # out ->
+            # {
+            #   "where": {"status": "active"},
+            #   "where_document": {"$contains": "python"},
+            #   "include": ["documents"],
+            #   "limit": 10
+            # }
+            ```
+
+        2. Build kwargs using id filters:
+            ```python
+            from gllm_datastore.core.filters import filter as F
+            from gllm_datastore.data_store.chroma.query_translator import ChromaQueryTranslator
+
+            translator = ChromaQueryTranslator()
+            filters = F.or_(F.eq("id", "123"), F.in_("id", ["a", "b"]))
+            out = build_chroma_get_kwargs(filters, translator)
+            # out -> {"ids": ["123", "a", "b"]}
+            ```
+
+    Args:
+        filters (QueryFilter | None): QueryFilter to process.
+        query_translator (ChromaQueryTranslator): Query translator instance to use.
+        include (list[str] | None, optional): List of fields to include in results.
+            Defaults to None.
+        limit (int | None, optional): Maximum number of results to return.
+            Defaults to None.
+        **additional_kwargs: Additional kwargs to include in the result.
+
+    Returns:
+        dict[str, Any]: Dictionary of kwargs ready for ChromaDB collection.get() call.
+    '''
+def build_chroma_delete_kwargs(filters: QueryFilter | None, query_translator: ChromaQueryTranslator, **additional_kwargs: Any) -> dict[str, Any]:
+    '''Build kwargs dictionary for ChromaDB collection.delete() operations.
+
+    This function processes filters and builds a kwargs dictionary that includes
+    where, where_document, and ids parameters as needed.
+
+    Examples:
+        1. Delete by ids or where:
+            ```python
+            from gllm_datastore.core.filters import filter as F
+            from gllm_datastore.data_store.chroma.query_translator import ChromaQueryTranslator
+
+            translator = ChromaQueryTranslator()
+            filters = F.and_(
+                F.in_("id", ["x1", "x2"]),
+                F.eq("metadata.status", "inactive"),
+            )
+            out = build_chroma_delete_kwargs(filters, translator)
+            # out ->
+            # {
+            #   "ids": ["x1", "x2"],
+            #   "where": {"status": "inactive"}
+            # }
+            ```
+
+    Args:
+        filters (QueryFilter | None): QueryFilter to process.
+        query_translator (ChromaQueryTranslator): Query translator instance to use.
+        **additional_kwargs: Additional kwargs to include in the result.
+
+    Returns:
+        dict[str, Any]: Dictionary of kwargs ready for ChromaDB collection.delete() call.
+    '''
+def extract_chroma_query_components(filters: QueryFilter | None) -> ChromaQueryComponents:
+    '''Prepare all ChromaDB query parameters from a QueryFilter.
+
+    This function processes a QueryFilter and extracts:
+    1. Metadata filters -> Where clause
+    2. Content filters -> WhereDocument clause
+    3. id filters -> ids parameter
+
+    Only operators natively supported by ChromaDB are allowed:
+    1. id: EQ, IN (using ids parameter)
+    2. content: TEXT_CONTAINS (substring match in document content, maps to $contains)
+    3. metadata: EQ, NE, GT, LT, GTE, LTE, IN, NIN (using where clause)
+    4. metadata: ARRAY_CONTAINS (array membership, not supported by ChromaDB - raises NotImplementedError)
+
+    Examples:
+        1. Extract all components from a mixed filter:
+            ```python
+            from gllm_datastore.core.filters import filter as F
+
+            filters = F.and_(
+                F.eq("metadata.status", "active"),
+                F.text_contains("content", "python"),
+                F.in_("id", ["a", "b"]),
+            )
+            components = extract_chroma_query_components(filters)
+            # components.where_condition -> dict
+            # components.where_document -> dict
+            # components.id_values -> ["a", "b"]
+            ```
+
+    Args:
+        filters (QueryFilter | None): QueryFilter to process.
+
+    Returns:
+        ChromaQueryComponents: Dataclass containing where_condition, where_document, and id_values.
+
+    Raises:
+        NotImplementedError: If unsupported operators are used for id or content filters.
+    '''

gllm_datastore/data_store/chroma/query_translator.pyi

@@ -0,0 +1,41 @@
+from dataclasses import dataclass
+from gllm_datastore.constants import CHUNK_KEYS as CHUNK_KEYS
+from gllm_datastore.core.filters.schema import FilterClause as FilterClause, FilterCondition as FilterCondition, FilterOperator as FilterOperator, QueryFilter as QueryFilter
+from gllm_datastore.data_store.chroma.query import ChromaCollectionKeys as ChromaCollectionKeys, ChromaOperatorMapper as ChromaOperatorMapper, ChromaOperators as ChromaOperators, ChromaQueryComponents as ChromaQueryComponents
+
+@dataclass
+class FilterSeparationResult:
+    """Intermediate result from separating special filters (id, content) from metadata filters.
+
+    Attributes:
+        id_values (list[str] | None): Extracted ID values, or None if no ID filters found.
+        document_filters (list[FilterClause | QueryFilter]): List of content FilterClauses or
+            QueryFilters for where_document. QueryFilters are used to represent NOT conditions.
+        metadata_filters (list[FilterClause | QueryFilter]): Metadata filters for where clause.
+        condition (FilterCondition): The original FilterCondition from the QueryFilter.
+    """
+    id_values: list[str] | None
+    document_filters: list[FilterClause | QueryFilter]
+    metadata_filters: list[FilterClause | QueryFilter]
+    condition: FilterCondition
+
+class ChromaQueryTranslator:
+    """Translates QueryFilter and FilterClause objects to ChromaDB native filter syntax.
+
+    This class encapsulates all query translation logic for ChromaDB, converting
+    structured FilterClause and QueryFilter objects into ChromaDB's where, where_document,
+    and ids parameters.
+    """
+    def translate(self, filters: QueryFilter | None = None) -> ChromaQueryComponents:
+        """Translate QueryFilter to ChromaDB query components.
+
+        This is the main entry point for query translation. It handles None filters
+        and orchestrates filter separation and translation.
+
+        Args:
+            filters (QueryFilter | None, optional): Structured QueryFilter to translate. Defaults to None.
+
+        Returns:
+            ChromaQueryComponents: ChromaDB query components containing where,
+                where_document, and id_values, or None if no filters are provided.
+        """

gllm_datastore/data_store/chroma/vector.pyi

@@ -0,0 +1,197 @@
+from _typeshed import Incomplete
+from chromadb import ClientAPI
+from gllm_core.schema import Chunk
+from gllm_datastore.constants import CHUNK_KEYS as CHUNK_KEYS, DEFAULT_TOP_K as DEFAULT_TOP_K, METADATA_KEYS as METADATA_KEYS
+from gllm_datastore.core.filters import FilterClause as FilterClause, QueryFilter as QueryFilter, QueryOptions as QueryOptions
+from gllm_datastore.data_store.chroma._chroma_import import safe_import_chromadb as safe_import_chromadb
+from gllm_datastore.data_store.chroma.query import ChromaCollectionKeys as ChromaCollectionKeys, DEFAULT_NUM_CANDIDATES as DEFAULT_NUM_CANDIDATES, build_chroma_delete_kwargs as build_chroma_delete_kwargs, build_chroma_get_kwargs as build_chroma_get_kwargs
+from gllm_datastore.data_store.chroma.query_translator import ChromaQueryTranslator as ChromaQueryTranslator
+from gllm_datastore.utils.converter import from_langchain as from_langchain, l2_distance_to_similarity_score as l2_distance_to_similarity_score, to_langchain as to_langchain
+from gllm_inference.em_invoker.em_invoker import BaseEMInvoker
+from gllm_inference.schema import Vector
+from typing import Any
+
+chromadb: Incomplete
+
+class ChromaVectorCapability:
+    """ChromaDB implementation of VectorCapability protocol.
+
+    This class provides document CRUD operations and vector search using ChromaDB.
+
+    Attributes:
+        collection_name (str): The name of the ChromaDB collection.
+        collection (Collection): The ChromaDB collection instance.
+        vector_store (Chroma): The langchain Chroma vector store instance.
+        num_candidates (int): The maximum number of candidates to consider during search.
+    """
+    collection_name: Incomplete
+    client: Incomplete
+    collection: Incomplete
+    num_candidates: Incomplete
+    vector_store: Incomplete
+    def __init__(self, collection_name: str, em_invoker: BaseEMInvoker, client: ClientAPI, num_candidates: int = ...) -> None:
+        """Initialize the ChromaDB vector capability.
+
+        Args:
+            collection_name (str): The name of the ChromaDB collection.
+            em_invoker (BaseEMInvoker): The embedding model to perform vectorization.
+            client (ClientAPI): The ChromaDB client instance.
+            num_candidates (int, optional): Maximum number of candidates to consider during search.
+                Defaults to 50.
+        """
+    @property
+    def em_invoker(self) -> BaseEMInvoker:
+        """Returns the EM Invoker instance.
+
+        Returns:
+            BaseEMInvoker: The EM Invoker instance.
+        """
+    async def ensure_index(self) -> None:
+        """Ensure ChromaDB collection exists, creating it if necessary.
+
+        This method is idempotent - if the collection already exists, it will return
+        the existing collection. The collection is automatically created during initialization,
+        but this method can be called explicitly to ensure it exists.
+
+        Raises:
+            RuntimeError: If collection creation fails.
+        """
+    async def create(self, data: Chunk | list[Chunk], **kwargs: Any) -> None:
+        """Add chunks to the vector store with automatic embedding generation.
+
+        Args:
+            data (Chunk | list[Chunk]): Single chunk or list of chunks to add.
+            **kwargs: Backend-specific parameters.
+        """
+    async def create_from_vector(self, chunk_vectors: list[tuple[Chunk, Vector]], **kwargs: Any) -> None:
+        '''Add pre-computed embeddings directly.
+
+        Examples:
+            ```python
+            await datastore.vector.create_from_vector(chunk_vectors=[
+                (Chunk(content="text1", metadata={"source": "source1"}, id="id1"), [0.1, 0.2, 0.3]),
+                (Chunk(content="text2", metadata={"source": "source2"}, id="id2"), [0.4, 0.5, 0.6]),
+            ])
+            ```
+
+        Args:
+            chunk_vectors (list[tuple[Chunk, Vector]]): List of tuples containing chunks and their
+                corresponding vectors.
+            **kwargs: Datastore-specific parameters.
+        '''
+    async def retrieve(self, query: str, filters: FilterClause | QueryFilter | None = None, options: QueryOptions | None = None) -> list[Chunk]:
+        '''Semantic search using text query converted to vector.
+
+        Examples:
+            ```python
+            from gllm_datastore.core.filters import filter as F
+
+            # Direct FilterClause usage
+            await datastore.vector.retrieve(
+                query="What is the capital of France?",
+                filters=F.eq("metadata.category", "tech")
+            )
+
+            # Multiple filters
+            filters = F.and_(F.eq("metadata.source", "wikipedia"), F.eq("metadata.category", "tech"))
+            await datastore.vector.retrieve(query="What is the capital of France?", filters=filters)
+            ```
+            This will retrieve the top 10 chunks by similarity score from the vector store
+            that match the query and the filters. The chunks will be sorted by score in descending order.
+
+        Args:
+            query (str): Text query to embed and search for.
+            filters (FilterClause | QueryFilter | None, optional): Filters to apply to the search.
+                FilterClause objects are automatically converted to QueryFilter internally.
+                Defaults to None.
+            options (QueryOptions | None, optional): Options to apply to the search. Defaults to None.
+
+        Returns:
+            list[Chunk]: List of chunks ordered by relevance score.
+        '''
+    async def retrieve_by_vector(self, vector: Vector, filters: FilterClause | QueryFilter | None = None, options: QueryOptions | None = None) -> list[Chunk]:
+        '''Direct vector similarity search.
+
+        Examples:
+            ```python
+            from gllm_datastore.core.filters import filter as F
+
+            # Direct FilterClause usage
+            await datastore.vector.retrieve_by_vector(
+                vector=[0.1, 0.2, 0.3],
+                filters=F.eq("metadata.category", "tech")
+            )
+
+            # Multiple filters
+            filters = F.and_(F.eq("metadata.source", "wikipedia"), F.eq("metadata.category", "tech"))
+            await datastore.vector.retrieve_by_vector(vector=[0.1, 0.2, 0.3], filters=filters)
+            ```
+            This will retrieve the top 10 chunks by similarity score from the vector store
+            that match the vector and the filters. The chunks will be sorted by score in descending order.
+
+        Args:
+            vector (Vector): Query embedding vector.
+            filters (FilterClause | QueryFilter | None, optional): Filters to apply to the search.
+                FilterClause objects are automatically converted to QueryFilter internally.
+                Defaults to None.
+            options (QueryOptions | None, optional): Options to apply to the search. Defaults to None.
+
+        Returns:
+            list[Chunk]: List of chunks ordered by similarity score.
+        '''
+    async def update(self, update_values: dict[str, Any], filters: FilterClause | QueryFilter | None = None) -> None:
+        '''Update existing records in the datastore.
+
+        Examples:
+            ```python
+            from gllm_datastore.core.filters import filter as F
+
+            # Direct FilterClause usage
+            await datastore.vector.update(
+                update_values={"metadata": {"status": "published"}},
+                filters=F.eq("metadata.category", "tech"),
+            )
+
+            # Multiple filters
+            filters = F.and_(F.eq("metadata.source", "wikipedia"), F.eq("metadata.category", "tech"))
+            await datastore.vector.update(
+                update_values={"metadata": {"status": "published"}},
+                filters=filters,
+            )
+            ```
+            This will update the metadata of the chunks that match the filters to "published".
+
+        Args:
+            update_values (dict[str, Any]): Values to update.
+            filters (FilterClause | QueryFilter | None, optional): Filters to select records to update.
+                FilterClause objects are automatically converted to QueryFilter internally.
+                Defaults to None, in which case no operation is performed (no-op).
+
+        Note:
+            ChromaDB doesn\'t support direct update operations. This method requires
+            filters to identify records and will update matching records.
+        '''
+    async def delete(self, filters: FilterClause | QueryFilter | None = None, **kwargs: Any) -> None:
+        '''Delete records from the datastore.
+
+        Examples:
+            ```python
+            from gllm_datastore.core.filters import filter as F
+
+            # Direct FilterClause usage
+            await datastore.vector.delete(filters=F.eq("metadata.category", "tech"))
+
+            # Multiple filters
+            filters = F.and_(F.eq("metadata.source", "wikipedia"), F.eq("metadata.category", "tech"))
+            await datastore.vector.delete(filters=filters)
+            ```
+            This will delete all chunks from the vector store that match the filters.
+
+        Args:
+            filters (FilterClause | QueryFilter | None, optional): Filters to select records to delete.
+                FilterClause objects are automatically converted to QueryFilter internally.
+                Defaults to None, in which case no operation is performed (no-op).
+            **kwargs: Datastore-specific parameters.
+        '''
+    async def clear(self) -> None:
+        """Clear all records from the datastore."""

gllm_datastore/data_store/elasticsearch/__init__.pyi

@@ -0,0 +1,5 @@
+from gllm_datastore.data_store.elasticsearch.data_store import ElasticsearchDataStore as ElasticsearchDataStore
+from gllm_datastore.data_store.elasticsearch.fulltext import ElasticsearchFulltextCapability as ElasticsearchFulltextCapability
+from gllm_datastore.data_store.elasticsearch.vector import ElasticsearchVectorCapability as ElasticsearchVectorCapability
+
+__all__ = ['ElasticsearchDataStore', 'ElasticsearchFulltextCapability', 'ElasticsearchVectorCapability']

gllm_datastore/data_store/elasticsearch/data_store.pyi

@@ -0,0 +1,119 @@
+from _typeshed import Incomplete
+from elasticsearch import AsyncElasticsearch
+from gllm_datastore.constants import DEFAULT_REQUEST_TIMEOUT as DEFAULT_REQUEST_TIMEOUT
+from gllm_datastore.core.filters.schema import FilterClause as FilterClause, QueryFilter as QueryFilter
+from gllm_datastore.data_store.base import BaseDataStore as BaseDataStore, CapabilityType as CapabilityType
+from gllm_datastore.data_store.elasticsearch.fulltext import ElasticsearchFulltextCapability as ElasticsearchFulltextCapability
+from gllm_datastore.data_store.elasticsearch.query import translate_filter as translate_filter
+from gllm_datastore.data_store.elasticsearch.vector import ElasticsearchVectorCapability as ElasticsearchVectorCapability
+from gllm_inference.em_invoker.em_invoker import BaseEMInvoker
+from langchain_elasticsearch.vectorstores import AsyncRetrievalStrategy
+from typing import Any
+
+class ElasticsearchDataStore(BaseDataStore):
+    """Elasticsearch data store with multiple capability support.
+
+    Attributes:
+        index_name (str): The name of the Elasticsearch index.
+        client (AsyncElasticsearch): AsyncElasticsearch client.
+    """
+    client: Incomplete
+    index_name: Incomplete
+    def __init__(self, index_name: str, client: AsyncElasticsearch | None = None, url: str | None = None, cloud_id: str | None = None, api_key: str | None = None, username: str | None = None, password: str | None = None, request_timeout: int = ...) -> None:
+        """Initialize the Elasticsearch fulltext capability.
+
+        Args:
+            index_name (str): The name of the Elasticsearch index.
+            client (AsyncElasticsearch | None, optional): The Elasticsearch client. Defaults to None.
+                If provided, it will be used instead of the url and cloud_id.
+            url (str | None, optional): The URL of the Elasticsearch server. Defaults to None.
+            cloud_id (str | None, optional): The cloud ID of the Elasticsearch cluster. Defaults to None.
+            api_key (str | None, optional): The API key for authentication. Defaults to None.
+            username (str | None, optional): The username for authentication. Defaults to None.
+            password (str | None, optional): The password for authentication. Defaults to None.
+            request_timeout (int, optional): The request timeout. Defaults to DEFAULT_REQUEST_TIMEOUT.
+        """
+    @property
+    def supported_capabilities(self) -> list[str]:
+        """Return list of currently supported capabilities.
+
+        Returns:
+            list[str]: List of capability names that are supported.
+        """
+    @property
+    def fulltext(self) -> ElasticsearchFulltextCapability:
+        """Access fulltext capability if supported.
+
+        This method uses the logic of its parent class to return the fulltext capability handler.
+        This method overrides the parent class to return the ElasticsearchFulltextCapability handler for better
+        type hinting.
+
+        Returns:
+            ElasticsearchFulltextCapability: Fulltext capability handler.
+
+        Raises:
+            NotSupportedException: If fulltext capability is not supported.
+        """
+    @property
+    def vector(self) -> ElasticsearchVectorCapability:
+        """Access vector capability if supported.
+
+        This method uses the logic of its parent class to return the vector capability handler.
+        This method overrides the parent class to return the ElasticsearchVectorCapability handler for better
+        type hinting.
+
+        Returns:
+            ElasticsearchVectorCapability: Vector capability handler.
+
+        Raises:
+            NotSupportedException: If vector capability is not supported.
+        """
+    def with_fulltext(self, index_name: str | None = None, query_field: str = 'text') -> ElasticsearchDataStore:
+        '''Configure fulltext capability and return datastore instance.
+
+        This method uses the logic of its parent class to configure the fulltext capability.
+        This method overrides the parent class for better type hinting.
+
+        Args:
+            index_name (str | None, optional): The name of the Elasticsearch index. Defaults to None,
+                in which case the default class attribute will be utilized.
+            query_field (str, optional): The field name to use for text content. Defaults to "text".
+
+        Returns:
+            Self: Self for method chaining.
+        '''
+    def with_vector(self, em_invoker: BaseEMInvoker, index_name: str | None = None, query_field: str = 'text', vector_query_field: str = 'vector', retrieval_strategy: AsyncRetrievalStrategy | None = None, distance_strategy: str | None = None) -> ElasticsearchDataStore:
+        '''Configure vector capability and return datastore instance.
+
+        This method uses the logic of its parent class to configure the vector capability.
+        This method overrides the parent class for better type hinting.
+
+        Args:
+            em_invoker (BaseEMInvoker): The embedding model to perform vectorization.
+            index_name (str | None, optional): The name of the Elasticsearch index. Defaults to None,
+                in which case the default class attribute will be utilized.
+            query_field (str, optional): The field name for text queries. Defaults to "text".
+            vector_query_field (str, optional): The field name for vector queries. Defaults to "vector".
+            retrieval_strategy (AsyncRetrievalStrategy | None, optional): The retrieval strategy for retrieval.
+                Defaults to None, in which case DenseVectorStrategy() is used.
+            distance_strategy (str | None, optional): The distance strategy for retrieval. Defaults to None.
+
+        Returns:
+            Self: Self for method chaining.
+        '''
+    @classmethod
+    def translate_query_filter(cls, query_filter: FilterClause | QueryFilter | None) -> dict[str, Any] | None:
+        """Translate QueryFilter or FilterClause to Elasticsearch native filter syntax.
+
+        This method delegates to the existing translate_filter function in the
+        elasticsearch.query module and returns the result as a dictionary.
+
+        Args:
+            query_filter (FilterClause | QueryFilter | None): The filter to translate.
+                Can be a single FilterClause, a QueryFilter with multiple clauses,
+                or None for empty filters.
+
+        Returns:
+            dict[str, Any] | None: The translated filter as an Elasticsearch DSL dict.
+                Returns None for empty filters.
+        """