langchain-timbr 1.5.0__py3-none-any.whl

langchain_timbr/langchain/validate_timbr_sql_chain.py

@@ -0,0 +1,187 @@
+from typing import Optional, Union, Dict, Any
+from langchain.chains.base import Chain
+from langchain.llms.base import LLM
+
+from ..utils.general import parse_list, to_integer, to_boolean
+from ..utils.timbr_llm_utils import generate_sql
+from ..utils.timbr_utils import validate_sql
+
+
+class ValidateTimbrSqlChain(Chain):
+    """
+    LangChain chain for validating SQL queries against Timbr knowledge graph schemas.
+    
+    This chain validates SQL queries to ensure they are syntactically correct and 
+    compatible with the target Timbr ontology/knowledge graph structure. It uses an LLM
+    for validation and connects to Timbr via URL and token.
+    """
+    
+    def __init__(
+        self,
+        llm: LLM,
+        url: str,
+        token: str,
+        ontology: str,
+        schema: Optional[str] = 'dtimbr',
+        concept: Optional[str] = None,
+        retries: Optional[int] = 3,
+        concepts_list: Optional[Union[list[str], str]] = None,
+        views_list: Optional[Union[list[str], str]] = None,
+        include_logic_concepts: Optional[bool] = False,
+        include_tags: Optional[Union[list[str], str]] = None,
+        exclude_properties: Optional[Union[list[str], str]] = ['entity_id', 'entity_type', 'entity_label'],
+        max_limit: Optional[int] = 500,
+        note: Optional[str] = '',
+        db_is_case_sensitive: Optional[bool] = False,
+        graph_depth: Optional[int] = 1,
+        verify_ssl: Optional[bool] = True,
+        is_jwt: Optional[bool] = False,
+        jwt_tenant_id: Optional[str] = None,
+        conn_params: Optional[dict] = None,
+        debug: Optional[bool] = False,
+        **kwargs,
+    ):
+        """
+        :param llm: An LLM instance or a function that takes a prompt string and returns the LLM’s response
+        :param url: Timbr server url
+        :param token: Timbr password or token value
+        :param ontology: The name of the ontology/knowledge graph
+        :param schema: The name of the schema to query
+        :param concept: The name of the concept to query
+        :param retries: The maximum number of retries to attempt
+        :param concepts_list: Optional specific concept options to query
+        :param views_list: Optional specific view options to query
+        :param include_logic_concepts: Optional boolean to include logic concepts (concepts without unique properties which only inherits from an upper level concept with filter logic) in the query. 
+        :param include_tags: Optional specific concepts & properties tag options to use in the query (Disabled by default. Use '*' to enable all tags or a string represents a list of tags divided by commas (e.g. 'tag1,tag2')
+        :param exclude_properties: Optional specific properties to exclude from the query (entity_id, entity_type & entity_label by default).
+        :param max_limit: Maximum number of rows to query
+        :param note: Optional additional note to extend our llm prompt
+        :param db_is_case_sensitive: Whether the database is case sensitive (default is False).
+        :param graph_depth: Maximum number of relationship hops to traverse from the source concept during schema exploration (default is 1).
+        :param verify_ssl: Whether to verify SSL certificates (default is True).
+        :param is_jwt: Whether to use JWT authentication (default is False).
+        :param jwt_tenant_id: JWT tenant ID for multi-tenant environments (required when is_jwt=True).
+        :param conn_params: Extra Timbr connection parameters sent with every request (e.g., 'x-api-impersonate-user').
+        :param kwargs: Additional arguments to pass to the base
+        
+        ## Example
+        ```
+        validate_timbr_sql_chain = ValidateTimbrSqlChain(
+            url=<url>,
+            token=<token>,
+            llm=<llm or timbr_llm_wrapper instance>,
+            ontology=<ontology_name>,
+            schema=<schema_name>,
+            concept=<concept_name>,
+            retries=<retries_number>,
+            concepts_list=<concepts>,
+            views_list=<views>,
+            include_tags=<tags>,
+            note=<note>,
+        )
+
+        return validate_timbr_sql_chain.invoke({ "prompt": question, "sql": <latest_query_to_validate> }).get("sql", [])
+        ```
+        """
+        super().__init__(**kwargs)
+        self._llm = llm
+        self._url = url
+        self._token = token
+        self._ontology = ontology
+        self._schema = schema
+        self._concept = concept
+        self._retries = retries
+        self._concepts_list = parse_list(concepts_list)
+        self._views_list = parse_list(views_list)
+        self._include_logic_concepts = to_boolean(include_logic_concepts)
+        self._include_tags = parse_list(include_tags)
+        self._exclude_properties = parse_list(exclude_properties)
+        self._max_limit = to_integer(max_limit)
+        self._note = note
+        self._db_is_case_sensitive = to_boolean(db_is_case_sensitive)
+        self._graph_depth = to_integer(graph_depth)
+        self._verify_ssl = to_boolean(verify_ssl)
+        self._is_jwt = to_boolean(is_jwt)
+        self._jwt_tenant_id = jwt_tenant_id
+        self._debug = to_boolean(debug)
+        self._conn_params = conn_params or {}
+
+
+    @property
+    def usage_metadata_key(self) -> str:
+        return "validate_sql_usage_metadata"
+
+
+    @property
+    def input_keys(self) -> list:
+        return ["prompt", "sql"]
+
+
+    @property
+    def output_keys(self) -> list:
+        return [
+            "sql",
+            "schema",
+            "concept",
+            "is_sql_valid",
+            "error",
+            self.usage_metadata_key,
+        ]
+
+
+    def _get_conn_params(self) -> dict:
+        return {
+            "url": self._url,
+            "token": self._token,
+            "ontology": self._ontology,
+            "verify_ssl": self._verify_ssl,
+            "is_jwt": self._is_jwt,
+            "jwt_tenant_id": self._jwt_tenant_id,
+            **self._conn_params,
+        }
+
+
+    def _call(self, inputs: Dict[str, Any], run_manager=None) -> Dict[str, Any]:
+        usage_metadata = {}
+        sql = inputs["sql"]
+        prompt = inputs["prompt"]
+        schema = self._schema
+        concept = self._concept
+
+        is_sql_valid, error = validate_sql(sql, self._get_conn_params())
+        if not is_sql_valid:
+            prompt_extension = self._note + '\n' if self._note else ""
+            generate_res = generate_sql(
+                question=prompt,
+                llm=self._llm,
+                conn_params=self._get_conn_params(),
+                schema=schema,
+                concept=concept,
+                concepts_list=self._concepts_list,
+                views_list=self._views_list,
+                include_logic_concepts=self._include_logic_concepts,
+                include_tags=self._include_tags,
+                exclude_properties=self._exclude_properties,
+                should_validate_sql=True,
+                retries=self._retries,
+                max_limit=self._max_limit,
+                note=f"{prompt_extension}The original SQL query (`{sql}`) was invalid with this error from query {error}. Please take this in consideration while generating the query.",
+                db_is_case_sensitive=self._db_is_case_sensitive,
+                graph_depth=self._graph_depth,
+                debug=self._debug,
+            )
+            sql = generate_res.get("sql", "")
+            schema = generate_res.get("schema", self._schema)
+            concept = generate_res.get("concept", self._concept)
+            usage_metadata.update(generate_res.get("usage_metadata", {}))
+            is_sql_valid = generate_res.get("is_sql_valid")
+            error = generate_res.get("error")
+
+        return {
+            "sql": sql,
+            "schema": schema,
+            "concept": concept,
+            "is_sql_valid": is_sql_valid,
+            "error": error,
+            self.usage_metadata_key: usage_metadata,
+        }

