gllm-datastore-binary 0.0.15__cp312-cp312-macosx_13_0_x86_64.whl

gllm_datastore/graph_data_store/neo4j_graph_data_store.pyi

@@ -0,0 +1,81 @@
+from _typeshed import Incomplete
+from gllm_datastore.graph_data_store.graph_data_store import BaseGraphDataStore as BaseGraphDataStore
+from typing import Any
+
+class Neo4jGraphDataStore(BaseGraphDataStore):
+    """Implementation of BaseGraphDataStore for Neo4j.
+
+    Attributes:
+        driver (Driver): The Neo4j driver.
+    """
+    driver: Incomplete
+    def __init__(self, uri: str, user: str, password: str) -> None:
+        """Initialize Neo4jGraphDataStore.
+
+        Args:
+            uri (str): The URI of the graph store.
+            user (str): The user of the graph store.
+            password (str): The password of the graph store.
+        """
+    def upsert_node(self, label: str, identifier_key: str, identifier_value: str, properties: dict[str, Any] | None = None) -> Any:
+        """Upsert a node in the graph.
+
+        Args:
+            label (str): The label of the node.
+            identifier_key (str): The key of the identifier.
+            identifier_value (str): The value of the identifier.
+            properties (dict[str, Any] | None, optional): The properties of the node. Defaults to None.
+
+        Returns:
+            Any: The result of the operation.
+        """
+    def upsert_relationship(self, node_source_key: str, node_source_value: str, relation: str, node_target_key: str, node_target_value: str, properties: dict[str, Any] | None = None) -> Any:
+        """Upsert a relationship between two nodes in the graph.
+
+        Args:
+            node_source_key (str): The key of the source node.
+            node_source_value (str): The value of the source node.
+            relation (str): The type of the relationship.
+            node_target_key (str): The key of the target node.
+            node_target_value (str): The value of the target node.
+            properties (dict[str, Any] | None, optional): The properties of the relationship. Defaults to None.
+
+        Returns:
+            Any: The result of the operation.
+        """
+    def delete_node(self, label: str, identifier_key: str, identifier_value: str) -> Any:
+        """Delete a node from the graph.
+
+        Args:
+            label (str): The label of the node.
+            identifier_key (str): The key of the identifier.
+            identifier_value (str): The identifier of the node.
+
+        Returns:
+            Any: The result of the operation.
+        """
+    def delete_relationship(self, node_source_key: str, node_source_value: str, relation: str, node_target_key: str, node_target_value: str) -> Any:
+        """Delete a relationship between two nodes in the graph.
+
+        Args:
+            node_source_key (str): The key of the source node.
+            node_source_value (str): The identifier of the source node.
+            relation (str): The type of the relationship.
+            node_target_key (str): The key of the target node.
+            node_target_value (str): The identifier of the target node.
+
+        Returns:
+            Any: The result of the operation.
+        """
+    def query(self, query: str, parameters: dict[str, Any] | None = None) -> list[dict[str, Any]]:
+        """Query the graph store.
+
+        Args:
+            query (str): The query to be executed.
+            parameters (dict[str, Any] | None, optional): The parameters of the query. Defaults to None.
+
+        Returns:
+            list[dict[str, Any]]: The result of the query.
+        """
+    def close(self) -> None:
+        """Close the graph data store."""

gllm_datastore/sql_data_store/__init__.pyi

@@ -0,0 +1,5 @@
+from gllm_datastore.sql_data_store.sqlalchemy_data_store import SQLAlchemyDataStore as SQLAlchemyDataStore
+from gllm_datastore.sql_data_store.sqlalchemy_sql_data_store import SQLAlchemySQLDataStore as SQLAlchemySQLDataStore
+from gllm_datastore.sql_data_store.types import QueryFilter as QueryFilter, QueryOptions as QueryOptions
+
+__all__ = ['SQLAlchemyDataStore', 'SQLAlchemySQLDataStore', 'QueryFilter', 'QueryOptions']

gllm_datastore/sql_data_store/adapter/sqlalchemy_adapter.pyi

