MindsDB 1.2.9__py3-none-any.whl → 24.12.4.0__py3-none-any.whl

mindsdb/integrations/handlers/litellm_handler/litellm_handler.py

@@ -0,0 +1,141 @@
+import ast
+from typing import Dict, Optional, List
+
+import pandas as pd
+
+from mindsdb.integrations.libs.base import BaseMLEngine
+from mindsdb.utilities import log
+
+from mindsdb.integrations.handlers.litellm_handler.settings import CompletionParameters
+
+from litellm import completion, batch_completion
+
+
+logger = log.getLogger(__name__)
+
+
+class LiteLLMHandler(BaseMLEngine):
+    """
+    LiteLLMHandler is a MindsDB handler for litellm - https://docs.litellm.ai/docs/
+    """
+
+    name = "litellm"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.generative = True
+
+    @staticmethod
+    def create_validation(target, args=None, **kwargs):
+        if "using" not in args:
+            raise Exception(
+                "Litellm engine requires a USING clause. See settings.py for more info on supported args."
+            )
+
+    def create(
+        self,
+        target: str,
+        df: pd.DataFrame = None,
+        args: Optional[Dict] = None,
+    ):
+        """
+        Dispatch is validating args and storing args in model_storage
+        """
+        # get api key from user input on create ML_ENGINE or create MODEL
+        input_args = args["using"]
+
+        # get api key from engine_storage
+        ml_engine_args = self.engine_storage.get_connection_args()
+
+        # check engine_storage for api_key
+        input_args.update({k: v for k, v in ml_engine_args.items()})
+
+        # validate args
+        export_args = CompletionParameters(**input_args).model_dump()
+
+        # store args
+        self.model_storage.json_set("args", export_args)
+
+    def predict(self, df: pd.DataFrame = None, args: dict = None):
+        """
+        Dispatch is getting args from model_storage, validating args and running completion
+        """
+
+        input_args = self.model_storage.json_get("args")
+
+        # validate args
+        args = CompletionParameters(**input_args).model_dump()
+
+        # build messages
+        self._build_messages(args, df)
+
+        # remove prompt_template from args
+        args.pop('prompt_template', None)
+
+        if len(args['messages']) > 1:
+            # if more than one message, use batch completion
+            responses = batch_completion(**args)
+            return pd.DataFrame({"result": [response.choices[0].message.content for response in responses]})
+
+        # run completion
+        response = completion(**args)
+
+        return pd.DataFrame({"result": [response.choices[0].message.content]})
+
+    @staticmethod
+    def _prompt_to_messages(prompt: str, **kwargs) -> List[Dict]:
+        """
+        Convert a prompt to a list of messages
+        """
+
+        if kwargs:
+            # if kwargs are passed in, format the prompt with kwargs
+            prompt = prompt.format(**kwargs)
+
+        return [{"content": prompt, "role": "user"}]
+
+    def _build_messages(self, args: dict, df: pd.DataFrame):
+        """
+        Build messages for completion
+        """
+
+        prompt_kwargs = df.iloc[0].to_dict()
+
+        if "prompt_template" in prompt_kwargs:
+            # if prompt_template is passed in predict query, use it
+            logger.info("Using 'prompt_template' passed in SELECT Predict query. "
+                        "Note this will overwrite a 'prompt_template' passed in create MODEL query.")
+
+            args['prompt_template'] = prompt_kwargs.pop('prompt_template')
+
+        if 'mock_response' in prompt_kwargs:
+            # used for testing to save on real completion api calls
+            args['mock_response']: str = prompt_kwargs.pop('mock_response')
+
+        if 'messages' in prompt_kwargs and len(prompt_kwargs) > 1:
+            # if user passes in messages, no other args can be passed in
+            raise Exception(
+                "If 'messages' is passed in SELECT Predict query, no other args can be passed in."
+            )
+
+        # if user passes in messages, use those instead
+        if 'messages' in prompt_kwargs:
+            logger.info("Using messages passed in SELECT Predict query. 'prompt_template' will be ignored.")
+
+            args['messages']: List = ast.literal_eval(df['messages'].iloc[0])
+
+        else:
+            # if user passes in prompt_template, use that to create messages
+            if len(prompt_kwargs) == 1:
+                args['messages'] = self._prompt_to_messages(args['prompt_template'], **prompt_kwargs) \
+                    if args['prompt_template'] else self._prompt_to_messages(df.iloc[0][0])
+
+            elif len(prompt_kwargs) > 1:
+                try:
+                    args['messages'] = self._prompt_to_messages(args['prompt_template'], **prompt_kwargs)
+                except KeyError as e:
+                    raise Exception(
+                        f"{e}: Please pass in either a prompt_template on create MODEL or "
+                        f"a single where clause in predict query."
+                        f""
+                    )

