MindsDB 25.7.1.0__py3-none-any.whl → 25.7.3.0__py3-none-any.whl

mindsdb/interfaces/functions/controller.py

@@ -7,15 +7,15 @@ from mindsdb.utilities.config import config
 
 
 def python_to_duckdb_type(py_type):
-    if py_type == 'int':
+    if py_type == "int":
         return BIGINT
-    elif py_type == 'float':
+    elif py_type == "float":
         return DOUBLE
-    elif py_type == 'str':
+    elif py_type == "str":
         return VARCHAR
-    elif py_type == 'bool':
+    elif py_type == "bool":
         return BOOLEAN
-    elif py_type == 'bytes':
+    elif py_type == "bytes":
         return BLOB
     else:
         # Unknown
@@ -53,8 +53,8 @@ class BYOMFunctionsController:
             # first run
             self.byom_engines = []
             for name, info in self.session.integration_controller.get_all().items():
-                if info['type'] == 'ml' and info['engine'] == 'byom':
-                    if info['connection_data'].get('mode') == 'custom_function':
+                if info["type"] == "ml" and info["engine"] == "byom":
+                    if info["connection_data"].get("mode") == "custom_function":
                         self.byom_engines.append(name)
         return self.byom_engines
 
@@ -63,7 +63,7 @@ class BYOMFunctionsController:
             ml_handler = self.session.integration_controller.get_ml_handler(engine)
 
             storage = HandlerStorage(ml_handler.integration_id)
-            methods = storage.json_get('methods')
+            methods = storage.json_get("methods")
             self.byom_methods[engine] = methods
             self.byom_handlers[engine] = ml_handler
 
@@ -81,7 +81,7 @@ class BYOMFunctionsController:
             # do nothing
             return
 
-        new_name = f'{node.namespace}_{fnc_name}'
+        new_name = f"{node.namespace}_{fnc_name}"
         node.op = new_name
 
         if new_name in self.callbacks:
@@ -91,16 +91,13 @@ class BYOMFunctionsController:
         def callback(*args):
             return self.method_call(engine, fnc_name, args)
 
-        input_types = [
-            param['type']
-            for param in methods[fnc_name]['input_params']
-        ]
+        input_types = [param["type"] for param in methods[fnc_name]["input_params"]]
 
         meta = {
-            'name': new_name,
-            'callback': callback,
-            'input_types': input_types,
-            'output_type': methods[fnc_name]['output_type']
+            "name": new_name,
+            "callback": callback,
+            "input_types": input_types,
+            "output_type": methods[fnc_name]["output_type"],
         }
 
         self.callbacks[new_name] = meta
@@ -114,7 +111,6 @@ class BYOMFunctionsController:
 
 
 class FunctionController(BYOMFunctionsController):
-
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
@@ -124,10 +120,10 @@ class FunctionController(BYOMFunctionsController):
             return meta
 
         # builtin functions
-        if node.op.lower() == 'llm':
+        if node.op.lower() == "llm":
             return self.llm_call_function(node)
 
-        elif node.op.lower() == 'to_markdown':
+        elif node.op.lower() == "to_markdown":
             return self.to_markdown_call_function(node)
 
     def llm_call_function(self, node):
@@ -141,70 +137,74 @@ class FunctionController(BYOMFunctionsController):
         try:
             from langchain_core.messages import HumanMessage
             from mindsdb.interfaces.agents.langchain_agent import create_chat_model
+
             llm = create_chat_model(chat_model_params)
         except Exception as e:
-            raise RuntimeError(f'Unable to use LLM function, check ENV variables: {e}')
+            raise RuntimeError(f"Unable to use LLM function, check ENV variables: {e}")
 
         def callback(question):
             resp = llm([HumanMessage(question)])
             return resp.content
 
-        meta = {
-            'name': name,
-            'callback': callback,
-            'input_types': ['str'],
-            'output_type': 'str'
-        }
+        meta = {"name": name, "callback": callback, "input_types": ["str"], "output_type": "str"}
         self.callbacks[name] = meta
         return meta
 
     def to_markdown_call_function(self, node):
         # load on-demand because lib is heavy
         from mindsdb.interfaces.functions.to_markdown import ToMarkdown
+
         name = node.op.lower()
 
         if name in self.callbacks:
             return self.callbacks[name]
 
