MindsDB 25.8.2.0__py3-none-any.whl → 25.9.1.0__py3-none-any.whl

mindsdb/api/http/namespaces/default.py

@@ -1,6 +1,4 @@
-import time
-
-from flask import request, session
+from flask import request
 from flask_restx import Resource
 from flask_restx import fields
 
@@ -10,143 +8,113 @@ from mindsdb.api.http.utils import http_error
 from mindsdb.metrics.metrics import api_endpoint_metrics
 from mindsdb.utilities.config import Config
 from mindsdb.utilities import log
+from mindsdb.api.common.middleware import generate_pat, revoke_pat, verify_pat
 
 
 logger = log.getLogger(__name__)
 
 
-def check_auth() -> bool:
-    ''' checking whether current user is authenticated
-
-        Returns:
-            bool: True if user authentication is approved
-    '''
-    config = Config()
-    if config['auth']['http_auth_enabled'] is False:
-        return True
-
-    if config['auth'].get('provider') == 'cloud':
-        if isinstance(session.get('username'), str) is False:
-            return False
-
-        if config['auth']['oauth']['tokens']['expires_at'] < time.time():
-            return False
-
-        return True
-
-    return session.get('username') == config['auth']['username']
-
-
-@ns_conf.route('/login', methods=['POST'])
+@ns_conf.route("/login", methods=["POST"])
 class LoginRoute(Resource):
     @ns_conf.doc(
-        responses={
-            200: 'Success',
-            400: 'Error in username or password',
-            401: 'Invalid username or password'
-        },
-        body=ns_conf.model('request_login', {
-            'username': fields.String(description='Username'),
-            'password': fields.String(description='Password')
-        })
+        responses={200: "Success", 400: "Error in username or password", 401: "Invalid username or password"},
+        body=ns_conf.model(
+            "request_login",
+            {"username": fields.String(description="Username"), "password": fields.String(description="Password")},
+        ),
     )
-    @api_endpoint_metrics('POST', '/default/login')
+    @api_endpoint_metrics("POST", "/default/login")
     def post(self):
-        ''' Check user's credentials and creates a session
-        '''
-        username = request.json.get('username')
-        password = request.json.get('password')
+        """Check user's credentials and creates a session"""
+        username = request.json.get("username")
+        password = request.json.get("password")
         if (
-            isinstance(username, str) is False or len(username) == 0
-            or isinstance(password, str) is False or len(password) == 0
+            isinstance(username, str) is False
+            or len(username) == 0
+            or isinstance(password, str) is False
+            or len(password) == 0
         ):
-            return http_error(
-                400, 'Error in username or password',
-                'Username and password should be string'
-            )
+            return http_error(400, "Error in username or password", "Username and password should be string")
 
         config = Config()
-        inline_username = config['auth']['username']
-        inline_password = config['auth']['password']
+        inline_username = config["auth"]["username"]
+        inline_password = config["auth"]["password"]
 
-        if (
-            username != inline_username
-            or password != inline_password
-        ):
-            return http_error(
-                401, 'Forbidden',
-                'Invalid username or password'
-            )
+        if username != inline_username or password != inline_password:
+            return http_error(401, "Forbidden", "Invalid username or password")
 
-        session.clear()
-        session['username'] = username
-        session.permanent = True
+        logger.info(f"User '{username}' logged in successfully")
 
-        return '', 200
+        return {"token": generate_pat()}, 200
 
 
-@ns_conf.route('/logout', methods=['POST'])
+@ns_conf.route("/logout", methods=["POST"])
 class LogoutRoute(Resource):
-    @ns_conf.doc(
-        responses={
-            200: 'Success'
-        }
-    )
-    @api_endpoint_metrics('POST', '/default/logout')
+    @ns_conf.doc(responses={200: "Success"})
+    @api_endpoint_metrics("POST", "/default/logout")
     def post(self):
