gllm-datastore-binary 0.0.15__cp311-cp311-macosx_13_0_x86_64.whl

gllm_datastore/cache_data_store/__init__.pyi

@@ -0,0 +1,5 @@
+from gllm_datastore.cache_data_store.file_system_cache_data_store import FileSystemCacheDataStore as FileSystemCacheDataStore
+from gllm_datastore.cache_data_store.in_memory_cache_data_store import InMemoryCacheDataStore as InMemoryCacheDataStore
+from gllm_datastore.cache_data_store.redis_cache_data_store import RedisCacheDataStore as RedisCacheDataStore
+
+__all__ = ['FileSystemCacheDataStore', 'InMemoryCacheDataStore', 'RedisCacheDataStore']

gllm_datastore/cache_data_store/cache_data_store.pyi

@@ -0,0 +1,146 @@
+import abc
+from _typeshed import Incomplete
+from abc import ABC, abstractmethod
+from enum import StrEnum
+from gllm_datastore.cache_data_store.utils import generate_key_from_func as generate_key_from_func
+from gllm_datastore.utils import convert_ttl_to_seconds as convert_ttl_to_seconds
+from typing import Any, Callable, ParamSpec, TypeVar
+
+P = ParamSpec('P')
+T = TypeVar('T')
+
+class CacheMatchingStrategy(StrEnum):
+    """An enumeration of cache matching strategies.
+
+    Attributes:
+        EXACT (str): The cache key must match the query exactly.
+        FUZZY (str): The cache key must match the query with fuzzy matching.
+    """
+    EXACT = 'exact'
+    FUZZY = 'fuzzy'
+
+class BaseCacheDataStore(ABC, metaclass=abc.ABCMeta):
+    """A base class for cache data store used in Gen AI applications.
+
+    The `BaseCacheDataStore` class provides a framework for storing and retrieving cache data.
+
+    Attributes:
+        retrieval_method (Callable[[str], Any]): The method to retrieve cache data based on the matching strategy.
+        fuzzy_distance_ratio (float): The ratio of key length to use as maximum Levenshtein distance
+            for fuzzy matching (e.g., 0.1 means 10% of key length). Must be between 0 and 1.
+
+    Supported matching strategies:
+        1. EXACT
+           The cache matches when the key is an exact match.
+        2. FUZZY
+           The cache matches when the key has a Levenshtein distance of less than or equal to the maximum allowed
+           distance. The maximum allowed distance is calculated by multiplying the `fuzzy_distance_ratio` with the key
+           length. Since the fuzzy matching heavily depends on the syntactic similarity between the key and the cached
+           key, it should only be used when the key is a plain string. Fuzzy matching SHOULD NOT be used when the key
+           is a hash / encryption of the input data.
+    """
+    retrieval_method: Incomplete
+    fuzzy_distance_ratio: Incomplete
+    def __init__(self, matching_strategy: CacheMatchingStrategy = ..., fuzzy_distance_ratio: float = 0.05) -> None:
+        """Initialize a new instance of the `BaseCacheDataStore` class.
+
+        Args:
+            matching_strategy (CacheMatchingStrategy, optional): The matching strategy to use.
+                Defaults to CacheMatchingStrategy.EXACT.
+            fuzzy_distance_ratio (float, optional): The ratio of key length to use as maximum Levenshtein distance
+                for fuzzy matching (e.g., 0.05 means 5% of key length). Must be between 0 and 1. Defaults to 0.05.
+
+        Raises:
+            ValueError: If the matching strategy is not supported or if fuzzy_distance_ratio is not between 0 and 1.
+        """
+    def store(self, key: str, value: Any, ttl: int | str | None = None) -> None:
+        '''Stores cache data in the storage.
+
+        This method preprocesses the TTL (time-to-live) value to seconds if provided, and then calls the `_store`
+        method to store the cache data in the storage.
+
+        Args:
+            key (str): The key to store the cache data.
+            value (Any): The cache data to store.
+            ttl (int | str | None): The time-to-live (TTL) for the cache data. Must either be an integer in seconds
+                or a string (e.g. "1h", "1d", "1w", "1y"). If None, the cache data will not expire.
+        '''
+    def retrieve(self, key: str) -> Any:
+        """Retrieves cache data from the storage.
+
+        Args:
+            key (str): The key to retrieve the cache data.
+
+        Returns:
+            Any: The retrieved cache data.
+        """
+    @abstractmethod
+    def retrieve_all_keys(self) -> list[str]:
+        """Retrieves all keys from the storage.
+
+        This method must be implemented by the subclasses to define the logic for retrieving all keys from the storage.
+
+        Returns:
+            list[str]: A list of all keys in the storage.
+
+        Raises:
+            NotImplementedError: If the method is not implemented.
+        """
+    @abstractmethod
+    def delete(self, key: str | list[str]) -> None:
+        """Deletes cache data from the storage.
+
+        This method must be implemented by the subclasses to define the logic for deleting cache data from the storage.
+
+        Args:
+            key (str | list[str] | None): The key(s) to delete the cache data.
+
+        Raises:
+            NotImplementedError: If the method is not implemented.
+        """
+    @abstractmethod
+    def clear(self) -> None:
+        """Clears all cache data from the storage.
+
+        This method must be implemented by the subclasses to define the logic for clearing all cache data from the
+        storage.
+
+        Args:
+            None
+
+        Raises:
+            NotImplementedError: If the method is not implemented.
+        """
+    def cache(self, key_func: Callable[P, str] | None = None, name: str = '', ttl: int | str | None = None) -> Callable[[Callable[P, T]], Callable[P, T]]:
+        '''Decorator for caching function results.
+
+        This decorator caches the results of the decorated function using this cache storage.
+        The cache key is generated using the provided key function or a default key generation
+        based on the function name and arguments.
+
+        Synchronous and asynchronous functions are supported.
+
+        Args:
+            key_func (Callable[P, str] | None, optional): Function to generate cache keys.
+                Must accept the same parameters as the decorated function.
+            name (str, optional): Name to use in the default key generation if key_func is None.
+            ttl (int | str | None, optional): The time-to-live for the cached data. Can be an integer
+                in seconds or a string (e.g. "1h", "1d", "1w", "1y"). If None, the cache data will not expire.
+                Defaults to None. In this case, the cache will not expire.
+
+        Example:
+            ```python
+            def get_user_cache_key(user_id: int) -> str:
+                return f"user:{user_id}"
+
+            @cache_store.cache(key_func=get_user_cache_key, ttl="1h")
+            async def get_user(user_id: int) -> User:
+                return await db.get_user(user_id)
+
+            # will use/store cache with key "user:1", expiring after 1 hour
+            user1 = await get_user(1)
+            ```
+
+        Returns:
+            Callable: A decorator function.
+        '''

