MindsDB 25.9.2.0a1__py3-none-any.whl → 25.10.0__py3-none-any.whl

mindsdb/interfaces/agents/mcp_client_agent.py

@@ -54,8 +54,8 @@ class MCPQueryTool(BaseTool):
             return f"Query executed successfully: {json.dumps(result.content)}"
 
         except Exception as e:
-            logger.error(f"Error executing MCP query: {str(e)}")
-            return f"Error executing query: {str(e)}"
+            logger.error("Error executing MCP query:")
+            return f"Error executing query: {e}"
 
     def _run(self, query: str) -> str:
         """Synchronous wrapper for async query function"""
@@ -112,8 +112,8 @@ class MCPLangchainAgent(LangchainAgent):
                 )
 
             except Exception as e:
-                logger.error(f"Failed to connect to MCP server: {str(e)}")
-                raise ConnectionError(f"Failed to connect to MCP server: {str(e)}")
+                logger.exception("Failed to connect to MCP server:")
+                raise ConnectionError(f"Failed to connect to MCP server: {e}") from e
 
     def _langchain_tools_from_skills(self, llm):
         """Override to add MCP query tool along with other tools"""
@@ -131,8 +131,8 @@ class MCPLangchainAgent(LangchainAgent):
             if self.session:
                 tools.append(MCPQueryTool(self.session))
                 logger.info("Added MCP query tool to agent tools")
-        except Exception as e:
-            logger.error(f"Failed to add MCP query tool: {str(e)}")
+        except Exception:
+            logger.exception("Failed to add MCP query tool:")
 
         return tools
 
@@ -144,8 +144,8 @@ class MCPLangchainAgent(LangchainAgent):
                 # Using the event loop directly instead of asyncio.run()
                 loop = asyncio.get_event_loop()
                 loop.run_until_complete(self.connect_to_mcp())
-        except Exception as e:
-            logger.error(f"Failed to connect to MCP server: {str(e)}")
+        except Exception:
+            logger.exception("Failed to connect to MCP server:")
 
         # Call parent implementation to get completion
         response = super().get_completion(messages, stream)
@@ -224,8 +224,8 @@ class LiteLLMAgentWrapper:
                     }
                 # Allow async context switch
                 await asyncio.sleep(0)
-        except Exception as e:
-            logger.error(f"Streaming error: {str(e)}")
+        except Exception:
+            logger.exception("Streaming error:")
             raise
 
     async def cleanup(self):

mindsdb/interfaces/agents/mindsdb_database_agent.py

@@ -3,11 +3,11 @@ Wrapper around MindsDB's executor and integration controller following the imple
 langchain.sql_database.SQLDatabase class to partly replicate its behavior.
 """
 
-import traceback
 from typing import Any, Iterable, List, Optional
 
-from mindsdb.utilities import log
 from langchain_community.utilities import SQLDatabase
+
+from mindsdb.utilities import log
 from mindsdb.interfaces.skills.sql_agent import SQLAgent
 
 logger = log.getLogger(__name__)
@@ -99,7 +99,7 @@ class MindsDBSQL(SQLDatabase):
             return self._sql_agent.query(command)
 
         except Exception as e:
-            logger.error(f"Error executing SQL command: {str(e)}\n{traceback.format_exc()}")
+            logger.exception("Error executing SQL command:")
             # 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()
@@ -115,8 +115,8 @@ class MindsDBSQL(SQLDatabase):
         """
         try:
             return self._sql_agent.get_usable_knowledge_base_names()
-        except Exception as e:
-            logger.error(f"Error getting usable knowledge base names: {str(e)}")
+        except Exception:
+            logger.exception("Error getting usable knowledge base names:")
             return []
 
     def check_knowledge_base_permission(self, name):

mindsdb/interfaces/agents/run_mcp_agent.py

