MindsDB 25.8.3.0__py3-none-any.whl → 25.9.1.1__py3-none-any.whl

mindsdb/api/http/namespaces/handlers.py

@@ -19,96 +19,94 @@ from mindsdb.api.http.utils import http_error
 from mindsdb.api.http.namespaces.configs.handlers import ns_conf
 from mindsdb.api.executor.controllers.session_controller import SessionController
 from mindsdb.api.executor.command_executor import ExecuteCommands
-from mindsdb.utilities.config import Config
 
 
-@ns_conf.route('/')
+@ns_conf.route("/")
 class HandlersList(Resource):
-    @ns_conf.doc('handlers_list')
-    @api_endpoint_metrics('GET', '/handlers')
+    @ns_conf.doc("handlers_list")
+    @api_endpoint_metrics("GET", "/handlers")
     def get(self):
-        '''List all db handlers'''
+        """List all db handlers"""
 
-        if request.args.get('lazy') == '1':
+        if request.args.get("lazy") == "1":
             handlers = ca.integration_controller.get_handlers_metadata()
         else:
             handlers = ca.integration_controller.get_handlers_import_status()
         result = []
         for handler_type, handler_meta in handlers.items():
             # remove non-integration handlers
-            if handler_type not in ['utilities', 'dummy_data']:
-                row = {'name': handler_type}
+            if handler_type not in ["utilities", "dummy_data"]:
+                row = {"name": handler_type}
                 row.update(handler_meta)
-                del row['path']
+                del row["path"]
                 result.append(row)
         return result
 
 
-@ns_conf.route('/<handler_name>/icon')
+@ns_conf.route("/<handler_name>/icon")
 class HandlerIcon(Resource):
-    @ns_conf.param('handler_name', 'Handler name')
-    @api_endpoint_metrics('GET', '/handlers/handler/icon')
+    @ns_conf.param("handler_name", "Handler name")
+    @api_endpoint_metrics("GET", "/handlers/handler/icon")
     def get(self, handler_name):
         try:
             handler_meta = ca.integration_controller.get_handlers_metadata().get(handler_name)
             if handler_meta is None:
-                return http_error(HTTPStatus.NOT_FOUND, 'Icon not found', f'Icon for {handler_name} not found')
-            icon_name = handler_meta['icon']['name']
-            handler_folder = handler_meta['import']['folder']
-            mindsdb_path = Path(importlib.util.find_spec('mindsdb').origin).parent
-            icon_path = mindsdb_path.joinpath('integrations/handlers').joinpath(handler_folder).joinpath(icon_name)
+                return http_error(HTTPStatus.NOT_FOUND, "Icon not found", f"Icon for {handler_name} not found")
+            icon_name = handler_meta["icon"]["name"]
+            handler_folder = handler_meta["import"]["folder"]
+            mindsdb_path = Path(importlib.util.find_spec("mindsdb").origin).parent
+            icon_path = mindsdb_path.joinpath("integrations/handlers").joinpath(handler_folder).joinpath(icon_name)
             if icon_path.is_absolute() is False:
                 icon_path = Path(os.getcwd()).joinpath(icon_path)
         except Exception:
-            return http_error(HTTPStatus.NOT_FOUND, 'Icon not found', f'Icon for {handler_name} not found')
+            return http_error(HTTPStatus.NOT_FOUND, "Icon not found", f"Icon for {handler_name} not found")
         else:
             return send_file(icon_path)
 
 
-@ns_conf.route('/<handler_name>')
+@ns_conf.route("/<handler_name>")
 class HandlerInfo(Resource):
-    @ns_conf.param('handler_name', 'Handler name')
-    @api_endpoint_metrics('GET', '/handlers/handler')
+    @ns_conf.param("handler_name", "Handler name")
+    @api_endpoint_metrics("GET", "/handlers/handler")
     def get(self, handler_name):
-
         handler_meta = ca.integration_controller.get_handler_meta(handler_name)
-        row = {'name': handler_name}
+        row = {"name": handler_name}
         row.update(handler_meta)
-        del row['path']
-        del row['icon']
+        del row["path"]
+        del row["icon"]
         return row
 
 
-@ns_conf.route('/<handler_name>/install')
+@ns_conf.route("/<handler_name>/install")
 class InstallDependencies(Resource):