gllm_datastore/cache_data_store/cache_data_store_utils.pyi

@@ -0,0 +1 @@
+from gllm_datastore.cache_data_store.utils import *

gllm_datastore/cache_data_store/file_system_cache_data_store.pyi

@@ -0,0 +1,62 @@
+from _typeshed import Incomplete
+from gllm_datastore.cache_data_store.cache_data_store import BaseCacheDataStore as BaseCacheDataStore, CacheMatchingStrategy as CacheMatchingStrategy
+
+class FileSystemCacheDataStore(BaseCacheDataStore):
+    '''A cache data store that stores data in the file system.
+
+    The `FileSystemCacheDataStore` class utilizes the file system to store cache data.
+
+    Attributes:
+        cache_dir (str): The directory to store the cache data.
+        cache_version (str): The version of the cache data.
+        current_version_dir (str): The directory to store the cache data for the current version.
+        serialization_format (str): The serialization format to use for storing the cache data.
+            The supported serialization formats are "json" and "pickle".
+        compression_extension (str): The extension to use for the compression of the cache data.
+        matching_strategy (CacheMatchingStrategy): The matching strategy to use.
+        logger (Logger): The logger to use for logging.
+        retrieval_method (Callable[[str], Any]): The method to retrieve cache data based on the matching strategy.
+        fuzzy_distance_ratio (float): The ratio of key length to use as maximum Levenshtein distance
+            for fuzzy matching (e.g., 0.05 means 5% of key length). Must be between 0 and 1.
+    '''
+    logger: Incomplete
+    cache_dir: Incomplete
+    cache_version: Incomplete
+    current_version_dir: Incomplete
+    serialization_format: Incomplete
+    compression_extension: Incomplete
+    def __init__(self, cache_dir: str, cache_version: str = '1.0.0', serialization_format: str = 'json', matching_strategy: CacheMatchingStrategy = ..., fuzzy_distance_ratio: float = 0.05) -> None:
+        '''Initializes a new instance of the FileSystemCacheDataStore class.
+
+        Args:
+            cache_dir (str): The directory to store the cache data.
+            cache_version (str, optional): The version of the cache data. Defaults to "1.0.0".
+            serialization_format (str, optional): The serialization format to use for storing the cache data.
+                The supported serialization formats are "json" and "pickle". Defaults to "json".
+            matching_strategy (CacheMatchingStrategy, optional): The matching strategy to use.
+                Defaults to CacheMatchingStrategy.EXACT.
+            fuzzy_distance_ratio (float, optional): The ratio of key length to use as maximum Levenshtein distance
+                for fuzzy matching (e.g., 0.05 means 5% of key length). Must be between 0 and 1. Defaults to 0.05.
+
+        Raises:
+            ValueError: If the serialization format is not supported.
+        '''
+    def retrieve_all_keys(self) -> list[str]:
+        """Retrieves all keys from the file system cache data store.
+
+        This method filters out and deletes any expired keys before returning the list.
+
+        Returns:
+            list[str]: A list of all keys in the file system cache data store.
+        """
+    def delete(self, key: str | list[str]) -> None:
+        """Deletes cache data from the file system cache data store.
+
+        Args:
+            key (str | list[str]): The key(s) to delete the cache data.
+
+        Raises:
+            Exception: If there's exist cache file that cannot be deleted.
+        """
+    def clear(self) -> None:
+        """Clears all cache data from the file system cache data store cahe directory."""

gllm_datastore/cache_data_store/in_memory_cache_data_store.pyi

@@ -0,0 +1,43 @@
+from _typeshed import Incomplete
+from gllm_datastore.cache_data_store.cache_data_store import BaseCacheDataStore as BaseCacheDataStore, CacheMatchingStrategy as CacheMatchingStrategy
+
+class InMemoryCacheDataStore(BaseCacheDataStore):
+    """A cache data store that stores data in an in-memory dictionary.
+
+    The `InMemoryCacheDataStore` class utilizes an in-memory dictionary to store the cache data.
+
+    Attributes:
+        in_memory_cache (dict[str, Any]): An in-memory dictionary to store the cache data.
+        retrieval_method (Callable[[str], Any]): The method to retrieve cache data based on the matching strategy.
+        fuzzy_distance_ratio (float): The ratio of key length to use as maximum Levenshtein distance
+            for fuzzy matching (e.g., 0.05 means 5% of key length). Must be between 0 and 1.
+    """
+    in_memory_cache: Incomplete
+    def __init__(self, matching_strategy: CacheMatchingStrategy = ..., fuzzy_distance_ratio: float = 0.05) -> None:
+        """Initializes a new instance of the InMemoryCacheDataStore class.
+
+        Args:
+            matching_strategy (CacheMatchingStrategy, optional): The matching strategy to use.
+                Defaults to CacheMatchingStrategy.EXACT.
+            fuzzy_distance_ratio (float, optional): The ratio of key length to use as maximum Levenshtein distance
+                for fuzzy matching (e.g., 0.05 means 5% of key length). Must be between 0 and 1. Defaults to 0.05.
+
+        Raises:
+            ValueError: If the fuzzy distance ratio is not between 0 and 1.
+        """
+    def retrieve_all_keys(self) -> list[str]:
+        """Retrieves all keys from the storage.
+
+        This method filters out and deletes any expired keys before returning the list.
+
+        Returns:
+            list[str]: A list of all keys in the storage.
+        """
+    def delete(self, key: str | list[str]) -> None:
+        """Deletes cache data from the storage.
+
+        Args:
+            key (str | list[str]): The key(s) to delete the cache data.
+        """
+    def clear(self) -> None:
+        """Clears all cache data from the storage."""

gllm_datastore/cache_data_store/redis_cache_data_store.pyi