mindsdb/integrations/handlers/litellm_handler/requirements.txt

@@ -0,0 +1,2 @@
+litellm==1.44.8
+

mindsdb/integrations/handlers/litellm_handler/settings.py

@@ -0,0 +1,39 @@
+from typing import List, Optional, Union, Dict
+from pydantic import BaseModel, Extra
+
+
+class CompletionParameters(BaseModel):
+    model: str  # The model to be used for the API call.
+    prompt_template: Optional[str] = None  # Template for the prompt to be used.
+
+    # Optional OpenAI params: see  https://platform.openai.com/docs/api-reference/chat/runs
+    tool_choice: Optional[str] = None  # Specific tool to be used, if applicable.
+
+    timeout: Optional[Union[float, int]] = None  # Timeout for the API request.
+    temperature: Optional[float] = None  # Controls randomness: higher value means more random responses.
+    top_p: Optional[float] = None  # Nucleus sampling: higher value means more diverse responses.
+    n: Optional[int] = None  # Number of completions to generate for each prompt.
+    stream: Optional[bool] = None  # Whether to stream responses or not.
+    stop: Optional[str] = None  # Sequence at which the model should stop generating further tokens.
+    max_tokens: Optional[float] = None  # Maximum number of tokens to generate in each completion.
+    presence_penalty: Optional[float] = None  # Penalty for new tokens based on their existing presence in the text.
+    frequency_penalty: Optional[float] = None  # Penalty for new tokens based on their frequency in the text.
+    logit_bias: Optional[Dict] = None  # Adjusts the likelihood of specified tokens appearing in the completion.
+    user: Optional[str] = None  # Identifier for the end-user, for usage tracking.
+
+    # openai v1.0+ new params
+    response_format: Optional[Dict] = None  # Format of the response, if specific formatting is required.
+    seed: Optional[int] = None  # Random seed for deterministic completions.
+    tools: Optional[List[str]] = None  # List of additional tools or features to be used.
+    tool_choice: Optional[str] = None  # Specific tool to be used, if applicable.
+    deployment_id: Optional[str] = None  # Identifier for the deployment.
+
+    # set api_base, api_version, api_key
+    base_url: Optional[str] = None  # Base URL of the API.
+    api_version: Optional[str] = None  # Version of the API to be used.
+    api_key: str  # API key for authentication.
+
+    class Config:
+        extra = Extra.forbid
+        arbitrary_types_allowed = True
+        use_enum_values = True

mindsdb/integrations/handlers/llama_index_handler/__about__.py

@@ -0,0 +1,9 @@
+__title__ = "MindsDB LlamaIndex  handler"
+__package_name__ = "mindsdb_llama_index_handler"
+__version__ = "0.0.1"
+__description__ = "MindsDB handler for LlamaIndex"
+__author__ = "Balaji Seetharaman "
+__github__ = "https://github.com/mindsdb/mindsdb"
+__pypi__ = "https://pypi.org/project/mindsdb/"
+__license__ = "MIT"
+__copyright__ = "Copyright 2023 - mindsdb"

mindsdb/integrations/handlers/llama_index_handler/__init__.py