@@ -0,0 +1,30 @@
+from _typeshed import Incomplete
+from sqlalchemy.engine import Engine as Engine
+
+class SQLAlchemyAdapter:
+    """Initializes a database engine and session using SQLAlchemy.
+
+    Provides a scoped session and a base query property for interacting with the database.
+
+    Attributes:
+        engine (Engine): The SQLAlchemy engine object.
+        db (Session): The SQLAlchemy session object.
+        base (DeclarativeMeta): The SQLAlchemy declarative base object.
+    """
+    engine: Incomplete
+    db: Incomplete
+    base: Incomplete
+    @classmethod
+    def initialize(cls, engine_or_url: Engine | str, pool_size: int = 50, max_overflow: int = 0, autocommit: bool = False, autoflush: bool = True):
+        """Creates a new database engine and session.
+
+        Must provide either an engine or a database URL.
+
+        Args:
+            engine_or_url (Engine | str): Sqlalchemy engine object or database URL.
+            pool_size (int, optional): The size of the database connections to be maintained. Defaults to 50.
+            max_overflow (int, optional): The maximum overflow size of the pool. Defaults to 0.
+            autocommit (bool, optional): If True, all changes to the database are committed immediately.
+                Defaults to False.
+            autoflush (bool, optional): If True, all changes to the database are flushed immediately. Defaults to True.
+        """

gllm_datastore/sql_data_store/constants.pyi

@@ -0,0 +1,6 @@
+QUERY_ERROR_MSG: str
+CREATE_ERROR_MSG: str
+READ_ERROR_MSG: str
+DELETE_ERROR_MSG: str
+UPDATE_ERROR_MSG: str
+UNEXPECTED_ERROR_MSG: str

gllm_datastore/sql_data_store/sql_data_store.pyi

@@ -0,0 +1,87 @@
+import abc
+import pandas as pd
+from abc import ABC, abstractmethod
+from gllm_datastore.sql_data_store.types import QueryFilter as QueryFilter, QueryOptions as QueryOptions
+from typing import Any
+
+class BaseSQLDataStore(ABC, metaclass=abc.ABCMeta):
+    """Abstract base class for SQL data stores.
+
+    This class defines the interface for all SQL data store implementations.
+    Subclasses must implement the abstract methods.
+    """
+    @abstractmethod
+    async def query(self, query: str, params: dict[str, Any] | None = None) -> pd.DataFrame:
+        """Executes raw SQL query.
+
+        This method must be implemented by subclasses to execute a raw SQL query.
+        Use this method for raw queries, complex queries, or for executing a query generated by LLM.
+
+        Args:
+            query (str): The query string to execute.
+            params (dict[str, Any] | None, optional): Parameters to bind to the query. Defaults to None.
+
+        Returns:
+            pd.DataFrame: A DataFrame of query results.
+
+        Raises:
+            NotImplementedError: If the method is not implemented.
+        """
+    @abstractmethod
+    def create(self, **kwargs: Any) -> None:
+        """Create data using available information in kwargs.
+
+        This method must be implemented by subclasses to create data in the data store.
+
+        Args:
+            **kwargs (Any): A dictionary of information to create data.
+
+        Raises:
+            NotImplementedError: If the method is not implemented.
+        """
+    @abstractmethod
+    def read(self, filters: QueryFilter | None = None, options: QueryOptions | None = None, **kwargs: Any) -> pd.DataFrame:
+        """Read data from the data store using optional filters and options.
+
+        This method must be implemented by subclasses to read data from the data store.
+        Use this method for simple queries with filters and options.
+
+        Args:
+            filters (QueryFilter | None, optional): Filters to apply to the query. Defaults to None.
+            options (QueryOptions | None, optional): Options to apply to the query. Defaults to None.
+            **kwargs (Any): A dictionary of additional information to support the read method.
+
+        Returns:
+            pd.DataFrame: A DataFrame of query results.
+
+        Raises:
+            NotImplementedError: If the method is not implemented.
+        """
+    @abstractmethod
+    def update(self, update_values: dict[str, Any], filters: QueryFilter | None = None, **kwargs: Any) -> None:
+        """Update data in the data store using optional filters and update values.
+
+        This method must be implemented by subclasses to update data in the data store.
+
+        Args:
+            update_values (dict[str, Any]): Values to update in the data store.
+            filters (QueryFilter | None, optional): Filters to apply to the query. Defaults to None.
+            **kwargs (Any): A dictionary of additional information to support the update method.
+
+        Raises:
+            NotImplementedError: If the method is not implemented.
+        """
+    @abstractmethod
+    def delete(self, filters: QueryFilter | None = None, allow_delete_all: bool = False, **kwargs: Any) -> None:
+        """Delete data in the data store using filters.
+
+        This method must be implemented by subclasses to delete data in the data store.
+
+        Args:
+            filters (QueryFilter | None, optional): Filters to apply to the query. Defaults to None.
+            allow_delete_all (bool, optional): A flag to allow deleting all data. Defaults to False.
+            **kwargs (Any): A dictionary of additional information to support the delete method.
+
+        Raises:
+            NotImplementedError: If the method is not implemented.
+        """

