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

mindsdb/api/mcp/start.py

@@ -1,205 +0,0 @@
-import os
-from typing import Any
-from textwrap import dedent
-from contextlib import asynccontextmanager
-from collections.abc import AsyncIterator
-from dataclasses import dataclass
-
-import uvicorn
-import anyio
-from mcp.server.fastmcp import FastMCP
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request
-from starlette.responses import Response
-
-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.utilities import log
-from mindsdb.utilities.log import get_uvicorn_logging_config
-from mindsdb.utilities.config import Config
-from mindsdb.interfaces.storage import db
-
-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),
-        }
-
-
-class CustomAuthMiddleware(BaseHTTPMiddleware):
-    """Custom middleware to handle authentication basing on header 'Authorization'"""
-
-    async def dispatch(self, request: Request, call_next):
-        mcp_access_token = os.environ.get("MINDSDB_MCP_ACCESS_TOKEN")
-        if mcp_access_token is not None:
-            auth_token = request.headers.get("Authorization", "").partition("Bearer ")[-1]
-            if mcp_access_token != auth_token:
-                return Response(status_code=401, content="Unauthorized", media_type="text/plain")
-
-        response = await call_next(request)
-
-        return response
-
-
-async def run_sse_async() -> None:
-    """Run the server using SSE transport."""
-    starlette_app = mcp.sse_app()
-    starlette_app.add_middleware(CustomAuthMiddleware)
-
-    config = uvicorn.Config(
-        starlette_app,
-        host=mcp.settings.host,
-        port=mcp.settings.port,
-        log_level=mcp.settings.log_level.lower(),
-        log_config=get_uvicorn_logging_config("uvicorn_mcp"),
-    )
-    server = uvicorn.Server(config)
-    await server.serve()
-
-
-def start(*args, **kwargs):
-    """Start the MCP server
-    Args:
-        host (str): Host to bind to
-        port (int): Port to listen on
-    """
-    config = Config()
-    port = int(config["api"].get("mcp", {}).get("port", 47337))
-    host = config["api"].get("mcp", {}).get("host", "127.0.0.1")
-
-    logger.info(f"Starting MCP server on {host}:{port}")
-    mcp.settings.host = host
-    mcp.settings.port = port
-
-    try:
-        anyio.run(run_sse_async)
-    except Exception as e:
-        logger.error(f"Error starting MCP server: {str(e)}")
-        raise
-
-
-if __name__ == "__main__":
-    start()

mindsdb/api/mongo/classes/__init__.py

@@ -1,5 +0,0 @@
-from .responder_collection import RespondersCollection
-from .responder import Responder
-from .session import Session
-
-__all__ = ['RespondersCollection', 'Responder', 'Session']

mindsdb/api/mongo/classes/query_sql.py

@@ -1,19 +0,0 @@
-from mindsdb.api.executor.controllers import SessionController
-from mindsdb.api.executor.command_executor import ExecuteCommands
-from mindsdb.utilities.config import config
-
-
-def run_sql_command(request_env, ast_query):
-    sql_session = SessionController()
-    sql_session.database = request_env.get('database', config.get('default_project'))
-
-    command_executor = ExecuteCommands(sql_session)
-    ret = command_executor.execute_command(ast_query)
-    if ret.error_code is not None:
-        raise Exception(ret.error_message)
-
-    if ret.data is None:
-        # return no data
-        return []
-
-    return list(ret.data.get_records())

mindsdb/api/mongo/classes/responder.py

