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

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,16 +165,21 @@ 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
@@ -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

@@ -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
@@ -233,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
@@ -285,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

mindsdb/interfaces/database/database.py

@@ -18,18 +18,30 @@ class DatabaseController:
         self.logs_db_controller = LogDBController()
         self.information_schema_controller = None
 
-    def delete(self, name: str):
+    def delete(self, name: str, strict_case: bool = False) -> None:
+        """Delete a database (project or integration) by name.
+
+        Args:
+            name (str): The name of the database to delete.
+            strict_case (bool, optional): If True, the database name is case-sensitive. Defaults to False.
+
+        Raises:
+            EntityNotExistsError: If the database does not exist.
+            Exception: If the database cannot be deleted.
+
+        Returns:
+            None
+        """
         databases = self.get_dict()
-        name = name.lower()
-        if name not in databases:
+        if name.lower() not in databases:
             raise EntityNotExistsError("Database does not exists", name)
-        db_type = databases[name]["type"]
+        db_type = databases[name.lower()]["type"]
         if db_type == "project":
-            project = self.get_project(name)
+            project = self.get_project(name, strict_case)
             project.delete()
             return
         elif db_type == "data":
-            self.integration_controller.delete(name)
+            self.integration_controller.delete(name, strict_case)
             return
         else:
             raise Exception(f"Database with type '{db_type}' cannot be deleted")
@@ -81,9 +93,9 @@ class DatabaseController:
 
         return result
 
-    def get_dict(self, filter_type: Optional[str] = None):
+    def get_dict(self, filter_type: Optional[str] = None, lowercase: bool = True):
         return OrderedDict(
-            (x["name"].lower(), {"type": x["type"], "engine": x["engine"], "id": x["id"]})
+            (x["name"].lower() if lowercase else x["name"], {"type": x["type"], "engine": x["engine"], "id": x["id"]})
             for x in self.get_list(filter_type=filter_type)
         )
 
@@ -98,8 +110,17 @@ class DatabaseController:
     def exists(self, db_name: str) -> bool:
         return db_name.lower() in self.get_dict()
 
-    def get_project(self, name: str):
-        return self.project_controller.get(name=name)
+    def get_project(self, name: str, strict_case: bool = False):
+        """Get a project by name.
+
+        Args:
+            name (str): The name of the project to retrieve.
+            strict_case (bool, optional): If True, the project name is case-sensitive. Defaults to False.
+
+        Returns:
+            Project: The project instance matching the given name.
+        """
+        return self.project_controller.get(name=name, strict_case=strict_case)
 
     def get_system_db(self, name: str):
         if name == "log":
@@ -112,19 +133,21 @@ class DatabaseController:
         else:
             raise Exception(f"Database '{name}' does not exists")
 
-    def update(self, name: str, data: dict):
+    def update(self, name: str, data: dict, strict_case: bool = False):
         """
         Updates the database with the given name using the provided data.
 
         Parameters:
             name (str): The name of the database to update.
             data (dict): The data to update the database with.
+            strict_case (bool): if True, then name is case-sesitive
 
         Raises:
             EntityNotExistsError: If the database does not exist.
         """
-        databases = self.get_dict()
-        name = name.lower()
+        databases = self.get_dict(lowercase=(not strict_case))
+        if not strict_case:
+            name = name.lower()
         if name not in databases:
             raise EntityNotExistsError("Database does not exist.", name)
 
@@ -133,6 +156,8 @@ class DatabaseController:
             # Only the name of the project can be updated.
             if {"name"} != set(data):
                 raise ValueError("Only the 'name' field can be updated for projects.")
+            if not data["name"].islower():
+                raise ValueError("New name must be in lower case.")
             self.project_controller.update(name=name, new_name=str(data["name"]))
             return
 

mindsdb/interfaces/database/integrations.py

@@ -161,7 +161,7 @@ class IntegrationController:
         db.session.commit()
         return integration_record.id
 
-    def add(self, name, engine, connection_args):
+    def add(self, name: str, engine, connection_args):
         logger.debug(
             "%s: add method calling name=%s, engine=%s, connection_args=%s, company_id=%s",
             self.__class__.__name__,
@@ -172,6 +172,9 @@ class IntegrationController:
         )
         handler_meta = self.get_handler_meta(engine)
 
+        if not name.islower():
+            raise ValueError(f"The name must be in lower case: {name}")
+
         accept_connection_args = handler_meta.get("connection_args")
         logger.debug("%s: accept_connection_args - %s", self.__class__.__name__, accept_connection_args)
 
@@ -210,20 +213,32 @@ class IntegrationController:
         integration_record.data = data
         db.session.commit()
 
-    def delete(self, name):
-        if name in ("files", "lightwood"):
+    def delete(self, name: str, strict_case: bool = False) -> None:
+        """Delete an integration by name.
+
+        Args:
+            name (str): The name of the integration to delete.
+            strict_case (bool, optional): If True, the integration name is case-sensitive. Defaults to False.
+
+        Raises:
+            Exception: If the integration cannot be deleted (system, permanent, demo, in use, or has active models).
+
+        Returns:
+            None
+        """
+        if name == "files":
             raise Exception("Unable to drop: is system database")
 
         self.handlers_cache.delete(name)
 
         # check permanent integration
-        if name in self.handler_modules:
+        if name.lower() in self.handler_modules:
             handler = self.handler_modules[name]
 
             if getattr(handler, "permanent", False) is True:
                 raise Exception("Unable to drop permanent integration")
 
-        integration_record = self._get_integration_record(name)
+        integration_record = self._get_integration_record(name, case_sensitive=strict_case)
         if isinstance(integration_record.data, dict) and integration_record.data.get("is_demo") is True:
             raise Exception("Unable to drop demo object")