langchain_timbr/langgraph/__init__.py

@@ -0,0 +1,13 @@
+from .identify_concept_node import IdentifyConceptNode
+from .generate_timbr_sql_node import GenerateTimbrSqlNode
+from .validate_timbr_query_node import ValidateSemanticSqlNode
+from .execute_timbr_query_node import ExecuteSemanticQueryNode
+from .generate_response_node import GenerateResponseNode
+
+__all__ = [
+    "IdentifyConceptNode",
+    "GenerateTimbrSqlNode",
+    "ValidateSemanticSqlNode",
+    "ExecuteSemanticQueryNode",
+    "GenerateResponseNode",
+]

langchain_timbr/langgraph/execute_timbr_query_node.py

@@ -0,0 +1,108 @@
+from typing import Optional, Union
+from langchain.llms.base import LLM
+from langgraph.graph import StateGraph
+
+from ..langchain.execute_timbr_query_chain import ExecuteTimbrQueryChain
+
+
+class ExecuteSemanticQueryNode:
+    """
+    Node that wraps ExecuteTimbrQueryChain functionality.
+    Expects the SQL (and optionally the concept) in the payload.
+    Returns the query rows along with the SQL and concept.
+    """
+    def __init__(
+        self,
+        llm: LLM,
+        url: Optional[str] = None,
+        token: Optional[str] = None,
+        ontology: Optional[str] = None,
+        schema: Optional[str] = None,
+        concept: Optional[str] = None,
+        concepts_list: Optional[Union[list[str], str]] = None,
+        views_list: Optional[Union[list[str], str]] = None,
+        include_logic_concepts: Optional[bool] = False,
+        include_tags: Optional[Union[list[str], str]] = None,
+        exclude_properties: Optional[Union[list[str], str]] = ['entity_id', 'entity_type', 'entity_label'],
+        should_validate_sql: Optional[bool] = False,
+        retries: Optional[int] = 3,
+        max_limit: Optional[int] = 500,
+        retry_if_no_results: Optional[bool] = False,
+        no_results_max_retries: Optional[int] = 2,
+        note: Optional[str] = '',
+        db_is_case_sensitive: Optional[bool] = False,
+        graph_depth: Optional[int] = 1,
+        verify_ssl: Optional[bool] = True,
+        is_jwt: Optional[bool] = False,
+        jwt_tenant_id: Optional[str] = None,
+        conn_params: Optional[dict] = None,
+        debug: Optional[bool] = False,
+        **kwargs,
+    ):
+        """
+        :param llm: An LLM instance or a function that takes a prompt string and returns the LLM’s response
+        :param url: Timbr server url
+        :param token: Timbr password or token value
+        :param ontology: The name of the ontology/knowledge graph
+        :param schema: The name of the schema to query
+        :param concept: The name of the concept to query
+        :param concepts_list: Optional specific concept options to query
+        :param views_list: Optional specific view options to query
+        :param include_logic_concepts: Optional boolean to include logic concepts (concepts without unique properties which only inherits from an upper level concept with filter logic) in the query.
+        :param include_tags: Optional specific concepts & properties tag options to use in the query (Disabled by default. Use '*' to enable all tags or a string represents a list of tags divided by commas (e.g. 'tag1,tag2')
+        :param exclude_properties: Optional specific properties to exclude from the query (entity_id, entity_type & entity_label by default).
+        :param should_validate_sql: Whether to validate the SQL before executing it
+        :param retries: Number of retry attempts if the generated SQL is invalid
+        :param max_limit: Maximum number of rows to return
+        :retry_if_no_results: Whether to infer the result value from the SQL query. If the query won't return any rows, it will try to re-generate the SQL query then re-run it.
+        :param no_results_max_retries: Number of retry attempts to infer the result value from the SQL query
+        :param note: Optional additional note to extend our llm prompt
+        :param db_is_case_sensitive: Whether the database is case sensitive (default is False).
+        :param graph_depth: Maximum number of relationship hops to traverse from the source concept during schema exploration (default is 1).
+        :param verify_ssl: Whether to verify SSL certificates (default is True).
+        :param is_jwt: Whether to use JWT authentication (default is False).
+        :param jwt_tenant_id: JWT tenant ID for multi-tenant environments (required when is_jwt=True).
+        :param conn_params: Extra Timbr connection parameters sent with every request (e.g., 'x-api-impersonate-user').
+        :return: A list of rows from the Timbr query
+        """
+        self.chain = ExecuteTimbrQueryChain(
+            llm=llm,
+            url=url,
+            token=token,
+            ontology=ontology,
+            schema=schema,
+            concept=concept,
+            concepts_list=concepts_list,
+            views_list=views_list,
+            include_logic_concepts=include_logic_concepts,
+            include_tags=include_tags,
+            exclude_properties=exclude_properties,
+            should_validate_sql=should_validate_sql,
+            retries=retries,
+            max_limit=max_limit,
+            retry_if_no_results=retry_if_no_results,
+            no_results_max_retries=no_results_max_retries,
+            note=note,
+            db_is_case_sensitive=db_is_case_sensitive,
+            graph_depth=graph_depth,
+            verify_ssl=verify_ssl,
+            is_jwt=is_jwt,
+            jwt_tenant_id=jwt_tenant_id,
+            conn_params=conn_params,
+            debug=debug,
+            **kwargs,
+        )
+
+
+    def run(self, state: StateGraph) -> dict:
+        try:
+            prompt = state.messages[-1].content if state.messages[-1] else None
+        except:
+            prompt = state.get('prompt', None)
+
+        return self.chain.invoke({ "prompt": prompt })
+
+
+    def __call__(self, state: dict) -> dict:
+        return self.run(state)
+

langchain_timbr/langgraph/generate_response_node.py

@@ -0,0 +1,59 @@
+from typing import Optional, Union
+from langchain.llms.base import LLM
+from langgraph.graph import StateGraph
+
+from ..langchain import GenerateAnswerChain
+
+
+class GenerateResponseNode:
+    """
+    Node that wraps GenerateAnswerChain functionality, which generates an answer based on a given prompt and rows of data.
+    It uses the LLM to build a human-readable answer.
+
+    This node connects to a Timbr server via the provided URL and token to generate contextual answers from query results using an LLM.
+    """
+    def __init__(
+        self,
+        llm: LLM,
+        url: str,
+        token: str,
+        verify_ssl: Optional[bool] = True,
+        is_jwt: Optional[bool] = False,
+        jwt_tenant_id: Optional[str] = None,
+        conn_params: Optional[dict] = None,
+        debug: Optional[bool] = False,
+        **kwargs,
+    ):
+        """
+        :param llm: An LLM instance or a function that takes a prompt string and returns the LLM’s response
+        :param url: Timbr server url
+        :param token: Timbr password or token value
+        :param verify_ssl: Whether to verify SSL certificates (default is True).
+        :param is_jwt: Whether to use JWT authentication (default is False).
+        :param jwt_tenant_id: JWT tenant ID for multi-tenant environments (required when is_jwt=True).
+        :param conn_params: Extra Timbr connection parameters sent with every request (e.g., 'x-api-impersonate-user').
+        """
+        self.chain = GenerateAnswerChain(
+            llm=llm,
+            url=url,
+            token=token,
+            verify_ssl=verify_ssl,
+            is_jwt=is_jwt,
+            jwt_tenant_id=jwt_tenant_id,
+            conn_params=conn_params,
+            debug=debug,
+            **kwargs,
+        )
+
+
+    def run(self, state: dict) -> dict:
+        sql = state.get("sql", "")
+        rows = state.get("rows", "")
+        prompt = state.get("prompt", "")
+
+        return self.chain.invoke({ "prompt": prompt, "rows": rows, "sql": sql })
+
+
+    def __call__(self, state: dict) -> dict:
+        return self.run(state)
+