-        def callback(file_path_or_url):
-            chat_model_params = self._parse_chat_model_params('TO_MARKDOWN_FUNCTION_')
-
+        def prepare_chat_model_params(chat_model_params: dict) -> dict:
+            """
+            Parepares the chat model parameters for the ToMarkdown function.
+            """
             params_copy = copy.deepcopy(chat_model_params)
-            params_copy['model'] = params_copy.pop('model_name')
-            params_copy.pop('api_keys')
-            params_copy.pop('provider')
+            params_copy["model"] = params_copy.pop("model_name")
+
+            # Set the base_url for the Google provider.
+            if params_copy["provider"] == "google" and "base_url" not in params_copy:
+                params_copy["base_url"] = "https://generativelanguage.googleapis.com/v1beta/"
+
+            params_copy.pop("api_keys")
+            params_copy.pop("provider")
+
+            return params_copy
+
+        def callback(file_path_or_url):
+            chat_model_params = self._parse_chat_model_params("TO_MARKDOWN_FUNCTION_")
+            chat_model_params = prepare_chat_model_params(chat_model_params)
 
             to_markdown = ToMarkdown()
-            return to_markdown.call(file_path_or_url, **params_copy)
+            return to_markdown.call(file_path_or_url, **chat_model_params)
 
-        meta = {
-            'name': name,
-            'callback': callback,
-            'input_types': ['str'],
-            'output_type': 'str'
-        }
+        meta = {"name": name, "callback": callback, "input_types": ["str"], "output_type": "str"}
         self.callbacks[name] = meta
         return meta
 
-    def _parse_chat_model_params(self, param_prefix: str = 'LLM_FUNCTION_'):
+    def _parse_chat_model_params(self, param_prefix: str = "LLM_FUNCTION_"):
         """
         Parses the environment variables for chat model parameters.
         """
         chat_model_params = config.get("default_llm") or {}
         for k, v in os.environ.items():
             if k.startswith(param_prefix):
-                param_name = k[len(param_prefix):]
-                if param_name == 'MODEL':
-                    chat_model_params['model_name'] = v
+                param_name = k[len(param_prefix) :]
+                if param_name == "MODEL":
+                    chat_model_params["model_name"] = v
                 else:
                     chat_model_params[param_name.lower()] = v
 
-        if 'provider' not in chat_model_params:
-            chat_model_params['provider'] = 'openai'
+        if "provider" not in chat_model_params:
+            chat_model_params["provider"] = "openai"
 
-        if 'api_key' in chat_model_params:
+        if "api_key" in chat_model_params:
             # move to api_keys dict
-            chat_model_params["api_keys"] = {chat_model_params['provider']: chat_model_params['api_key']}
+            chat_model_params["api_keys"] = {chat_model_params["provider"]: chat_model_params["api_key"]}
 
         return chat_model_params
 
@@ -215,33 +215,23 @@ class DuckDBFunctions:
         self.functions = {}
 
     def check_function(self, node):
-
         meta = self.controller.check_function(node)
         if meta is None:
             return
 
-        name = meta['name']
+        name = meta["name"]
 
         if name in self.functions:
             return
 
-        input_types = [
-            python_to_duckdb_type(param)
-            for param in meta['input_types']
-        ]
+        input_types = [python_to_duckdb_type(param) for param in meta["input_types"]]
 
         self.functions[name] = {
-            'callback': function_maker(len(input_types), meta['callback']),
-            'input': input_types,
-            'output': python_to_duckdb_type(meta['output_type'])
+            "callback": function_maker(len(input_types), meta["callback"]),
+            "input": input_types,
+            "output": python_to_duckdb_type(meta["output_type"]),
         }
 
     def register(self, connection):
         for name, info in self.functions.items():
-            connection.create_function(
-                name,
-                info['callback'],
-                info['input'],
-                info['output'],
-                null_handling="special"
-            )
+            connection.create_function(name, info["callback"], info["input"], info["output"], null_handling="special")

mindsdb/interfaces/functions/to_markdown.py

@@ -2,6 +2,7 @@ from io import BytesIO
 import os
 from typing import Union
 from urllib.parse import urlparse
+import xml.etree.ElementTree as ET
 
 from aipdf import ocr
 import mimetypes
@@ -12,6 +13,7 @@ class ToMarkdown:
     """
     Extracts the content of documents of various formats in markdown format.
     """
