MindsDB 25.4.4.0__py3-none-any.whl → 25.5.3.0__py3-none-any.whl

mindsdb/__about__.py

@@ -1,6 +1,6 @@
 __title__ = 'MindsDB'
 __package_name__ = 'mindsdb'
-__version__ = '25.4.4.0'
+__version__ = '25.5.3.0'
 __description__ = "MindsDB's AI SQL Server enables developers to build AI tools that need access to real-time data to perform their tasks"
 __email__ = "jorge@mindsdb.com"
 __author__ = 'MindsDB Inc'

mindsdb/__main__.py

@@ -1,3 +1,5 @@
+import gc
+gc.disable()
 import os
 import sys
 import time
@@ -12,7 +14,7 @@ from enum import Enum
 from dataclasses import dataclass, field
 from typing import Callable, Optional, Tuple, List
 
-from packaging import version
+from sqlalchemy import func
 from sqlalchemy.orm.attributes import flag_modified
 
 from mindsdb.utilities import log
@@ -22,17 +24,12 @@ logger.debug("Starting MindsDB...")
 
 from mindsdb.__about__ import __version__ as mindsdb_version
 from mindsdb.utilities.config import config
-from mindsdb.utilities.exception import EntityNotExistsError
 from mindsdb.utilities.starters import (
-    start_http, start_mysql, start_mongo, start_postgres, start_ml_task_queue, start_scheduler, start_tasks,
-    start_mcp, start_litellm
+    start_http, start_mysql, start_mongo, start_postgres, start_ml_task_queue,
+    start_scheduler, start_tasks, start_mcp, start_litellm
 )
 from mindsdb.utilities.ps import is_pid_listen_port, get_child_pids
-from mindsdb.utilities.functions import get_versions_where_predictors_become_obsolete
-from mindsdb.interfaces.database.integrations import integration_controller
-from mindsdb.interfaces.database.projects import ProjectController
 import mindsdb.interfaces.storage.db as db
-from mindsdb.integrations.utilities.install import install_dependencies
 from mindsdb.utilities.fs import clean_process_marks, clean_unlinked_process_marks
 from mindsdb.utilities.context import context as ctx
 from mindsdb.utilities.auth import register_oauth_client, get_aws_meta_data
@@ -47,6 +44,8 @@ try:
 except RuntimeError:
     logger.info('Torch multiprocessing context already set, ignoring...')
 
+gc.enable()
+
 _stop_event = threading.Event()
 
 
@@ -213,7 +212,96 @@ def do_clean_process_marks():
             set_error_model_status_by_pids(unexisting_pids)
 
 
+def create_permanent_integrations():
+    """
+    Create permanent integrations, for now only the 'files' integration.
+    NOTE: this is intentional to avoid importing integration_controller
+    """
+    integration_name = 'files'
+    existing = db.session.query(db.Integration).filter_by(name=integration_name, company_id=None).first()
+    if existing is None:
+        integration_record = db.Integration(
+            name=integration_name,
+            data={},
+            engine=integration_name,
+            company_id=None,
+        )
+        db.session.add(integration_record)
+        try:
+            db.session.commit()
+        except Exception as e:
+            logger.error(f"Failed to commit permanent integration {integration_name}: {e}")
+            db.session.rollback()
+
+
+def validate_default_project() -> None:
+    """Handle 'default_project' config option.
+    Project with the name specified in 'default_project' must exists and be marked with
+    'is_default' metadata. If it is not possible, then terminate the process with error.
+    Note: this can be done using 'project_controller', but we want to save init time and used RAM.
+    """
+    new_default_project_name = config.get('default_project')
+    logger.debug(f"Checking if default project {new_default_project_name} exists")
+    filter_company_id = ctx.company_id if ctx.company_id is not None else 0
+
+    current_default_project: db.Project | None = (
+        db.Project.query.filter(
+            db.Project.company_id == filter_company_id,
+            db.Project.metadata_['is_default'].as_boolean() == True  # noqa
+        ).first()
+    )
+
+    if current_default_project is None:
+        # Legacy: If the default project does not exist, mark the new one as default.
+        existing_project = db.Project.query.filter(
+            db.Project.company_id == filter_company_id,
+            func.lower(db.Project.name) == func.lower(new_default_project_name)
+        ).first()
+        if existing_project is None:
+            logger.critical(f"A project with the name '{new_default_project_name}' does not exist")
+            sys.exit(1)
+
+        existing_project.metadata_ = {'is_default': True}
+        flag_modified(existing_project, 'metadata_')
+        db.session.commit()
+    elif current_default_project.name != new_default_project_name:
+        # If the default project exists, but the name is different, update the name.
+        existing_project = db.Project.query.filter(
+            db.Project.company_id == filter_company_id,
+            func.lower(db.Project.name) == func.lower(new_default_project_name)
+        ).first()
+        if existing_project is not None:
+            logger.critical(f"A project with the name '{new_default_project_name}' already exists")
+            sys.exit(1)
+        current_default_project.name = new_default_project_name
+        db.session.commit()
+
+
+def start_process(trunc_process_data: TrunkProcessData) -> None:
+    """Start a process.
+
+    Args:
+        trunc_process_data (TrunkProcessData): The data of the process to start.
+    """
+    mp_ctx = mp.get_context("spawn")
+    logger.info(f"{trunc_process_data.name} API: starting...")
+    try:
+        trunc_process_data.process = mp_ctx.Process(
+            target=trunc_process_data.entrypoint,
+            args=trunc_process_data.args,
+            name=trunc_process_data.name
+        )
+        trunc_process_data.process.start()
+    except Exception as e:
+        logger.error(
+            f"Failed to start {trunc_process_data.name} API with exception {e}\n{traceback.format_exc()}"
+        )
+        close_api_gracefully(trunc_processes_struct)
+        raise e
+
+
 if __name__ == '__main__':
