Upload folder using huggingface_hub

agent.py

@@ -0,0 +1,313 @@
+import boto3
+import json
+import time
+import zipfile
+from io import BytesIO
+
+iam_client = boto3.client('iam')
+sts_client = boto3.client('sts')
+session = boto3.session.Session()
+region = session.region_name
+account_id = sts_client.get_caller_identity()["Account"]
+dynamodb_client = boto3.client('dynamodb')
+dynamodb_resource = boto3.resource('dynamodb')
+lambda_client = boto3.client('lambda')
+bedrock_agent_client = boto3.client('bedrock-agent')
+
+
+def create_dynamodb(table_name):
+    table = dynamodb_resource.create_table(
+        TableName=table_name,
+        KeySchema=[
+            {
+                'AttributeName': 'booking_id',
+                'KeyType': 'HASH'
+            }
+        ],
+        AttributeDefinitions=[
+            {
+                'AttributeName': 'booking_id',
+                'AttributeType': 'S'
+            }
+        ],
+        BillingMode='PAY_PER_REQUEST'  # Use on-demand capacity mode
+    )
+
+    # Wait for the table to be created
+    print(f'Creating table {table_name}...')
+    table.wait_until_exists()
+    print(f'Table {table_name} created successfully!')
+    return
+
+
+def create_lambda(lambda_function_name, lambda_iam_role):
+    # add to function
+
+    # Package up the lambda function code
+    s = BytesIO()
+    z = zipfile.ZipFile(s, 'w')
+    z.write("lambda_function.py")
+    z.close()
+    zip_content = s.getvalue()
+
+    # Create Lambda Function
+    lambda_function = lambda_client.create_function(
+        FunctionName=lambda_function_name,
+        Runtime='python3.12',
+        Timeout=60,
+        Role=lambda_iam_role['Role']['Arn'],
+        Code={'ZipFile': zip_content},
+        Handler='lambda_function.lambda_handler'
+    )
+    return lambda_function
+
+
+def create_lambda_role(agent_name, dynamodb_table_name):
+    lambda_function_role = f'{agent_name}-lambda-role'
+    dynamodb_access_policy_name = f'{agent_name}-dynamodb-policy'
+    # Create IAM Role for the Lambda function
+    try:
+        assume_role_policy_document = {
+            "Version": "2012-10-17",
+            "Statement": [
+                {
+                    "Effect": "Allow",
+                    "Principal": {
+                        "Service": "lambda.amazonaws.com"
+                    },
+                    "Action": "sts:AssumeRole"
+                }
+            ]
+        }
+
+        assume_role_policy_document_json = json.dumps(assume_role_policy_document)
+
+        lambda_iam_role = iam_client.create_role(
+            RoleName=lambda_function_role,
+            AssumeRolePolicyDocument=assume_role_policy_document_json
+        )
+
+        # Pause to make sure role is created
+        time.sleep(10)
+    except iam_client.exceptions.EntityAlreadyExistsException:
+        lambda_iam_role = iam_client.get_role(RoleName=lambda_function_role)
+
+    # Attach the AWSLambdaBasicExecutionRole policy
+    iam_client.attach_role_policy(
+        RoleName=lambda_function_role,
+        PolicyArn='arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole'
+    )
+
+    # Create a policy to grant access to the DynamoDB table
+    dynamodb_access_policy = {
+        "Version": "2012-10-17",
+        "Statement": [
+            {
+                "Effect": "Allow",
+                "Action": [
+                    "dynamodb:GetItem",
+                    "dynamodb:PutItem",
+                    "dynamodb:DeleteItem"
+                ],
+                "Resource": "arn:aws:dynamodb:{}:{}:table/{}".format(
+                    region, account_id, dynamodb_table_name
+                )
+            }
+        ]
+    }
+
+    # Create the policy
+    dynamodb_access_policy_json = json.dumps(dynamodb_access_policy)
+    dynamodb_access_policy_response = iam_client.create_policy(
+        PolicyName=dynamodb_access_policy_name,
+        PolicyDocument=dynamodb_access_policy_json
+    )
+
+    # Attach the policy to the Lambda function's role
+    iam_client.attach_role_policy(
+        RoleName=lambda_function_role,
+        PolicyArn=dynamodb_access_policy_response['Policy']['Arn']
+    )
+    return lambda_iam_role
+
+
+def create_agent_role_and_policies(agent_name, agent_foundation_model, kb_id=None):
+    agent_bedrock_allow_policy_name = f"{agent_name}-ba"
+    agent_role_name = f'AmazonBedrockExecutionRoleForAgents_{agent_name}'
+    # Create IAM policies for agent
+    statements = [
+        {
+            "Sid": "AmazonBedrockAgentBedrockFoundationModelPolicy",
+            "Effect": "Allow",
+            "Action": "bedrock:InvokeModel",
+            "Resource": [
+                f"arn:aws:bedrock:{region}::foundation-model/{agent_foundation_model}"
+            ]
+        }
+    ]
+    # add Knowledge Base retrieve and retrieve and generate permissions if agent has KB attached to it
+    if kb_id:
+        statements.append(
+            {
+                "Sid": "QueryKB",
+                "Effect": "Allow",
+                "Action": [
+                    "bedrock:Retrieve",
+                    "bedrock:RetrieveAndGenerate"
+                ],
+                "Resource": [
+                    f"arn:aws:bedrock:{region}:{account_id}:knowledge-base/{kb_id}"
+                ]
+            }
+        )
+
+    bedrock_agent_bedrock_allow_policy_statement = {
+        "Version": "2012-10-17",
+        "Statement": statements
+    }
+
+    bedrock_policy_json = json.dumps(bedrock_agent_bedrock_allow_policy_statement)
+
+    agent_bedrock_policy = iam_client.create_policy(
+        PolicyName=agent_bedrock_allow_policy_name,
+        PolicyDocument=bedrock_policy_json
+    )
+
+    # Create IAM Role for the agent and attach IAM policies
+    assume_role_policy_document = {
+        "Version": "2012-10-17",
+        "Statement": [{
+            "Effect": "Allow",
+            "Principal": {
+                "Service": "bedrock.amazonaws.com"
+            },
+            "Action": "sts:AssumeRole"
+        }]
+    }
+
+    assume_role_policy_document_json = json.dumps(assume_role_policy_document)
+    agent_role = iam_client.create_role(
+        RoleName=agent_role_name,
+        AssumeRolePolicyDocument=assume_role_policy_document_json
+    )
+
+    # Pause to make sure role is created
+    time.sleep(10)
+
+    iam_client.attach_role_policy(
+        RoleName=agent_role_name,
+        PolicyArn=agent_bedrock_policy['Policy']['Arn']
+    )
+    return agent_role
+
+
+def delete_agent_roles_and_policies(agent_name):
+    agent_bedrock_allow_policy_name = f"{agent_name}-ba"
+    agent_role_name = f'AmazonBedrockExecutionRoleForAgents_{agent_name}'
+    dynamodb_access_policy_name = f'{agent_name}-dynamodb-policy'
+    lambda_function_role = f'{agent_name}-lambda-role'
+
+    for policy in [agent_bedrock_allow_policy_name]:
+        try:
+            iam_client.detach_role_policy(
+                RoleName=agent_role_name,
+                PolicyArn=f'arn:aws:iam::{account_id}:policy/{policy}'
+            )
+        except Exception as e:
+            print(f"Could not detach {policy} from {agent_role_name}")
+            print(e)
+
+    for policy in [dynamodb_access_policy_name]:
+        try:
+            iam_client.detach_role_policy(
+                RoleName=lambda_function_role,
+                PolicyArn=f'arn:aws:iam::{account_id}:policy/{policy}'
+            )
+        except Exception as e:
+            print(f"Could not detach {policy} from {lambda_function_role}")
+            print(e)
+
+    try:
+        iam_client.detach_role_policy(
+            RoleName=lambda_function_role,
+            PolicyArn='arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole'
+        )
+    except Exception as e:
+        print(f"Could not detach AWSLambdaBasicExecutionRole from {lambda_function_role}")
+        print(e)
+
+    for role_name in [agent_role_name, lambda_function_role]:
+        try:
+            iam_client.delete_role(
+                RoleName=role_name
+            )
+        except Exception as e:
+            print(f"Could not delete role {role_name}")
+            print(e)
+
+    for policy in [agent_bedrock_allow_policy_name, dynamodb_access_policy_name]:
+        try:
+            iam_client.delete_policy(
+                PolicyArn=f'arn:aws:iam::{account_id}:policy/{policy}'
+            )
+        except Exception as e:
+            print(f"Could not delete policy {policy}")
+            print(e)
+
+
+def clean_up_resources(
+        table_name, lambda_function, lambda_function_name, agent_action_group_response, agent_functions,
+        agent_id, kb_id, alias_id
+):
+    action_group_id = agent_action_group_response['agentActionGroup']['actionGroupId']
+    action_group_name = agent_action_group_response['agentActionGroup']['actionGroupName']
+    # Delete Agent Action Group, Agent Alias, and Agent
+    try:
+        bedrock_agent_client.update_agent_action_group(
+            agentId=agent_id,
+            agentVersion='DRAFT',
+            actionGroupId= action_group_id,
+            actionGroupName=action_group_name,
+            actionGroupExecutor={
+                'lambda': lambda_function['FunctionArn']
+            },
+            functionSchema={
+                'functions': agent_functions
+            },
+            actionGroupState='DISABLED',
+        )
+        bedrock_agent_client.disassociate_agent_knowledge_base(
+            agentId=agent_id,
+            agentVersion='DRAFT',
+            knowledgeBaseId=kb_id
+        )
+        bedrock_agent_client.delete_agent_action_group(
+            agentId=agent_id,
+            agentVersion='DRAFT',
+            actionGroupId=action_group_id
+        )
+        bedrock_agent_client.delete_agent_alias(
+            agentAliasId=alias_id,
+            agentId=agent_id
+        )
+        bedrock_agent_client.delete_agent(agentId=agent_id)
+        print(f"Agent {agent_id}, Agent Alias {alias_id}, and Action Group have been deleted.")
+    except Exception as e:
+        print(f"Error deleting Agent resources: {e}")
+
+    # Delete Lambda function
+    try:
+        lambda_client.delete_function(FunctionName=lambda_function_name)
+        print(f"Lambda function {lambda_function_name} has been deleted.")
+    except Exception as e:
+        print(f"Error deleting Lambda function {lambda_function_name}: {e}")
+
+    # Delete DynamoDB table
+    try:
+        dynamodb_client.delete_table(TableName=table_name)
+        print(f"Table {table_name} is being deleted...")
+        waiter = dynamodb_client.get_waiter('table_not_exists')
+        waiter.wait(TableName=table_name)
+        print(f"Table {table_name} has been deleted.")
+    except Exception as e:
+        print(f"Error deleting table {table_name}: {e}")

aws_bedrock.py

@@ -0,0 +1,135 @@
+import json
+import typing as t
+
+from ragas.messages import AIMessage, HumanMessage
+
+
+def get_last_orchestration_value(traces: t.List[t.Dict[str, t.Any]], key: str):
+    """
+    Iterates through the traces to find the last occurrence of a specified key
+    within the orchestrationTrace.
+
+    Returns:
+        (index, value): Tuple where index is the last index at which the key was found, and value is the corresponding value, or (None, None) if not found.
+    """
+    last_index = -1
+    last_value = None
+    for i, trace in enumerate(traces):
+        orchestration = trace.get("trace", {}).get("orchestrationTrace", {})
+        if key in orchestration:
+            last_index = i
+            last_value = orchestration[key]
+    return last_index, last_value
+
+
+def extract_messages_from_model_invocation(model_inv):
+    """
+    Extracts messages from the 'text' field of the modelInvocationInput.
+    Ensures that each message's content is cast to a string.
+
+    Returns:
+        List of messages as HumanMessage or AIMessage objects.
+    """
+    messages = []
+    text_json = json.loads(model_inv.get("text", "{}"))
+    for msg in text_json.get("messages", []):
+        content_str = str(msg.get("content", ""))
+        role = msg.get("role")
+        if role == "user":
+            messages.append(HumanMessage(content=content_str))
+        elif role == "assistant":
+            messages.append(AIMessage(content=content_str))
+    return messages[:-1]
+
+
+def convert_to_ragas_messages(traces: t.List):
+    """
+    Converts a list of trace dictionaries into a list of messages.
+    It extracts messages from the last modelInvocationInput and appends
+    the finalResponse from the observation (if it occurs after the model invocation).
+
+    Returns:
+        List of HumanMessage and AIMessage objects.
+    """
+    result = []
+
+    # Get the last modelInvocationInput from the traces.
+    last_model_inv_index, last_model_inv = get_last_orchestration_value(
+        traces, "modelInvocationInput"
+    )
+    if last_model_inv is not None:
+        result.extend(extract_messages_from_model_invocation(last_model_inv))
+
+    # Get the last observation from the traces.
+    last_obs_index, last_observation = get_last_orchestration_value(
+        traces, "observation"
+    )
+    if last_observation is not None and last_obs_index > last_model_inv_index:
+        final_text = str(last_observation.get("finalResponse", {}).get("text", ""))
+        result.append(AIMessage(content=final_text))
+
+    return result
+
+
+def extract_kb_trace(traces):
+    """
+    Extracts groups of traces that follow the specific order:
+      1. An element with 'trace' -> 'orchestrationTrace' containing an 'invocationInput'
+         with invocationType == "KNOWLEDGE_BASE"
+      2. Followed (later in the list or within the same trace) by an element with an 'observation'
+         that contains 'knowledgeBaseLookupOutput'
+      3. Followed by an element with an 'observation' that contains 'finalResponse'
+
+    Returns a list of dictionaries each with keys:
+      'user_input', 'retrieved_contexts', and 'response'
+
+    This version supports multiple knowledge base invocation groups.
+    """
+    results = []
+    groups_in_progress = []  # list to keep track of groups in progress
+
+    for trace in traces:
+        orchestration = trace.get("trace", {}).get("orchestrationTrace", {})
+
+        # 1. Look for a KB invocation input.
+        inv_input = orchestration.get("invocationInput")
+        if inv_input and inv_input.get("invocationType") == "KNOWLEDGE_BASE":
+            kb_input = inv_input.get("knowledgeBaseLookupInput", {})
+            # Start a new group with the user's input text.
+            groups_in_progress.append({"user_input": kb_input.get("text")})
+
+        # 2. Process observations.
+        obs = orchestration.get("observation", {})
+        if obs:
+            # If the observation contains a KB output, assign it to the earliest group
+            # that does not yet have a 'retrieved_contexts' key.
+            if "knowledgeBaseLookupOutput" in obs:
+                for group in groups_in_progress:
+                    if "user_input" in group and "retrieved_contexts" not in group:
+                        kb_output = obs["knowledgeBaseLookupOutput"]
+                        group["retrieved_contexts"] = [
+                            retrieved.get("content", {}).get("text")
+                            for retrieved in kb_output.get("retrievedReferences", [])
+                        ]
+                        break
+
+            # 3. When we see a final response, assign it to all groups that have already
+            # received their KB output but still lack a response.
+            if "finalResponse" in obs:
+                final_text = obs["finalResponse"].get("text")
+                completed_groups = []
+                for group in groups_in_progress:
+                    if (
+                        "user_input" in group
+                        and "retrieved_contexts" in group
+                        and "response" not in group
+                    ):
+                        group["response"] = final_text
+                        completed_groups.append(group)
+                # Remove completed groups from the in-progress list and add to the final results.
+                groups_in_progress = [
+                    g for g in groups_in_progress if g not in completed_groups
+                ]
+                results.extend(completed_groups)
+
+    return results