-        session.clear()
-        return '', 200
+        # We can't forcibly log out a user with the
+        h = request.headers.get("Authorization")
+        if not h or not h.startswith("Bearer "):
+            bearer = None
+        else:
+            bearer = h.split(" ", 1)[1].strip() or None
+        revoke_pat(bearer)
+        return "", 200
 
 
-@ns_conf.route('/status')
+@ns_conf.route("/status")
 class StatusRoute(Resource):
     @ns_conf.doc(
-        responses={
-            200: 'Success'
-        },
-        model=ns_conf.model('response_status', {
-            'environment': fields.String(description='The name of current environment: cloud, local or other'),
-            'mindsdb_version': fields.String(description='Current version of mindsdb'),
-            'auth': fields.Nested(
-                ns_conf.model('response_status_auth', {
-                    'confirmed': fields.Boolean(description='is current user authenticated'),
-                    'required': fields.Boolean(description='is authenticated required'),
-                    'provider': fields.Boolean(description='current authenticated provider: local of 3d-party')
-                })
-            )
-        })
+        responses={200: "Success"},
+        model=ns_conf.model(
+            "response_status",
+            {
+                "environment": fields.String(description="The name of current environment: cloud, local or other"),
+                "mindsdb_version": fields.String(description="Current version of mindsdb"),
+                "auth": fields.Nested(
+                    ns_conf.model(
+                        "response_status_auth",
+                        {
+                            "confirmed": fields.Boolean(description="is current user authenticated"),
+                            "required": fields.Boolean(description="is authenticated required"),
+                            "provider": fields.Boolean(description="current authenticated provider: local of 3d-party"),
+                        },
+                    )
+                ),
+            },
+        ),
     )
-    @api_endpoint_metrics('GET', '/default/status')
+    @api_endpoint_metrics("GET", "/default/status")
     def get(self):
-        ''' returns auth and environment data
-        '''
-        environment = 'local'
+        """returns auth and environment data"""
+        environment = "local"
         config = Config()
 
-        environment = config.get('environment')
+        environment = config.get("environment")
         if environment is None:
-            if config.get('cloud', False):
-                environment = 'cloud'
-            elif config.get('aws_marketplace', False):
-                environment = 'aws_marketplace'
+            if config.get("cloud", False):
+                environment = "cloud"
+            elif config.get("aws_marketplace", False):
+                environment = "aws_marketplace"
             else:
-                environment = 'local'
+                environment = "local"
 
-        auth_provider = 'disabled'
-        if config['auth']['http_auth_enabled'] is True:
-            if config['auth'].get('provider') is not None:
-                auth_provider = config['auth'].get('provider')
+        auth_provider = "disabled"
+        if config["auth"]["http_auth_enabled"] is True:
+            if config["auth"].get("provider") is not None:
+                auth_provider = config["auth"].get("provider")
             else:
-                auth_provider = 'local'
+                auth_provider = "local"
 
         resp = {
-            'mindsdb_version': mindsdb_version,
-            'environment': environment,
-            'auth': {
-                'confirmed': check_auth(),
-                'http_auth_enabled': config['auth']['http_auth_enabled'],
-                'provider': auth_provider
-            }
+            "mindsdb_version": mindsdb_version,
+            "environment": environment,
+            "auth": {
+                "confirmed": verify_pat(request.headers.get("Authorization", "").replace("Bearer ", "")),
+                "http_auth_enabled": config["auth"]["http_auth_enabled"],
+                "provider": auth_provider,
+            },
         }
 
         return resp

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,6 +10,16 @@ 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()
 
@@ -23,50 +33,21 @@ def start(verbose, no_studio, app: Flask = None):
     if app is None:
         app = initialize_app(config, no_studio)
 
-    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()
+    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))
 
-        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)
+    # Root app LAST so it won't shadow the others
+    routes.append(Mount("/", app=WSGIMiddleware(app)))
 
-        options = {
-            'bind': f'{host}:{port}',
-            'post_fork': post_fork,
-            'worker_exit': before_worker_exit,
-            **server_config
-        }
-        StandaloneApplication(app, options).run()
+    # 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