+    mp.freeze_support()
     # warn if less than 1Gb of free RAM
     if psutil.virtual_memory().available < (1 << 30):
         logger.warning(
@@ -270,7 +358,6 @@ if __name__ == '__main__':
             pass
 
     db.init()
-    mp.freeze_support()
 
     environment = config["environment"]
     if environment == "aws_marketplace":
@@ -287,52 +374,6 @@ if __name__ == '__main__':
         except Exception:
             pass
 
-    is_cloud = config.is_cloud
-
-    if not is_cloud:
-        logger.debug("Applying database migrations")
-        try:
-            from mindsdb.migrations import migrate
-            migrate.migrate_to_head()
-        except Exception as e:
-            logger.error(f"Error! Something went wrong during DB migrations: {e}")
-
-        logger.debug(f"Checking if default project {config.get('default_project')} exists")
-        project_controller = ProjectController()
-
-        try:
-            current_default_project = project_controller.get(is_default=True)
-        except EntityNotExistsError:
-            # In previous versions, the default project could be deleted. This is no longer possible.
-            current_default_project = None
-
-        if current_default_project:
-            if current_default_project.record.name != config.get('default_project'):
-                try:
-                    project_controller.get(name=config.get('default_project'))
-                    log.critical(f"A project with the name '{config.get('default_project')}' already exists")
-                    sys.exit(1)
-                except EntityNotExistsError:
-                    pass
-                project_controller.update(current_default_project.record.id, new_name=config.get('default_project'))
-
-        # Legacy: If the default project does not exist, mark the new one as default.
-        else:
-            try:
-                project_controller.get(name=config.get('default_project'))
-            except EntityNotExistsError:
-                log.critical(
-                    f"A project with the name '{config.get('default_project')}' does not exist"
-                )
-                raise
-
-            project_controller.update(
-                name=config.get('default_project'),
-                new_metadata={
-                    "is_default": True
-                }
-            )
-
     apis = os.getenv('MINDSDB_APIS') or config.cmd_args.api
 
     if apis is None:  # If "--api" option is not specified, start the default APIs
@@ -342,27 +383,6 @@ if __name__ == '__main__':
     else:  # The user has provided a list of APIs to start
         api_arr = [TrunkProcessEnum(name) for name in apis.split(',')]
 
-    if config.cmd_args.install_handlers is not None:
-        handlers_list = [s.strip() for s in config.cmd_args.install_handlers.split(",")]
-        # import_meta = handler_meta.get('import', {})
-        for handler_name, handler_meta in integration_controller.get_handlers_import_status().items():
-            if handler_name not in handlers_list:
-                continue
-            import_meta = handler_meta.get("import", {})
-            if import_meta.get("success") is True:
-                logger.info(f"{'{0: <18}'.format(handler_name)} - already installed")
-                continue
-            result = install_dependencies(import_meta.get("dependencies", []))
-            if result.get("success") is True:
-                logger.info(
-                    f"{'{0: <18}'.format(handler_name)} - successfully installed"
-                )
-            else:
-                logger.info(
-                    f"{'{0: <18}'.format(handler_name)} - error during dependencies installation: {result.get('error_message', 'unknown error')}"
-                )
-        sys.exit(0)
-
     logger.info(f"Version: {mindsdb_version}")
     logger.info(f"Configuration file: {config.config_path or 'absent'}")
     logger.info(f"Storage path: {config.paths['root']}")
@@ -370,42 +390,22 @@ if __name__ == '__main__':
     logger.debug(f"System config: {config.auto_config}")
     logger.debug(f"Env config: {config.env_config}")
 
+    is_cloud = config.is_cloud
     unexisting_pids = clean_unlinked_process_marks()
     if not is_cloud:
+        logger.debug("Applying database migrations")
+        try:
+            from mindsdb.migrations import migrate
+            migrate.migrate_to_head()
+        except Exception as e:
+            logger.error(f"Error! Something went wrong during DB migrations: {e}")
+
+        validate_default_project()
+
         if len(unexisting_pids) > 0:
             set_error_model_status_by_pids(unexisting_pids)
         set_error_model_status_for_unfinished()
-
-        integration_controller.create_permanent_integrations()
-
-        # region Mark old predictors as outdated
-        is_modified = False
-        predictor_records = (
-            db.session.query(db.Predictor)
-            .filter(db.Predictor.deleted_at.is_(None))
-            .all()
-        )
-        if len(predictor_records) > 0:
-            (
-                sucess,
-                compatible_versions,
-            ) = get_versions_where_predictors_become_obsolete()
-            if sucess is True:
-                compatible_versions = [version.parse(x) for x in compatible_versions]
-                mindsdb_version_parsed = version.parse(mindsdb_version)
-                compatible_versions = [x for x in compatible_versions if x <= mindsdb_version_parsed]
-                if len(compatible_versions) > 0:
-                    last_compatible_version = compatible_versions[-1]
-                    for predictor_record in predictor_records:
-                        if (
-                            isinstance(predictor_record.mindsdb_version, str)
-                            and version.parse(predictor_record.mindsdb_version) < last_compatible_version
-                        ):
-                            predictor_record.update_status = "available"
-                            is_modified = True
-        if is_modified is True:
-            db.session.commit()
-        # endregion
+        create_permanent_integrations()
 
     clean_process_marks()
 
@@ -503,24 +503,6 @@ if __name__ == '__main__':
     if config.cmd_args.ml_task_queue_consumer is True:
         trunc_processes_struct[TrunkProcessEnum.ML_TASK_QUEUE].need_to_run = True
 
-    def start_process(trunc_process_data):
-        # TODO this 'ctx' is eclipsing 'context' class imported as 'ctx'
-        ctx = mp.get_context("spawn")
-        logger.info(f"{trunc_process_data.name} API: starting...")
-        try:
-            trunc_process_data.process = ctx.Process(
-                target=trunc_process_data.entrypoint,
-                args=trunc_process_data.args,
-                name=trunc_process_data.name
-            )
-            trunc_process_data.process.start()
-        except Exception as e:
-            logger.error(
-                f"Failed to start {trunc_process_data.name} API with exception {e}\n{traceback.format_exc()}"
-            )
-            close_api_gracefully(trunc_processes_struct)
-            raise e
-
     for trunc_process_data in trunc_processes_struct.values():
         if trunc_process_data.started is True or trunc_process_data.need_to_run is False:
             continue

mindsdb/api/executor/command_executor.py

@@ -5,7 +5,6 @@ from typing import Optional
 from functools import reduce
 
 import pandas as pd
-from mindsdb_evaluator.accuracy.general import evaluate_accuracy
 from mindsdb_sql_parser import parse_sql
 from mindsdb_sql_parser.ast import (
     Alter,
@@ -585,6 +584,8 @@ class ExecuteCommands:
             )
         elif statement_type is Insert:
             query = SQLQuery(statement, session=self.session, database=database_name)
+            if query.fetched_data.length() > 0:
+                return self.answer_select(query)
             return ExecuteAnswer(
                 affected_rows=query.fetched_data.affected_rows
             )
@@ -670,7 +671,7 @@ class ExecuteCommands:
         command = target.op.lower()
         args = [arg.value for arg in target.args if isinstance(arg, Constant)]
         if command == 'query_resume':
-            ret = SQLQuery(None, session=self.session, database=database_name, query_id=args[0])
+            ret = SQLQuery(None, session=self.session, query_id=args[0])
             return self.answer_select(ret)
 
         elif command == 'query_cancel':
@@ -812,6 +813,8 @@ class ExecuteCommands:
         return ExecuteAnswer()
 
     def answer_evaluate_metric(self, statement, database_name):
+        # heavy import, so we do it here on-demand
+        from mindsdb_evaluator.accuracy.general import evaluate_accuracy
         try:
             sqlquery = SQLQuery(statement.data, session=self.session, database=database_name)
         except Exception as e:
@@ -868,13 +871,21 @@ class ExecuteCommands:
             else:
                 raise WrongArgumentError(f'Unknown describe type: {obj_type}')
 
-        name = obj_name.parts[-1]
+        parts = obj_name.parts
+        if len(parts) > 2:
+            raise WrongArgumentError(
+                f"Invalid object name: {obj_name.to_string()}.\n"
+                "Only models support three-part namespaces."
+            )
+
+        name = parts[-1]
         where = BinaryOperation(op='=', args=[
             Identifier('name'),
             Constant(name)
         ])
 
         if obj_type in project_objects:
+            database_name = parts[0] if len(parts) > 1 else database_name
             where = BinaryOperation(op='and', args=[
                 where,
                 BinaryOperation(op='=', args=[Identifier('project'), Constant(database_name)])

mindsdb/api/executor/datahub/datanodes/information_schema_datanode.py

@@ -22,6 +22,8 @@ from .mindsdb_tables import (
     ModelsTable, DatabasesTable, MLEnginesTable, HandlersTable, JobsTable, QueriesTable,
     ChatbotsTable, KBTable, SkillsTable, AgentsTable, ViewsTable, TriggersTable)
 
+from mindsdb.api.executor.datahub.classes.tables_row import TablesRow
+
 
 logger = log.getLogger(__name__)
 
@@ -166,6 +168,12 @@ class InformationSchemaDataNode(DataNode):
         return [x.lower() for x in projects]
 
     def get_tables(self):
+        return [
+            TablesRow(TABLE_NAME=name)
+            for name in self.tables.keys()
+        ]
+
+    def get_tree_tables(self):
         return {
             name: table
             for name, table in self.tables.items()

mindsdb/api/executor/datahub/datanodes/mindsdb_tables.py

@@ -451,7 +451,8 @@ class ViewsTable(MdbTable):
 
 class QueriesTable(MdbTable):
     name = 'QUERIES'
-    columns = ["ID", "STARTED_AT", "FINISHED_AT", "PROCESSED_ROWS", "ERROR", "SQL", "PARAMETERS", "CONTEXT", "UPDATED_AT"]
+    columns = ["ID", "STARTED_AT", "FINISHED_AT", "PROCESSED_ROWS", "ERROR", "SQL", "DATABASE",
+               "PARAMETERS", "CONTEXT", "UPDATED_AT"]
 
     @classmethod
     def get_data(cls, **kwargs):

mindsdb/api/executor/datahub/datanodes/system_tables.py

@@ -311,20 +311,17 @@ class ColumnsTable(Table):
         result = []
         for db_name in databases:
             tables = {}
-            if db_name == 'information_schema':
-                for table_name, table in inf_schema.tables.items():
-                    tables[table_name] = [
-                        {'name': name} for name in table.columns
-                    ]
+
+            dn = inf_schema.get(db_name)
+            if dn is None:
+                continue
+
+            if tables_names is None:
+                list_tables = [t.TABLE_NAME for t in dn.get_tables()]
             else:
-                dn = inf_schema.get(db_name)
-                if dn is None:
-                    continue
-
-                if tables_names is None:
-                    tables_names = [t.TABLE_NAME for t in dn.get_tables()]
-                for table_name in tables_names:
-                    tables[table_name] = dn.get_table_columns_df(table_name)
+                list_tables = tables_names
+            for table_name in list_tables:
+                tables[table_name] = dn.get_table_columns_df(table_name)
 
             for table_name, table_columns_df in tables.items():
                 for _, row in table_columns_df.iterrows():

mindsdb/api/executor/planner/query_plan.py

@@ -3,6 +3,7 @@ class QueryPlan:
     def __init__(self, steps=None, **kwargs):
         self.steps = []
         self.is_resumable = False
+        self.is_async = False
 
         if steps:
             for step in steps:

mindsdb/api/executor/planner/query_planner.py

@@ -29,6 +29,9 @@ from mindsdb.utilities.config import config
 
 default_project = config.get('default_project')
 
+# This includes built-in MindsDB SQL functions and functions to be executed via DuckDB consistently.
+MINDSDB_SQL_FUNCTIONS = {'llm', 'to_markdown', 'hash'}
+
 
 class QueryPlanner:
 
@@ -237,7 +240,7 @@ class QueryPlanner:
 
         def find_objects(node, is_table, **kwargs):
             if isinstance(node, Function):
-                if node.namespace is not None or node.op.lower() in ('llm',):
+                if node.namespace is not None or node.op.lower() in MINDSDB_SQL_FUNCTIONS:
                     user_functions.append(node)
 
             if is_table:
@@ -847,6 +850,7 @@ class QueryPlanner:
         # handle fetchdataframe partitioning
         steps_out = []
 
+        step = None
         partition_step = None
         for step in plan.steps:
             if isinstance(step, FetchDataframeStep) and step.params is not None:
@@ -898,6 +902,10 @@ class QueryPlanner:
                     continue
 
             steps_out.append(step)
+
+        if plan.is_resumable and isinstance(step, InsertToTable):
+            plan.is_async = True
+
         plan.steps = steps_out
         return plan
 

mindsdb/api/executor/sql_query/sql_query.py

@@ -12,7 +12,9 @@ import inspect
 from textwrap import dedent
 from typing import Union, Dict
 
+import pandas as pd
 from mindsdb_sql_parser import parse_sql, ASTNode
+
 from mindsdb.api.executor.planner.steps import (
     ApplyTimeseriesPredictorStep,
     ApplyPredictorRowStep,
@@ -47,9 +49,16 @@ class SQLQuery:
     step_handlers = {}
 
     def __init__(self, sql: Union[ASTNode, str], session, execute: bool = True,
-                 database: str = None, query_id: int = None):
+                 database: str = None, query_id: int = None, stop_event=None):
         self.session = session
 
+        self.query_id = query_id
+        if self.query_id is not None:
+            # get sql and database from resumed query
+            run_query = query_context_controller.get_query(self.query_id)
+            sql = run_query.sql
+            database = run_query.database
+
         if database is not None:
             self.database = database
         else:
@@ -69,12 +78,7 @@ class SQLQuery:
 
         self.outer_query = None
         self.run_query = None
-        self.query_id = query_id
-        if query_id is not None:
-            # resume query
-            run_query = query_context_controller.get_query(self.query_id)
-            run_query.clear_error()
-            sql = run_query.sql
+        self.stop_event = stop_event
 
         if isinstance(sql, str):
             self.query = parse_sql(sql)
@@ -240,7 +244,19 @@ class SQLQuery:
             if self.query_id is not None:
                 self.run_query = query_context_controller.get_query(self.query_id)
             else:
-                self.run_query = query_context_controller.create_query(self.context['query_str'])
+                self.run_query = query_context_controller.create_query(self.context['query_str'], database=self.database)
+
+            if self.planner.plan.is_async and ctx.task_id is None:
+                # add to task
+                self.run_query.add_to_task()
+                # return query info
+                # columns in upper case
+                rec = {k.upper(): v for k, v in self.run_query.get_info().items()}
+                self.fetched_data = ResultSet().from_df(pd.DataFrame([rec]))
+                self.columns_list = self.fetched_data.columns
+                return
+            self.run_query.mark_as_run()
+
             ctx.run_query_id = self.run_query.record.id
 
         step_result = None

mindsdb/api/executor/sql_query/steps/apply_predictor_step.py

@@ -1,7 +1,6 @@
 import datetime as dt
 import re
 
-import dateinfer
 import pandas as pd
 
 from mindsdb_sql_parser.ast import (
@@ -262,7 +261,7 @@ class ApplyPredictorStepCall(ApplyPredictorBaseCall):
             return predictor_data
 
         def get_date_format(samples):
-            # dateinfer reads sql date 2020-04-01 as yyyy-dd-mm. workaround for in
+            # Try common formats first with explicit patterns
             for date_format, pattern in (
                 ('%Y-%m-%d', r'[\d]{4}-[\d]{2}-[\d]{2}'),
                 ('%Y-%m-%d %H:%M:%S', r'[\d]{4}-[\d]{2}-[\d]{2} [\d]{2}:[\d]{2}:[\d]{2}'),
@@ -280,7 +279,26 @@ class ApplyPredictorStepCall(ApplyPredictorBaseCall):
                     if date_format is not None:
                         return date_format
 
-            return dateinfer.infer(samples)
+            # Use dateparser as fallback and infer format
+            try:
+                # Parse the first sample to get its format
+                # The import is heavy, so we do it here on-demand
+                import dateparser
+                parsed_date = dateparser.parse(samples[0])
+                if parsed_date is None:
+                    raise ValueError("Could not parse date")
+
+                # Verify the format works for all samples
+                for sample in samples[1:]:
+                    if dateparser.parse(sample) is None:
+                        raise ValueError("Inconsistent date formats in samples")
+                # Convert to strftime format based on the input
+                if re.search(r'\d{2}:\d{2}:\d{2}', samples[0]):
+                    return '%Y-%m-%d %H:%M:%S'
+                return '%Y-%m-%d'
+            except (ValueError, AttributeError):
+                # If dateparser fails, return a basic format as last resort
+                return '%Y-%m-%d'
 
         model_types = predictor_metadata['model_types']
         if model_types.get(order_col) in ('float', 'integer'):

mindsdb/api/executor/sql_query/steps/fetch_dataframe_partition.py

@@ -222,7 +222,9 @@ class FetchDataframePartitionCall(BaseStepCall):
                         else:
                             executor.shutdown()
                             raise e
-
+                if self.sql_query.stop_event is not None and self.sql_query.stop_event.is_set():
+                    executor.shutdown()
+                    raise RuntimeError('Query is interrupted')
                 # TODO
                 #  1. get next batch without updating track_value:
                 #    it allows to keep queue_in filled with data between fetching batches

mindsdb/api/http/initialize.py

@@ -50,12 +50,29 @@ from mindsdb.utilities.json_encoder import CustomJSONProvider
 from mindsdb.utilities.ps import is_pid_listen_port, wait_func_is_true
 from mindsdb.utilities.sentry import sentry_sdk  # noqa: F401
 from mindsdb.utilities.otel import trace  # noqa: F401
-from opentelemetry.instrumentation.flask import FlaskInstrumentor  # noqa: F401
-from opentelemetry.instrumentation.requests import RequestsInstrumentor  # noqa: F401
 
 logger = log.getLogger(__name__)
 
 
+class _NoOpFlaskInstrumentor:
+    def instrument_app(self, app):
+        pass
+
+
+class _NoOpRequestsInstrumentor:
+    def instrument(self):
+        pass
+
+
+try:
+    from opentelemetry.instrumentation.flask import FlaskInstrumentor
+    from opentelemetry.instrumentation.requests import RequestsInstrumentor
+except ImportError:
+    logger.debug("OpenTelemetry is not avaiable. Please run `pip install -r requirements/requirements-opentelemetry.txt` to use it.")
+    FlaskInstrumentor = _NoOpFlaskInstrumentor
+    RequestsInstrumentor = _NoOpRequestsInstrumentor
+
+
 class Swagger_Api(Api):
     """
     This is a modification of the base Flask Restplus Api class due to the issue described here
@@ -376,7 +393,7 @@ def initialize_flask(config, init_static_thread, no_studio):
     app = Flask(__name__, **kwargs)
     init_metrics(app)
 
-    # Instrument Flask app for OpenTelemetry
+    # Instrument Flask app and requests using either real or no-op instrumentors
     FlaskInstrumentor().instrument_app(app)
     RequestsInstrumentor().instrument()
 

mindsdb/api/http/namespaces/analysis.py

@@ -79,7 +79,14 @@ class QueryAnalysis(Resource):
 
         column_names = [x["name"] for x in result.columns]
         df = DataFrame(result.data, columns=column_names)
-        analysis = analyze_df(df)
+        try:
+            analysis = analyze_df(df)
+        except ImportError:
+            return {
+                'analysis': {},
+                'timestamp': time.time(),
+                'error': 'To use this feature, please install the "dataprep_ml" package.'
+            }
 
         query_tables = [
             table.to_string() for table in get_query_tables(ast)
@@ -107,6 +114,12 @@ class DataAnalysis(Resource):
         try:
             analysis = analyze_df(DataFrame(data, columns=column_names))
             return {"analysis": analysis, "timestamp": time.time()}
+        except ImportError:
+            return {
+                'analysis': {},
+                'timestamp': timestamp,
+                'error': 'To use this feature, please install the "dataprep_ml" package.'
+            }
         except Exception as e:
             # Don't want analysis exceptions to show up on UI.
             # TODO: Fix analysis so it doesn't throw exceptions at all.