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

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

@@ -1,5 +1,5 @@
 from typing import Optional, Literal
-from dataclasses import dataclass, astuple, fields
+from dataclasses import dataclass, fields
 
 import pandas as pd
 from mindsdb_sql_parser.ast.base import ASTNode
@@ -7,11 +7,10 @@ from mindsdb_sql_parser.ast.base import ASTNode
 from mindsdb.utilities import log
 from mindsdb.utilities.config import config
 from mindsdb.integrations.utilities.sql_utils import extract_comparison_conditions
-from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
-from mindsdb.api.executor.datahub.classes.tables_row import (
-    TABLES_ROW_TYPE,
-    TablesRow,
-)
+from mindsdb.integrations.libs.response import INF_SCHEMA_COLUMNS_NAMES
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE, MYSQL_DATA_TYPE_COLUMNS_DEFAULT
+from mindsdb.api.executor.datahub.classes.tables_row import TABLES_ROW_TYPE, TablesRow
+
 
 logger = log.getLogger(__name__)
 
@@ -165,11 +164,36 @@ class TablesTable(Table):
         return df
 
 
-@dataclass
+def infer_mysql_type(original_type: str) -> MYSQL_DATA_TYPE:
+    """Infer MySQL data type from original type string from a database.
+
+    Args:
+        original_type (str): The original type string from a database.
+
+    Returns:
+        MYSQL_DATA_TYPE: The inferred MySQL data type.
+    """
+    match original_type.lower():
+        case 'double precision' | 'real' | 'numeric' | 'float':
+            data_type = MYSQL_DATA_TYPE.FLOAT
+        case 'integer' | 'smallint' | 'int' | 'bigint':
+            data_type = MYSQL_DATA_TYPE.BIGINT
+        case 'timestamp without time zone' | 'timestamp with time zone' | 'date' | 'timestamp':
+            data_type = MYSQL_DATA_TYPE.DATETIME
+        case _:
+            data_type = MYSQL_DATA_TYPE.VARCHAR
+    return data_type
+
+
+@dataclass(slots=True, kw_only=True)
 class ColumnsTableRow:
-    """Represents a row in the COLUMNS table.
-    Fields description: https://dev.mysql.com/doc/refman/8.4/en/information-schema-columns-table.html
-    NOTE: attrs order matter, don't change it.
+    """Represents a row in the MindsDB's internal INFORMATION_SCHEMA.COLUMNS table.
+    This class follows the MySQL-compatible COLUMNS table structure.
+
+    Detailed field descriptions can be found in MySQL documentation:
+    https://dev.mysql.com/doc/refman/8.4/en/information-schema-columns-table.html
+
+    NOTE: The order of attributes is significant and matches the MySQL column order.
     """
     TABLE_CATALOG: Literal['def'] = 'def'
     TABLE_SCHEMA: Optional[str] = None
@@ -192,73 +216,81 @@ class ColumnsTableRow:
     PRIVILEGES: str = 'select'
     COLUMN_COMMENT: Optional[str] = None
     GENERATION_EXPRESSION: Optional[str] = None
+    SRS_ID: Optional[str] = None
+    # MindsDB's specific columns:
+    ORIGINAL_TYPE: Optional[str] = None
+
+    @classmethod
+    def from_is_columns_row(cls, table_schema: str, table_name: str, row: pd.Series) -> 'ColumnsTableRow':
+        """Transform row from response of `handler.get_columns(...)` to internal information_schema.columns row.
+
+        Args:
+            table_schema (str): The name of the schema of the table which columns are described.
+            table_name (str): The name of the table which columns are described.
+            row (pd.Series): A row from the response of `handler.get_columns(...)`.
+
+        Returns:
+            ColumnsTableRow: A row in the MindsDB's internal INFORMATION_SCHEMA.COLUMNS table.
+        """
+        original_type: str = row[INF_SCHEMA_COLUMNS_NAMES.DATA_TYPE] or ''
+        data_type: MYSQL_DATA_TYPE | None = row[INF_SCHEMA_COLUMNS_NAMES.MYSQL_DATA_TYPE]
+        if isinstance(data_type, MYSQL_DATA_TYPE) is False:
+            data_type = infer_mysql_type(original_type)
+
+        # region set default values depend on type
+        defaults = MYSQL_DATA_TYPE_COLUMNS_DEFAULT.get(data_type)
+        if defaults is not None:
+            for key, value in defaults.items():
+                if key in row and row[key] is None:
+                    row[key] = value
+
+        # region determine COLUMN_TYPE - it is text representation of DATA_TYPE with additioan attributes
+        match data_type:
+            case MYSQL_DATA_TYPE.DECIMAL:
+                column_type = f'decimal({row[INF_SCHEMA_COLUMNS_NAMES.NUMERIC_PRECISION]},{INF_SCHEMA_COLUMNS_NAMES.NUMERIC_SCALE})'
+            case MYSQL_DATA_TYPE.VARCHAR:
+                column_type = f'varchar({row[INF_SCHEMA_COLUMNS_NAMES.CHARACTER_MAXIMUM_LENGTH]})'
+            case MYSQL_DATA_TYPE.VARBINARY:
+                column_type = f'varbinary({row[INF_SCHEMA_COLUMNS_NAMES.CHARACTER_MAXIMUM_LENGTH]})'
+            case MYSQL_DATA_TYPE.BIT | MYSQL_DATA_TYPE.BINARY | MYSQL_DATA_TYPE.CHAR:
+                column_type = f'{data_type.value.lower()}(1)'
+            case MYSQL_DATA_TYPE.BOOL | MYSQL_DATA_TYPE.BOOLEAN:
+                column_type = 'tinyint(1)'
+            case _:
+                column_type = data_type.value.lower()
+        # endregion
+
+        # BOOLean types had 'tinyint' DATA_TYPE in MySQL
+        if data_type in (MYSQL_DATA_TYPE.BOOL, MYSQL_DATA_TYPE.BOOLEAN):
+            data_type = 'tinyint'
+        else:
+            data_type = data_type.value.lower()
+
+        return cls(
+            TABLE_SCHEMA=table_schema,
+            TABLE_NAME=table_name,
+            COLUMN_NAME=row[INF_SCHEMA_COLUMNS_NAMES.COLUMN_NAME],
+            ORDINAL_POSITION=row[INF_SCHEMA_COLUMNS_NAMES.ORDINAL_POSITION],
+            COLUMN_DEFAULT=row[INF_SCHEMA_COLUMNS_NAMES.COLUMN_DEFAULT],
+            IS_NULLABLE=row[INF_SCHEMA_COLUMNS_NAMES.IS_NULLABLE],
+            DATA_TYPE=data_type,
+            CHARACTER_MAXIMUM_LENGTH=row[INF_SCHEMA_COLUMNS_NAMES.CHARACTER_MAXIMUM_LENGTH],
+            CHARACTER_OCTET_LENGTH=row[INF_SCHEMA_COLUMNS_NAMES.CHARACTER_OCTET_LENGTH],
+            NUMERIC_PRECISION=row[INF_SCHEMA_COLUMNS_NAMES.NUMERIC_PRECISION],
+            NUMERIC_SCALE=row[INF_SCHEMA_COLUMNS_NAMES.NUMERIC_SCALE],
+            DATETIME_PRECISION=row[INF_SCHEMA_COLUMNS_NAMES.DATETIME_PRECISION],
+            CHARACTER_SET_NAME=row[INF_SCHEMA_COLUMNS_NAMES.CHARACTER_SET_NAME],
+            COLLATION_NAME=row[INF_SCHEMA_COLUMNS_NAMES.COLLATION_NAME],
+            COLUMN_TYPE=column_type,
+            ORIGINAL_TYPE=original_type
+        )
 
     def __post_init__(self):
-        # region check mandatory fields
+        """Check if all mandatory fields are filled.
+        """
         mandatory_fields = ['TABLE_SCHEMA', 'TABLE_NAME', 'COLUMN_NAME']
         if any(getattr(self, field_name) is None for field_name in mandatory_fields):
             raise ValueError('One of mandatory fields is missed when creating ColumnsTableRow')
-        # endregion
-
-        # region set default values depend on type
-        defaults = {
-            'COLUMN_TYPE': self.DATA_TYPE
-        }
-        if MYSQL_DATA_TYPE(self.DATA_TYPE) in (
-            MYSQL_DATA_TYPE.TIMESTAMP,
-            MYSQL_DATA_TYPE.DATETIME,
-            MYSQL_DATA_TYPE.DATE
-        ):
-            defaults = {
-                'DATETIME_PRECISION': 0,
-                'COLUMN_TYPE': self.DATA_TYPE
-            }
-        elif MYSQL_DATA_TYPE(self.DATA_TYPE) in (
-            MYSQL_DATA_TYPE.FLOAT,
-            MYSQL_DATA_TYPE.DOUBLE,
-            MYSQL_DATA_TYPE.DECIMAL
-        ):
-            defaults = {
-                'NUMERIC_PRECISION': 12,
-                'NUMERIC_SCALE': 0,
-                'COLUMN_TYPE': self.DATA_TYPE
-            }
-        elif MYSQL_DATA_TYPE(self.DATA_TYPE) in (
-            MYSQL_DATA_TYPE.TINYINT,
-            MYSQL_DATA_TYPE.SMALLINT,
-            MYSQL_DATA_TYPE.MEDIUMINT,
-            MYSQL_DATA_TYPE.INT,
-            MYSQL_DATA_TYPE.BIGINT
-        ):
-            defaults = {
-                'NUMERIC_PRECISION': 20,
-                'NUMERIC_SCALE': 0,
-                'COLUMN_TYPE': self.DATA_TYPE
-            }
-        elif MYSQL_DATA_TYPE(self.DATA_TYPE) is MYSQL_DATA_TYPE.VARCHAR:
-            defaults = {
-                'CHARACTER_MAXIMUM_LENGTH': 1024,
-                'CHARACTER_OCTET_LENGTH': 3072,
-                'CHARACTER_SET_NAME': 'utf8',
-                'COLLATION_NAME': 'utf8_bin',
-                'COLUMN_TYPE': 'varchar(1024)'
-            }
-        else:
-            # show as MYSQL_DATA_TYPE.TEXT:
-            defaults = {
-                'CHARACTER_MAXIMUM_LENGTH': 65535,      # from https://bugs.mysql.com/bug.php?id=90685
-                'CHARACTER_OCTET_LENGTH': 65535,        #
-                'CHARACTER_SET_NAME': 'utf8',
-                'COLLATION_NAME': 'utf8_bin',
-                'COLUMN_TYPE': 'text'
-            }
-
-        for key, value in defaults.items():
-            setattr(self, key, value)
-
-        self.DATA_TYPE = self.DATA_TYPE.lower()
-        self.COLUMN_TYPE = self.COLUMN_TYPE.lower()
-        # endregion
 
 
 class ColumnsTable(Table):
@@ -266,9 +298,7 @@ class ColumnsTable(Table):
     columns = [field.name for field in fields(ColumnsTableRow)]
 
     @classmethod
-    def get_data(cls, inf_schema=None, query: ASTNode = None, **kwargs):
-        result = []
-
+    def get_data(cls, inf_schema=None, query: ASTNode = None, **kwargs) -> pd.DataFrame:
         databases, tables_names = _get_scope(query)
 
         if databases is None:
@@ -278,6 +308,7 @@ class ColumnsTable(Table):
                 'files'
             ]
 
+        result = []
         for db_name in databases:
             tables = {}
             if db_name == 'information_schema':
@@ -293,43 +324,19 @@ class ColumnsTable(Table):
                 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(table_name)
-
-            for table_name, table_columns in tables.items():
-                for i, column in enumerate(table_columns):
-                    column_name = column['name']
-                    column_type = column.get('type', 'text')
-
-                    # region infer type
-                    if isinstance(column_type, MYSQL_DATA_TYPE) is False:
-                        if column_type in ('double precision', 'real', 'numeric', 'float'):
-                            column_type = MYSQL_DATA_TYPE.FLOAT
-                        elif column_type in ('integer', 'smallint', 'int', 'bigint'):
-                            column_type = MYSQL_DATA_TYPE.BIGINT
-                        elif column_type in (
-                            'timestamp without time zone',
-                            'timestamp with time zone',
-                            'date', 'timestamp'
-                        ):
-                            column_type = MYSQL_DATA_TYPE.DATETIME
-                        else:
-                            column_type = MYSQL_DATA_TYPE.VARCHAR
-                    # endregion
-
-                    column_row = astuple(
-                        ColumnsTableRow(
-                            TABLE_SCHEMA=db_name,
-                            TABLE_NAME=table_name,
-                            COLUMN_NAME=column_name,
-                            DATA_TYPE=column_type.value,
-                            ORDINAL_POSITION=i
+                    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():
+                    result.append(
+                        ColumnsTableRow.from_is_columns_row(
+                            table_schema=db_name,
+                            table_name=table_name,
+                            row=row
                         )
                     )
 
-                    result.append(column_row)
-
-        df = pd.DataFrame(result, columns=cls.columns)
-        return df
+        return pd.DataFrame(result, columns=cls.columns)
 
 
 class EventsTable(Table):

mindsdb/api/executor/planner/query_planner.py

@@ -656,9 +656,18 @@ class QueryPlanner:
             # plan sub-select first
             last_step = self.plan_select(query.from_select, integration=integration_name)
 
+            # possible knowledge base parameters
+            select = query.from_select
+            params = {}
+            if isinstance(select, Select) and select.using is not None:
+                for k, v in select.using.items():
+                    if k.startswith('kb_'):
+                        params[k] = v
+
             self.plan.add_step(InsertToTable(
                 table=table,
                 dataframe=last_step,
+                params=params,
             ))
         else:
             self.plan.add_step(InsertToTable(
@@ -762,7 +771,7 @@ class QueryPlanner:
         elif from_table is None:
             # one line select
             step = QueryStep(query, from_table=pd.DataFrame([None]))
-            self.plan.add_step(step)
+            return self.plan.add_step(step)
         else:
             raise PlanningException(f'Unsupported from_table {type(from_table)}')
 

mindsdb/api/executor/planner/steps.py

@@ -200,7 +200,7 @@ class MultipleSteps(PlanStep):
 
 
 class SaveToTable(PlanStep):
-    def __init__(self, table, dataframe, is_replace=False, *args, **kwargs):
+    def __init__(self, table, dataframe, is_replace=False, params=None, *args, **kwargs):
         """
             Creates table if not exists and fills it with content of dataframe
             is_replace - to drop table beforehand
