MindsDB 24.6.1.1__tar.gz → 24.6.2.2__tar.gz

{MindsDB-24.6.1.1 → MindsDB-24.6.2.2/MindsDB.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MindsDB
-Version: 24.6.1.1
+Version: 24.6.2.2
 Summary: MindsDB's AI SQL Server enables developers to build AI tools that need access to real-time data to perform their tasks
 Home-page: https://github.com/mindsdb/mindsdb
 Download-URL: https://pypi.org/project/mindsdb/

{MindsDB-24.6.1.1 → MindsDB-24.6.2.2}/MindsDB.egg-info/SOURCES.txt

@@ -926,14 +926,14 @@ mindsdb/integrations/handlers/milvus_handler/icon.svg
 mindsdb/integrations/handlers/milvus_handler/milvus_handler.py
 mindsdb/integrations/handlers/milvus_handler/requirements.txt
 mindsdb/integrations/handlers/milvus_handler/tests/__init__.py
-mindsdb/integrations/handlers/mindsdb_inference/__about__.py
-mindsdb/integrations/handlers/mindsdb_inference/__init__.py
-mindsdb/integrations/handlers/mindsdb_inference/icon.svg
-mindsdb/integrations/handlers/mindsdb_inference/mindsdb_inference_handler.py
-mindsdb/integrations/handlers/mindsdb_inference/requirements.txt
-mindsdb/integrations/handlers/mindsdb_inference/settings.py
-mindsdb/integrations/handlers/mindsdb_inference/tests/__init__.py
-mindsdb/integrations/handlers/mindsdb_inference/tests/test_mindsdb_inference_handler.py
+mindsdb/integrations/handlers/minds_endpoint/__about__.py
+mindsdb/integrations/handlers/minds_endpoint/__init__.py
+mindsdb/integrations/handlers/minds_endpoint/icon.svg
+mindsdb/integrations/handlers/minds_endpoint/minds_endpoint_handler.py
+mindsdb/integrations/handlers/minds_endpoint/requirements.txt
+mindsdb/integrations/handlers/minds_endpoint/settings.py
+mindsdb/integrations/handlers/minds_endpoint/tests/__init__.py
+mindsdb/integrations/handlers/minds_endpoint/tests/test_minds_endpoint_handler.py
 mindsdb/integrations/handlers/mlflow_handler/__about__.py
 mindsdb/integrations/handlers/mlflow_handler/__init__.py
 mindsdb/integrations/handlers/mlflow_handler/icon.svg
@@ -1593,6 +1593,7 @@ mindsdb/integrations/libs/ml_handler_process/__init__.py
 mindsdb/integrations/libs/ml_handler_process/create_engine_process.py
 mindsdb/integrations/libs/ml_handler_process/create_validation_process.py
 mindsdb/integrations/libs/ml_handler_process/describe_process.py
+mindsdb/integrations/libs/ml_handler_process/func_call_process.py
 mindsdb/integrations/libs/ml_handler_process/handlers_cacher.py
 mindsdb/integrations/libs/ml_handler_process/learn_process.py
 mindsdb/integrations/libs/ml_handler_process/predict_process.py

{MindsDB-24.6.1.1/MindsDB.egg-info → MindsDB-24.6.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MindsDB
-Version: 24.6.1.1
+Version: 24.6.2.2
 Summary: MindsDB's AI SQL Server enables developers to build AI tools that need access to real-time data to perform their tasks
 Home-page: https://github.com/mindsdb/mindsdb
 Download-URL: https://pypi.org/project/mindsdb/

{MindsDB-24.6.1.1 → MindsDB-24.6.2.2}/mindsdb/__about__.py

@@ -1,6 +1,6 @@
 __title__ = 'MindsDB'
 __package_name__ = 'mindsdb'
-__version__ = '24.6.1.1'
+__version__ = '24.6.2.2'
 __description__ = "MindsDB's AI SQL Server enables developers to build AI tools that need access to real-time data to perform their tasks"
 __email__ = "jorge@mindsdb.com"
 __author__ = 'MindsDB Inc'

{MindsDB-24.6.1.1 → MindsDB-24.6.2.2}/mindsdb/api/executor/controllers/session_controller.py

@@ -15,6 +15,8 @@ from mindsdb.interfaces.model.model_controller import ModelController
 from mindsdb.interfaces.database.database import DatabaseController
 from mindsdb.interfaces.database.integrations import integration_controller
 from mindsdb.interfaces.skills.skills_controller import SkillsController
+from mindsdb.interfaces.functions.controller import BYOMFunctionsController
+
 from mindsdb.utilities import log
 
 logger = log.getLogger(__name__)
@@ -41,6 +43,7 @@ class SessionController:
         self.integration_controller = integration_controller
         self.database_controller = DatabaseController()
         self.skills_controller = SkillsController()
+        self.function_controller = BYOMFunctionsController(self)
 
         # to prevent circular imports
         from mindsdb.interfaces.knowledge_base.controller import KnowledgeBaseController

{MindsDB-24.6.1.1 → MindsDB-24.6.2.2}/mindsdb/api/executor/datahub/datanodes/project_datanode.py

@@ -131,7 +131,7 @@ class ProjectDataNode(DataNode):
                     raise Exception(f"Cant execute view query: {view_meta['query_ast']}")
                 df = result['result']
 
-                df = query_df(df, query)
+                df = query_df(df, query, session=session)
 
                 columns_info = [
                     {

{MindsDB-24.6.1.1 → MindsDB-24.6.2.2}/mindsdb/api/executor/sql_query/steps/project_step.py

@@ -81,6 +81,6 @@ class ProjectStepCall(BaseStepCall):
                 targets.append(target)
         query.targets = targets
 
-        res = query_df(df, query)
+        res = query_df(df, query, session=self.session)
 
         return ResultSet().from_df_cols(res, col_names, strict=False)

{MindsDB-24.6.1.1 → MindsDB-24.6.2.2}/mindsdb/api/executor/sql_query/steps/subselect_step.py

@@ -51,7 +51,7 @@ class SubSelectStepCall(BaseStepCall):
                     result.add_column(Column(col_name))
 
         df = result.to_df()
-        res = query_df(df, query)
+        res = query_df(df, query, session=self.session)
 
         result2 = ResultSet()
         # get database from first column
@@ -124,7 +124,7 @@ class QueryStepCall(BaseStepCall):
         query.where = query_context_controller.remove_lasts(query.where)
 
         query.from_table = Identifier('df_table')
-        res = query_df(df, query)
+        res = query_df(df, query, session=self.session)
 
         data = ResultSet().from_df_cols(res, col_names, strict=False)
 

{MindsDB-24.6.1.1 → MindsDB-24.6.2.2}/mindsdb/api/executor/utilities/sql.py

@@ -52,7 +52,7 @@ def get_query_models(query: ASTNode, default_database: str = None) -> List[tuple
     return _get_query_tables(query, resolve_model_identifier, default_database)
 
 
-def query_df_with_type_infer_fallback(query_str: str, dataframes: dict):
+def query_df_with_type_infer_fallback(query_str: str, dataframes: dict, user_functions=None):
     ''' Duckdb need to infer column types if column.dtype == object. By default it take 1000 rows,
         but that may be not sufficient for some cases. This func try to run query multiple times
         increasing butch size for type infer
@@ -60,6 +60,7 @@ def query_df_with_type_infer_fallback(query_str: str, dataframes: dict):
         Args:
             query_str (str): query to execute
             dataframes (dict): dataframes
+            user_functions: functions controller which register new functions in connection
 
         Returns:
             pandas.DataFrame
@@ -70,6 +71,9 @@ def query_df_with_type_infer_fallback(query_str: str, dataframes: dict):
         locals()[name] = value
 
     con = duckdb.connect(database=':memory:')
+    if user_functions:
+        user_functions.register(con)
+
     for sample_size in [1000, 10000, 1000000]:
         try:
             con.execute(f'set global pandas_analyze_sample={sample_size};')
@@ -113,6 +117,11 @@ def query_df(df, query, session=None):
 
     json_columns = set()
 
+    if session is not None:
+        user_functions = session.function_controller.create_function_set()
+    else:
+        user_functions = None
+
     def adapt_query(node, is_table, **kwargs):
         if is_table:
             return
@@ -128,13 +137,16 @@ def query_df(df, query, session=None):
                 else:
                     cur_db = None
                 return Constant(cur_db)
-            if fnc_name == 'truncate':
+            elif fnc_name == 'truncate':
                 # replace mysql 'truncate' function to duckdb 'round'
                 node.op = 'round'
                 if len(node.args) == 1:
                     node.args.append(0)
-            if fnc_name == 'json_extract':
+            elif fnc_name == 'json_extract':
                 json_columns.add(node.args[0].parts[-1])
+            else:
+                if user_functions is not None:
+                    user_functions.check_function(node)
 
     query_traversal(query_ast, adapt_query)
 
@@ -169,7 +181,7 @@ def query_df(df, query, session=None):
             if 'CONNECTION_DATA' in df.columns:
                 df = df.astype({'CONNECTION_DATA': 'string'})
 
-    result_df, description = query_df_with_type_infer_fallback(query_str, {'df': df})
+    result_df, description = query_df_with_type_infer_fallback(query_str, {'df': df}, user_functions=user_functions)
     result_df = result_df.replace({np.nan: None})
 
     new_column_names = {}

{MindsDB-24.6.1.1 → MindsDB-24.6.2.2}/mindsdb/api/http/namespaces/agents.py

@@ -118,7 +118,7 @@ class AgentResource(Resource):
     @ns_conf.doc('get_agent')
     @api_endpoint_metrics('GET', '/agents/agent')
     def get(self, project_name, agent_name):
-        '''Gets a agent by name'''
+        '''Gets an agent by name'''
         session = SessionController()
         try:
             existing_agent = session.agents_controller.get_agent(agent_name, project_name=project_name)
@@ -140,7 +140,7 @@ class AgentResource(Resource):
     @ns_conf.doc('update_agent')
     @api_endpoint_metrics('PUT', '/agents/agent')
     def put(self, project_name, agent_name):
-        '''Updates a agent by name, creating one if it doesn't exist'''
+        '''Updates an agent by name, creating one if it doesn't exist'''
 
         # Check for required parameters.
         if 'agent' not in request.json:
@@ -272,6 +272,9 @@ class AgentCompletions(Resource):
                 f'Project with name {project_name} does not exist'
             )
 
+        # Add OpenAI API key to agent params if not already present.
+        existing_agent.params['openai_api_key'] = existing_agent.params.get('openai_api_key', os.getenv('OPENAI_API_KEY'))
+
         # Model needs to exist.
         model_name_no_version, version = db.Predictor.get_name_and_version(existing_agent.model_name)
         try:
@@ -286,7 +289,9 @@ class AgentCompletions(Resource):
 
         trace_id = None
         observation_id = None
+        api_trace = None
         run_completion_span = None
+        messages = request.json['messages']
         # Trace Agent completions using Langfuse if configured.
         if os.getenv('LANGFUSE_PUBLIC_KEY') is not None:
             langfuse = Langfuse(
@@ -294,14 +299,18 @@ class AgentCompletions(Resource):
                 secret_key=os.getenv('LANGFUSE_SECRET_KEY'),
                 host=os.getenv('LANGFUSE_HOST')
             )
-            api_trace = langfuse.trace(name='api-completion')
-            run_completion_span = api_trace.span(name='run-completion')
+            api_trace = langfuse.trace(
+                name='api-completion',
+                input=messages,
+                tags=[os.getenv('FLASK_ENV', 'unknown')]
+            )
+            run_completion_span = api_trace.span(name='run-completion', input=messages)
             trace_id = api_trace.id
             observation_id = run_completion_span.id
 
         completion = session.agents_controller.get_completion(
             existing_agent,
-            request.json['messages'],
+            messages,
             trace_id=trace_id,
             observation_id=observation_id,
             project_name=project_name,
@@ -310,11 +319,11 @@ class AgentCompletions(Resource):
             tools=[]
         )
 
-        if run_completion_span is not None:
-            run_completion_span.end()
-
         output_col = agent_model_record.to_predict[0]
         model_output = completion.iloc[-1][output_col]
+        if run_completion_span is not None and api_trace is not None:
+            run_completion_span.end(output=model_output)
+            api_trace.update(output=model_output)
         return {
             'message': {
                 'content': model_output,

{MindsDB-24.6.1.1 → MindsDB-24.6.2.2}/mindsdb/integrations/handlers/byom_handler/byom_handler.py

@@ -37,7 +37,7 @@ import mindsdb.utilities.profiler as profiler
 
 from .proc_wrapper import (
     pd_decode, pd_encode, encode, decode, BYOM_METHOD,
-    import_string, find_model_class
+    import_string, find_model_class, get_methods_info
 )
 from .__about__ import __version__
 
@@ -281,7 +281,9 @@ class BYOMHandler(BaseMLEngine):
 
         model_proxy = self._get_model_proxy()
         try:
-            model_proxy.check()
+            methods = model_proxy.check()
+            self.engine_storage.json_set('methods', methods)
+
         except Exception as e:
             model_proxy.remove_venv()
             raise e
@@ -332,11 +334,20 @@ class BYOMHandler(BaseMLEngine):
 
         model_proxy = self._get_model_proxy(new_version)
         try:
-            model_proxy.check()
+            methods = model_proxy.check()
+            self.engine_storage.json_set('methods', methods)
+
         except Exception as e:
             model_proxy.remove_venv()
             raise e
 
+    def function_list(self):
+        return self.engine_storage.json_get('methods')
+
+    def function_call(self, name, args):
+        mp = self._get_model_proxy()
+        return mp.func_call(name, args)
+
     def finetune(self, df: Optional[pd.DataFrame] = None, args: Optional[Dict] = None) -> None:
         using_args = args.get('using', {})
         engine_version = using_args.get('engine_version')
@@ -432,8 +443,14 @@ class ModelWrapperUnsafe:
             return self.model_instance.describe(attribute)
         return pd.DataFrame()
 
+    def func_call(self, func_name, args):
+
+        func = getattr(self.model_instance, func_name)
+        return func(*args)
+
     def check(self):
-        pass
+        methods = get_methods_info(self.model_instance)
+        return methods
 
 
 class ModelWrapperSafe:
@@ -639,3 +656,13 @@ class ModelWrapperSafe:
         enc_df = self._run_command(params)
         df = pd_decode(enc_df)
         return df
+
+    def func_call(self, func_name, args):
+        params = {
+            'method': BYOM_METHOD.FUNC_CALL.value,
+            'code': self.code,
+            'func_name': func_name,
+            'args': args,
+        }
+        result = self._run_command(params)
+        return result

{MindsDB-24.6.1.1 → MindsDB-24.6.2.2}/mindsdb/integrations/handlers/byom_handler/proc_wrapper.py

@@ -33,6 +33,7 @@ class BYOM_METHOD(Enum):
     PREDICT = 3
     FINETUNE = 4
     DESCRIBE = 5
+    FUNC_CALL = 6
 
 
 def pd_encode(df):
@@ -90,6 +91,27 @@ def find_model_class(module):
         ]
         if 'predict' in funcs and 'train' in funcs:
             return klass
+    raise RuntimeError('Unable to find model class (has to have `train` and `predict` methods)')
+
+
+def get_methods_info(model):
+    # get all methods and their types
+    methods = {}
+    for method_name in dir(model):
+        if method_name.startswith('__'):
+            continue
+
+        method = getattr(model, method_name)
+        sig = inspect.signature(method)
+        input_params = [
+            {'name': name, 'type': param.annotation.__name__}
+            for name, param in sig.parameters.items()
+        ]
+        methods[method_name] = {
+            'input_params': input_params,
+            'output_type': sig.return_annotation.__name__
+        }
+    return methods
 
 
 def main():
@@ -108,13 +130,15 @@ def main():
     if method == BYOM_METHOD.CHECK:
         model = model_class()
 
-        if not hasattr(model, 'train'):
+        methods = get_methods_info(model)
+
+        if 'train' not in methods:
             raise RuntimeError('Model class has to have "train" method')
 
-        if not hasattr(model, 'predict'):
+        if 'predict' not in methods:
             raise RuntimeError('Model class has to have "predict" method')
 
-        return_output(True)
+        return_output(methods)
 
     if method == BYOM_METHOD.TRAIN:
         df = pd_decode(params['df'])
@@ -176,6 +200,14 @@ def main():
             return_output(pd_encode(pd.DataFrame()))
         return_output(pd_encode(df))
 
+    elif method == BYOM_METHOD.FUNC_CALL:
+        model = model_class()
+        func_name = params['func_name']
+        args = params['args']
+
+        func = getattr(model, func_name)
+        return return_output(func(*args))
+
     raise NotImplementedError(method)
 
 

{MindsDB-24.6.1.1/mindsdb/integrations/handlers/mindsdb_inference → MindsDB-24.6.2.2/mindsdb/integrations/handlers/minds_endpoint}/__about__.py

@@ -1,7 +1,7 @@
-__title__ = 'MindsDB Inference handler'
-__package_name__ = 'mindsdb_inference_handler'
+__title__ = 'Minds Endpoint handler'
+__package_name__ = 'minds_endpoint_handler'
 __version__ = '0.0.1'
-__description__ = "MindsDB handler for the MindsDB Inference Endpoints"
+__description__ = "MindsDB handler for the Minds Endpoint"
 __author__ = 'MindsDB Inc'
 __github__ = 'https://github.com/mindsdb/mindsdb'
 __pypi__ = 'https://pypi.org/project/mindsdb/'

{MindsDB-24.6.1.1/mindsdb/integrations/handlers/mindsdb_inference → MindsDB-24.6.2.2/mindsdb/integrations/handlers/minds_endpoint}/__init__.py

@@ -7,15 +7,15 @@ from .__about__ import __description__ as description
 from .__about__ import __version__ as version
 
 try:
-    from .mindsdb_inference_handler import MindsDBInferenceHandler as Handler
+    from .minds_endpoint_handler import MindsEndpointHandler as Handler
 
     import_error = None
 except Exception as e:
     Handler = None
     import_error = e
 
-title = "MindsDB Inference"
-name = "mindsdb_inference"
+title = "Minds Endpoint"
+name = "minds_endpoint"
 type = HANDLER_TYPE.ML
 icon_path = 'icon.svg'
 permanent = False

MindsDB-24.6.1.1/mindsdb/integrations/handlers/mindsdb_inference/mindsdb_inference_handler.py → MindsDB-24.6.2.2/mindsdb/integrations/handlers/minds_endpoint/minds_endpoint_handler.py

@@ -5,32 +5,32 @@ from openai import OpenAI, NotFoundError, AuthenticationError
 from typing import Dict, Optional
 from mindsdb.integrations.handlers.openai_handler import Handler as OpenAIHandler
 from mindsdb.integrations.utilities.handler_utils import get_api_key
-from mindsdb.integrations.handlers.mindsdb_inference.settings import mindsdb_inference_handler_config
+from mindsdb.integrations.handlers.minds_endpoint.settings import minds_endpoint_handler_config
 from mindsdb.utilities import log
 
 logger = log.getLogger(__name__)
 
 
-class MindsDBInferenceHandler(OpenAIHandler):
+class MindsEndpointHandler(OpenAIHandler):
     """
-    This handler handles connection and inference with the MindsDB Inference Endpoints.
+    This handler handles connection to the Minds Endpoint.
     """
 
-    name = 'mindsdb_inference'
+    name = 'minds_endpoint'
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.api_base = mindsdb_inference_handler_config.BASE_URL
+        self.api_base = minds_endpoint_handler_config.BASE_URL
         self.default_model = 'gpt-3.5-turbo'
         self.default_mode = 'default'
 
     @staticmethod
     def _check_client_connection(client: OpenAI):
         """
-        Check the MindsDB Inference engine client connection by listing models.
+        Check the Minds Endpoint engine client connection by listing models.
 
         Args:
-            client (OpenAI): OpenAI client configured with the MindsDB Inference API credentials.
+            client (OpenAI): OpenAI client configured with the Minds Endpoint API credentials.
 
         Raises:
             Exception: If the client connection (API key) is invalid.
@@ -49,7 +49,7 @@ class MindsDBInferenceHandler(OpenAIHandler):
 
     def create_engine(self, connection_args):
         """
-        Validate the MindsDB Inference API credentials on engine creation.
+        Validate the Minds Endpoint API credentials on engine creation.
 
         Args:
             connection_args (dict): Connection arguments.
@@ -61,17 +61,17 @@ class MindsDBInferenceHandler(OpenAIHandler):
             None
         """
         connection_args = {k.lower(): v for k, v in connection_args.items()}
-        api_key = connection_args.get('mindsdb_inference_api_key')
+        api_key = connection_args.get('minds_endpoint_api_key')
         if api_key is not None:
             org = connection_args.get('api_organization')
-            api_base = connection_args.get('api_base') or os.environ.get('MINDSDB_INFERENCE_BASE', mindsdb_inference_handler_config.BASE_URL)
+            api_base = connection_args.get('api_base') or os.environ.get('minds_endpoint_BASE', minds_endpoint_handler_config.BASE_URL)
             client = self._get_client(api_key=api_key, base_url=api_base, org=org)
-            MindsDBInferenceHandler._check_client_connection(client)
+            MindsEndpointHandler._check_client_connection(client)
 
     @staticmethod
     def create_validation(target, args=None, **kwargs):
         """
-        Validate the MindsDB Inference API credentials on model creation.
+        Validate the Minds Endpoint API credentials on model creation.
 
         Args:
             target (str): Target column, not required for LLMs.
@@ -86,22 +86,22 @@ class MindsDBInferenceHandler(OpenAIHandler):
         """
         if 'using' not in args:
             raise Exception(
-                "MindsDB Inference engine requires a USING clause! Refer to its documentation for more details."
+                "Minds Endpoint engine requires a USING clause! Refer to its documentation for more details."
             )
         else:
             args = args['using']
 
         engine_storage = kwargs['handler_storage']
         connection_args = engine_storage.get_connection_args()
-        api_key = get_api_key('mindsdb_inference', args, engine_storage=engine_storage)
-        api_base = connection_args.get('api_base') or args.get('api_base') or os.environ.get('MINDSDB_INFERENCE_BASE', mindsdb_inference_handler_config.BASE_URL)
+        api_key = get_api_key('minds_endpoint', args, engine_storage=engine_storage)
+        api_base = connection_args.get('api_base') or args.get('api_base') or os.environ.get('minds_endpoint_BASE', minds_endpoint_handler_config.BASE_URL)
         org = args.get('api_organization')
         client = OpenAIHandler._get_client(api_key=api_key, base_url=api_base, org=org)
-        MindsDBInferenceHandler._check_client_connection(client)
+        MindsEndpointHandler._check_client_connection(client)
 
     def predict(self, df: pd.DataFrame, args: Optional[Dict] = None) -> pd.DataFrame:
         """
-        Call the MindsDB Inference engine to predict the next token.
+        Call the Minds Endpoint engine to predict the next token.
 
         Args:
             df (pd.DataFrame): Input data.
@@ -110,7 +110,7 @@ class MindsDBInferenceHandler(OpenAIHandler):
         Returns:
             pd.DataFrame: Predicted data
         """
-        api_key = get_api_key('mindsdb_inference', args, self.engine_storage)
+        api_key = get_api_key('minds_endpoint', args, self.engine_storage)
         supported_models = self._get_supported_models(api_key, self.api_base)
         self.chat_completion_models = [model.id for model in supported_models]
         return super().predict(df, args)
@@ -118,7 +118,7 @@ class MindsDBInferenceHandler(OpenAIHandler):
     @staticmethod
     def _get_supported_models(api_key, base_url, org=None):
         """
-        Get the list of supported models for the MindsDB Inference engine.
+        Get the list of supported models for the Minds Endpoint engine.
 
         Args:
             api_key (str): API key.

MindsDB-24.6.2.2/mindsdb/integrations/handlers/minds_endpoint/settings.py

@@ -0,0 +1,18 @@
+from pydantic_settings import BaseSettings
+
+
+class MindsEndpointHandlerConfig(BaseSettings):
+    """
+    Configuration for Minds Endpoint handler.
+
+    Attributes
+    ----------
+
+    BASE_URL : str
+        Base URL for the Minds Endpoint API.
+    """
+
+    BASE_URL: str = "https://llm.mdb.ai/"
+
+
+minds_endpoint_handler_config = MindsEndpointHandlerConfig()