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

mindsdb/interfaces/agents/constants.py

@@ -15,7 +15,10 @@ OPEN_AI_CHAT_MODELS = (
     "gpt-4-32k",
     "gpt-4-1106-preview",
     "gpt-4-0125-preview",
+    "gpt-4.1",
+    "gpt-4.1-mini",
     "gpt-4o",
+    "o4-mini",
     "o3-mini",
     "o1-mini",
 )
@@ -216,8 +219,12 @@ You are an AI assistant powered by MindsDB. When answering questions, follow the
    - Finally use kb_query_tool to query the knowledge base for specific information
 
 2. For questions about database tables and their contents:
-   - Use the sql_tool to query the tables directly
+   - Use the sql_db_query to query the tables directly
    - You can join tables if needed to get comprehensive information
+   - You are running on a federated query engine, so joins across multiple databases are allowed and supported
+   - **Important Rule for SQL Queries:** If you formulate an SQL query as part of answering a user's question, you *must* then use the `sql_db_query` tool to execute that query and get its results. The SQL query string itself is NOT the final answer to the user unless the user has specifically asked for the query. Your final AI response should be based on the *results* obtained from executing the query.
+
 
 For factual questions, ALWAYS use the available tools to look up information rather than relying on your internal knowledge.
+
 """

mindsdb/interfaces/agents/langchain_agent.py

@@ -226,7 +226,7 @@ def process_chunk(chunk):
 
 
 class LangchainAgent:
-    def __init__(self, agent: db.Agents, model: dict = None):
+    def __init__(self, agent: db.Agents, model: dict = None, params: dict = None):
         self.agent = agent
         self.model = model
 
@@ -239,16 +239,35 @@ class LangchainAgent:
         self.mdb_langfuse_callback_handler: Optional[object] = None  # custom (see langfuse_callback_handler.py)
 
         self.langfuse_client_wrapper = LangfuseClientWrapper()
-        self.args = self._initialize_args()
+        self.args = self._initialize_args(params)
 
         # Back compatibility for old models
         self.provider = self.args.get("provider", get_llm_provider(self.args))
 
-    def _initialize_args(self) -> dict:
-        """Initialize the arguments based on the agent's parameters."""
-        args = self.agent.params.copy()
-        args["model_name"] = self.agent.model_name
-        args["provider"] = self.agent.provider
+    def _initialize_args(self, params: dict = None) -> dict:
+        """
+        Initialize the arguments for agent execution.
+
+        Takes the parameters passed during execution and sets necessary defaults.
+        The params are already merged with defaults by AgentsController.get_agent_llm_params.
+
+        Args:
+            params: Parameters for agent execution (already merged with defaults)
+
+        Returns:
+            dict: Final parameters for agent execution
+        """
+        # Use the parameters passed to the method (already merged with defaults by AgentsController)
+        # No fallback needed as AgentsController.get_agent_llm_params already handles this
+        args = params.copy() if params else {}
+
+        # Set model name and provider if given in create agent otherwise use global llm defaults
+        # AgentsController.get_agent_llm_params
+        if self.agent.model_name is not None:
+            args["model_name"] = self.agent.model_name
+        if self.agent.provider is not None:
+            args["provider"] = self.agent.provider
+
         args["embedding_model_provider"] = args.get("embedding_model", get_embedding_model_provider(args))
 
         # agent is using current langchain model
@@ -261,11 +280,20 @@ class LangchainAgent:
                 # only update prompt_template if it is set on the model
                 args["prompt_template"] = prompt_template
 
+        # Set default prompt template if not provided
         if args.get("prompt_template") is None:
+            # Default prompt template depends on agent mode
             if args.get("mode") == "retrieval":
                 args["prompt_template"] = DEFAULT_RAG_PROMPT_TEMPLATE
+                logger.info(f"Using default retrieval prompt template: {DEFAULT_RAG_PROMPT_TEMPLATE[:50]}...")
             else:
-                raise ValueError("Please provide a `prompt_template` or set `mode=retrieval`")
+                # Set a default prompt template for non-retrieval mode
+                default_prompt = "you are an assistant, answer using the tables connected"
+                args["prompt_template"] = default_prompt
+                logger.info(f"Using default prompt template: {default_prompt}")
+
+        if "prompt_template" in args:
+            logger.info(f"Using prompt template: {args['prompt_template'][:50]}...")
 
         return args
 
@@ -318,7 +346,7 @@ class LangchainAgent:
         self.provider = args.get("provider", get_llm_provider(args))
 
         df = df.reset_index(drop=True)