+
     def __init__(self):
         """
         Initializes the ToMarkdown class.
@@ -24,24 +26,28 @@ class ToMarkdown:
         file_extension = self._get_file_extension(file_path_or_url)
         file_content = self._get_file_content(file_path_or_url)
 
-        if file_extension == '.pdf':
+        if file_extension == ".pdf":
             return self._pdf_to_markdown(file_content, **kwargs)
+
+        elif file_extension in (".xml", ".nessus"):
+            return self._xml_to_markdown(file_content, **kwargs)
+
         else:
             raise ValueError(f"Unsupported file type: {file_extension}.")
 
-    def _get_file_content(self, file_path_or_url: str) -> str:
+    def _get_file_content(self, file_path_or_url: str) -> BytesIO:
         """
         Retrieves the content of a file.
         """
         parsed_url = urlparse(file_path_or_url)
-        if parsed_url.scheme in ('http', 'https'):
+        if parsed_url.scheme in ("http", "https"):
             response = requests.get(file_path_or_url)
             if response.status_code == 200:
-                return response
+                return BytesIO(response.content)
             else:
-                raise RuntimeError(f'Unable to retrieve file from URL: {file_path_or_url}')
+                raise RuntimeError(f"Unable to retrieve file from URL: {file_path_or_url}")
         else:
-            with open(file_path_or_url, 'rb') as file:
+            with open(file_path_or_url, "rb") as file:
                 return BytesIO(file.read())
 
     def _get_file_extension(self, file_path_or_url: str) -> str:
@@ -49,13 +55,13 @@ class ToMarkdown:
         Retrieves the file extension from a file path or URL.
         """
         parsed_url = urlparse(file_path_or_url)
-        if parsed_url.scheme in ('http', 'https'):
+        if parsed_url.scheme in ("http", "https"):
             try:
                 # Make a HEAD request to get headers without downloading the file.
                 response = requests.head(file_path_or_url, allow_redirects=True)
-                content_type = response.headers.get('Content-Type', '')
+                content_type = response.headers.get("Content-Type", "")
                 if content_type:
-                    ext = mimetypes.guess_extension(content_type.split(';')[0].strip())
+                    ext = mimetypes.guess_extension(content_type.split(";")[0].strip())
                     if ext:
                         return ext
 
@@ -64,16 +70,43 @@ class ToMarkdown:
                 if ext:
                     return ext
             except requests.RequestException:
-                raise RuntimeError(f'Unable to retrieve file extension from URL: {file_path_or_url}')
+                raise RuntimeError(f"Unable to retrieve file extension from URL: {file_path_or_url}")
         else:
             return os.path.splitext(file_path_or_url)[1]
 
-    def _pdf_to_markdown(self, file_content: Union[requests.Response, bytes], **kwargs) -> str:
+    def _pdf_to_markdown(self, file_content: Union[requests.Response, BytesIO], **kwargs) -> str:
         """
         Converts a PDF file to markdown.
         """
-        if isinstance(file_content, requests.Response):
-            file_content = BytesIO(file_content.content)
-
         markdown_pages = ocr(file_content, **kwargs)
         return "\n\n---\n\n".join(markdown_pages)
+
+    def _xml_to_markdown(self, file_content: Union[requests.Response, BytesIO], **kwargs) -> str:
+        """
+        Converts an XML (or Nessus) file to markdown.
+        """
+
+        def parse_element(element: ET.Element, depth: int = 0) -> str:
+            """
+            Recursively parses an XML element and converts it to markdown.
+            """
+            markdown = []
+            heading = "#" * (depth + 1)
+
+            markdown.append(f"{heading} {element.tag}")
+
+            for key, val in element.attrib.items():
+                markdown.append(f"- **{key}**: {val}")
+
+            text = (element.text or "").strip()
+            if text:
+                markdown.append(f"\n{text}\n")
+
+            for child in element:
+                markdown.append(parse_element(child, depth + 1))
+
+            return "\n".join(markdown)
+
+        root = ET.fromstring(file_content.read().decode("utf-8"))
+        markdown_content = parse_element(root)
+        return markdown_content

mindsdb/interfaces/knowledge_base/controller.py

@@ -1,17 +1,19 @@
 import os
 import copy
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Any, Text
 import json
 import decimal
 
 import pandas as pd
 import numpy as np
