MindsDB 25.6.2.0__py3-none-any.whl → 25.6.3.0__py3-none-any.whl

mindsdb/integrations/handlers/salesforce_handler/salesforce_handler.py

@@ -70,8 +70,8 @@ class SalesforceHandler(MetaAPIHandler):
             )
             self.is_connected = True
 
-            # Register Salesforce tables.
-            for resource_name in self._get_resource_names():
+            resource_tables = self._get_resource_names()
+            for resource_name in resource_tables:
                 table_class = create_table_class(resource_name)
                 self._register_table(resource_name, table_class(self))
 
@@ -154,23 +154,109 @@ class SalesforceHandler(MetaAPIHandler):
 
         return response
 
-    def _get_resource_names(self) -> None:
+    def _get_resource_names(self) -> List[str]:
         """
-        Retrieves the names of the Salesforce resources.
-
+        Retrieves the names of the Salesforce resources, with more aggressive filtering to remove tables.
         Returns:
-            None
+            List[str]: A list of filtered resource names.
         """
         if not self.resource_names:
-            # Fetch the queryable list of Salesforce resources (sobjects).
-            self.resource_names = [
+            all_resources = [
                 resource["name"]
                 for resource in self.connection.sobjects.describe()["sobjects"]
                 if resource.get("queryable", False)
             ]
 
+            # Define patterns for tables to be filtered out.
+            # Expanded suffixes and prefixes and exact matches
+            ignore_suffixes = ("Share", "History", "Feed", "ChangeEvent", "Tag", "Permission", "Setup", "Consent")
+            ignore_prefixes = (
+                "Apex",
+                "CommPlatform",
+                "Lightning",
+                "Flow",
+                "Transaction",
+                "AI",
+                "Aura",
+                "ContentWorkspace",
+                "Collaboration",
+                "Datacloud",
+            )
+            ignore_exact = {
+                "EntityDefinition",
+                "FieldDefinition",
+                "RecordType",
+                "CaseStatus",
+                "UserRole",
+                "UserLicense",
+                "UserPermissionAccess",
+                "UserRecordAccess",
+                "Folder",
+                "Group",
+                "Note",
+                "ProcessDefinition",
+                "ProcessInstance",
+                "ContentFolder",
+                "ContentDocumentSubscription",
+                "DashboardComponent",
+                "Report",
+                "Dashboard",
+                "Topic",
+                "TopicAssignment",
+                "Period",
+                "Partner",
+                "PackageLicense",
+                "ColorDefinition",
+                "DataUsePurpose",
+                "DataUseLegalBasis",
+            }
+
+            ignore_substrings = (
+                "CleanInfo",
+                "Template",
+                "Rule",
+                "Definition",
+                "Status",
+                "Policy",
+                "Setting",
+                "Access",
+                "Config",
+                "Subscription",
+                "DataType",
+                "MilestoneType",
+                "Entitlement",
+                "Auth",
+            )
+
+            filtered = []
+            for r in all_resources:
+                if (
+                    not r.endswith(ignore_suffixes)
+                    and not r.startswith(ignore_prefixes)
+                    and not any(sub in r for sub in ignore_substrings)
+                    and r not in ignore_exact
+                ):
+                    filtered.append(r)
+
+            self.resource_names = [r for r in filtered]
         return self.resource_names
 
+    def meta_get_handler_info(self, **kwargs) -> str:
+        """
+        Retrieves information about the design and implementation of the API handler.
+        This should include, but not be limited to, the following:
+        - The type of SQL queries and operations that the handler supports.
+        - etc.
+
+        Args:
+            kwargs: Additional keyword arguments that may be used in generating the handler information.
+
+        Returns:
+            str: A string containing information about the API handler's design and implementation.
+        """
+        # TODO: Relationships? Aliases?
+        return "When filtering on a Date or DateTime field, the value MUST be an unquoted literal in YYYY-MM-DD or YYYY-MM-DDThh:mm:ssZ format. For example, CloseDate >= 2025-05-28 is correct; CloseDate >= '2025-05-28' is incorrect."
+
     def meta_get_tables(self, table_names: Optional[List[str]] = None) -> Response:
         """
         Retrieves metadata for the specified tables (or all tables if no list is provided).

mindsdb/integrations/handlers/snowflake_handler/snowflake_handler.py

@@ -6,7 +6,7 @@ from snowflake.sqlalchemy import snowdialect
 from snowflake import connector
 from snowflake.connector.errors import NotSupportedError
 from snowflake.connector.cursor import SnowflakeCursor, ResultMetadata
-from typing import Optional, List
+from typing import Any, Optional, List
 
 from mindsdb_sql_parser.ast.base import ASTNode
 from mindsdb_sql_parser.ast import Select, Identifier
@@ -706,3 +706,21 @@ class SnowflakeHandler(MetaDatabaseHandler):
         except Exception as e:
             logger.error(f"Exception in meta_get_primary_keys: {e!r}")
             return Response(RESPONSE_TYPE.ERROR, error_message=f"Exception querying primary keys: {e!r}")
+
+    def meta_get_handler_info(self, **kwargs: Any) -> str:
+        """
+        Retrieves information about the design and implementation of the database handler.
+        This should include, but not be limited to, the following:
+        - The type of SQL queries and operations that the handler supports.
+        - etc.
+
+        Args:
+            kwargs: Additional keyword arguments that may be used in generating the handler information.
+
+        Returns:
+            str: A string containing information about the database handler's design and implementation.
+        """
+        return (
+            "To query columns that contain special characters, use ticks around the column name, e.g. `column name`.\n"
+            "DO NOT use double quotes for this purpose."
+        )

mindsdb/integrations/libs/api_handler.py

@@ -457,8 +457,11 @@ class APIHandler(BaseHandler):
 
     def query(self, query: ASTNode):
         if isinstance(query, Select):
+            # If the list method exists, it should be overridden in the child class.
+            # The APIResource class could be used as a base class by overriding the select method, but not the list method.
             table = self._get_table(query.from_table)
-            if not hasattr(table, "list"):
+            list_method = getattr(table, "list", None)
+            if not list_method or (list_method and list_method.__func__ is APIResource.list):
                 # for back compatibility, targets wasn't passed in previous version
                 query.targets = [Star()]
             result = self._get_table(query.from_table).select(query)
@@ -515,6 +518,21 @@ class MetaAPIHandler(APIHandler):
     This class is used when the handler is also needed to store information in the data catalog.
     """
 
+    def meta_get_handler_info(self, **kwargs) -> str:
+        """
+        Retrieves information about the design and implementation of the API handler.
+        This should include, but not be limited to, the following:
+        - The type of SQL queries and operations that the handler supports.
+        - etc.
+
+        Args:
+            kwargs: Additional keyword arguments that may be used in generating the handler information.
+
+        Returns:
+            str: A string containing information about the API handler's design and implementation.
+        """
+        pass
+
     def meta_get_tables(self, table_names: Optional[List[str]] = None, **kwargs) -> Response:
         """
         Retrieves metadata for the specified tables (or all tables if no list is provided).

mindsdb/integrations/libs/base.py

@@ -1,4 +1,5 @@
 import ast
+import concurrent.futures
 import inspect
 import textwrap
 from _ast import AnnAssign, AugAssign
@@ -8,7 +9,7 @@ import pandas as pd
 from mindsdb_sql_parser.ast.base import ASTNode
 from mindsdb.utilities import log
 
-from mindsdb.integrations.libs.response import HandlerResponse, HandlerStatusResponse
+from mindsdb.integrations.libs.response import HandlerResponse, HandlerStatusResponse, RESPONSE_TYPE
 
 logger = log.getLogger(__name__)
 
@@ -156,6 +157,7 @@ class MetaDatabaseHandler(DatabaseHandler):
     def meta_get_column_statistics(self, table_names: Optional[List[str]]) -> HandlerResponse:
         """
         Returns metadata statisical information about the columns in the tables to be stored in the data catalog.
+        Either this method should be overridden in the handler or `meta_get_column_statistics_for_table` should be implemented.
 
         Returns:
             HandlerResponse: The response should consist of the following columns:
@@ -168,7 +170,74 @@ class MetaDatabaseHandler(DatabaseHandler):
             - MAXIMUM_VALUE (str): Maximum value in the column (optional).
             - DISTINCT_VALUES_COUNT (int): Count of distinct values in the column (optional).
         """
-        raise NotImplementedError()
+        method = getattr(self, "meta_get_column_statistics_for_table")
+        if method.__func__ is not MetaDatabaseHandler.meta_get_column_statistics_for_table:
+            meta_columns = self.meta_get_columns(table_names)
+            grouped_columns = (
+                meta_columns.data_frame.groupby("table_name")
+                .agg(
+                    {
+                        "column_name": list,
+                    }
+                )
+                .reset_index()
+            )
+
+            executor = concurrent.futures.ThreadPoolExecutor(max_workers=5)
+            futures = []
+
+            results = []
+            with executor:
+                for _, row in grouped_columns.iterrows():
+                    table_name = row["table_name"]
+                    columns = row["column_name"]
+                    futures.append(executor.submit(self.meta_get_column_statistics_for_table, table_name, columns))
+
+            for future in concurrent.futures.as_completed(futures):
+                try:
+                    result = future.result(timeout=120)
+                    if result.resp_type == RESPONSE_TYPE.TABLE:
+                        results.append(result.data_frame)
+                    else:
+                        logger.error(
+                            f"Error retrieving column statistics for table {table_name}: {result.error_message}"
+                        )
+                except Exception as e:
+                    logger.error(f"Exception occurred while retrieving column statistics for table {table_name}: {e}")
+
+            if not results:
+                logger.warning("No column statistics could be retrieved for the specified tables.")
+                return HandlerResponse(RESPONSE_TYPE.ERROR, error_message="No column statistics could be retrieved.")
+            return HandlerResponse(
+                RESPONSE_TYPE.TABLE, pd.concat(results, ignore_index=True) if results else pd.DataFrame()
+            )
+
+        else:
+            raise NotImplementedError()
+
+    def meta_get_column_statistics_for_table(
+        self, table_name: str, column_names: Optional[List[str]] = None
+    ) -> HandlerResponse:
+        """
+        Returns metadata statistical information about the columns in a specific table to be stored in the data catalog.
+        Either this method should be implemented in the handler or `meta_get_column_statistics` should be overridden.
+
+        Args:
+            table_name (str): Name of the table.
+            column_names (Optional[List[str]]): List of column names to retrieve statistics for. If None, statistics for all columns will be returned.
+
+        Returns:
+            HandlerResponse: The response should consist of the following columns:
+            - TABLE_NAME (str): Name of the table.
+            - COLUMN_NAME (str): Name of the column.
+            - MOST_COMMON_VALUES (List[str]): Most common values in the column (optional).
+            - MOST_COMMON_FREQUENCIES (List[str]): Frequencies of the most common values in the column (optional).
+            - NULL_PERCENTAGE: Percentage of NULL values in the column (optional).
+            - MINIMUM_VALUE (str): Minimum value in the column (optional).
+            - MAXIMUM_VALUE (str): Maximum value in the column (optional).
+            - DISTINCT_VALUES_COUNT (int): Count of distinct values in the column (optional).
+        """
+        pass
 
     def meta_get_primary_keys(self, table_names: Optional[List[str]]) -> HandlerResponse:
         """
@@ -197,6 +266,21 @@ class MetaDatabaseHandler(DatabaseHandler):
         """
         raise NotImplementedError()
 
+    def meta_get_handler_info(self, **kwargs) -> str:
+        """
+        Retrieves information about the design and implementation of the database handler.
+        This should include, but not be limited to, the following:
+        - The type of SQL queries and operations that the handler supports.
+        - etc.
+
+        Args:
+            kwargs: Additional keyword arguments that may be used in generating the handler information.
+
+        Returns:
+            str: A string containing information about the database handler's design and implementation.
+        """
+        pass
+
 
 class ArgProbeMixin:
     """

mindsdb/interfaces/agents/agents_controller.py

@@ -10,6 +10,7 @@ import pandas as pd
 from mindsdb.interfaces.storage import db
 from mindsdb.interfaces.storage.db import Predictor
 from mindsdb.utilities.context import context as ctx
+from mindsdb.interfaces.data_catalog.data_catalog_loader import DataCatalogLoader
 from mindsdb.interfaces.database.projects import ProjectController
 from mindsdb.interfaces.model.functions import PredictorRecordNotFound
 from mindsdb.interfaces.model.model_controller import ModelController
@@ -52,7 +53,7 @@ class AgentsController:
         """
         Checks if a model exists, and gets the provider of the model.
 
-        The provider is either the provider of the model, or the provider given as an argument.
+        The provider is either the provider of the model or the provider given as an argument.
 
         Parameters:
             model_name (str): The name of the model
@@ -325,12 +326,37 @@ class AgentsController:
                 db.session.rollback()
                 raise ValueError(f"Skill with name does not exist: {skill_name}")
 
-            # Add table restrictions if this is a text2sql skill
-            if existing_skill.type == "sql" and (include_tables or ignore_tables):
-                parameters["tables"] = include_tables or ignore_tables
-
-            # Add knowledge base restrictions if this is a text2sql skill
             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. "
+                        )
+
+                # 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

mindsdb/interfaces/agents/constants.py

@@ -221,6 +221,7 @@ You are an AI assistant powered by MindsDB. When answering questions, follow the
 2. For questions about database tables and their contents:
    - Use the sql_db_query to query the tables directly
    - You can join tables if needed to get comprehensive information
+   - You are running on a federated query engine, so joins across multiple databases are allowed and supported
    - **Important Rule for SQL Queries:** If you formulate an SQL query as part of answering a user's question, you *must* then use the `sql_db_query` tool to execute that query and get its results. The SQL query string itself is NOT the final answer to the user unless the user has specifically asked for the query. Your final AI response should be based on the *results* obtained from executing the query.
 
 

mindsdb/interfaces/agents/mindsdb_database_agent.py

@@ -1,7 +1,8 @@
 """
-    Wrapper around MindsDB's executor and integration controller following the implementation of the original
-    langchain.sql_database.SQLDatabase class to partly replicate its behavior.
+Wrapper around MindsDB's executor and integration controller following the implementation of the original
+langchain.sql_database.SQLDatabase class to partly replicate its behavior.
 """
+
 import traceback
 from typing import Any, Iterable, List, Optional
 
@@ -13,26 +14,25 @@ logger = log.getLogger(__name__)
 
 
 def extract_essential(input: str) -> str:
-    """ Sometimes LLM include to input unnecessary data. We can't control stochastic nature of LLM, so we need to
-        'clean' input somehow. LLM prompt contains instruction to enclose input between '$START$' and '$STOP$'.
+    """Sometimes LLM include to input unnecessary data. We can't control stochastic nature of LLM, so we need to
+    'clean' input somehow. LLM prompt contains instruction to enclose input between '$START$' and '$STOP$'.
     """
-    if '$START$' in input:
-        input = input.partition('$START$')[-1]
-    if '$STOP$' in input:
-        input = input.partition('$STOP$')[0]
-    return input.strip(' ')
+    if "$START$" in input:
+        input = input.partition("$START$")[-1]
+    if "$STOP$" in input:
+        input = input.partition("$STOP$")[0]
+    return input.strip(" ")
 
 
 class MindsDBSQL(SQLDatabase):
     @staticmethod
-    def custom_init(
-        sql_agent: 'SQLAgent'
-    ) -> 'MindsDBSQL':
+    def custom_init(sql_agent: "SQLAgent") -> "MindsDBSQL":
         instance = MindsDBSQL()
         instance._sql_agent = sql_agent
         return instance
 
     """ Can't modify signature, as LangChain does a Pydantic check."""
+
     def __init__(
         self,
         engine: Optional[Any] = None,
@@ -51,7 +51,7 @@ class MindsDBSQL(SQLDatabase):
 
     @property
     def dialect(self) -> str:
-        return 'mindsdb'
+        return "mindsdb"
 
     @property
     def table_info(self) -> str:
@@ -93,23 +93,26 @@ class MindsDBSQL(SQLDatabase):
         command = extract_essential(command)
 
         try:
-
             # Log the query for debugging
             logger.info(f"Executing SQL query: {command}")
 
+            # Removing backticks causes in query execution.
             # remove backticks
-            command = command.replace('`', '')
+            # command = command.replace('`', '')
 
             # Parse the SQL string to an AST object first
             from mindsdb_sql_parser import parse_sql
+
             ast_query = parse_sql(command)
 
             # Now execute the parsed query
-            result = self._sql_agent.skill_tool.get_command_executor().execute_command(ast_query, database_name="mindsdb")
+            result = self._sql_agent.skill_tool.get_command_executor().execute_command(
+                ast_query, database_name="mindsdb"
+            )
 
             # Convert ExecuteAnswer to a DataFrame for easier manipulation
             df = None
-            if hasattr(result, 'data') and hasattr(result.data, 'data_frame'):
+            if hasattr(result, "data") and hasattr(result.data, "data_frame"):
                 df = result.data.data_frame
             else:
                 # Fallback to to_df when data_frame attr not available
@@ -130,7 +133,9 @@ class MindsDBSQL(SQLDatabase):
         except Exception as e:
             logger.error(f"Error executing SQL command: {str(e)}\n{traceback.format_exc()}")
             # If this is a knowledge base query, provide a more helpful error message
-            if "knowledge_base" in command.lower() or any(kb in command for kb in self._sql_agent.get_usable_knowledge_base_names()):
+            if "knowledge_base" in command.lower() or any(
+                kb in command for kb in self._sql_agent.get_usable_knowledge_base_names()
+            ):
                 return f"Error executing knowledge base query: {str(e)}. Please check that the knowledge base exists and your query syntax is correct."
             return f"Error: {str(e)}"
 

mindsdb/interfaces/data_catalog/data_catalog_loader.py

@@ -60,15 +60,20 @@ class DataCatalogLoader(BaseDataCatalog):
         """
         self.logger.info(f"Loading tables for {self.database_name}")
         response = self.data_handler.meta_get_tables(self.table_names)
-        if response.resp_type != RESPONSE_TYPE.TABLE:
+        if response.resp_type == RESPONSE_TYPE.ERROR:
             self.logger.error(f"Failed to load tables for {self.database_name}: {response.error_message}")
             return []
+        elif response.resp_type == RESPONSE_TYPE.OK:
+            self.logger.error(f"No tables found for {self.database_name}.")
+            return []
 
         df = response.data_frame
         if df.empty:
             self.logger.info(f"No tables to add for {self.database_name}.")
             return []
 
+        df.columns = df.columns.str.lower()
+
         # Filter out tables that are already loaded in the data catalog
         if loaded_table_names:
             df = df[~df["table_name"].isin(loaded_table_names)]
@@ -77,7 +82,6 @@ class DataCatalogLoader(BaseDataCatalog):
             self.logger.info(f"No new tables to load for {self.database_name}.")
             return []
 
-        df.columns = df.columns.str.lower()
         tables = self._add_table_metadata(df)
         self.logger.info(f"Tables loaded for {self.database_name}.")
         return tables
@@ -117,9 +121,12 @@ class DataCatalogLoader(BaseDataCatalog):
         """
         self.logger.info(f"Loading columns for {self.database_name}")
         response = self.data_handler.meta_get_columns(self.table_names)
-        if response.resp_type != RESPONSE_TYPE.TABLE:
+        if response.resp_type == RESPONSE_TYPE.ERROR:
             self.logger.error(f"Failed to load columns for {self.database_name}: {response.error_message}")
             return []
+        elif response.resp_type == RESPONSE_TYPE.OK:
+            self.logger.error(f"No columns found for {self.database_name}.")
+            return []
 
         df = response.data_frame
         if df.empty:
@@ -162,9 +169,12 @@ class DataCatalogLoader(BaseDataCatalog):
         """
         self.logger.info(f"Loading column statistics for {self.database_name}")
         response = self.data_handler.meta_get_column_statistics(self.table_names)
-        if response.resp_type != RESPONSE_TYPE.TABLE:
+        if response.resp_type == RESPONSE_TYPE.ERROR:
             self.logger.error(f"Failed to load column statistics for {self.database_name}: {response.error_message}")
             return
+        elif response.resp_type == RESPONSE_TYPE.OK:
+            self.logger.error(f"No column statistics found for {self.database_name}.")
+            return
 
         df = response.data_frame
         if df.empty:
@@ -222,9 +232,12 @@ class DataCatalogLoader(BaseDataCatalog):
         """
         self.logger.info(f"Loading primary keys for {self.database_name}")
         response = self.data_handler.meta_get_primary_keys(self.table_names)
-        if response.resp_type != RESPONSE_TYPE.TABLE:
+        if response.resp_type == RESPONSE_TYPE.ERROR:
             self.logger.error(f"Failed to load primary keys for {self.database_name}: {response.error_message}")
             return
+        elif response.resp_type == RESPONSE_TYPE.OK:
+            self.logger.error(f"No primary keys found for {self.database_name}.")
+            return
 
         df = response.data_frame
         if df.empty:
@@ -271,9 +284,12 @@ class DataCatalogLoader(BaseDataCatalog):
         """
         self.logger.info(f"Loading foreign keys for {self.database_name}")
         response = self.data_handler.meta_get_foreign_keys(self.table_names)
-        if response.resp_type != RESPONSE_TYPE.TABLE:
+        if response.resp_type == RESPONSE_TYPE.ERROR:
             self.logger.error(f"Failed to foreign keys for {self.database_name}: {response.error_message}")
             return
+        elif response.resp_type == RESPONSE_TYPE.OK:
+            self.logger.error(f"No foreign keys found for {self.database_name}.")
+            return
 
         df = response.data_frame
         if df.empty:

mindsdb/interfaces/data_catalog/data_catalog_reader.py

@@ -17,7 +17,11 @@ class DataCatalogReader(BaseDataCatalog):
         if not tables:
             self.logger.warning(f"No metadata found for database '{self.database_name}'")
             return f"No metadata found for database '{self.database_name}'"
+
         metadata_str = "Data Catalog: \n"
+        if hasattr(self.data_handler, "meta_get_handler_info"):
+            metadata_str += self.data_handler.meta_get_handler_info() + "\n\n"
+
         for table in tables:
             metadata_str += table.as_string() + "\n\n"
         return metadata_str

mindsdb/interfaces/database/integrations.py

@@ -256,7 +256,9 @@ class IntegrationController:
 
         # Remove the integration metadata from the data catalog (if enabled).
         # TODO: Can this be handled via cascading delete in the database?
-        if Config().get("data_catalog", {}).get("enabled", False):
+        if self.get_handler_meta(integration_record.engine).get("type") == HANDLER_TYPE.DATA and Config().get(
+            "data_catalog", {}
+        ).get("enabled", False):
             data_catalog_reader = DataCatalogLoader(database_name=name)
             data_catalog_reader.unload_metadata()
 
@@ -798,7 +800,7 @@ class IntegrationController:
         for item in code.body:
             if isinstance(item, ast.ClassDef):
                 bases = [base.id for base in item.bases]
-                if "APIHandler" in bases:
+                if "APIHandler" in bases or "MetaAPIHandler" in bases:
                     return "api"
         return "sql"
 

mindsdb/interfaces/knowledge_base/controller.py

@@ -1201,22 +1201,10 @@ class KnowledgeBaseController:
         project_names = {i.id: i.name for i in project_controller.get_list()}
 
         for record in query:
-            vector_database = record.vector_database
-            embedding_model = record.embedding_model
+            kb = record.as_dict(with_secrets=self.session.show_secrets)
+            kb["project_name"] = project_names[record.project_id]
 
-            data.append(
-                {
-                    "id": record.id,
-                    "name": record.name,
-                    "project_id": record.project_id,
-                    "project_name": project_names[record.project_id],
-                    "embedding_model": embedding_model.name if embedding_model is not None else None,
-                    "vector_database": None if vector_database is None else vector_database.name,
-                    "vector_database_table": record.vector_database_table,
-                    "query_id": record.query_id,
-                    "params": record.params,
-                }
-            )
+            data.append(kb)
 
         return data
 

mindsdb/interfaces/knowledge_base/evaluate.py

@@ -492,8 +492,6 @@ class EvaluateDocID(EvaluateBase):
         total_questions = len(stats)
         total_found = sum([1 for stat in stats if stat["doc_found"]])
 
-        total_accurately_retrieved = sum([1 for stat in stats if stat["doc_found"]])
-
         accurate_in_top_10 = sum([1 for stat in stats if stat["doc_found"] and stat["doc_position"] < 10])
 
         # calculate recall curve by position
@@ -512,7 +510,6 @@ class EvaluateDocID(EvaluateBase):
         return {
             "total": total_questions,
             "total_found": total_found,
-            "retrieved_in_top_k": total_accurately_retrieved,
             "retrieved_in_top_10": accurate_in_top_10,
             "cumulative_recall": cumulative_recall,
             "avg_query_time": avg_query_time,