langchain-timbr 1.5.3__py3-none-any.whl → 1.5.5__py3-none-any.whl

langchain_timbr/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.5.3'
-__version_tuple__ = version_tuple = (1, 5, 3)
+__version__ = version = '1.5.5'
+__version_tuple__ = version_tuple = (1, 5, 5)
 
 __commit_id__ = commit_id = None

langchain_timbr/config.py

@@ -4,7 +4,7 @@ from .utils.general import to_boolean, to_integer, parse_list
 # MUST HAVE VARIABLES
 url = os.environ.get('TIMBR_URL')
 token = os.environ.get('TIMBR_TOKEN')
-ontology = os.environ.get('ONTOLOGY', 'system_db')
+ontology = os.environ.get('TIMBR_ONTOLOGY', os.environ.get('ONTOLOGY', 'system_db'))
 
 # OPTIONAL VARIABLES
 is_jwt = to_boolean(os.environ.get('IS_JWT', 'false'))
@@ -18,4 +18,5 @@ llm_type = os.environ.get('LLM_TYPE')
 llm_model = os.environ.get('LLM_MODEL')
 llm_api_key = os.environ.get('LLM_API_KEY')
 llm_temperature = os.environ.get('LLM_TEMPERATURE', 0.0)
+llm_additional_params = os.environ.get('LLM_ADDITIONAL_PARAMS', '')
 llm_timeout = to_integer(os.environ.get('LLM_TIMEOUT', 60))  # Default 60 seconds timeout

langchain_timbr/langchain/execute_timbr_query_chain.py

@@ -2,9 +2,11 @@ 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_boolean, to_integer
+from ..utils.general import parse_list, to_boolean, to_integer, validate_timbr_connection_params
 from ..utils.timbr_utils import run_query, validate_sql
 from ..utils.timbr_llm_utils import generate_sql
+from ..llm_wrapper.llm_wrapper import LlmWrapper
+from .. import config
 
 class ExecuteTimbrQueryChain(Chain):
     """
@@ -17,10 +19,10 @@ class ExecuteTimbrQueryChain(Chain):
     
     def __init__(
         self,
-        llm: LLM,
-        url: str,
-        token: str,
-        ontology: str,
+        llm: Optional[LLM] = None,
+        url: Optional[str] = None,
+        token: Optional[str] = None,
+        ontology: Optional[str] = None,
         schema: Optional[str] = 'dtimbr',
         concept: Optional[str] = None,
         concepts_list: Optional[Union[list[str], str]] = None,
@@ -44,10 +46,10 @@ class ExecuteTimbrQueryChain(Chain):
         **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 llm: An LLM instance or a function that takes a prompt string and returns the LLM's response (optional, will use LlmWrapper with env variables if not provided)
+        :param url: Timbr server url (optional, defaults to TIMBR_URL environment variable)
+        :param token: Timbr password or token value (optional, defaults to TIMBR_TOKEN environment variable)
+        :param ontology: The name of the ontology/knowledge graph (optional, defaults to ONTOLOGY/TIMBR_ONTOLOGY environment variable)
         :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
@@ -72,6 +74,7 @@ class ExecuteTimbrQueryChain(Chain):
 
         ## Example
         ```
+        # Using explicit parameters
         execute_timbr_query_chain = ExecuteTimbrQueryChain(
             url=<url>,
             token=<token>,
@@ -85,14 +88,35 @@ class ExecuteTimbrQueryChain(Chain):
             note=<note>,
         )
 
+        # Using environment variables for timbr environment (TIMBR_URL, TIMBR_TOKEN, TIMBR_ONTOLOGY)
+        execute_timbr_query_chain = ExecuteTimbrQueryChain(
+            llm=<llm or timbr_llm_wrapper instance>,
+        )
+
+        # Using environment variables for both timbr environment & llm (TIMBR_URL, TIMBR_TOKEN, TIMBR_ONTOLOGY, LLM_TYPE, LLM_API_KEY, etc.)
+        execute_timbr_query_chain = ExecuteTimbrQueryChain()
+
         return execute_timbr_query_chain.invoke({ "prompt": question }).get("rows", [])
         ```
         """
         super().__init__(**kwargs)
-        self._llm = llm
-        self._url = url
-        self._token = token
-        self._ontology = ontology
+        
+        # Initialize LLM - use provided one or create with LlmWrapper from env variables
+        if llm is not None:
+            self._llm = llm
+        else:
+            try:
+                self._llm = LlmWrapper()
+            except Exception as e:
+                raise ValueError(f"Failed to initialize LLM from environment variables. Either provide an llm parameter or ensure LLM_TYPE and LLM_API_KEY environment variables are set. Error: {e}")
+        
+        self._url = url if url is not None else config.url
+        self._token = token if token is not None else config.token
+        self._ontology = ontology if ontology is not None else config.ontology
+        
+        # Validate required parameters
+        validate_timbr_connection_params(self._url, self._token)
+        
         self._schema = schema
         self._concept = concept
         self._concepts_list = parse_list(concepts_list)
@@ -181,7 +205,7 @@ class ExecuteTimbrQueryChain(Chain):
             should_validate_sql=self._should_validate_sql,
             retries=self._retries,
             max_limit=self._max_limit,
-            note=self._note + err_txt,
+            note=(self._note or '') + err_txt,
             db_is_case_sensitive=self._db_is_case_sensitive,
             graph_depth=self._graph_depth,
             debug=self._debug,
@@ -251,7 +275,7 @@ class ExecuteTimbrQueryChain(Chain):
                             generated.append(sql)
                             # If the SQL is valid but no rows are returned, create an error message to be sent to the LLM
                             if is_sql_valid:
-                                error = f"No rows returned. Please revise the SQL considering if the question was ambiguous (e.g., which ID or name to use), try use alternative columns in the WHERE clause part in a way that could match the user's intent, without adding new columns with new filters."
+                                error = "No rows returned. Please revise the SQL considering if the question was ambiguous (e.g., which ID or name to use), try use alternative columns in the WHERE clause part in a way that could match the user's intent, without adding new columns with new filters."
                                 error += "\nConsider that this queries already generated and returned 0 rows:\n" + "\n".join(generated)
                                 is_sql_valid = False
                         else:

langchain_timbr/langchain/generate_answer_chain.py

@@ -2,8 +2,10 @@ from typing import Optional, Dict, Any
 from langchain.chains.base import Chain
 from langchain.llms.base import LLM
 
-from ..utils.general import to_boolean
+from ..utils.general import to_boolean, validate_timbr_connection_params
 from ..utils.timbr_llm_utils import answer_question
+from ..llm_wrapper.llm_wrapper import LlmWrapper
+from .. import config
 
 class GenerateAnswerChain(Chain):
     """
@@ -14,9 +16,9 @@ class GenerateAnswerChain(Chain):
     """
     def __init__(
         self,
-        llm: LLM,
-        url: str,
-        token: str,
+        llm: Optional[LLM] = None,
+        url: Optional[str] = None,
+        token: Optional[str] = None,
         verify_ssl: Optional[bool] = True,
         is_jwt: Optional[bool] = False,
         jwt_tenant_id: Optional[str] = None,
@@ -25,9 +27,9 @@ class GenerateAnswerChain(Chain):
         **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 llm: An LLM instance or a function that takes a prompt string and returns the LLM’s response (optional, will use LlmWrapper with env variables if not provided)
+        :param url: Timbr server url (optional, defaults to TIMBR_URL environment variable)
+        :param token: Timbr password or token value (optional, defaults to TIMBR_TOKEN environment variable)
         :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).