@@ -37,8 +37,8 @@ async def run_conversation(agent_wrapper, messages: List[Dict[str, str]], stream
             # We still need to display the response to the user
             sys.stdout.write(f"{content}\n")
             sys.stdout.flush()
-    except Exception as e:
-        logger.error(f"Error during agent conversation: {str(e)}")
+    except Exception:
+        logger.exception("Error during agent conversation:")
 
 
 async def execute_direct_query(query):
@@ -48,11 +48,7 @@ async def execute_direct_query(query):
     # Set up MCP client to connect to the running server
     async with AsyncExitStack() as stack:
         # Connect to MCP server
-        server_params = StdioServerParameters(
-            command="python",
-            args=["-m", "mindsdb", "--api=mcp"],
-            env=None
-        )
+        server_params = StdioServerParameters(command="python", args=["-m", "mindsdb", "--api=mcp"], env=None)
 
         try:
             stdio_transport = await stack.enter_async_context(stdio_client(server_params))
@@ -80,9 +76,9 @@ async def execute_direct_query(query):
             # Execute query
             result = await session.call_tool("query", {"query": query})
             logger.info(f"Query result: {result.content}")
-        except Exception as e:
-            logger.error(f"Error executing query: {str(e)}")
-            logger.info("Make sure the MindsDB server is running with MCP enabled: python -m mindsdb --api=mysql,mcp,http")
+        except Exception:
+            logger.exception("Error executing query:")
+            logger.info("Make sure the MindsDB server is running with HTTP enabled: python -m mindsdb --api=http")
 
 
 async def main():
@@ -100,6 +96,7 @@ async def main():
     try:
         # Initialize database connection
         from mindsdb.interfaces.storage import db
+
         db.init()
 
         # Direct SQL execution mode (for testing MCP connection)
@@ -117,10 +114,7 @@ async def main():
         logger.info("Make sure MindsDB server is running with MCP enabled: python -m mindsdb --api=mysql,mcp,http")
 
         agent_wrapper = create_mcp_agent(
-            agent_name=args.agent,
-            project_name=args.project,
-            mcp_host=args.host,
-            mcp_port=args.port
+            agent_name=args.agent, project_name=args.project, mcp_host=args.host, mcp_port=args.port
         )
 
         # Run an example query if provided
@@ -173,7 +167,7 @@ async def main():
                             sys.stdout.write("Error: No active MCP session\n")
                             sys.stdout.flush()
                     except Exception as e:
-                        logger.error(f"SQL Error: {str(e)}")
+                        logger.exception("SQL Error:")
                         sys.stdout.write(f"SQL Error: {str(e)}\n")
                         sys.stdout.flush()
                     continue
@@ -184,17 +178,14 @@ async def main():
                 # Add assistant's response to the conversation history
                 if not args.stream:
                     response = await agent_wrapper.acompletion(messages)
-                    messages.append({
-                        "role": "assistant",
-                        "content": response["choices"][0]["message"]["content"]
-                    })
+                    messages.append({"role": "assistant", "content": response["choices"][0]["message"]["content"]})
 
         # Clean up resources
         logger.info("Cleaning up resources")
         await agent_wrapper.cleanup()
 
-    except Exception as e:
-        logger.error(f"Error running MCP agent: {str(e)}")
+    except Exception:
+        logger.exception("Error running MCP agent:")
         logger.info("Make sure the MindsDB server is running with MCP enabled: python -m mindsdb --api=mysql,mcp,http")
         return 1
 

mindsdb/interfaces/chatbot/chatbot_task.py

@@ -21,7 +21,6 @@ HOLDING_MESSAGE = "Bot is typing..."
 
 
 class ChatBotTask(BaseTask):
-
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.bot_id = self.object_id
@@ -40,7 +39,7 @@ class ChatBotTask(BaseTask):
         self.agent_id = bot_record.agent_id
         if self.agent_id is not None:
             self.bot_executor_cls = AgentExecutor
-        elif self.bot_params.get('modes') is None:
+        elif self.bot_params.get("modes") is None:
             self.bot_executor_cls = BotExecutor
         else:
             self.bot_executor_cls = MultiModeBotExecutor
@@ -52,36 +51,35 @@ class ChatBotTask(BaseTask):
             raise Exception(f"Can't use chat database: {database_name}")
 
         chat_params = self.chat_handler.get_chat_config()
-        polling = chat_params['polling']['type']
+        polling = chat_params["polling"]["type"]
 
-        memory = chat_params['memory']['type'] if 'memory' in chat_params else None
+        memory = chat_params["memory"]["type"] if "memory" in chat_params else None
         memory_cls = None
         if memory:
-            memory_cls = DBMemory if memory == 'db' else HandlerMemory
+            memory_cls = DBMemory if memory == "db" else HandlerMemory
 
-        if polling == 'message_count':
-            chat_params = chat_params['tables'] if 'tables' in chat_params else [chat_params]
+        if polling == "message_count":
+            chat_params = chat_params["tables"] if "tables" in chat_params else [chat_params]
             self.chat_pooling = MessageCountPolling(self, chat_params)
             # The default type for message count polling is HandlerMemory if not specified.
             self.memory = HandlerMemory(self, chat_params) if memory_cls is None else memory_cls(self, chat_params)
 
-        elif polling == 'realtime':
-            chat_params = chat_params['tables'] if 'tables' in chat_params else [chat_params]
+        elif polling == "realtime":
+            chat_params = chat_params["tables"] if "tables" in chat_params else [chat_params]
             self.chat_pooling = RealtimePolling(self, chat_params)
             # The default type for real-time polling is DBMemory if not specified.
             self.memory = DBMemory(self, chat_params) if memory_cls is None else memory_cls(self, chat_params)
 
-        elif polling == 'webhook':
+        elif polling == "webhook":
             self.chat_pooling = WebhookPolling(self, chat_params)
             self.memory = DBMemory(self, chat_params)
 
         else:
             raise Exception(f"Not supported polling: {polling}")
 
-        self.bot_params['bot_username'] = self.chat_handler.get_my_user_name()
+        self.bot_params["bot_username"] = self.chat_handler.get_my_user_name()
 
     def run(self, stop_event):
-
         # TODO check deleted, raise errors
         # TODO checks on delete predictor / project/ integration
 
@@ -89,7 +87,7 @@ class ChatBotTask(BaseTask):
 
     def on_message(self, message: ChatBotMessage, chat_id=None, chat_memory=None, table_name=None):
         if not chat_id and not chat_memory:
-            raise Exception('chat_id or chat_memory should be provided')
+            raise Exception("chat_id or chat_memory should be provided")
 
         try:
             self._on_holding_message(chat_id, chat_memory, table_name)
@@ -97,9 +95,8 @@ class ChatBotTask(BaseTask):
         except (SystemExit, KeyboardInterrupt):
             raise
         except Exception:
-            error = traceback.format_exc()
-            logger.error(error)
-            self.set_error(str(error))
+            logger.exception("Error during chatbot message processing:")
+            self.set_error(traceback.format_exc())
 
     def _on_holding_message(self, chat_id: str = None, chat_memory: BaseMemory = None, table_name: str = None):
         """
@@ -117,14 +114,14 @@ class ChatBotTask(BaseTask):
             ChatBotMessage.Type.DIRECT,
             HOLDING_MESSAGE,
             # In Slack direct messages are treated as channels themselves.
-            user=self.bot_params['bot_username'],
+            user=self.bot_params["bot_username"],
             destination=chat_id,
-            sent_at=dt.datetime.now()
+            sent_at=dt.datetime.now(),
         )
 
         # send to chat adapter
         self.chat_pooling.send_message(response_message, table_name=table_name)
-        logger.debug(f'>>chatbot {chat_id} out (holding message): {response_message.text}')
+        logger.debug(f">>chatbot {chat_id} out (holding message): {response_message.text}")
 
     def _on_message(self, message: ChatBotMessage, chat_id, chat_memory, table_name=None):
         # add question to history
@@ -132,26 +129,26 @@ class ChatBotTask(BaseTask):
         chat_memory = chat_memory if chat_memory else self.memory.get_chat(chat_id, table_name=table_name)
         chat_memory.add_to_history(message)
 
-        logger.debug(f'>>chatbot {chat_memory.chat_id} in: {message.text}')
+        logger.debug(f">>chatbot {chat_memory.chat_id} in: {message.text}")
 
         # process
         bot_executor = self.bot_executor_cls(self, chat_memory)
         response_text = bot_executor.process()
 
         chat_id = chat_memory.chat_id
-        bot_username = self.bot_params['bot_username']
+        bot_username = self.bot_params["bot_username"]
         response_message = ChatBotMessage(
             ChatBotMessage.Type.DIRECT,
             response_text,
             # In Slack direct messages are treated as channels themselves.
             user=bot_username,
             destination=chat_id,
-            sent_at=dt.datetime.now()
+            sent_at=dt.datetime.now(),
         )
 
         # send to chat adapter
         self.chat_pooling.send_message(response_message, table_name=table_name)
-        logger.debug(f'>>chatbot {chat_id} out: {response_message.text}')
+        logger.debug(f">>chatbot {chat_id} out: {response_message.text}")
 
         # send to history
         chat_memory.add_to_history(response_message)

mindsdb/interfaces/chatbot/polling.py

@@ -24,10 +24,14 @@ class BasePolling:
         chat_id = message.destination if isinstance(message.destination, tuple) else (message.destination,)
         text = message.text
 
-        t_params = self.params["chat_table"] if table_name is None else next(
-            (t["chat_table"] for t in self.params if t["chat_table"]["name"] == table_name)
+        t_params = (
+            self.params["chat_table"]
+            if table_name is None
+            else next((t["chat_table"] for t in self.params if t["chat_table"]["name"] == table_name))
+        )
+        chat_id_cols = (
+            t_params["chat_id_col"] if isinstance(t_params["chat_id_col"], list) else [t_params["chat_id_col"]]
         )
-        chat_id_cols = t_params["chat_id_col"] if isinstance(t_params["chat_id_col"], list) else [t_params["chat_id_col"]]
 
         ast_query = Insert(
             table=Identifier(t_params["name"]),
@@ -60,20 +64,22 @@ class MessageCountPolling(BasePolling):
                                 chat_id,
                                 table_name=chat_params["chat_table"]["name"],
                             )
-                        except Exception as e:
-                            logger.error(f"Problem retrieving chat memory: {e}")
+                        except Exception:
+                            logger.exception("Problem retrieving chat memory:")
 
                         try:
                             message = self.get_last_message(chat_memory)
-                        except Exception as e:
-                            logger.error(f"Problem getting last message: {e}")
+                        except Exception:
+                            logger.exception("Problem getting last message:")
                             message = None
 
                         if message:
-                            self.chat_task.on_message(message, chat_memory=chat_memory, table_name=chat_params["chat_table"]["name"])
+                            self.chat_task.on_message(
+                                message, chat_memory=chat_memory, table_name=chat_params["chat_table"]["name"]
+                            )
 
-            except Exception as e:
-                logger.error(e)
+            except Exception:
+                logger.exception("Unexpected error")
 
             if stop_event.is_set():
                 return
@@ -84,8 +90,8 @@ class MessageCountPolling(BasePolling):
         # retrive from history
         try:
             history = chat_memory.get_history()
-        except Exception as e:
-            logger.error(f"Problem retrieving history: {e}")
+        except Exception:
+            logger.exception("Problem retrieving history:")
             history = []
         last_message = history[-1]
         if last_message.user == self.chat_task.bot_params["bot_username"]:
@@ -151,7 +157,11 @@ class RealtimePolling(BasePolling):
             # Identify the table relevant to this event based on the key.
             event_keys = list(key.keys())
             for param in self.params:
-                table_keys = [param["chat_table"]["chat_id_col"]] if isinstance(param["chat_table"]["chat_id_col"], str) else param["chat_table"]["chat_id_col"]
+                table_keys = (
+                    [param["chat_table"]["chat_id_col"]]
+                    if isinstance(param["chat_table"]["chat_id_col"], str)
+                    else param["chat_table"]["chat_id_col"]
+                )
 
                 if sorted(event_keys) == sorted(table_keys):
                     t_params = param["chat_table"]
@@ -162,7 +172,11 @@ class RealtimePolling(BasePolling):
             t_params = self.params[0]
 
         # Get the chat ID from the row based on the chat ID column(s).
-        chat_id = tuple(row[key] for key in t_params["chat_id_col"]) if isinstance(t_params["chat_id_col"], list) else row[t_params["chat_id_col"]]
+        chat_id = (
+            tuple(row[key] for key in t_params["chat_id_col"])
+            if isinstance(t_params["chat_id_col"], list)
+            else row[t_params["chat_id_col"]]
+        )
 
         message = ChatBotMessage(
             ChatBotMessage.Type.DIRECT,
@@ -179,10 +193,7 @@ class RealtimePolling(BasePolling):
         )
 
     def run(self, stop_event):
-        self.chat_task.chat_handler.subscribe(
-            stop_event,
-            self._callback
-        )
+        self.chat_task.chat_handler.subscribe(stop_event, self._callback)
 
     # def send_message(self, message: ChatBotMessage):
     #
@@ -193,6 +204,7 @@ class WebhookPolling(BasePolling):
     """
     Polling class for handling webhooks.
     """
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 

mindsdb/interfaces/data_catalog/data_catalog_loader.py

@@ -19,9 +19,7 @@ class DataCatalogLoader(BaseDataCatalog):
         if not self.is_data_catalog_supported():
             return
 
-        loaded_table_names = self._get_loaded_table_names()
-
-        tables = self._load_table_metadata(loaded_table_names)
+        tables = self._load_table_metadata()
 
         if tables:
             columns = self._load_column_metadata(tables)
@@ -34,7 +32,7 @@ class DataCatalogLoader(BaseDataCatalog):
 
         self.logger.info(f"Metadata loading completed for {self.database_name}.")
 
-    def _get_loaded_table_names(self) -> List[str]:
+    def _get_loaded_table_names(self, in_table_names) -> List[str]:
         """
         Retrieve the names of tables that are already present in the data catalog for the current integration.
         If table_names are provided, only those tables will be checked.
@@ -43,8 +41,8 @@ class DataCatalogLoader(BaseDataCatalog):
             List[str]: Names of tables already loaded in the data catalog.
         """
         query = db.session.query(db.MetaTables).filter_by(integration_id=self.integration_id)
-        if self.table_names:
-            query = query.filter(db.MetaTables.name.in_(self.table_names))
+        if in_table_names:
+            query = query.filter(db.MetaTables.name.in_(in_table_names))
 
         tables = query.all()
         table_names = [table.name for table in tables]
@@ -54,7 +52,7 @@ class DataCatalogLoader(BaseDataCatalog):
 
         return table_names
 
-    def _load_table_metadata(self, loaded_table_names: List[str] = None) -> List[Union[db.MetaTables, None]]:
+    def _load_table_metadata(self) -> List[Union[db.MetaTables, None]]:
         """
         Load the table metadata from the handler.
         """
@@ -75,6 +73,7 @@ class DataCatalogLoader(BaseDataCatalog):
         df.columns = df.columns.str.lower()
 
         # Filter out tables that are already loaded in the data catalog
+        loaded_table_names = self._get_loaded_table_names(list(df["table_name"]))
         if loaded_table_names:
             df = df[~df["table_name"].isin(loaded_table_names)]
 
@@ -109,8 +108,8 @@ class DataCatalogLoader(BaseDataCatalog):
 
             db.session.add_all(tables)
             db.session.commit()
-        except Exception as e:
-            self.logger.error(f"Failed to add tables: {e}")
+        except Exception:
+            self.logger.exception("Failed to add tables:")
             db.session.rollback()
             raise
         return tables
@@ -157,8 +156,8 @@ class DataCatalogLoader(BaseDataCatalog):
 
             db.session.add_all(columns)
             db.session.commit()
-        except Exception as e:
-            self.logger.error(f"Failed to add columns: {e}")
+        except Exception:
+            self.logger.exception("Failed to add columns:")
             db.session.rollback()
             raise
         return columns
@@ -223,8 +222,8 @@ class DataCatalogLoader(BaseDataCatalog):
 
             db.session.add_all(column_statistics)
             db.session.commit()
-        except Exception as e:
-            self.logger.error(f"Failed to add column statistics: {e}")
+        except Exception:
+            self.logger.exception("Failed to add column statistics:")
             db.session.rollback()
             raise
 
@@ -275,8 +274,8 @@ class DataCatalogLoader(BaseDataCatalog):
 
             db.session.add_all(primary_keys)
             db.session.commit()
-        except Exception as e:
-            self.logger.error(f"Failed to add primary keys: {e}")
+        except Exception:
+            self.logger.exception("Failed to add primary keys:")
             db.session.rollback()
             raise
 
@@ -344,8 +343,8 @@ class DataCatalogLoader(BaseDataCatalog):
 
             db.session.add_all(foreign_keys)
             db.session.commit()
-        except Exception as e:
-            self.logger.error(f"Failed to add foreign keys: {e}")
+        except Exception:
+            self.logger.exception("Failed to add foreign keys:")
             db.session.rollback()
             raise
 

mindsdb/interfaces/data_catalog/data_catalog_reader.py

@@ -1,3 +1,5 @@
+import sqlalchemy as sa
+
 from mindsdb.interfaces.data_catalog.base_data_catalog import BaseDataCatalog
 from mindsdb.interfaces.storage import db
 
@@ -13,8 +15,11 @@ class DataCatalogReader(BaseDataCatalog):
         """
         tables = self._read_metadata()
         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}'"
+            # try case independent
+            tables = self._read_metadata(strict_case=False)
+            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"):
@@ -42,7 +47,7 @@ class DataCatalogReader(BaseDataCatalog):
         """
         return self.data_handler.meta_get_handler_info()
 
-    def _read_metadata(self) -> list:
+    def _read_metadata(self, strict_case=True) -> list:
         """
         Read the metadata from the data catalog and return it in a structured format.
         """
@@ -52,6 +57,12 @@ class DataCatalogReader(BaseDataCatalog):
         query = db.session.query(db.MetaTables).filter_by(integration_id=self.integration_id)
         if self.table_names:
             cleaned_table_names = [name.strip("`").split(".")[-1] for name in self.table_names]
-            query = query.filter(db.MetaTables.name.in_(cleaned_table_names))
+
+            if strict_case:
+                query = query.filter(db.MetaTables.name.in_(cleaned_table_names))
+            else:
+                cleaned_table_names = [name.lower() for name in cleaned_table_names]
+                query = query.filter(sa.func.lower(db.MetaTables.name).in_(cleaned_table_names))
         tables = query.all()
+
         return tables