MindsDB 25.2.1.2__py3-none-any.whl → 25.2.2.1__py3-none-any.whl

mindsdb/integrations/utilities/query_traversal.py

@@ -1,7 +1,7 @@
 from mindsdb_sql_parser import ast
 
 
-def query_traversal(node, callback, is_table=False, is_target=False, parent_query=None):
+def query_traversal(node, callback, is_table=False, is_target=False, parent_query=None, stack=None):
     """
     :param node: element
     :param callback: function applied to every element
@@ -26,20 +26,25 @@ def query_traversal(node, callback, is_table=False, is_target=False, parent_quer
 
     """
 
-    res = callback(node, is_table=is_table, is_target=is_target, parent_query=parent_query)
+    if stack is None:
+        stack = []
+
+    res = callback(node, is_table=is_table, is_target=is_target, parent_query=parent_query, callstack=stack)
+    stack2 = [node] + stack
+
     if res is not None:
         # node is going to be replaced
         return res
 
     if isinstance(node, ast.Select):
         if node.from_table is not None:
-            node_out = query_traversal(node.from_table, callback, is_table=True, parent_query=node)
+            node_out = query_traversal(node.from_table, callback, is_table=True, parent_query=node, stack=stack2)
             if node_out is not None:
                 node.from_table = node_out
 
         array = []
         for node2 in node.targets:
-            node_out = query_traversal(node2, callback, parent_query=node, is_target=True) or node2
+            node_out = query_traversal(node2, callback, parent_query=node, is_target=True, stack=stack2) or node2
             if isinstance(node_out, list):
                 array.extend(node_out)
             else:
@@ -49,51 +54,51 @@ def query_traversal(node, callback, is_table=False, is_target=False, parent_quer
         if node.cte is not None:
             array = []
             for cte in node.cte:
-                node_out = query_traversal(cte.query, callback, parent_query=node) or cte
+                node_out = query_traversal(cte.query, callback, parent_query=node, stack=stack2) or cte
                 array.append(node_out)
             node.cte = array
 
         if node.where is not None:
-            node_out = query_traversal(node.where, callback, parent_query=node)
+            node_out = query_traversal(node.where, callback, parent_query=node, stack=stack2)
             if node_out is not None:
                 node.where = node_out
 
         if node.group_by is not None:
             array = []
             for node2 in node.group_by:
-                node_out = query_traversal(node2, callback, parent_query=node) or node2
+                node_out = query_traversal(node2, callback, parent_query=node, stack=stack2) or node2
                 array.append(node_out)
             node.group_by = array
 
         if node.having is not None:
-            node_out = query_traversal(node.having, callback, parent_query=node)
+            node_out = query_traversal(node.having, callback, parent_query=node, stack=stack2)
             if node_out is not None:
                 node.having = node_out
 
         if node.order_by is not None:
             array = []
             for node2 in node.order_by:
-                node_out = query_traversal(node2, callback, parent_query=node) or node2
+                node_out = query_traversal(node2, callback, parent_query=node, stack=stack2) or node2
                 array.append(node_out)
             node.order_by = array
 
     elif isinstance(node, (ast.Union, ast.Intersect, ast.Except)):
-        node_out = query_traversal(node.left, callback, parent_query=node)
+        node_out = query_traversal(node.left, callback, parent_query=node, stack=stack2)
         if node_out is not None:
             node.left = node_out
-        node_out = query_traversal(node.right, callback, parent_query=node)
+        node_out = query_traversal(node.right, callback, parent_query=node, stack=stack2)
         if node_out is not None:
             node.right = node_out
 
     elif isinstance(node, ast.Join):
-        node_out = query_traversal(node.right, callback, is_table=True, parent_query=parent_query)
+        node_out = query_traversal(node.right, callback, is_table=True, parent_query=parent_query, stack=stack2)
         if node_out is not None:
             node.right = node_out
-        node_out = query_traversal(node.left, callback, is_table=True, parent_query=parent_query)
+        node_out = query_traversal(node.left, callback, is_table=True, parent_query=parent_query, stack=stack2)
         if node_out is not None:
             node.left = node_out
         if node.condition is not None:
-            node_out = query_traversal(node.condition, callback, parent_query=parent_query)
+            node_out = query_traversal(node.condition, callback, parent_query=parent_query, stack=stack2)
             if node_out is not None:
                 node.condition = node_out
 
@@ -101,46 +106,46 @@ def query_traversal(node, callback, is_table=False, is_target=False, parent_quer
                            ast.Exists, ast.NotExists)):
         array = []
         for arg in node.args:
-            node_out = query_traversal(arg, callback, parent_query=parent_query) or arg
+            node_out = query_traversal(arg, callback, parent_query=parent_query, stack=stack2) or arg
             array.append(node_out)
         node.args = array
 
         if isinstance(node, ast.Function):
             if node.from_arg is not None:
-                node_out = query_traversal(node.from_arg, callback, parent_query=parent_query)
+                node_out = query_traversal(node.from_arg, callback, parent_query=parent_query, stack=stack2)
                 if node_out is not None:
                     node.from_arg = node_out
 
     elif isinstance(node, ast.WindowFunction):
-        query_traversal(node.function, callback, parent_query=parent_query)
+        query_traversal(node.function, callback, parent_query=parent_query, stack=stack2)
         if node.partition is not None:
             array = []
             for node2 in node.partition:
-                node_out = query_traversal(node2, callback, parent_query=parent_query) or node2
+                node_out = query_traversal(node2, callback, parent_query=parent_query, stack=stack2) or node2
                 array.append(node_out)
             node.partition = array
         if node.order_by is not None:
             array = []
             for node2 in node.order_by:
-                node_out = query_traversal(node2, callback, parent_query=parent_query) or node2
+                node_out = query_traversal(node2, callback, parent_query=parent_query, stack=stack2) or node2
                 array.append(node_out)
             node.order_by = array
 
     elif isinstance(node, ast.TypeCast):
-        node_out = query_traversal(node.arg, callback, parent_query=parent_query)
+        node_out = query_traversal(node.arg, callback, parent_query=parent_query, stack=stack2)
         if node_out is not None:
             node.arg = node_out
 
     elif isinstance(node, ast.Tuple):
         array = []
         for node2 in node.items:
-            node_out = query_traversal(node2, callback, parent_query=parent_query) or node2
+            node_out = query_traversal(node2, callback, parent_query=parent_query, stack=stack2) or node2
             array.append(node_out)
         node.items = array
 
     elif isinstance(node, ast.Insert):
         if node.table is not None:
-            node_out = query_traversal(node.table, callback, is_table=True, parent_query=node)
+            node_out = query_traversal(node.table, callback, is_table=True, parent_query=node, stack=stack2)
             if node_out is not None:
                 node.table = node_out
 