langchain_timbr/langgraph/generate_timbr_sql_node.py

@@ -0,0 +1,98 @@
+from typing import Optional, Union
+from langchain.llms.base import LLM
+from langgraph.graph import StateGraph
+
+from ..langchain.generate_timbr_sql_chain import GenerateTimbrSqlChain
+
+class GenerateTimbrSqlNode:
+    """
+    Node that wraps GenerateTimbrSqlChain functionality.
+    Expects an input payload with a "prompt" key.
+    """
+    def __init__(
+        self,
+        llm: LLM,
+        url: Optional[str] = None,
+        token: Optional[str] = None,
+        ontology: Optional[str] = None,
+        schema: Optional[str] = None,
+        concept: Optional[str] = None,
+        concepts_list: Optional[Union[list[str], str]] = None,
+        views_list: Optional[Union[list[str], str]] = None,
+        include_logic_concepts: Optional[bool] = False,
+        include_tags: Optional[Union[list[str], str]] = None,
+        exclude_properties: Optional[Union[list[str], str]] = ['entity_id', 'entity_type', 'entity_label'],
+        should_validate_sql: Optional[bool] = False,
+        retries: Optional[int] = 3,
+        max_limit: Optional[int] = 500,
+        note: Optional[str] = '',
+        db_is_case_sensitive: Optional[bool] = False,
+        graph_depth: Optional[int] = 1,
+        verify_ssl: Optional[bool] = True,
+        is_jwt: Optional[bool] = False,
+        jwt_tenant_id: Optional[str] = None,
+        conn_params: Optional[dict] = None,
+        debug: Optional[bool] = False,
+        **kwargs,
+    ):
+        """
+        :param llm: An LLM instance or a function that takes a prompt string and returns the LLM’s response
+        :param url: Timbr server url
+        :param token: Timbr password or token value
+        :param ontology: The name of the ontology/knowledge graph
+        :param schema: The name of the schema to query
+        :param concept: The name of the concept to query
+        :param concepts_list: Optional specific concept options to query
+        :param views_list: Optional specific view options to query
+        :param include_logic_concepts: Optional boolean to include logic concepts (concepts without unique properties which only inherits from an upper level concept with filter logic) in the query.
+        :param include_tags: Optional specific concepts & properties tag options to use in the query (Disabled by default. Use '*' to enable all tags or a string represents a list of tags divided by commas (e.g. 'tag1,tag2')
+        :param exclude_properties: Optional specific properties to exclude from the query (entity_id, entity_type & entity_label by default).
+        :param should_validate_sql: Whether to validate the SQL before executing it
+        :param retries: Number of retry attempts if the generated SQL is invalid
+        :param max_limit: Maximum number of rows to query
+        :param note: Optional additional note to extend our llm prompt
+        :param db_is_case_sensitive: Whether the database is case sensitive (default is False).
+        :param graph_depth: Maximum number of relationship hops to traverse from the source concept during schema exploration (default is 1).
+        :param verify_ssl: Whether to verify SSL certificates (default is True).
+        :param is_jwt: Whether to use JWT authentication (default: False)
+        :param jwt_tenant_id: Tenant ID for JWT authentication when using multi-tenant setup
+        :param conn_params: Extra Timbr connection parameters sent with every request (e.g., 'x-api-impersonate-user').
+        """
+        self.chain = GenerateTimbrSqlChain(
+            llm=llm,
+            url=url,
+            token=token,
+            ontology=ontology,
+            schema=schema,
+            concept=concept,
+            concepts_list=concepts_list,
+            views_list=views_list,
+            include_logic_concepts=include_logic_concepts,
+            include_tags=include_tags,
+            exclude_properties=exclude_properties,
+            should_validate_sql=should_validate_sql,
+            retries=retries,
+            max_limit=max_limit,
+            note=note,
+            db_is_case_sensitive=db_is_case_sensitive,
+            graph_depth=graph_depth,
+            verify_ssl=verify_ssl,
+            is_jwt=is_jwt,
+            jwt_tenant_id=jwt_tenant_id,
+            conn_params=conn_params,
+            debug=debug,
+            **kwargs,
+        )
+        
+
+    def run(self, state: StateGraph) -> dict:
+        try:
+            prompt = state.messages[-1].content if (state.messages and state.messages[-1]) else None
+        except:
+            prompt = state.get('prompt', None)
+
+        return self.chain.invoke({ "prompt": prompt })
+
+
+    def __call__(self, state: dict) -> dict:
+        return self.run(state)