@@ -209,15 +209,21 @@ class SaveToTable(PlanStep):
         self.table = table
         self.dataframe = dataframe
         self.is_replace = is_replace
+        if params is None:
+            params = {}
+        self.params = params
 
 
 class InsertToTable(PlanStep):
-    def __init__(self, table, dataframe=None, query=None, *args, **kwargs):
+    def __init__(self, table, dataframe=None, query=None, params=None, *args, **kwargs):
         """Fills table with content of dataframe"""
         super().__init__(*args, **kwargs)
         self.table = table
         self.dataframe = dataframe
         self.query = query
+        if params is None:
+            params = {}
+        self.params = params
 
 
 class CreateTableStep(PlanStep):

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

@@ -95,8 +95,8 @@ class ApplyPredictorRowStepCall(ApplyPredictorBaseCall):
         result = ResultSet()
         result.is_prediction = True
         if len(predictions) == 0:
-            columns = [col['name'] for col in project_datanode.get_table_columns(predictor_name)]
-            predictions = pd.DataFrame([], columns=columns)
+            columns_names = project_datanode.get_table_columns_names(predictor_name)
+            predictions = pd.DataFrame([], columns=columns_names)
 
         result.from_df(
             predictions,
@@ -173,10 +173,10 @@ class ApplyPredictorStepCall(ApplyPredictorBaseCall):
 
         project_datanode = self.session.datahub.get(project_name)
         if len(data) == 0:
-            cols = [col['name'] for col in project_datanode.get_table_columns(predictor_name)] + ['__mindsdb_row_id']
-            for col in cols:
+            columns_names = project_datanode.get_table_columns_names(predictor_name) + ['__mindsdb_row_id']
+            for column_name in columns_names:
                 result.add_column(Column(
-                    name=col,
+                    name=column_name,
                     database=table_name[0],
                     table_name=table_name[1],
                     table_alias=table_name[2]

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

@@ -182,7 +182,7 @@ class FetchDataframePartitionCall(BaseStepCall):
             thread_count = get_max_thread_count()
 
         # 3 tasks per worker during 1 batch
-        partition_size = int(run_query.batch_size / thread_count / 3)
+        partition_size = int(run_query.batch_size / thread_count)
         # min partition size
         if partition_size < 10:
             partition_size = 10

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

@@ -95,7 +95,8 @@ class InsertToTableCall(BaseStepCall):
             table_name=table_name,
             result_set=data,
             is_replace=is_replace,
-            is_create=is_create
+            is_create=is_create,
+            params=step.params
         )
         return ResultSet(affected_rows=response.affected_rows)
 

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

@@ -20,15 +20,14 @@ class GetPredictorColumnsCall(BaseStepCall):
     bind = GetPredictorColumns
 
     def call(self, step):
-
         mindsdb_database_name = config.get('default_project')
 
         predictor_name = step.predictor.parts[-1]
         dn = self.session.datahub.get(mindsdb_database_name)
-        columns = [col['name'] for col in dn.get_table_columns(predictor_name)]
+        columns_names = dn.get_table_columns_names(predictor_name)
 
         data = ResultSet()
-        for column_name in columns:
+        for column_name in columns_names:
             data.add_column(Column(
                 name=column_name,
                 table_name=predictor_name,

mindsdb/api/litellm/start.py

@@ -0,0 +1,82 @@
+import asyncio
+from mindsdb.utilities import log
+from mindsdb.utilities.config import Config
+from mindsdb.interfaces.agents.litellm_server import run_server, run_server_async
+
+logger = log.getLogger(__name__)
+
+
+async def start_async(verbose=False):
+    """Start the LiteLLM server
+
+    Args:
+        verbose (bool): Whether to enable verbose logging
+    """
+    config = Config()
+
+    # Get agent name from command line args
+    agent_name = config.cmd_args.agent
+    if not agent_name:
+        logger.error("Agent name is required for LiteLLM server. Use --agent parameter.")
+        return 1
+
+    # Get project name or use default
+    project_name = config.cmd_args.project or "mindsdb"
+
+    # Get MCP server connection details
+    mcp_host = config.get('api', {}).get('mcp', {}).get('host', '127.0.0.1')
+    mcp_port = int(config.get('api', {}).get('mcp', {}).get('port', 47337))
+
+    # Get LiteLLM server settings
+    litellm_host = config.get('api', {}).get('litellm', {}).get('host', '0.0.0.0')
+    litellm_port = int(config.get('api', {}).get('litellm', {}).get('port', 8000))
+
+    logger.info(f"Starting LiteLLM server for agent '{agent_name}' in project '{project_name}'")
+    logger.info(f"Connecting to MCP server at {mcp_host}:{mcp_port}")
+    logger.info(f"Binding to {litellm_host}:{litellm_port}")
+
+    return await run_server_async(
+        agent_name=agent_name,
+        project_name=project_name,
+        mcp_host=mcp_host,
+        mcp_port=mcp_port,
+        host=litellm_host,
+        port=litellm_port
+    )
+
+
+def start(verbose=False):
+    """Start the LiteLLM server (synchronous wrapper)
+
+    Args:
+        verbose (bool): Whether to enable verbose logging
+    """
+    from mindsdb.interfaces.storage import db
+    db.init()
+
+    # Run the async function in the event loop
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    result = loop.run_until_complete(start_async(verbose))
+
+    if result == 0:
+        # Run the server
+        config = Config()
+        agent_name = config.cmd_args.agent
+        project_name = config.cmd_args.project or "mindsdb"
+        mcp_host = config.get('api', {}).get('mcp', {}).get('host', '127.0.0.1')
+        mcp_port = int(config.get('api', {}).get('mcp', {}).get('port', 47337))
+        litellm_host = config.get('api', {}).get('litellm', {}).get('host', '0.0.0.0')
+        litellm_port = int(config.get('api', {}).get('litellm', {}).get('port', 8000))
+
+        return run_server(
+            agent_name=agent_name,
+            project_name=project_name,
+            mcp_host=mcp_host,
+            mcp_port=mcp_port,
+            host=litellm_host,
+            port=litellm_port
+        )
+    else:
+        logger.error("LiteLLM server initialization failed")
+        return result

mindsdb/api/mysql/mysql_proxy/libs/constants/mysql.py

@@ -179,6 +179,139 @@ class MYSQL_DATA_TYPE(enum.Enum):
     BOOLEAN = 'BOOLEAN'
 
 
+# Default values for attributes of MySQL data types as they appear in information_schema.columns
+# These values match the MySQL v8.0.37 defaults and are used to properly represent column metadata
+MYSQL_DATA_TYPE_COLUMNS_DEFAULT = {
+    MYSQL_DATA_TYPE.TINYINT: {
+        'NUMERIC_PRECISION': 3,
+        'NUMERIC_SCALE': 0
+    },
+    MYSQL_DATA_TYPE.SMALLINT: {
+        'NUMERIC_PRECISION': 5,
+        'NUMERIC_SCALE': 0
+    },
+    MYSQL_DATA_TYPE.MEDIUMINT: {
+        'NUMERIC_PRECISION': 7,
+        'NUMERIC_SCALE': 0
+    },
+    MYSQL_DATA_TYPE.INT: {
+        'NUMERIC_PRECISION': 10,
+        'NUMERIC_SCALE': 0
+    },
+    MYSQL_DATA_TYPE.BIGINT: {
+        'NUMERIC_PRECISION': 19,
+        'NUMERIC_SCALE': 0
+    },
+    MYSQL_DATA_TYPE.FLOAT: {
+        'NUMERIC_PRECISION': 12
+    },
+    MYSQL_DATA_TYPE.DOUBLE: {
+        'NUMERIC_PRECISION': 22
+    },
+    MYSQL_DATA_TYPE.DECIMAL: {
+        'NUMERIC_PRECISION': 10,
+        'NUMERIC_SCALE': 0,
+        'COLUMN_TYPE': 'decimal(10,0)'
+    },
+    MYSQL_DATA_TYPE.YEAR: {
+        # every column is null
+    },
+    MYSQL_DATA_TYPE.TIME: {
+        'DATETIME_PRECISION': 0
+    },
+    MYSQL_DATA_TYPE.DATE: {
+        # every column is null
+    },
+    MYSQL_DATA_TYPE.DATETIME: {
+        'DATETIME_PRECISION': 0
+    },
+    MYSQL_DATA_TYPE.TIMESTAMP: {
+        'DATETIME_PRECISION': 0
+    },
+    MYSQL_DATA_TYPE.CHAR: {
+        'CHARACTER_MAXIMUM_LENGTH': 1,
+        'CHARACTER_OCTET_LENGTH': 4,
+        'CHARACTER_SET_NAME': 'utf8',
+        'COLLATION_NAME': 'utf8_bin',
+        'COLUMN_TYPE': 'char(1)'
+    },
+    MYSQL_DATA_TYPE.BINARY: {
+        'CHARACTER_MAXIMUM_LENGTH': 1,
+        'CHARACTER_OCTET_LENGTH': 1,
+        'COLUMN_TYPE': 'binary(1)'
+    },
+    MYSQL_DATA_TYPE.VARCHAR: {
+        'CHARACTER_MAXIMUM_LENGTH': 1024,   # NOTE mandatory for field creation
+        'CHARACTER_OCTET_LENGTH': 4096,     # NOTE mandatory for field creation
+        'CHARACTER_SET_NAME': 'utf8',
+        'COLLATION_NAME': 'utf8_bin',
+        'COLUMN_TYPE': 'varchar(1024)'
+    },
+    MYSQL_DATA_TYPE.VARBINARY: {
+        'CHARACTER_MAXIMUM_LENGTH': 1024,   # NOTE mandatory for field creation
+        'CHARACTER_OCTET_LENGTH': 1024,     # NOTE mandatory for field creation
+        'COLUMN_TYPE': 'varbinary(1024)'
+    },
+    MYSQL_DATA_TYPE.TINYBLOB: {
+        'CHARACTER_MAXIMUM_LENGTH': 255,
+        'CHARACTER_OCTET_LENGTH': 255
+    },
+    MYSQL_DATA_TYPE.TINYTEXT: {
+        'CHARACTER_MAXIMUM_LENGTH': 255,
+        'CHARACTER_OCTET_LENGTH': 255,
+        'CHARACTER_SET_NAME': 'utf8',
+        'COLLATION_NAME': 'utf8_bin'
+    },
+    MYSQL_DATA_TYPE.BLOB: {
+        'CHARACTER_MAXIMUM_LENGTH': 65535,
+        'CHARACTER_OCTET_LENGTH': 65535
+    },
+    MYSQL_DATA_TYPE.TEXT: {
+        'CHARACTER_MAXIMUM_LENGTH': 65535,
+        'CHARACTER_OCTET_LENGTH': 65535,
+        'CHARACTER_SET_NAME': 'utf8',
+        'COLLATION_NAME': 'utf8_bin'
+    },
+    MYSQL_DATA_TYPE.MEDIUMBLOB: {
+        'CHARACTER_MAXIMUM_LENGTH': 16777215,
+        'CHARACTER_OCTET_LENGTH': 16777215
+    },
+    MYSQL_DATA_TYPE.MEDIUMTEXT: {
+        'CHARACTER_MAXIMUM_LENGTH': 16777215,
+        'CHARACTER_OCTET_LENGTH': 16777215,
+        'CHARACTER_SET_NAME': 'utf8',
+        'COLLATION_NAME': 'utf8_bin'
+    },
+    MYSQL_DATA_TYPE.LONGBLOB: {
+        'CHARACTER_MAXIMUM_LENGTH': 4294967295,
+        'CHARACTER_OCTET_LENGTH': 4294967295,
+    },
+    MYSQL_DATA_TYPE.LONGTEXT: {
+        'CHARACTER_MAXIMUM_LENGTH': 4294967295,
+        'CHARACTER_OCTET_LENGTH': 4294967295,
+        'CHARACTER_SET_NAME': 'utf8',
+        'COLLATION_NAME': 'utf8_bin'
+    },
+    MYSQL_DATA_TYPE.BIT: {
+        'NUMERIC_PRECISION': 1,
+        'COLUMN_TYPE': 'bit(1)'
+        # 'NUMERIC_SCALE': null
+    },
+    MYSQL_DATA_TYPE.BOOL: {
+        'DATA_TYPE': 'tinyint',
+        'NUMERIC_PRECISION': 3,
+        'NUMERIC_SCALE': 0,
+        'COLUMN_TYPE': 'tinyint(1)'
+    },
+    MYSQL_DATA_TYPE.BOOLEAN: {
+        'DATA_TYPE': 'tinyint',
+        'NUMERIC_PRECISION': 3,
+        'NUMERIC_SCALE': 0,
+        'COLUMN_TYPE': 'tinyint(1)'
+    }
+}
+
+
 # Map between data types and C types
 # https://dev.mysql.com/doc/c-api/8.0/en/c-api-prepared-statement-type-codes.html
 DATA_C_TYPE_MAP = {

mindsdb/integrations/handlers/chromadb_handler/chromadb_handler.py

@@ -68,6 +68,10 @@ class ChromaDBHandler(VectorStoreHandler):
             "persist_directory": self.persist_directory,
         }
 
+        self.create_collection_metadata = {
+            "hnsw:space": config.distance,
+        }
+
         self._use_handler_storage = False
 
         self.connect()
@@ -398,7 +402,7 @@ class ChromaDBHandler(VectorStoreHandler):
         Insert/Upsert data into ChromaDB collection.
         If records with same IDs exist, they will be updated.
         """
-        collection = self._client.get_or_create_collection(collection_name)
+        collection = self._client.get_or_create_collection(collection_name, metadata=self.create_collection_metadata)
 
         # Convert metadata from string to dict if needed
         if TableField.METADATA.value in df.columns:
@@ -484,7 +488,8 @@ class ChromaDBHandler(VectorStoreHandler):
         """
         Create a collection with the given name in the ChromaDB database.
         """
-        self._client.create_collection(table_name, get_or_create=if_not_exists)
+        self._client.create_collection(table_name, get_or_create=if_not_exists,
+                                       metadata=self.create_collection_metadata)
         self._sync()
 
     def drop_table(self, table_name: str, if_exists=True):

mindsdb/integrations/handlers/chromadb_handler/settings.py

@@ -14,6 +14,7 @@ class ChromaHandlerConfig(BaseModel):
     host: str = None
     port: str = None
     password: str = None
+    distance: str = 'cosine'
 
     class Config:
         extra = "forbid"