@@ -0,0 +1,48 @@
+from _typeshed import Incomplete
+from gllm_datastore.cache_data_store.cache_data_store import BaseCacheDataStore as BaseCacheDataStore, CacheMatchingStrategy as CacheMatchingStrategy
+
+class RedisCacheDataStore(BaseCacheDataStore):
+    """A cache data store that stores data in Redis.
+
+    The `RedisCacheDataStore` class utilizes Redis to store the cache data.
+
+    Attributes:
+        client (StrictRedis): The Redis client.
+        retrieval_method (Callable[[str], Any]): The method to retrieve cache data based on the matching strategy.
+        fuzzy_distance_ratio (float): The ratio of key length to use as maximum Levenshtein distance
+            for fuzzy matching (e.g., 0.05 means 5% of key length). Must be between 0 and 1.
+    """
+    client: Incomplete
+    def __init__(self, host: str, port: int, password: str, db: int = 0, ssl: bool = False, matching_strategy: CacheMatchingStrategy = ..., fuzzy_distance_ratio: float = 0.05) -> None:
+        """Initializes a new instance of the RedisCacheDataStore class.
+
+        Args:
+            host (str): The host of the Redis server.
+            port (int): The port of the Redis server.
+            password (str): The password for the Redis server.
+            db (int, optional): The database number. Defaults to 0.
+            ssl (bool, optional): Whether to use SSL. Defaults to False.
+            matching_strategy (CacheMatchingStrategy, optional): The matching strategy to use.
+                Defaults to CacheMatchingStrategy.EXACT.
+            fuzzy_distance_ratio (float, optional): The ratio of key length to use as maximum Levenshtein distance
+                for fuzzy matching (e.g., 0.05 means 5% of key length). Must be between 0 and 1. Defaults to 0.05.
+
+        Raises:
+            ValueError: If the fuzzy distance ratio is not between 0 and 1.
+        """
+    def retrieve_all_keys(self) -> list[str]:
+        """Retrieves all keys from the storage.
+
+        This method filters out and deletes any expired keys before returning the list.
+
+        Returns:
+            list[str]: A list of all keys in the storage.
+        """
+    def delete(self, key: str | list[str]) -> None:
+        """Deletes cache data from the storage.
+
+        Args:
+            key (str | list[str]): The key(s) to delete the cache data.
+        """
+    def clear(self) -> None:
+        """Clears all cache data from the storage."""

gllm_datastore/cache_data_store/utils.pyi

@@ -0,0 +1,36 @@
+from _typeshed import Incomplete
+from typing import Any
+
+logger: Incomplete
+
+def generate_cache_key(input_: str, key_prefix: str = '') -> str:
+    '''Generate a cache key from the input string.
+
+    This function generates a cache key from the input string.
+    If the input is a valid file, the function will hash the file.
+    If the input is not a valid file, the function will hash the input string.
+
+    Args:
+        input_ (str): The input string to generate the cache key from.
+        key_prefix (str, optional): The prefix of the cache key. Defaults to "".
+
+    Returns:
+        str: The generated cache key.
+
+    Raises:
+        Exception: If the input file path exists but cannot be read.
+    '''
+def generate_key_from_func(func_name: str, *args: Any, **kwargs: Any) -> str:
+    """Generate a cache key based on function name and arguments.
+
+    The key is created by hashing the function name, positional arguments, and keyword arguments.
+    If the function name, positional arguments, or keyword arguments are modified, the cache key will change.
+
+    Args:
+        func_name (str): Name of the function being cached
+        *args (Any): Positional arguments passed to the function
+        **kwargs (Any): Keyword arguments passed to the function
+
+    Returns:
+        str: SHA-256 hash digest to be used as cache key
+    """

gllm_datastore/constants.pyi

@@ -0,0 +1,2 @@
+DEFAULT_TOP_K: int
+DEFAULT_REQUEST_TIMEOUT: int

gllm_datastore/graph_data_store/graph_data_store.pyi