langchain_timbr/langgraph/identify_concept_node.py

@@ -0,0 +1,78 @@
+from typing import Optional, Union
+from langchain.llms.base import LLM
+from langgraph.graph import StateGraph
+
+from ..langchain.identify_concept_chain import IdentifyTimbrConceptChain
+
+
+class IdentifyConceptNode:
+    def __init__(
+        self,
+        llm: LLM,
+        url: Optional[str] = None,
+        token: Optional[str] = None,
+        ontology: Optional[str] = None,
+        concepts_list: Optional[Union[list[str], str]] = None,
+        views_list: Optional[Union[list[str], str]] = None,
+        include_logic_concepts: Optional[bool] = False,
+        include_tags: Optional[Union[list[str], str]] = None,
+        should_validate: Optional[bool] = False,
+        retries: Optional[int] = 3,
+        note: Optional[str] = None,
+        verify_ssl: Optional[bool] = True,
+        is_jwt: Optional[bool] = False,
+        jwt_tenant_id: Optional[str] = None,
+        conn_params: Optional[dict] = None,
+        debug: Optional[bool] = False,
+        **kwargs,
+    ):
+        """
+        :param llm: An LLM instance or a function that takes a prompt string and returns the LLM’s response
+        :param url: Timbr server url
+        :param token: Timbr password or token value
+        :param ontology: The name of the ontology/knowledge graph
+        :param concepts_list: Optional specific concept options to query
+        :param views_list: Optional specific view options to query
+        :param include_logic_concepts: Optional boolean to include logic concepts (concepts without unique properties which only inherits from an upper level concept with filter logic) in the query.
+        :param include_tags: Optional specific concepts & properties tag options to use in the query (Disabled by default. Use '*' to enable all tags or a string represents a list of tags divided by commas (e.g. 'tag1,tag2')
+        :param should_validate: Whether to validate the identified concept before returning it
+        :param retries: Number of retry attempts if the identified concept is invalid
+        :param note: Optional additional note to extend our llm prompt
+        :param verify_ssl: Whether to verify SSL certificates
+        :param is_jwt: Whether to use JWT authentication (default: False)
+        :param jwt_tenant_id: Tenant ID for JWT authentication when using multi-tenant setup
+        :param conn_params: Extra Timbr connection parameters sent with every request (e.g., 'x-api-impersonate-user').
+        """
+        self.chain = IdentifyTimbrConceptChain(
+            llm=llm,
+            url=url,
+            token=token,
+            ontology=ontology,
+            concepts_list=concepts_list,
+            views_list=views_list,
+            include_logic_concepts=include_logic_concepts,
+            include_tags=include_tags,
+            should_validate=should_validate,
+            retries=retries,
+            note=note,
+            verify_ssl=verify_ssl,
+            is_jwt=is_jwt,
+            jwt_tenant_id=jwt_tenant_id,
+            conn_params=conn_params,
+            debug=debug,
+            **kwargs,
+        )
+
+
+    def run(self, state: StateGraph) -> dict:
+        try:
+          prompt = state.messages[-1].content if state.messages[-1] else None
+        except:
+          prompt = state.get('prompt', None)
+
+        return self.chain.invoke({ "prompt": prompt })
+
+
+    def __call__(self, state: dict) -> dict:
+        return self.run(state)
+

langchain_timbr/langgraph/validate_timbr_query_node.py

@@ -0,0 +1,100 @@
+from typing import Optional, Union
+from langchain.llms.base import LLM
+from langgraph.graph import StateGraph
+
+from ..langchain.validate_timbr_sql_chain import ValidateTimbrSqlChain
+
+
+class ValidateSemanticSqlNode:
+    """
+    Node that wraps ValidateTimbrSqlChain functionality.
+    Expects an input payload with a "sql" or "prompt" key.
+    Produces output with keys: "sql" and "is_sql_valid".
+    """
+    def __init__(
+        self,
+        llm: LLM,
+        url: str,
+        token: str,
+        ontology: str,
+        schema: Optional[str] = None,
+        concept: Optional[str] = None,
+        retries: Optional[int] = 3,
+        concepts_list: Optional[Union[list[str], str]] = None,
+        views_list: Optional[Union[list[str], str]] = None,
+        include_logic_concepts: Optional[bool] = False,
+        include_tags: Optional[Union[list[str], str]] = None,
+        exclude_properties: Optional[Union[list[str], str]] = ['entity_id', 'entity_type', 'entity_label'],
+        max_limit: Optional[int] = 500,
+        note: Optional[str] = None,
+        db_is_case_sensitive: Optional[bool] = False,
+        graph_depth: Optional[int] = 1,
+        verify_ssl: Optional[bool] = True,
+        is_jwt: Optional[bool] = False,
+        jwt_tenant_id: Optional[str] = None,
+        conn_params: Optional[dict] = None,
+        debug: Optional[bool] = False,
+        **kwargs,
+    ):
+        """
+        :param llm: An LLM instance or a function that takes a prompt string and returns the LLM’s response
+        :param url: Timbr server url
+        :param token: Timbr password or token value
+        :param ontology: The name of the ontology/knowledge graph
+        :param schema: The name of the schema to query
+        :param concept: The name of the concept to query
+        :param retries: The maximum number of retries to attempt
+        :param concepts_list: Optional specific concept options to query
+        :param views_list: Optional specific view options to query
+        :param include_logic_concepts: Optional boolean to include logic concepts (concepts without unique properties which only inherits from an upper level concept with filter logic) in the query. 
+        :param include_tags: Optional specific concepts & properties tag options to use in the query (Disabled by default. Use '*' to enable all tags or a string represents a list of tags divided by commas (e.g. 'tag1,tag2')
+        :param exclude_properties: Optional specific properties to exclude from the query (entity_id, entity_type & entity_label by default).
+        :param max_limit: Maximum number of rows to query
+        :param note: Optional additional note to extend our llm prompt
+        :param db_is_case_sensitive: Whether the database is case sensitive (default is False).
+        :param graph_depth: Maximum number of relationship hops to traverse from the source concept during schema exploration (default is 1).
+        :param verify_ssl: Whether to verify SSL certificates (default is True).
+        :param is_jwt: Whether to use JWT authentication (default: False)
+        :param jwt_tenant_id: Tenant ID for JWT authentication when using multi-tenant setup
+        :param conn_params: Extra Timbr connection parameters sent with every request (e.g., 'x-api-impersonate-user').
+        """
+        self.chain = ValidateTimbrSqlChain(
+            llm=llm,
+            url=url,
+            token=token,
+            ontology=ontology,
+            schema=schema,
+            concept=concept,
+            retries=retries,
+            concepts_list=concepts_list,
+            views_list=views_list,
+            include_logic_concepts=include_logic_concepts,
+            include_tags=include_tags,
+            exclude_properties=exclude_properties,
+            max_limit=max_limit,
+            note=note,
+            db_is_case_sensitive=db_is_case_sensitive,
+            graph_depth=graph_depth,
+            verify_ssl=verify_ssl,
+            is_jwt=is_jwt,
+            jwt_tenant_id=jwt_tenant_id,
+            conn_params=conn_params,
+            debug=debug,
+            **kwargs,
+        )
+
+
+    def run(self, state: StateGraph) -> dict:
+        try:
+            sql = state.sql
+            prompt = state.prompt
+        except:
+            sql = state.get('sql', None)
+            prompt = state.get('prompt', None)
+
+        return self.chain.invoke({ "sql": sql, "prompt": prompt })
+
+
+    def __call__(self, payload: dict) -> dict:
+        return self.run(payload)
+