+from pydantic import BaseModel, ValidationError
 from sqlalchemy.orm.attributes import flag_modified
 
 from mindsdb_sql_parser.ast import BinaryOperation, Constant, Identifier, Select, Update, Delete, Star
 from mindsdb_sql_parser.ast.mindsdb import CreatePredictor
 from mindsdb_sql_parser import parse_sql
 
+from mindsdb.integrations.libs.keyword_search_base import KeywordSearchBase
 from mindsdb.integrations.utilities.query_traversal import query_traversal
 
 import mindsdb.interfaces.storage.db as db
@@ -37,7 +39,7 @@ from mindsdb.interfaces.knowledge_base.evaluate import EvaluateBase
 from mindsdb.interfaces.knowledge_base.executor import KnowledgeBaseQueryExecutor
 from mindsdb.interfaces.model.functions import PredictorRecordNotFound
 from mindsdb.utilities.exception import EntityExistsError, EntityNotExistsError
-from mindsdb.integrations.utilities.sql_utils import FilterCondition, FilterOperator
+from mindsdb.integrations.utilities.sql_utils import FilterCondition, FilterOperator, KeywordSearchArgs
 from mindsdb.utilities.config import config
 from mindsdb.utilities.context import context as ctx
 
@@ -49,6 +51,20 @@ from mindsdb.integrations.utilities.rag.rerankers.base_reranker import BaseLLMRe
 logger = log.getLogger(__name__)
 
 
