gllm-datastore-binary 0.5.50__cp312-cp312-macosx_13_0_arm64.whl

gllm_datastore/graph_data_store/mixins/agentic_graph_tools_mixin.pyi

@@ -0,0 +1,175 @@
+from abc import ABC, abstractmethod
+from gllm_core.schema import Node as Node
+from gllm_datastore.graph_data_store.schema import RelationshipDirection as RelationshipDirection, SearchPosition as SearchPosition, Triplet as Triplet
+from typing import Any
+
+class AgenticGraphToolsMixin(ABC):
+    """Mixin class providing agentic graph tools for graph exploration.
+
+    This mixin adds methods for graph database operations including:
+    - Safe query execution (read-only)
+    - Neighborhood exploration
+    - Node and relationship search
+    - Context-sensitive autocomplete
+
+    Note: Base query() method remains unchanged and allows write operations
+    read_only_query() provides read-only guarantee for safety-critical scenarios
+    """
+    @abstractmethod
+    async def read_only_query(self, query: str, parameters: dict[str, Any] | None = None, max_results: int = 100, timeout: int = 60) -> list[dict[str, Any]]:
+        """Execute a validated read-only query.
+
+        Differentiates from base query() by enforcing read-only validation
+        Base query() allows write operations (CREATE, DELETE, MERGE, SET, REMOVE)
+        This method blocks all write operations for safety
+
+        Args:
+            query (str): Query string to execute.
+            parameters (dict[str, Any] | None, optional): Query parameters. Defaults to None.
+            max_results (int, optional): Maximum results to return. Defaults to 100.
+            timeout (int, optional): Query timeout in seconds. Defaults to 60.
+
+        Returns:
+            list[dict[str, Any]]: List of result dictionaries.
+
+        Raises:
+            NotImplementedError: This is an abstract method that must be implemented by subclasses.
+        """
+    @abstractmethod
+    async def get_neighborhood(self, node_id: str | None = None, relationship_type: str | None = None, target_node_id: str | None = None, limit: int = 10) -> list[Triplet]:
+        """Get graph patterns matching partial constraints.
+
+        Provide at least one of: node_id, relationship_type, or target_node_id
+        Returns up to N diverse patterns to help understand graph structure
+
+        This method differs from traverse() in base graph_data_store
+        - traverse() follows a specific path through the graph from a starting node
+        - get_neighborhood() discovers patterns matching given constraints without
+          requiring a specific traversal path or starting point.
+
+        Args:
+            node_id (str | None, optional): Source node ID (property-based). Defaults to None.
+            relationship_type (str | None, optional): Relationship type to filter by. Defaults to None.
+            target_node_id (str | None, optional): Target node ID (property-based). Defaults to None.
+            limit (int, optional): Maximum number of patterns to return. Defaults to 10.
+
+        Returns:
+            list[Triplet]: List of triplets containing source-relationship-target patterns.
+
+        Raises:
+            NotImplementedError: This is an abstract method that must be implemented by subclasses.
+        """
+    @abstractmethod
+    async def search_node(self, query: str, node_label: str | None = None, limit: int = 10) -> list[Node]:
+        """Search for nodes using substring matching.
+
+        Searches across common properties like id, name, title, description
+        Uses case-insensitive substring matching
+
+        Args:
+            query (str): Search query string.
+            node_label (str | None, optional): Optional node label to filter by. Defaults to None.
+            limit (int, optional): Maximum number of results to return. Defaults to 10.
+
+        Returns:
+            list[Node]: List of matching nodes.
+
+        Raises:
+            NotImplementedError: This is an abstract method that must be implemented by subclasses.
+        """
+    @abstractmethod
+    async def search_relationship(self, query: str, node_label: str | None = None, limit: int = 10) -> list[Triplet]:
+        """Search for relationship types using substring matching.
+
+        Returns relationship types that exist in graph with usage counts
+        Helps avoid hallucinating relationship types
+
+        Args:
+            query (str): Search query string.
+            node_label (str | None, optional): Optional node label to filter relationships. Defaults to None.
+            limit (int, optional): Maximum number of results to return. Defaults to 10.
+
+        Returns:
+            list[Triplet]: List of triplets representing relationship types found in the graph.
+
+        Raises:
+            NotImplementedError: This is an abstract method that must be implemented by subclasses.
+        """
+    @abstractmethod
+    async def search_rel_of_node(self, query: str, node_id: str, direction: RelationshipDirection = ..., limit: int = 10) -> list[Triplet]:
+        """Search for relationship types for a specific node.
+
+        More context-sensitive than general relationship search
+        Only returns relationships that connect to the given node
+
+        Args:
+            query (str): Search query string.
+            node_id (str, optional): Node ID to search relationships for. Defaults to None.
+            direction (RelationshipDirection, optional): Relationship direction. Defaults to BOTH.
+            limit (int, optional): Maximum number of results to return. Defaults to 10.
+
+        Returns:
+            list[Triplet]: List of triplets for the node.
+
+        Raises:
+            NotImplementedError: This is an abstract method that must be implemented by subclasses.
+        """
+    @abstractmethod
+    async def search_target_of_rel(self, query: str, relationship_type: str, source_node_id: str | None = None, limit: int = 10) -> list[Node]:
+        """Search for target nodes reachable via relationship type.
+
+        If source_node_id provided, finds targets from that node only
+        Otherwise finds all nodes reachable via relationship type
+
+        Args:
+            query (str): Search query string.
+            relationship_type (str, optional): Relationship type to traverse. Defaults to None.
+            source_node_id (str | None, optional): Optional source node to start from. Defaults to None.
+            limit (int, optional): Maximum number of results to return. Defaults to 10.
+
+        Returns:
+            list[Node]: List of target nodes matching query.
+
+        Raises:
+            NotImplementedError: This is an abstract method that must be implemented by subclasses.
+        """
+    @abstractmethod
+    async def search_autocomplete(self, query: str, query_pattern: str, search_var: str, limit: int = 10) -> list[Node]:
+        """Context-sensitive search constrained by query pattern.
+
+        Executes a partial query pattern and searches for nodes.
+        that can be bound to search_var. Pattern provides context.
+
+        Args:
+            query (str): Search query string.
+            query_pattern (str, optional): Partial query with variable placeholder. Defaults to None.
+            search_var (str, optional): Variable name to search for (e.g., 'company'). Defaults to None.
+            limit (int, optional): Maximum number of results to return. Defaults to 10.
+
+        Returns:
+            list[Node]: List of nodes matching query within pattern context.
+
+        Raises:
+            NotImplementedError: This is an abstract method that must be implemented by subclasses.
+        """
+    @abstractmethod
+    async def search_constrained(self, query: str, position: SearchPosition, source_node_id: str | None = None, relationship_type: str | None = None, target_node_id: str | None = None, limit: int = 10) -> list[Node] | list[Triplet]:
+        """Search for items in pattern position under constraints.
+
+        Build a pattern with constraints and search for items in specified position (source, relationship, or target).
+
+        Args:
+            query (str): Search query string.
+            position (SearchPosition): What to search for (SOURCE, RELATIONSHIP, or TARGET).
+            source_node_id (str | None, optional): Constraint on source node. Defaults to None.
+            relationship_type (str | None, optional): Constraint on relationship type. Defaults to None.
+            target_node_id (str | None, optional): Constraint on target node. Defaults to None.
+            limit (int, optional): Maximum number of results to return. Defaults to 10.
+
+        Returns:
+            list[Node] | list[Triplet]: List of nodes (if position is SOURCE/TARGET).
+                or triplets (if position is RELATIONSHIP).
+
+        Raises:
+            NotImplementedError: This is an abstract method that must be implemented by subclasses.
+        """