gllm_datastore/sql_data_store/sqlalchemy_data_store.pyi

@@ -0,0 +1,9 @@
+from gllm_datastore.sql_data_store.sqlalchemy_sql_data_store import SQLAlchemySQLDataStore as SQLAlchemySQLDataStore
+
+class SQLAlchemyDataStore(SQLAlchemySQLDataStore):
+    """A data store for interacting with SQLAlchemy.
+
+    This class is a subclass of SQLAlchemySQLDataStore.
+    It is deprecated and will be removed in a future release.
+    Use SQLAlchemySQLDataStore instead.
+    """

gllm_datastore/sql_data_store/sqlalchemy_sql_data_store.pyi

@@ -0,0 +1,183 @@
+import pandas as pd
+from _typeshed import Incomplete
+from gllm_datastore.sql_data_store.adapter.sqlalchemy_adapter import SQLAlchemyAdapter as SQLAlchemyAdapter
+from gllm_datastore.sql_data_store.constants import CREATE_ERROR_MSG as CREATE_ERROR_MSG, DELETE_ERROR_MSG as DELETE_ERROR_MSG, QUERY_ERROR_MSG as QUERY_ERROR_MSG, READ_ERROR_MSG as READ_ERROR_MSG, UNEXPECTED_ERROR_MSG as UNEXPECTED_ERROR_MSG, UPDATE_ERROR_MSG as UPDATE_ERROR_MSG
+from gllm_datastore.sql_data_store.sql_data_store import BaseSQLDataStore as BaseSQLDataStore
+from gllm_datastore.sql_data_store.types import QueryFilter as QueryFilter, QueryOptions as QueryOptions
+from sqlalchemy import Engine as Engine
+from sqlalchemy.orm import DeclarativeBase as DeclarativeBase
+from typing import Any
+
+class SQLAlchemySQLDataStore(BaseSQLDataStore):
+    """Data store for interacting with SQLAlchemy.
+
+    This class provides methods to interact with a SQL database using SQLAlchemy.
+
+    Attributes:
+        db (Engine): The SQLAlchemy engine object.
+        logger (Logger): The logger object.
+    """
+    db: Incomplete
+    logger: Incomplete
+    def __init__(self, engine_or_url: Engine | str, pool_size: int = 50, max_overflow: int = 50, autoflush: bool = True) -> None:
+        """Initialize SQLAlchemySQLDataStore class.
+
+        Args:
+            engine_or_url (Engine | str): SQLAlchemy engine object or database URL.
+            pool_size (int, optional): The size of the database connections to be maintained. Defaults to 50.
+            max_overflow (int, optional): The maximum overflow size of the pool. Defaults to 50.
+            autoflush (bool, optional): If True, all changes to the database are flushed immediately. Defaults to True.
+
+        Raises:
+            ValueError: If the database adapter is not initialized.
+        """
+    async def query(self, query: str, params: dict[str, Any] | None = None) -> pd.DataFrame:
+        '''Executes raw SQL queries.
+
+        Preferred for complex queries, when working with legacy schemas without ORM models,
+        or when using an LLM to generate your SQL queries.
+        Use this method when you need advanced SQL operations not supported by read().
+
+        Args:
+            query (str): The query string with optional :param style parameters.
+            params (dict[str, Any] | None, optional): Parameters to bind to the query. Defaults to None.
+
+        Returns:
+            pd.DataFrame: The result of the query.
+
+        Note:
+            Using string parameters directly in queries is unsafe and vulnerable to SQL injection.
+            Therefore, please avoid doing as follows as they\'re unsafe:
+            ```
+            name = "O\'Connor"
+            query = f"SELECT * FROM users WHERE last_name = \'{name}\'"
+            ```
+            or
+            ```
+            query = "SELECT * FROM users WHERE last_name = \'" + name + "\'"
+            ```
+            Instead, please use parameterized queries with :param style notation as follows:
+            ```
+            query = "SELECT * FROM users WHERE last_name = :last_name"
+            params = {"last_name": "O\'Connor"}
+            ```
+
+        Raises:
+            RuntimeError: If the query fails.
+            RuntimeError: If an unexpected error occurs.
+        '''
+    def create(self, model: DeclarativeBase | list[DeclarativeBase]) -> None:
+        '''Inserts data into the database using SQLAlchemy ORM.
+
+        This method provides a structured way to insert data using ORM models.
+
+        Args:
+            model (DeclarativeBase | list[DeclarativeBase]): An instance or list of instances of SQLAlchemy
+                model to be inserted.
+
+        Example:
+            To insert a row into a table:
+            ```
+            data_store.create(MyModel(column1="value1", column2="value2"))
+            ```
+
+            To insert multiple rows:
+            ```
+            data_store.create([
+                MyModel(column1="value1", column2="value2"),
+                MyModel(column1="value3", column2="value4")
+            ])
+            ```
+
+        Raises:
+            RuntimeError: If the insertion fails.
+            RuntimeError: If an unexpected error occurs.
+        '''
+    def read(self, model_class: type[DeclarativeBase], filters: QueryFilter | None = None, options: QueryOptions | None = None) -> pd.DataFrame:
+        '''Reads data from the database using SQLAlchemy ORM with a structured, type-safe interface.
+
+        This method provides a high-level interface for querying data using ORM models. It supports
+        filtering, column selection, ordering, and limiting results through a type-safe interface.
+
+        Args:
+            model_class (Type[DeclarativeBase]): The SQLAlchemy model class to query.
+            filters (QueryFilter | None, optional): Optional query filters containing column-value pairs
+                to filter the results. Defaults to None.
+            options (QueryOptions | None, optional): Optional query configuration including:
+                - columns: Specific columns to select
+                - order_by: Column to sort by
+                - order_desc: Sort order (ascending/descending)
+                - limit: Maximum number of results
+                Defaults to None.
+
+        Returns:
+            pd.DataFrame: A DataFrame containing the query results.
+
+        Example:
+            ```python
+            data_store.read(
+                Message,
+                filters=QueryFilter(conditions={"conversation_id": "123"}),
+                options=QueryOptions(
+                    columns=["role", "content"],
+                    order_by="created_at",
+                    order_desc=True,
+                    limit=10
+                )
+            )
+            ```
+
+        Raises:
+            RuntimeError: If the read operation fails.
+            RuntimeError: If an unexpected error occurs.
+        '''
+    def update(self, model_class: type[DeclarativeBase], update_values: dict[str, Any], filters: QueryFilter | None = None, **kwargs: Any) -> None:
+        '''Updates data in the database using SQLAlchemy ORM.
+
+        This method provides a structured way to update data using ORM models.
+
+        Args:
+            model_class (Type[DeclarativeBase]): The SQLAlchemy model class to update.
+            update_values (dict[str, Any]): Values to update.
+            filters (QueryFilter | None, optional): Filters to apply to the query. Defaults to None.
+            **kwargs (Any): Additional keyword arguments to support the update method.
+
+        Example:
+            To update a row in a table:
+            ```
+            data_store.update(
+                MyModel,
+                update_values={"column1": "new_value"}
+                filters=QueryFilter(conditions={"id": 1}),
+            )
+            ```
+
+        Raises:
+            RuntimeError: If the update operation fails.
+            RuntimeError: If an unexpected error occurs.
+        '''
+    def delete(self, model_class: type[DeclarativeBase], filters: QueryFilter | None = None, allow_delete_all: bool = False, **kwargs: Any) -> None:
+        '''Deletes data from the database using SQLAlchemy ORM.
+
+        This method provides a structured way to delete data using ORM models.
+
+        Args:
+            model_class (Type[DeclarativeBase]): The SQLAlchemy model class to delete.
+            filters (QueryFilter | None, optional): Filters to apply to the query. Defaults to None.
+            allow_delete_all (bool, optional): If True, allows deletion of all records. Defaults to False.
+            **kwargs (Any): Additional keyword arguments to support the delete method.
+
+        Example:
+            To delete a row from a table:
+            ```
+            data_store.delete(
+                MyModel,
+                filters=QueryFilter(conditions={"id": 1})
+            )
+            ```
+
+        Raises:
+            ValueError: If no filters are provided (to prevent accidental deletion of all records).
+            RuntimeError: If the delete operation fails.
+            RuntimeError: If an unexpected error occurs.
+        '''

