ag2 0.9.1a1__py3-none-any.whl → 0.9.2__py3-none-any.whl

autogen/agentchat/contrib/graph_rag/falkor_graph_query_engine.py

@@ -0,0 +1,170 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+import warnings
+from typing import Any, Optional
+
+from ....import_utils import optional_import_block, require_optional_import
+from .document import Document
+from .graph_query_engine import GraphStoreQueryResult
+
+with optional_import_block():
+    from falkordb import FalkorDB, Graph
+    from graphrag_sdk import KnowledgeGraph, Source
+    from graphrag_sdk.model_config import KnowledgeGraphModelConfig
+    from graphrag_sdk.models import GenerativeModel
+    from graphrag_sdk.models.openai import OpenAiGenerativeModel
+    from graphrag_sdk.ontology import Ontology
+
+
+@require_optional_import(["falkordb", "graphrag_sdk"], "graph-rag-falkor-db")
+class FalkorGraphQueryEngine:
+    """This is a wrapper for FalkorDB KnowledgeGraph."""
+
+    def __init__(  # type: ignore[no-any-unimported]
+        self,
+        name: str,
+        host: str = "127.0.0.1",
+        port: int = 6379,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        model: Optional["GenerativeModel"] = None,
+        ontology: Optional["Ontology"] = None,
+    ):
+        """Initialize a FalkorDB knowledge graph.
+        Please also refer to https://github.com/FalkorDB/GraphRAG-SDK/blob/main/graphrag_sdk/kg.py
+
+        TODO: Fix LLM API cost calculation for FalkorDB usages.
+
+        Args:
+            name (str): Knowledge graph name.
+            host (str): FalkorDB hostname.
+            port (int): FalkorDB port number.
+            username (str|None): FalkorDB username.
+            password (str|None): FalkorDB password.
+            model (GenerativeModel): LLM model to use for FalkorDB to build and retrieve from the graph, default to use OAI gpt-4o.
+            ontology: FalkorDB knowledge graph schema/ontology, https://github.com/FalkorDB/GraphRAG-SDK/blob/main/graphrag_sdk/ontology.py
+                If None, FalkorDB will auto generate an ontology from the input docs.
+        """
+        self.name = name
+        self.ontology_table_name = name + "_ontology"
+        self.host = host
+        self.port = port
+        self.username = username
+        self.password = password
+        self.model = model or OpenAiGenerativeModel("gpt-4o")
+        self.model_config = KnowledgeGraphModelConfig.with_model(model)
+        self.ontology = ontology
+        self.knowledge_graph: Optional["KnowledgeGraph"] = None  # type: ignore[no-any-unimported]
+        self.falkordb = FalkorDB(host=self.host, port=self.port, username=self.username, password=self.password)
+
+    def connect_db(self) -> None:
+        """Connect to an existing knowledge graph."""
+        if self.name in self.falkordb.list_graphs():
+            try:
+                self.ontology = self._load_ontology_from_db()
+            except Exception:
+                warnings.warn("Graph Ontology is not loaded.")
+
+            if self.ontology is None:
+                raise ValueError(f"Ontology of the knowledge graph '{self.name}' can't be None.")
+
+            self.knowledge_graph = KnowledgeGraph(
+                name=self.name,
+                host=self.host,
+                port=self.port,
+                username=self.username,
+                password=self.password,
+                model_config=self.model_config,
+                ontology=self.ontology,
+            )
+
+            # Establishing a chat session will maintain the history
+            self._chat_session = self.knowledge_graph.chat_session()
+        else:
+            raise ValueError(f"Knowledge graph '{self.name}' does not exist")
+
+    def init_db(self, input_doc: list[Document]) -> None:
+        """Build the knowledge graph with input documents."""
+        sources = []
+        for doc in input_doc:
+            if doc.path_or_url and os.path.exists(doc.path_or_url):
+                sources.append(Source(doc.path_or_url))
+
+        if sources:
+            # Auto generate graph ontology if not created by user.
+            if self.ontology is None:
+                self.ontology = Ontology.from_sources(
+                    sources=sources,
+                    model=self.model,
+                )
+            # Save Ontology to graph for future access.
+            self._save_ontology_to_db(self.ontology)
+
+            self.knowledge_graph = KnowledgeGraph(
+                name=self.name,
+                host=self.host,
+                port=self.port,
+                username=self.username,
+                password=self.password,
+                model_config=KnowledgeGraphModelConfig.with_model(self.model),
+                ontology=self.ontology,
+            )
+
+            self.knowledge_graph.process_sources(sources)
+
+            # Establishing a chat session will maintain the history
+            self._chat_session = self.knowledge_graph.chat_session()
+        else:
+            raise ValueError("No input documents could be loaded.")
+
+    def add_records(self, new_records: list[Document]) -> bool:
+        raise NotImplementedError("This method is not supported by FalkorDB SDK yet.")
+
+    def query(self, question: str, n_results: int = 1, **kwargs: Any) -> GraphStoreQueryResult:
+        """Query the knowledge graph with a question and optional message history.
+
+        Args:
+        question: a human input question.
+        n_results: number of returned results.
+        kwargs:
+            messages: a list of message history.
+
+        Returns: FalkorGraphQueryResult
+        """
+        if self.knowledge_graph is None:
+            raise ValueError("Knowledge graph has not been selected or created.")
+
+        response = self._chat_session.send_message(question)
+
+        # History will be considered when querying by setting the last_answer
+        self._chat_session.last_answer = response["response"]
+
+        return GraphStoreQueryResult(answer=response["response"], results=[])
+
+    def delete(self) -> bool:
+        """Delete graph and its data from database."""
+        all_graphs = self.falkordb.list_graphs()
+        if self.name in all_graphs:
+            self.falkordb.select_graph(self.name).delete()
+        if self.ontology_table_name in all_graphs:
+            self.falkordb.select_graph(self.ontology_table_name).delete()
+        return True
+
+    def __get_ontology_storage_graph(self) -> "Graph":  # type: ignore[no-any-unimported]
+        return self.falkordb.select_graph(self.ontology_table_name)
+
+    def _save_ontology_to_db(self, ontology: "Ontology") -> None:  # type: ignore[no-any-unimported]
+        """Save graph ontology to a separate table with {graph_name}_ontology"""
+        if self.ontology_table_name in self.falkordb.list_graphs():
+            raise ValueError(f"Knowledge graph {self.name} is already created.")
+        graph = self.__get_ontology_storage_graph()
+        ontology.save_to_graph(graph)
+
+    def _load_ontology_from_db(self) -> "Ontology":  # type: ignore[no-any-unimported]
+        if self.ontology_table_name not in self.falkordb.list_graphs():
+            raise ValueError(f"Knowledge graph {self.name} has not been created.")
+        graph = self.__get_ontology_storage_graph()
+        return Ontology.from_graph(graph)

