MindsDB 25.5.3.0__py3-none-any.whl → 25.5.4.1__py3-none-any.whl

mindsdb/integrations/libs/llm/utils.py

@@ -16,6 +16,7 @@ from mindsdb.integrations.libs.llm.config import (
     OpenAIConfig,
     NvidiaNIMConfig,
     MindsdbConfig,
+    WriterConfig,
 )
 from mindsdb.utilities.config import config
 from langchain_text_splitters import Language, RecursiveCharacterTextSplitter
@@ -41,16 +42,12 @@ DEFAULT_LITELLM_BASE_URL = "https://ai.dev.mindsdb.com"
 DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434"
 DEFAULT_OLLAMA_MODEL = "llama2"
 
-DEFAULT_NVIDIA_NIM_BASE_URL = (
-    "http://localhost:8000/v1"  # Assumes local port forwarding through ssh
-)
+DEFAULT_NVIDIA_NIM_BASE_URL = "http://localhost:8000/v1"  # Assumes local port forwarding through ssh
 DEFAULT_NVIDIA_NIM_MODEL = "meta/llama-3_1-8b-instruct"
 DEFAULT_VLLM_SERVER_URL = "http://localhost:8000/v1"
 
 
-def get_completed_prompts(
-    base_template: str, df: pd.DataFrame, strict=True
-) -> Tuple[List[str], np.ndarray]:
+def get_completed_prompts(base_template: str, df: pd.DataFrame, strict=True) -> Tuple[List[str], np.ndarray]:
     """
     Helper method that produces formatted prompts given a template and data in a Pandas DataFrame.
     It also returns the ID of any empty templates that failed to be filled due to missing data.
@@ -69,9 +66,7 @@ def get_completed_prompts(
     if len(matches) == 0:
         # no placeholders
         if strict:
-            raise AssertionError(
-                "No placeholders found in the prompt, please provide a valid prompt template."
-            )
+            raise AssertionError("No placeholders found in the prompt, please provide a valid prompt template.")
         prompts = [base_template] * len(df)
         return prompts, np.ndarray(0)
 
@@ -95,12 +90,8 @@ def get_completed_prompts(
     for i in range(len(template)):
         atom = template[i]
         if i < len(columns):
-            col = df[columns[i]].replace(
-                to_replace=[None], value=""
-            )  # add empty quote if data is missing
-            df["__mdb_prompt"] = df["__mdb_prompt"].apply(
-                lambda x: x + atom
-            ) + col.astype("string")
+            col = df[columns[i]].replace(to_replace=[None], value="")  # add empty quote if data is missing
+            df["__mdb_prompt"] = df["__mdb_prompt"].apply(lambda x: x + atom) + col.astype("string")
         else:
             df["__mdb_prompt"] = df["__mdb_prompt"].apply(lambda x: x + atom)
     prompts = list(df["__mdb_prompt"])
@@ -119,8 +110,7 @@ def get_llm_config(provider: str, args: Dict) -> BaseLLMConfig:
     """
     temperature = min(1.0, max(0.0, args.get("temperature", 0.0)))
     if provider == "openai":
-
-        if any(x in args.get("model_name", "") for x in ['o1', 'o3']):
+        if any(x in args.get("model_name", "") for x in ["o1", "o3"]):
             # for o1 and 03, 'temperature' does not support 0.0 with this model. Only the default (1) value is supported
             temperature = 1
 
@@ -173,9 +163,7 @@ def get_llm_config(provider: str, args: Dict) -> BaseLLMConfig:
             max_tokens=args.get("max_tokens", DEFAULT_OPENAI_MAX_TOKENS),
             top_p=args.get("top_p", None),
             top_k=args.get("top_k", None),
-            custom_llm_provider=args.get(
-                "custom_llm_provider", DEFAULT_LITELLM_PROVIDER
-            ),
+            custom_llm_provider=args.get("custom_llm_provider", DEFAULT_LITELLM_PROVIDER),
             model_kwargs=model_kwargs,
         )
     if provider == "ollama":
@@ -237,6 +225,18 @@ def get_llm_config(provider: str, args: Dict) -> BaseLLMConfig:
             max_output_tokens=args.get("max_tokens", None),
             google_api_key=args["api_keys"].get("google", None),
         )
+    if provider == "writer":
+        return WriterConfig(
+            model_name=args.get("model_name", "palmyra-x5"),
+            temperature=temperature,
+            max_tokens=args.get("max_tokens", None),
+            top_p=args.get("top_p", None),
+            stop=args.get("stop", None),
+            best_of=args.get("best_of", None),
+            writer_api_key=args["api_keys"].get("writer", None),
+            writer_org_id=args.get("writer_org_id", None),
+            base_url=args.get("base_url", None),
+        )
 
     raise ValueError(f"Provider {provider} is not supported.")
 
@@ -290,9 +290,7 @@ def ft_jsonl_validation(
                 )  # noqa
 
             if messages_col not in batch:
-                raise Exception(
-                    f"{prefix}Each line in the provided data should have a '{messages_col}' key"
-                )
+                raise Exception(f"{prefix}Each line in the provided data should have a '{messages_col}' key")
 
             messages = batch[messages_col]
             try:
@@ -350,30 +348,22 @@ def ft_chat_format_validation(
 
     for c in chat:
         if any(k not in valid_keys for k in c.keys()):
-            raise Exception(
-                f"Each message should only have these keys: `{valid_keys}`. Found: `{c.keys()}`"
-            )
+            raise Exception(f"Each message should only have these keys: `{valid_keys}`. Found: `{c.keys()}`")
 
     roles = [m[role_key] for m in chat]
     contents = [m[content_key] for m in chat]
 
     if len(roles) != len(contents):
-        raise Exception(
-            f"Each message should contain both `{role_key}` and `{content_key}` fields"
-        )
+        raise Exception(f"Each message should contain both `{role_key}` and `{content_key}` fields")
 
     if len(roles) == 0:
         raise Exception("Chat should have at least one message")
 
     if assistant_key not in roles:
-        raise Exception(
-            "Chat should have at least one assistant message"
-        )  # otherwise it is useless for FT
+        raise Exception("Chat should have at least one assistant message")  # otherwise it is useless for FT
 
     if user_key not in roles:
-        raise Exception(
-            "Chat should have at least one user message"
-        )  # perhaps remove in the future
+        raise Exception("Chat should have at least one user message")  # perhaps remove in the future
 
     # set default transitions for finite state machine if undefined
     if transitions is None:
@@ -387,20 +377,15 @@ def ft_chat_format_validation(
     # check order is valid via finite state machine
     state = None
     for i, (role, content) in enumerate(zip(roles, contents)):
-
         prefix = f"message #{i + 1}: "
 
         # check invalid roles
         if role not in valid_roles:
-            raise Exception(
-                f"{prefix}Invalid role (found `{role}`, expected one of `{valid_roles}`)"
-            )
+            raise Exception(f"{prefix}Invalid role (found `{role}`, expected one of `{valid_roles}`)")
 
         # check content
         if not isinstance(content, str):
-            raise Exception(
-                f"{prefix}Content should be a string, got type `{type(content)}`"
-            )
+            raise Exception(f"{prefix}Content should be a string, got type `{type(content)}`")
 
         # check transition
         if role not in transitions[state]:
@@ -464,9 +449,7 @@ def ft_chat_formatter(df: pd.DataFrame) -> List[Dict]:
             df = df.sort_values(["chat_id"], kind="stable")
     elif "message_id" in df.columns:
         if df["message_id"].duplicated().any():
-            raise Exception(
-                "If `message_id` is provided, it must not contain duplicate IDs."
-            )
+            raise Exception("If `message_id` is provided, it must not contain duplicate IDs.")
         df = df.sort_values(["message_id"])
 
     # 2. build chats
@@ -477,12 +460,8 @@ def ft_chat_formatter(df: pd.DataFrame) -> List[Dict]:
         for _, row in df.iterrows():
             try:
                 chat = json.loads(row["chat_json"])
-                assert list(chat.keys()) == [
-                    "messages"
-                ], "Each chat should have a 'messages' key, and nothing else."
-                ft_chat_format_validation(
-                    chat["messages"]
-                )  # will raise Exception if chat is invalid
+                assert list(chat.keys()) == ["messages"], "Each chat should have a 'messages' key, and nothing else."
+                ft_chat_format_validation(chat["messages"])  # will raise Exception if chat is invalid
                 chats.append(chat)
             except json.JSONDecodeError:
                 pass  # TODO: add logger info here, prompt user to clean dataset carefully
@@ -492,9 +471,7 @@ def ft_chat_formatter(df: pd.DataFrame) -> List[Dict]:
         chat = []
         for i, row in df.iterrows():
             if row["role"] == "system" and len(chat) > 0:
-                ft_chat_format_validation(
-                    chat
-                )  # will raise Exception if chat is invalid
+                ft_chat_format_validation(chat)  # will raise Exception if chat is invalid
                 chats.append({"messages": chat})
                 chat = []
             event = {"role": row["role"], "content": row["content"]}
@@ -529,15 +506,11 @@ def ft_code_formatter(
     # input and setup validation
     assert len(df) > 0, "Input dataframe should not be empty"
     assert "code" in df.columns, "Input dataframe should have a 'code' column"
-    assert chunk_size > 0 and isinstance(
-        chunk_size, int
-    ), "`chunk_size` should be a positive integer"
+    assert chunk_size > 0 and isinstance(chunk_size, int), "`chunk_size` should be a positive integer"
 
     supported_formats = ["chat", "fim"]
     supported_langs = [e.value for e in Language]
-    assert (
-        language.lower() in supported_langs
-    ), f"Invalid language. Valid choices are: {supported_langs}"
+    assert language.lower() in supported_langs, f"Invalid language. Valid choices are: {supported_langs}"
 
     # ensure correct encoding
     df["code"] = df["code"].map(lambda x: x.encode("utf8").decode("unicode_escape"))
@@ -574,7 +547,7 @@ def ft_code_formatter(
     roles = []
     contents = []
     for idx in range(0, len(chunks), 3):
-        pre, mid, suf = chunks[idx: idx + 3]
+        pre, mid, suf = chunks[idx : idx + 3]
         interleaved = list(itertools.chain(*zip(templates, (pre, suf, mid))))
         user = "\n".join(interleaved[:-1])
         assistant = "\n".join(interleaved[-1:])
@@ -595,12 +568,11 @@ def ft_cqa_formatter(
     default_instruction="You are a helpful assistant.",
     default_context="",
 ) -> pd.DataFrame:
-
     # input and setup validation
     assert len(df) > 0, "Input dataframe should not be empty"
-    assert {question_col, answer_col}.issubset(
-        set(df.columns)
-    ), f"Input dataframe must have columns `{question_col}`, and `{answer_col}`"  # noqa
+    assert {question_col, answer_col}.issubset(set(df.columns)), (
+        f"Input dataframe must have columns `{question_col}`, and `{answer_col}`"
+    )  # noqa
 
     if instruction_col not in df.columns:
         df[instruction_col] = default_instruction

mindsdb/integrations/libs/response.py

@@ -6,6 +6,7 @@ import pandas
 
 from mindsdb.utilities import log
 from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 from mindsdb_sql_parser.ast import ASTNode
 
 
@@ -18,29 +19,32 @@ class _INFORMATION_SCHEMA_COLUMNS_NAMES:
     These column names match the standard INFORMATION_SCHEMA.COLUMNS structure
     used in SQL databases to describe table metadata.
     """
-    COLUMN_NAME: str = 'COLUMN_NAME'
-    DATA_TYPE: str = 'DATA_TYPE'
-    ORDINAL_POSITION: str = 'ORDINAL_POSITION'
-    COLUMN_DEFAULT: str = 'COLUMN_DEFAULT'
-    IS_NULLABLE: str = 'IS_NULLABLE'
-    CHARACTER_MAXIMUM_LENGTH: str = 'CHARACTER_MAXIMUM_LENGTH'
-    CHARACTER_OCTET_LENGTH: str = 'CHARACTER_OCTET_LENGTH'
-    NUMERIC_PRECISION: str = 'NUMERIC_PRECISION'
-    NUMERIC_SCALE: str = 'NUMERIC_SCALE'
-    DATETIME_PRECISION: str = 'DATETIME_PRECISION'
-    CHARACTER_SET_NAME: str = 'CHARACTER_SET_NAME'
-    COLLATION_NAME: str = 'COLLATION_NAME'
-    MYSQL_DATA_TYPE: str = 'MYSQL_DATA_TYPE'
+
+    COLUMN_NAME: str = "COLUMN_NAME"
+    DATA_TYPE: str = "DATA_TYPE"
+    ORDINAL_POSITION: str = "ORDINAL_POSITION"
+    COLUMN_DEFAULT: str = "COLUMN_DEFAULT"
+    IS_NULLABLE: str = "IS_NULLABLE"
+    CHARACTER_MAXIMUM_LENGTH: str = "CHARACTER_MAXIMUM_LENGTH"
+    CHARACTER_OCTET_LENGTH: str = "CHARACTER_OCTET_LENGTH"
+    NUMERIC_PRECISION: str = "NUMERIC_PRECISION"
+    NUMERIC_SCALE: str = "NUMERIC_SCALE"
+    DATETIME_PRECISION: str = "DATETIME_PRECISION"
+    CHARACTER_SET_NAME: str = "CHARACTER_SET_NAME"
+    COLLATION_NAME: str = "COLLATION_NAME"
+    MYSQL_DATA_TYPE: str = "MYSQL_DATA_TYPE"
 
 
 INF_SCHEMA_COLUMNS_NAMES = _INFORMATION_SCHEMA_COLUMNS_NAMES()
 INF_SCHEMA_COLUMNS_NAMES_SET = set(f.name for f in fields(INF_SCHEMA_COLUMNS_NAMES))
 
 
-
 class HandlerResponse:
-    def __init__(self, resp_type: RESPONSE_TYPE, data_frame: pandas.DataFrame = None, query: ASTNode = 0, error_code: int = 0,
-                 error_message: str | None = None, affected_rows: int | None = None) -> None:
+    def __init__(
+            self, resp_type: RESPONSE_TYPE, data_frame: pandas.DataFrame = None, query: ASTNode = 0,
+            error_code: int = 0, error_message: str | None = None, affected_rows: int | None = None,
+            mysql_types: list[MYSQL_DATA_TYPE] | None = None
+    ) -> None:
         self.resp_type = resp_type
         self.query = query
         self.data_frame = data_frame
@@ -49,6 +53,7 @@ class HandlerResponse:
         self.affected_rows = affected_rows
         if isinstance(self.affected_rows, int) is False or self.affected_rows < 0:
             self.affected_rows = 0
+        self.mysql_types = mysql_types
 
     @property
     def type(self):
@@ -66,7 +71,9 @@ class HandlerResponse:
                     f"Cannot convert {self.resp_type} to {RESPONSE_TYPE.COLUMNS_TABLE}, "
                     f"the error is: {self.error_message}"
                 )
-            raise ValueError(f"Cannot convert {self.resp_type} to {RESPONSE_TYPE.COLUMNS_TABLE}")
+            raise ValueError(
+                f"Cannot convert {self.resp_type} to {RESPONSE_TYPE.COLUMNS_TABLE}"
+            )
 
         self.data_frame.columns = [name.upper() for name in self.data_frame.columns]
         self.data_frame[INF_SCHEMA_COLUMNS_NAMES.MYSQL_DATA_TYPE] = self.data_frame[
@@ -77,24 +84,26 @@ class HandlerResponse:
         current_columns_set = set(self.data_frame.columns)
         if INF_SCHEMA_COLUMNS_NAMES_SET != current_columns_set:
             raise ValueError(
-                f'Columns set for INFORMATION_SCHEMA.COLUMNS is wrong: {list(current_columns_set)}'
+                f"Columns set for INFORMATION_SCHEMA.COLUMNS is wrong: {list(current_columns_set)}"
             )
         # endregion
 
-        self.data_frame = self.data_frame.astype({
-            INF_SCHEMA_COLUMNS_NAMES.COLUMN_NAME: 'string',
-            INF_SCHEMA_COLUMNS_NAMES.DATA_TYPE: 'string',
-            INF_SCHEMA_COLUMNS_NAMES.ORDINAL_POSITION: 'Int32',
-            INF_SCHEMA_COLUMNS_NAMES.COLUMN_DEFAULT: 'string',
-            INF_SCHEMA_COLUMNS_NAMES.IS_NULLABLE: 'string',
-            INF_SCHEMA_COLUMNS_NAMES.CHARACTER_MAXIMUM_LENGTH: 'Int32',
-            INF_SCHEMA_COLUMNS_NAMES.CHARACTER_OCTET_LENGTH: 'Int32',
-            INF_SCHEMA_COLUMNS_NAMES.NUMERIC_PRECISION: 'Int32',
-            INF_SCHEMA_COLUMNS_NAMES.NUMERIC_SCALE: 'Int32',
-            INF_SCHEMA_COLUMNS_NAMES.DATETIME_PRECISION: 'Int32',
-            INF_SCHEMA_COLUMNS_NAMES.CHARACTER_SET_NAME: 'string',
-            INF_SCHEMA_COLUMNS_NAMES.COLLATION_NAME: 'string',
-        })
+        self.data_frame = self.data_frame.astype(
+            {
+                INF_SCHEMA_COLUMNS_NAMES.COLUMN_NAME: "string",
+                INF_SCHEMA_COLUMNS_NAMES.DATA_TYPE: "string",
+                INF_SCHEMA_COLUMNS_NAMES.ORDINAL_POSITION: "Int32",
+                INF_SCHEMA_COLUMNS_NAMES.COLUMN_DEFAULT: "string",
+                INF_SCHEMA_COLUMNS_NAMES.IS_NULLABLE: "string",
+                INF_SCHEMA_COLUMNS_NAMES.CHARACTER_MAXIMUM_LENGTH: "Int32",
+                INF_SCHEMA_COLUMNS_NAMES.CHARACTER_OCTET_LENGTH: "Int32",
+                INF_SCHEMA_COLUMNS_NAMES.NUMERIC_PRECISION: "Int32",
+                INF_SCHEMA_COLUMNS_NAMES.NUMERIC_SCALE: "Int32",
+                INF_SCHEMA_COLUMNS_NAMES.DATETIME_PRECISION: "Int32",
+                INF_SCHEMA_COLUMNS_NAMES.CHARACTER_SET_NAME: "string",
+                INF_SCHEMA_COLUMNS_NAMES.COLLATION_NAME: "string",
+            }
+        )
         self.data_frame.replace([numpy.NaN, pandas.NA], None, inplace=True)
 
         self.resp_type = RESPONSE_TYPE.COLUMNS_TABLE
@@ -103,33 +112,39 @@ class HandlerResponse:
         try:
             data = None
             if self.data_frame is not None:
-                data = self.data_frame.to_json(orient="split", index=False, date_format="iso")
+                data = self.data_frame.to_json(
+                    orient="split", index=False, date_format="iso"
+                )
         except Exception as e:
             logger.error("%s.to_json: error - %s", self.__class__.__name__, e)
             data = None
-        return  {"type": self.resp_type,
-                 "query": self.query,
-                 "data_frame": data,
-                 "error_code": self.error_code,
-                 "error": self.error_message}
+        return {
+            "type": self.resp_type,
+            "query": self.query,
+            "data_frame": data,
+            "error_code": self.error_code,
+            "error": self.error_message,
+        }
 
     def __repr__(self):
-        return "%s: resp_type=%s, query=%s, data_frame=%s, err_code=%s, error=%s, affected_rows=%s" % (
-                self.__class__.__name__,
-                self.resp_type,
-                self.query,
-                self.data_frame,
-                self.error_code,
-                self.error_message,
-                self.affected_rows
-            )
+        return "%s: resp_type=%s, query=%s, data_frame=\n%s\nerr_code=%s, error=%s, affected_rows=%s" % (
+            self.__class__.__name__,
+            self.resp_type,
+            self.query,
+            self.data_frame,
+            self.error_code,
+            self.error_message,
+            self.affected_rows,
+        )
 
 
 class HandlerStatusResponse:
-    def __init__(self, success: bool = True,
-                 error_message: str = None,
-                 redirect_url: str = None,
-                 copy_storage: str = None
+    def __init__(
+        self,
+        success: bool = True,
+        error_message: str = None,
+        redirect_url: str = None,
+        copy_storage: str = None,
     ) -> None:
         self.success = success
         self.error_message = error_message
@@ -139,7 +154,7 @@ class HandlerStatusResponse:
     def to_json(self):
         data = {"success": self.success, "error": self.error_message}
         if self.redirect_url is not None:
-            data['redirect_url'] = self.redirect_url
+            data["redirect_url"] = self.redirect_url
         return data
 
     def __repr__(self):

mindsdb/integrations/libs/vectordatabase_handler.py

@@ -553,3 +553,9 @@ class VectorStoreHandler(BaseHandler):
             df(pd.DataFrame): Hybrid search result, sorted by hybrid search rank
         '''
         raise NotImplementedError(f'Hybrid search not supported for VectorStoreHandler {self.name}')
+
+    def create_index(self, *args, **kwargs):
+        """
+        Create an index on the specified table.
+        """
+        raise NotImplementedError(f'create_index not supported for VectorStoreHandler {self.name}')

mindsdb/integrations/utilities/handler_utils.py

@@ -43,6 +43,11 @@ def get_api_key(
     if f"{api_name.lower()}_api_key" in create_args:
         return create_args[f"{api_name.lower()}_api_key"]
 
+    # 2.5 - Check in params dictionary if it exists (for agents)
+    if "params" in create_args and create_args["params"] is not None:
+        if f"{api_name.lower()}_api_key" in create_args["params"]:
+            return create_args["params"][f"{api_name.lower()}_api_key"]
+
     # 3
     if engine_storage is not None:
         connection_args = engine_storage.get_connection_args()
@@ -68,7 +73,14 @@ def get_api_key(
         return create_args['api_keys'][api_name]
 
     if strict:
-        raise Exception(
-            f"Missing API key '{api_name.lower()}_api_key'. Either re-create this ML_ENGINE specifying the '{api_name.lower()}_api_key' parameter, or re-create this model and pass the API key with `USING` syntax."
-        )  # noqa
+        provider_upper = api_name.upper()
+        api_key_env_var = f"{provider_upper}_API_KEY"
+        api_key_arg = f"{api_name.lower()}_api_key"
+        error_message = (
+            f"API key for {api_name} not found. Please provide it using one of the following methods:\n"
+            f"1. Set the {api_key_env_var} environment variable\n"
+            f"2. Provide it as '{api_key_arg}' parameter when creating an agent using the CREATE AGENT syntax\n"
+            f"   Example: CREATE AGENT my_agent USING model='gpt-4', provider='{api_name}', {api_key_arg}='your-api-key';\n"
+        )
+        raise Exception(error_message)
     return None

mindsdb/integrations/utilities/handlers/api_utilities/__init__.py

@@ -1 +0,0 @@
-from .microsoft import MSGraphAPIBaseClient

mindsdb/integrations/utilities/handlers/auth_utilities/__init__.py

@@ -1,2 +0,0 @@
-from .google import GoogleUserOAuth2Manager, GoogleServiceAccountOAuth2Manager
-from .microsoft import MSGraphAPIApplicationPermissionsManager, MSGraphAPIDelegatedPermissionsManager