MindsDB 25.7.2.0__py3-none-any.whl → 25.7.4.0__py3-none-any.whl

mindsdb/integrations/utilities/handler_utils.py

@@ -37,54 +37,74 @@ def get_api_key(
 
     # 1
     if "using" in create_args and f"{api_name.lower()}_api_key" in create_args["using"]:
-        return create_args["using"][f"{api_name.lower()}_api_key"]
+        api_key = create_args["using"][f"{api_name.lower()}_api_key"]
+        if api_key:
+            return api_key
 
     # 1.5 - Check for generic api_key in using
     if "using" in create_args and "api_key" in create_args["using"]:
-        return create_args["using"]["api_key"]
+        api_key = create_args["using"]["api_key"]
+        if api_key:
+            return api_key
 
     # 2
     if f"{api_name.lower()}_api_key" in create_args:
-        return create_args[f"{api_name.lower()}_api_key"]
+        api_key = create_args[f"{api_name.lower()}_api_key"]
+        if api_key:
+            return api_key
 
     # 2.5 - Check for generic api_key
     if "api_key" in create_args:
-        return create_args["api_key"]
+        api_key = create_args["api_key"]
+        if api_key:
+            return api_key
 
     # 3 - Check in params dictionary if it exists (for agents)
     if "params" in create_args and create_args["params"] is not None:
         if f"{api_name.lower()}_api_key" in create_args["params"]:
-            return create_args["params"][f"{api_name.lower()}_api_key"]
+            api_key = create_args["params"][f"{api_name.lower()}_api_key"]
+            if api_key:
+                return api_key
         # 3.5 - Check for generic api_key in params
         if "api_key" in create_args["params"]:
-            return create_args["params"]["api_key"]
+            api_key = create_args["params"]["api_key"]
+            if api_key:
+                return api_key
 
     # 4
     if engine_storage is not None:
         connection_args = engine_storage.get_connection_args()
         if f"{api_name.lower()}_api_key" in connection_args:
-            return connection_args[f"{api_name.lower()}_api_key"]
+            api_key = connection_args[f"{api_name.lower()}_api_key"]
+            if api_key:
+                return api_key
         # 4.5 - Check for generic api_key in connection_args
         if "api_key" in connection_args:
-            return connection_args["api_key"]
+            api_key = connection_args["api_key"]
+            if api_key:
+                return api_key
 
     # 5
     api_key = os.getenv(f"{api_name.lower()}_api_key")
-    if api_key is not None:
+    if api_key:
         return api_key
     api_key = os.getenv(f"{api_name.upper()}_API_KEY")
-    if api_key is not None:
+    if api_key:
         return api_key
 
     # 6
     config = Config()
     api_cfg = config.get(api_name, {})
     if f"{api_name.lower()}_api_key" in api_cfg:
-        return api_cfg[f"{api_name.lower()}_api_key"]
+        api_key = api_cfg[f"{api_name.lower()}_api_key"]
+        if api_key:
+            return api_key
 
     # 7
     if "api_keys" in create_args and api_name in create_args["api_keys"]:
-        return create_args["api_keys"][api_name]
+        api_key = create_args["api_keys"][api_name]
+        if api_key:
+            return api_key
 
     if strict:
         provider_upper = api_name.upper()

mindsdb/interfaces/agents/agents_controller.py

@@ -20,7 +20,7 @@ from mindsdb.utilities import log
 
 from mindsdb.utilities.exception import EntityExistsError, EntityNotExistsError
 
-from .constants import ASSISTANT_COLUMN, SUPPORTED_PROVIDERS, PROVIDER_TO_MODELS, DEFAULT_TEXT2SQL_DATABASE
+from .constants import ASSISTANT_COLUMN, SUPPORTED_PROVIDERS, PROVIDER_TO_MODELS
 from .langchain_agent import get_llm_provider
 
 logger = log.getLogger(__name__)
@@ -165,22 +165,27 @@ class AgentsController:
                  with one of keys is "name", and other is additional parameters for relationship agent<>skill
             provider (str): The provider of the model
             params (Dict[str, str]): Parameters to use when running the agent
+                data: Dict, data sources for an agent, keys:
+                  - knowledge_bases: List of KBs to use
+                  - tables: list of tables to use
+                model: Dict, parameters for the model to use
+                  - provider: The provider of the model (e.g., 'openai', 'google')
+                  - Other model-specific parameters like 'api_key', 'model_name', etc.
+                <provider>_api_key: API key for the provider (e.g., openai_api_key)
+
+                # Deprecated parameters:
                 database: The database to use for text2sql skills (default is 'mindsdb')
                 knowledge_base_database: The database to use for knowledge base queries (default is 'mindsdb')
                 include_tables: List of tables to include for text2sql skills
                 ignore_tables: List of tables to ignore for text2sql skills
                 include_knowledge_bases: List of knowledge bases to include for text2sql skills
                 ignore_knowledge_bases: List of knowledge bases to ignore for text2sql skills
-                <provider>_api_key: API key for the provider (e.g., openai_api_key)
-                data: Dict, data sources for an agent, keys:
-                  - knowledge_bases: List of KBs to use (alternative to `include_knowledge_bases`)
-                  - tables: list of tables to use (alternative to `include_tables`)
 
         Returns:
             agent (db.Agents): The created agent
 
         Raises:
-            ValueError: Agent with given name already exists, or skill/model with given name does not exist.
+            EntityExistsError: Agent with given name already exists, or skill/model with given name does not exist.
         """
         if project_name is None:
             project_name = default_project
@@ -189,7 +194,7 @@ class AgentsController:
         agent = self.get_agent(name, project_name)
 
         if agent is not None:
-            raise ValueError(f"Agent with name already exists: {name}")
+            raise EntityExistsError("Agent already exists", name)
 
         # No need to copy params since we're not preserving the original reference
         params = params or {}
@@ -223,48 +228,31 @@ class AgentsController:
             # It will be picked up by get_api_key() in handler_utils.py
             pass
 
-        # Extract table and knowledge base parameters from params
-        database = params.pop("database", None)
-        knowledge_base_database = params.pop("knowledge_base_database", DEFAULT_TEXT2SQL_DATABASE)
-        include_tables = params.pop("include_tables", None)
-        ignore_tables = params.pop("ignore_tables", None)
-        include_knowledge_bases = params.pop("include_knowledge_bases", None)
-        ignore_knowledge_bases = params.pop("ignore_knowledge_bases", None)
-
-        # Save the extracted parameters back to params for API responses only if they were explicitly provided
-        # or if they're needed for skills
-        need_params = include_tables or ignore_tables or include_knowledge_bases or ignore_knowledge_bases
-
-        if "database" in params or need_params:
-            params["database"] = database
+        depreciated_params = [
+            "database",
+            "knowledge_base_database",
+            "include_tables",
+            "ignore_tables",
+            "include_knowledge_bases",
+            "ignore_knowledge_bases",
+        ]
+        if any(param in params for param in depreciated_params):
+            raise ValueError(
+                f"Parameters {', '.join(depreciated_params)} are deprecated. "
+                "Use 'data' parameter with 'tables' and 'knowledge_bases' keys instead."
+            )
 
+        include_tables = None
+        include_knowledge_bases = None
         if "data" in params:
-            if include_knowledge_bases is None:
-                include_knowledge_bases = params["data"].get("knowledge_bases")
-            if include_tables is None:
-                include_tables = params["data"].get("tables")
-
-        if "knowledge_base_database" in params or include_knowledge_bases or ignore_knowledge_bases:
-            params["knowledge_base_database"] = knowledge_base_database
-
-        if include_tables is not None:
-            params["include_tables"] = include_tables
-        if ignore_tables is not None:
-            params["ignore_tables"] = ignore_tables
-        if include_knowledge_bases is not None:
-            params["include_knowledge_bases"] = include_knowledge_bases
-        if ignore_knowledge_bases is not None:
-            params["ignore_knowledge_bases"] = ignore_knowledge_bases
+            include_knowledge_bases = params["data"].get("knowledge_bases")
+            include_tables = params["data"].get("tables")
 
         # Convert string parameters to lists if needed
         if isinstance(include_tables, str):
             include_tables = [t.strip() for t in include_tables.split(",")]
-        if isinstance(ignore_tables, str):
-            ignore_tables = [t.strip() for t in ignore_tables.split(",")]
         if isinstance(include_knowledge_bases, str):
             include_knowledge_bases = [kb.strip() for kb in include_knowledge_bases.split(",")]
-        if isinstance(ignore_knowledge_bases, str):
-            ignore_knowledge_bases = [kb.strip() for kb in ignore_knowledge_bases.split(",")]
 
         # Auto-create SQL skill if no skills are provided but include_tables or include_knowledge_bases params are provided
         if not skills and (include_tables or include_knowledge_bases):
@@ -272,23 +260,15 @@ class AgentsController:
             skill_name = f"{name}_sql_skill"
             skill_params = {
                 "type": "sql",
-                "database": database,
                 "description": f"Auto-generated SQL skill for agent {name}",
             }
 
-            # Add table restrictions if provided
+            # Add restrictions provided
             if include_tables:
                 skill_params["include_tables"] = include_tables
-            if ignore_tables:
-                skill_params["ignore_tables"] = ignore_tables
-
-            # Add knowledge base parameters if provided
-            if knowledge_base_database:
-                skill_params["knowledge_base_database"] = knowledge_base_database
             if include_knowledge_bases:
                 skill_params["include_knowledge_bases"] = include_knowledge_bases
-            if ignore_knowledge_bases:
-                skill_params["ignore_knowledge_bases"] = ignore_knowledge_bases
+
             try:
                 # Check if skill already exists
                 existing_skill = self.skills_controller.get_skill(skill_name, project_name)
@@ -340,44 +320,16 @@ class AgentsController:
                 db.session.rollback()
                 raise ValueError(f"Skill with name does not exist: {skill_name}")
 
-            if existing_skill.type == "sql":
-                # Run Data Catalog loader if enabled
-                if config.get("data_catalog", {}).get("enabled", False):
-                    if include_tables:
-                        database_table_map = {}
-                        for table in include_tables:
-                            parts = table.split(".", 1)
-                            database_table_map[parts[0]] = database_table_map.get(parts[0], []) + [parts[1]]
-
-                        for database_name, table_names in database_table_map.items():
-                            data_catalog_loader = DataCatalogLoader(
-                                database_name=database_name, table_names=table_names
-                            )
-                            data_catalog_loader.load_metadata()
-
-                    elif "database" in existing_skill.params:
-                        data_catalog_loader = DataCatalogLoader(
-                            database_name=existing_skill.params["database"],
-                            table_names=parameters["tables"] if "tables" in parameters else None,
-                        )
-                        data_catalog_loader.load_metadata()
-
-                    else:
-                        raise ValueError(
-                            "Data Catalog loading is enabled, but the provided parameters are insufficient to load metadata. "
-                        )
+            # Run Data Catalog loader if enabled.
+            if include_tables:
+                self._run_data_catalog_loader_for_table_entries(include_tables, project_name, skill=existing_skill)
+            else:
+                self._run_data_catalog_loader_for_skill(existing_skill, project_name, tables=parameters.get("tables"))
 
+            if existing_skill.type == "sql":
                 # Add table restrictions if this is a text2sql skill
-                if include_tables or ignore_tables:
-                    parameters["tables"] = include_tables or ignore_tables
-
-                # Pass database parameter if provided
-                if database and "database" not in parameters:
-                    parameters["database"] = database
-
-                # Pass knowledge base database parameter if provided
-                if knowledge_base_database and "knowledge_base_database" not in parameters:
-                    parameters["knowledge_base_database"] = knowledge_base_database
+                if include_tables:
+                    parameters["tables"] = include_tables
 
                 # Add knowledge base parameters to both the skill and the association parameters
                 if include_knowledge_bases:
@@ -385,16 +337,6 @@ class AgentsController:
                     if "include_knowledge_bases" not in existing_skill.params:
                         existing_skill.params["include_knowledge_bases"] = include_knowledge_bases
                         flag_modified(existing_skill, "params")
-                elif ignore_knowledge_bases:
-                    parameters["ignore_knowledge_bases"] = ignore_knowledge_bases
-                    if "ignore_knowledge_bases" not in existing_skill.params:
-                        existing_skill.params["ignore_knowledge_bases"] = ignore_knowledge_bases
-                        flag_modified(existing_skill, "params")
-
-                # Ensure knowledge_base_database is set in the skill's params
-                if knowledge_base_database and "knowledge_base_database" not in existing_skill.params:
-                    existing_skill.params["knowledge_base_database"] = knowledge_base_database
-                    flag_modified(existing_skill, "params")
 
             association = db.AgentSkillsAssociation(parameters=parameters, agent=agent, skill=existing_skill)
             db.session.add(association)
@@ -462,6 +404,8 @@ class AgentsController:
             raise ValueError("It is forbidden to change properties of the demo object")
 
         if name is not None and name != agent_name:
+            if not name.islower():
+                raise ValueError(f"The name must be in lower case: {name}")
             # Check to see if updated name already exists
             agent_with_new_name = self.get_agent(name, project_name=project_name)
             if agent_with_new_name is not None:
@@ -503,12 +447,20 @@ class AgentsController:
 
             # add skills
             for skill_name in set(skills_to_add_names) - set(existing_agent_skills_names):
+                # Run Data Catalog loader if enabled for the new skill
+                self._run_data_catalog_loader_for_skill(
+                    skill_name,
+                    project_name,
+                    tables=next((x for x in skills_to_add if x["name"] == skill_name), {}).get("tables"),
+                )
+
                 skill_parameters = next(x for x in skills_to_add if x["name"] == skill_name).copy()
                 del skill_parameters["name"]
                 association = db.AgentSkillsAssociation(
                     parameters=skill_parameters, agent=existing_agent, skill=skill_name_to_record_map[skill_name]
                 )
                 db.session.add(association)
+
         elif len(skills_to_rewrite) > 0:
             skill_name_to_parameters = {
                 x["name"]: {k: v for k, v in x.items() if k != "name"} for x in skills_to_rewrite
@@ -519,9 +471,23 @@ class AgentsController:
                     db.session.delete(rel)
                 else:
                     existing_skill_names.add(rel.skill.name)
-                    rel.parameters = skill_name_to_parameters[rel.skill.name]
+                    skill_parameters = skill_name_to_parameters[rel.skill.name]
+
+                    # Run Data Catalog loader if enabled for the updated skill
+                    self._run_data_catalog_loader_for_skill(
+                        rel.skill.name, project_name, tables=skill_parameters.get("tables")
+                    )
+
+                    rel.parameters = skill_parameters
                     flag_modified(rel, "parameters")
             for new_skill_name in set(skill_name_to_parameters) - existing_skill_names:
+                # Run Data Catalog loader if enabled for the new skill
+                self._run_data_catalog_loader_for_skill(
+                    new_skill_name,
+                    project_name,
+                    tables=skill_name_to_parameters[new_skill_name].get("tables"),
+                )
+
                 association = db.AgentSkillsAssociation(
                     parameters=skill_name_to_parameters[new_skill_name],
                     agent=existing_agent,
@@ -530,8 +496,17 @@ class AgentsController:
                 db.session.add(association)
 
         if params is not None:
-            # Merge params on update
             existing_params = existing_agent.params or {}
+
+            if params.get("data", {}).get("tables"):
+                new_table_entries = set(params["data"]["tables"]) - set(
+                    existing_params.get("data", {}).get("tables", [])
+                )
+                if new_table_entries:
+                    # Run Data Catalog loader for new table entries if enabled.
+                    self._run_data_catalog_loader_for_table_entries(new_table_entries, project_name)
+
+            # Merge params on update
             existing_params.update(params)
             # Remove None values entirely.
             params = {k: v for k, v in existing_params.items() if v is not None}
@@ -543,6 +518,86 @@ class AgentsController:
 
         return existing_agent
 
+    def _run_data_catalog_loader_for_skill(
+        self,
+        skill: Union[str, db.Skills],
+        project_name: str,
+        tables: List[str] = None,
+    ):
+        """
+        Runs Data Catalog loader for a skill if enabled in the config.
+        This is used to load metadata for SQL skills when they are added or updated.
+        """
+        if not config.get("data_catalog", {}).get("enabled", False):
+            return
+
+        skill = skill if isinstance(skill, db.Skills) else self.skills_controller.get_skill(skill, project_name)
+        if skill.type == "sql":
+            if "database" in skill.params:
+                valid_table_names = skill.params.get("tables") if skill.params.get("tables") else tables
+                data_catalog_loader = DataCatalogLoader(
+                    database_name=skill.params["database"], table_names=valid_table_names
+                )
+                data_catalog_loader.load_metadata()
+            else:
+                raise ValueError(
+                    "Data Catalog loading is enabled, but the provided parameters for the new skills are insufficient to load metadata. "
+                )
+
+    def _run_data_catalog_loader_for_table_entries(
+        self,
+        table_entries: List[str],
+        project_name: str,
+        skill: Union[str, db.Skills] = None,
+    ):
+        """
+        Runs Data Catalog loader for a list of table entries if enabled in the config.
+        This is used to load metadata for SQL skills when they are added or updated.
+        """
+        if not config.get("data_catalog", {}).get("enabled", False):
+            return
+
+        skill = skill if isinstance(skill, db.Skills) else self.skills_controller.get_skill(skill, project_name)
+        if not skill or skill.type == "sql":
+            database_table_map = {}
+            for table_entry in table_entries:
+                parts = table_entry.split(".", 1)
+
+                # Ensure the table name is in 'database.table' format.
+                if len(parts) != 2:
+                    logger.warning(
+                        f"Invalid table name format: {table_entry}. Expected 'database.table' format."
+                        "Metadata will not be loaded for this entry."
+                    )
+                    continue
+
+                database, table = parts[0], parts[1]
+
+                # Wildcards in database names are not supported at the moment by data catalog loader.
+                if "*" in database:
+                    logger.warning(
+                        f"Invalid database name format: {database}. Wildcards are not supported."
+                        "Metadata will not be loaded for this entry."
+                    )
+                    continue
+
+                # Wildcards in table names are supported either.
+                # However, the table name itself can be a wildcard representing all tables.
+                if table == "*":
+                    table = None
+                elif "*" in table:
+                    logger.warning(
+                        f"Invalid table name format: {table}. Wildcards are not supported."
+                        "Metadata will not be loaded for this entry."
+                    )
+                    continue
+
+                database_table_map[database] = database_table_map.get(database, []) + [table]
+
+            for database_name, table_names in database_table_map.items():
+                data_catalog_loader = DataCatalogLoader(database_name=database_name, table_names=table_names)
+                data_catalog_loader.load_metadata()
+
     def delete_agent(self, agent_name: str, project_name: str = default_project):
         """
         Deletes an agent by name.
@@ -584,20 +639,22 @@ class AgentsController:
     def get_completion(
         self,
         agent: db.Agents,
-        messages: List[Dict[str, str]],
+        messages: list[Dict[str, str]],
         project_name: str = default_project,
-        tools: List[BaseTool] = None,
+        tools: list[BaseTool] = None,
         stream: bool = False,
+        params: dict | None = None,
     ) -> Union[Iterator[object], pd.DataFrame]:
         """
         Queries an agent to get a completion.
 
         Parameters:
             agent (db.Agents): Existing agent to get completion from
-            messages (List[Dict[str, str]]): Chat history to send to the agent
+            messages (list[Dict[str, str]]): Chat history to send to the agent
             project_name (str): Project the agent belongs to (default mindsdb)
-            tools (List[BaseTool]): Tools to use while getting the completion
+            tools (list[BaseTool]): Tools to use while getting the completion
             stream (bool): Whether to stream the response
+            params (dict | None): params to redefine agent params
 
         Returns:
             response (Union[Iterator[object], pd.DataFrame]): Completion as a DataFrame or iterator of completion chunks
@@ -606,7 +663,7 @@ class AgentsController:
             ValueError: Agent's model does not exist.
         """
         if stream:
-            return self._get_completion_stream(agent, messages, project_name=project_name, tools=tools)
+            return self._get_completion_stream(agent, messages, project_name=project_name, tools=tools, params=params)
         from .langchain_agent import LangchainAgent
 
         model, provider = self.check_model_provider(agent.model_name, agent.provider)
@@ -619,25 +676,27 @@ class AgentsController:
         llm_params = self.get_agent_llm_params(agent.params)
 
         lang_agent = LangchainAgent(agent, model, llm_params=llm_params)
-        return lang_agent.get_completion(messages)
+        return lang_agent.get_completion(messages, params=params)
 
     def _get_completion_stream(
         self,
         agent: db.Agents,
-        messages: List[Dict[str, str]],
+        messages: list[Dict[str, str]],
         project_name: str = default_project,
-        tools: List[BaseTool] = None,
+        tools: list[BaseTool] = None,
+        params: dict | None = None,
     ) -> Iterator[object]:
         """
         Queries an agent to get a stream of completion chunks.
 
         Parameters:
             agent (db.Agents): Existing agent to get completion from
-            messages (List[Dict[str, str]]): Chat history to send to the agent
+            messages (list[Dict[str, str]]): Chat history to send to the agent
             trace_id (str): ID of Langfuse trace to use
             observation_id (str): ID of parent Langfuse observation to use
             project_name (str): Project the agent belongs to (default mindsdb)
-            tools (List[BaseTool]): Tools to use while getting the completion
+            tools (list[BaseTool]): Tools to use while getting the completion
+            params (dict | None): params to redefine agent params
 
         Returns:
             chunks (Iterator[object]): Completion chunks as an iterator
@@ -659,4 +718,4 @@ class AgentsController:
         llm_params = self.get_agent_llm_params(agent.params)
 
         lang_agent = LangchainAgent(agent, model=model, llm_params=llm_params)
-        return lang_agent.get_completion(messages, stream=True)
+        return lang_agent.get_completion(messages, stream=True, params=params)

mindsdb/interfaces/agents/langchain_agent.py

@@ -321,7 +321,7 @@ class LangchainAgent:
             self.provider,
         ]
 
-    def get_completion(self, messages, stream: bool = False):
+    def get_completion(self, messages, stream: bool = False, params: dict | None = None):
         # Get metadata and tags to be used in the trace
         metadata = self.get_metadata()
         tags = self.get_tags()
@@ -342,7 +342,9 @@ class LangchainAgent:
         if stream:
             return self._get_completion_stream(messages)
 
-        args = self.args
+        args = {}
+        args.update(self.args)
+        args.update(params or {})
 
         df = pd.DataFrame(messages)
 
@@ -598,7 +600,12 @@ AI: {response}"""
                     completions.append(result[ASSISTANT_COLUMN])
                     contexts.append(result[CONTEXT_COLUMN])
             except TimeoutError:
-                timeout_message = "I'm sorry! I couldn't come up with a response in time. Please try again."
+                timeout_message = (
+                    f"I'm sorry! I couldn't generate a response within the allotted time ({agent_timeout_seconds} seconds). "
+                    "If you need more time for processing, you can adjust the timeout settings. "
+                    "Please refer to the documentation for instructions on how to change the timeout value. "
+                    "Feel free to try your request again."
+                )
                 logger.warning(f"Agent execution timed out after {agent_timeout_seconds} seconds")
                 for _ in range(len(futures) - len(completions)):
                     completions.append(timeout_message)

mindsdb/interfaces/data_catalog/data_catalog_loader.py

@@ -1,7 +1,7 @@
 from typing import List, Union
-
 import pandas as pd
-
+import json
+import datetime
 from mindsdb.integrations.libs.response import RESPONSE_TYPE
 from mindsdb.interfaces.data_catalog.base_data_catalog import BaseDataCatalog
 from mindsdb.interfaces.storage import db
@@ -120,7 +120,7 @@ class DataCatalogLoader(BaseDataCatalog):
         Load the column metadata from the handler.
         """
         self.logger.info(f"Loading columns for {self.database_name}")
-        response = self.data_handler.meta_get_columns(self.table_names)
+        response = self.data_handler.meta_get_columns([table.name for table in tables])
         if response.resp_type == RESPONSE_TYPE.ERROR:
             self.logger.error(f"Failed to load columns for {self.database_name}: {response.error_message}")
             return []
@@ -168,7 +168,7 @@ class DataCatalogLoader(BaseDataCatalog):
         Load the column statistics metadata from the handler.
         """
         self.logger.info(f"Loading column statistics for {self.database_name}")
-        response = self.data_handler.meta_get_column_statistics(self.table_names)
+        response = self.data_handler.meta_get_column_statistics([table.name for table in tables])
         if response.resp_type == RESPONSE_TYPE.ERROR:
             self.logger.error(f"Failed to load column statistics for {self.database_name}: {response.error_message}")
             return
@@ -204,6 +204,8 @@ class DataCatalogLoader(BaseDataCatalog):
                 # Convert the distinct_values_count to an integer if it is not NaN, otherwise set it to None.
                 val = row.get("distinct_values_count")
                 distinct_values_count = int(val) if pd.notna(val) else None
+                min_val = row.get("minimum_value")
+                max_val = row.get("maximum_value")
 
                 # Convert the most_common_frequencies to a list of strings.
                 most_common_frequencies = [str(val) for val in row.get("most_common_frequencies") or []]
@@ -214,8 +216,8 @@ class DataCatalogLoader(BaseDataCatalog):
                     most_common_frequencies=most_common_frequencies,
                     null_percentage=row.get("null_percentage"),
                     distinct_values_count=distinct_values_count,
-                    minimum_value=row.get("minimum_value"),
-                    maximum_value=row.get("maximum_value"),
+                    minimum_value=self.to_str(min_val),
+                    maximum_value=self.to_str(max_val),
                 )
                 column_statistics.append(record)
 