autogen/agentchat/contrib/graph_rag/falkor_graph_rag_capability.py

@@ -0,0 +1,103 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Optional, Union
+
+from .... import Agent, ConversableAgent
+from .falkor_graph_query_engine import FalkorGraphQueryEngine
+from .graph_query_engine import GraphStoreQueryResult
+from .graph_rag_capability import GraphRagCapability
+
+
+class FalkorGraphRagCapability(GraphRagCapability):
+    """The FalkorDB GraphRAG capability integrate FalkorDB with graphrag_sdk version: 0.1.3b0.
+    Ref: https://github.com/FalkorDB/GraphRAG-SDK/tree/2-move-away-from-sql-to-json-ontology-detection
+
+    For usage, please refer to example notebook/agentchat_graph_rag_falkordb.ipynb
+    """
+
+    def __init__(self, query_engine: FalkorGraphQueryEngine):
+        """Initialize GraphRAG capability with a graph query engine"""
+        self.query_engine = query_engine
+
+    def add_to_agent(self, agent: ConversableAgent) -> None:
+        """Add FalkorDB GraphRAG capability to a ConversableAgent.
+
+        Args:
+            agent: The ConversableAgent instance to add the capability to.
+
+        The restriction to a ConversableAgent to make sure the returned message does not contain information retrieved from the graph DB instead of any LLMs.
+
+        """
+        if not isinstance(agent, ConversableAgent):
+            raise Exception("FalkorDB GraphRAG capability can only be added to a ConversableAgent.")
+
+        self.graph_rag_agent = agent
+
+        # Validate the agent config
+        if agent.llm_config not in (None, False):
+            raise Exception(
+                "Agents with GraphRAG capabilities do not use an LLM configuration. Please set your llm_config to None or False."
+            )
+
+        # Register method to generate the reply using a FalkorDB query
+        # All other reply methods will be removed
+        agent.register_reply(
+            [ConversableAgent, None], self._reply_using_falkordb_query, position=0, remove_other_reply_funcs=True
+        )
+
+    def _reply_using_falkordb_query(
+        self,
+        recipient: ConversableAgent,
+        messages: Optional[list[dict[str, Any]]] = None,
+        sender: Optional[Agent] = None,
+        config: Optional[Any] = None,
+    ) -> tuple[bool, Optional[Union[str, dict[str, Any]]]]:
+        """Query FalkorDB and return the message. Internally, it utilises OpenAI to generate a reply based on the given messages.
+        The history with FalkorDB is also logged and updated.
+
+        The agent's system message will be incorporated into the query, if it's not blank.
+
+        If no results are found, a default message is returned: "I'm sorry, I don't have an answer for that."
+
+        Args:
+            recipient: The agent instance that will receive the message.
+            messages: A list of messages in the conversation history with the sender.
+            sender: The agent instance that sent the message.
+            config: Optional configuration for message processing.
+
+        Returns:
+            A tuple containing a boolean indicating success and the assistant's reply.
+        """
+        # todo: fix typing, this is not correct
+        question = self._messages_summary(messages, recipient.system_message)  # type: ignore[arg-type]
+        result: GraphStoreQueryResult = self.query_engine.query(question)
+
+        return True, result.answer if result.answer else "I'm sorry, I don't have an answer for that."
+
+    def _messages_summary(self, messages: Union[dict[str, Any], str], system_message: str) -> str:
+        """Summarize the messages in the conversation history. Excluding any message with 'tool_calls' and 'tool_responses'
+        Includes the 'name' (if it exists) and the 'content', with a new line between each one, like:
+        customer:
+        <content>
+
+        agent:
+        <content>
+        """
+        if isinstance(messages, str):
+            return (f"IMPORTANT: {system_message}\n" if system_message else "") + f"Context:\n\n{messages}"
+
+        elif isinstance(messages, list):
+            summary = ""
+            for message in messages:
+                if "content" in message and "tool_calls" not in message and "tool_responses" not in message:
+                    summary += f"{message.get('name', '')}: {message.get('content', '')}\n\n"
+
+            if system_message:
+                summary = f"IMPORTANT: {system_message}\nContext:\n\n{summary}"
+
+            return summary
+
+        else:
+            raise ValueError("Invalid messages format. Must be a list of messages or a string.")