gllm_datastore/graph_data_store/nebula_graph_data_store.pyi

@@ -0,0 +1,206 @@
+from _typeshed import Incomplete
+from gllm_datastore.graph_data_store.graph_data_store import BaseGraphDataStore as BaseGraphDataStore
+from typing import Any
+
+class NebulaGraphDataStore(BaseGraphDataStore):
+    '''Implementation of BaseGraphDataStore for Nebula Graph.
+
+    This class provides an interface for graph-based Retrieval-Augmented Generation (RAG)
+    operations on Nebula graph databases.
+
+    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.
+
+    Example:
+        ```python
+        store = NebulaGraphDataStore(
+            url="127.0.0.1",
+            port=9669,
+            user="root",
+            password="nebula",
+            space="testing"
+        )
+        # Perform query
+        results = await store.query("MATCH (n) RETURN n")
+
+        # Create a node
+        node = await store.upsert_node("Person", "name", "John", {"age": 30})
+        ```
+    '''
+    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.
+        """
+    async 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.
+        """
+    async 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.
+        """
+    async 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.
+        """
+    async 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.
+        """
+    async 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.
+        """
+    async def traverse_graph(self, node_properties: dict[str, Any], extracted_node_properties: list[str] | None = None, extracted_relationship_properties: list[str] | None = None, depth: int = 3) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+        '''Traverse graph from a node with specified properties, ignoring relationship\'s direction, up to a given depth.
+
+        Example:
+            ```python
+            nodes, relationships = await graph_data_store.traverse_graph(
+                node_properties={"name": "John Doe"},
+                extracted_node_properties=["name", "age"],
+                extracted_relationship_properties=["since"],
+                depth=1
+            )
+            ```
+            Means starting from the node with property `name` equal to "John Doe", traverse
+            the graph up to depth 1, extracting the `name` and `age` properties from nodes
+            and the `since` property from relationships.
+
+            ```python
+            nodes, relationships = await graph_data_store.traverse_graph(
+                node_properties={"name": "John Doe"},
+                depth=2
+            )
+            ```
+            Means starting from the node with property `name` equal to "John Doe", traverse
+            the graph up to depth 2, extracting all properties from nodes and relationships.
+
+        Args:
+            node_properties (dict[str, Any]): The properties of the starting node.
+            extracted_node_properties (list[str] | None, optional): The properties to extract from nodes during
+                traversal. If None or empty list, all node properties will be returned. Defaults to None.
+            extracted_relationship_properties (list[str] | None, optional): The properties to extract from relationships
+                during traversal. If None or empty list, all relationship properties will be returned. Defaults to None.
+            depth (int, optional): The depth of traversal. Defaults to 3.
+
+        Returns:
+            tuple[list[dict[str, Any]], list[dict[str, Any]]]: A tuple containing two lists:
+                - List of nodes with their extracted properties (including the source node).
+                - List of relationships with their extracted properties.
+
+            Example return value:
+            nodes = [
+                {
+                    "id": 1001,
+                    "labels": ["Person"],
+                    "properties": {
+                        "name": "John Doe",
+                        "age": 30,
+                        "occupation": "Engineer"
+                    }
+                },
+                {
+                    "id": 2001,
+                    "labels": ["Company"],
+                    "properties": {
+                        "name": "TechCorp",
+                        "industry": "Technology",
+                        "employees": 500
+                    }
+                }
+            ]
+
+            relationships = [
+                {
+                    "id": 5002,
+                    "type": "FRIEND_OF",
+                    "start_node": 1001,
+                    "end_node": 1002,
+                    "properties": {
+                        "since": "2018-05-20",
+                        "closeness": 8
+                    }
+                }
+            ]
+
+        Raises:
+            ValueError: If node_properties is empty or depth is less than 1.
+        '''
+    async def close(self) -> None:
+        """Close the graph data store."""
+    async 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.
+        """
+    async 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.
+        """