@@ -1,45 +0,0 @@
-class Responder():
-    def __init__(self, when=None, result=None):
-        if when is not None:
-            self.when = when
-        if result is not None:
-            self.result = result
-        if not hasattr(self, 'when') or (not isinstance(self.when, dict) and not callable(self.when)):
-            raise ValueError("Responder attr 'when' must be dict or function.")
-        if not hasattr(self, 'result') or (not isinstance(self.result, dict) and not callable(self.result)):
-            raise ValueError("Responder attr 'result' must be dict or function.")
-
-    def match(self, query):
-        """ check, if this 'responder' can be used to answer or current request
-
-        query (dict): request document
-
-        return bool
-        """
-        if isinstance(self.when, dict):
-            for key, value in self.when.items():
-                if key not in query:
-                    return False
-                if callable(value):
-                    if not value(query[key]):
-                        return False
-                elif value != query[key]:
-                    return False
-            return True
-        else:
-            return self.when(query)
-
-    def handle(self, query, args, env, session):
-        """ making answer based on params:
-
-        query (dict): document(s) from request
-        args (dict): all other significant information from request: flags, collection name, rows to return, etc
-        env (dict): config, model_controller instance, and other mindsdb related stuff
-        session (object): current session
-
-        returns documents as dict or list of dicts
-        """
-        if isinstance(self.result, dict):
-            return self.result
-        else:
-            return self.result(query, args, env, session)

mindsdb/api/mongo/classes/responder_collection.py

@@ -1,34 +0,0 @@
-from .responder import Responder
-from mindsdb.utilities import log
-
-logger = log.getLogger(__name__)
-
-
-class RespondersCollection():
-    def __init__(self):
-        self.responders = []
-
-    def find_match(self, query):
-        for r in self.responders:
-            if r.match(query):
-                return r
-
-        msg = f'Is not responder for query: {query}'
-
-        class ErrorResponder(Responder):
-            when = {}
-
-            result = {
-                "ok": 0.0,
-                "errmsg": msg,
-                "code": 59,
-                "codeName": "CommandNotFound"
-            }
-
-        logger.error(msg)
-        return ErrorResponder()
-
-    def add(self, when, result):
-        self.responders.append(
-            Responder(when, result)
-        )

mindsdb/api/mongo/classes/scram.py

@@ -1,86 +0,0 @@
-# https://stackoverflow.com/questions/29298346/xmpp-sasl-scram-sha1-authentication
-# https://tools.ietf.org/html/rfc5802
-# https://tools.ietf.org/html/rfc7677
-
-import base64
-import hashlib
-import hmac
-import os
-
-from pymongo.auth import _password_digest, _xor, saslprep
-
-
-class Scram():
-    ''' implementation of server-side SCRAM-SHA-1 and SCRAM-SHA-256 auth for mongodb
-    '''
-
-    def __init__(self, method='sha1', get_salted_password=None):
-        self.get_salted_password = get_salted_password
-        self.snonce = base64.b64encode(os.urandom(24)).decode()
-        self.iterations = 4096
-        self.messages = []
-
-        if method == 'sha1':
-            self.method_str = 'sha1'
-            self.method_func = hashlib.sha1
-            self.salt = base64.b64encode(os.urandom(16))
-        elif method == 'sha256':
-            self.method_str = 'sha256'
-            self.method_func = hashlib.sha256
-            self.salt = base64.b64encode(os.urandom(28))
-
-    def process_client_first_message(self, payload):
-        payload = payload[3:]
-        payload_parts = self._split_payload(payload)
-        self.client_user = payload_parts['n']
-
-        if self.get_salted_password is not None:
-            salt_bytes, self.salted_password = self.get_salted_password(self.client_user, self.method_str)
-            self.salt = base64.b64encode(salt_bytes)
-        else:
-            self.salted_password = self.salt_password()
-
-        self.unonce = payload_parts['r']
-        self.messages.append(payload)
-
-        responce_msg = f"r={self.unonce}{self.snonce},s={self.salt.decode()},i={self.iterations}"
-        self.messages.append(responce_msg)
-        return responce_msg
-
-    def process_client_second_message(self, payload):
-        self.messages.append(payload[:payload.rfind(',p=')])    # without 'p' part
-
-        messages = ','.join(self.messages)
-        server_key = self._hmac(self.salted_password, b'Server Key')
-        server_signature = self._hmac(server_key, messages.encode('utf-8'))
-
-        client_key = self._hmac(self.salted_password, b'Client Key')
-        stored_key = self.method_func(client_key).digest()
-        client_signature = self._hmac(stored_key, messages.encode('utf-8'))
-        expected_client_proof = base64.b64encode(_xor(client_key, client_signature)).decode()
-
-        income_client_proof = payload[payload.rfind(',p=') + 3:]
-
-        if expected_client_proof != income_client_proof:
-            raise Exception('wrong password')
-
-        return f'v={base64.b64encode(server_signature).decode()}'
-
-    def _hmac(self, key, msg):
-        return hmac.new(key, msg, digestmod=self.method_func).digest()
-
-    def salt_password(self, user, password):
-        if self.method_str == 'sha1':
-            password = _password_digest(user, password).encode("utf-8")
-        elif self.method_str == 'sha256':
-            password = saslprep(password).encode("utf-8")
-
-        return hashlib.pbkdf2_hmac(
-            self.method_str, password, base64.b64decode(self.salt), self.iterations
-        )
-
-    def _split_payload(self, payload):
-        parts = {}
-        for part in [x for x in payload.split(',') if len(x) > 0]:
-            parts[part[0]] = part[2:]
-        return parts

mindsdb/api/mongo/classes/session.py

@@ -1,23 +0,0 @@
-import base64
-
-from mindsdb.api.mongo.classes.scram import Scram
-
-
-class Session():
-    def __init__(self, server_mindsdb_env):
-        self.config = server_mindsdb_env['config']
-        self.mindsdb_env = {'company_id': None}
-        self.mindsdb_env.update(server_mindsdb_env)
-
-    def init_scram(self, method):
-        self.scram = Scram(method=method, get_salted_password=self.get_salted_password)
-
-    def get_salted_password(self, username, method=None):
-        real_user = self.config['auth'].get('username', '')
-        password = self.config['auth'].get('password', '')
-        if username != real_user:
-            raise Exception(f'Wrong username {username}')
-
-        salted_password = self.scram.salt_password(real_user, password)
-
-        return base64.b64decode(self.scram.salt), salted_password

mindsdb/api/mongo/functions/__init__.py

@@ -1,19 +0,0 @@
-import bson
-
-
-def is_true(val):
-    return bool(val) is True
-
-
-def is_false(val):
-    return bool(val) is False
-
-
-def int_to_objectid(n):
-    s = str(n)
-    s = '0' * (24 - len(s)) + s
-    return bson.ObjectId(s)
-
-
-def objectid_to_int(obj):
-    return int(str(obj))

mindsdb/api/mongo/responders/__init__.py

@@ -1,73 +0,0 @@
-from .whatsmyuri import responder as responder_whatsmyuri
-from .buildinfo import responder as responder_buildinfo
-from .is_master import responder as responder_is_master
-from .is_master_lower import responder as responder_is_master_lower
-from .replsetgetstatus import responder as responder_replsetgetstatus
-from .getlog import responder as responder_getlog
-from .add_shard import responder as responder_add_shard
-from .update_range_deletions import responder as responder_update_range_deletions
-from .recv_chunk_start import responder as responder_recv_chunk_start
-from .connection_status import responder as responder_connection_status
-from .get_cmd_line_opts import responder as responder_get_cmd_line_opts
-from .host_info import responder as responder_host_info
-from .db_stats import responder as responder_db_stats
-from .coll_stats import responder as responder_coll_stats
-from .count import responder as responder_count
-from .aggregate import responder as responder_aggregate
-from .get_free_monitoring_status import responder as responder_get_free_monitoring_status
-from .end_sessions import responder as responder_end_sessions
-from .ping import responder as responder_ping
-from .get_parameter import responder as responder_get_parameter
-
-from .list_indexes import responder as responder_list_indexes
-from .list_collections import responder as responder_list_collections
-from .list_databases import responder as responder_list_databases
-
-from .find import responder as responder_find
-from .insert import responder as responder_insert
-from .delete import responder as responder_delete
-from .describe import responder as responder_describe
-
-from .sasl_start import responder as sasl_start
-from .sasl_continue import responder as sasl_continue
-
-from .company_id import responder as responder_company_id
-
-
-responders = [
-    # service queries
-    responder_whatsmyuri,
-    responder_buildinfo,
-    responder_is_master,
-    responder_is_master_lower,
-    responder_replsetgetstatus,
-    responder_getlog,
-    responder_add_shard,                # 4.4
-    responder_update_range_deletions,   # 4.4
-    responder_recv_chunk_start,         # 4.4
-    responder_connection_status,
-    responder_get_cmd_line_opts,
-    responder_host_info,
-    responder_db_stats,
-    responder_coll_stats,
-    responder_count,
-    responder_aggregate,
-    responder_get_free_monitoring_status,
-    responder_end_sessions,
-    responder_ping,
-    responder_get_parameter,
-
-    # user queries
-    responder_list_indexes,
-    responder_list_collections,
-    responder_list_databases,
-    responder_find,
-    responder_insert,
-    responder_delete,
-    responder_describe,
-    # auth
-    sasl_start,
-    sasl_continue,
-    # cloud
-    responder_company_id
-]

mindsdb/api/mongo/responders/add_shard.py

@@ -1,13 +0,0 @@
-from mindsdb.api.mongo.classes import Responder
-import mindsdb.api.mongo.functions as helpers
-
-
-class Responce(Responder):
-    when = {'_addShard': helpers.is_true}
-
-    result = {
-        "ok": 1
-    }
-
-
-responder = Responce()

mindsdb/api/mongo/responders/aggregate.py

@@ -1,90 +0,0 @@
-from bson.int64 import Int64
-
-from mindsdb_sql_parser.ast import Identifier, Insert, CreateTable
-
-from mindsdb.api.mongo.classes import Responder
-import mindsdb.api.mongo.functions as helpers
-from mindsdb.api.mongo.responders.find import find_to_ast
-from mindsdb.api.mongo.classes.query_sql import run_sql_command
-from mindsdb.utilities.config import config
-
-
-def aggregate_to_ast(query, database):
-    collection = query['aggregate']
-
-    save_table = None
-    is_append = False
-    first_step = query['pipeline'][0]
-    if '$match' in first_step:
-        # convert to find
-        find_query = {
-            'find': collection,
-            'filter': first_step['$match'],
-        }
-        for step in query['pipeline'][1:]:
-            if '$project' in step:
-                find_query['projection'] = step['$project']
-            if '$sort' in step:
-                find_query['sort'] = step['$sort']
-            if '$skip' in step:
-                find_query['skip'] = step['$skip']
-            if '$limit' in step:
-                find_query['limit'] = step['$limit']
-
-            if '$out' in step:
-                target = step['$out']
-                if isinstance(target, str):
-                    save_table = Identifier(target)
-                else:
-                    save_table = Identifier(parts=[target['db'], target['coll']])
-                    if target.get('append'):
-                        is_append = True
-
-            # TODO implement group
-        ast_query = find_to_ast(find_query, database)
-        if save_table is not None:
-            if is_append:
-                ast_query = Insert(save_table, from_select=ast_query)
-            else:
-                ast_query = CreateTable(save_table, from_select=ast_query, is_replace=True)
-
-    else:
-        raise NotImplementedError
-
-    return ast_query
-
-
-class Responce(Responder):
-    when = {'aggregate': helpers.is_true}
-
-    def result(self, query, request_env, mindsdb_env, session):
-        db = query['$db']
-        collection = query['aggregate']
-
-        first_step = query['pipeline'][0]
-        if '$match' in first_step:
-            ast_query = aggregate_to_ast(query, request_env.get('database', config.get('default_project')))
-
-            data = run_sql_command(request_env, ast_query)
-
-        elif '$collStats' in first_step:
-            raise ValueError(
-                "To describe model use:"
-                " db.runCommand({describe: 'model_name.attribute'})"
-            )
-
-        else:
-            raise NotImplementedError
-
-        cursor = {
-            'id': Int64(0),
-            'ns': f"{db}.$cmd.{collection}",
-            'firstBatch': data
-        }
-        return {
-            'cursor': cursor,
-            'ok': 1
-        }
-
-
-responder = Responce()

mindsdb/api/mongo/responders/buildinfo.py

@@ -1,17 +0,0 @@
-from mindsdb.api.mongo.classes import Responder
-
-
-class Responce(Responder):
-    def when(self, query):
-        return (
-            'buildinfo' in query or 'buildInfo' in query
-        )
-
-    result = {
-        'version': '3.6.8',
-        'versionArray': [3, 6, 8, 0],
-        'ok': 1
-    }
-
-
-responder = Responce()