-    @ns_conf.param('handler_name', 'Handler name')
-    @api_endpoint_metrics('POST', '/handlers/handler/install')
+    @ns_conf.param("handler_name", "Handler name")
+    @api_endpoint_metrics("POST", "/handlers/handler/install")
     def post(self, handler_name):
         handler_meta = ca.integration_controller.get_handler_meta(handler_name)
 
         if handler_meta is None:
-            return f'Unknown handler: {handler_name}', 400
+            return f"Unknown handler: {handler_name}", 400
 
-        if handler_meta.get('import', {}).get('success', False) is True:
-            return 'Installed', 200
+        if handler_meta.get("import", {}).get("success", False) is True:
+            return "Installed", 200
 
-        dependencies = handler_meta['import']['dependencies']
+        dependencies = handler_meta["import"]["dependencies"]
         if len(dependencies) == 0:
-            return 'Installed', 200
+            return "Installed", 200
 
         result = install_dependencies(dependencies)
 
         # reload it if any result, so we can get new error message
         ca.integration_controller.reload_handler_module(handler_name)
-        if result.get('success') is True:
+        if result.get("success") is True:
             # If warm processes are available in the cache, remove them.
             # This will force a new process to be created with the installed dependencies.
             process_cache.remove_processes_for_handler(handler_name)
-            return '', 200
+            return "", 200
         return http_error(
             500,
-            f'Failed to install dependencies for {handler_meta.get("title", handler_name)}',
-            result.get('error_message', 'unknown error')
+            f"Failed to install dependencies for {handler_meta.get('title', handler_name)}",
+            result.get("error_message", "unknown error"),
         )
 
 
@@ -122,24 +120,24 @@ def prepare_formdata():
         params[name] = value
 
     def on_file(file):
-        params[file.field_name.decode()] = file.file_object
-        file_names.append(file.field_name.decode())
+        file_name = file.field_name.decode()
+        if file_name not in ("code", "modules"):
+            raise ValueError(f"Wrong field name: {file_name}")
+        params[file_name] = file.file_object
+        file_names.append(file_name)
 
-    temp_dir_path = temp_dir_path = tempfile.mkdtemp(
-        prefix='mindsdb_byom_file_',
-        dir=Config().paths['tmp']
-    )
+    temp_dir_path = tempfile.mkdtemp(prefix="mindsdb_file_")
 
     parser = multipart.create_form_parser(
         headers=request.headers,
         on_field=on_field,
         on_file=on_file,
         config={
-            'UPLOAD_DIR': temp_dir_path.encode(),  # bytes required
-            'UPLOAD_KEEP_FILENAME': True,
-            'UPLOAD_KEEP_EXTENSIONS': True,
-            'MAX_MEMORY_FILE_SIZE': 0
-        }
+            "UPLOAD_DIR": temp_dir_path.encode(),  # bytes required
+            "UPLOAD_KEEP_FILENAME": True,
+            "UPLOAD_KEEP_EXTENSIONS": True,
+            "MAX_MEMORY_FILE_SIZE": float("inf"),
+        },
     )
 
     while True:
@@ -151,32 +149,33 @@ def prepare_formdata():
     parser.close()
 
     for file_name in file_names:
+        file_path = os.path.join(temp_dir_path, file_name)
+        with open(file_path, "wb") as f:
+            params[file_name].seek(0)
+            f.write(params[file_name].read())
         params[file_name].close()
+        params[file_name] = file_path
 
     return params
 
 
-@ns_conf.route('/byom/<name>')
-@ns_conf.param('name', "Name of the model")
+@ns_conf.route("/byom/<name>")
+@ns_conf.param("name", "Name of the model")
 class BYOMUpload(Resource):
-    @ns_conf.doc('post_file')
-    @api_endpoint_metrics('POST', '/handlers/byom/handler')
+    @ns_conf.doc("post_file")
+    @api_endpoint_metrics("POST", "/handlers/byom/handler")
     def post(self, name):
         params = prepare_formdata()
 
-        code_file_path = params['code'].name.decode()
+        code_file_path = params["code"]
         try:
-            module_file_path = params['modules'].name.decode()
+            module_file_path = params["modules"]
         except AttributeError:
-            module_file_path = Path(code_file_path).parent / 'requirements.txt'
+            module_file_path = Path(code_file_path).parent / "requirements.txt"
             module_file_path.touch()
             module_file_path = str(module_file_path)
 
-        connection_args = {
-            'code': code_file_path,
-            'modules': module_file_path,
-            'type': params.get('type')
-        }
+        connection_args = {"code": code_file_path, "modules": module_file_path, "type": params.get("type")}
 
         session = SessionController()
 
@@ -185,48 +184,39 @@ class BYOMUpload(Resource):
 
         engine_storage = HandlerStorage(base_ml_handler.integration_id)
 
-        engine_versions = [
-            int(x) for x in engine_storage.get_connection_args()['versions'].keys()
-        ]
+        engine_versions = [int(x) for x in engine_storage.get_connection_args()["versions"].keys()]
 
-        return {
-            'last_engine_version': max(engine_versions),
-            'engine_versions': engine_versions
-        }
+        return {"last_engine_version": max(engine_versions), "engine_versions": engine_versions}
 
-    @ns_conf.doc('put_file')
-    @api_endpoint_metrics('PUT', '/handlers/byom/handler')
+    @ns_conf.doc("put_file")
+    @api_endpoint_metrics("PUT", "/handlers/byom/handler")
     def put(self, name):
-        ''' upload new model
-            params in FormData:
-                - code
-                - modules
-        '''
+        """upload new model
+        params in FormData:
+            - code
+            - modules
+        """
 
         params = prepare_formdata()
 
-        code_file_path = params['code'].name.decode()
+        code_file_path = params["code"]
         try:
-            module_file_path = params['modules'].name.decode()
+            module_file_path = params["modules"]
         except KeyError:
-            module_file_path = Path(code_file_path).parent / 'requirements.txt'
+            module_file_path = Path(code_file_path).parent / "requirements.txt"
             module_file_path.touch()
             module_file_path = str(module_file_path)
 
         connection_args = {
-            'code': code_file_path,
-            'modules': module_file_path,
-            'mode': params.get('mode'),
-            'type': params.get('type')
+            "code": code_file_path,
+            "modules": module_file_path,
+            "mode": params.get("mode"),
+            "type": params.get("type"),
         }
 
-        ast_query = CreateMLEngine(
-            name=Identifier(name),
-            handler='byom',
-            params=connection_args
-        )
+        ast_query = CreateMLEngine(name=Identifier(name), handler="byom", params=connection_args)
         sql_session = SessionController()
         command_executor = ExecuteCommands(sql_session)
         command_executor.execute_command(ast_query)
 
-        return '', 200
+        return "", 200

mindsdb/api/http/start.py

@@ -1,8 +1,8 @@
 import gc
+
 gc.disable()
 
 from flask import Flask
-from waitress import serve
 
 from mindsdb.api.http.initialize import initialize_app
 from mindsdb.interfaces.storage import db
@@ -10,63 +10,45 @@ from mindsdb.utilities import log
 from mindsdb.utilities.config import config
 from mindsdb.utilities.functions import init_lexer_parsers
 from mindsdb.integrations.libs.ml_exec_base import process_cache
+from mindsdb.api.common.middleware import PATAuthMiddleware
+
+
+from starlette.applications import Starlette
+from starlette.routing import Mount
+from starlette.middleware.wsgi import WSGIMiddleware
+import uvicorn
+
+from mindsdb.api.a2a import get_a2a_app
+from mindsdb.api.mcp import get_mcp_app
 
 gc.enable()
 
 logger = log.getLogger(__name__)
 
 
-def start(verbose, no_studio, app: Flask = None):
+def start(verbose, app: Flask = None):
     db.init()
     init_lexer_parsers()
 
     if app is None:
-        app = initialize_app(config, no_studio)
+        app = initialize_app()
 
-    port = config['api']['http']['port']
-    host = config['api']['http']['host']
-    server_type = config['api']['http']['server']['type']
-    server_config = config['api']['http']['server']['config']
+    port = config["api"]["http"]["port"]
+    host = config["api"]["http"]["host"]
 
     process_cache.init()
 