gllm_datastore/graph_data_store/neo4j_graph_data_store.pyi

@@ -0,0 +1,182 @@
+from _typeshed import Incomplete
+from gllm_core.utils.retry import RetryConfig
+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.
+
+    This class provides an interface for graph-based Retrieval-Augmented Generation (RAG)
+    operations on Neo4j graph databases.
+
+    Attributes:
+        driver (Driver): The Neo4j driver.
+
+    Example:
+        ```python
+        store = Neo4jGraphDataStore(
+            uri="bolt://localhost:7687",
+            user="neo4j",
+            password="password"
+        )
+        # Perform async operations
+        results = await store.query("MATCH (n) RETURN n")
+
+        # Create a node
+        node = await store.upsert_node("Person", "name", "John", {"age": 30})
+        ```
+    '''
+    driver: Incomplete
+    retry_config: Incomplete
+    def __init__(self, uri: str, user: str, password: str, max_connection_pool_size: int = 100, retry_config: RetryConfig | None = None, **kwargs: Any) -> 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.
+            max_connection_pool_size (int, optional): The maximum size of the connection pool. Defaults to 100.
+            retry_config (RetryConfig | None, optional): Configuration for retry behavior. Defaults to None.
+                If provided, query operations will be retried according to the specified RetryConfig parameters.
+                When a database operation fails with a retryable exception (e.g., neo4j.exceptions.ServiceUnavailable),
+                the operation will be automatically retried based on the retry policy defined in the configuration.
+            **kwargs (Any): Additional keyword arguments for the driver.
+        """
+    async 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.
+        """
+    async 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.
+        """
+    async 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.
+        """
+    async 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.
+        """
+    async 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.
+        """
+    async def traverse_graph(self, node_properties: dict[str, Any], extracted_node_properties: list[str] | None = None, extracted_relationship_properties: list[str] | None = None, depth: int = 3) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+        '''Traverse graph from a node with specified properties, ignoring relationship\'s direction, up to a given depth.
+
+        Example:
+            ```python
+            nodes, relationships = await graph_data_store.traverse_graph(
+                node_properties={"name": "John Doe"},
+                extracted_node_properties=["name", "age"],
+                extracted_relationship_properties=["since"],
+                depth=1
+            )
+            ```
+            Means starting from the node with property `name` equal to "John Doe", traverse
+            the graph up to depth 1, extracting the `name` and `age` properties from nodes
+            and the `since` property from relationships.
+
+            ```python
+            nodes, relationships = await graph_data_store.traverse_graph(
+                node_properties={"name": "John Doe"},
+                depth=2
+            )
+            ```
+            Means starting from the node with property `name` equal to "John Doe", traverse
+            the graph up to depth 2, extracting all properties from nodes and relationships.
+
+        Args:
+            node_properties (dict[str, Any]): The properties of the starting node.
+            extracted_node_properties (list[str] | None, optional): The properties to extract from nodes during
+                traversal. If None or empty list, all node properties will be returned. Defaults to None.
+            extracted_relationship_properties (list[str] | None, optional): The properties to extract from relationships
+                during traversal. If None or empty list, all relationship properties will be returned. Defaults to None.
+            depth (int, optional): The depth of traversal. Defaults to 3.
+
+        Returns:
+            tuple[list[dict[str, Any]], list[dict[str, Any]]]: A tuple containing two lists:
+                - List of nodes with their extracted properties (including the source node).
+                - List of relationships with their extracted properties.
+
+            Example return value:
+            nodes = [
+                {
+                    "id": 1001,
+                    "labels": ["Person"],
+                    "properties": {
+                        "name": "John Doe",
+                        "age": 30,
+                        "occupation": "Engineer"
+                    }
+                },
+                {
+                    "id": 2001,
+                    "labels": ["Company"],
+                    "properties": {
+                        "name": "TechCorp",
+                        "industry": "Technology",
+                        "employees": 500
+                    }
+                }
+            ]
+
+            relationships = [
+                {
+                    "id": 5002,
+                    "type": "FRIEND_OF",
+                    "start_node": 1001,
+                    "end_node": 1002,
+                    "properties": {
+                        "since": "2018-05-20",
+                        "closeness": 8
+                    }
+                }
+            ]
+
+        Raises:
+            ValueError: If node_properties is empty or depth is less than 1.
+        '''
+    async def close(self) -> None:
+        """Close the graph data store."""

gllm_datastore/graph_data_store/schema.pyi

@@ -0,0 +1,27 @@
+from enum import StrEnum
+from gllm_core.schema.graph import Edge, Node
+from pydantic import BaseModel
+
+class RelationshipDirection(StrEnum):
+    """Direction for relationship traversal."""
+    OUTGOING: str
+    INCOMING: str
+    BOTH: str
+
+class SearchPosition(StrEnum):
+    """Position in a graph pattern for constrained search."""
+    SOURCE: str
+    RELATIONSHIP: str
+    TARGET: str
+
+class Triplet(BaseModel):
+    """Graph triplet pattern (source-relationship-target).
+
+    Attributes:
+        source (Node): Source node.
+        relationship (Edge): A directed relationship from source to target.
+        target (Node): Target node.
+    """
+    source: Node
+    relationship: Edge
+    target: Node

gllm_datastore/graph_data_store/utils/__init__.pyi

@@ -0,0 +1,6 @@
+from gllm_datastore.graph_data_store.utils.light_rag_em_invoker_adapter import LightRAGEMInvokerAdapter as LightRAGEMInvokerAdapter
+from gllm_datastore.graph_data_store.utils.light_rag_lm_invoker_adapter import LightRAGLMInvokerAdapter as LightRAGLMInvokerAdapter
+from gllm_datastore.graph_data_store.utils.llama_index_em_invoker_adapter import LlamaIndexEMInvokerAdapter as LlamaIndexEMInvokerAdapter
+from gllm_datastore.graph_data_store.utils.llama_index_lm_invoker_adapter import LlamaIndexLMInvokerAdapter as LlamaIndexLMInvokerAdapter
+
+__all__ = ['LightRAGEMInvokerAdapter', 'LightRAGLMInvokerAdapter', 'LlamaIndexEMInvokerAdapter', 'LlamaIndexLMInvokerAdapter']

gllm_datastore/graph_data_store/utils/constants.pyi

@@ -0,0 +1,21 @@
+class LightRAGKeys:
+    """Keys used in LightRAG indexer."""
+    ENTITY_TYPE: str
+    ENTITY_ID: str
+    SOURCE_ID: str
+    ROLE: str
+    CONTENT: str
+
+class LightRAGConstants:
+    """Constants used in LightRAG indexer."""
+    CHUNK_TYPE: str
+    DEVELOPER_ROLE: str
+    EMBEDDING_PAYLOAD_TEST: str
+    FILE_TYPE: str
+
+class LightRAGPostgresStorageConstants:
+    """Constants used in LightRAG indexer with PostgreSQL storage."""
+    DOC_STATUS_STORAGE: str
+    GRAPH_STORAGE: str
+    KV_STORAGE: str
+    VECTOR_STORAGE: str

gllm_datastore/graph_data_store/utils/light_rag_em_invoker_adapter.pyi

@@ -0,0 +1,56 @@
+from _typeshed import Incomplete
+from gllm_datastore.graph_data_store.utils.constants import LightRAGConstants as LightRAGConstants
+from gllm_inference.em_invoker.em_invoker import BaseEMInvoker
+from lightrag.base import EmbeddingFunc
+
+class LightRAGEMInvokerAdapter(EmbeddingFunc):
+    """Adapter for embedding model invokers to work with LightRAG.
+
+    This adapter wraps BaseEMInvoker instances to make them compatible
+    with LightRAG's expected interface.
+
+    Attributes:
+        _em_invoker (BaseEMInvoker): The EM invoker to use.
+        func (callable): The embedding function.
+        embedding_dim (int): The embedding dimension. Defaults to 0.
+    """
+    func: Incomplete
+    embedding_dim: int
+    def __init__(self, em_invoker: BaseEMInvoker) -> None:
+        """Initialize the LightRAGEMInvokerAdapter.
+
+        Args:
+            em_invoker (BaseEMInvoker): The EM invoker to use.
+        """
+    async def ensure_initialized(self) -> None:
+        """Ensure that the adapter is initialized.
+
+        This asynchronous method ensures that the embedding dimension is determined.
+        If the embedding dimension is 0, it will determine the dimension by calling
+        the embedding invoker with a test input. Raises an error if initialization fails.
+
+        Raises:
+            RuntimeError: If embedding dimension cannot be determined after initialization.
+        """
+    def __deepcopy__(self, memo: dict) -> LightRAGEMInvokerAdapter:
+        """Custom deepcopy implementation to handle non-serializable objects.
+
+        This method is called when copy.deepcopy() is invoked on this object.
+        We create a new instance without deep-copying the invoker object
+        which may contain non-serializable components.
+
+        Args:
+            memo (dict): Memoization dictionary for deepcopy process
+
+        Returns:
+            LightRAGEMInvokerAdapter: A new instance with the same invoker reference
+        """
+    async def __call__(self, input: str | list[str]) -> list[list[float]]:
+        """Make the adapter callable for compatibility with LightRAG.
+
+        Args:
+            input (str | list[str]): The input text or list of texts to embed.
+
+        Returns:
+            list[list[float]]: The embeddings for the input texts.
+        """