gllm_datastore/sql_data_store/types.pyi

@@ -0,0 +1,30 @@
+from pydantic import BaseModel
+from typing import Any, Sequence
+
+class QueryFilter(BaseModel):
+    '''Model for query filters.
+
+    Attributes:
+        conditions (dict[str, Any]): The conditions for filtering the query.
+
+    Example:
+        QueryFilter(conditions={"column1": "value1", "column2": "value2"})
+    '''
+    conditions: dict[str, Any]
+
+class QueryOptions(BaseModel):
+    '''Model for query options.
+
+    Attributes:
+        columns (Sequence[str] | None): The columns to include in the query result. Defaults to None.
+        order_by (str | None): The column to order the query result by. Defaults to None.
+        order_desc (bool): Whether to order the query result in descending order. Defaults to False.
+        limit (int | None): The maximum number of rows to return. Defaults to None.
+
+    Example:
+        QueryOptions(columns=["column1", "column2"], order_by="column1", order_desc=True, limit=10)
+    '''
+    columns: Sequence[str] | None
+    order_by: str | None
+    order_desc: bool
+    limit: int | None

gllm_datastore/utils/__init__.pyi

@@ -0,0 +1,4 @@
+from gllm_datastore.utils.converter import from_langchain as from_langchain
+from gllm_datastore.utils.ttl import convert_ttl_to_seconds as convert_ttl_to_seconds
+
+__all__ = ['from_langchain', 'convert_ttl_to_seconds']