@@ -0,0 +1,19 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+
+from .__about__ import __version__ as version, __description__ as description
+
+try:
+    from .llama_index_handler import LlamaIndexHandler as Handler
+
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = "LlamaIndex"
+name = "llama_index"
+type = HANDLER_TYPE.ML
+icon_path = 'icon.svg'
+permanent = False
+
+__all__ = ["Handler", "version", "name", "type", "title", "description", "import_error", "icon_path"]

mindsdb/integrations/handlers/llama_index_handler/icon.svg

@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="40" height="40" viewBox="0 0 40 40" fill="none">
+  <path d="M0 0H40V39.5876H0V0Z" fill="url(#pattern0)"/>
+  <defs>
+    <pattern id="pattern0" patternContentUnits="objectBoundingBox" width="1" height="1">
+      <use xlink:href="#image0_146_1014" transform="scale(0.0103093 0.0104167)"/>
+    </pattern>
+    <image id="image0_146_1014" width="428" height="96" xlink:href="data:image/png;base64,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"/>
+  </defs>
+</svg>

mindsdb/integrations/handlers/llama_index_handler/llama_index_handler.py

@@ -0,0 +1,201 @@
+from typing import Optional, Dict
+
+import pandas as pd
+import openai
+from llama_index.llms.openai import OpenAI
+from llama_index.core import Document
+from llama_index.readers.web import SimpleWebPageReader
+from llama_index.core import PromptTemplate
+from llama_index.core import StorageContext, load_index_from_storage
+from llama_index.embeddings.openai import OpenAIEmbedding
+from llama_index.core import VectorStoreIndex
+from llama_index.core import Settings
+
+from mindsdb.integrations.libs.base import BaseMLEngine
+from mindsdb.utilities.config import Config
+from mindsdb.utilities.security import validate_urls
+from mindsdb.integrations.handlers.llama_index_handler.settings import llama_index_config, LlamaIndexModel
+from mindsdb.integrations.libs.api_handler_exceptions import MissingConnectionParams
+from mindsdb.integrations.utilities.handler_utils import get_api_key
+
+
+class LlamaIndexHandler(BaseMLEngine):
+    """Integration with the LlamaIndex data framework for LLM applications."""
+
+    name = "llama_index"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.generative = True
+        self.default_index_class = llama_index_config.DEFAULT_INDEX_CLASS
+        self.supported_index_class = llama_index_config.SUPPORTED_INDEXES
+        self.default_reader = llama_index_config.DEFAULT_READER
+        self.supported_reader = llama_index_config.SUPPORTED_READERS
+        self.config = Config()
+
+    @staticmethod
+    def create_validation(target, args=None, **kwargs):
+        if 'using' not in args:
+            raise MissingConnectionParams("LlamaIndex engine requires USING clause!")
+        else:
+            args = args['using']
+            LlamaIndexModel(**args)
+
+    def create(
+        self,
+        target: str,
+        df: Optional[pd.DataFrame] = None,
+        args: Optional[Dict] = None,
+    ) -> None:
+        # workaround to create llama model without input data
+        if df is None or df.empty:
+            df = pd.DataFrame([{"text": ""}])
+        
+        args_reader = args.get("using", {}).get("reader", self.default_reader)
+
+        if args_reader == "DFReader":
+            dstrs = df.apply(
+                lambda x: ", ".join(
+                    [f"{col}: {str(entry)}" for col, entry in zip(df.columns, x)]
+                ),
+                axis=1,
+            )
+            reader = list(map(lambda x: Document(text=x), dstrs.tolist()))
+        elif args_reader == "SimpleWebPageReader":
+            url = args["using"]["source_url_link"]
+            allowed_urls = self.config.get('web_crawling_allowed_sites', [])
+            if allowed_urls and not validate_urls(url, allowed_urls):
+                raise ValueError(f"The provided URL is not allowed for web crawling. Please use any of {', '.join(allowed_urls)}.")
+            reader = SimpleWebPageReader(html_to_text=True).load_data([url])
+        else:
+            raise Exception(
+                f"Invalid operation mode. Please use one of {self.supported_reader}."
+            )
+        self.model_storage.json_set("args", args)
+        index = self._setup_index(reader)
+        path = self.model_storage.folder_get("context")
+        index.storage_context.persist(persist_dir=path)
+        self.model_storage.folder_sync("context")
+
+    def update(self, args) -> None:
+        args_cur = self.model_storage.json_get("args")
+        args_cur["using"].update(args["using"])
+
+        # check new set of arguments
+        self.create_validation(None, args_cur)
+
+        self.model_storage.json_set("args", args_cur)
+
+    def predict(
+        self, df: Optional[pd.DataFrame] = None, args: Optional[Dict] = None
+    ) -> pd.DataFrame:
+        pred_args = args["predict_params"] if args else {}
+
+        args = self.model_storage.json_get("args")
+        engine_kwargs = {}
+
+        if args["using"].get("mode") == "conversational":
+            user_column = args["using"]["user_column"]
+            assistant_column = args["using"]["assistant_column"]
+
+            messages = []
+            for row in df[:-1].to_dict("records"):
+                messages.append(f"user: {row[user_column]}")
+                messages.append(f"assistant: {row[assistant_column]}")
+
+            conversation = "\n".join(messages)
+
+            questions = [df.iloc[-1][user_column]]
+
+            if "prompt" in pred_args and pred_args["prompt"] is not None:
+                user_prompt = pred_args["prompt"]
+            else:
+                user_prompt = args["using"].get("prompt", "")
+
+            prompt_template = (
+                f"{user_prompt}\n"
+                f"---------------------\n"
+                f"We have provided context information below. \n"
+                f"{{context_str}}\n"
+                f"---------------------\n"
+                f"This is previous conversation history:\n"
+                f"{conversation}\n"
+                f"---------------------\n"
+                f"Given this information, please answer the question: {{query_str}}"
+            )
+
+            engine_kwargs["text_qa_template"] = PromptTemplate(prompt_template)
+
+        else:
+            input_column = args["using"].get("input_column", None)
+
+            prompt_template = args["using"].get(
+                "prompt_template", args.get("prompt_template", None)
+            )
+            if prompt_template is not None:
+                self.create_validation(args=args)
+                engine_kwargs["text_qa_template"] = PromptTemplate(prompt_template)
+
+            if input_column is None:
+                raise Exception(
+                    f"`input_column` must be provided at model creation time or through USING clause when predicting. Please try again."
+                )  # noqa
+
+            if input_column not in df.columns:
+                raise Exception(
+                    f'Column "{input_column}" not found in input data! Please try again.'
+                )
+
+            questions = df[input_column]
+
+        index_path = self.model_storage.folder_get("context")
+        storage_context = StorageContext.from_defaults(persist_dir=index_path)
+        self._get_service_context()
+       
+        index = load_index_from_storage(
+            storage_context
+        )
+        query_engine = index.as_query_engine(**engine_kwargs)
+
+        results = []
+
+        for question in questions:
+            query_results = query_engine.query(
+                question
+            )  # TODO: provide extra_info in explain_target col
+            results.append(query_results.response)
+
+        result_df = pd.DataFrame(
+            {"question": questions, args["target"]: results}
+        )  # result_df['answer'].tolist()
+        return result_df
+
+    def _get_service_context(self) -> None:
+        args = self.model_storage.json_get("args")
+        engine_storage = self.engine_storage
+        openai_api_key = get_api_key('openai', args["using"], engine_storage, strict=True)
+        llm_kwargs = {"api_key": openai_api_key}
+
+        if "temperature" in args["using"]:
+            llm_kwargs["temperature"] = args["using"]["temperature"]
+        if "model_name" in args["using"]:
+            llm_kwargs["model_name"] = args["using"]["model_name"]
+        if "max_tokens" in args["using"]:
+            llm_kwargs["max_tokens"] = args["using"]["max_tokens"]
+        #only way this works is by sending the key through openai
+
+        openai.api_key = openai_api_key
+        if Settings.llm is None:
+            llm = OpenAI()
+            Settings.llm = llm
+        if Settings.embed_model is None:
+            embed_model = OpenAIEmbedding()
+            Settings.embed_model = embed_model
+        # TODO: all usual params should be added to Settings
+
+    def _setup_index(self, documents):
+        self._get_service_context()
+        index = VectorStoreIndex.from_documents(
+            documents
+        )
+        return index

mindsdb/integrations/handlers/llama_index_handler/requirements.txt

@@ -0,0 +1,5 @@
+llama-index==0.10.13
+openai == 1.24.0
+pydantic-settings >= 2.1.0
+llama-index-readers-web
+llama-index-embeddings-openai

mindsdb/integrations/handlers/llama_index_handler/settings.py

@@ -0,0 +1,65 @@
+from typing import List, Optional
+from pydantic import BaseModel, field_validator, model_validator
+from pydantic_settings import BaseSettings
+
+class LlamaIndexConfig(BaseSettings):
+    """
+    Model for LlamaIndexHandler settings.
+
+    Attributes:
+        default_index_class (str): Default index class.
+        supported_index_class (List[str]): Supported index classes.
+        default_reader (str): Default reader. Note this is custom data frame reader.
+        supported_reader (List[str]): Supported readers.
+    """
+    DEFAULT_INDEX_CLASS : str = "VectorStoreIndex"
+    SUPPORTED_INDEXES : List[str] = ["VectorStoreIndex"]
+    DEFAULT_READER: str = "DFReader"
+    SUPPORTED_READERS : List[str] = ["DFReader", "SimpleWebPageReader"]
+
+
+llama_index_config = LlamaIndexConfig()
+
+class LlamaIndexModel(BaseModel):
+    """
+    Model for LlamaIndexHandler.
+
+    Attributes:
+        reader (str): Reader.
+        index_class (str): Index class.
+        index (Any): Index.
+        reader_params (Any): Reader parameters.
+        index_params (Any): Index parameters.
+    """
+    reader: Optional[str] = None
+    index_class: Optional[str] = None
+    input_column: str
+    openai_api_key: Optional[str] = None
+    input_column: Optional[str]
+    mode: Optional[str] = None
+    user_column: Optional[str] = None
+    assistant_column: Optional[str] = None
+
+    @field_validator('reader')
+    @classmethod
+    def validate_reader(cls, value):
+        if value not in llama_index_config.SUPPORTED_READERS:
+            raise ValueError(f"Reader {value} is not supported.")
+        
+        return value
+
+    @field_validator('index_class')
+    @classmethod
+    def validate_index_class(cls, value):
+        if value not in llama_index_config.SUPPORTED_INDEXES:
+            raise ValueError(f"Index class {value} is not supported.")
+        
+        return value
+    
+    @model_validator(mode='after')
+    def validate_mode(self):
+        if self.mode == "conversational" and not all([self.user_column, self.assistant_column]):
+            raise ValueError(f"Conversational mode requires user_column and assistant_column parameter")
+        
+        return self
+

mindsdb/integrations/handlers/ludwig_handler/__about__.py

@@ -0,0 +1,9 @@
+__title__ = 'MindsDB Ludwig handler'
+__package_name__ = 'mindsdb_ludwig_handler'
+__version__ = '0.0.2'
+__description__ = "MindsDB handler for Ludwig AutoML"
+__author__ = 'MindsDB Inc'
+__github__ = 'https://github.com/mindsdb/mindsdb'
+__pypi__ = 'https://pypi.org/project/mindsdb/'
+__license__ = 'MIT'
+__copyright__ = 'Copyright 2022- mindsdb'

mindsdb/integrations/handlers/ludwig_handler/__init__.py

@@ -0,0 +1,19 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+
+from mindsdb.integrations.handlers.ludwig_handler.__about__ import __version__ as version, __description__ as description
+try:
+    from .ludwig_handler import LudwigHandler as Handler
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = 'Ludwig'
+name = 'ludwig'
+type = HANDLER_TYPE.ML
+icon_path = 'icon.svg'
+permanent = False
+
+__all__ = [
+    'Handler', 'version', 'name', 'type', 'title', 'description', 'import_error', 'icon_path'
+]

mindsdb/integrations/handlers/ludwig_handler/icon.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="40" height="40" viewBox="0 0 40 40" fill="none">
+  <rect x="2.08333" y="2.08333" width="35.8333" height="35.8333" stroke="#404040" stroke-width="4.16667"/>
+  <path d="M11.6664 10V28.3333H28.3331" stroke="#404040" stroke-width="4.16667" stroke-linecap="square"/>
+  <path d="M20 10V20H28.3333V10" stroke="#404040" stroke-width="4.16667" stroke-linecap="square"/>
+</svg>

mindsdb/integrations/handlers/ludwig_handler/ludwig_handler.py

@@ -0,0 +1,68 @@
+from typing import Optional
+
+import dill
+import dask
+import pandas as pd
+from ludwig.automl import auto_train
+
+from mindsdb.integrations.libs.base import BaseMLEngine
+from .utils import RayConnection
+
+
+class LudwigHandler(BaseMLEngine):
+    """
+    Integration with the Ludwig declarative ML library.
+    """  # noqa
+
+    name = 'ludwig'
+
+    def create(self, target: str, df: Optional[pd.DataFrame] = None, args: Optional[dict] = None) -> None:
+        args = args['using']  # ignore the rest of the problem definition
+
+        # TODO: filter out incompatible use cases (e.g. time series won't work currently)
+        # TODO: enable custom values via `args` (mindful of local vs cloud)
+        user_config = {'hyperopt': {'executor': {'gpu_resources_per_trial': 0, 'num_samples': 3}}}  # no GPU for now
+
+        with RayConnection():
+            results = auto_train(
+                dataset=df,
+                target=target,
+                tune_for_memory=False,
+                time_limit_s=120,
+                user_config=user_config,
+                # output_directory='./',
+                # random_seed=42,
+                # use_reference_config=False,
+                # kwargs={}
+            )
+        model = results.best_model
+        args['dtype_dict'] = {f['name']: f['type'] for f in model.base_config['input_features']}
+        args['accuracies'] = {'metric': results.experiment_analysis.best_result['metric_score']}
+        self.model_storage.json_set('args', args)
+        self.model_storage.file_set('model', dill.dumps(model))
+
+    def predict(self, df, args=None):
+        model = dill.loads(self.model_storage.file_get('model'))
+        with RayConnection():
+            predictions = self._call_model(df, model)
+        return predictions
+
+    @staticmethod
+    def _call_model(df, model):
+        predictions = dask.compute(model.predict(df)[0])[0]
+        target_name = model.config['output_features'][0]['column']
+
+        if target_name not in df:
+            predictions.columns = [target_name]
+        else:
+            predictions.columns = ['prediction']
+
+        predictions[f'{target_name}_explain'] = None
+        joined = df.join(predictions)
+
+        if 'prediction' in joined:
+            joined = joined.rename({
+                target_name: f'{target_name}_original',
+                'prediction': target_name
+            }, axis=1)
+        return joined

mindsdb/integrations/handlers/ludwig_handler/requirements.txt

@@ -0,0 +1,3 @@
+ludwig[distributed]>=0.5.2
+ray==2.8.1
+dask

mindsdb/integrations/handlers/ludwig_handler/utils.py

@@ -0,0 +1,12 @@
+import ray
+
+
+class RayConnection:
+    def __init__(self, addr=None, **kwargs):
+        ray.init(address=addr, **kwargs)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        ray.shutdown()

mindsdb/integrations/handlers/luma_handler/__about__.py

@@ -0,0 +1,9 @@
+__title__ = "MindsDB Luma handler"
+__package_name__ = "mindsdb_luma_handler"
+__version__ = "0.0.1"
+__description__ = "MindsDB handler for Luma"
+__author__ = "Abhilash K R"
+__github__ = "https://github.com/mindsdb/mindsdb"
+__pypi__ = "https://pypi.org/project/mindsdb/"
+__license__ = "MIT"
+__copyright__ = "Copyright 2023 - mindsdb"