autogen/agentchat/contrib/graph_rag/graph_query_engine.py

@@ -0,0 +1,53 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from https://github.com/microsoft/autogen are under the MIT License.
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any, Optional, Protocol, runtime_checkable
+
+from .document import Document
+
+__all__ = ["GraphQueryEngine", "GraphStoreQueryResult"]
+
+
+@dataclass
+class GraphStoreQueryResult:
+    """A wrapper of graph store query results.
+
+    answer: human readable answer to question/query.
+    results: intermediate results to question/query, e.g. node entities.
+    """
+
+    answer: Optional[str] = None
+    results: list[Any] = field(default_factory=list)
+
+
+@runtime_checkable
+class GraphQueryEngine(Protocol):
+    """An abstract base class that represents a graph query engine on top of a underlying graph database.
+
+    This interface defines the basic methods for graph-based RAG.
+    """
+
+    def init_db(self, input_doc: Optional[list[Document]] = None) -> None:
+        """This method initializes graph database with the input documents or records.
+        Usually, it takes the following steps,
+        1. connecting to a graph database.
+        2. extract graph nodes, edges based on input data, graph schema and etc.
+        3. build indexes etc.
+
+        Args:
+        input_doc: a list of input documents that are used to build the graph in database.
+
+        """
+        pass
+
+    def add_records(self, new_records: list[Any]) -> bool:
+        """Add new records to the underlying database and add to the graph if required."""
+        pass
+
+    def query(self, question: str, n_results: int = 1, **kwarg: Any) -> GraphStoreQueryResult:
+        """This method transform a string format question into database query and return the result."""
+        pass