@@ -149,38 +154,38 @@ def query_traversal(node, callback, is_table=False, is_target=False, parent_quer
             for row in node.values:
                 items = []
                 for item in row:
-                    item2 = query_traversal(item, callback, parent_query=node) or item
+                    item2 = query_traversal(item, callback, parent_query=node, stack=stack2) or item
                     items.append(item2)
                 rows.append(items)
             node.values = rows
 
         if node.from_select is not None:
-            node_out = query_traversal(node.from_select, callback, parent_query=node)
+            node_out = query_traversal(node.from_select, callback, parent_query=node, stack=stack2)
             if node_out is not None:
                 node.from_select = node_out
 
     elif isinstance(node, ast.Update):
         if node.table is not None:
-            node_out = query_traversal(node.table, callback, is_table=True, parent_query=node)
+            node_out = query_traversal(node.table, callback, is_table=True, parent_query=node, stack=stack2)
             if node_out is not None:
                 node.table = node_out
 
         if node.where is not None:
-            node_out = query_traversal(node.where, callback, parent_query=node)
+            node_out = query_traversal(node.where, callback, parent_query=node, stack=stack2)
             if node_out is not None:
                 node.where = node_out
 
         if node.update_columns is not None:
             changes = {}
             for k, v in node.update_columns.items():
-                v2 = query_traversal(v, callback, parent_query=node)
+                v2 = query_traversal(v, callback, parent_query=node, stack=stack2)
                 if v2 is not None:
                     changes[k] = v2
             if changes:
                 node.update_columns.update(changes)
 
         if node.from_select is not None:
-            node_out = query_traversal(node.from_select, callback, parent_query=node)
+            node_out = query_traversal(node.from_select, callback, parent_query=node, stack=stack2)
             if node_out is not None:
                 node.from_select = node_out
 
@@ -188,50 +193,50 @@ def query_traversal(node, callback, is_table=False, is_target=False, parent_quer
         array = []
         if node.columns is not None:
             for node2 in node.columns:
-                node_out = query_traversal(node2, callback, parent_query=node) or node2
+                node_out = query_traversal(node2, callback, parent_query=node, stack=stack2) or node2
                 array.append(node_out)
             node.columns = array
 
         if node.name is not None:
-            node_out = query_traversal(node.name, callback, is_table=True, parent_query=node)
+            node_out = query_traversal(node.name, callback, is_table=True, parent_query=node, stack=stack2)
             if node_out is not None:
                 node.name = node_out
 
         if node.from_select is not None:
-            node_out = query_traversal(node.from_select, callback, parent_query=node)
+            node_out = query_traversal(node.from_select, callback, parent_query=node, stack=stack2)
             if node_out is not None:
                 node.from_select = node_out
 
     elif isinstance(node, ast.Delete):
         if node.where is not None:
-            node_out = query_traversal(node.where, callback, parent_query=node)
+            node_out = query_traversal(node.where, callback, parent_query=node, stack=stack2)
             if node_out is not None:
                 node.where = node_out
 
     elif isinstance(node, ast.OrderBy):
         if node.field is not None:
-            node_out = query_traversal(node.field, callback, parent_query=parent_query)
+            node_out = query_traversal(node.field, callback, parent_query=parent_query, stack=stack2)
             if node_out is not None:
                 node.field = node_out
 
     elif isinstance(node, ast.Case):
         rules = []
         for condition, result in node.rules:
-            condition2 = query_traversal(condition, callback, parent_query=parent_query)
-            result2 = query_traversal(result, callback, parent_query=parent_query)
+            condition2 = query_traversal(condition, callback, parent_query=parent_query, stack=stack2)
+            result2 = query_traversal(result, callback, parent_query=parent_query, stack=stack2)
 
             condition = condition if condition2 is None else condition2
             result = result if result2 is None else result2
             rules.append([condition, result])
         node.rules = rules
-        default = query_traversal(node.default, callback, parent_query=parent_query)
+        default = query_traversal(node.default, callback, parent_query=parent_query, stack=stack2)
         if default is not None:
             node.default = default
 
     elif isinstance(node, list):
         array = []
         for node2 in node:
-            node_out = query_traversal(node2, callback, parent_query=parent_query) or node2
+            node_out = query_traversal(node2, callback, parent_query=parent_query, stack=stack2) or node2
             array.append(node_out)
         return array
 

mindsdb/interfaces/agents/langfuse_callback_handler.py

@@ -1,6 +1,7 @@
 from typing import Any, Dict, Union, Optional, List
 from uuid import uuid4
 import datetime
+import json
 
 from langchain_core.callbacks.base import BaseCallbackHandler
 
@@ -21,6 +22,10 @@ class LangfuseCallbackHandler(BaseCallbackHandler):
         # if these are not available, we generate some UUIDs
         self.trace_id = trace_id or uuid4().hex
         self.observation_id = observation_id or uuid4().hex
+        # Track metrics about tools and chains
+        self.tool_metrics = {}
+        self.chain_metrics = {}
+        self.current_chain = None
 
     def on_tool_start(
             self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
@@ -30,9 +35,28 @@ class LangfuseCallbackHandler(BaseCallbackHandler):
         action_span = self.action_uuid_to_span.get(parent_run_uuid)
         if action_span is None:
             return
+
+        tool_name = serialized.get("name", "tool")
+        start_time = datetime.datetime.now()
+
+        # Initialize or update tool metrics
+        if tool_name not in self.tool_metrics:
+            self.tool_metrics[tool_name] = {
+                'count': 0,
+                'total_time': 0,
+                'errors': 0,
+                'last_error': None,
+                'inputs': []
+            }
+
+        self.tool_metrics[tool_name]['count'] += 1
+        self.tool_metrics[tool_name]['inputs'].append(input_str)
+
         metadata = {
-            'tool_name': serialized.get("name", "tool"),
-            'started': datetime.datetime.now().isoformat()
+            'tool_name': tool_name,
+            'started': start_time.isoformat(),
+            'start_timestamp': start_time.timestamp(),
+            'input_length': len(input_str) if input_str else 0
         }
         action_span.update(metadata=metadata)
 
@@ -42,9 +66,25 @@ class LangfuseCallbackHandler(BaseCallbackHandler):
         action_span = self.action_uuid_to_span.get(parent_run_uuid)
         if action_span is None:
             return
+
+        end_time = datetime.datetime.now()
+        tool_name = action_span.metadata.get('tool_name', 'unknown')
+        start_timestamp = action_span.metadata.get('start_timestamp')
+
+        if start_timestamp:
+            duration = end_time.timestamp() - start_timestamp
+            if tool_name in self.tool_metrics:
+                self.tool_metrics[tool_name]['total_time'] += duration
+
+        metadata = {
+            'finished': end_time.isoformat(),
+            'duration_seconds': duration if start_timestamp else None,
+            'output_length': len(output) if output else 0
+        }
+
         action_span.update(
             output=output,  # tool output is action output (unless superseded by a global action output)
-            metadata={'finished': datetime.datetime.now().isoformat()}
+            metadata=metadata
         )
 
     def on_tool_error(
@@ -55,75 +95,213 @@ class LangfuseCallbackHandler(BaseCallbackHandler):
         action_span = self.action_uuid_to_span.get(parent_run_uuid)
         if action_span is None:
             return
+
         try:
             error_str = str(error)
         except Exception:
             error_str = "Couldn't get error string."
-        action_span.update(metadata={'error_description': error_str})
+
+        tool_name = action_span.metadata.get('tool_name', 'unknown')
+        if tool_name in self.tool_metrics:
+            self.tool_metrics[tool_name]['errors'] += 1
+            self.tool_metrics[tool_name]['last_error'] = error_str
+
+        metadata = {
+            'error_description': error_str,
+            'error_type': error.__class__.__name__,
+            'error_time': datetime.datetime.now().isoformat()
+        }
+        action_span.update(metadata=metadata)
 
     def on_chain_start(
             self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
     ) -> Any:
         """Run when chain starts running."""
+        if self.langfuse is None:
+            return
+
         run_uuid = kwargs.get('run_id', uuid4()).hex
 
         if serialized is None:
             serialized = {}
 
-        chain_span = self.langfuse.span(
-            name=f'{serialized.get("name", "chain")}-{run_uuid}',
-            trace_id=self.trace_id,
-            parent_observation_id=self.observation_id,
-            input=str(inputs)
-        )
-        self.chain_uuid_to_span[run_uuid] = chain_span
+        chain_name = serialized.get("name", "chain")
+        start_time = datetime.datetime.now()
+
+        # Initialize or update chain metrics
+        if chain_name not in self.chain_metrics:
+            self.chain_metrics[chain_name] = {
+                'count': 0,
+                'total_time': 0,
+                'errors': 0,
+                'last_error': None
+            }
+
+        self.chain_metrics[chain_name]['count'] += 1
+        self.current_chain = chain_name
+
+        try:
+            chain_span = self.langfuse.span(
+                name=f'{chain_name}-{run_uuid}',
+                trace_id=self.trace_id,
+                parent_observation_id=self.observation_id,
+                input=json.dumps(inputs, indent=2)
+            )
+
+            metadata = {
+                'chain_name': chain_name,
+                'started': start_time.isoformat(),
+                'start_timestamp': start_time.timestamp(),
+                'input_keys': list(inputs.keys()) if isinstance(inputs, dict) else None,
+                'input_size': len(inputs) if isinstance(inputs, dict) else len(str(inputs))
+            }
+            chain_span.update(metadata=metadata)
+            self.chain_uuid_to_span[run_uuid] = chain_span
+        except Exception as e:
+            logger.warning(f"Error creating Langfuse span: {str(e)}")
 
     def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> Any:
         """Run when chain ends running."""
+        if self.langfuse is None:
+            return
+
         chain_uuid = kwargs.get('run_id', uuid4()).hex
         if chain_uuid not in self.chain_uuid_to_span:
             return
         chain_span = self.chain_uuid_to_span.pop(chain_uuid)
         if chain_span is None:
             return
-        chain_span.update(output=str(outputs))
-        chain_span.end()
+
+        try:
+            end_time = datetime.datetime.now()
+            chain_name = chain_span.metadata.get('chain_name', 'unknown')
+            start_timestamp = chain_span.metadata.get('start_timestamp')
+
+            if start_timestamp and chain_name in self.chain_metrics:
+                duration = end_time.timestamp() - start_timestamp
+                self.chain_metrics[chain_name]['total_time'] += duration
+
+            metadata = {
+                'finished': end_time.isoformat(),
+                'duration_seconds': duration if start_timestamp else None,
+                'output_keys': list(outputs.keys()) if isinstance(outputs, dict) else None,
+                'output_size': len(outputs) if isinstance(outputs, dict) else len(str(outputs))
+            }
+            chain_span.update(output=json.dumps(outputs, indent=2), metadata=metadata)
+            chain_span.end()
+        except Exception as e:
+            logger.warning(f"Error updating Langfuse span: {str(e)}")
 
     def on_chain_error(self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any) -> Any:
         """Run when chain errors."""
-        # Do nothing for now.
-        pass
+        chain_uuid = kwargs.get('run_id', uuid4()).hex
+        if chain_uuid not in self.chain_uuid_to_span:
+            return
+        chain_span = self.chain_uuid_to_span.get(chain_uuid)
+        if chain_span is None:
+            return
+
+        try:
+            error_str = str(error)
+        except Exception:
+            error_str = "Couldn't get error string."
+
+        chain_name = chain_span.metadata.get('chain_name', 'unknown')
+        if chain_name in self.chain_metrics:
+            self.chain_metrics[chain_name]['errors'] += 1
+            self.chain_metrics[chain_name]['last_error'] = error_str
+
+        metadata = {
+            'error_description': error_str,
+            'error_type': error.__class__.__name__,
+            'error_time': datetime.datetime.now().isoformat()
+        }
+        chain_span.update(metadata=metadata)
 
     def on_agent_action(self, action, **kwargs: Any) -> Any:
         """Run on agent action."""
-        # Do nothing for now.
+        if self.langfuse is None:
+            return
+
         run_uuid = kwargs.get('run_id', uuid4()).hex
-        action_span = self.langfuse.span(
-            name=f'{getattr(action, "type", "action")}-{getattr(action, "tool", "")}-{run_uuid}',
-            trace_id=self.trace_id,
-            parent_observation_id=self.observation_id,
-            input=str(action)
-        )
-        self.action_uuid_to_span[run_uuid] = action_span
+        try:
+            action_span = self.langfuse.span(
+                name=f'{getattr(action, "type", "action")}-{getattr(action, "tool", "")}-{run_uuid}',
+                trace_id=self.trace_id,
+                parent_observation_id=self.observation_id,
+                input=str(action)
+            )
+            self.action_uuid_to_span[run_uuid] = action_span
+        except Exception as e:
+            logger.warning(f"Error creating Langfuse span for agent action: {str(e)}")
 
     def on_agent_finish(self, finish, **kwargs: Any) -> Any:
         """Run on agent end."""
-        # Do nothing for now.
+        if self.langfuse is None:
+            return
+
         run_uuid = kwargs.get('run_id', uuid4()).hex
         if run_uuid not in self.action_uuid_to_span:
             return
         action_span = self.action_uuid_to_span.pop(run_uuid)
         if action_span is None:
             return
-        if finish is not None:
-            action_span.update(output=finish)  # supersedes tool output
-        action_span.end()
+
+        try:
+            if finish is not None:
+                action_span.update(output=finish)  # supersedes tool output
+            action_span.end()
+        except Exception as e:
+            logger.warning(f"Error updating Langfuse span: {str(e)}")
 
     def auth_check(self):
         if self.langfuse is not None:
             return self.langfuse.auth_check()
         return False
 
+    def get_metrics(self) -> Dict[str, Any]:
+        """Get collected metrics about tools and chains.
+
+        Returns:
+            Dict containing:
+            - tool_metrics: Statistics about tool usage, errors, and timing
+            - chain_metrics: Statistics about chain execution, errors, and timing
+            For each tool/chain, includes:
+                - count: Number of times used
+                - total_time: Total execution time
+                - errors: Number of errors
+                - last_error: Most recent error message
+                - avg_duration: Average execution time
+        """
+        metrics = {
+            'tool_metrics': {},
+            'chain_metrics': {}
+        }
+
+        # Process tool metrics
+        for tool_name, data in self.tool_metrics.items():
+            metrics['tool_metrics'][tool_name] = {
+                'count': data['count'],
+                'total_time': data['total_time'],
+                'avg_duration': data['total_time'] / data['count'] if data['count'] > 0 else 0,
+                'errors': data['errors'],
+                'last_error': data['last_error'],
+                'error_rate': data['errors'] / data['count'] if data['count'] > 0 else 0
+            }
+
+        # Process chain metrics
+        for chain_name, data in self.chain_metrics.items():
+            metrics['chain_metrics'][chain_name] = {
+                'count': data['count'],
+                'total_time': data['total_time'],
+                'avg_duration': data['total_time'] / data['count'] if data['count'] > 0 else 0,
+                'errors': data['errors'],
+                'last_error': data['last_error'],
+                'error_rate': data['errors'] / data['count'] if data['count'] > 0 else 0
+            }
+
+        return metrics
+
 
 def get_skills(agent: db.Agents) -> List:
     """ Retrieve skills from agent `skills` attribute. Specific to agent endpoints. """

mindsdb/interfaces/file/file_controller.py

@@ -82,7 +82,7 @@ class FileController:
 
         file_dir = None
         try:
-            df, _col_map = FileHandler._handle_source(file_path)
+            df = FileHandler.handle_source(file_path)
 
             ds_meta = {"row_count": len(df), "column_names": list(df.columns)}
 

mindsdb/interfaces/skills/custom/text2sql/mindsdb_sql_toolkit.py

@@ -1,5 +1,6 @@
 from typing import List
 from textwrap import dedent
+from datetime import datetime
 
 from langchain_community.agent_toolkits.sql.toolkit import SQLDatabaseToolkit
 from langchain_community.tools import ListSQLDatabaseTool, InfoSQLDatabaseTool, QuerySQLDataBaseTool
@@ -11,6 +12,9 @@ from mindsdb.interfaces.skills.custom.text2sql.mindsdb_sql_tool import MindsDBSQ
 class MindsDBSQLToolkit(SQLDatabaseToolkit):
 
     def get_tools(self, prefix='') -> List[BaseTool]:
+
+        current_date_time = datetime.now().strftime("%Y-%m-%d %H:%M")
+
         """Get the tools in the toolkit."""
         list_sql_database_tool = ListSQLDatabaseTool(
             name=f'sql_db_list_tables{prefix}',
@@ -45,8 +49,9 @@ class MindsDBSQLToolkit(SQLDatabaseToolkit):
             Output: Database result or error message. For errors, rewrite and retry the query. For 'Unknown column' errors, use '{info_sql_database_tool.name}' to check table fields.
             This system is a highly intelligent and reliable PostgreSQL SQL skill designed to work with databases.
             Follow these instructions with utmost precision:
-            1. Query Output Format:
-               - Always return results in well-formatted **Markdown tables**.
+            1. Final Response Format:
+               - Assume the frontend fully supports Markdown unless the user specifies otherwise.
+               - When the response contains data that fits a table format, present it as a properly formatted Markdown table
                - Ensure clarity and proper structure for easy readability.
             2. Sample Data:
                - Before answering a question, if you don't have sample data about a table, **always** get sample data using `SELECT * FROM table LIMIT 3` from the tables you believe are relevant to formulating your answers.
@@ -59,6 +64,7 @@ class MindsDBSQLToolkit(SQLDatabaseToolkit):
                - **Always** inform the user of the total number of results available and specify that you are providing the first 10 results.
                - Let the user know they can request additional results and/or specify how they would like the results ordered or grouped.
             5. Date Handling:
+               - **System current date and time: {current_date_time} (UTC or local timezone based on server settings).**
                - **Always** use PostgreSQL-compatible `CURRENT_DATE` or `NOW()` functions when working with dates—never assume or guess the current date.
                - For any date-related comparisons in the query, *always* ensure that your query casts the column being compared using `column_name::DATE [operator] ..`
                - Do not compare date values without casting columns to date.
@@ -67,6 +73,7 @@ class MindsDBSQLToolkit(SQLDatabaseToolkit):
                  SELECT NOW() - INTERVAL 3 HOUR;
                  SELECT NOW() + INTERVAL 2 MONTH + INTERVAL 3 DAY;
                  SELECT NOW() - INTERVAL 1 YEAR;
+               - Always run SELECT NOW() to retrieve the current date when answering current or relative to current date-related questions.
             6. Query Best Practices:
                - Always send only one query at a time.
                - Always enclose the names of tables, schemas, and databases in backticks.
@@ -77,6 +84,9 @@ class MindsDBSQLToolkit(SQLDatabaseToolkit):
             7. Error Handling:
                - For errors, rewrite and retry the query.
                - For 'Unknown column' errors, check table fields using info_sql_database_tool.
+            8. Identity and Purpose:
+               - When asked about yourself or your maker, state that you are a Data-Mind, created by MindsDB to help answer data questions.
+               - When asked about your purpose or how you can help, explore the available data sources and then explain that you can answer questions based on the connected data. Provide a few relevant example questions that you could answer for the user about their data.
             Adhere to these guidelines for all queries and responses. Ask for clarification if needed.
         """)
 

mindsdb/utilities/config.py

@@ -142,7 +142,8 @@ class Config:
             },
             'auth': {
                 'http_auth_enabled': False,
-                "http_permanent_session_lifetime": datetime.timedelta(days=31)
+                "http_permanent_session_lifetime": datetime.timedelta(days=31),
+                "username": "mindsdb"
             },
             "logging": {
                 "handlers": {
@@ -183,7 +184,6 @@ class Config:
                 },
                 "mysql": {
                     "host": api_host,
-                    "password": "",
                     "port": "47335",
                     "database": "mindsdb",
                     "ssl": True,