-    if server_type == "waitress":
-        logger.debug("Serving HTTP app with waitress...")
-        serve(
-            app,
-            host='*' if host in ('', '0.0.0.0') else host,
-            port=port,
-            **server_config
-        )
-    elif server_type == "flask":
-        logger.debug("Serving HTTP app with flask...")
-        # that will 'disable access' log in console
-
-        app.run(debug=False, port=port, host=host, **server_config)
-    elif server_type == 'gunicorn':
-        try:
-            from mindsdb.api.http.gunicorn_wrapper import StandaloneApplication
-        except ImportError:
-            logger.error(
-                "Gunicorn server is not available by default. If you wish to use it, please install 'gunicorn'"
-            )
-            return
-
-        def post_fork(arbiter, worker):
-            db.engine.dispose()
-
-        def before_worker_exit(arbiter, worker):
-            """Latest version of gunicorn (23.0.0) calls 'join' for each child process before exiting. However this does
-            not work for processes created by ProcessPoolExecutor, because they execute forever. We need to explicitly
-            call 'shutdown' for such processes before exiting.
-            """
-            from mindsdb.integrations.libs.process_cache import process_cache
-            process_cache.shutdown(wait=True)
-
-        options = {
-            'bind': f'{host}:{port}',
-            'post_fork': post_fork,
-            'worker_exit': before_worker_exit,
-            **server_config
-        }
-        StandaloneApplication(app, options).run()
+    routes = []
+    # Specific mounts FIRST
+    a2a = get_a2a_app()
+    a2a.add_middleware(PATAuthMiddleware)
+    mcp = get_mcp_app()
+    mcp.add_middleware(PATAuthMiddleware)
+    routes.append(Mount("/a2a", app=a2a))
+    routes.append(Mount("/mcp", app=mcp))
+
+    # Root app LAST so it won't shadow the others
+    routes.append(Mount("/", app=WSGIMiddleware(app)))
+
+    # Setting logging to None makes uvicorn use the existing logging configuration
+    uvicorn.run(Starlette(routes=routes, debug=verbose), host=host, port=int(port), log_level=None, log_config=None)

mindsdb/api/litellm/start.py

@@ -24,12 +24,12 @@ async def start_async(verbose=False):
     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))
+    mcp_host = "127.0.0.1"
+    mcp_port = int(config.get("api", {}).get("http", {}).get("port", 47334))
 
     # 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))
+    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}")
@@ -41,7 +41,7 @@ async def start_async(verbose=False):
         mcp_host=mcp_host,
         mcp_port=mcp_port,
         host=litellm_host,
-        port=litellm_port
+        port=litellm_port,
     )
 
 