@@ -0,0 +1,80 @@
+import abc
+from abc import ABC, abstractmethod
+from typing import Any
+
+class BaseGraphDataStore(ABC, metaclass=abc.ABCMeta):
+    """Abstract base class for a graph data store interface."""
+    @abstractmethod
+    def upsert_node(self, label: str, identifier_key: str, identifier_value: str, properties: dict[str, Any] | 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.
+        """
+    @abstractmethod
+    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) -> 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.
+        """
+    @abstractmethod
+    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.
+        """
+    @abstractmethod
+    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.
+        """
+    @abstractmethod
+    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.
+        """
+    @abstractmethod
+    def close(self) -> None:
+        """Close the graph data store."""
+
+class GraphDataStore(BaseGraphDataStore, metaclass=abc.ABCMeta):
+    """A graph data store interface.
+
+    This class is deprecated and will be removed in a future release. Use BaseGraphDataStore instead.
+    """

gllm_datastore/graph_data_store/graph_rag_data_store.pyi

@@ -0,0 +1,28 @@
+import abc
+from abc import ABC, abstractmethod
+from typing import Any
+
+class BaseGraphRAGDataStore(ABC, metaclass=abc.ABCMeta):
+    """Abstract base class for graph RAG data stores in the retrieval system.
+
+    This class defines the interface for all graph data store implementations.
+    """
+    @abstractmethod
+    def query(self, query: str, **kwargs: Any) -> Any:
+        """Query the graph RAG data store.
+
+        Args:
+            query (str): The query to be executed.
+            **kwargs (Any): Additional keyword arguments.
+
+        Returns:
+            Any: The result of the query.
+        """
+    @abstractmethod
+    def delete_by_document_id(self, document_id: str, **kwargs: Any) -> None:
+        """Delete nodes and edges by document ID.
+
+        Args:
+            document_id (str): The document ID.
+            **kwargs (Any): Additional keyword arguments.
+        """

gllm_datastore/graph_data_store/llama_index_graph_rag_data_store.pyi

@@ -0,0 +1,18 @@
+import abc
+from abc import ABC
+from gllm_datastore.graph_data_store.graph_rag_data_store import BaseGraphRAGDataStore as BaseGraphRAGDataStore
+from llama_index.core.graph_stores.types import PropertyGraphStore
+from typing import Any
+
+class LlamaIndexGraphRAGDataStore(PropertyGraphStore, BaseGraphRAGDataStore, ABC, metaclass=abc.ABCMeta):
+    """Abstract base class for a LlamaIndex graph RAG data store."""
+    def query(self, query: str, **kwargs: Any) -> Any:
+        """Query the graph RAG data store.
+
+        Args:
+            query (str): The query to be executed.
+            **kwargs (Any): Additional keyword arguments.
+
+        Returns:
+            Any: The result of the query.
+        """

gllm_datastore/graph_data_store/llama_index_neo4j_graph_rag_data_store.pyi

@@ -0,0 +1,26 @@
+from _typeshed import Incomplete
+from gllm_datastore.graph_data_store.llama_index_graph_rag_data_store import LlamaIndexGraphRAGDataStore as LlamaIndexGraphRAGDataStore
+from llama_index.graph_stores.neo4j import Neo4jPropertyGraphStore
+from typing import Any
+
+class LlamaIndexNeo4jGraphRAGDataStore(LlamaIndexGraphRAGDataStore, Neo4jPropertyGraphStore):
+    """Graph RAG data store for Neo4j. This class extends the Neo4jPropertyGraphStore class from LlamaIndex.
+
+    Attributes:
+        neo4j_version_tuple (tuple[int, ...]): The Neo4j version tuple.
+    """
+    neo4j_version_tuple: Incomplete
+    def __init__(self, *args, **kwargs) -> None:
+        """Initialize the LlamaIndexNeo4jGraphRAGDataStore.
+
+        Args:
+            *args: Variable length argument list.
+            **kwargs: Arbitrary keyword arguments.
+        """
+    def delete_by_document_id(self, document_id: str, **kwargs: Any) -> None:
+        """Delete nodes and edges by document ID.
+
+        Args:
+            document_id (str): The document ID.
+            **kwargs (Any): Additional keyword arguments.
+        """

gllm_datastore/graph_data_store/nebula_graph_data_store.pyi

@@ -0,0 +1,112 @@
+from _typeshed import Incomplete
+from gllm_datastore.graph_data_store.graph_data_store import BaseGraphDataStore as BaseGraphDataStore
+from nebula3.gclient.net import Session as Session
+from typing import Any
+
+class NebulaGraphDataStore(BaseGraphDataStore):
+    """Implementation of BaseGraphDataStore for Nebula Graph.
+
+    Attributes:
+        connection_pool (ConnectionPool): The connection pool for Nebula Graph.
+        space (str): The space name.
+        user (str): The username.
+        password (str): The password.
+        operation_wait_time (int): The timeout in seconds.
+    """
+    connection_pool: Incomplete
+    space: Incomplete
+    user: Incomplete
+    password: Incomplete
+    operation_wait_time: Incomplete
+    def __init__(self, url: str, port: int, user: str, password: str, space: str, operation_wait_time: int = 5) -> None:
+        """Initialize NebulaGraphDataStore.
+
+        Args:
+            url (str): The URL of the graph store.
+            port (int): The port of the graph store.
+            user (str): The user of the graph store.
+            password (str): The password of the graph store.
+            space (str): The space name.
+            operation_wait_time (int, optional): The operation wait time in seconds. Defaults to 5.
+        """
+    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."""
+    def get_nodes(self, label: str | None = None) -> list[dict[str, Any]]:
+        """Get all nodes with optional label filter.
+
+        Args:
+            label (str | None, optional): The label of the nodes. Defaults to None.
+
+        Returns:
+            list[dict[str, Any]]: The result of the query.
+        """
+    def get_relationships(self, source_value: str | None = None, relation: str | None = None) -> list[dict[str, Any]]:
+        """Get relationships with optional filters.
+
+        Args:
+            source_value (str | None, optional): The source vertex identifier. Defaults to None.
+            relation (str | None, optional): The relationship type. Defaults to None.
+
+        Returns:
+            list[dict[str, Any]]: The result of the query.
+        """