-        agent = self.create_agent(df, args)
+        agent = self.create_agent(df)
         # Use last message as prompt, remove other questions.
         user_column = args.get("user_column", USER_COLUMN)
         df.iloc[:-1, df.columns.get_loc(user_column)] = None
@@ -348,14 +376,17 @@ class LangchainAgent:
         self.provider = args.get("provider", get_llm_provider(args))
 
         df = df.reset_index(drop=True)
-        agent = self.create_agent(df, args)
+        agent = self.create_agent(df)
         # Use last message as prompt, remove other questions.
         user_column = args.get("user_column", USER_COLUMN)
         df.iloc[:-1, df.columns.get_loc(user_column)] = None
         return self.stream_agent(df, agent, args)
 
-    def create_agent(self, df: pd.DataFrame, args: Dict = None) -> AgentExecutor:
+    def create_agent(self, df: pd.DataFrame) -> AgentExecutor:
         # Set up tools.
+
+        args = self.args
+
         llm = create_chat_model(args)
         self.llm = llm
 

mindsdb/interfaces/agents/mcp_client_agent.py

@@ -63,11 +63,19 @@ class MCPQueryTool(BaseTool):
         return loop.run_until_complete(self._arun(query))
 
 
+# todo move instantiation to agent controller
 class MCPLangchainAgent(LangchainAgent):
     """Extension of LangchainAgent that delegates to MCP server"""
 
-    def __init__(self, agent: db.Agents, model: dict = None, mcp_host: str = "127.0.0.1", mcp_port: int = 47337):
-        super().__init__(agent, model)
+    def __init__(
+        self,
+        agent: db.Agents,
+        model: dict = None,
+        params: dict = None,
+        mcp_host: str = "127.0.0.1",
+        mcp_port: int = 47337,
+    ):
+        super().__init__(agent, model, params)
         self.mcp_host = mcp_host
         self.mcp_port = mcp_port
         self.exit_stack = AsyncExitStack()
@@ -85,7 +93,7 @@ class MCPLangchainAgent(LangchainAgent):
                 server_params = StdioServerParameters(
                     command="python",
                     args=["-m", "mindsdb", "--api=mcp"],
-                    env={"MCP_HOST": self.mcp_host, "MCP_PORT": str(self.mcp_port)}
+                    env={"MCP_HOST": self.mcp_host, "MCP_PORT": str(self.mcp_port)},
                 )
 
                 logger.info(f"Connecting to MCP server at {self.mcp_host}:{self.mcp_port}")
@@ -99,7 +107,9 @@ class MCPLangchainAgent(LangchainAgent):
 
                 # Test the connection by listing tools
                 tools_response = await self.session.list_tools()
-                logger.info(f"Successfully connected to MCP server. Available tools: {[tool.name for tool in tools_response.tools]}")
+                logger.info(
+                    f"Successfully connected to MCP server. Available tools: {[tool.name for tool in tools_response.tools]}"
+                )
 
             except Exception as e:
                 logger.error(f"Failed to connect to MCP server: {str(e)}")
@@ -141,7 +151,7 @@ class MCPLangchainAgent(LangchainAgent):
         response = super().get_completion(messages, stream)
 
         # Ensure response is a string (not a DataFrame)
-        if hasattr(response, 'to_string'):  # It's a DataFrame
+        if hasattr(response, "to_string"):  # It's a DataFrame
             return response.to_string()
 
         return response
@@ -167,7 +177,7 @@ class LiteLLMAgentWrapper:
         formatted_messages = [
             {
                 "question": msg["content"] if msg["role"] == "user" else "",
-                "answer": msg["content"] if msg["role"] == "assistant" else ""
+                "answer": msg["content"] if msg["role"] == "assistant" else "",
             }
             for msg in messages
         ]
@@ -177,23 +187,16 @@ class LiteLLMAgentWrapper:
 
         # Ensure response is a string
         if not isinstance(response, str):
-            if hasattr(response, 'to_string'):  # It's a DataFrame
+            if hasattr(response, "to_string"):  # It's a DataFrame
                 response = response.to_string()
             else:
                 response = str(response)
 
         # Format response in LiteLLM expected format
         return {
-            "choices": [
-                {
-                    "message": {
-                        "role": "assistant",
-                        "content": response
-                    }
-                }
-            ],
+            "choices": [{"message": {"role": "assistant", "content": response}}],
             "model": self.agent.args["model_name"],
-            "object": "chat.completion"
+            "object": "chat.completion",
         }
 
     async def acompletion_stream(self, messages: List[Dict[str, str]], **kwargs) -> Iterator[Dict[str, Any]]:
@@ -202,7 +205,7 @@ class LiteLLMAgentWrapper:
         formatted_messages = [
             {
                 "question": msg["content"] if msg["role"] == "user" else "",
-                "answer": msg["content"] if msg["role"] == "assistant" else ""
+                "answer": msg["content"] if msg["role"] == "assistant" else "",
             }
             for msg in messages
         ]
@@ -217,7 +220,7 @@ class LiteLLMAgentWrapper:
                     yield {
                         "choices": [{"delta": {"role": "assistant", "content": content}}],
                         "model": model_name,
-                        "object": "chat.completion.chunk"
+                        "object": "chat.completion.chunk",
                     }
                 # Allow async context switch
                 await asyncio.sleep(0)
@@ -230,7 +233,9 @@ class LiteLLMAgentWrapper:
         await self.agent.cleanup()
 
 
-def create_mcp_agent(agent_name: str, project_name: str, mcp_host: str = "127.0.0.1", mcp_port: int = 47337) -> LiteLLMAgentWrapper:
+def create_mcp_agent(
+    agent_name: str, project_name: str, mcp_host: str = "127.0.0.1", mcp_port: int = 47337
+) -> LiteLLMAgentWrapper:
     """Create an MCP agent and wrap it for LiteLLM compatibility"""
     from mindsdb.interfaces.agents.agents_controller import AgentsController
     from mindsdb.interfaces.storage import db
@@ -245,8 +250,11 @@ def create_mcp_agent(agent_name: str, project_name: str, mcp_host: str = "127.0.
     if agent_db is None:
         raise ValueError(f"Agent {agent_name} not found in project {project_name}")
 
-    # Create MCP agent
-    mcp_agent = MCPLangchainAgent(agent_db, mcp_host=mcp_host, mcp_port=mcp_port)
+    # Get merged parameters (defaults + agent params)
+    merged_params = agent_controller.get_agent_llm_params(agent_db.params)
+
+    # Create MCP agent with merged parameters
+    mcp_agent = MCPLangchainAgent(agent_db, params=merged_params, mcp_host=mcp_host, mcp_port=mcp_port)
 
     # Wrap for LiteLLM compatibility
     return LiteLLMAgentWrapper(mcp_agent)

mindsdb/interfaces/agents/mindsdb_database_agent.py

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

mindsdb/interfaces/data_catalog/base_data_catalog.py

@@ -0,0 +1,54 @@
+from typing import List, Optional, Union
+
+from mindsdb.integrations.libs.api_handler import MetaAPIHandler
+from mindsdb.integrations.libs.base import MetaDatabaseHandler
+from mindsdb.utilities import log
+
+
+logger = log.getLogger("mindsdb")
+
+
+class BaseDataCatalog:
+    """
+    This is the base class for the Data Catalog interface.
+    """
+
+    def __init__(self, database_name: str, table_names: Optional[List[str]] = None) -> None:
+        """
+        Initialize the DataCatalogReader.
+
+        Args:
+            database_name (str): The data source to read/write metadata from.
+            table_names (Optional[List[str]]): The list of table names to read or write metadata for. If None, all tables will be read or written.
+        """
+        from mindsdb.api.executor.controllers.session_controller import (
+            SessionController,
+        )
+
+        session = SessionController()
+
+        self.database_name = database_name
+        self.data_handler: Union[MetaDatabaseHandler, MetaAPIHandler] = session.integration_controller.get_data_handler(
+            database_name
+        )
+        integration = session.integration_controller.get(database_name)
+        self.integration_id = integration["id"]
+        self.integration_engine = integration["engine"]
+        # TODO: Handle situations where a schema is provided along with the database name, e.g., 'schema.table'.
+        # TODO: Handle situations where a file path is provided with integrations like S3, e.g., 'dir/file.csv'.
+        self.table_names = table_names
+
+        self.logger = logger
+
+    def is_data_catalog_supported(self) -> bool:
+        """
+        Check if the data catalog is supported for the given database.
+
+        Returns:
+            bool: True if the data catalog is supported, False otherwise.
+        """
+        if not isinstance(self.data_handler, (MetaDatabaseHandler, MetaAPIHandler)):
+            self.logger.warning(f"Data catalog is not supported for the '{self.integration_engine}' integration'. ")
+            return False
+
+        return True