@@ -52,6 +52,7 @@ def start(verbose=False):
         verbose (bool): Whether to enable verbose logging
     """
     from mindsdb.interfaces.storage import db
+
     db.init()
 
     # Run the async function in the event loop
@@ -64,10 +65,10 @@ def start(verbose=False):
         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))
+        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,
@@ -75,7 +76,7 @@ def start(verbose=False):
             mcp_host=mcp_host,
             mcp_port=mcp_port,
             host=litellm_host,
-            port=litellm_port
+            port=litellm_port,
         )
     else:
         logger.error("LiteLLM server initialization failed")

mindsdb/api/mcp/__init__.py

@@ -0,0 +1,165 @@
+from textwrap import dedent
+from typing import Any
+from contextlib import asynccontextmanager
+from collections.abc import AsyncIterator
+from dataclasses import dataclass
+
+from mcp.server.fastmcp import FastMCP
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+
+from mindsdb.api.mysql.mysql_proxy.classes.fake_mysql_proxy import FakeMysqlProxy
+from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE as SQL_RESPONSE_TYPE
+from mindsdb.interfaces.storage import db
+from mindsdb.utilities import log
+
+logger = log.getLogger(__name__)
+
+
+@dataclass
+class AppContext:
+    db: Any
+
+
+@asynccontextmanager
+async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
+    """Manage application lifecycle with type-safe context"""
+    # Initialize on startup
+    db.init()
+    try:
+        yield AppContext(db=db)
+    finally:
+        # TODO: We need better way to handle this in storage/db.py
+        pass
+
+
+# Configure server with lifespan
+mcp = FastMCP(
+    "MindsDB",
+    lifespan=app_lifespan,
+    dependencies=["mindsdb"],  # Add any additional dependencies
+)
+
+
+# MCP Queries
+LISTING_QUERY = "SHOW DATABASES"
+
+
+query_tool_description = dedent("""\
+    Executes a SQL query against MindsDB.
+
+    A database must be specified either in the `context` parameter or directly in the query string (e.g., `SELECT * FROM my_database.my_table`). Queries like `SELECT * FROM my_table` will fail without a `context`.
+
+    Args:
+        query (str): The SQL query to execute.
+        context (dict, optional): The default database context. For example, `{"db": "my_postgres"}`.
+
+    Returns:
+        A dictionary describing the result.
+        - For a successful query with no data to return (e.g., an `UPDATE` statement), the response is `{"type": "ok"}`.
+        - If the query returns tabular data, the response is a dictionary containing `data` (a list of rows) and `column_names` (a list of column names). For example: `{"type": "table", "data": [[1, "a"], [2, "b"]], "column_names": ["column_a", "column_b"]}`.
+        - In case of an error, a response is `{"type": "error", "error_message": "the error message"}`.
+""")
+
+
+@mcp.tool(name="query", description=query_tool_description)
+def query(query: str, context: dict | None = None) -> dict[str, Any]:
+    """Execute a SQL query against MindsDB
+
+    Args:
+        query: The SQL query to execute
+        context: Optional context parameters for the query
+
+    Returns:
+        Dict containing the query results or error information
+    """
+
+    if context is None:
+        context = {}
+
+    logger.debug(f"Incoming MCP query: {query}")
+
+    mysql_proxy = FakeMysqlProxy()
+    mysql_proxy.set_context(context)
+
+    try:
+        result = mysql_proxy.process_query(query)
+
+        if result.type == SQL_RESPONSE_TYPE.OK:
+            return {"type": SQL_RESPONSE_TYPE.OK}
+
+        if result.type == SQL_RESPONSE_TYPE.TABLE:
+            return {
+                "type": SQL_RESPONSE_TYPE.TABLE,
+                "data": result.result_set.to_lists(json_types=True),
+                "column_names": [column.alias or column.name for column in result.result_set.columns],
+            }
+        else:
+            return {"type": SQL_RESPONSE_TYPE.ERROR, "error_code": 0, "error_message": "Unknown response type"}
+
+    except Exception as e:
+        logger.error(f"Error processing query: {str(e)}")
+        return {"type": SQL_RESPONSE_TYPE.ERROR, "error_code": 0, "error_message": str(e)}
+
+
+list_databases_tool_description = (
+    "Returns a list of all database connections currently available in MindsDB. "
+    + "The tool takes no parameters and responds with a list of database names, "
+    + 'for example: ["my_postgres", "my_mysql", "test_db"].'
+)
+
+
+@mcp.tool(name="list_databases", description=list_databases_tool_description)
+def list_databases() -> list[str]:
+    """
+    List all databases in MindsDB
+
+    Returns:
+       list[str]: list of databases
+    """
+
+    mysql_proxy = FakeMysqlProxy()
+
+    try:
+        result = mysql_proxy.process_query(LISTING_QUERY)
+        if result.type == SQL_RESPONSE_TYPE.ERROR:
+            return {
+                "type": "error",
+                "error_code": result.error_code,
+                "error_message": result.error_message,
+            }
+
+        elif result.type == SQL_RESPONSE_TYPE.OK:
+            return {"type": "ok"}
+
+        elif result.type == SQL_RESPONSE_TYPE.TABLE:
+            data = result.result_set.to_lists(json_types=True)
+            data = [val[0] for val in data]
+            return data
+
+    except Exception as e:
+        return {
+            "type": "error",
+            "error_code": 0,
+            "error_message": str(e),
+        }
+
+
+def _get_status(request: Request) -> JSONResponse:
+    """
+    Status endpoint that returns basic server information.
+    This endpoint can be used by the frontend to check if the MCP server is running.
+    """
+
+    status_info = {
+        "status": "ok",
+        "service": "mindsdb-mcp",
+    }
+
+    return JSONResponse(status_info)
+
+
+def get_mcp_app():
+    app = mcp.sse_app()
+    app.add_route("/status", _get_status, methods=["GET"])
+    return app