@@ -231,7 +233,7 @@ class DataCatalogLoader(BaseDataCatalog):
         Load the primary keys metadata from the handler.
         """
         self.logger.info(f"Loading primary keys for {self.database_name}")
-        response = self.data_handler.meta_get_primary_keys(self.table_names)
+        response = self.data_handler.meta_get_primary_keys([table.name for table in tables])
         if response.resp_type == RESPONSE_TYPE.ERROR:
             self.logger.error(f"Failed to load primary keys for {self.database_name}: {response.error_message}")
             return
@@ -283,7 +285,7 @@ class DataCatalogLoader(BaseDataCatalog):
         Load the foreign keys metadata from the handler.
         """
         self.logger.info(f"Loading foreign keys for {self.database_name}")
-        response = self.data_handler.meta_get_foreign_keys(self.table_names)
+        response = self.data_handler.meta_get_foreign_keys([table.name for table in tables])
         if response.resp_type == RESPONSE_TYPE.ERROR:
             self.logger.error(f"Failed to foreign keys for {self.database_name}: {response.error_message}")
             return
@@ -373,3 +375,15 @@ class DataCatalogLoader(BaseDataCatalog):
             db.session.delete(table)
         db.session.commit()
         self.logger.info(f"Metadata for {self.database_name} removed successfully.")
+
+    def to_str(self, val) -> str:
+        """
+        Convert a value to a string.
+        """
+        if val is None:
+            return None
+        if isinstance(val, (datetime.datetime, datetime.date)):
+            return val.isoformat()
+        if isinstance(val, (list, dict, set, tuple)):
+            return json.dumps(val, default=str)
+        return str(val)