MindsDB 25.9.1.0__py3-none-any.whl → 25.9.1.1__py3-none-any.whl

mindsdb/interfaces/knowledge_base/controller.py

@@ -245,22 +245,34 @@ class KnowledgeBaseTable:
         keyword_search_cols_and_values = []
         query_text = None
         relevance_threshold = None
+        relevance_threshold_allowed_operators = [
+            FilterOperator.GREATER_THAN_OR_EQUAL.value,
+            FilterOperator.GREATER_THAN.value,
+        ]
+        gt_filtering = False
         hybrid_search_enabled_flag = False
         query_conditions = db_handler.extract_conditions(query.where)
         hybrid_search_alpha = None  # Default to None, meaning no alpha weighted blending
         if query_conditions is not None:
             for item in query_conditions:
-                if item.column == "relevance" and item.op.value == FilterOperator.GREATER_THAN_OR_EQUAL.value:
+                if (item.column == "relevance") and (item.op.value in relevance_threshold_allowed_operators):
                     try:
                         relevance_threshold = float(item.value)
                         # Validate range: must be between 0 and 1
                         if not (0 <= relevance_threshold <= 1):
                             raise ValueError(f"relevance_threshold must be between 0 and 1, got: {relevance_threshold}")
+                        if item.op.value == FilterOperator.GREATER_THAN.value:
+                            gt_filtering = True
                         logger.debug(f"Found relevance_threshold in query: {relevance_threshold}")
                     except (ValueError, TypeError) as e:
                         error_msg = f"Invalid relevance_threshold value: {item.value}. {str(e)}"
                         logger.error(error_msg)
                         raise ValueError(error_msg)
+                elif (item.column == "relevance") and (item.op.value not in relevance_threshold_allowed_operators):
+                    raise ValueError(
+                        f"Invalid operator for relevance: {item.op.value}. Only the following operators are allowed: "
+                        f"{','.join(relevance_threshold_allowed_operators)}."
+                    )
                 elif item.column == "reranking":
                     if item.value is False or (isinstance(item.value, str) and item.value.lower() == "false"):
                         disable_reranking = True
@@ -279,10 +291,6 @@ class KnowledgeBaseTable:
                     if not (0 <= item.value <= 1):
                         raise ValueError(f"Invalid hybrid_search_alpha value: {item.value}. Must be between 0 and 1.")
                     hybrid_search_alpha = item.value
-                elif item.column == "relevance" and item.op.value != FilterOperator.GREATER_THAN_OR_EQUAL.value:
-                    raise ValueError(
-                        f"Invalid operator for relevance: {item.op.value}. Only GREATER_THAN_OR_EQUAL is allowed."
-                    )
                 elif item.column == TableField.CONTENT.value:
                     query_text = item.value
 
@@ -368,6 +376,11 @@ class KnowledgeBaseTable:
         # Check if we have a rerank_model configured in KB params
         df = self.add_relevance(df, query_text, relevance_threshold, disable_reranking)
 
+        # if relevance filtering method is strictly GREATER THAN we filter the df
+        if gt_filtering:
+            relevance_scores = TableField.RELEVANCE.value
+            df = df[relevance_scores > relevance_threshold]
+
         return df
 
     def _get_allowed_metadata_columns(self) -> List[str] | None:
@@ -410,7 +423,7 @@ class KnowledgeBaseTable:
 
             # Filter by threshold
             scores_array = np.array(scores)
-            df = df[scores_array > reranker.filtering_threshold]
+            df = df[scores_array >= reranker.filtering_threshold]
             logger.debug(f"Applied reranking with params: {reranking_model_params}")
 
         elif "distance" in df.columns:
@@ -1080,6 +1093,7 @@ class KnowledgeBaseController:
             raise EntityExistsError("Knowledge base already exists", name)
 
         embedding_params = get_model_params(params.get("embedding_model", {}), "default_embedding_model")