autogen/agentchat/contrib/graph_rag/graph_rag_capability.py

@@ -0,0 +1,63 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from https://github.com/microsoft/autogen are under the MIT License.
+# SPDX-License-Identifier: MIT
+from ...conversable_agent import ConversableAgent
+from ..capabilities.agent_capability import AgentCapability
+from .graph_query_engine import GraphQueryEngine
+
+__all__ = ["GraphRagCapability"]
+
+
+class GraphRagCapability(AgentCapability):
+    """A graph-based RAG capability uses a graph query engine to give a conversable agent the graph-based RAG ability.
+
+    An agent class with graph-based RAG capability could
+    1. create a graph in the underlying database with input documents.
+    2. retrieved relevant information based on messages received by the agent.
+    3. generate answers from retrieved information and send messages back.
+
+    For example,
+    ```python
+    graph_query_engine = GraphQueryEngine(...)
+    graph_query_engine.init_db([Document(doc1), Document(doc2), ...])
+
+    graph_rag_agent = ConversableAgent(
+        name="graph_rag_agent",
+        max_consecutive_auto_reply=3,
+        ...
+    )
+    graph_rag_capability = GraphRagCapbility(graph_query_engine)
+    graph_rag_capability.add_to_agent(graph_rag_agent)
+
+    user_proxy = UserProxyAgent(
+        name="user_proxy",
+        code_execution_config=False,
+        is_termination_msg=lambda msg: "TERMINATE" in msg["content"],
+        human_input_mode="ALWAYS",
+    )
+    user_proxy.initiate_chat(graph_rag_agent, message="Name a few actors who've played in 'The Matrix'")
+
+    # ChatResult(
+        # chat_id=None,
+        # chat_history=[
+            # {'content': 'Name a few actors who've played in \'The Matrix\'', 'role': 'graph_rag_agent'},
+            # {'content': 'A few actors who have played in The Matrix are:
+            #   - Keanu Reeves
+            #   - Laurence Fishburne
+            #   - Carrie-Anne Moss
+            #   - Hugo Weaving',
+            #   'role': 'user_proxy'},
+        # ...)
+    ```
+    """
+
+    def __init__(self, query_engine: GraphQueryEngine) -> None:
+        """Initialize graph-based RAG capability with a graph query engine"""
+        ...
+
+    def add_to_agent(self, agent: ConversableAgent) -> None:
+        """Add the capability to an agent"""
+        ...

autogen/agentchat/contrib/graph_rag/neo4j_graph_query_engine.py

@@ -0,0 +1,268 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+import os
+import sys
+from typing import Any, Optional, Union
+
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
+
+from ....import_utils import optional_import_block, require_optional_import
+from .document import Document, DocumentType
+from .graph_query_engine import GraphStoreQueryResult
+
+with optional_import_block():
+    from llama_index.core import PropertyGraphIndex, SimpleDirectoryReader
+    from llama_index.core.base.embeddings.base import BaseEmbedding
+    from llama_index.core.chat_engine.types import ChatMode
+    from llama_index.core.indices.property_graph import (
+        DynamicLLMPathExtractor,
+        SchemaLLMPathExtractor,
+    )
+    from llama_index.core.indices.property_graph.transformations.schema_llm import Triple
+    from llama_index.core.llms import LLM
+    from llama_index.core.readers.json import JSONReader
+    from llama_index.core.schema import Document as LlamaDocument
+    from llama_index.core.schema import TransformComponent
+    from llama_index.embeddings.openai import OpenAIEmbedding
+    from llama_index.graph_stores.neo4j import Neo4jPropertyGraphStore
+    from llama_index.llms.openai import OpenAI
+
+
+@require_optional_import("llama_index", "neo4j")
+class Neo4jGraphQueryEngine:
+    """This class serves as a wrapper for a property graph query engine backed by LlamaIndex and Neo4j,
+    facilitating the creating, connecting, updating, and querying of LlamaIndex property graphs.
+
+    It builds a property graph Index from input documents,
+    storing and retrieving data from the property graph in the Neo4j database.
+
+    It extracts triplets, i.e., [entity] -> [relationship] -> [entity] sets,
+    from the input documents using llamIndex extractors.
+
+    Users can provide custom entities, relationships, and schema to guide the extraction process.
+
+    If strict is True, the engine will extract triplets following the schema
+    of allowed relationships for each entity specified in the schema.
+
+    It also leverages LlamaIndex's chat engine which has a conversation history internally to provide context-aware responses.
+
+    For usage, please refer to example notebook/agentchat_graph_rag_neo4j.ipynb
+    """
+
+    def __init__(  # type: ignore[no-any-unimported]
+        self,
+        host: str = "bolt://localhost",
+        port: int = 7687,
+        database: str = "neo4j",
+        username: str = "neo4j",
+        password: str = "neo4j",
+        llm: Optional["LLM"] = None,
+        embedding: Optional["BaseEmbedding"] = None,
+        entities: Optional["TypeAlias"] = None,
+        relations: Optional["TypeAlias"] = None,
+        schema: Optional[Union[dict[str, str], list["Triple"]]] = None,
+        strict: Optional[bool] = False,
+    ):
+        """Initialize a Neo4j Property graph.
+        Please also refer to https://docs.llamaindex.ai/en/stable/examples/property_graph/graph_store/
+
+        Args:
+            name (str): Property graph name.
+            host (str): Neo4j hostname.
+            port (int): Neo4j port number.
+            database (str): Neo4j database name.
+            username (str): Neo4j username.
+            password (str): Neo4j password.
+            llm (LLM): Language model to use for extracting triplets.
+            embedding (BaseEmbedding): Embedding model to use constructing index and query
+            entities (Optional[TypeAlias]): Custom suggested entities to include in the graph.
+            relations (Optional[TypeAlias]): Custom suggested relations to include in the graph.
+            schema (Optional[Union[Dict[str, str], List[Triple]]): Custom schema to specify allowed relationships for each entity.
+            strict (Optional[bool]): If false, allows for values outside of the input schema.
+        """
+        self.host = host
+        self.port = port
+        self.database = database
+        self.username = username
+        self.password = password
+        self.llm = llm or OpenAI(model="gpt-4o", temperature=0.0)
+        self.embedding = embedding or OpenAIEmbedding(model_name="text-embedding-3-small")
+        self.entities = entities
+        self.relations = relations
+        self.schema = schema
+        self.strict = strict
+
+    def init_db(self, input_doc: Optional[list[Document]] = None) -> None:
+        """Build the knowledge graph with input documents."""
+        self.documents = self._load_doc(input_doc if input_doc is not None else [])
+
+        self.graph_store = Neo4jPropertyGraphStore(
+            username=self.username,
+            password=self.password,
+            url=self.host + ":" + str(self.port),
+            database=self.database,
+        )
+
+        # delete all entities and relationships in case a graph pre-exists
+        self._clear()
+
+        # Create knowledge graph extractors.
+        self.kg_extractors = self._create_kg_extractors()
+
+        self.index = PropertyGraphIndex.from_documents(
+            self.documents,
+            llm=self.llm,
+            embed_model=self.embedding,
+            kg_extractors=self.kg_extractors,
+            property_graph_store=self.graph_store,
+            show_progress=True,
+        )
+
+    def connect_db(self) -> None:
+        """Connect to an existing knowledge graph database."""
+        self.graph_store = Neo4jPropertyGraphStore(
+            username=self.username,
+            password=self.password,
+            url=self.host + ":" + str(self.port),
+            database=self.database,
+        )
+
+        self.kg_extractors = self._create_kg_extractors()
+
+        self.index = PropertyGraphIndex.from_existing(
+            property_graph_store=self.graph_store,
+            kg_extractors=self.kg_extractors,
+            llm=self.llm,
+            embed_model=self.embedding,
+            show_progress=True,
+        )
+
+    def add_records(self, new_records: list[Document]) -> bool:
+        """Add new records to the knowledge graph. Must be local files.
+
+        Args:
+            new_records (List[Document]): List of new documents to add.
+
+        Returns:
+            bool: True if successful, False otherwise.
+        """
+        if self.graph_store is None:
+            raise ValueError("Knowledge graph is not initialized. Please call init_db or connect_db first.")
+
+        try:
+            """
+            SimpleDirectoryReader will select the best file reader based on the file extensions,
+            see  _load_doc for supported file types.
+            """
+            new_documents = SimpleDirectoryReader(input_files=[doc.path_or_url for doc in new_records]).load_data()
+
+            for doc in new_documents:
+                self.index.insert(doc)
+
+            return True
+        except Exception as e:
+            print(f"Error adding records: {e}")
+            return False
+
+    def query(self, question: str, n_results: int = 1, **kwargs: Any) -> GraphStoreQueryResult:
+        """Query the property graph with a question using LlamaIndex chat engine.
+        We use the condense_plus_context chat mode
+        which condenses the conversation history and the user query into a standalone question,
+        and then build a context for the standadlone question
+        from the property graph to generate a response.
+
+        Args:
+            question: a human input question.
+            n_results: number of results to return.
+            **kwargs: additional keyword arguments.
+
+        Returns:
+            A GrapStoreQueryResult object containing the answer and related triplets.
+        """
+        if not hasattr(self, "index"):
+            raise ValueError("Property graph index is not created.")
+
+        # Initialize chat engine if not already initialized
+        if not hasattr(self, "chat_engine"):
+            self.chat_engine = self.index.as_chat_engine(chat_mode=ChatMode.CONDENSE_PLUS_CONTEXT, llm=self.llm)
+
+        response = self.chat_engine.chat(question)
+        return GraphStoreQueryResult(answer=str(response))
+
+    def _clear(self) -> None:
+        """Delete all entities and relationships in the graph.
+        TODO: Delete all the data in the database including indexes and constraints.
+        """
+        with self.graph_store._driver.session() as session:
+            session.run("MATCH (n) DETACH DELETE n;")
+
+    def _load_doc(self, input_doc: list[Document]) -> list["LlamaDocument"]:  # type: ignore[no-any-unimported]
+        """Load documents from the input files. Currently support the following file types:
+        .csv - comma-separated values
+        .docx - Microsoft Word
+        .epub - EPUB ebook format
+        .hwp - Hangul Word Processor
+        .ipynb - Jupyter Notebook
+        .jpeg, .jpg - JPEG image
+        .mbox - MBOX email archive
+        .md - Markdown
+        .mp3, .mp4 - audio and video
+        .pdf - Portable Document Format
+        .png - Portable Network Graphics
+        .ppt, .pptm, .pptx - Microsoft PowerPoint
+        .json JSON files
+        """
+        for doc in input_doc:
+            if not os.path.exists(doc.path_or_url):  # type: ignore[arg-type]
+                raise ValueError(f"Document file not found: {doc.path_or_url}")
+
+        common_type_input_files = []
+        json_type_input_files = []
+        for doc in input_doc:
+            if doc.doctype is DocumentType.JSON:
+                json_type_input_files.append(doc.path_or_url)
+            else:
+                common_type_input_files.append(doc.path_or_url)
+        loaded_documents = []
+        if common_type_input_files:
+            loaded_documents.extend(SimpleDirectoryReader(input_files=common_type_input_files).load_data())
+        for json_file in json_type_input_files:
+            loaded_documents.extend(JSONReader().load_data(input_file=json_file))  # type: ignore[arg-type]
+
+        return loaded_documents
+
+    def _create_kg_extractors(self) -> list["TransformComponent"]:  # type: ignore[no-any-unimported]
+        """If strict is True,
+        extract paths following a strict schema of allowed relationships for each entity.
+
+        If strict is False,
+        auto-create relationships and schema that fit the graph
+
+        # To add more extractors, please refer to https://docs.llamaindex.ai/en/latest/module_guides/indexing/lpg_index_guide/#construction
+        """
+        #
+        kg_extractors: list["TransformComponent"] = [  # type: ignore[no-any-unimported]
+            SchemaLLMPathExtractor(
+                llm=self.llm,
+                possible_entities=self.entities,
+                possible_relations=self.relations,
+                kg_validation_schema=self.schema,
+                strict=self.strict if self.strict else False,
+            ),
+        ]
+
+        # DynamicLLMPathExtractor will auto-create relationships and schema that fit the graph
+        if not self.strict:
+            kg_extractors.append(
+                DynamicLLMPathExtractor(
+                    llm=self.llm,
+                    allowed_entity_types=self.entities,
+                    allowed_relation_types=self.relations,
+                )
+            )
+
+        return kg_extractors