gllm_datastore/utils/converter.pyi

@@ -0,0 +1,21 @@
+from gllm_core.schema import Chunk
+from langchain_core.documents import Document
+
+def from_langchain(doc: Document) -> Chunk:
+    """Create a standardized Chunk from a LangChain Document.
+
+    Args:
+        doc (Document): The document to create a Chunk from.
+
+    Returns:
+        Chunk: The standardized Chunk object.
+    """
+def to_langchain(chunk: Chunk) -> Document:
+    """Create a LangChain Document from a standardized Chunk.
+
+    Args:
+        chunk (Chunk): The standardized Chunk to create a Document from.
+
+    Returns:
+        Document: The LangChain Document object.
+    """

gllm_datastore/utils/ttl.pyi

@@ -0,0 +1,25 @@
+from _typeshed import Incomplete
+
+TIME_UNIT_TO_SECOND_MAPPING: Incomplete
+
+def convert_ttl_to_seconds(ttl: str | int) -> int:
+    '''Convert TTL (time-to-live) string with time units to seconds.
+
+    Supported units: s (seconds), m (minutes), h (hours), d (days), w (weeks), y (years).
+
+    Examples:
+        "2m" -> 120 (2 minutes in seconds)
+        "1h" -> 3600 (1 hour in seconds)
+        "1y" -> 31536000 (1 year in seconds)
+        300 -> 300 (numeric input returned as is)
+
+    Args:
+        ttl (str | int): Time to live value with optional unit suffix (e.g., "2m", "1h", "1y")
+            or numeric value in seconds.
+
+    Returns:
+        int: TTL converted to seconds.
+
+    Raises:
+        ValueError: If the input format is invalid.
+    '''