+        params["embedding_model"] = embedding_params
 
         # if model_name is None:  # Legacy
         model_name = self._create_embedding_model(
@@ -1106,6 +1120,7 @@ class KnowledgeBaseController:
             params["reranking_model"] = {}
 
         reranking_model_params = get_model_params(reranking_model_params, "default_reranking_model")
+        params["reranking_model"] = reranking_model_params
         if reranking_model_params:
             # Get reranking model from params.
             # This is called here to check validaity of the parameters.
@@ -1230,6 +1245,7 @@ class KnowledgeBaseController:
                 raise RuntimeError(f"Problem with embedding model config: {e}")
             return
 
+        params = copy.deepcopy(params)
         if "provider" in params:
             engine = params.pop("provider").lower()
 

mindsdb/utilities/config.py

@@ -3,14 +3,12 @@ import sys
 import json
 import argparse
 import datetime
-import logging
 from pathlib import Path
 from copy import deepcopy
 
 from appdirs import user_data_dir
 
 # NOTE do not `import from mindsdb` here
-logger = logging.getLogger(__name__)
 
 
 def _merge_key_recursive(target_dict, source_dict, key):
@@ -161,7 +159,7 @@ class Config:
                     },
                 }
             },
-            "gui": {"autoupdate": True},
+            "gui": {"open_on_start": True, "autoupdate": True},
             "debug": False,
             "environment": "local",
             "integrations": {},
@@ -230,6 +228,7 @@ class Config:
             "paths": {},
             "permanent_storage": {},
             "ml_task_queue": {},
+            "gui": {},
         }
 
         # region storage root path
@@ -304,6 +303,10 @@ class Config:
         if os.environ.get("MINDSDB_DATA_CATALOG_ENABLED", "").lower() in ("1", "true"):
             self._env_config["data_catalog"] = {"enabled": True}
 
+        if os.environ.get("MINDSDB_NO_STUDIO", "").lower() in ("1", "true"):
+            self._env_config["gui"]["open_on_start"] = False
+            self._env_config["gui"]["autoupdate"] = False
+
     def fetch_auto_config(self) -> bool:
         """Load dict readed from config.auto.json to `auto_config`.
         Do it only if `auto_config` was not loaded before or config.auto.json been changed.
@@ -335,10 +338,11 @@ class Config:
         """
         if self._user_config is None:
             cmd_args_config = self.cmd_args.config
-            if isinstance(cmd_args_config, str):
-                self.config_path = cmd_args_config
-            elif isinstance(os.environ.get("MINDSDB_CONFIG_PATH"), str):
+            if isinstance(os.environ.get("MINDSDB_CONFIG_PATH"), str):
                 self.config_path = os.environ["MINDSDB_CONFIG_PATH"]
+            elif isinstance(cmd_args_config, str):
+                self.config_path = cmd_args_config
+
             if self.config_path == "absent":
                 self.config_path = None
             if isinstance(self.config_path, str):
@@ -364,6 +368,11 @@ class Config:
         """Merge multiple configs to one."""
         new_config = deepcopy(self._default_config)
         _merge_configs(new_config, self._user_config)
+
+        if getattr(self.cmd_args, "no_studio", None) is True:
+            new_config["gui"]["open_on_start"] = False
+            new_config["gui"]["autoupdate"] = False
+
         _merge_configs(new_config, self._auto_config or {})
         _merge_configs(new_config, self._env_config or {})
 

mindsdb/utilities/render/sqlalchemy_render.py

@@ -47,7 +47,7 @@ def _compile_interval(element, compiler, **kw):
         if items[1].upper().endswith("S"):
             items[1] = items[1][:-1]
 
-    if compiler.dialect.driver in ["snowflake"]:
+    if compiler.dialect.driver in ["snowflake"] or compiler.dialect.name in ["postgresql"]:
         # quote all
         args = " ".join(map(str, items))
         args = f"'{args}'"
@@ -282,6 +282,12 @@ class SqlalchemyRender:
                 func = functions[t.op.lower()]
                 col = func(arg0, arg1)
             else:
+                # for unknown operators wrap arguments into parens
+                if isinstance(t.args[0], ast.BinaryOperation):
+                    arg0 = arg0.self_group()
+                if isinstance(t.args[1], ast.BinaryOperation):
+                    arg1 = arg1.self_group()
+
                 col = arg0.op(t.op)(arg1)
 
             if t.alias: