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

mindsdb/integrations/handlers/bedrock_handler/bedrock_handler.py

@@ -0,0 +1,328 @@
+import numpy as np
+import pandas as pd
+from typing import Text, Tuple, Dict, List, Optional, Any
+
+from mindsdb.utilities import log
+
+from mindsdb.integrations.libs.base import BaseMLEngine
+from mindsdb.integrations.libs.llm.utils import get_completed_prompts
+from mindsdb.integrations.libs.api_handler_exceptions import MissingConnectionParams
+from mindsdb.integrations.handlers.bedrock_handler.utilities import create_amazon_bedrock_client
+from mindsdb.integrations.handlers.bedrock_handler.settings import AmazonBedrockHandlerEngineConfig, AmazonBedrockHandlerModelConfig
+
+
+logger = log.getLogger(__name__)
+
+
+class AmazonBedrockHandler(BaseMLEngine):
+    """
+    This handler handles connection and inference with the Amazon Bedrock API.
+    """
+
+    name = 'bedrock'
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.generative = True
+
+    def create_engine(self, connection_args: Dict) -> None:
+        """
+        Validates the AWS credentials provided on creation of an engine.
+
+        Args:
+            connection_args (Dict): The parameters of the engine.
+
+        Raises:
+            Exception: If the handler is not configured with valid API credentials.
+        """
+        connection_args = {k.lower(): v for k, v in connection_args.items()}
+        AmazonBedrockHandlerEngineConfig(**connection_args)
+
+    def create(self, target, args: Dict = None, **kwargs: Any) -> None:
+        """
+        Creates a model by validating the model configuration and saving it to the storage.
+
+        Args:
+            target (Text): The target column name.
+            args (Dict): The parameters of the model.
+            kwargs (Any): Other keyword arguments.
+
+        Raises:
+            Exception: If the model is not configured with valid parameters.
+
+        Returns:
+            None
+        """
+        if 'using' not in args:
+            raise MissingConnectionParams("Amazon Bedrock engine requires a USING clause! Refer to its documentation for more details.")
+        else:
+            model_args = args['using']
+            # Replace 'model_id' with 'id' to match the Amazon Bedrock handler model configuration.
+            # This is done to avoid the Pydantic warning regarding conflicts with the protected 'model_' namespace.
+            if 'model_id' in model_args:
+                model_args['id'] = model_args['model_id']
+                del model_args['model_id']
+
+            handler_model_config = AmazonBedrockHandlerModelConfig(**model_args, connection_args=self.engine_storage.get_connection_args())
+
+            # Save the model configuration to the storage.
+            handler_model_params = handler_model_config.model_dump()
+            logger.info(f"Saving model configuration to storage: {handler_model_params}")
+
+            args['target'] = target
+            args['handler_model_params'] = handler_model_params
+            self.model_storage.json_set('args', args)
+
+    def predict(self, df: Optional[pd.DataFrame] = None, args: Optional[Dict] = None) -> pd.DataFrame:
+        """
+        Makes predictions using a model by invoking the Amazon Bedrock API.
+
+        Args:
+            df (pd.DataFrame): The input data to invoke the model with.
+            args (Dict): The parameters passed when making predictions.
+
+        Raises:
+            ValueError: If the input data does not match the configuration of the model.
+
+        Returns:
+            pd.DataFrame: The input data with the predicted values in a new column.
+        """
+        args = self.model_storage.json_get('args')
+        handler_model_params = args['handler_model_params']
+        mode = handler_model_params['mode']
+        model_id = handler_model_params['id']
+        inference_config = handler_model_params.get('inference_config')
+        target = args['target']
+
+        if mode == 'default':
+            prompts, empty_prompt_ids = self._prepare_data_for_default_mode(df, args)
+            predictions = self._predict_for_default_mode(model_id, prompts, inference_config)
+
+            # Fill the empty predictions with None.
+            for i in sorted(empty_prompt_ids):
+                predictions.insert(i, None)
+
+        elif mode == 'conversational':
+            prompt, total_questions = self._prepare_data_for_conversational_mode(df, args)
+            prediction = self._predict_for_conversational_mode(model_id, prompt, inference_config)
+
+            # Create a list of None values for the total number of questions and replace the last one with the prediction.
+            predictions = [None] * total_questions
+            predictions[-1] = prediction
+
+        pred_df = pd.DataFrame(predictions, columns=[target])
+        return pred_df
+
+    def _prepare_data_for_default_mode(self, df: pd.DataFrame, args: Dict) -> List[Dict]:
+        """
+        Prepares the input data for the default mode of the Amazon Bedrock handler.
+        A separate prompt is prepared for each question.
+
+        Args:
+            df (pd.DataFrame): The input data to invoke the model with.
+            args (Dict): The parameters of the model.
+
+        Returns:
+            List[Dict]: The prepared prompts for invoking the Amazon Bedrock API. The model will be invoked for each prompt.
+        """
+        handler_model_params = args['handler_model_params']
+        question_column = handler_model_params.get('question_column')
+        context_column = handler_model_params.get('context_column')
+        prompt_template = handler_model_params.get('prompt_template')
+
+        if question_column is not None:
+            questions, empty_prompt_ids = self._prepare_data_with_question_and_context_columns(
+                df,
+                question_column,
+                context_column
+            )
+
+        elif prompt_template is not None:
+            questions, empty_prompt_ids = self._prepare_data_with_prompt_template(df, prompt_template)
+
+        # Prepare the prompts.
+        questions = [question for i, question in enumerate(questions) if i not in empty_prompt_ids]
+        prompts = [{"role": "user", "content": [{"text": question}]} for question in questions]
+
+        return prompts, empty_prompt_ids
+
+    def _prepare_data_for_conversational_mode(self, df: pd.DataFrame, args: Dict) -> Tuple[List[Dict], int]:
+        """
+        Prepares the input data for the conversational mode of the Amazon Bedrock handler.
+        A single prompt is prepared for all the questions.
+
+        Args:
+            df (pd.DataFrame): The input data to invoke the model with.
+            args (Dict): The parameters of the model.
+
+        Returns:
+            Tuple[List[Dict], int]: The prepared prompt for invoking the Amazon Bedrock API and the total number of questions.
+            The model will be invoked once using this prompt which contains all the questions.
+            The total number of questions is used to produce the final list of predictions.
+        """
+        handler_model_params = args['handler_model_params']
+        question_column = handler_model_params.get('question_column')
+        context_column = handler_model_params.get('context_column')
+        prompt_template = handler_model_params.get('prompt_template')
+
+        if question_column is not None:
+            questions, empty_prompt_ids = self._prepare_data_with_question_and_context_columns(
+                df,
+                question_column,
+                context_column
+            )
+
+        if prompt_template is not None:
+            questions, empty_prompt_ids = self._prepare_data_with_prompt_template(df, prompt_template)
+
+        # Prepare the prompts.
+        questions = [question for i, question in enumerate(questions) if i not in empty_prompt_ids]
+        prompt = [{"role": "user", "content": [{"text": question} for question in questions]}]
+
+        # Get the total number of questions; including the empty ones.
+        total_questions = len(df)
+
+        return prompt, total_questions
+
+    def _prepare_data_with_question_and_context_columns(self, df: pd.DataFrame, question_column: Text, context_column: Text = None) -> Tuple[List[Text], List[int]]:
+        """
+        Prepares the input data with question and context columns.
+
+        Args:
+            df (pd.DataFrame): The input data to invoke the model with.
+            question_column (Text): The column containing the questions.
+            context_column (Text): The column containing the context.
+
+        Returns:
+            Tuple[List[Text], List[int]]: The questions to build the prompts for invoking the Amazon Bedrock API and the empty prompt IDs.
+        """
+        if question_column not in df.columns:
+            raise ValueError(f"Column {question_column} not found in the dataframe!")
+
+        if context_column and context_column not in df.columns:
+            raise ValueError(f"Column {context_column} not found in the dataframe!")
+
+        if context_column:
+            empty_prompt_ids = np.where(
+                df[[context_column, question_column]]
+                .isna()
+                .all(axis=1)
+                .values
+            )[0]
+            contexts = list(df[context_column].apply(lambda x: str(x)))
+            questions_without_context = list(df[question_column].apply(lambda x: str(x)))
+
+            questions = [
+                f'Context: {c}\nQuestion: {q}\nAnswer: '
+                for c, q in zip(contexts, questions_without_context)
+            ]
+
+        else:
+            questions = list(df[question_column].apply(lambda x: str(x)))
+            empty_prompt_ids = np.where(
+                df[[question_column]].isna().all(axis=1).values
+            )[0]
+
+        return questions, empty_prompt_ids
+
+    def _prepare_data_with_prompt_template(self, df: pd.DataFrame, prompt_template: Text) -> Tuple[List[Text], List[int]]:
+        """
+        Prepares the input data with a prompt template.
+
+        Args:
+            df (pd.DataFrame): The input data to invoke the model with.
+            prompt_template (Text): The base prompt template to use.
+
+        Returns:
+            Tuple[List[Text], List[int]]: The questions to build the prompts for invoking the Amazon Bedrock API and the empty prompt IDs.
+        """
+        questions, empty_prompt_ids = get_completed_prompts(prompt_template, df)
+
+        return questions, empty_prompt_ids
+
+    def _predict_for_default_mode(self, model_id: Text, prompts: List[Text], inference_config: Dict) -> List[Text]:
+        """
+        Makes predictions for the default mode of the Amazon Bedrock handler using the prepared prompts.
+
+        Args:
+            model_id (Text): The ID of the model in Amazon Bedrock.
+            prompts (List[Text]): The prepared prompts for invoking the Amazon Bedrock API.
+            inference_config (Dict): The inference configuration supported by the Amazon Bedrock API.
+
+        Returns:
+            List[Text]: The predictions made by the Amazon Bedrock API.
+        """
+        predictions = []
+        bedrock_runtime_client = create_amazon_bedrock_client(
+            'bedrock-runtime',
+            **self.engine_storage.get_connection_args()
+        )
+
+        for prompt in prompts:
+            response = bedrock_runtime_client.converse(
+                modelId=model_id,
+                messages=[prompt],
+                inferenceConfig=inference_config
+            )
+            predictions.append(
+                response["output"]["message"]["content"][0]["text"]
+            )
+
+        return predictions
+
+    def _predict_for_conversational_mode(self, model_id: Text, prompt: List[Text], inference_config: Dict) -> Text:
+        """
+        Makes a prediction for the conversational mode of the Amazon Bedrock handler using the prepared prompt.
+
+        Args:
+            model_id (Text): The ID of the model in Amazon Bedrock.
+            prompts (List[Text]): Prepared prompts for invoking the Amazon Bedrock API.
+            inference_config (Dict): Inference configuration supported by the Amazon Bedrock API.
+
+        Returns:
+            Text: The prediction made by the Amazon Bedrock API.
+        """
+        bedrock_runtime_client = create_amazon_bedrock_client(
+            'bedrock-runtime',
+            **self.engine_storage.get_connection_args()
+        )
+
+        response = bedrock_runtime_client.converse(
+            modelId=model_id,
+            messages=prompt,
+            inferenceConfig=inference_config
+        )
+
+        return response["output"]["message"]["content"][0]["text"]
+
+    def describe(self, attribute: Optional[Text] = None) -> pd.DataFrame:
+        """
+        Get the metadata or arguments of a model.
+
+        Args:
+            attribute (Optional[Text]): Attribute to describe. Can be 'args' or 'metadata'.
+
+        Returns:
+            pd.DataFrame: Model metadata or model arguments.
+        """
+        args = self.model_storage.json_get('args')
+
+        if attribute == 'args':
+            del args['handler_model_params']
+            return pd.DataFrame(args.items(), columns=['key', 'value'])
+
+        elif attribute == 'metadata':
+            model_id = args['handler_model_params']['id']
+            try:
+                bedrock_client = create_amazon_bedrock_client(
+                    'bedrock',
+                    **self.engine_storage.get_connection_args()
+                )
+                meta = bedrock_client.get_foundation_model(modelIdentifier=model_id)['modelDetails']
+            except Exception as e:
+                meta = {'error': str(e)}
+            return pd.DataFrame(dict(meta).items(), columns=['key', 'value'])
+
+        else:
+            tables = ['args', 'metadata']
+            return pd.DataFrame(tables, columns=['tables'])

mindsdb/integrations/handlers/bedrock_handler/icon.svg

@@ -0,0 +1,9 @@
+<svg width="40" height="40" viewBox="0 0 40 40" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M7.54482 27.2109V32.3273L16.0863 37.5229L20.453 35.0211V4.91116L16.4576 2.62195L7.54482 7.72844V13.5958M7.54482 27.2109L3.13256 24.5269V16.1235L7.54482 13.5958M7.54482 27.2109L11.3 24.61M7.54482 13.5958L11.7694 15.7386M11.7271 5.36272V10.1059M11.7694 15.7386V19.1182M11.7694 15.7386L16.0877 13.4855V9.54261M11.7694 19.1182L9.51629 21.0896M11.7694 19.1182L14.6795 21.2304M3.0387 20.3855L6.84075 18.1794M20.3122 24.7978L11.5816 29.6325M12.0773 35.0676L15.0081 33.106M20.4197 13.3184H28.6673V9.44875M20.4197 18.1803H33.1265M20.4197 22.5447H29.7469L31.8122 24.61M20.3592 27.0978H26.5551V30.7121M30.8735 7.43037C30.8735 8.67471 29.8648 9.68344 28.6204 9.68344C27.3761 9.68344 26.3674 8.67471 26.3674 7.43037C26.3674 6.18604 27.3761 5.1773 28.6204 5.1773C29.8648 5.1773 30.8735 6.18604 30.8735 7.43037ZM37.8674 18.2733C37.8674 19.5176 36.8586 20.5263 35.6143 20.5263C34.37 20.5263 33.3612 19.5176 33.3612 18.2733C33.3612 17.0289 34.37 16.0202 35.6143 16.0202C36.8586 16.0202 37.8674 17.0289 37.8674 18.2733ZM35.5674 26.3937C35.5674 27.638 34.5586 28.6468 33.3143 28.6468C32.07 28.6468 31.0612 27.638 31.0612 26.3937C31.0612 25.1494 32.07 24.1406 33.3143 24.1406C34.5586 24.1406 35.5674 25.1494 35.5674 26.3937ZM28.949 33.0121C28.949 34.2564 27.9403 35.2651 26.6959 35.2651C25.4516 35.2651 24.4428 34.2564 24.4428 33.0121C24.4428 31.7677 25.4516 30.759 26.6959 30.759C27.9403 30.759 28.949 31.7677 28.949 33.0121Z" stroke="url(#paint0_linear_1571_188)" stroke-width="1.4" stroke-miterlimit="10"/>
+<defs>
+<linearGradient id="paint0_linear_1571_188" x1="3" y1="40.5" x2="34" y2="5" gradientUnits="userSpaceOnUse">
+<stop stop-color="#A1DEFC"/>
+<stop offset="1" stop-color="#725AF7"/>
+</linearGradient>
+</defs>
+</svg>

mindsdb/integrations/handlers/bedrock_handler/requirements.txt

@@ -0,0 +1 @@
+pydantic-settings >= 2.1.0

mindsdb/integrations/handlers/bedrock_handler/settings.py

@@ -0,0 +1,287 @@
+import textwrap
+from pydantic_settings import BaseSettings
+from botocore.exceptions import ClientError
+from typing import Text, List, Dict, Optional, Any, ClassVar
+from pydantic import BaseModel, Field, model_validator, field_validator
+
+from mindsdb.integrations.handlers.bedrock_handler.utilities import create_amazon_bedrock_client
+from mindsdb.integrations.utilities.handlers.validation_utilities import ParameterValidationUtilities
+
+
+class AmazonBedrockHandlerSettings(BaseSettings):
+    """
+    Settings for Amazon Bedrock handler.
+
+    Attributes
+    ----------
+    DEFAULT_MODE : Text
+        The default mode for the handler.
+
+    SUPPORTED_MODES : List
+        List of supported modes for the handler.
+
+    DEFAULT_TEXT_MODEL_ID : Text
+        The default model ID to use for text generation. This will be the default model ID for the default and conversational modes.
+    """
+    # Modes.
+    # TODO: Add other modes.
+    DEFAULT_MODE: ClassVar[Text] = 'default'
+    SUPPORTED_MODES: ClassVar[List] = ['default', 'conversational']
+
+    # TODO: Set the default model ID for other modes.
+    # Model IDs.
+    DEFAULT_TEXT_MODEL_ID: ClassVar[Text] = 'amazon.titan-text-premier-v1:0'
+
+
+class AmazonBedrockHandlerEngineConfig(BaseModel):
+    """
+    Configuration model for engines created via the Amazon Bedrock handler.
+
+    Attributes
+    ----------
+    aws_access_key_id : Text
+        The AWS access key ID.
+
+    aws_secret_access_key : Text
+        The AWS secret access key.
+
+    region_name : Text
+        The AWS region name.
+
+    aws_session_token : Text, Optional
+        The AWS session token. Optional, but required for temporary security credentials.
+    """
+    aws_access_key_id: Text
+    aws_secret_access_key: Text
+    region_name: Text
+    aws_session_token: Optional[Text] = None
+
+    class Config:
+        extra = "forbid"
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_if_params_contain_typos(cls, values: Any) -> Any:
+        """
+        Checks if there are any typos in the parameters.
+
+        Args:
+            values (Any): The parameters provided when creating an engine via the Amazon Bedrock handler.
+
+        Raises:
+            ValueError: If there are any typos in the parameters.
+        """
+        ParameterValidationUtilities.validate_parameter_spelling(cls, values)
+
+        return values
+
+    @model_validator(mode="after")
+    @classmethod
+    def check_access_to_amazon_bedrock(cls, model: BaseModel) -> BaseModel:
+        """
+        Checks if the AWS credentials provided are valid and Amazon Bedrock is accessible.
+
+        Args:
+            model (BaseModel): The parameters provided when creating an engine via the Amazon Bedrock handler.
+
+        Raises:
+            ValueError: If the AWS credentials are invalid or Amazon Bedrock is not accessible.
+        """
+        bedrock_client = create_amazon_bedrock_client(
+            "bedrock",
+            model.aws_access_key_id,
+            model.aws_secret_access_key,
+            model.region_name,
+            model.aws_session_token
+        )
+
+        try:
+            bedrock_client.list_foundation_models()
+        except ClientError as e:
+            raise ValueError(f"Invalid Amazon Bedrock credentials: {e}!")
+
+        return model
+
+
+class AmazonBedrockHandlerModelConfig(BaseModel):
+    """
+    Configuration model for models created via the Amazon Bedrock handler.
+
+    Attributes
+    ----------
+    id : Text
+        The ID of the model in Amazon Bedrock.
+
+    mode : Optional[Text]
+        The mode to run the handler model in. The default mode and the supported modes are defined in the AmazonBedrockHandlerSettings class.
+
+    prompt_template : Optional[Text]
+        The base template for prompts with placeholders.
+
+    question_column : Optional[Text]
+        The column name for questions to be asked.
+
+    context_column : Optional[Text]
+        The column name for context to be provided with the questions.
+
+    temperature : Optional[float]
+        The setting for the randomness in the responses generated by the model.
+
+    top_p : Optional[float]
+        The setting for the probability of the tokens in the responses generated by the model.
+
+    max_tokens : Optional[int]
+        The maximum number of tokens to generate in the responses.
+
+    stop : Optional[List[Text]]
+        The list of sequences to stop the generation of tokens in the responses.
+
+    connection_args : Dict
+        The connection arguments passed required to connect to Amazon Bedrock. These are AWS credentials provided when creating the engine.
+    """
+    # User-provided Handler Model Prameters: These are parameters specific to the MindsDB handler for Amazon Bedrock provided by the user.
+    id: Text = Field(None)
+    mode: Optional[Text] = Field(AmazonBedrockHandlerSettings.DEFAULT_MODE)
+    prompt_template: Optional[Text] = Field(None)
+    question_column: Optional[Text] = Field(None)
+    context_column: Optional[Text] = Field(None)
+
+    # Amazon Bedrock Model Parameters: These are parameters specific to the models in Amazon Bedrock. They are provided by the user.
+    temperature: Optional[float] = Field(None, bedrock_model_param=True, bedrock_model_param_name='temperature')
+    top_p: Optional[float] = Field(None, bedrock_model_param=True, bedrock_model_param_name='topP')
+    max_tokens: Optional[int] = Field(None, bedrock_model_param=True, bedrock_model_param_name='maxTokens')
+    stop: Optional[List[Text]] = Field(None, bedrock_model_param=True, bedrock_model_param_name='stopSequences')
+
+    # System-provided Handler Model Parameters: These are parameters specific to the MindsDB handler for Amazon Bedrock provided by the system.
+    connection_args: Dict = Field(None, exclude=True)
+
+    class Config:
+        extra = "forbid"
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_if_params_contain_typos(cls, values: Any) -> Any:
+        """
+        Checks if there are any typos in the parameters.
+
+        Args:
+            values (Any): The parameters provided when creating a model via the Amazon Bedrock handler.
+
+        Raises:
+            ValueError: If there are any typos in the parameters.
+        """
+        ParameterValidationUtilities.validate_parameter_spelling(cls, values)
+
+        return values
+
+    @field_validator("mode")
+    @classmethod
+    def check_if_mode_is_supported(cls, mode: Text) -> Text:
+        """
+        Checks if the mode provided is supported.
+
+        Args:
+            mode (Text): The mode to run the handler model in.
+
+        Raises:
+            ValueError: If the mode provided is not supported.
+        """
+        if mode not in AmazonBedrockHandlerSettings.SUPPORTED_MODES:
+            raise ValueError(f"Mode {mode} is not supported. The supported modes are {''.join(AmazonBedrockHandlerSettings.SUPPORTED_MODES)}!")
+
+        return mode
+
+    @model_validator(mode="after")
+    @classmethod
+    def check_if_model_id_is_valid_and_correct_for_mode(cls, model: BaseModel) -> BaseModel:
+        """
+        Checks if the model ID and the parameters provided for the model are valid.
+        If a model ID is not provided, the default model ID for that mode will be used.
+
+        Args:
+            values (Any): The parameters provided when creating a model via the Amazon Bedrock handler.
+
+        Raises:
+            ValueError: If the model ID provided is invalid or the parameters provided are invalid for the chosen model.
+        """
+        # TODO: Set the default model ID for other modes.
+        if model.id is None:
+            if model.mode in ['default', 'conversational']:
+                model.id = AmazonBedrockHandlerSettings.DEFAULT_TEXT_MODEL_ID
+
+        bedrock_client = create_amazon_bedrock_client(
+            "bedrock",
+            **model.connection_args
+        )
+
+        try:
+            # Check if the model ID is valid and accessible.
+            response = bedrock_client.get_foundation_model(modelIdentifier=model.id)
+        except ClientError as e:
+            raise ValueError(f"Invalid Amazon Bedrock model ID: {e}!")
+
+        # Check if the model is suitable for the mode provided.
+        if model.mode in ['default', 'conversational']:
+            if 'TEXT' not in response['modelDetails']['outputModalities']:
+                raise ValueError(f"The models used for the {model.mode} should support text generation!")
+
+        return model
+
+    @model_validator(mode="after")
+    @classmethod
+    def check_if_params_are_valid_for_mode(cls, model: BaseModel) -> BaseModel:
+        """
+        Checks if the parameters required for the chosen mode provided are valid.
+
+        Args:
+            model (BaseModel): The parameters provided when creating a model via the Amazon Bedrock handler.
+
+        Raises:
+            ValueError: If the parameters provided are invalid for the mode provided.
+        """
+        # If the mode is default, one of the following need to be provided:
+        # 1. prompt_template.
+        # 2. question_column with an optional context_column.
+        # TODO: Find the other possible parameters/combinations for the default mode.
+        if model.mode in ['default', 'conversational']:
+            error_message = textwrap.dedent(
+                f"""\
+                    For the {model.mode} mode, one of the following need to be provided:
+                        1) A `prompt_template`
+                        2) A `question_column` and an optional `context_column`
+                """
+            )
+            if model.prompt_template is None and model.question_column is None:
+                raise ValueError(error_message)
+
+            if model.prompt_template is not None and model.question_column is not None:
+                raise ValueError(error_message)
+
+            if model.context_column is not None and model.question_column is None:
+                raise ValueError(error_message)
+
+        # TODO: Add validations for other modes.
+
+        return model
+
+    def model_dump(self) -> Dict:
+        """
+        Dumps the model configuration to a dictionary.
+
+        Returns:
+            Dict: The configuration of the model.
+        """
+        bedrock_model_param_names = [val.get("bedrock_model_param_name") for key, val in self.model_json_schema(mode='serialization')['properties'].items() if val.get("bedrock_model_param")]
+        bedrock_model_params = [key for key, val in self.model_json_schema(mode='serialization')['properties'].items() if val.get("bedrock_model_param")]
+
+        handler_model_params = [key for key, val in self.model_json_schema(mode='serialization')['properties'].items() if not val.get("bedrock_model_param")]
+
+        inference_config = {}
+        for index, key in enumerate(bedrock_model_params):
+            if getattr(self, key) is not None:
+                inference_config[bedrock_model_param_names[index]] = getattr(self, key)
+
+        return {
+            "inference_config": inference_config,
+            **{key: getattr(self, key) for key in handler_model_params}
+        }

mindsdb/integrations/handlers/bedrock_handler/utilities.py

@@ -0,0 +1,46 @@
+import boto3
+from typing import Text, Optional
+
+
+def create_amazon_bedrock_client(
+    client: Text,
+    aws_access_key_id: Text,
+    aws_secret_access_key: Text,
+    region_name: Text,
+    aws_session_token: Optional[Text] = None,
+) -> boto3.client:
+    """
+    Create an Amazon Bedrock client via boto3.
+
+    Parameters
+    ----------
+    client : Text
+        The type of client to create. It can be 'bedrock' or 'bedrock-runtime'.
+
+    aws_access_key_id : Text
+        The AWS access key ID.
+
+    aws_secret_access_key : Text
+        The AWS secret access key.
+
+    region_name : Text
+        The AWS region name.
+
+    aws_session_token : Text, Optional
+        The AWS session token. Optional, but required for temporary security credentials.
+
+    Returns
+    -------
+    boto3.client
+        Amazon Bedrock client.
+    """
+    if client not in ["bedrock", "bedrock-runtime"]:
+        raise ValueError("The client must be 'bedrock' or 'bedrock-runtime'")
+
+    return boto3.client(
+        client,
+        aws_access_key_id=aws_access_key_id,
+        aws_secret_access_key=aws_secret_access_key,
+        region_name=region_name,
+        aws_session_token=aws_session_token,
+    )

mindsdb/integrations/handlers/bigquery_handler/__about__.py

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