@@ -35,17 +37,41 @@ class GenerateAnswerChain(Chain):
         
         ## Example
         ```
+        # Using explicit parameters
+        generate_answer_chain = GenerateAnswerChain(
+            llm=<llm or timbr_llm_wrapper instance>,
+            url=<url>,
+            token=<token>
+        )
+
+        # Using environment variables for timbr environment (TIMBR_URL, TIMBR_TOKEN)
         generate_answer_chain = GenerateAnswerChain(
             llm=<llm or timbr_llm_wrapper instance>
         )
+        
+        # Using environment variables for both timbr environment & llm (TIMBR_URL, TIMBR_TOKEN, LLM_TYPE, LLM_API_KEY, etc.)
+        generate_answer_chain = GenerateAnswerChain()
 
         return generate_answer_chain.invoke({ "prompt": prompt, "rows": rows }).get("answer", [])
         ```
         """
         super().__init__(**kwargs)
-        self._llm = llm
-        self._url = url
-        self._token = token
+        
+        # Initialize LLM - use provided one or create with LlmWrapper from env variables
+        if llm is not None:
+            self._llm = llm
+        else:
+            try:
+                self._llm = LlmWrapper()
+            except Exception as e:
+                raise ValueError(f"Failed to initialize LLM from environment variables. Either provide an llm parameter or ensure LLM_TYPE and LLM_API_KEY environment variables are set. Error: {e}")
+        
+        self._url = url if url is not None else config.url
+        self._token = token if token is not None else config.token
+        
+        # Validate required parameters
+        validate_timbr_connection_params(self._url, self._token)
+        
         self._verify_ssl = to_boolean(verify_ssl)
         self._is_jwt = to_boolean(is_jwt)
         self._jwt_tenant_id = jwt_tenant_id

langchain_timbr/langchain/generate_timbr_sql_chain.py

@@ -2,8 +2,10 @@ 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_boolean, to_integer
+from ..utils.general import parse_list, to_boolean, to_integer, validate_timbr_connection_params
 from ..utils.timbr_llm_utils import generate_sql
+from ..llm_wrapper.llm_wrapper import LlmWrapper
+from .. import config
 
 class GenerateTimbrSqlChain(Chain):
     """