+class KnowledgeBaseInputParams(BaseModel):
+    metadata_columns: List[str] | None = None
+    content_columns: List[str] | None = None
+    id_column: str | None = None
+    kb_no_upsert: bool = False
+    embedding_model: Dict[Text, Any] | None = None
+    is_sparse: bool = False
+    vector_size: int | None = None
+    reranking_model: Dict[Text, Any] | None = None
+
+    class Config:
+        extra = "forbid"
+
+
 def get_model_params(model_params: dict, default_config_key: str):
     """
     Get model parameters by combining default config with user provided parameters.
@@ -101,7 +117,10 @@ def get_reranking_model_from_params(reranking_model_params: dict):
 
     if "api_key" not in params_copy:
         params_copy["api_key"] = get_api_key(provider, params_copy, strict=False)
-    params_copy["model"] = params_copy.pop("model_name", None)
+
+    if "model_name" not in params_copy:
+        raise ValueError("'model_name' must be provided for reranking model")
+    params_copy["model"] = params_copy.pop("model_name")
 
     return BaseLLMReranker(**params_copy)
 
@@ -179,17 +198,20 @@ class KnowledgeBaseTable:
         df = executor.run(query)
 
         if (
-            query.group_by is not None
-            or query.order_by is not None
-            or query.having is not None
-            or query.distinct is True
-            or len(query.targets) != 1
-            or not isinstance(query.targets[0], Star)
+            query_copy.group_by is not None
+            or query_copy.order_by is not None
+            or query_copy.having is not None
+            or query_copy.distinct is True
+            or len(query_copy.targets) != 1
+            or not isinstance(query_copy.targets[0], Star)
         ):
             query_copy.where = None
             if "metadata" in df.columns:
                 df["metadata"] = df["metadata"].apply(to_json)
 
+            if query_copy.from_table is None:
+                query_copy.from_table = Identifier(parts=[self._kb.name])
+
             df = query_df(df, query_copy, session=self.session)
 
         return df
@@ -218,8 +240,12 @@ class KnowledgeBaseTable:
 
         # extract values from conditions and prepare for vectordb
         conditions = []
+        keyword_search_conditions = []
+        keyword_search_cols_and_values = []
         query_text = None
         relevance_threshold = None
+        reranking_enabled_flag = True
+        hybrid_search_enabled_flag = False
         query_conditions = db_handler.extract_conditions(query.where)
         if query_conditions is not None:
             for item in query_conditions:
@@ -235,9 +261,17 @@ class KnowledgeBaseTable:
                         logger.error(error_msg)
                         raise ValueError(error_msg)
                 elif item.column == "reranking":
+                    reranking_enabled_flag = item.value
+                    # cast to boolean
+                    if isinstance(reranking_enabled_flag, str):
+                        reranking_enabled_flag = reranking_enabled_flag.lower() not in ("false")
+                elif item.column == "hybrid_search":
+                    hybrid_search_enabled_flag = item.value
+                    # cast to boolean
+                    if isinstance(hybrid_search_enabled_flag, str):
+                        hybrid_search_enabled_flag = hybrid_search_enabled_flag.lower() not in ("false")
                     if item.value is False or (isinstance(item.value, str) and item.value.lower() == "false"):
                         disable_reranking = True
-
                 elif item.column == "relevance" and item.op.value != FilterOperator.GREATER_THAN_OR_EQUAL.value:
                     raise ValueError(
                         f"Invalid operator for relevance: {item.op.value}. Only GREATER_THAN_OR_EQUAL is allowed."
@@ -253,8 +287,16 @@ class KnowledgeBaseTable:
                             op=FilterOperator.EQUAL,
                         )
                     )
+                    keyword_search_cols_and_values.append((TableField.CONTENT.value, item.value))
                 else:
                     conditions.append(item)
+                    keyword_search_conditions.append(item)  # keyword search conditions do not use embeddings
+
+        if len(keyword_search_cols_and_values) > 1:
+            raise ValueError(
+                "Multiple content columns found in query conditions. "
+                "Only one content column is allowed for keyword search."
+            )
 
         logger.debug(f"Extracted query text: {query_text}")
 
@@ -272,9 +314,42 @@ class KnowledgeBaseTable:
         allowed_metadata_columns = self._get_allowed_metadata_columns()
         df = db_handler.dispatch_select(query, conditions, allowed_metadata_columns=allowed_metadata_columns)
         df = self.addapt_result_columns(df)
-
         logger.debug(f"Query returned {len(df)} rows")
         logger.debug(f"Columns in response: {df.columns.tolist()}")
+
+        if hybrid_search_enabled_flag and not isinstance(db_handler, KeywordSearchBase):
+            raise ValueError(f"Hybrid search is enabled but the db_handler {type(db_handler)} does not support it. ")
+        # check if db_handler inherits from KeywordSearchBase
+        if hybrid_search_enabled_flag and isinstance(db_handler, KeywordSearchBase):
+            # If query_text is present, use it for keyword search
+            logger.debug(f"Performing keyword search with query text: {query_text}")
+            keyword_search_args = KeywordSearchArgs(query=query_text, column=TableField.CONTENT.value)
+            keyword_query_obj = copy.deepcopy(query)
+
+            keyword_query_obj.targets = [
+                Identifier(TableField.ID.value),
+                Identifier(TableField.CONTENT.value),
+                Identifier(TableField.METADATA.value),
+            ]
+
+            df_keyword_select = db_handler.dispatch_select(
+                keyword_query_obj, keyword_search_conditions, keyword_search_args=keyword_search_args
+            )
+            df_keyword_select = self.addapt_result_columns(df_keyword_select)
+            logger.debug(f"Keyword search returned {len(df_keyword_select)} rows")
+            logger.debug(f"Columns in keyword search response: {df_keyword_select.columns.tolist()}")
+            # ensure df and df_keyword_select have exactly the same columns
+            if not df_keyword_select.empty:
+                if set(df.columns) != set(df_keyword_select.columns):
+                    raise ValueError(
+                        f"Keyword search returned different columns: {df_keyword_select.columns} "
+                        f"than expected: {df.columns}"
+                    )
+                df = pd.concat([df, df_keyword_select], ignore_index=True)
+                # if chunk_id column exists remove duplicates based on chunk_id
+                if "chunk_id" in df.columns:
+                    df = df.drop_duplicates(subset=["chunk_id"])
+
         # Check if we have a rerank_model configured in KB params
         df = self.add_relevance(df, query_text, relevance_threshold, disable_reranking)
 
@@ -736,8 +811,7 @@ class KnowledgeBaseTable:
         if model_id is None:
             # call litellm handler
             messages = list(df[TableField.CONTENT.value])
-            embedding_params = copy.deepcopy(config.get("default_embedding_model", {}))
-            embedding_params.update(self._kb.params["embedding_model"])
+            embedding_params = get_model_params(self._kb.params.get("embedding_model", {}), "default_embedding_model")
             results = self.call_litellm_embedding(self.session, embedding_params, messages)
             results = [[val] for val in results]
             return pd.DataFrame(results, columns=[TableField.EMBEDDINGS.value])
@@ -783,6 +857,9 @@ class KnowledgeBaseTable:
     def call_litellm_embedding(session, model_params, messages):
         args = copy.deepcopy(model_params)
 
+        if "model_name" not in args:
+            raise ValueError("'model_name' must be provided for embedding model")
+
         llm_model = args.pop("model_name")
         engine = args.pop("provider")
 
@@ -936,6 +1013,24 @@ class KnowledgeBaseController:
         # fill variables
         params = variables_controller.fill_parameters(params)
 
+        try:
+            KnowledgeBaseInputParams.model_validate(params)
+        except ValidationError as e:
+            problems = []
+            for error in e.errors():
+                parameter = ".".join([str(i) for i in error["loc"]])
+                param_type = error["type"]
+                if param_type == "extra_forbidden":
+                    msg = f"Parameter '{parameter}' is not allowed"
+                else:
+                    msg = f"Error in '{parameter}' (type: {param_type}): {error['msg']}. Input: {repr(error['input'])}"
+                problems.append(msg)
+
+            msg = "\n".join(problems)
+            if len(problems) > 1:
+                msg = "\n" + msg
+            raise ValueError(f"Problem with knowledge base parameters: {msg}")
+
         # Validate preprocessing config first if provided
         if preprocessing_config is not None:
             PreprocessingConfig(**preprocessing_config)  # Validate before storing
@@ -961,24 +1056,6 @@ class KnowledgeBaseController:
                 return kb
             raise EntityExistsError("Knowledge base already exists", name)
 
-        embedding_params = copy.deepcopy(config.get("default_embedding_model", {}))
-
-        # Legacy
-        # model_name = None
-        # model_project = project
-        # if embedding_model:
-        #     model_name = embedding_model.parts[-1]
-        #     if len(embedding_model.parts) > 1:
-        #         model_project = self.session.database_controller.get_project(embedding_model.parts[-2])
-
-        # elif "embedding_model" in params:
-        #     if isinstance(params["embedding_model"], str):
-        #         # it is model name
-        #         model_name = params["embedding_model"]
-        #     else:
-        #         # it is params for model
-        #         embedding_params.update(params["embedding_model"])
-
         embedding_params = get_model_params(params.get("embedding_model", {}), "default_embedding_model")
 
         # if model_name is None:  # Legacy
@@ -1009,7 +1086,11 @@ class KnowledgeBaseController:
         if reranking_model_params:
             # Get reranking model from params.
             # This is called here to check validaity of the parameters.
-            get_reranking_model_from_params(reranking_model_params)
+            try:
+                reranker = get_reranking_model_from_params(reranking_model_params)
+                reranker.get_scores("test", ["test"])
+            except (ValueError, RuntimeError) as e:
+                raise RuntimeError(f"Problem with reranker config: {e}")
 
         # search for the vector database table
         if storage is None:
@@ -1102,15 +1183,33 @@ class KnowledgeBaseController:
         except PredictorRecordNotFound:
             pass
 
-        if params.get("provider", None) not in ("openai", "azure_openai"):
+        if "provider" not in params:
+            raise ValueError("'provider' parameter is required for embedding model")
+
+        # check available providers
+        avail_providers = ("openai", "azure_openai", "bedrock", "gemini", "google")
+        if params["provider"] not in avail_providers:
+            raise ValueError(
+                f"Wrong embedding provider: {params['provider']}. Available providers: {', '.join(avail_providers)}"
+            )
+
+        if params["provider"] not in ("openai", "azure_openai"):
             # try use litellm
-            KnowledgeBaseTable.call_litellm_embedding(self.session, params, ["test"])
+            try:
+                KnowledgeBaseTable.call_litellm_embedding(self.session, params, ["test"])
+            except Exception as e:
+                raise RuntimeError(f"Problem with embedding model config: {e}")
             return
 
         if "provider" in params:
             engine = params.pop("provider").lower()
 
-        api_key = get_api_key(engine, params, strict=False) or params.pop("api_key")
+        api_key = get_api_key(engine, params, strict=False)
+        if api_key is None:
+            if "api_key" in params:
+                params.pop("api_key")
+            else:
+                raise ValueError("'api_key' parameter is required for embedding model")
 
         if engine == "azure_openai":
             engine = "openai"