knowledge_base.py

@@ -0,0 +1,632 @@
+import json
+import boto3
+import time
+from botocore.exceptions import ClientError
+from opensearchpy import OpenSearch, RequestsHttpConnection, AWSV4SignerAuth, RequestError
+import pprint
+from retrying import retry
+
+valid_embedding_models = ["cohere.embed-multilingual-v3", "cohere.embed-english-v3", "amazon.titan-embed-text-v1"]
+pp = pprint.PrettyPrinter(indent=2)
+
+
+def interactive_sleep(seconds: int):
+    """
+    Support functionality to induce an artificial 'sleep' to the code in order to wait for resources to be available
+    Args:
+        seconds (int): number of seconds to sleep for
+    """
+    dots = ''
+    for i in range(seconds):
+        dots += '.'
+        print(dots, end='\r')
+        time.sleep(1)
+
+
+class BedrockKnowledgeBase:
+    """
+    Support class that allows for:
+        - creation (or retrieval) of a Knowledge Base for Amazon Bedrock with all its pre-requisites
+          (including OSS, IAM roles and Permissions and S3 bucket)
+        - Ingestion of data into the Knowledge Base
+        - Deletion of all resources created
+    """
+    def __init__(
+            self,
+            kb_name,
+            kb_description=None,
+            data_bucket_name=None,
+            embedding_model="amazon.titan-embed-text-v1"
+    ):
+        """
+        Class initializer
+        Args:
+            kb_name (str): the knowledge base name
+            kb_description (str): knowledge base description
+            data_bucket_name (str): name of s3 bucket to connect with knowledge base
+            embedding_model (str): embedding model to use
+        """
+        boto3_session = boto3.session.Session()
+        self.region_name = boto3_session.region_name
+        self.iam_client = boto3_session.client('iam')
+        self.account_number = boto3.client('sts').get_caller_identity().get('Account')
+        self.suffix = str(self.account_number)[:4]
+        self.identity = boto3.client('sts').get_caller_identity()['Arn']
+        self.aoss_client = boto3_session.client('opensearchserverless')
+        self.s3_client = boto3.client('s3')
+        self.bedrock_agent_client = boto3.client('bedrock-agent')
+        credentials = boto3.Session().get_credentials()
+        self.awsauth = AWSV4SignerAuth(credentials, self.region_name, 'aoss')
+
+        self.kb_name = kb_name
+        self.kb_description = kb_description
+        if data_bucket_name is not None:
+            self.bucket_name = data_bucket_name
+        else:
+            self.bucket_name = f"{self.kb_name}-{self.suffix}"
+        if embedding_model not in valid_embedding_models:
+            valid_embeddings_str = str(valid_embedding_models)
+            raise ValueError(f"Invalid embedding model. Your embedding model should be one of {valid_embeddings_str}")
+        self.embedding_model = embedding_model
+        self.encryption_policy_name = f"bedrock-sample-rag-sp-{self.suffix}"
+        self.network_policy_name = f"bedrock-sample-rag-np-{self.suffix}"
+        self.access_policy_name = f'bedrock-sample-rag-ap-{self.suffix}'
+        self.kb_execution_role_name = f'AmazonBedrockExecutionRoleForKnowledgeBase_{self.suffix}'
+        self.fm_policy_name = f'AmazonBedrockFoundationModelPolicyForKnowledgeBase_{self.suffix}'
+        self.s3_policy_name = f'AmazonBedrockS3PolicyForKnowledgeBase_{self.suffix}'
+        self.oss_policy_name = f'AmazonBedrockOSSPolicyForKnowledgeBase_{self.suffix}'
+
+        self.vector_store_name = f'bedrock-sample-rag-{self.suffix}'
+        self.index_name = f"bedrock-sample-rag-index-{self.suffix}"
+        print("========================================================================================")
+        print(f"Step 1 - Creating or retrieving {self.bucket_name} S3 bucket for Knowledge Base documents")
+        self.create_s3_bucket()
+        print("========================================================================================")
+        print(f"Step 2 - Creating Knowledge Base Execution Role ({self.kb_execution_role_name}) and Policies")
+        self.bedrock_kb_execution_role = self.create_bedrock_kb_execution_role()
+        print("========================================================================================")
+        print(f"Step 3 - Creating OSS encryption, network and data access policies")
+        self.encryption_policy, self.network_policy, self.access_policy = self.create_policies_in_oss()
+        print("========================================================================================")
+        print(f"Step 4 - Creating OSS Collection (this step takes a couple of minutes to complete)")
+        self.host, self.collection, self.collection_id, self.collection_arn = self.create_oss()
+        # Build the OpenSearch client
+        self.oss_client = OpenSearch(
+            hosts=[{'host': self.host, 'port': 443}],
+            http_auth=self.awsauth,
+            use_ssl=True,
+            verify_certs=True,
+            connection_class=RequestsHttpConnection,
+            timeout=300
+        )
+        print("========================================================================================")
+        print(f"Step 5 - Creating OSS Vector Index")
+        self.create_vector_index()
+        print("========================================================================================")
+        print(f"Step 6 - Creating Knowledge Base")
+        self.knowledge_base, self.data_source = self.create_knowledge_base()
+        print("========================================================================================")
+
+    def create_s3_bucket(self):
+        """
+        Check if bucket exists, and if not create S3 bucket for knowledge base data source
+        """
+        try:
+            self.s3_client.head_bucket(Bucket=self.bucket_name)
+            print(f'Bucket {self.bucket_name} already exists - retrieving it!')
+        except ClientError as e:
+            print(f'Creating bucket {self.bucket_name}')
+            if self.region_name == "us-east-1":
+                self.s3_client.create_bucket(
+                    Bucket=self.bucket_name
+                )
+            else:
+                self.s3_client.create_bucket(
+                    Bucket=self.bucket_name,
+                    CreateBucketConfiguration={'LocationConstraint': self.region_name}
+                )
+
+    def create_bedrock_kb_execution_role(self):
+        """
+        Create Knowledge Base Execution IAM Role and its required policies.
+        If role and/or policies already exist, retrieve them
+        Returns:
+            IAM role
+        """
+        foundation_model_policy_document = {
+            "Version": "2012-10-17",
+            "Statement": [
+                {
+                    "Effect": "Allow",
+                    "Action": [
+                        "bedrock:InvokeModel",
+                    ],
+                    "Resource": [
+                        f"arn:aws:bedrock:{self.region_name}::foundation-model/{self.embedding_model}"
+                    ]
+                }
+            ]
+        }
+
+        s3_policy_document = {
+            "Version": "2012-10-17",
+            "Statement": [
+                {
+                    "Effect": "Allow",
+                    "Action": [
+                        "s3:GetObject",
+                        "s3:ListBucket"
+                    ],
+                    "Resource": [
+                        f"arn:aws:s3:::{self.bucket_name}",
+                        f"arn:aws:s3:::{self.bucket_name}/*"
+                    ],
+                    "Condition": {
+                        "StringEquals": {
+                            "aws:ResourceAccount": f"{self.account_number}"
+                        }
+                    }
+                }
+            ]
+        }
+
+        assume_role_policy_document = {
+            "Version": "2012-10-17",
+            "Statement": [
+                {
+                    "Effect": "Allow",
+                    "Principal": {
+                        "Service": "bedrock.amazonaws.com"
+                    },
+                    "Action": "sts:AssumeRole"
+                }
+            ]
+        }
+        try:
+            # create policies based on the policy documents
+            fm_policy = self.iam_client.create_policy(
+                PolicyName=self.fm_policy_name,
+                PolicyDocument=json.dumps(foundation_model_policy_document),
+                Description='Policy for accessing foundation model',
+            )
+        except self.iam_client.exceptions.EntityAlreadyExistsException:
+            fm_policy = self.iam_client.get_policy(
+                PolicyArn=f"arn:aws:iam::{self.account_number}:policy/{self.fm_policy_name}"
+            )
+
+        try:
+            s3_policy = self.iam_client.create_policy(
+                PolicyName=self.s3_policy_name,
+                PolicyDocument=json.dumps(s3_policy_document),
+                Description='Policy for reading documents from s3')
+        except self.iam_client.exceptions.EntityAlreadyExistsException:
+            s3_policy = self.iam_client.get_policy(
+                PolicyArn=f"arn:aws:iam::{self.account_number}:policy/{self.s3_policy_name}"
+            )
+        # create bedrock execution role
+        try:
+            bedrock_kb_execution_role = self.iam_client.create_role(
+                RoleName=self.kb_execution_role_name,
+                AssumeRolePolicyDocument=json.dumps(assume_role_policy_document),
+                Description='Amazon Bedrock Knowledge Base Execution Role for accessing OSS and S3',
+                MaxSessionDuration=3600
+            )
+        except self.iam_client.exceptions.EntityAlreadyExistsException:
+            bedrock_kb_execution_role = self.iam_client.get_role(
+                RoleName=self.kb_execution_role_name
+            )
+        # fetch arn of the policies and role created above
+        s3_policy_arn = s3_policy["Policy"]["Arn"]
+        fm_policy_arn = fm_policy["Policy"]["Arn"]
+
+        # attach policies to Amazon Bedrock execution role
+        self.iam_client.attach_role_policy(
+            RoleName=bedrock_kb_execution_role["Role"]["RoleName"],
+            PolicyArn=fm_policy_arn
+        )
+        self.iam_client.attach_role_policy(
+            RoleName=bedrock_kb_execution_role["Role"]["RoleName"],
+            PolicyArn=s3_policy_arn
+        )
+        return bedrock_kb_execution_role
+
+    def create_oss_policy_attach_bedrock_execution_role(self, collection_id):
+        """
+        Create OpenSearch Serverless policy and attach it to the Knowledge Base Execution role.
+        If policy already exists, attaches it
+        """
+        # define oss policy document
+        oss_policy_document = {
+            "Version": "2012-10-17",
+            "Statement": [
+                {
+                    "Effect": "Allow",
+                    "Action": [
+                        "aoss:APIAccessAll"
+                    ],
+                    "Resource": [
+                        f"arn:aws:aoss:{self.region_name}:{self.account_number}:collection/{collection_id}"
+                    ]
+                }
+            ]
+        }
+
+        oss_policy_arn = f"arn:aws:iam::{self.account_number}:policy/{self.oss_policy_name}"
+        created = False
+        try:
+            self.iam_client.create_policy(
+                PolicyName=self.oss_policy_name,
+                PolicyDocument=json.dumps(oss_policy_document),
+                Description='Policy for accessing opensearch serverless',
+            )
+            created = True
+        except self.iam_client.exceptions.EntityAlreadyExistsException:
+            print(f"Policy {oss_policy_arn} already exists, skipping creation")
+        print("Opensearch serverless arn: ", oss_policy_arn)
+
+        self.iam_client.attach_role_policy(
+            RoleName=self.bedrock_kb_execution_role["Role"]["RoleName"],
+            PolicyArn=oss_policy_arn
+        )
+        return created
+
+    def create_policies_in_oss(self):
+        """
+        Create OpenSearch Serverless encryption, network and data access policies.
+        If policies already exist, retrieve them
+        """
+        try:
+            encryption_policy = self.aoss_client.create_security_policy(
+                name=self.encryption_policy_name,
+                policy=json.dumps(
+                    {
+                        'Rules': [{'Resource': ['collection/' + self.vector_store_name],
+                                   'ResourceType': 'collection'}],
+                        'AWSOwnedKey': True
+                    }),
+                type='encryption'
+            )
+        except self.aoss_client.exceptions.ConflictException:
+            encryption_policy = self.aoss_client.get_security_policy(
+                name=self.encryption_policy_name,
+                type='encryption'
+            )
+
+        try:
+            network_policy = self.aoss_client.create_security_policy(
+                name=self.network_policy_name,
+                policy=json.dumps(
+                    [
+                        {'Rules': [{'Resource': ['collection/' + self.vector_store_name],
+                                    'ResourceType': 'collection'}],
+                         'AllowFromPublic': True}
+                    ]),
+                type='network'
+            )
+        except self.aoss_client.exceptions.ConflictException:
+            network_policy = self.aoss_client.get_security_policy(
+                name=self.network_policy_name,
+                type='network'
+            )
+
+        try:
+            access_policy = self.aoss_client.create_access_policy(
+                name=self.access_policy_name,
+                policy=json.dumps(
+                    [
+                        {
+                            'Rules': [
+                                {
+                                    'Resource': ['collection/' + self.vector_store_name],
+                                    'Permission': [
+                                        'aoss:CreateCollectionItems',
+                                        'aoss:DeleteCollectionItems',
+                                        'aoss:UpdateCollectionItems',
+                                        'aoss:DescribeCollectionItems'],
+                                    'ResourceType': 'collection'
+                                },
+                                {
+                                    'Resource': ['index/' + self.vector_store_name + '/*'],
+                                    'Permission': [
+                                        'aoss:CreateIndex',
+                                        'aoss:DeleteIndex',
+                                        'aoss:UpdateIndex',
+                                        'aoss:DescribeIndex',
+                                        'aoss:ReadDocument',
+                                        'aoss:WriteDocument'],
+                                    'ResourceType': 'index'
+                                }],
+                            'Principal': [self.identity, self.bedrock_kb_execution_role['Role']['Arn']],
+                            'Description': 'Easy data policy'}
+                    ]),
+                type='data'
+            )
+        except self.aoss_client.exceptions.ConflictException:
+            access_policy = self.aoss_client.get_access_policy(
+                name=self.access_policy_name,
+                type='data'
+            )
+
+        return encryption_policy, network_policy, access_policy
+
+    def create_oss(self):
+        """
+        Create OpenSearch Serverless Collection. If already existent, retrieve
+        """
+        try:
+            collection = self.aoss_client.create_collection(name=self.vector_store_name, type='VECTORSEARCH')
+            collection_id = collection['createCollectionDetail']['id']
+            collection_arn = collection['createCollectionDetail']['arn']
+        except self.aoss_client.exceptions.ConflictException:
+            collection = self.aoss_client.batch_get_collection(names=[self.vector_store_name])['collectionDetails'][0]
+            pp.pprint(collection)
+            collection_id = collection['id']
+            collection_arn = collection['arn']
+        pp.pprint(collection)
+
+        # Get the OpenSearch serverless collection URL
+        host = collection_id + '.' + self.region_name + '.aoss.amazonaws.com'
+        print(host)
+        # wait for collection creation
+        # This can take couple of minutes to finish
+        response = self.aoss_client.batch_get_collection(names=[self.vector_store_name])
+        # Periodically check collection status
+        while (response['collectionDetails'][0]['status']) == 'CREATING':
+            print('Creating collection...')
+            interactive_sleep(30)
+            response = self.aoss_client.batch_get_collection(names=[self.vector_store_name])
+        print('\nCollection successfully created:')
+        pp.pprint(response["collectionDetails"])
+        # create opensearch serverless access policy and attach it to Bedrock execution role
+        try:
+            created = self.create_oss_policy_attach_bedrock_execution_role(collection_id)
+            if created:
+                # It can take up to a minute for data access rules to be enforced
+                print("Sleeping for a minute to ensure data access rules have been enforced")
+                interactive_sleep(60)
+            return host, collection, collection_id, collection_arn
+        except Exception as e:
+            print("Policy already exists")
+            pp.pprint(e)
+
+    def create_vector_index(self):
+        """
+        Create OpenSearch Serverless vector index. If existent, ignore
+        """
+        body_json = {
+            "settings": {
+                "index.knn": "true",
+                "number_of_shards": 1,
+                "knn.algo_param.ef_search": 512,
+                "number_of_replicas": 0,
+            },
+            "mappings": {
+                "properties": {
+                    "vector": {
+                        "type": "knn_vector",
+                        "dimension": 1536,
+                        "method": {
+                            "name": "hnsw",
+                            "engine": "faiss",
+                            "space_type": "l2"
+                        },
+                    },
+                    "text": {
+                        "type": "text"
+                    },
+                    "text-metadata": {
+                        "type": "text"}
+                }
+            }
+        }
+
+        # Create index
+        try:
+            response = self.oss_client.indices.create(index=self.index_name, body=json.dumps(body_json))
+            print('\nCreating index:')
+            pp.pprint(response)
+
+            # index creation can take up to a minute
+            interactive_sleep(60)
+        except RequestError as e:
+            # you can delete the index if its already exists
+            # oss_client.indices.delete(index=index_name)
+            print(
+                f'Error while trying to create the index, with error {e.error}\nyou may unmark the delete above to '
+                f'delete, and recreate the index')
+
+    @retry(wait_random_min=1000, wait_random_max=2000, stop_max_attempt_number=7)
+    def create_knowledge_base(self):
+        """
+        Create Knowledge Base and its Data Source. If existent, retrieve
+        """
+        opensearch_serverless_configuration = {
+            "collectionArn": self.collection_arn,
+            "vectorIndexName": self.index_name,
+            "fieldMapping": {
+                "vectorField": "vector",
+                "textField": "text",
+                "metadataField": "text-metadata"
+            }
+        }
+
+        # Ingest strategy - How to ingest data from the data source
+        chunking_strategy_configuration = {
+            "chunkingStrategy": "FIXED_SIZE",
+            "fixedSizeChunkingConfiguration": {
+                "maxTokens": 512,
+                "overlapPercentage": 20
+            }
+        }
+
+        # The data source to ingest documents from, into the OpenSearch serverless knowledge base index
+        s3_configuration = {
+            "bucketArn": f"arn:aws:s3:::{self.bucket_name}",
+            # "inclusionPrefixes":["*.*"] # you can use this if you want to create a KB using data within s3 prefixes.
+        }
+
+        # The embedding model used by Bedrock to embed ingested documents, and realtime prompts
+        embedding_model_arn = f"arn:aws:bedrock:{self.region_name}::foundation-model/{self.embedding_model}"
+        try:
+            create_kb_response = self.bedrock_agent_client.create_knowledge_base(
+                name=self.kb_name,
+                description=self.kb_description,
+                roleArn=self.bedrock_kb_execution_role['Role']['Arn'],
+                knowledgeBaseConfiguration={
+                    "type": "VECTOR",
+                    "vectorKnowledgeBaseConfiguration": {
+                        "embeddingModelArn": embedding_model_arn
+                    }
+                },
+                storageConfiguration={
+                    "type": "OPENSEARCH_SERVERLESS",
+                    "opensearchServerlessConfiguration": opensearch_serverless_configuration
+                }
+            )
+            kb = create_kb_response["knowledgeBase"]
+            pp.pprint(kb)
+        except self.bedrock_agent_client.exceptions.ConflictException:
+            kbs = self.bedrock_agent_client.list_knowledge_bases(
+                maxResults=100
+            )
+            kb_id = None
+            for kb in kbs['knowledgeBaseSummaries']:
+                if kb['name'] == self.kb_name:
+                    kb_id = kb['knowledgeBaseId']
+            response = self.bedrock_agent_client.get_knowledge_base(knowledgeBaseId=kb_id)
+            kb = response['knowledgeBase']
+            pp.pprint(kb)
+
+        # Create a DataSource in KnowledgeBase
+        try:
+            create_ds_response = self.bedrock_agent_client.create_data_source(
+                name=self.kb_name,
+                description=self.kb_description,
+                knowledgeBaseId=kb['knowledgeBaseId'],
+                dataSourceConfiguration={
+                    "type": "S3",
+                    "s3Configuration": s3_configuration
+                },
+                vectorIngestionConfiguration={
+                    "chunkingConfiguration": chunking_strategy_configuration
+                }
+            )
+            ds = create_ds_response["dataSource"]
+            pp.pprint(ds)
+        except self.bedrock_agent_client.exceptions.ConflictException:
+            ds_id = self.bedrock_agent_client.list_data_sources(
+                knowledgeBaseId=kb['knowledgeBaseId'],
+                maxResults=100
+            )['dataSourceSummaries'][0]['dataSourceId']
+            get_ds_response = self.bedrock_agent_client.get_data_source(
+                dataSourceId=ds_id,
+                knowledgeBaseId=kb['knowledgeBaseId']
+            )
+            ds = get_ds_response["dataSource"]
+            pp.pprint(ds)
+        return kb, ds
+
+    def start_ingestion_job(self):
+        """
+        Start an ingestion job to synchronize data from an S3 bucket to the Knowledge Base
+        """
+        # Start an ingestion job
+        start_job_response = self.bedrock_agent_client.start_ingestion_job(
+            knowledgeBaseId=self.knowledge_base['knowledgeBaseId'],
+            dataSourceId=self.data_source["dataSourceId"]
+        )
+        job = start_job_response["ingestionJob"]
+        pp.pprint(job)
+        # Get job
+        while job['status'] != 'COMPLETE':
+            get_job_response = self.bedrock_agent_client.get_ingestion_job(
+                knowledgeBaseId=self.knowledge_base['knowledgeBaseId'],
+                dataSourceId=self.data_source["dataSourceId"],
+                ingestionJobId=job["ingestionJobId"]
+            )
+            job = get_job_response["ingestionJob"]
+        pp.pprint(job)
+        interactive_sleep(40)
+
+    def get_knowledge_base_id(self):
+        """
+        Get Knowledge Base Id
+        """
+        pp.pprint(self.knowledge_base["knowledgeBaseId"])
+        return self.knowledge_base["knowledgeBaseId"]
+
+    def get_bucket_name(self):
+        """
+        Get the name of the bucket connected with the Knowledge Base Data Source
+        """
+        pp.pprint(f"Bucket connected with KB: {self.bucket_name}")
+        return self.bucket_name
+
+    def delete_kb(self, delete_s3_bucket=False, delete_iam_roles_and_policies=True):
+        """
+        Delete the Knowledge Base resources
+        Args:
+            delete_s3_bucket (bool): boolean to indicate if s3 bucket should also be deleted
+            delete_iam_roles_and_policies (bool): boolean to indicate if IAM roles and Policies should also be deleted
+        """
+        self.bedrock_agent_client.delete_data_source(
+            dataSourceId=self.data_source["dataSourceId"],
+            knowledgeBaseId=self.knowledge_base['knowledgeBaseId']
+        )
+        self.bedrock_agent_client.delete_knowledge_base(
+            knowledgeBaseId=self.knowledge_base['knowledgeBaseId']
+        )
+        self.oss_client.indices.delete(index=self.index_name)
+        self.aoss_client.delete_collection(id=self.collection_id)
+        self.aoss_client.delete_access_policy(
+            type="data",
+            name=self.access_policy_name
+        )
+        self.aoss_client.delete_security_policy(
+            type="network",
+            name=self.network_policy_name
+        )
+        self.aoss_client.delete_security_policy(
+            type="encryption",
+            name=self.encryption_policy_name
+        )
+        if delete_s3_bucket:
+            self.delete_s3()
+        if delete_iam_roles_and_policies:
+            self.delete_iam_roles_and_policies()
+
+    def delete_iam_roles_and_policies(self):
+        """
+        Delete IAM Roles and policies used by the Knowledge Base
+        """
+        fm_policy_arn = f"arn:aws:iam::{self.account_number}:policy/{self.fm_policy_name}"
+        s3_policy_arn = f"arn:aws:iam::{self.account_number}:policy/{self.s3_policy_name}"
+        oss_policy_arn = f"arn:aws:iam::{self.account_number}:policy/{self.oss_policy_name}"
+        self.iam_client.detach_role_policy(
+            RoleName=self.kb_execution_role_name,
+            PolicyArn=s3_policy_arn
+        )
+        self.iam_client.detach_role_policy(
+            RoleName=self.kb_execution_role_name,
+            PolicyArn=fm_policy_arn
+        )
+        self.iam_client.detach_role_policy(
+            RoleName=self.kb_execution_role_name,
+            PolicyArn=oss_policy_arn
+        )
+        self.iam_client.delete_role(RoleName=self.kb_execution_role_name)
+        self.iam_client.delete_policy(PolicyArn=s3_policy_arn)
+        self.iam_client.delete_policy(PolicyArn=fm_policy_arn)
+        self.iam_client.delete_policy(PolicyArn=oss_policy_arn)
+        return 0
+
+    def delete_s3(self):
+        """
+        Delete the objects contained in the Knowledge Base S3 bucket.
+        Once the bucket is empty, delete the bucket
+        """
+        objects = self.s3_client.list_objects(Bucket=self.bucket_name)
+        if 'Contents' in objects:
+            for obj in objects['Contents']:
+                self.s3_client.delete_object(Bucket=self.bucket_name, Key=obj['Key'])
+        self.s3_client.delete_bucket(Bucket=self.bucket_name)