@@ -16,10 +18,10 @@ class GenerateTimbrSqlChain(Chain):
     
     def __init__(
         self,
-        llm: LLM,
-        url: str,
-        token: str,
-        ontology: str,
+        llm: Optional[LLM] = None,
+        url: Optional[str] = None,
+        token: Optional[str] = None,
+        ontology: Optional[str] = None,
         schema: Optional[str] = 'dtimbr',
         concept: Optional[str] = None,
         concepts_list: Optional[Union[list[str], str]] = None,
@@ -41,10 +43,10 @@ class GenerateTimbrSqlChain(Chain):
         **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 llm: An LLM instance or a function that takes a prompt string and returns the LLM's response (optional, will use LlmWrapper with env variables if not provided)
+        :param url: Timbr server url (optional, defaults to TIMBR_URL environment variable)
+        :param token: Timbr password or token value (optional, defaults to TIMBR_TOKEN environment variable)
+        :param ontology: The name of the ontology/knowledge graph (optional, defaults to ONTOLOGY/TIMBR_ONTOLOGY environment variable)
         :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
@@ -66,6 +68,7 @@ class GenerateTimbrSqlChain(Chain):
         
         ## Example
         ```
+        # Using explicit parameters
         generate_timbr_sql_chain = GenerateTimbrSqlChain(
             url=<url>,
             token=<token>,
@@ -79,14 +82,35 @@ class GenerateTimbrSqlChain(Chain):
             note=<note>,
         )
 
+        # Using environment variables for timbr environment (TIMBR_URL, TIMBR_TOKEN, TIMBR_ONTOLOGY)
+        generate_timbr_sql_chain = GenerateTimbrSqlChain(
+            llm=<llm or timbr_llm_wrapper instance>,
+        )
+
+        # Using environment variables for both timbr environment & llm (TIMBR_URL, TIMBR_TOKEN, TIMBR_ONTOLOGY, LLM_TYPE, LLM_API_KEY, etc.)
+        generate_timbr_sql_chain = GenerateTimbrSqlChain()
+
         return generate_timbr_sql_chain.invoke({ "prompt": question }).get("sql", [])
         ```
         """
         super().__init__(**kwargs)
-        self._llm = llm
-        self._url = url
-        self._token = token
-        self._ontology = ontology
+        
+        # Initialize LLM - use provided one or create with LlmWrapper from env variables
+        if llm is not None:
+            self._llm = llm
+        else:
+            try:
+                self._llm = LlmWrapper()
+            except Exception as e:
+                raise ValueError(f"Failed to initialize LLM from environment variables. Either provide an llm parameter or ensure LLM_TYPE and LLM_API_KEY environment variables are set. Error: {e}")
+        
+        self._url = url if url is not None else config.url
+        self._token = token if token is not None else config.token
+        self._ontology = ontology if ontology is not None else config.ontology
+        
+        # Validate required parameters
+        validate_timbr_connection_params(self._url, self._token)
+        
         self._schema = schema
         self._concept = concept
         self._concepts_list = parse_list(concepts_list)

langchain_timbr/langchain/identify_concept_chain.py

@@ -2,8 +2,10 @@ 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_boolean, to_integer
+from ..utils.general import parse_list, to_boolean, to_integer, validate_timbr_connection_params
 from ..utils.timbr_llm_utils import determine_concept
+from ..llm_wrapper.llm_wrapper import LlmWrapper
+from .. import config
 
 
 class IdentifyTimbrConceptChain(Chain):
@@ -17,10 +19,10 @@ class IdentifyTimbrConceptChain(Chain):
     
     def __init__(
         self,
-        llm: LLM,
-        url: str,
-        token: str,
-        ontology: str,
+        llm: Optional[LLM] = None,
+        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,
@@ -36,10 +38,10 @@ class IdentifyTimbrConceptChain(Chain):
         **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 llm: An LLM instance or a function that takes a prompt string and returns the LLM's response (optional, will use LlmWrapper with env variables if not provided)
+        :param url: Timbr server url (optional, defaults to TIMBR_URL environment variable)
+        :param token: Timbr password or token value (optional, defaults to TIMBR_TOKEN environment variable)
+        :param ontology: The name of the ontology/knowledge graph (optional, defaults to ONTOLOGY/TIMBR_ONTOLOGY environment variable)
         :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.
@@ -55,10 +57,11 @@ class IdentifyTimbrConceptChain(Chain):
         
         ## Example
         ```
+        # Using explicit parameters
         identify_timbr_concept_chain = IdentifyTimbrConceptChain(
+            llm=<llm or timbr_llm_wrapper instance>,
             url=<url>,
             token=<token>,
-            llm=<llm or timbr_llm_wrapper instance>,
             ontology=<ontology_name>,
             concepts_list=<concepts>,
             views_list=<views>,
@@ -66,14 +69,35 @@ class IdentifyTimbrConceptChain(Chain):
             note=<note>,
         )
 
+        # Using environment variables for timbr environment (TIMBR_URL, TIMBR_TOKEN, TIMBR_ONTOLOGY)
+        identify_timbr_concept_chain = IdentifyTimbrConceptChain(
+            llm=<llm or timbr_llm_wrapper instance>,
+        )
+
+        # Using environment variables for both timbr environment & llm (TIMBR_URL, TIMBR_TOKEN, TIMBR_ONTOLOGY, LLM_TYPE, LLM_API_KEY, etc.)
+        identify_timbr_concept_chain = IdentifyTimbrConceptChain()
+
         return identify_timbr_concept_chain.invoke({ "prompt": question }).get("concept", None)
         ```
         """
         super().__init__(**kwargs)
-        self._llm = llm
-        self._url = url
-        self._token = token
-        self._ontology = ontology
+        
+        # Initialize LLM - use provided one or create with LlmWrapper from env variables
+        if llm is not None:
+            self._llm = llm
+        else:
+            try:
+                self._llm = LlmWrapper()
+            except Exception as e:
+                raise ValueError(f"Failed to initialize LLM from environment variables. Either provide an llm parameter or ensure LLM_TYPE and LLM_API_KEY environment variables are set. Error: {e}")
+        
+        self._url = url if url is not None else config.url
+        self._token = token if token is not None else config.token
+        self._ontology = ontology if ontology is not None else config.ontology
+        
+        # Validate required parameters
+        validate_timbr_connection_params(self._url, self._token)
+        
         self._concepts_list = parse_list(concepts_list)
         self._views_list = parse_list(views_list)
         self._include_logic_concepts = to_boolean(include_logic_concepts)

langchain_timbr/langchain/timbr_sql_agent.py

@@ -10,10 +10,10 @@ from .generate_answer_chain import GenerateAnswerChain
 class TimbrSqlAgent(BaseSingleActionAgent):
     def __init__(
         self,
-        llm: LLM,
-        url: str,
-        token: str,
-        ontology: str,
+        llm: Optional[LLM] = None,
+        url: Optional[str] = None,
+        token: Optional[str] = None,
+        ontology: Optional[str] = None,
         schema: Optional[str] = 'dtimbr',
         concept: Optional[str] = None,
         concepts_list: Optional[Union[list[str], str]] = None,
@@ -37,10 +37,10 @@ class TimbrSqlAgent(BaseSingleActionAgent):
         debug: Optional[bool] = False
     ):
         """
-        :param llm: Language model to use
-        :param url: Timbr server URL
-        :param token: Timbr authentication token
-        :param ontology: Name of the ontology/knowledge graph
+        :param llm: An LLM instance or a function that takes a prompt string and returns the LLM's response (optional, will use LlmWrapper with env variables if not provided)
+        :param url: Timbr server URL (optional, defaults to TIMBR_URL environment variable)
+        :param token: Timbr authentication token (optional, defaults to TIMBR_TOKEN environment variable)
+        :param ontology: Name of the ontology/knowledge graph (optional, defaults to ONTOLOGY/TIMBR_ONTOLOGY environment variable)
         :param schema: Optional specific schema name to query
         :param concept: Optional specific concept name to query
         :param concepts_list: Optional specific concept options to query
@@ -64,6 +64,7 @@ class TimbrSqlAgent(BaseSingleActionAgent):
 
         ## Example
         ```
+        # Using explicit parameters
         agent = TimbrSqlAgent(
             llm=<llm>,
             url=<url>,
@@ -77,6 +78,14 @@ class TimbrSqlAgent(BaseSingleActionAgent):
             retries=<retries>,
             note=<note>,
         )
+
+        # Using environment variables for timbr environment (TIMBR_URL, TIMBR_TOKEN, TIMBR_ONTOLOGY)
+        agent = TimbrSqlAgent(
+            llm=<llm>,
+        )
+
+        # Using environment variables for both timbr environment & llm (TIMBR_URL, TIMBR_TOKEN, TIMBR_ONTOLOGY, LLM_TYPE, LLM_API_KEY, etc.)
+        agent = TimbrSqlAgent()
         ```
         """
         super().__init__()
@@ -298,10 +307,10 @@ class TimbrSqlAgent(BaseSingleActionAgent):
 
 
 def create_timbr_sql_agent(
-    llm: LLM,
-    url: str,
-    token: str,
-    ontology: str,
+    llm: Optional[LLM] = None,
+    url: Optional[str] = None,
+    token: Optional[str] = None,
+    ontology: Optional[str] = None,
     schema: Optional[str] = 'dtimbr',
     concept: Optional[str] = None,
     concepts_list: Optional[Union[list[str], str]] = None,
@@ -327,10 +336,10 @@ def create_timbr_sql_agent(
     """
     Create and configure a Timbr agent with its executor.
     
-    :param llm: Language model to use
-    :param url: Timbr server URL
-    :param token: Timbr authentication token
-    :param ontology: Name of the ontology/knowledge graph
+    :param llm: An LLM instance or a function that takes a prompt string and returns the LLM's response (optional, will use LlmWrapper with env variables if not provided)
+    :param url: Timbr server URL (optional, defaults to TIMBR_URL environment variable)
+    :param token: Timbr authentication token (optional, defaults to TIMBR_TOKEN environment variable)
+    :param ontology: Name of the ontology/knowledge graph (optional, defaults to ONTOLOGY/TIMBR_ONTOLOGY environment variable)
     :param schema: Optional specific schema name to query
     :param concept: Optional specific concept name to query
     :param concepts_list: Optional specific concept options to query
@@ -357,6 +366,7 @@ def create_timbr_sql_agent(
     
     ## Example
         ```
+        # Using explicit parameters
         agent = create_timbr_sql_agent(
             llm=<llm>,
             url=<url>,
@@ -372,7 +382,15 @@ def create_timbr_sql_agent(
             retries=<retries>,
             note=<note>,
         )
-        
+
+        # Using environment variables for timbr environment (TIMBR_URL, TIMBR_TOKEN, TIMBR_ONTOLOGY)
+        agent = create_timbr_sql_agent(
+            llm=<llm>,
+        )
+
+        # Using environment variables for both timbr environment & llm (TIMBR_URL, TIMBR_TOKEN, TIMBR_ONTOLOGY, LLM_TYPE, LLM_API_KEY, etc.)
+        agent = create_timbr_sql_agent()
+
         result = agent.invoke("What are the total sales for last month?")
         
         # Access the components of the result:

langchain_timbr/langchain/validate_timbr_sql_chain.py

@@ -2,9 +2,11 @@ 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.general import parse_list, to_integer, to_boolean, validate_timbr_connection_params
 from ..utils.timbr_llm_utils import generate_sql
 from ..utils.timbr_utils import validate_sql
+from ..llm_wrapper.llm_wrapper import LlmWrapper
+from .. import config
 
 
 class ValidateTimbrSqlChain(Chain):
@@ -18,10 +20,10 @@ class ValidateTimbrSqlChain(Chain):
     
     def __init__(
         self,
-        llm: LLM,
-        url: str,
-        token: str,
-        ontology: str,
+        llm: Optional[LLM] = None,
+        url: Optional[str] = None,
+        token: Optional[str] = None,
+        ontology: Optional[str] = None,
         schema: Optional[str] = 'dtimbr',
         concept: Optional[str] = None,
         retries: Optional[int] = 3,
@@ -42,10 +44,10 @@ class ValidateTimbrSqlChain(Chain):
         **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 llm: An LLM instance or a function that takes a prompt string and returns the LLM's response (optional, will use LlmWrapper with env variables if not provided)
+        :param url: Timbr server url (optional, defaults to TIMBR_URL environment variable)
+        :param token: Timbr password or token value (optional, defaults to TIMBR_TOKEN environment variable)
+        :param ontology: The name of the ontology/knowledge graph (optional, defaults to ONTOLOGY/TIMBR_ONTOLOGY environment variable)
         :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
@@ -66,6 +68,7 @@ class ValidateTimbrSqlChain(Chain):
         
         ## Example
         ```
+        # Using explicit parameters
         validate_timbr_sql_chain = ValidateTimbrSqlChain(
             url=<url>,
             token=<token>,
@@ -80,14 +83,35 @@ class ValidateTimbrSqlChain(Chain):
             note=<note>,
         )
 
+        # Using environment variables for timbr environment (TIMBR_URL, TIMBR_TOKEN, TIMBR_ONTOLOGY)
+        validate_timbr_sql_chain = ValidateTimbrSqlChain(
+            llm=<llm or timbr_llm_wrapper instance>,
+        )
+        
+        # Using environment variables for both timbr environment & llm (TIMBR_URL, TIMBR_TOKEN, TIMBR_ONTOLOGY, LLM_TYPE, LLM_API_KEY, etc.)
+        validate_timbr_sql_chain = ValidateTimbrSqlChain()
+
         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
+        
+        # Initialize LLM - use provided one or create with LlmWrapper from env variables
+        if llm is not None:
+            self._llm = llm
+        else:
+            try:
+                self._llm = LlmWrapper()
+            except Exception as e:
+                raise ValueError(f"Failed to initialize LLM from environment variables. Either provide an llm parameter or ensure LLM_TYPE and LLM_API_KEY environment variables are set. Error: {e}")
+        
+        self._url = url if url is not None else config.url
+        self._token = token if token is not None else config.token
+        self._ontology = ontology if ontology is not None else config.ontology
+        
+        # Validate required parameters
+        validate_timbr_connection_params(self._url, self._token)
+        
         self._schema = schema
         self._concept = concept
         self._retries = retries

langchain_timbr/langgraph/execute_timbr_query_node.py

@@ -13,7 +13,7 @@ class ExecuteSemanticQueryNode:
     """
     def __init__(
         self,
-        llm: LLM,
+        llm: Optional[LLM] = None,
         url: Optional[str] = None,
         token: Optional[str] = None,
         ontology: Optional[str] = None,
@@ -40,10 +40,10 @@ class ExecuteSemanticQueryNode:
         **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 llm: An LLM instance or a function that takes a prompt string and returns the LLM's response (optional, will use LlmWrapper with env variables if not provided)
+        :param url: Timbr server url (optional, defaults to TIMBR_URL environment variable)
+        :param token: Timbr password or token value (optional, defaults to TIMBR_TOKEN environment variable)
+        :param ontology: The name of the ontology/knowledge graph (optional, defaults to ONTOLOGY/TIMBR_ONTOLOGY environment variable)
         :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
@@ -97,7 +97,7 @@ class ExecuteSemanticQueryNode:
     def run(self, state: StateGraph) -> dict:
         try:
             prompt = state.messages[-1].content if state.messages[-1] else None
-        except:
+        except Exception:
             prompt = state.get('prompt', None)
 
         return self.chain.invoke({ "prompt": prompt })

langchain_timbr/langgraph/generate_response_node.py

@@ -1,6 +1,5 @@
-from typing import Optional, Union
+from typing import Optional
 from langchain.llms.base import LLM
-from langgraph.graph import StateGraph
 
 from ..langchain import GenerateAnswerChain
 
@@ -14,9 +13,9 @@ class GenerateResponseNode:
     """
     def __init__(
         self,
-        llm: LLM,
-        url: str,
-        token: str,
+        llm: Optional[LLM] = None,
+        url: Optional[str] = None,
+        token: Optional[str] = None,
         verify_ssl: Optional[bool] = True,
         is_jwt: Optional[bool] = False,
         jwt_tenant_id: Optional[str] = None,
@@ -25,9 +24,9 @@ class GenerateResponseNode:
         **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 llm: An LLM instance or a function that takes a prompt string and returns the LLM's response (optional, will use LlmWrapper with env variables if not provided)
+        :param url: Timbr server url (optional, defaults to TIMBR_URL environment variable)
+        :param token: Timbr password or token value (optional, defaults to TIMBR_TOKEN environment variable)
         :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).

langchain_timbr/langgraph/generate_timbr_sql_node.py

@@ -11,7 +11,7 @@ class GenerateTimbrSqlNode:
     """
     def __init__(
         self,
-        llm: LLM,
+        llm: Optional[LLM] = None,
         url: Optional[str] = None,
         token: Optional[str] = None,
         ontology: Optional[str] = None,
@@ -36,10 +36,10 @@ class GenerateTimbrSqlNode:
         **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 llm: An LLM instance or a function that takes a prompt string and returns the LLM's response (optional, will use LlmWrapper with env variables if not provided)
+        :param url: Timbr server url (optional, defaults to TIMBR_URL environment variable)
+        :param token: Timbr password or token value (optional, defaults to TIMBR_TOKEN environment variable)
+        :param ontology: The name of the ontology/knowledge graph (optional, defaults to ONTOLOGY/TIMBR_ONTOLOGY environment variable)
         :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
@@ -88,7 +88,7 @@ class GenerateTimbrSqlNode:
     def run(self, state: StateGraph) -> dict:
         try:
             prompt = state.messages[-1].content if (state.messages and state.messages[-1]) else None
-        except:
+        except Exception:
             prompt = state.get('prompt', None)
 
         return self.chain.invoke({ "prompt": prompt })

langchain_timbr/langgraph/identify_concept_node.py

@@ -8,7 +8,7 @@ from ..langchain.identify_concept_chain import IdentifyTimbrConceptChain
 class IdentifyConceptNode:
     def __init__(
         self,
-        llm: LLM,
+        llm: Optional[LLM] = None,
         url: Optional[str] = None,
         token: Optional[str] = None,
         ontology: Optional[str] = None,
@@ -27,10 +27,10 @@ class IdentifyConceptNode:
         **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 llm: An LLM instance or a function that takes a prompt string and returns the LLM's response (optional, will use LlmWrapper with env variables if not provided)
+        :param url: Timbr server url (optional, defaults to TIMBR_URL environment variable)
+        :param token: Timbr password or token value (optional, defaults to TIMBR_TOKEN environment variable)
+        :param ontology: The name of the ontology/knowledge graph (optional, defaults to ONTOLOGY/TIMBR_ONTOLOGY environment variable)
         :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.
@@ -67,7 +67,7 @@ class IdentifyConceptNode:
     def run(self, state: StateGraph) -> dict:
         try:
           prompt = state.messages[-1].content if state.messages[-1] else None
-        except:
+        except Exception:
           prompt = state.get('prompt', None)
 
         return self.chain.invoke({ "prompt": prompt })

langchain_timbr/langgraph/validate_timbr_query_node.py

@@ -13,10 +13,10 @@ class ValidateSemanticSqlNode:
     """
     def __init__(
         self,
-        llm: LLM,
-        url: str,
-        token: str,
-        ontology: str,
+        llm: Optional[LLM] = None,
+        url: Optional[str] = None,
+        token: Optional[str] = None,
+        ontology: Optional[str] = None,
         schema: Optional[str] = None,
         concept: Optional[str] = None,
         retries: Optional[int] = 3,
@@ -37,10 +37,10 @@ class ValidateSemanticSqlNode:
         **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 llm: An LLM instance or a function that takes a prompt string and returns the LLM's response (optional, will use LlmWrapper with env variables if not provided)
+        :param url: Timbr server url (optional, defaults to TIMBR_URL environment variable)
+        :param token: Timbr password or token value (optional, defaults to TIMBR_TOKEN environment variable)
+        :param ontology: The name of the ontology/knowledge graph (optional, defaults to ONTOLOGY/TIMBR_ONTOLOGY environment variable)
         :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
@@ -88,7 +88,7 @@ class ValidateSemanticSqlNode:
         try:
             sql = state.sql
             prompt = state.prompt
-        except:
+        except Exception:
             sql = state.get('sql', None)
             prompt = state.get('prompt', None)
 

langchain_timbr/llm_wrapper/llm_wrapper.py

@@ -1,10 +1,11 @@
 from enum import Enum
+from typing import Optional
 from langchain.llms.base import LLM
 from pydantic import Field
 
 from .timbr_llm_wrapper import TimbrLlmWrapper
-from ..utils.general import is_llm_type, is_support_temperature
-from ..config import llm_temperature
+from ..utils.general import is_llm_type, is_support_temperature, get_supported_models, parse_additional_params
+from ..config import llm_temperature, llm_type as default_llm_type, llm_model as default_llm_model, llm_api_key as default_llm_api_key, llm_additional_params as default_llm_additional_params
 
 class LlmTypes(Enum):
   OpenAI = 'openai-chat'
@@ -21,29 +22,47 @@ class LlmWrapper(LLM):
   LlmWrapper is a unified interface for connecting to various Large Language Model (LLM) providers
   (OpenAI, Anthropic, Google, Azure OpenAI, Snowflake Cortex, Databricks, etc.) using LangChain. It abstracts
   the initialization and connection logic for each provider, allowing you to switch between them
-  with a consistent API.
   """
-  client: LLM = Field(default=None, exclude=True)
+  client: Optional[LLM] = Field(default=None, exclude=True)
 
   def __init__(
       self,
-      llm_type: str,
-      api_key: str,
-      model: str = None,
+      llm_type: Optional[str] = None,
+      api_key: Optional[str] = None,
+      model: Optional[str] = None,
       **llm_params,
   ):
       """
-      :param llm_type (str): The type of LLM provider (e.g., 'openai-chat', 'anthropic-chat').
-      :param api_key (str): The API key for authenticating with the LLM provider.
-      :param model (str): The model name or deployment to use. Defaults to provider-specific values (Optional).
+      :param llm_type (str, optional): The type of LLM provider (e.g., 'openai-chat', 'anthropic-chat').
+                                       If not provided, will try to get from LLM_TYPE environment variable.
+      :param api_key (str, optional): The API key for authenticating with the LLM provider. 
+                                     If not provided, will try to get from LLM_API_KEY environment variable.
+      :param model (str, optional): The model name or deployment to use. If not provided, will try to get from LLM_MODEL environment variable.
       :param **llm_params: Additional parameters for the LLM (e.g., temperature, endpoint, etc.).
       """
       super().__init__()
+      
+      selected_llm_type = llm_type or default_llm_type
+      selected_api_key = api_key or default_llm_api_key
+      selected_model = model or default_llm_model
+      selected_additional_params = llm_params.pop('additional_params', None)
+
+      # Parse additional parameters from init params or config and merge with provided params
+      default_additional_params = parse_additional_params(selected_additional_params or default_llm_additional_params or {})
+      additional_llm_params = {**default_additional_params, **llm_params}
+      
+      # Validation: Ensure we have the required parameters
+      if not selected_llm_type:
+          raise ValueError("llm_type must be provided either as parameter or in config (LLM_TYPE environment variable)")
+      
+      if not selected_api_key:
+          raise ValueError("api_key must be provided either as parameter or in config (LLM_API_KEY environment variable)")
+      
       self.client = self._connect_to_llm(
-        llm_type,
-        api_key,
-        model,
-        **llm_params,
+        selected_llm_type,
+        selected_api_key,
+        selected_model,
+        **additional_llm_params,
       )
 
 
@@ -168,7 +187,7 @@ class LlmWrapper(LLM):
           # For Azure, get the deployments instead of models
           try:
             models = [model.id for model in client.models.list()]
-          except:
+          except Exception:
             # If listing models fails, provide some common deployment names
             models = ["gpt-4o", "Other (Custom)"]
       elif is_llm_type(self._llm_type, LlmTypes.Snowflake):
@@ -185,8 +204,20 @@ class LlmWrapper(LLM):
         
       # elif self._is_llm_type(self._llm_type, LlmTypes.Timbr):
         
-    except Exception as e:
-      models = []
+    except Exception:
+      # If model list fetching throws an exception, return default value using get_supported_models
+      llm_type_name = None
+      if hasattr(self, '_llm_type'):
+        # Try to extract the LLM type name from the _llm_type
+        for llm_enum in LlmTypes:
+          if is_llm_type(self._llm_type, llm_enum):
+            llm_type_name = llm_enum.name
+            break
+      
+      if llm_type_name:
+        models = get_supported_models(llm_type_name)
+      else:
+        models = []
     
     return sorted(models)
 

langchain_timbr/utils/general.py

@@ -1,4 +1,5 @@
 import os
+from typing import Optional
 import json
 
 ### A global helper functions to use across the project
@@ -30,6 +31,43 @@ def to_integer(value) -> int:
         raise ValueError(f"Failed to parse integer value: {e}")
 
 
+def parse_additional_params(value) -> dict:
+    """
+    Parse additional parameters from string format 'a=1,b=2' or return dict as-is.
+    
+    Args:
+        value: String in format 'key=value,key2=value2', JSON string, or dict
+        
+    Returns:
+        Dictionary of parsed parameters
+    """
+    try:
+        if isinstance(value, dict):
+            return value
+        elif isinstance(value, str) and value.strip():
+            # Try to parse as JSON first
+            stripped_value = value.strip()
+            if stripped_value.startswith('{') and stripped_value.endswith('}'):
+                try:
+                    return json.loads(stripped_value)
+                except json.JSONDecodeError:
+                    pass
+            
+            # Fall back to key=value parsing
+            params = {}
+            for pair in (value.split('&') if '&' in value else value.split(',')):
+                if '=' in pair:
+                    key, val = pair.split('=', 1)
+                    params[key.strip()] = val.strip()
+                elif ':' in pair:
+                    key, val = pair.split(':', 1)
+                    params[key.strip()] = val.strip()
+            return params
+        return {}
+    except Exception as e:
+        raise ValueError(f"Failed to parse additional parameters: {e}")
+
+
 def is_llm_type(llm_type, enum_value):
     """Check if llm_type equals the enum value or its name, case-insensitive."""
     if llm_type == enum_value:
@@ -51,10 +89,42 @@ def is_llm_type(llm_type, enum_value):
     return False
   
 
+def validate_timbr_connection_params(url: Optional[str] = None, token: Optional[str] = None) -> None:
+    """
+    Validate that required Timbr connection parameters are provided.
+    
+    Args:
+        url: Timbr server URL
+        token: Timbr authentication token
+        
+    Raises:
+        ValueError: If URL or token are not provided with clear instructions
+    """
+    if not url:
+        raise ValueError("URL must be provided either through the 'url' parameter or by setting the 'TIMBR_URL' environment variable")
+    if not token:
+        raise ValueError("Token must be provided either through the 'token' parameter or by setting the 'TIMBR_TOKEN' environment variable")
+
+
 def is_support_temperature(llm_type: str, llm_model: str) -> bool:
     """
     Check if the LLM model supports temperature setting.
     """
+    supported_models = get_supported_models(llm_type)
+    return llm_model in supported_models
+
+
+def get_supported_models(llm_type: str) -> list[str]:
+    """
+    Get the list of supported models for a given LLM type.
+    
+    Args:
+        llm_type (str): The LLM type to get supported models for
+        
+    Returns:
+        list[str]: List of supported model names for the given LLM type.
+                   Returns empty list if llm_type is not found in the JSON file.
+    """
     current_dir = os.path.dirname(os.path.abspath(__file__))
     json_file_path = os.path.join(current_dir, 'temperature_supported_models.json')
 
@@ -62,10 +132,9 @@ def is_support_temperature(llm_type: str, llm_model: str) -> bool:
         with open(json_file_path, 'r') as f:
             temperature_supported_models = json.load(f)
         
-        # Check if llm_type exists and llm_model is in its list
-        if llm_type in temperature_supported_models:
-            return llm_model in temperature_supported_models[llm_type]
+        # Return the list of models for the given llm_type, or empty list if not found
+        return temperature_supported_models.get(llm_type, [])
         
-        return False
-    except (FileNotFoundError, json.JSONDecodeError, KeyError):
-        return False
+    except (FileNotFoundError, json.JSONDecodeError):
+        return []
+

langchain_timbr/utils/prompt_service.py

@@ -1,32 +1,45 @@
 import requests
 from typing import Dict, Any, Optional, List, Union
-from langchain.schema import SystemMessage, HumanMessage
 from langchain.prompts.chat import ChatPromptTemplate
 from langchain.prompts import SystemMessagePromptTemplate, HumanMessagePromptTemplate
 import json
 import logging
-
-from ..config import url, token as default_token, is_jwt, jwt_tenant_id as default_jwt_tenant_id, llm_timeout
+from ..config import url as default_url, token as default_token, is_jwt, jwt_tenant_id as default_jwt_tenant_id, llm_timeout
 
 logger = logging.getLogger(__name__)
 
 # Global template cache shared across all PromptService instances
-_global_template_cache = {}
+_global_template_cache: dict[Any, Any] = {}
 
 class PromptService:
     def __init__(
         self, 
-        base_url: Optional[str] = url, 
-        token: Optional[str] = default_token,
-        is_jwt: Optional[bool] = is_jwt,
-        jwt_tenant_id: Optional[str] = default_jwt_tenant_id,
-        timeout: Optional[int] = llm_timeout,
+        conn_params: Optional[Dict[str, Any]] = None,
+        **kwargs
     ):
-        self.base_url = base_url.rstrip('/') if base_url else ''
-        self.token = token
-        self.is_jwt = is_jwt
-        self.jwt_tenant_id = jwt_tenant_id
-        self.timeout = timeout
+        """
+        Initialize PromptService with connection parameters.
+        
+        Args:
+            conn_params: Dictionary containing connection parameters
+            **kwargs: Additional parameters for backward compatibility
+        """
+        # Extract relevant parameters from conn_params or use defaults
+        if conn_params:
+            url_value = conn_params.get('url') or default_url
+            self.base_url = url_value.rstrip('/') if url_value else ''
+            self.token = conn_params.get('token') or default_token
+            self.is_jwt = conn_params.get('is_jwt', is_jwt)
+            self.jwt_tenant_id = conn_params.get('jwt_tenant_id') or default_jwt_tenant_id
+            self.timeout = conn_params.get('timeout') or llm_timeout
+        else:
+            # Fallback to kwargs for backward compatibility
+            url_value = kwargs.get('url') or default_url
+            self.base_url = url_value.rstrip('/') if url_value else ''
+            self.token = str(kwargs.get('token') or default_token)
+            self.is_jwt = kwargs.get('is_jwt', is_jwt)
+            self.jwt_tenant_id = kwargs.get('jwt_tenant_id') or default_jwt_tenant_id
+            self.timeout = kwargs.get('timeout') or llm_timeout
 
     
     def _get_headers(self) -> Dict[str, str]:
@@ -220,99 +233,67 @@ class PromptTemplateWrapper:
 
 # Individual prompt template getter functions
 def get_determine_concept_prompt_template(
-    token: Optional[str] = None,
-    is_jwt: Optional[bool] = None,
-    jwt_tenant_id: Optional[str] = None
+    conn_params: Optional[dict] = None
 ) -> PromptTemplateWrapper:
     """
     Get determine concept prompt template wrapper
     
     Args:
-        token: Authentication token
-        is_jwt: Whether the token is a JWT
-        jwt_tenant_id: JWT tenant ID
-        
+        conn_params: Connection parameters including url, token, is_jwt, and jwt_tenant_id
+
     Returns:
         PromptTemplateWrapper for determine concept
     """
-    prompt_service = PromptService(
-        token=token,
-        is_jwt=is_jwt,
-        jwt_tenant_id=jwt_tenant_id
-    )
+    prompt_service = PromptService(conn_params=conn_params)
     return PromptTemplateWrapper(prompt_service, "get_identify_concept_template")
 
 
 def get_generate_sql_prompt_template(
-    token: Optional[str] = None,
-    is_jwt: Optional[bool] = None,
-    jwt_tenant_id: Optional[str] = None
+    conn_params: Optional[dict] = None
 ) -> PromptTemplateWrapper:
     """
     Get generate SQL prompt template wrapper
     
     Args:
-        token: Authentication token
-        is_jwt: Whether the token is a JWT
-        jwt_tenant_id: JWT tenant ID
+        conn_params: Connection parameters including url, token, is_jwt, and jwt_tenant_id
         
     Returns:
         PromptTemplateWrapper for generate SQL
     """
-    prompt_service = PromptService(
-        token=token,
-        is_jwt=is_jwt,
-        jwt_tenant_id=jwt_tenant_id
-    )
+    prompt_service = PromptService(conn_params=conn_params)
     return PromptTemplateWrapper(prompt_service, "get_generate_sql_template")
 
 
 def get_qa_prompt_template(
-    token: Optional[str] = None,
-    is_jwt: Optional[bool] = None,
-    jwt_tenant_id: Optional[str] = None
+    conn_params: Optional[dict] = None
 ) -> PromptTemplateWrapper:
     """
     Get QA prompt template wrapper
     
     Args:
-        token: Authentication token
-        is_jwt: Whether the token is a JWT
-        jwt_tenant_id: JWT tenant ID
-        
+        conn_params: Connection parameters including url, token, is_jwt, and jwt_tenant_id
+
     Returns:
         PromptTemplateWrapper for QA
     """
-    prompt_service = PromptService(
-        token=token,
-        is_jwt=is_jwt,
-        jwt_tenant_id=jwt_tenant_id
-    )
+    prompt_service = PromptService(conn_params=conn_params)
     return PromptTemplateWrapper(prompt_service, "get_generate_answer_template")
 
 
 # Global prompt service instance (updated signature)
 def get_prompt_service(
-    token: str = None,
-    is_jwt: bool = None, 
-    jwt_tenant_id: str = None
+    conn_params: Optional[dict] = None
 ) -> PromptService:
     """
     Get or create a prompt service instance
     
     Args:
-        token: Authentication token (API key or JWT token)
-        is_jwt: Whether the token is a JWT
-        jwt_tenant_id: JWT tenant ID
-        
+        conn_params: Connection parameters including url, token, is_jwt, and jwt_tenant_id
+
     Returns:
         PromptService instance
     """
-    return PromptService(
-        token=token,
-        is_jwt=is_jwt,
-        jwt_tenant_id=jwt_tenant_id
-    )
+    return PromptService(conn_params=conn_params)
 
 
 # Global cache management functions

langchain_timbr/utils/timbr_llm_utils.py

@@ -212,7 +212,7 @@ def determine_concept(
     note: Optional[str] = '',
     debug: Optional[bool] = False,
     timeout: Optional[int] = None,
-) -> dict[str, any]:
+) -> dict[str, Any]:
     usage_metadata = {}
     determined_concept_name = None
     schema = 'dtimbr'
@@ -221,7 +221,7 @@ def determine_concept(
     if timeout is None:
         timeout = llm_timeout
     
-    determine_concept_prompt = get_determine_concept_prompt_template(conn_params["token"], conn_params["is_jwt"], conn_params["jwt_tenant_id"])
+    determine_concept_prompt = get_determine_concept_prompt_template(conn_params)
     tags = get_tags(conn_params=conn_params, include_tags=include_tags)
     concepts = get_concepts(
         conn_params=conn_params,
@@ -418,7 +418,7 @@ def generate_sql(
     if timeout is None:
         timeout = llm_timeout
     
-    generate_sql_prompt = get_generate_sql_prompt_template(conn_params["token"], conn_params["is_jwt"], conn_params["jwt_tenant_id"])
+    generate_sql_prompt = get_generate_sql_prompt_template(conn_params)
    
     if concept and concept != "" and (schema is None or schema != "vtimbr"):
         concepts_list = [concept]
@@ -550,7 +550,7 @@ def answer_question(
     if timeout is None:
         timeout = llm_timeout
 
-    qa_prompt = get_qa_prompt_template(conn_params["token"], conn_params["is_jwt"], conn_params["jwt_tenant_id"])
+    qa_prompt = get_qa_prompt_template(conn_params)
 
     prompt = qa_prompt.format_messages(
         question=question,

{langchain_timbr-1.5.3.dist-info → langchain_timbr-1.5.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-timbr
-Version: 1.5.3
+Version: 1.5.5
 Summary: LangChain & LangGraph extensions that parse LLM prompts into Timbr semantic SQL and execute them.
 Project-URL: Homepage, https://github.com/WPSemantix/langchain-timbr
 Project-URL: Documentation, https://docs.timbr.ai/doc/docs/integration/langchain-sdk/

langchain_timbr-1.5.5.dist-info/RECORD

@@ -0,0 +1,28 @@
+langchain_timbr/__init__.py,sha256=gxd6Y6QDmYZtPlYVdXtPIy501hMOZXHjWh2qq4qzt_s,828
+langchain_timbr/_version.py,sha256=-6ligW2dI8j2jxE-2b0-iN0QH0LgHVSboUTjBV5nIrc,704
+langchain_timbr/config.py,sha256=DT2__mjaFCh8Eynm4czQM8vKRTxYVcNX3UJNU3epJwo,934
+langchain_timbr/timbr_llm_connector.py,sha256=OXRttlEOJf-dTyilnXR6b6Cgl_cWDYrXGXQfmDV6vc8,13206
+langchain_timbr/langchain/__init__.py,sha256=ejcsZKP9PK0j4WrrCCcvBXpDpP-TeRiVb21OIUJqix8,580
+langchain_timbr/langchain/execute_timbr_query_chain.py,sha256=g7VzCuywo7xlWIldjtGOV4dYsQB3KsO8VARCfKrZFHM,15461
+langchain_timbr/langchain/generate_answer_chain.py,sha256=euy8GcMOziMKpiJrmpiH-De-qKTaVV48TqTduDa5-PE,4711
+langchain_timbr/langchain/generate_timbr_sql_chain.py,sha256=6NPvidW8pwmaX3w7p7yNFwQTZ8Cnmb40ZznRQJ2dTFM,9023
+langchain_timbr/langchain/identify_concept_chain.py,sha256=kuzg0jJQpFGIiaxtNhdQ5K4HXveLVwONFNsoipPCteE,7169
+langchain_timbr/langchain/timbr_sql_agent.py,sha256=7S7USe3wnwxdBduBycHYVbXnywnvog-Bg67Tk8-2X_s,19551
+langchain_timbr/langchain/validate_timbr_sql_chain.py,sha256=sxT72asK-Cms4ZTiThWv58PgEBY1p_9hnUQwU35kPIQ,9492
+langchain_timbr/langgraph/__init__.py,sha256=mKBFd0x01jWpRujUWe-suX3FFhenPoDxrvzs8I0mum0,457
+langchain_timbr/langgraph/execute_timbr_query_node.py,sha256=rPx_V3OOh-JTGOwrEopHmOmFuM-ngBZdswkW9oZ43hU,5536
+langchain_timbr/langgraph/generate_response_node.py,sha256=BLmsDZfbhncRpO7PEfDpy7CnPE7a55j8QV5jfg30heQ,2247
+langchain_timbr/langgraph/generate_timbr_sql_node.py,sha256=wkau-NajblSVzNIro9IyqawULvz3XaCYSEdYW95vWco,4911
+langchain_timbr/langgraph/identify_concept_node.py,sha256=aiLDFEcz_vM4zZ_ULe1SvJKmI-e4Fb2SibZQaEPz_eY,3649
+langchain_timbr/langgraph/validate_timbr_query_node.py,sha256=-2fuieCz1hv6ua-17zfonme8LQ_OoPnoOBTdGSXkJgs,4793
+langchain_timbr/llm_wrapper/llm_wrapper.py,sha256=XK4tcm6GGX4fZfciVN1BgwAFk0YI5FdkmtMwFuUL-Po,9701
+langchain_timbr/llm_wrapper/timbr_llm_wrapper.py,sha256=sDqDOz0qu8b4WWlagjNceswMVyvEJ8yBWZq2etBh-T0,1362
+langchain_timbr/utils/general.py,sha256=UDKumpar8gPbfhBBf7-7xzuTDj5NCk4JJhctfePhOjU,4960
+langchain_timbr/utils/prompt_service.py,sha256=QT7kiq72rQno77z1-tvGGD7HlH_wdTQAl_1teSoKEv4,11373
+langchain_timbr/utils/temperature_supported_models.json,sha256=d3UmBUpG38zDjjB42IoGpHTUaf0pHMBRSPY99ao1a3g,1832
+langchain_timbr/utils/timbr_llm_utils.py,sha256=7-nnTa1T9XOcgIb-aJP3Pgon_gOrCMnDPiIPiAT3UCg,23016
+langchain_timbr/utils/timbr_utils.py,sha256=p21DwTGhF4iKTLDQBkeBaJDFcXt-Hpu1ij8xzQt00Ng,16958
+langchain_timbr-1.5.5.dist-info/METADATA,sha256=NcjtNkm167oxPOvd9CjGqzPm5hoONnPnYHPORQpo6rA,6129
+langchain_timbr-1.5.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langchain_timbr-1.5.5.dist-info/licenses/LICENSE,sha256=0ITGFk2alkC7-e--bRGtuzDrv62USIiVyV2Crf3_L_0,1065
+langchain_timbr-1.5.5.dist-info/RECORD,,

langchain_timbr-1.5.3.dist-info/RECORD

@@ -1,28 +0,0 @@
-langchain_timbr/__init__.py,sha256=gxd6Y6QDmYZtPlYVdXtPIy501hMOZXHjWh2qq4qzt_s,828
-langchain_timbr/_version.py,sha256=YmPxci9z5OdhwvwXu2qOrZdFU4K4N2lTtMkI0KAJCh0,704
-langchain_timbr/config.py,sha256=NOMjSpo0TVkWT8BdbiGSADU08iknF2bRltFLwQRhpwk,832
-langchain_timbr/timbr_llm_connector.py,sha256=OXRttlEOJf-dTyilnXR6b6Cgl_cWDYrXGXQfmDV6vc8,13206
-langchain_timbr/langchain/__init__.py,sha256=ejcsZKP9PK0j4WrrCCcvBXpDpP-TeRiVb21OIUJqix8,580
-langchain_timbr/langchain/execute_timbr_query_chain.py,sha256=we1qjMS2JdBPRkGMJTzyHkpY3yW62wlh3PF3bTkEe8U,13883
-langchain_timbr/langchain/generate_answer_chain.py,sha256=3q_Fe2tclZsdH0PFkNdZtO4Xe2WQQoxg4sekFic5zt4,3260
-langchain_timbr/langchain/generate_timbr_sql_chain.py,sha256=-RZcdJ1lsivOE6zAm_hyg9txaINMGHWnGmkZepCg2Dk,7458
-langchain_timbr/langchain/identify_concept_chain.py,sha256=m3Lzb0PVeSeE7YpfhjB1OY0x9jcR6a_lTYg5YTTDhIw,5588
-langchain_timbr/langchain/timbr_sql_agent.py,sha256=F-HVqziHS7bVxWTkmvrkseRP5uZTuHQ2JoZNorQR4J8,18025
-langchain_timbr/langchain/validate_timbr_sql_chain.py,sha256=SPW7zimqunZZLRD5d-trglL9RkqrWOy2vjkBc19CWhE,7919
-langchain_timbr/langgraph/__init__.py,sha256=mKBFd0x01jWpRujUWe-suX3FFhenPoDxrvzs8I0mum0,457
-langchain_timbr/langgraph/execute_timbr_query_node.py,sha256=ZL-HsBer073VmkJv59qFCNYJyKOgB8-Ziij4EEBD39c,5263
-langchain_timbr/langgraph/generate_response_node.py,sha256=gChNFSPjK9lKwblgWTia6ETxhY5aIbgGsEykyIlGd90,2065
-langchain_timbr/langgraph/generate_timbr_sql_node.py,sha256=qyL7uqB5k-Bv8rE12f2Ub7wlcAw-pQibEPP1SvFKLu0,4638
-langchain_timbr/langgraph/identify_concept_node.py,sha256=ot9TFdRg8FA9JYVrtHLVi5k0vmUHUfL4ptQDFYYqOoA,3376
-langchain_timbr/langgraph/validate_timbr_query_node.py,sha256=TypUs60OaBhOx9Ceq-15qNVuuAvfrFBjQsPRjWK1StQ,4469
-langchain_timbr/llm_wrapper/llm_wrapper.py,sha256=qd6MHbmJsU02no7bAReec3Ps4oYc_m0WPrDFqRY2Dlc,7735
-langchain_timbr/llm_wrapper/timbr_llm_wrapper.py,sha256=sDqDOz0qu8b4WWlagjNceswMVyvEJ8yBWZq2etBh-T0,1362
-langchain_timbr/utils/general.py,sha256=Psb9F9ylI0z-1Ddw0Hi74nKl03_aLanIV9YC-MJUdsw,2522
-langchain_timbr/utils/prompt_service.py,sha256=f-L2w-wRCF9GEMLC7GZy_gZ0pcnEQj0em-lDJvg2onY,11164
-langchain_timbr/utils/temperature_supported_models.json,sha256=d3UmBUpG38zDjjB42IoGpHTUaf0pHMBRSPY99ao1a3g,1832
-langchain_timbr/utils/timbr_llm_utils.py,sha256=Mn9Q9Wj97WuOZO3xKxZLjTQx31H22EACAPppz3B0JlE,23202
-langchain_timbr/utils/timbr_utils.py,sha256=p21DwTGhF4iKTLDQBkeBaJDFcXt-Hpu1ij8xzQt00Ng,16958
-langchain_timbr-1.5.3.dist-info/METADATA,sha256=jt8vCwK1a1hwjgTPxG2DzhNF0KO0CkqY-3kPTftejTc,6129
-langchain_timbr-1.5.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langchain_timbr-1.5.3.dist-info/licenses/LICENSE,sha256=0ITGFk2alkC7-e--bRGtuzDrv62USIiVyV2Crf3_L_0,1065
-langchain_timbr-1.5.3.dist-info/RECORD,,