gllm_datastore/vector_data_store/__init__.pyi

@@ -0,0 +1,4 @@
+from gllm_datastore.vector_data_store.elasticsearch_data_store import ElasticsearchDataStore as ElasticsearchDataStore
+from gllm_datastore.vector_data_store.elasticsearch_vector_data_store import ElasticsearchVectorDataStore as ElasticsearchVectorDataStore
+
+__all__ = ['ElasticsearchDataStore', 'ElasticsearchVectorDataStore']

gllm_datastore/vector_data_store/chroma_vector_data_store.pyi

@@ -0,0 +1,119 @@
+from _typeshed import Incomplete
+from chromadb.types import Where as Where, WhereDocument as WhereDocument
+from enum import Enum
+from gllm_core.schema.chunk import Chunk
+from gllm_datastore.constants import DEFAULT_TOP_K as DEFAULT_TOP_K
+from gllm_datastore.utils.converter import from_langchain as from_langchain, to_langchain as to_langchain
+from gllm_datastore.vector_data_store.vector_data_store import BaseVectorDataStore as BaseVectorDataStore
+from langchain_core.documents import Document as Document
+from langchain_core.embeddings import Embeddings as Embeddings
+from typing import Any
+
+DEFAULT_NUM_CANDIDATES: int
+
+class ChromaClientType(str, Enum):
+    """Enum for different types of ChromaDB clients.
+
+    Attributes:
+        MEMORY (str): Client type for an in-memory data store.
+        PERSISTENT (str): Client type for a persistent data store.
+        HTTP (str): Client type for a client-server architecture.
+    """
+    MEMORY = 'memory'
+    PERSISTENT = 'persistent'
+    HTTP = 'http'
+
+class ChromaVectorDataStore(BaseVectorDataStore):
+    """Datastore for interacting with ChromaDB.
+
+    This class provides methods to interact with ChromaDB for vector storage and retrieval
+    using the langchain-chroma integration.
+
+    Attributes:
+        collection_name (str): The name of the ChromaDB collection to use.
+        embedding: The model used to generate embeddings.
+        client: The ChromaDB client instance.
+            1. MEMORY: In-memory client (chromadb.Client)
+            2. PERSISTENT: Persistent client (chromadb.PersistentClient)
+            3. HTTP: HTTP client for client-server architecture (chromadb.HttpClient)
+        vector_store (Chroma): The langchain Chroma vector store instance.
+        num_candidates (int): The maximum number of candidates to consider during search.
+    """
+    collection_name: Incomplete
+    embedding: Incomplete
+    vector_store: Incomplete
+    num_candidates: Incomplete
+    def __init__(self, collection_name: str, embedding: Embeddings | None = None, client_type: ChromaClientType = ..., persist_directory: str | None = None, host: str | None = None, port: int | None = None, num_candidates: int = ..., **kwargs: Any) -> None:
+        """Initialize the ChromaDB vector data store with langchain-chroma.
+
+        Args:
+            collection_name (str): Name of the collection to use in ChromaDB.
+            embedding (Embeddings | None): Function to generate embeddings.
+            client_type (ChromaClientType, optional): Type of ChromaDB client to use.
+                Defaults to ChromaClientType.MEMORY.
+            persist_directory (str | None, optional): Directory to persist vector store data.
+                Required for PERSISTENT client type. Defaults to None.
+            host (str | None, optional): Host address for ChromaDB server.
+                Required for HTTP client type. Defaults to None.
+            port (int | None, optional): Port for ChromaDB server.
+                Required for HTTP client type. Defaults to None.
+            num_candidates (int, optional): Maximum number of candidates to consider during search.
+                Defaults to DEFAULT_NUM_CANDIDATES.
+            **kwargs: Additional parameters for Chroma initialization.
+
+        Note:
+            num_candidates (int, optional): This constant affects the maximum number of results to consider
+            during the search. Index with more documents would need a higher value for the whole documents
+            to be considered during search. This happens due to a bug with Chroma's search algorithm as discussed
+            in this issue: [3] https://github.com/langchain-ai/langchain/issues/1946
+        """
+    async def query(self, query: str, top_k: int = ..., retrieval_params: dict[str, dict[str, str]] | None = None) -> list[Chunk]:
+        '''Query the vector data store for similar chunks.
+
+        Args:
+            query (str): The query string to find similar chunks for.
+            top_k (int, optional): Maximum number of results to return. Defaults to DEFAULT_TOP_K.
+            retrieval_params (dict[str, Any] | None, optional): Additional parameters for retrieval.
+                - filter (Where, optional): A Where type dict used to filter the retrieval by the metadata keys.
+                    E.g. `{"$and": [{"color" : "red"}, {"price": {"$gte": 4.20}]}}`.
+                - where_document (WhereDocument, optional): A WhereDocument type dict used to filter the retrieval by
+                    the document content. E.g. `{$contains: {"text": "hello"}}`.
+                Defaults to None.
+
+        Returns:
+            list[Chunk]: A list of Chunk objects matching the query.
+        '''
+    async def query_by_id(self, id: str | list[str]) -> list[Chunk]:
+        """Retrieve chunks by their IDs.
+
+        Args:
+            id (str | list[str]): A single ID or a list of IDs to retrieve.
+
+        Returns:
+            list[Chunk]: A list of retrieved Chunk objects.
+        """
+    async def add_chunks(self, chunks: Chunk | list[Chunk], **kwargs) -> list[str]:
+        """Add chunks to the vector data store.
+
+        Args:
+            chunks (Chunk | list[Chunk]): A single chunk or list of chunks to add.
+            **kwargs: Additional keyword arguments for the add operation.
+
+        Returns:
+            list[str]: List of IDs of the added chunks.
+        """
+    async def delete_chunks(self, ids: list[str] = None, where: Where | None = None, where_document: WhereDocument | None = None) -> None:
+        '''Delete chunks from the vector data store.
+
+        Args:
+            ids (list[str], optional): List of IDs of chunks to delete. Defaults to None. If not provided, the deletion
+                all chunks will be based on the `where` and `where_document` filters. If all are None, all chunks will
+                be deleted.
+            where (Where | None, optional): A Where type dict used to filter the deletion by the metadata keys.
+                E.g. `{"$and": [{"color" : "red"}, {"price": {"$gte": 4.20}]}}`. Defaults to None.
+            where_document (WhereDocument | None, optional): A WhereDocument type dict used to filter the deletion by
+                the document content. E.g. `{$contains: {"text": "hello"}}`. Defaults to None.
+
+        Note:
+            If no parameters are provided, all chunks in the collection will be deleted. Please use with caution.
+        '''

gllm_datastore/vector_data_store/elasticsearch_data_store.pyi

@@ -0,0 +1,9 @@
+from gllm_datastore.vector_data_store.elasticsearch_vector_data_store import ElasticsearchVectorDataStore as ElasticsearchVectorDataStore
+
+class ElasticsearchDataStore(ElasticsearchVectorDataStore):
+    """A vector data store for interacting with Elasticsearch.
+
+    This class is a subclass of ElasticsearchVectorDataStore.
+    It is deprecated and will be removed in a future release.
+    Use ElasticsearchVectorDataStore instead.
+    """