diff --git a/.changelog/37220.txt b/.changelog/37220.txt
new file mode 100644
index 000000000000..b6b6d1aeb715
--- /dev/null
+++ b/.changelog/37220.txt
@@ -0,0 +1,3 @@
+```release-note:enhancement
+resource/aws_bedrockagent_knowledge_base: Add `storage_configuration.mongo_db_atlas_configuration` argument
+```
\ No newline at end of file
diff --git a/.changelog/44060.txt b/.changelog/44060.txt
new file mode 100644
index 000000000000..dd0f56f7a5a3
--- /dev/null
+++ b/.changelog/44060.txt
@@ -0,0 +1,3 @@
+```release-note:enhancement
+resource/aws_bedrockagent_knowledge_base: Add `storage_configuration.opensearch_managed_cluster_configuration` argument
+```
\ No newline at end of file
diff --git a/.changelog/44388.txt b/.changelog/44388.txt
new file mode 100644
index 000000000000..30955b45cdac
--- /dev/null
+++ b/.changelog/44388.txt
@@ -0,0 +1,7 @@
+```release-note:enhancement
+resource/aws_bedrockagent_knowledge_base: Add `knowledge_base_configuration.kendra_knowledge_base_configuration` argument
+```
+
+```release-note:enhancement
+resource/aws_bedrockagent_knowledge_base: Make `knowledge_base_configuration.vector_knowledge_base_configuration` and ``storage_configuration` optional
+```
\ No newline at end of file
diff --git a/.changelog/45465.txt b/.changelog/45465.txt
new file mode 100644
index 000000000000..df85be9f6843
--- /dev/null
+++ b/.changelog/45465.txt
@@ -0,0 +1,7 @@
+```release-note:enhancement
+resource/aws_bedrockagent_knowledge_base: Add `knowledge_base_configuration.sql_knowledge_base_configuration` and `storage_configuration.neptune_analytics_configuration` arguments
+```
+
+```release-note:bug
+resource/aws_bedrockagent_knowledge_base: Mark `knowledge_base_configuration.vector_knowledge_base_configuration.embedding_model_configuration` and `knowledge_base_configuration.vector_knowledge_base_configuration.supplemental_data_storage_configuration` as `ForceNew`
+```
\ No newline at end of file
diff --git a/.changelog/45468.txt b/.changelog/45468.txt
new file mode 100644
index 000000000000..cf8b77a307fa
--- /dev/null
+++ b/.changelog/45468.txt
@@ -0,0 +1,3 @@
+```release-note:enhancement
+resource/aws_bedrockagent_knowledge_base: Add `storage_configuration.s3_vectors_configuration` block
+```
diff --git a/docs/acc-test-environment-variables.md b/docs/acc-test-environment-variables.md
index 6d50e00f87bb..6a2444a91ebf 100644
--- a/docs/acc-test-environment-variables.md
+++ b/docs/acc-test-environment-variables.md
@@ -110,6 +110,7 @@ Environment variables (beyond standard AWS Go SDK ones) used by acceptance testi
 | `TF_AWS_CONTROLTOWER_CONTROL_OU_NAME`                           | Organizational unit name to be targeted by the Control Tower control.                                                                                                                            |
 | `TF_AWS_CONTROLTOWER_BASELINE_ENABLE_BASELINE_ARN`              | Enable baseline ARN.                                                                                                                                                                             |
 | `TF_AWS_DATAEXCHANGE_DATA_SET_ID`                               | ID of DataExchange Data Set to use for testing.                                                                                                                                                  |
+| `TF_AWS_KENDRA_INDEX_ARN`                               | ARN of Kendra Index to use for testing.                                                                                                                                                  |
 | `TF_AWS_LICENSE_MANAGER_GRANT_HOME_REGION`                      | Region where a License Manager license is imported.                                                                                                                                              |
 | `TF_AWS_LICENSE_MANAGER_GRANT_LICENSE_ARN`                      | ARN for a License Manager license imported into the current account.                                                                                                                             |
 | `TF_AWS_LICENSE_MANAGER_GRANT_PRINCIPAL`                        | ARN of a principal to share the License Manager license with. Either a root user, Organization, or Organizational Unit.                                                                          |
diff --git a/internal/acctest/configs.go b/internal/acctest/configs.go
index be9a373d3dd1..50174e64ab4e 100644
--- a/internal/acctest/configs.go
+++ b/internal/acctest/configs.go
@@ -728,240 +728,70 @@ resource "aws_subnet" "test" {
 	)
 }
 
-func ConfigBedrockAgentKnowledgeBaseRDSBase(rName, model string) string {
-	return ConfigCompose(
-		ConfigVPCWithSubnetsEnableDNSHostnames(rName, 2), //nolint:mnd // 2 subnets required
-		fmt.Sprintf(`
-data "aws_partition" "current" {}
+func ConfigBedrockAgentKnowledgeBaseS3VectorsBase(rName string) string {
+	return fmt.Sprintf(`
 data "aws_region" "current" {}
+data "aws_partition" "current" {}
 
-resource "aws_iam_role" "test" {
-  name               = %[1]q
-  path               = "/service-role/"
-  assume_role_policy = <<POLICY
-{
-	"Version": "2012-10-17",
-	"Statement": [{
-		"Action": "sts:AssumeRole",
-		"Principal": {
-		"Service": "bedrock.amazonaws.com"
-		},
-		"Effect": "Allow"
-	}]
-}
-POLICY
-}
-
-# See https://docs.aws.amazon.com/bedrock/latest/userguide/kb-permissions.html.
-resource "aws_iam_role_policy" "test" {
-  name   = %[1]q
-  role   = aws_iam_role.test.name
-  policy = <<POLICY
-{
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Action": [
-        "bedrock:ListFoundationModels",
-        "bedrock:ListCustomModels"
-      ],
-      "Resource": "*"
-    },
-    {
-      "Effect": "Allow",
-      "Action": [
-        "bedrock:InvokeModel"
-      ],
-      "Resource": [
-        "arn:${data.aws_partition.current.partition}:bedrock:${data.aws_region.current.region}::foundation-model/%[2]s"
-      ]
+data "aws_iam_policy_document" "assume_role_bedrock" {
+  statement {
+    effect = "Allow"
+    principals {
+      type        = "Service"
+      identifiers = ["bedrock.amazonaws.com"]
     }
-  ]
-}
-POLICY
-}
-
-resource "aws_iam_role_policy_attachment" "rds_data_full_access" {
-  role       = aws_iam_role.test.name
-  policy_arn = "arn:${data.aws_partition.current.partition}:iam::${data.aws_partition.current.partition}:policy/AmazonRDSDataFullAccess"
-}
-
-resource "aws_iam_role_policy_attachment" "secrets_manager_read_write" {
-  role       = aws_iam_role.test.name
-  policy_arn = "arn:${data.aws_partition.current.partition}:iam::${data.aws_partition.current.partition}:policy/SecretsManagerReadWrite"
-}
-
-data "aws_rds_orderable_db_instance" "test" {
-  engine                     = "aurora-postgresql"
-  engine_latest_version      = true
-  preferred_instance_classes = ["db.serverless"]
-}
-
-resource "aws_rds_cluster" "test" {
-  cluster_identifier          = %[1]q
-  master_username             = "test"
-  manage_master_user_password = true
-  database_name               = "test"
-  skip_final_snapshot         = true
-  engine                      = data.aws_rds_orderable_db_instance.test.engine
-  engine_version              = data.aws_rds_orderable_db_instance.test.engine_version
-  enable_http_endpoint        = true
-  vpc_security_group_ids      = [aws_security_group.test.id]
-  db_subnet_group_name        = aws_db_subnet_group.test.name
-
-  serverlessv2_scaling_configuration {
-    max_capacity = 1.0
-    min_capacity = 0.5
+    actions = ["sts:AssumeRole"]
   }
 }
 
-resource "aws_rds_cluster_instance" "test" {
-  cluster_identifier  = aws_rds_cluster.test.id
-  instance_class      = "db.serverless"
-  engine              = aws_rds_cluster.test.engine
-  engine_version      = aws_rds_cluster.test.engine_version
-  publicly_accessible = true
-}
-
-resource "aws_db_subnet_group" "test" {
-  name       = %[1]q
-  subnet_ids = aws_subnet.test[*].id
-}
-
-resource "aws_internet_gateway" "test" {
-  vpc_id = aws_vpc.test.id
-
-  tags = {
-    Name = %[1]q
+data "aws_iam_policy_document" "bedrock" {
+  statement {
+    effect    = "Allow"
+    actions   = ["bedrock:InvokeModel"]
+    resources = ["*"]
   }
-}
-
-resource "aws_default_route_table" "test" {
-  default_route_table_id = aws_vpc.test.default_route_table_id
-
-  route {
-    cidr_block = "0.0.0.0/0"
-    gateway_id = aws_internet_gateway.test.id
+  statement {
+    effect    = "Allow"
+    actions   = ["s3:ListBucket", "s3:GetObject"]
+    resources = ["*"]
   }
-
-  tags = {
-    Name = %[1]q
+  statement {
+    effect = "Allow"
+    actions = [
+      "s3vectors:GetIndex",
+      "s3vectors:QueryVectors",
+      "s3vectors:PutVectors",
+      "s3vectors:GetVectors",
+      "s3vectors:DeleteVectors"
+    ]
+    resources = ["*"]
   }
 }
 
-resource "aws_security_group" "test" {
-  name   = %[1]q
-  vpc_id = aws_vpc.test.id
-
-  ingress {
-    from_port   = 5432
-    to_port     = 5432
-    protocol    = "tcp"
-    cidr_blocks = ["0.0.0.0/0"]
-  }
-
-  egress {
-    from_port   = 0
-    to_port     = 0
-    protocol    = "-1"
-    cidr_blocks = ["0.0.0.0/0"]
-  }
-
-  tags = {
-    Name = %[1]q
-  }
+resource "aws_iam_role" "test" {
+  assume_role_policy = data.aws_iam_policy_document.assume_role_bedrock.json
+  name               = %[1]q
 }
 
-data "aws_secretsmanager_secret_version" "test" {
-  secret_id     = aws_rds_cluster.test.master_user_secret[0].secret_arn
-  version_stage = "AWSCURRENT"
-  depends_on    = [aws_rds_cluster.test]
-}
-
-resource "null_resource" "db_setup" {
-  depends_on = [aws_rds_cluster_instance.test, aws_rds_cluster.test, data.aws_secretsmanager_secret_version.test]
-
-  provisioner "local-exec" {
-    command = <<EOT
-      sleep 60
-      export PGPASSWORD=$(aws secretsmanager get-secret-value --secret-id '${aws_rds_cluster.test.master_user_secret[0].secret_arn}' --version-stage AWSCURRENT --region ${data.aws_region.current.region} --query SecretString --output text | jq -r '."password"')
-      psql -h ${aws_rds_cluster.test.endpoint} -U ${aws_rds_cluster.test.master_username} -d ${aws_rds_cluster.test.database_name} -c "CREATE EXTENSION IF NOT EXISTS vector;"
-      psql -h ${aws_rds_cluster.test.endpoint} -U ${aws_rds_cluster.test.master_username} -d ${aws_rds_cluster.test.database_name} -c "CREATE SCHEMA IF NOT EXISTS bedrock_integration;"
-      psql -h ${aws_rds_cluster.test.endpoint} -U ${aws_rds_cluster.test.master_username} -d ${aws_rds_cluster.test.database_name} -c "CREATE SCHEMA IF NOT EXISTS bedrock_new;"
-      psql -h ${aws_rds_cluster.test.endpoint} -U ${aws_rds_cluster.test.master_username} -d ${aws_rds_cluster.test.database_name} -c "CREATE ROLE bedrock_user WITH PASSWORD '$PGPASSWORD' LOGIN;"
-      psql -h ${aws_rds_cluster.test.endpoint} -U ${aws_rds_cluster.test.master_username} -d ${aws_rds_cluster.test.database_name} -c "GRANT ALL ON SCHEMA bedrock_integration TO bedrock_user;"
-      psql -h ${aws_rds_cluster.test.endpoint} -U ${aws_rds_cluster.test.master_username} -d ${aws_rds_cluster.test.database_name} -c "CREATE TABLE bedrock_integration.bedrock_kb (id uuid PRIMARY KEY, embedding vector(1536), chunks text, metadata json, custom_metadata jsonb);"
-      psql -h ${aws_rds_cluster.test.endpoint} -U ${aws_rds_cluster.test.master_username} -d ${aws_rds_cluster.test.database_name} -c "CREATE INDEX ON bedrock_integration.bedrock_kb USING hnsw (embedding vector_cosine_ops);"
-      psql -h ${aws_rds_cluster.test.endpoint} -U ${aws_rds_cluster.test.master_username} -d ${aws_rds_cluster.test.database_name} -c "CREATE INDEX ON bedrock_integration.bedrock_kb USING gin (to_tsvector('simple', chunks));"
-      psql -h ${aws_rds_cluster.test.endpoint} -U ${aws_rds_cluster.test.master_username} -d ${aws_rds_cluster.test.database_name} -c "CREATE INDEX ON bedrock_integration.bedrock_kb USING gin (custom_metadata);"
-    EOT
-  }
-}
-`, rName, model))
+resource "aws_iam_role_policy" "test" {
+  role   = aws_iam_role.test.name
+  policy = data.aws_iam_policy_document.bedrock.json
 }
 
-func ConfigBedrockAgentKnowledgeBaseRDSUpdateBase(rName, model string) string {
-	return ConfigCompose(
-		ConfigBedrockAgentKnowledgeBaseRDSBase(rName, model), //nolint:mnd
-		fmt.Sprintf(`
-resource "aws_iam_role" "test_update" {
-  name               = "%[1]s-update"
-  path               = "/service-role/"
-  assume_role_policy = <<POLICY
-{
-	"Version": "2012-10-17",
-	"Statement": [{
-		"Action": "sts:AssumeRole",
-		"Principal": {
-		"Service": "bedrock.amazonaws.com"
-		},
-		"Effect": "Allow"
-	}]
-}
-POLICY
-}
-
-# See https://docs.aws.amazon.com/bedrock/latest/userguide/kb-permissions.html.
-resource "aws_iam_role_policy" "test_update" {
-  name   = "%[1]s-update"
-  role   = aws_iam_role.test_update.name
-  policy = <<POLICY
-{
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Action": [
-        "bedrock:ListFoundationModels",
-        "bedrock:ListCustomModels"
-      ],
-      "Resource": "*"
-    },
-    {
-      "Effect": "Allow",
-      "Action": [
-        "bedrock:InvokeModel"
-      ],
-      "Resource": [
-        "arn:${data.aws_partition.current.partition}:bedrock:${data.aws_region.current.region}::foundation-model/%[2]s"
-      ]
-    }
-  ]
-}
-POLICY
+resource "aws_s3vectors_vector_bucket" "test" {
+  vector_bucket_name = %[1]q
+  force_destroy      = true
 }
 
-resource "aws_iam_role_policy_attachment" "rds_data_full_access_update" {
-  role       = aws_iam_role.test_update.name
-  policy_arn = "arn:${data.aws_partition.current.partition}:iam::${data.aws_partition.current.partition}:policy/AmazonRDSDataFullAccess"
-}
+resource "aws_s3vectors_index" "test" {
+  index_name         = %[1]q
+  vector_bucket_name = aws_s3vectors_vector_bucket.test.vector_bucket_name
 
-resource "aws_iam_role_policy_attachment" "secrets_manager_read_write_update" {
-  role       = aws_iam_role.test_update.name
-  policy_arn = "arn:${data.aws_partition.current.partition}:iam::${data.aws_partition.current.partition}:policy/SecretsManagerReadWrite"
+  data_type       = "float32"
+  dimension       = 256
+  distance_metric = "euclidean"
 }
-`, rName, model))
+`, rName)
 }
 
 // ConfigRandomPassword returns the configuration for an ephemeral resource that
diff --git a/internal/service/bedrockagent/agent_knowledge_base_association_test.go b/internal/service/bedrockagent/agent_knowledge_base_association_test.go
index 2fc612551449..9e637e099a43 100644
--- a/internal/service/bedrockagent/agent_knowledge_base_association_test.go
+++ b/internal/service/bedrockagent/agent_knowledge_base_association_test.go
@@ -19,38 +19,19 @@ import (
 	"github.com/hashicorp/terraform-provider-aws/names"
 )
 
-// Prerequisites:
-// * psql run via null_resource/provisioner "local-exec"
-// * jq for parsing output from aws cli to retrieve postgres password
 func TestAccBedrockAgentAgentKnowledgeBaseAssociation_basic(t *testing.T) {
-	acctest.SkipIfExeNotOnPath(t, "psql")
-	acctest.SkipIfExeNotOnPath(t, "jq")
-	acctest.SkipIfExeNotOnPath(t, "aws")
-
 	ctx := acctest.Context(t)
-	if testing.Short() {
-		t.Skip("skipping long-running test in short mode")
-	}
-
 	var agentknowledgebaseassociation types.AgentKnowledgeBase
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	resourceName := "aws_bedrockagent_agent_knowledge_base_association.test"
 	agentModel := "anthropic.claude-v2"
-	foundationModel := "amazon.titan-embed-text-v1"
+	foundationModel := "amazon.titan-embed-text-v2:0"
 
 	resource.ParallelTest(t, resource.TestCase{
-		PreCheck: func() {
-			acctest.PreCheck(ctx, t)
-		},
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
 		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		ExternalProviders: map[string]resource.ExternalProvider{
-			"null": {
-				Source:            "hashicorp/null",
-				VersionConstraint: "3.2.2",
-			},
-		},
-		CheckDestroy: testAccCheckAgentKnowledgeBaseAssociationDestroy(ctx),
+		CheckDestroy:             testAccCheckAgentKnowledgeBaseAssociationDestroy(ctx),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccAgentKnowledgeBaseAssociationConfig_basic(rName, agentModel, foundationModel, "test desc", "ENABLED"),
@@ -69,38 +50,19 @@ func TestAccBedrockAgentAgentKnowledgeBaseAssociation_basic(t *testing.T) {
 	})
 }
 
-// Prerequisites:
-// * psql run via null_resource/provisioner "local-exec"
-// * jq for parsing output from aws cli to retrieve postgres password
 func TestAccBedrockAgentAgentKnowledgeBaseAssociation_update(t *testing.T) {
-	acctest.SkipIfExeNotOnPath(t, "psql")
-	acctest.SkipIfExeNotOnPath(t, "jq")
-	acctest.SkipIfExeNotOnPath(t, "aws")
-
 	ctx := acctest.Context(t)
-	if testing.Short() {
-		t.Skip("skipping long-running test in short mode")
-	}
-
 	var agentknowledgebaseassociation types.AgentKnowledgeBase
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	resourceName := "aws_bedrockagent_agent_knowledge_base_association.test"
 	agentModel := "anthropic.claude-v2"
-	foundationModel := "amazon.titan-embed-text-v1"
+	foundationModel := "amazon.titan-embed-text-v2:0"
 
 	resource.ParallelTest(t, resource.TestCase{
-		PreCheck: func() {
-			acctest.PreCheck(ctx, t)
-		},
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
 		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		ExternalProviders: map[string]resource.ExternalProvider{
-			"null": {
-				Source:            "hashicorp/null",
-				VersionConstraint: "3.2.2",
-			},
-		},
-		CheckDestroy: testAccCheckAgentKnowledgeBaseAssociationDestroy(ctx),
+		CheckDestroy:             testAccCheckAgentKnowledgeBaseAssociationDestroy(ctx),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccAgentKnowledgeBaseAssociationConfig_basic(rName, agentModel, foundationModel, "test desc", "ENABLED"),
@@ -127,38 +89,19 @@ func TestAccBedrockAgentAgentKnowledgeBaseAssociation_update(t *testing.T) {
 	})
 }
 
-// Prerequisites:
-// * psql run via null_resource/provisioner "local-exec"
-// * jq for parsing output from aws cli to retrieve postgres password
 func TestAccBedrockAgentAgentKnowledgeBaseAssociation_disappears(t *testing.T) {
-	acctest.SkipIfExeNotOnPath(t, "psql")
-	acctest.SkipIfExeNotOnPath(t, "jq")
-	acctest.SkipIfExeNotOnPath(t, "aws")
-
 	ctx := acctest.Context(t)
-	if testing.Short() {
-		t.Skip("skipping long-running test in short mode")
-	}
-
 	var agentknowledgebaseassociation types.AgentKnowledgeBase
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	resourceName := "aws_bedrockagent_agent_knowledge_base_association.test"
 	agentModel := "anthropic.claude-v2"
-	foundationModel := "amazon.titan-embed-text-v1"
+	foundationModel := "amazon.titan-embed-text-v2:0"
 
 	resource.ParallelTest(t, resource.TestCase{
-		PreCheck: func() {
-			acctest.PreCheck(ctx, t)
-		},
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
 		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		ExternalProviders: map[string]resource.ExternalProvider{
-			"null": {
-				Source:            "hashicorp/null",
-				VersionConstraint: "3.2.2",
-			},
-		},
-		CheckDestroy: testAccCheckAgentKnowledgeBaseAssociationDestroy(ctx),
+		CheckDestroy:             testAccCheckAgentKnowledgeBaseAssociationDestroy(ctx),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccAgentKnowledgeBaseAssociationConfig_basic(rName, agentModel, foundationModel, "test desc", "ENABLED"),
@@ -222,7 +165,7 @@ func testAccCheckAgentKnowledgeBaseAssociationExists(ctx context.Context, n stri
 func testAccAgentKnowledgeBaseAssociationConfig_basic(rName, agentModel, embeddingModel, description, state string) string {
 	return acctest.ConfigCompose(
 		testAccAgentConfig_basic(rName, agentModel, description),
-		testAccKnowledgeBaseConfig_basicRDS(rName, embeddingModel, ""),
+		testAccKnowledgeBaseConfig_S3VectorsByIndexARN(rName, embeddingModel),
 		fmt.Sprintf(`
 resource "aws_bedrockagent_agent_knowledge_base_association" "test" {
   agent_id             = aws_bedrockagent_agent.test.id
diff --git a/internal/service/bedrockagent/bedrockagent_test.go b/internal/service/bedrockagent/bedrockagent_test.go
index b46ca755696d..b5dcfaf42f74 100644
--- a/internal/service/bedrockagent/bedrockagent_test.go
+++ b/internal/service/bedrockagent/bedrockagent_test.go
@@ -14,12 +14,18 @@ func TestAccBedrockAgent_serial(t *testing.T) {
 
 	testCases := map[string]map[string]func(t *testing.T){
 		"KnowledgeBase": {
-			acctest.CtBasic:                     testAccKnowledgeBase_basic,
-			acctest.CtDisappears:                testAccKnowledgeBase_disappears,
-			"tags":                              testAccKnowledgeBase_tags,
-			"OpenSearchBasic":                   testAccKnowledgeBase_OpenSearch_basic,
-			"OpenSearchUpdate":                  testAccKnowledgeBase_OpenSearch_update,
-			"OpenSearchSupplementalDataStorage": testAccKnowledgeBase_OpenSearch_supplementalDataStorage,
+			acctest.CtDisappears:                     testAccKnowledgeBase_disappears,
+			"tags":                                   testAccKnowledgeBase_tags,
+			"update":                                 testAccKnowledgeBase_update,
+			"OpenSearchServerlessBasic":              testAccKnowledgeBase_OpenSearchServerless_basic,
+			"Kendra":                                 testAccKnowledgeBase_Kendra_basic,
+			"NeptuneAnalytics":                       testAccKnowledgeBase_NeptuneAnalytics_basic,
+			"OpenSearchManagedClusterBasic":          testAccKnowledgeBase_OpenSearchManagedCluster_basic,
+			"S3Vectors":                              testAccKnowledgeBase_S3Vectors_update,
+			"StructuredDataStoreRedshiftProvisioned": testAccKnowledgeBase_StructuredDataStore_redshiftProvisioned,
+			"StructuredDataStoreRedshiftServerless":  testAccKnowledgeBase_StructuredDataStore_redshiftServerless,
+			"RDS":                                    testAccKnowledgeBase_RDS_basic,
+			"RDSSupplementalDataStorage":             testAccKnowledgeBase_RDS_supplementalDataStorage,
 		},
 		"DataSource": {
 			acctest.CtBasic:        testAccDataSource_basic,
diff --git a/internal/service/bedrockagent/data_source.go b/internal/service/bedrockagent/data_source.go
index cfe031da6cc0..9d4e69fff626 100644
--- a/internal/service/bedrockagent/data_source.go
+++ b/internal/service/bedrockagent/data_source.go
@@ -1123,7 +1123,7 @@ type intermediateStorageModel struct {
 }
 
 type s3LocationModel struct {
-	Uri types.String `tfsdk:"uri"`
+	URI types.String `tfsdk:"uri"`
 }
 
 type transformationModel struct {
diff --git a/internal/service/bedrockagent/data_source_test.go b/internal/service/bedrockagent/data_source_test.go
index 2b7c96e177a6..a4abec921250 100644
--- a/internal/service/bedrockagent/data_source_test.go
+++ b/internal/service/bedrockagent/data_source_test.go
@@ -19,37 +19,18 @@ import (
 	"github.com/hashicorp/terraform-provider-aws/names"
 )
 
-// Prerequisites:
-// * psql run via null_resource/provisioner "local-exec"
-// * jq for parsing output from aws cli to retrieve postgres password
 func testAccDataSource_basic(t *testing.T) {
-	acctest.SkipIfExeNotOnPath(t, "psql")
-	acctest.SkipIfExeNotOnPath(t, "jq")
-	acctest.SkipIfExeNotOnPath(t, "aws")
-
 	ctx := acctest.Context(t)
-	if testing.Short() {
-		t.Skip("skipping long-running test in short mode")
-	}
-
 	var dataSource types.DataSource
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	resourceName := "aws_bedrockagent_data_source.test"
-	foundationModel := "amazon.titan-embed-text-v1"
+	foundationModel := "amazon.titan-embed-text-v2:0"
 
 	resource.Test(t, resource.TestCase{
-		PreCheck: func() {
-			acctest.PreCheck(ctx, t)
-		},
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
 		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		ExternalProviders: map[string]resource.ExternalProvider{
-			"null": {
-				Source:            "hashicorp/null",
-				VersionConstraint: "3.2.2",
-			},
-		},
-		CheckDestroy: testAccCheckDataSourceDestroy(ctx),
+		CheckDestroy:             testAccCheckDataSourceDestroy(ctx),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDataSourceConfig_basic(rName, foundationModel),
@@ -66,37 +47,18 @@ func testAccDataSource_basic(t *testing.T) {
 	})
 }
 
-// Prerequisites:
-// * psql run via null_resource/provisioner "local-exec"
-// * jq for parsing output from aws cli to retrieve postgres password
 func testAccDataSource_full(t *testing.T) {
-	acctest.SkipIfExeNotOnPath(t, "psql")
-	acctest.SkipIfExeNotOnPath(t, "jq")
-	acctest.SkipIfExeNotOnPath(t, "aws")
-
 	ctx := acctest.Context(t)
-	if testing.Short() {
-		t.Skip("skipping long-running test in short mode")
-	}
-
 	var dataSource types.DataSource
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	resourceName := "aws_bedrockagent_data_source.test"
-	foundationModel := "amazon.titan-embed-text-v1"
+	foundationModel := "amazon.titan-embed-text-v2:0"
 
 	resource.Test(t, resource.TestCase{
-		PreCheck: func() {
-			acctest.PreCheck(ctx, t)
-		},
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
 		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		ExternalProviders: map[string]resource.ExternalProvider{
-			"null": {
-				Source:            "hashicorp/null",
-				VersionConstraint: "3.2.2",
-			},
-		},
-		CheckDestroy: testAccCheckDataSourceDestroy(ctx),
+		CheckDestroy:             testAccCheckDataSourceDestroy(ctx),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDataSourceConfig_full(rName, foundationModel),
@@ -132,33 +94,17 @@ func testAccDataSource_full(t *testing.T) {
 }
 
 func testAccDataSource_fullSemantic(t *testing.T) {
-	acctest.SkipIfExeNotOnPath(t, "psql")
-	acctest.SkipIfExeNotOnPath(t, "jq")
-	acctest.SkipIfExeNotOnPath(t, "aws")
-
 	ctx := acctest.Context(t)
-	if testing.Short() {
-		t.Skip("skipping long-running test in short mode")
-	}
-
 	var dataSource types.DataSource
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	resourceName := "aws_bedrockagent_data_source.test"
-	foundationModel := "amazon.titan-embed-text-v1"
+	foundationModel := "amazon.titan-embed-text-v2:0"
 
 	resource.Test(t, resource.TestCase{
-		PreCheck: func() {
-			acctest.PreCheck(ctx, t)
-		},
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
 		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		ExternalProviders: map[string]resource.ExternalProvider{
-			"null": {
-				Source:            "hashicorp/null",
-				VersionConstraint: "3.2.2",
-			},
-		},
-		CheckDestroy: testAccCheckDataSourceDestroy(ctx),
+		CheckDestroy:             testAccCheckDataSourceDestroy(ctx),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDataSourceConfig_fullSemantic(rName, foundationModel),
@@ -195,33 +141,17 @@ func testAccDataSource_fullSemantic(t *testing.T) {
 }
 
 func testAccDataSource_fullHierarchical(t *testing.T) {
-	acctest.SkipIfExeNotOnPath(t, "psql")
-	acctest.SkipIfExeNotOnPath(t, "jq")
-	acctest.SkipIfExeNotOnPath(t, "aws")
-
 	ctx := acctest.Context(t)
-	if testing.Short() {
-		t.Skip("skipping long-running test in short mode")
-	}
-
 	var dataSource types.DataSource
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	resourceName := "aws_bedrockagent_data_source.test"
-	foundationModel := "amazon.titan-embed-text-v1"
+	foundationModel := "amazon.titan-embed-text-v2:0"
 
 	resource.Test(t, resource.TestCase{
-		PreCheck: func() {
-			acctest.PreCheck(ctx, t)
-		},
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
 		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		ExternalProviders: map[string]resource.ExternalProvider{
-			"null": {
-				Source:            "hashicorp/null",
-				VersionConstraint: "3.2.2",
-			},
-		},
-		CheckDestroy: testAccCheckDataSourceDestroy(ctx),
+		CheckDestroy:             testAccCheckDataSourceDestroy(ctx),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDataSourceConfig_fullHierarchical(rName, foundationModel),
@@ -258,37 +188,18 @@ func testAccDataSource_fullHierarchical(t *testing.T) {
 	})
 }
 
-// Prerequisites:
-// * psql run via null_resource/provisioner "local-exec"
-// * jq for parsing output from aws cli to retrieve postgres password
 func testAccDataSource_fullCustomTranformation(t *testing.T) {
-	acctest.SkipIfExeNotOnPath(t, "psql")
-	acctest.SkipIfExeNotOnPath(t, "jq")
-	acctest.SkipIfExeNotOnPath(t, "aws")
-
 	ctx := acctest.Context(t)
-	if testing.Short() {
-		t.Skip("skipping long-running test in short mode")
-	}
-
 	var dataSource types.DataSource
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	resourceName := "aws_bedrockagent_data_source.test"
-	foundationModel := "amazon.titan-embed-text-v1"
+	foundationModel := "amazon.titan-embed-text-v2:0"
 
 	resource.Test(t, resource.TestCase{
-		PreCheck: func() {
-			acctest.PreCheck(ctx, t)
-		},
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
 		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		ExternalProviders: map[string]resource.ExternalProvider{
-			"null": {
-				Source:            "hashicorp/null",
-				VersionConstraint: "3.2.2",
-			},
-		},
-		CheckDestroy: testAccCheckDataSourceDestroy(ctx),
+		CheckDestroy:             testAccCheckDataSourceDestroy(ctx),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDataSourceConfig_fullCustomTransformation(rName, foundationModel),
@@ -323,38 +234,19 @@ func testAccDataSource_fullCustomTranformation(t *testing.T) {
 	})
 }
 
-// Prerequisites:
-// * psql run via null_resource/provisioner "local-exec"
-// * jq for parsing output from aws cli to retrieve postgres password
 func testAccDataSource_parsing(t *testing.T) {
-	acctest.SkipIfExeNotOnPath(t, "psql")
-	acctest.SkipIfExeNotOnPath(t, "jq")
-	acctest.SkipIfExeNotOnPath(t, "aws")
-
 	ctx := acctest.Context(t)
-	if testing.Short() {
-		t.Skip("skipping long-running test in short mode")
-	}
-
 	var dataSource types.DataSource
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	resourceName := "aws_bedrockagent_data_source.test"
-	foundationModel := "amazon.titan-embed-text-v1"
+	foundationModel := "amazon.titan-embed-text-v2:0"
 	parsingModel := "anthropic.claude-3-sonnet-20240229-v1:0"
 
 	resource.Test(t, resource.TestCase{
-		PreCheck: func() {
-			acctest.PreCheck(ctx, t)
-		},
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
 		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		ExternalProviders: map[string]resource.ExternalProvider{
-			"null": {
-				Source:            "hashicorp/null",
-				VersionConstraint: "3.2.2",
-			},
-		},
-		CheckDestroy: testAccCheckDataSourceDestroy(ctx),
+		CheckDestroy:             testAccCheckDataSourceDestroy(ctx),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDataSourceConfig_parsing(rName, foundationModel, parsingModel),
@@ -391,37 +283,18 @@ func testAccDataSource_parsing(t *testing.T) {
 	})
 }
 
-// Prerequisites:
-// * psql run via null_resource/provisioner "local-exec"
-// * jq for parsing output from aws cli to retrieve postgres password
 func testAccDataSource_disappears(t *testing.T) {
-	acctest.SkipIfExeNotOnPath(t, "psql")
-	acctest.SkipIfExeNotOnPath(t, "jq")
-	acctest.SkipIfExeNotOnPath(t, "aws")
-
 	ctx := acctest.Context(t)
-	if testing.Short() {
-		t.Skip("skipping long-running test in short mode")
-	}
-
 	var dataSource types.DataSource
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	resourceName := "aws_bedrockagent_data_source.test"
-	foundationModel := "amazon.titan-embed-text-v1"
+	foundationModel := "amazon.titan-embed-text-v2:0"
 
 	resource.Test(t, resource.TestCase{
-		PreCheck: func() {
-			acctest.PreCheck(ctx, t)
-		},
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
 		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		ExternalProviders: map[string]resource.ExternalProvider{
-			"null": {
-				Source:            "hashicorp/null",
-				VersionConstraint: "3.2.2",
-			},
-		},
-		CheckDestroy: testAccCheckDataSourceDestroy(ctx),
+		CheckDestroy:             testAccCheckDataSourceDestroy(ctx),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDataSourceConfig_basic(rName, foundationModel),
@@ -435,37 +308,18 @@ func testAccDataSource_disappears(t *testing.T) {
 	})
 }
 
-// Prerequisites:
-// * psql run via null_resource/provisioner "local-exec"
-// * jq for parsing output from aws cli to retrieve postgres password
 func testAccDataSource_update(t *testing.T) {
-	acctest.SkipIfExeNotOnPath(t, "psql")
-	acctest.SkipIfExeNotOnPath(t, "jq")
-	acctest.SkipIfExeNotOnPath(t, "aws")
-
 	ctx := acctest.Context(t)
-	if testing.Short() {
-		t.Skip("skipping long-running test in short mode")
-	}
-
 	var dataSource types.DataSource
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	resourceName := "aws_bedrockagent_data_source.test"
-	foundationModel := "amazon.titan-embed-text-v1"
+	foundationModel := "amazon.titan-embed-text-v2:0"
 
 	resource.Test(t, resource.TestCase{
-		PreCheck: func() {
-			acctest.PreCheck(ctx, t)
-		},
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
 		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		ExternalProviders: map[string]resource.ExternalProvider{
-			"null": {
-				Source:            "hashicorp/null",
-				VersionConstraint: "3.2.2",
-			},
-		},
-		CheckDestroy: testAccCheckDataSourceDestroy(ctx),
+		CheckDestroy:             testAccCheckDataSourceDestroy(ctx),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDataSourceConfig_basic(rName, foundationModel),
@@ -599,7 +453,7 @@ func testAccCheckDataSourceExists(ctx context.Context, n string, v *types.DataSo
 }
 
 func testAccDataSourceConfig_base(rName, embeddingModel string) string {
-	return acctest.ConfigCompose(testAccKnowledgeBaseConfig_basicRDS(rName, embeddingModel, ""), fmt.Sprintf(`
+	return acctest.ConfigCompose(testAccKnowledgeBaseConfig_S3VectorsByIndexARN(rName, embeddingModel), fmt.Sprintf(`
 resource "aws_s3_bucket" "test" {
   bucket = %[1]q
 }
@@ -834,7 +688,7 @@ resource "aws_bedrockagent_data_source" "test" {
 }
 
 func testAccDataSourceConfig_webConfiguration(rName, collectionName, embeddingModel string) string {
-	return acctest.ConfigCompose(testAccKnowledgeBaseConfig_OpenSearch_basic(rName, collectionName, embeddingModel), fmt.Sprintf(`
+	return acctest.ConfigCompose(testAccKnowledgeBaseConfig_OpenSearchServerless_basic(rName, collectionName, embeddingModel), fmt.Sprintf(`
 resource "aws_bedrockagent_data_source" "test" {
   name              = %[1]q
   knowledge_base_id = aws_bedrockagent_knowledge_base.test.id
diff --git a/internal/service/bedrockagent/knowledge_base.go b/internal/service/bedrockagent/knowledge_base.go
index 818fbaaf8666..92e526cd3771 100644
--- a/internal/service/bedrockagent/knowledge_base.go
+++ b/internal/service/bedrockagent/knowledge_base.go
@@ -16,12 +16,17 @@ import (
 	"github.com/hashicorp/aws-sdk-go-base/v2/tfawserr"
 	"github.com/hashicorp/terraform-plugin-framework-timeouts/resource/timeouts"
 	"github.com/hashicorp/terraform-plugin-framework-timetypes/timetypes"
+	"github.com/hashicorp/terraform-plugin-framework-validators/int64validator"
 	"github.com/hashicorp/terraform-plugin-framework-validators/listvalidator"
+	"github.com/hashicorp/terraform-plugin-framework-validators/objectvalidator"
 	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
+	"github.com/hashicorp/terraform-plugin-framework/path"
 	"github.com/hashicorp/terraform-plugin-framework/resource"
 	"github.com/hashicorp/terraform-plugin-framework/resource/schema"
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema/int64planmodifier"
 	"github.com/hashicorp/terraform-plugin-framework/resource/schema/listplanmodifier"
 	"github.com/hashicorp/terraform-plugin-framework/resource/schema/planmodifier"
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema/setplanmodifier"
 	"github.com/hashicorp/terraform-plugin-framework/resource/schema/stringplanmodifier"
 	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
 	"github.com/hashicorp/terraform-plugin-framework/types"
@@ -106,18 +111,416 @@ func (r *knowledgeBaseResource) Schema(ctx context.Context, request resource.Sch
 				NestedObject: schema.NestedBlockObject{
 					Attributes: map[string]schema.Attribute{
 						names.AttrType: schema.StringAttribute{
-							Required: true,
+							CustomType: fwtypes.StringEnumType[awstypes.KnowledgeBaseType](),
+							Required:   true,
 							PlanModifiers: []planmodifier.String{
 								stringplanmodifier.RequiresReplace(),
 							},
 						},
 					},
 					Blocks: map[string]schema.Block{
+						"kendra_knowledge_base_configuration": schema.ListNestedBlock{
+							CustomType: fwtypes.NewListNestedObjectTypeOf[kendraKnowledgeBaseConfigurationModel](ctx),
+							Validators: []validator.List{
+								listvalidator.SizeAtMost(1),
+								listvalidator.ExactlyOneOf(
+									path.MatchRelative().AtParent().AtName("kendra_knowledge_base_configuration"),
+									path.MatchRelative().AtParent().AtName("sql_knowledge_base_configuration"),
+									path.MatchRelative().AtParent().AtName("vector_knowledge_base_configuration"),
+								),
+							},
+							PlanModifiers: []planmodifier.List{
+								listplanmodifier.RequiresReplace(),
+							},
+							NestedObject: schema.NestedBlockObject{
+								Attributes: map[string]schema.Attribute{
+									"kendra_index_arn": schema.StringAttribute{
+										CustomType: fwtypes.ARNType,
+										Required:   true,
+										PlanModifiers: []planmodifier.String{
+											stringplanmodifier.RequiresReplace(),
+										},
+									},
+								},
+							},
+						},
+						"sql_knowledge_base_configuration": schema.ListNestedBlock{
+							CustomType: fwtypes.NewListNestedObjectTypeOf[sqlKnowledgeBaseConfigurationModel](ctx),
+							Validators: []validator.List{
+								listvalidator.SizeAtMost(1),
+							},
+							PlanModifiers: []planmodifier.List{
+								listplanmodifier.RequiresReplace(),
+							},
+							NestedObject: schema.NestedBlockObject{
+								Attributes: map[string]schema.Attribute{
+									names.AttrType: schema.StringAttribute{
+										CustomType: fwtypes.StringEnumType[awstypes.QueryEngineType](),
+										Required:   true,
+										PlanModifiers: []planmodifier.String{
+											stringplanmodifier.RequiresReplace(),
+										},
+									},
+								},
+								Blocks: map[string]schema.Block{
+									"redshift_configuration": schema.ListNestedBlock{
+										CustomType: fwtypes.NewListNestedObjectTypeOf[redshiftConfigurationModel](ctx),
+										Validators: []validator.List{
+											listvalidator.SizeAtMost(1),
+											listvalidator.ExactlyOneOf(
+												path.MatchRelative().AtParent().AtName("redshift_configuration"),
+											),
+										},
+										PlanModifiers: []planmodifier.List{
+											listplanmodifier.RequiresReplace(),
+										},
+										NestedObject: schema.NestedBlockObject{
+											Blocks: map[string]schema.Block{
+												"query_engine_configuration": schema.ListNestedBlock{
+													CustomType: fwtypes.NewListNestedObjectTypeOf[redshiftQueryEngineConfigurationModel](ctx),
+													Validators: []validator.List{
+														listvalidator.IsRequired(),
+														listvalidator.SizeAtLeast(1),
+														listvalidator.SizeAtMost(1),
+													},
+													PlanModifiers: []planmodifier.List{
+														listplanmodifier.RequiresReplace(),
+													},
+													NestedObject: schema.NestedBlockObject{
+														Attributes: map[string]schema.Attribute{
+															names.AttrType: schema.StringAttribute{
+																CustomType: fwtypes.StringEnumType[awstypes.RedshiftQueryEngineType](),
+																Required:   true,
+																PlanModifiers: []planmodifier.String{
+																	stringplanmodifier.RequiresReplace(),
+																},
+															},
+														},
+														Blocks: map[string]schema.Block{
+															"provisioned_configuration": schema.ListNestedBlock{
+																CustomType: fwtypes.NewListNestedObjectTypeOf[redshiftProvisionedConfigurationModel](ctx),
+																Validators: []validator.List{
+																	listvalidator.SizeAtMost(1),
+																	listvalidator.ExactlyOneOf(
+																		path.MatchRelative().AtParent().AtName("provisioned_configuration"),
+																		path.MatchRelative().AtParent().AtName("serverless_configuration"),
+																	),
+																},
+																PlanModifiers: []planmodifier.List{
+																	listplanmodifier.RequiresReplace(),
+																},
+																NestedObject: schema.NestedBlockObject{
+																	Attributes: map[string]schema.Attribute{
+																		names.AttrClusterIdentifier: schema.StringAttribute{
+																			Required: true,
+																			PlanModifiers: []planmodifier.String{
+																				stringplanmodifier.RequiresReplace(),
+																			},
+																		},
+																	},
+																	Blocks: map[string]schema.Block{
+																		"auth_configuration": schema.ListNestedBlock{
+																			CustomType: fwtypes.NewListNestedObjectTypeOf[redshiftProvisionedAuthConfigurationModel](ctx),
+																			Validators: []validator.List{
+																				listvalidator.IsRequired(),
+																				listvalidator.SizeAtLeast(1),
+																				listvalidator.SizeAtMost(1),
+																			},
+																			PlanModifiers: []planmodifier.List{
+																				listplanmodifier.RequiresReplace(),
+																			},
+																			NestedObject: schema.NestedBlockObject{
+																				Attributes: map[string]schema.Attribute{
+																					"database_user": schema.StringAttribute{
+																						Optional: true,
+																						PlanModifiers: []planmodifier.String{
+																							stringplanmodifier.RequiresReplace(),
+																						},
+																					},
+																					names.AttrType: schema.StringAttribute{
+																						CustomType: fwtypes.StringEnumType[awstypes.RedshiftProvisionedAuthType](),
+																						Required:   true,
+																						PlanModifiers: []planmodifier.String{
+																							stringplanmodifier.RequiresReplace(),
+																						},
+																					},
+																					"username_password_secret_arn": schema.StringAttribute{
+																						CustomType: fwtypes.ARNType,
+																						Optional:   true,
+																						PlanModifiers: []planmodifier.String{
+																							stringplanmodifier.RequiresReplace(),
+																						},
+																					},
+																				},
+																			},
+																		},
+																	},
+																},
+															},
+															"serverless_configuration": schema.ListNestedBlock{
+																CustomType: fwtypes.NewListNestedObjectTypeOf[redshiftServerlessConfigurationModel](ctx),
+																Validators: []validator.List{
+																	listvalidator.SizeAtMost(1),
+																},
+																PlanModifiers: []planmodifier.List{
+																	listplanmodifier.RequiresReplace(),
+																},
+																NestedObject: schema.NestedBlockObject{
+																	Attributes: map[string]schema.Attribute{
+																		"workgroup_arn": schema.StringAttribute{
+																			CustomType: fwtypes.ARNType,
+																			Required:   true,
+																			PlanModifiers: []planmodifier.String{
+																				stringplanmodifier.RequiresReplace(),
+																			},
+																		},
+																	},
+																	Blocks: map[string]schema.Block{
+																		"auth_configuration": schema.ListNestedBlock{
+																			CustomType: fwtypes.NewListNestedObjectTypeOf[redshiftServerlessAuthConfigurationModel](ctx),
+																			Validators: []validator.List{
+																				listvalidator.IsRequired(),
+																				listvalidator.SizeAtLeast(1),
+																				listvalidator.SizeAtMost(1),
+																			},
+																			PlanModifiers: []planmodifier.List{
+																				listplanmodifier.RequiresReplace(),
+																			},
+																			NestedObject: schema.NestedBlockObject{
+																				Attributes: map[string]schema.Attribute{
+																					names.AttrType: schema.StringAttribute{
+																						CustomType: fwtypes.StringEnumType[awstypes.RedshiftServerlessAuthType](),
+																						Required:   true,
+																						PlanModifiers: []planmodifier.String{
+																							stringplanmodifier.RequiresReplace(),
+																						},
+																					},
+																					"username_password_secret_arn": schema.StringAttribute{
+																						CustomType: fwtypes.ARNType,
+																						Optional:   true,
+																						PlanModifiers: []planmodifier.String{
+																							stringplanmodifier.RequiresReplace(),
+																						},
+																					},
+																				},
+																			},
+																		},
+																	},
+																},
+															},
+														},
+													},
+												},
+												"query_generation_configuration": schema.ListNestedBlock{
+													CustomType: fwtypes.NewListNestedObjectTypeOf[queryGenerationConfigurationModel](ctx),
+													Validators: []validator.List{
+														listvalidator.SizeAtMost(1),
+													},
+													PlanModifiers: []planmodifier.List{
+														listplanmodifier.RequiresReplace(),
+													},
+													NestedObject: schema.NestedBlockObject{
+														Attributes: map[string]schema.Attribute{
+															"execution_timeout_seconds": schema.Int64Attribute{
+																Optional: true,
+																Validators: []validator.Int64{
+																	int64validator.Between(1, 200),
+																},
+																PlanModifiers: []planmodifier.Int64{
+																	int64planmodifier.RequiresReplace(),
+																},
+															},
+														},
+														Blocks: map[string]schema.Block{
+															"generation_context": schema.ListNestedBlock{
+																CustomType: fwtypes.NewListNestedObjectTypeOf[queryGenerationContextModel](ctx),
+																Validators: []validator.List{
+																	listvalidator.SizeAtMost(1),
+																},
+																PlanModifiers: []planmodifier.List{
+																	listplanmodifier.RequiresReplace(),
+																},
+																NestedObject: schema.NestedBlockObject{
+																	Blocks: map[string]schema.Block{
+																		"curated_query": schema.ListNestedBlock{
+																			CustomType: fwtypes.NewListNestedObjectTypeOf[curatedQueryModel](ctx),
+																			Validators: []validator.List{
+																				listvalidator.SizeAtMost(10),
+																			},
+																			PlanModifiers: []planmodifier.List{
+																				listplanmodifier.RequiresReplace(),
+																			},
+																			NestedObject: schema.NestedBlockObject{
+																				Attributes: map[string]schema.Attribute{
+																					"natural_language": schema.StringAttribute{
+																						Required: true,
+																						PlanModifiers: []planmodifier.String{
+																							stringplanmodifier.RequiresReplace(),
+																						},
+																					},
+																					"sql": schema.StringAttribute{
+																						Required: true,
+																						PlanModifiers: []planmodifier.String{
+																							stringplanmodifier.RequiresReplace(),
+																						},
+																					},
+																				},
+																			},
+																		},
+																		"table": schema.ListNestedBlock{
+																			CustomType: fwtypes.NewListNestedObjectTypeOf[queryGenerationTableModel](ctx),
+																			Validators: []validator.List{
+																				listvalidator.SizeAtMost(50),
+																			},
+																			PlanModifiers: []planmodifier.List{
+																				listplanmodifier.RequiresReplace(),
+																			},
+																			NestedObject: schema.NestedBlockObject{
+																				Attributes: map[string]schema.Attribute{
+																					names.AttrDescription: schema.StringAttribute{
+																						Optional: true,
+																						Validators: []validator.String{
+																							stringvalidator.LengthBetween(1, 200),
+																						},
+																						PlanModifiers: []planmodifier.String{
+																							stringplanmodifier.RequiresReplace(),
+																						},
+																					},
+																					"inclusion": schema.StringAttribute{
+																						CustomType: fwtypes.StringEnumType[awstypes.IncludeExclude](),
+																						Optional:   true,
+																						PlanModifiers: []planmodifier.String{
+																							stringplanmodifier.RequiresReplace(),
+																						},
+																					},
+																					names.AttrName: schema.StringAttribute{
+																						Required: true,
+																						PlanModifiers: []planmodifier.String{
+																							stringplanmodifier.RequiresReplace(),
+																						},
+																					},
+																				},
+																				Blocks: map[string]schema.Block{
+																					"column": schema.ListNestedBlock{
+																						CustomType: fwtypes.NewListNestedObjectTypeOf[queryGenerationColumnModel](ctx),
+																						PlanModifiers: []planmodifier.List{
+																							listplanmodifier.RequiresReplace(),
+																						},
+																						NestedObject: schema.NestedBlockObject{
+																							Attributes: map[string]schema.Attribute{
+																								names.AttrDescription: schema.StringAttribute{
+																									Optional: true,
+																									Validators: []validator.String{
+																										stringvalidator.LengthBetween(1, 200),
+																									},
+																									PlanModifiers: []planmodifier.String{
+																										stringplanmodifier.RequiresReplace(),
+																									},
+																								},
+																								"inclusion": schema.StringAttribute{
+																									CustomType: fwtypes.StringEnumType[awstypes.IncludeExclude](),
+																									Optional:   true,
+																									PlanModifiers: []planmodifier.String{
+																										stringplanmodifier.RequiresReplace(),
+																									},
+																								},
+																								names.AttrName: schema.StringAttribute{
+																									Optional: true,
+																									PlanModifiers: []planmodifier.String{
+																										stringplanmodifier.RequiresReplace(),
+																									},
+																								},
+																							},
+																						},
+																					},
+																				},
+																			},
+																		},
+																	},
+																},
+															},
+														},
+													},
+												},
+												"storage_configuration": schema.ListNestedBlock{
+													CustomType: fwtypes.NewListNestedObjectTypeOf[redshiftQueryEngineStorageConfigurationModel](ctx),
+													Validators: []validator.List{
+														listvalidator.IsRequired(),
+														listvalidator.SizeAtLeast(1),
+														listvalidator.SizeAtMost(1),
+													},
+													PlanModifiers: []planmodifier.List{
+														listplanmodifier.RequiresReplace(),
+													},
+													NestedObject: schema.NestedBlockObject{
+														Attributes: map[string]schema.Attribute{
+															names.AttrType: schema.StringAttribute{
+																CustomType: fwtypes.StringEnumType[awstypes.RedshiftQueryEngineStorageType](),
+																Required:   true,
+																PlanModifiers: []planmodifier.String{
+																	stringplanmodifier.RequiresReplace(),
+																},
+															},
+														},
+														Blocks: map[string]schema.Block{
+															"aws_data_catalog_configuration": schema.ListNestedBlock{
+																CustomType: fwtypes.NewListNestedObjectTypeOf[redshiftQueryEngineAWSDataCatalogStorageConfigurationModel](ctx),
+																Validators: []validator.List{
+																	listvalidator.SizeAtMost(1),
+																	listvalidator.ExactlyOneOf(
+																		path.MatchRelative().AtParent().AtName("aws_data_catalog_configuration"),
+																		path.MatchRelative().AtParent().AtName("redshift_configuration"),
+																	),
+																},
+																PlanModifiers: []planmodifier.List{
+																	listplanmodifier.RequiresReplace(),
+																},
+																NestedObject: schema.NestedBlockObject{
+																	Attributes: map[string]schema.Attribute{
+																		"table_names": schema.SetAttribute{
+																			CustomType: fwtypes.SetOfStringType,
+																			Required:   true,
+																			PlanModifiers: []planmodifier.Set{
+																				setplanmodifier.RequiresReplace(),
+																			},
+																		},
+																	},
+																},
+															},
+															"redshift_configuration": schema.ListNestedBlock{
+																CustomType: fwtypes.NewListNestedObjectTypeOf[redshiftQueryEngineRedshiftStorageConfigurationModel](ctx),
+																Validators: []validator.List{
+																	listvalidator.SizeAtMost(1),
+																},
+																PlanModifiers: []planmodifier.List{
+																	listplanmodifier.RequiresReplace(),
+																},
+																NestedObject: schema.NestedBlockObject{
+																	Attributes: map[string]schema.Attribute{
+																		names.AttrDatabaseName: schema.StringAttribute{
+																			Required: true,
+																			Validators: []validator.String{
+																				stringvalidator.LengthBetween(1, 200),
+																			},
+																			PlanModifiers: []planmodifier.String{
+																				stringplanmodifier.RequiresReplace(),
+																			},
+																		},
+																	},
+																},
+															},
+														},
+													},
+												},
+											},
+										},
+									},
+								},
+							},
+						},
 						"vector_knowledge_base_configuration": schema.ListNestedBlock{
 							CustomType: fwtypes.NewListNestedObjectTypeOf[vectorKnowledgeBaseConfigurationModel](ctx),
 							Validators: []validator.List{
-								listvalidator.IsRequired(),
-								listvalidator.SizeAtLeast(1),
 								listvalidator.SizeAtMost(1),
 							},
 							PlanModifiers: []planmodifier.List{
@@ -134,71 +537,408 @@ func (r *knowledgeBaseResource) Schema(ctx context.Context, request resource.Sch
 									},
 								},
 								Blocks: map[string]schema.Block{
-									"embedding_model_configuration": schema.ListNestedBlock{
+									"embedding_model_configuration": schema.ListNestedBlock{
+										CustomType: fwtypes.NewListNestedObjectTypeOf[embeddingModelConfigurationModel](ctx),
+										Validators: []validator.List{
+											listvalidator.SizeAtMost(1),
+										},
+										PlanModifiers: []planmodifier.List{
+											listplanmodifier.RequiresReplace(),
+										},
+										NestedObject: schema.NestedBlockObject{
+											Blocks: map[string]schema.Block{
+												"bedrock_embedding_model_configuration": schema.ListNestedBlock{
+													CustomType: fwtypes.NewListNestedObjectTypeOf[bedrockEmbeddingModelConfigurationModel](ctx),
+													Validators: []validator.List{
+														listvalidator.SizeAtMost(1),
+													},
+													PlanModifiers: []planmodifier.List{
+														listplanmodifier.RequiresReplace(),
+													},
+													NestedObject: schema.NestedBlockObject{
+														Attributes: map[string]schema.Attribute{
+															"dimensions": schema.Int64Attribute{
+																Optional: true,
+																PlanModifiers: []planmodifier.Int64{
+																	int64planmodifier.RequiresReplace(),
+																},
+															},
+															"embedding_data_type": schema.StringAttribute{
+																CustomType: fwtypes.StringEnumType[awstypes.EmbeddingDataType](),
+																Optional:   true,
+																PlanModifiers: []planmodifier.String{
+																	stringplanmodifier.RequiresReplace(),
+																},
+															},
+														},
+													},
+												},
+											},
+										},
+									},
+									"supplemental_data_storage_configuration": schema.ListNestedBlock{
+										CustomType: fwtypes.NewListNestedObjectTypeOf[supplementalDataStorageConfigurationModel](ctx),
+										Validators: []validator.List{
+											listvalidator.SizeAtMost(1),
+										},
+										PlanModifiers: []planmodifier.List{
+											listplanmodifier.RequiresReplace(),
+										},
+										NestedObject: schema.NestedBlockObject{
+											Blocks: map[string]schema.Block{
+												"storage_location": schema.ListNestedBlock{
+													CustomType: fwtypes.NewListNestedObjectTypeOf[storageLocationModel](ctx),
+													Validators: []validator.List{
+														listvalidator.IsRequired(),
+														listvalidator.SizeAtLeast(1),
+														listvalidator.SizeAtMost(1),
+													},
+													PlanModifiers: []planmodifier.List{
+														listplanmodifier.RequiresReplace(),
+													},
+													NestedObject: schema.NestedBlockObject{
+														Attributes: map[string]schema.Attribute{
+															names.AttrType: schema.StringAttribute{
+																CustomType: fwtypes.StringEnumType[awstypes.SupplementalDataStorageLocationType](),
+																Required:   true,
+																PlanModifiers: []planmodifier.String{
+																	stringplanmodifier.RequiresReplace(),
+																},
+															},
+														},
+														Blocks: map[string]schema.Block{
+															"s3_location": schema.ListNestedBlock{
+																CustomType: fwtypes.NewListNestedObjectTypeOf[s3LocationModel](ctx),
+																Validators: []validator.List{
+																	listvalidator.SizeAtMost(1),
+																},
+																PlanModifiers: []planmodifier.List{
+																	listplanmodifier.RequiresReplace(),
+																},
+																NestedObject: schema.NestedBlockObject{
+																	Attributes: map[string]schema.Attribute{
+																		names.AttrURI: schema.StringAttribute{
+																			Required: true,
+																			Validators: []validator.String{
+																				stringvalidator.RegexMatches(
+																					regexache.MustCompile(`^s3://[a-z0-9.-]+(/.*)?$`),
+																					"must be a valid S3 URI",
+																				),
+																			},
+																			PlanModifiers: []planmodifier.String{
+																				stringplanmodifier.RequiresReplace(),
+																			},
+																		},
+																	},
+																},
+															},
+														},
+													},
+												},
+											},
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+			"storage_configuration": schema.ListNestedBlock{
+				CustomType: fwtypes.NewListNestedObjectTypeOf[storageConfigurationModel](ctx),
+				Validators: []validator.List{
+					listvalidator.SizeAtMost(1),
+				},
+				PlanModifiers: []planmodifier.List{
+					listplanmodifier.RequiresReplace(),
+				},
+				NestedObject: schema.NestedBlockObject{
+					Attributes: map[string]schema.Attribute{
+						names.AttrType: schema.StringAttribute{
+							CustomType: fwtypes.StringEnumType[awstypes.KnowledgeBaseStorageType](),
+							Required:   true,
+							PlanModifiers: []planmodifier.String{
+								stringplanmodifier.RequiresReplace(),
+							},
+						},
+					},
+					Blocks: map[string]schema.Block{
+						"mongo_db_atlas_configuration": schema.ListNestedBlock{
+							CustomType: fwtypes.NewListNestedObjectTypeOf[mongoDBAtlasConfigurationModel](ctx),
+							Validators: []validator.List{
+								listvalidator.SizeAtMost(1),
+								listvalidator.ExactlyOneOf(
+									path.MatchRelative().AtParent().AtName("mongo_db_atlas_configuration"),
+									path.MatchRelative().AtParent().AtName("neptune_analytics_configuration"),
+									path.MatchRelative().AtParent().AtName("opensearch_managed_cluster_configuration"),
+									path.MatchRelative().AtParent().AtName("opensearch_serverless_configuration"),
+									path.MatchRelative().AtParent().AtName("pinecone_configuration"),
+									path.MatchRelative().AtParent().AtName("rds_configuration"),
+									path.MatchRelative().AtParent().AtName("redis_enterprise_cloud_configuration"),
+									path.MatchRelative().AtParent().AtName("s3_vectors_configuration"),
+								),
+							},
+							PlanModifiers: []planmodifier.List{
+								listplanmodifier.RequiresReplace(),
+							},
+							NestedObject: schema.NestedBlockObject{
+								Attributes: map[string]schema.Attribute{
+									"collection_name": schema.StringAttribute{
+										Required: true,
+										PlanModifiers: []planmodifier.String{
+											stringplanmodifier.RequiresReplace(),
+										},
+									},
+									"credentials_secret_arn": schema.StringAttribute{
+										CustomType: fwtypes.ARNType,
+										Required:   true,
+										PlanModifiers: []planmodifier.String{
+											stringplanmodifier.RequiresReplace(),
+										},
+									},
+									names.AttrDatabaseName: schema.StringAttribute{
+										Required: true,
+										PlanModifiers: []planmodifier.String{
+											stringplanmodifier.RequiresReplace(),
+										},
+									},
+									names.AttrEndpoint: schema.StringAttribute{
+										Required: true,
+										PlanModifiers: []planmodifier.String{
+											stringplanmodifier.RequiresReplace(),
+										},
+									},
+									"endpoint_service_name": schema.StringAttribute{
+										Optional: true,
+										PlanModifiers: []planmodifier.String{
+											stringplanmodifier.RequiresReplace(),
+										},
+									},
+									"text_index_name": schema.StringAttribute{
+										Optional: true,
+										PlanModifiers: []planmodifier.String{
+											stringplanmodifier.RequiresReplace(),
+										},
+									},
+									"vector_index_name": schema.StringAttribute{
+										Required: true,
+										PlanModifiers: []planmodifier.String{
+											stringplanmodifier.RequiresReplace(),
+										},
+									},
+								},
+								Blocks: map[string]schema.Block{
+									"field_mapping": schema.ListNestedBlock{
+										CustomType: fwtypes.NewListNestedObjectTypeOf[mongoDBAtlasFieldMappingModel](ctx),
+										Validators: []validator.List{
+											listvalidator.IsRequired(),
+											listvalidator.SizeAtLeast(1),
+											listvalidator.SizeAtMost(1),
+										},
+										PlanModifiers: []planmodifier.List{
+											listplanmodifier.RequiresReplace(),
+										},
+										NestedObject: schema.NestedBlockObject{
+											Attributes: map[string]schema.Attribute{
+												"metadata_field": schema.StringAttribute{
+													Required: true,
+													PlanModifiers: []planmodifier.String{
+														stringplanmodifier.RequiresReplace(),
+													},
+												},
+												"text_field": schema.StringAttribute{
+													Required: true,
+													PlanModifiers: []planmodifier.String{
+														stringplanmodifier.RequiresReplace(),
+													},
+												},
+												"vector_field": schema.StringAttribute{
+													Required: true,
+													PlanModifiers: []planmodifier.String{
+														stringplanmodifier.RequiresReplace(),
+													},
+												},
+											},
+										},
+									},
+								},
+							},
+						},
+						"neptune_analytics_configuration": schema.ListNestedBlock{
+							CustomType: fwtypes.NewListNestedObjectTypeOf[neptuneAnalyticsConfigurationModel](ctx),
+							Validators: []validator.List{
+								listvalidator.SizeAtMost(1),
+							},
+							PlanModifiers: []planmodifier.List{
+								listplanmodifier.RequiresReplace(),
+							},
+							NestedObject: schema.NestedBlockObject{
+								Attributes: map[string]schema.Attribute{
+									"graph_arn": schema.StringAttribute{
+										CustomType: fwtypes.ARNType,
+										Required:   true,
+										PlanModifiers: []planmodifier.String{
+											stringplanmodifier.RequiresReplace(),
+										},
+									},
+								},
+								Blocks: map[string]schema.Block{
+									"field_mapping": schema.ListNestedBlock{
+										CustomType: fwtypes.NewListNestedObjectTypeOf[neptuneAnalyticsFieldMappingModel](ctx),
+										Validators: []validator.List{
+											listvalidator.IsRequired(),
+											listvalidator.SizeAtLeast(1),
+											listvalidator.SizeAtMost(1),
+										},
+										PlanModifiers: []planmodifier.List{
+											listplanmodifier.RequiresReplace(),
+										},
+										NestedObject: schema.NestedBlockObject{
+											Attributes: map[string]schema.Attribute{
+												"metadata_field": schema.StringAttribute{
+													Required: true,
+													PlanModifiers: []planmodifier.String{
+														stringplanmodifier.RequiresReplace(),
+													},
+												},
+												"text_field": schema.StringAttribute{
+													Required: true,
+													PlanModifiers: []planmodifier.String{
+														stringplanmodifier.RequiresReplace(),
+													},
+												},
+											},
+										},
+									},
+								},
+							},
+						},
+						"opensearch_managed_cluster_configuration": schema.ListNestedBlock{
+							CustomType: fwtypes.NewListNestedObjectTypeOf[openSearchManagedClusterConfigurationModel](ctx),
+							Validators: []validator.List{
+								listvalidator.SizeAtMost(1),
+							},
+							PlanModifiers: []planmodifier.List{
+								listplanmodifier.RequiresReplace(),
+							},
+							NestedObject: schema.NestedBlockObject{
+								Attributes: map[string]schema.Attribute{
+									"domain_arn": schema.StringAttribute{
+										CustomType: fwtypes.ARNType,
+										Required:   true,
+										PlanModifiers: []planmodifier.String{
+											stringplanmodifier.RequiresReplace(),
+										},
+									},
+									"domain_endpoint": schema.StringAttribute{
+										Required: true,
+										Validators: []validator.String{
+											stringvalidator.RegexMatches(
+												regexache.MustCompile(`^https://.*$`),
+												"must be a valid HTTPS URL",
+											),
+										},
+										PlanModifiers: []planmodifier.String{
+											stringplanmodifier.RequiresReplace(),
+										},
+									},
+									"vector_index_name": schema.StringAttribute{
+										Required: true,
+										PlanModifiers: []planmodifier.String{
+											stringplanmodifier.RequiresReplace(),
+										},
+									},
+								},
+								Blocks: map[string]schema.Block{
+									"field_mapping": schema.ListNestedBlock{
+										CustomType: fwtypes.NewListNestedObjectTypeOf[opensearchManagedClusterFieldMappingModel](ctx),
 										Validators: []validator.List{
-											listvalidator.SizeAtLeast(0),
+											listvalidator.IsRequired(),
+											listvalidator.SizeAtLeast(1),
 											listvalidator.SizeAtMost(1),
 										},
+										PlanModifiers: []planmodifier.List{
+											listplanmodifier.RequiresReplace(),
+										},
 										NestedObject: schema.NestedBlockObject{
-											Blocks: map[string]schema.Block{
-												"bedrock_embedding_model_configuration": schema.ListNestedBlock{
-													Validators: []validator.List{
-														listvalidator.SizeAtLeast(0),
-														listvalidator.SizeAtMost(1),
+											Attributes: map[string]schema.Attribute{
+												"metadata_field": schema.StringAttribute{
+													Required: true,
+													PlanModifiers: []planmodifier.String{
+														stringplanmodifier.RequiresReplace(),
 													},
-													NestedObject: schema.NestedBlockObject{
-														Attributes: map[string]schema.Attribute{
-															"dimensions": schema.Int64Attribute{
-																Optional: true,
-															},
-															"embedding_data_type": schema.StringAttribute{
-																CustomType: fwtypes.StringEnumType[awstypes.EmbeddingDataType](),
-																Optional:   true,
-															},
-														},
+												},
+												"text_field": schema.StringAttribute{
+													Required: true,
+													PlanModifiers: []planmodifier.String{
+														stringplanmodifier.RequiresReplace(),
+													},
+												},
+												"vector_field": schema.StringAttribute{
+													Required: true,
+													PlanModifiers: []planmodifier.String{
+														stringplanmodifier.RequiresReplace(),
 													},
 												},
 											},
 										},
 									},
-									"supplemental_data_storage_configuration": schema.ListNestedBlock{
+								},
+							},
+						},
+						"opensearch_serverless_configuration": schema.ListNestedBlock{
+							CustomType: fwtypes.NewListNestedObjectTypeOf[openSearchServerlessConfigurationModel](ctx),
+							Validators: []validator.List{
+								listvalidator.SizeAtMost(1),
+							},
+							PlanModifiers: []planmodifier.List{
+								listplanmodifier.RequiresReplace(),
+							},
+							NestedObject: schema.NestedBlockObject{
+								Attributes: map[string]schema.Attribute{
+									"collection_arn": schema.StringAttribute{
+										CustomType: fwtypes.ARNType,
+										Required:   true,
+										PlanModifiers: []planmodifier.String{
+											stringplanmodifier.RequiresReplace(),
+										},
+									},
+									"vector_index_name": schema.StringAttribute{
+										Required: true,
+										PlanModifiers: []planmodifier.String{
+											stringplanmodifier.RequiresReplace(),
+										},
+									},
+								},
+								Blocks: map[string]schema.Block{
+									"field_mapping": schema.ListNestedBlock{
+										CustomType: fwtypes.NewListNestedObjectTypeOf[openSearchServerlessFieldMappingModel](ctx),
 										Validators: []validator.List{
-											listvalidator.SizeAtLeast(0),
+											listvalidator.IsRequired(),
+											listvalidator.SizeAtLeast(1),
 											listvalidator.SizeAtMost(1),
 										},
+										PlanModifiers: []planmodifier.List{
+											listplanmodifier.RequiresReplace(),
+										},
 										NestedObject: schema.NestedBlockObject{
-											Blocks: map[string]schema.Block{
-												"storage_location": schema.ListNestedBlock{
-													Validators: []validator.List{
-														listvalidator.SizeAtLeast(1),
+											Attributes: map[string]schema.Attribute{
+												"metadata_field": schema.StringAttribute{
+													Required: true,
+													PlanModifiers: []planmodifier.String{
+														stringplanmodifier.RequiresReplace(),
 													},
-													NestedObject: schema.NestedBlockObject{
-														Attributes: map[string]schema.Attribute{
-															names.AttrType: schema.StringAttribute{
-																CustomType: fwtypes.StringEnumType[awstypes.SupplementalDataStorageLocationType](),
-																Required:   true,
-															},
-														},
-														Blocks: map[string]schema.Block{
-															"s3_location": schema.ListNestedBlock{
-																Validators: []validator.List{
-																	listvalidator.SizeAtMost(1),
-																},
-																NestedObject: schema.NestedBlockObject{
-																	Attributes: map[string]schema.Attribute{
-																		names.AttrURI: schema.StringAttribute{
-																			Required: true,
-																			Validators: []validator.String{
-																				stringvalidator.RegexMatches(
-																					regexache.MustCompile(`^s3://[a-z0-9.-]+(/.*)?$`),
-																					"must be a valid S3 URI",
-																				),
-																			},
-																		},
-																	},
-																},
-															},
-														},
+												},
+												"text_field": schema.StringAttribute{
+													Required: true,
+													PlanModifiers: []planmodifier.String{
+														stringplanmodifier.RequiresReplace(),
+													},
+												},
+												"vector_field": schema.StringAttribute{
+													Required: true,
+													PlanModifiers: []planmodifier.String{
+														stringplanmodifier.RequiresReplace(),
 													},
 												},
 											},
@@ -207,29 +947,6 @@ func (r *knowledgeBaseResource) Schema(ctx context.Context, request resource.Sch
 								},
 							},
 						},
-					},
-				},
-			},
-			"storage_configuration": schema.ListNestedBlock{
-				CustomType: fwtypes.NewListNestedObjectTypeOf[storageConfigurationModel](ctx),
-				Validators: []validator.List{
-					listvalidator.IsRequired(),
-					listvalidator.SizeAtLeast(1),
-					listvalidator.SizeAtMost(1),
-				},
-				PlanModifiers: []planmodifier.List{
-					listplanmodifier.RequiresReplace(),
-				},
-				NestedObject: schema.NestedBlockObject{
-					Attributes: map[string]schema.Attribute{
-						names.AttrType: schema.StringAttribute{
-							Required: true,
-							PlanModifiers: []planmodifier.String{
-								stringplanmodifier.RequiresReplace(),
-							},
-						},
-					},
-					Blocks: map[string]schema.Block{
 						"pinecone_configuration": schema.ListNestedBlock{
 							CustomType: fwtypes.NewListNestedObjectTypeOf[pineconeConfigurationModel](ctx),
 							Validators: []validator.List{
@@ -264,6 +981,8 @@ func (r *knowledgeBaseResource) Schema(ctx context.Context, request resource.Sch
 									"field_mapping": schema.ListNestedBlock{
 										CustomType: fwtypes.NewListNestedObjectTypeOf[pineconeFieldMappingModel](ctx),
 										Validators: []validator.List{
+											listvalidator.IsRequired(),
+											listvalidator.SizeAtLeast(1),
 											listvalidator.SizeAtMost(1),
 										},
 										PlanModifiers: []planmodifier.List{
@@ -272,13 +991,13 @@ func (r *knowledgeBaseResource) Schema(ctx context.Context, request resource.Sch
 										NestedObject: schema.NestedBlockObject{
 											Attributes: map[string]schema.Attribute{
 												"metadata_field": schema.StringAttribute{
-													Optional: true,
+													Required: true,
 													PlanModifiers: []planmodifier.String{
 														stringplanmodifier.RequiresReplace(),
 													},
 												},
 												"text_field": schema.StringAttribute{
-													Optional: true,
+													Required: true,
 													PlanModifiers: []planmodifier.String{
 														stringplanmodifier.RequiresReplace(),
 													},
@@ -330,6 +1049,8 @@ func (r *knowledgeBaseResource) Schema(ctx context.Context, request resource.Sch
 									"field_mapping": schema.ListNestedBlock{
 										CustomType: fwtypes.NewListNestedObjectTypeOf[rdsFieldMappingModel](ctx),
 										Validators: []validator.List{
+											listvalidator.IsRequired(),
+											listvalidator.SizeAtLeast(1),
 											listvalidator.SizeAtMost(1),
 										},
 										PlanModifiers: []planmodifier.List{
@@ -407,6 +1128,8 @@ func (r *knowledgeBaseResource) Schema(ctx context.Context, request resource.Sch
 									"field_mapping": schema.ListNestedBlock{
 										CustomType: fwtypes.NewListNestedObjectTypeOf[redisEnterpriseCloudFieldMappingModel](ctx),
 										Validators: []validator.List{
+											listvalidator.IsRequired(),
+											listvalidator.SizeAtLeast(1),
 											listvalidator.SizeAtMost(1),
 										},
 										PlanModifiers: []planmodifier.List{
@@ -438,8 +1161,8 @@ func (r *knowledgeBaseResource) Schema(ctx context.Context, request resource.Sch
 								},
 							},
 						},
-						"opensearch_serverless_configuration": schema.ListNestedBlock{
-							CustomType: fwtypes.NewListNestedObjectTypeOf[opensearchServerlessConfigurationModel](ctx),
+						"s3_vectors_configuration": schema.ListNestedBlock{
+							CustomType: fwtypes.NewListNestedObjectTypeOf[s3VectorsConfigurationModel](ctx),
 							Validators: []validator.List{
 								listvalidator.SizeAtMost(1),
 							},
@@ -448,53 +1171,41 @@ func (r *knowledgeBaseResource) Schema(ctx context.Context, request resource.Sch
 							},
 							NestedObject: schema.NestedBlockObject{
 								Attributes: map[string]schema.Attribute{
-									"collection_arn": schema.StringAttribute{
+									"index_arn": schema.StringAttribute{
 										CustomType: fwtypes.ARNType,
-										Required:   true,
+										Optional:   true,
+										Validators: []validator.String{
+											stringvalidator.ConflictsWith(path.MatchRelative().AtParent().AtName("index_name"), path.MatchRelative().AtParent().AtName("vector_bucket_arn")),
+										},
 										PlanModifiers: []planmodifier.String{
 											stringplanmodifier.RequiresReplace(),
 										},
 									},
-									"vector_index_name": schema.StringAttribute{
-										Required: true,
+									"index_name": schema.StringAttribute{
+										Optional: true,
+										Validators: []validator.String{
+											stringvalidator.AlsoRequires(path.MatchRelative().AtParent().AtName("vector_bucket_arn")),
+											stringvalidator.ConflictsWith(path.MatchRelative().AtParent().AtName("index_arn")),
+										},
 										PlanModifiers: []planmodifier.String{
 											stringplanmodifier.RequiresReplace(),
 										},
 									},
-								},
-								Blocks: map[string]schema.Block{
-									"field_mapping": schema.ListNestedBlock{
-										CustomType: fwtypes.NewListNestedObjectTypeOf[opensearchServerlessFieldMappingModel](ctx),
-										Validators: []validator.List{
-											listvalidator.SizeAtMost(1),
-										},
-										PlanModifiers: []planmodifier.List{
-											listplanmodifier.RequiresReplace(),
+									"vector_bucket_arn": schema.StringAttribute{
+										CustomType: fwtypes.ARNType,
+										Optional:   true,
+										Validators: []validator.String{
+											stringvalidator.AlsoRequires(path.MatchRelative().AtParent().AtName("index_name")),
+											stringvalidator.ConflictsWith(path.MatchRelative().AtParent().AtName("index_arn")),
 										},
-										NestedObject: schema.NestedBlockObject{
-											Attributes: map[string]schema.Attribute{
-												"metadata_field": schema.StringAttribute{
-													Optional: true,
-													PlanModifiers: []planmodifier.String{
-														stringplanmodifier.RequiresReplace(),
-													},
-												},
-												"text_field": schema.StringAttribute{
-													Optional: true,
-													PlanModifiers: []planmodifier.String{
-														stringplanmodifier.RequiresReplace(),
-													},
-												},
-												"vector_field": schema.StringAttribute{
-													Optional: true,
-													PlanModifiers: []planmodifier.String{
-														stringplanmodifier.RequiresReplace(),
-													},
-												},
-											},
+										PlanModifiers: []planmodifier.String{
+											stringplanmodifier.RequiresReplace(),
 										},
 									},
 								},
+								Validators: []validator.Object{
+									objectvalidator.AtLeastOneOf(path.MatchRelative().AtName("index_arn"), path.MatchRelative().AtName("index_name")),
+								},
 							},
 						},
 					},
@@ -518,8 +1229,8 @@ func (r *knowledgeBaseResource) Create(ctx context.Context, request resource.Cre
 
 	conn := r.Meta().BedrockAgentClient(ctx)
 
-	input := &bedrockagent.CreateKnowledgeBaseInput{}
-	response.Diagnostics.Append(fwflex.Expand(ctx, data, input)...)
+	var input bedrockagent.CreateKnowledgeBaseInput
+	response.Diagnostics.Append(fwflex.Expand(ctx, data, &input)...)
 	if response.Diagnostics.HasError() {
 		return
 	}
@@ -531,7 +1242,7 @@ func (r *knowledgeBaseResource) Create(ctx context.Context, request resource.Cre
 	var output *bedrockagent.CreateKnowledgeBaseOutput
 	var err error
 	err = tfresource.Retry(ctx, propagationTimeout, func(ctx context.Context) *tfresource.RetryError {
-		output, err = conn.CreateKnowledgeBase(ctx, input)
+		output, err = conn.CreateKnowledgeBase(ctx, &input)
 
 		// IAM propagation
 		if tfawserr.ErrMessageContains(err, errCodeValidationException, "cannot assume role") {
@@ -541,6 +1252,11 @@ func (r *knowledgeBaseResource) Create(ctx context.Context, request resource.Cre
 			return tfresource.RetryableError(err)
 		}
 
+		// Kendra access propagation
+		if tfawserr.ErrMessageContains(err, errCodeValidationException, "Encountered AccessDeniedException from Kendra") {
+			return tfresource.RetryableError(err)
+		}
+
 		// OpenSearch data access propagation
 		if tfawserr.ErrMessageContains(err, errCodeValidationException, "storage configuration provided is invalid") {
 			return tfresource.RetryableError(err)
@@ -559,13 +1275,14 @@ func (r *knowledgeBaseResource) Create(ctx context.Context, request resource.Cre
 	}
 
 	kb := output.KnowledgeBase
+	knowledgeBaseID := aws.ToString(kb.KnowledgeBaseId)
 	data.KnowledgeBaseARN = fwflex.StringToFramework(ctx, kb.KnowledgeBaseArn)
-	data.KnowledgeBaseID = fwflex.StringToFramework(ctx, kb.KnowledgeBaseId)
+	data.KnowledgeBaseID = fwflex.StringValueToFramework(ctx, knowledgeBaseID)
 
-	kb, err = waitKnowledgeBaseCreated(ctx, conn, data.KnowledgeBaseID.ValueString(), r.CreateTimeout(ctx, data.Timeouts))
+	kb, err = waitKnowledgeBaseCreated(ctx, conn, knowledgeBaseID, r.CreateTimeout(ctx, data.Timeouts))
 
 	if err != nil {
-		response.Diagnostics.AddError(fmt.Sprintf("waiting for Bedrock Agent Knowledge Base (%s) create", data.KnowledgeBaseID.ValueString()), err.Error())
+		response.Diagnostics.AddError(fmt.Sprintf("waiting for Bedrock Agent Knowledge Base (%s) create", knowledgeBaseID), err.Error())
 		return
 	}
 
@@ -586,7 +1303,8 @@ func (r *knowledgeBaseResource) Read(ctx context.Context, request resource.ReadR
 
 	conn := r.Meta().BedrockAgentClient(ctx)
 
-	kb, err := findKnowledgeBaseByID(ctx, conn, data.KnowledgeBaseID.ValueString())
+	knowledgeBaseID := fwflex.StringValueFromFramework(ctx, data.KnowledgeBaseID)
+	kb, err := findKnowledgeBaseByID(ctx, conn, knowledgeBaseID)
 
 	if retry.NotFound(err) {
 		response.Diagnostics.Append(fwdiag.NewResourceNotFoundWarningDiagnostic(err))
@@ -596,7 +1314,7 @@ func (r *knowledgeBaseResource) Read(ctx context.Context, request resource.ReadR
 	}
 
 	if err != nil {
-		response.Diagnostics.AddError(fmt.Sprintf("reading Bedrock Agent Knowledge Base (%s)", data.KnowledgeBaseID.ValueString()), err.Error())
+		response.Diagnostics.AddError(fmt.Sprintf("reading Bedrock Agent Knowledge Base (%s)", knowledgeBaseID), err.Error())
 
 		return
 	}
@@ -625,26 +1343,27 @@ func (r *knowledgeBaseResource) Update(ctx context.Context, request resource.Upd
 	if !new.Description.Equal(old.Description) ||
 		!new.Name.Equal(old.Name) ||
 		!new.RoleARN.Equal(old.RoleARN) {
-		input := &bedrockagent.UpdateKnowledgeBaseInput{}
-		response.Diagnostics.Append(fwflex.Expand(ctx, new, input)...)
+		knowledgeBaseID := fwflex.StringValueFromFramework(ctx, new.KnowledgeBaseID)
+		var input bedrockagent.UpdateKnowledgeBaseInput
+		response.Diagnostics.Append(fwflex.Expand(ctx, new, &input)...)
 		if response.Diagnostics.HasError() {
 			return
 		}
 
 		_, err := tfresource.RetryWhenAWSErrMessageContains(ctx, propagationTimeout, func(ctx context.Context) (any, error) {
-			return conn.UpdateKnowledgeBase(ctx, input)
+			return conn.UpdateKnowledgeBase(ctx, &input)
 		}, errCodeValidationException, "cannot assume role")
 
 		if err != nil {
-			response.Diagnostics.AddError(fmt.Sprintf("updating Bedrock Agent Knowledge Base (%s)", new.KnowledgeBaseID.ValueString()), err.Error())
+			response.Diagnostics.AddError(fmt.Sprintf("updating Bedrock Agent Knowledge Base (%s)", knowledgeBaseID), err.Error())
 
 			return
 		}
 
-		kb, err := waitKnowledgeBaseUpdated(ctx, conn, new.KnowledgeBaseID.ValueString(), r.UpdateTimeout(ctx, new.Timeouts))
+		kb, err := waitKnowledgeBaseUpdated(ctx, conn, knowledgeBaseID, r.UpdateTimeout(ctx, new.Timeouts))
 
 		if err != nil {
-			response.Diagnostics.AddError(fmt.Sprintf("waiting for Bedrock Agent Knowledge Base (%s) create", new.KnowledgeBaseID.ValueString()), err.Error())
+			response.Diagnostics.AddError(fmt.Sprintf("waiting for Bedrock Agent Knowledge Base (%s) update", knowledgeBaseID), err.Error())
 
 			return
 		}
@@ -668,8 +1387,9 @@ func (r *knowledgeBaseResource) Delete(ctx context.Context, request resource.Del
 
 	conn := r.Meta().BedrockAgentClient(ctx)
 
+	knowledgeBaseID := fwflex.StringValueFromFramework(ctx, data.KnowledgeBaseID)
 	input := bedrockagent.DeleteKnowledgeBaseInput{
-		KnowledgeBaseId: data.KnowledgeBaseID.ValueStringPointer(),
+		KnowledgeBaseId: aws.String(knowledgeBaseID),
 	}
 	_, err := conn.DeleteKnowledgeBase(ctx, &input)
 
@@ -678,15 +1398,13 @@ func (r *knowledgeBaseResource) Delete(ctx context.Context, request resource.Del
 	}
 
 	if err != nil {
-		response.Diagnostics.AddError(fmt.Sprintf("deleting Bedrock Agent Knowledge Base (%s)", data.KnowledgeBaseID.ValueString()), err.Error())
+		response.Diagnostics.AddError(fmt.Sprintf("deleting Bedrock Agent Knowledge Base (%s)", knowledgeBaseID), err.Error())
 
 		return
 	}
 
-	_, err = waitKnowledgeBaseDeleted(ctx, conn, data.KnowledgeBaseID.ValueString(), r.DeleteTimeout(ctx, data.Timeouts))
-
-	if err != nil {
-		response.Diagnostics.AddError(fmt.Sprintf("waiting for Bedrock Agent Knowledge Base (%s) delete", data.KnowledgeBaseID.ValueString()), err.Error())
+	if _, err := waitKnowledgeBaseDeleted(ctx, conn, knowledgeBaseID, r.DeleteTimeout(ctx, data.Timeouts)); err != nil {
+		response.Diagnostics.AddError(fmt.Sprintf("waiting for Bedrock Agent Knowledge Base (%s) delete", knowledgeBaseID), err.Error())
 
 		return
 	}
@@ -766,10 +1484,14 @@ func statusKnowledgeBase(ctx context.Context, conn *bedrockagent.Client, id stri
 }
 
 func findKnowledgeBaseByID(ctx context.Context, conn *bedrockagent.Client, id string) (*awstypes.KnowledgeBase, error) {
-	input := &bedrockagent.GetKnowledgeBaseInput{
+	input := bedrockagent.GetKnowledgeBaseInput{
 		KnowledgeBaseId: aws.String(id),
 	}
 
+	return findKnowledgeBase(ctx, conn, &input)
+}
+
+func findKnowledgeBase(ctx context.Context, conn *bedrockagent.Client, input *bedrockagent.GetKnowledgeBaseInput) (*awstypes.KnowledgeBase, error) {
 	output, err := conn.GetKnowledgeBase(ctx, input)
 
 	if errs.IsA[*awstypes.ResourceNotFoundException](err) {
@@ -808,10 +1530,96 @@ type knowledgeBaseResourceModel struct {
 }
 
 type knowledgeBaseConfigurationModel struct {
-	Type                             types.String                                                           `tfsdk:"type"`
+	KendraKnowledgeBaseConfiguration fwtypes.ListNestedObjectValueOf[kendraKnowledgeBaseConfigurationModel] `tfsdk:"kendra_knowledge_base_configuration"`
+	SQLKnowledgeBaseConfiguration    fwtypes.ListNestedObjectValueOf[sqlKnowledgeBaseConfigurationModel]    `tfsdk:"sql_knowledge_base_configuration"`
+	Type                             fwtypes.StringEnum[awstypes.KnowledgeBaseType]                         `tfsdk:"type"`
 	VectorKnowledgeBaseConfiguration fwtypes.ListNestedObjectValueOf[vectorKnowledgeBaseConfigurationModel] `tfsdk:"vector_knowledge_base_configuration"`
 }
 
+type kendraKnowledgeBaseConfigurationModel struct {
+	KendraIndexARN fwtypes.ARN `tfsdk:"kendra_index_arn"`
+}
+
+type sqlKnowledgeBaseConfigurationModel struct {
+	RedshiftConfiguration fwtypes.ListNestedObjectValueOf[redshiftConfigurationModel] `tfsdk:"redshift_configuration"`
+	Type                  fwtypes.StringEnum[awstypes.QueryEngineType]                `tfsdk:"type"`
+}
+
+type redshiftConfigurationModel struct {
+	QueryEngineConfiguration     fwtypes.ListNestedObjectValueOf[redshiftQueryEngineConfigurationModel]        `tfsdk:"query_engine_configuration"`
+	QueryGenerationConfiguration fwtypes.ListNestedObjectValueOf[queryGenerationConfigurationModel]            `tfsdk:"query_generation_configuration"`
+	StorageConfigurations        fwtypes.ListNestedObjectValueOf[redshiftQueryEngineStorageConfigurationModel] `tfsdk:"storage_configuration"`
+}
+
+type redshiftQueryEngineConfigurationModel struct {
+	ProvisionedConfiguration fwtypes.ListNestedObjectValueOf[redshiftProvisionedConfigurationModel] `tfsdk:"provisioned_configuration"`
+	ServerlessConfiguration  fwtypes.ListNestedObjectValueOf[redshiftServerlessConfigurationModel]  `tfsdk:"serverless_configuration"`
+	Type                     fwtypes.StringEnum[awstypes.RedshiftQueryEngineType]                   `tfsdk:"type"`
+}
+
+type redshiftProvisionedConfigurationModel struct {
+	AuthConfiguration fwtypes.ListNestedObjectValueOf[redshiftProvisionedAuthConfigurationModel] `tfsdk:"auth_configuration"`
+	ClusterIdentifier types.String                                                               `tfsdk:"cluster_identifier"`
+}
+
+type redshiftProvisionedAuthConfigurationModel struct {
+	DatabaseUser              types.String                                             `tfsdk:"database_user"`
+	Type                      fwtypes.StringEnum[awstypes.RedshiftProvisionedAuthType] `tfsdk:"type"`
+	UsernamePasswordSecretARN fwtypes.ARN                                              `tfsdk:"username_password_secret_arn"`
+}
+
+type redshiftServerlessConfigurationModel struct {
+	AuthConfiguration fwtypes.ListNestedObjectValueOf[redshiftServerlessAuthConfigurationModel] `tfsdk:"auth_configuration"`
+	WorkgroupARN      fwtypes.ARN                                                               `tfsdk:"workgroup_arn"`
+}
+
+type redshiftServerlessAuthConfigurationModel struct {
+	Type                      fwtypes.StringEnum[awstypes.RedshiftServerlessAuthType] `tfsdk:"type"`
+	UsernamePasswordSecretARN fwtypes.ARN                                             `tfsdk:"username_password_secret_arn"`
+}
+
+type queryGenerationConfigurationModel struct {
+	ExecutionTimeoutSeconds types.Int64                                                  `tfsdk:"execution_timeout_seconds"`
+	GenerationContext       fwtypes.ListNestedObjectValueOf[queryGenerationContextModel] `tfsdk:"generation_context"`
+}
+
+type queryGenerationContextModel struct {
+	CuratedQueries fwtypes.ListNestedObjectValueOf[curatedQueryModel]         `tfsdk:"curated_query"`
+	Tables         fwtypes.ListNestedObjectValueOf[queryGenerationTableModel] `tfsdk:"table"`
+}
+
+type curatedQueryModel struct {
+	NaturalLanguage types.String `tfsdk:"natural_language"`
+	SQL             types.String `tfsdk:"sql"`
+}
+
+type queryGenerationTableModel struct {
+	Columns     fwtypes.ListNestedObjectValueOf[queryGenerationColumnModel] `tfsdk:"column"`
+	Description types.String                                                `tfsdk:"description"`
+	Inclusion   fwtypes.StringEnum[awstypes.IncludeExclude]                 `tfsdk:"inclusion"`
+	Name        types.String                                                `tfsdk:"name"`
+}
+
+type queryGenerationColumnModel struct {
+	Description types.String                                `tfsdk:"description"`
+	Inclusion   fwtypes.StringEnum[awstypes.IncludeExclude] `tfsdk:"inclusion"`
+	Name        types.String                                `tfsdk:"name"`
+}
+
+type redshiftQueryEngineStorageConfigurationModel struct {
+	AWSDataCatalogConfiguration fwtypes.ListNestedObjectValueOf[redshiftQueryEngineAWSDataCatalogStorageConfigurationModel] `tfsdk:"aws_data_catalog_configuration"`
+	RedshiftConfiguration       fwtypes.ListNestedObjectValueOf[redshiftQueryEngineRedshiftStorageConfigurationModel]       `tfsdk:"redshift_configuration"`
+	Type                        fwtypes.StringEnum[awstypes.RedshiftQueryEngineStorageType]                                 `tfsdk:"type"`
+}
+
+type redshiftQueryEngineAWSDataCatalogStorageConfigurationModel struct {
+	TableNames fwtypes.SetOfString `tfsdk:"table_names"`
+}
+
+type redshiftQueryEngineRedshiftStorageConfigurationModel struct {
+	DatabaseName types.String `tfsdk:"database_name"`
+}
+
 type vectorKnowledgeBaseConfigurationModel struct {
 	EmbeddingModelARN                    fwtypes.ARN                                                                `tfsdk:"embedding_model_arn"`
 	EmbeddingModelConfiguration          fwtypes.ListNestedObjectValueOf[embeddingModelConfigurationModel]          `tfsdk:"embedding_model_configuration"`
@@ -828,29 +1636,73 @@ type bedrockEmbeddingModelConfigurationModel struct {
 }
 
 type supplementalDataStorageConfigurationModel struct {
-	StorageLocation fwtypes.ListNestedObjectValueOf[storageLocationModel] `tfsdk:"storage_location"`
+	StorageLocations fwtypes.ListNestedObjectValueOf[storageLocationModel] `tfsdk:"storage_location"`
 }
 
 type storageLocationModel struct {
-	Type       fwtypes.StringEnum[awstypes.SupplementalDataStorageLocationType] `tfsdk:"type"`
 	S3Location fwtypes.ListNestedObjectValueOf[s3LocationModel]                 `tfsdk:"s3_location"`
+	Type       fwtypes.StringEnum[awstypes.SupplementalDataStorageLocationType] `tfsdk:"type"`
 }
 
 type storageConfigurationModel struct {
-	OpensearchServerlessConfiguration fwtypes.ListNestedObjectValueOf[opensearchServerlessConfigurationModel] `tfsdk:"opensearch_serverless_configuration"`
-	PineconeConfiguration             fwtypes.ListNestedObjectValueOf[pineconeConfigurationModel]             `tfsdk:"pinecone_configuration"`
-	RDSConfiguration                  fwtypes.ListNestedObjectValueOf[rdsConfigurationModel]                  `tfsdk:"rds_configuration"`
-	RedisEnterpriseCloudConfiguration fwtypes.ListNestedObjectValueOf[redisEnterpriseCloudConfigurationModel] `tfsdk:"redis_enterprise_cloud_configuration"`
-	Type                              types.String                                                            `tfsdk:"type"`
+	MongoDBAtlasConfiguration             fwtypes.ListNestedObjectValueOf[mongoDBAtlasConfigurationModel]             `tfsdk:"mongo_db_atlas_configuration"`
+	NeptuneAnalyticsConfiguration         fwtypes.ListNestedObjectValueOf[neptuneAnalyticsConfigurationModel]         `tfsdk:"neptune_analytics_configuration"`
+	OpenSearchManagedClusterConfiguration fwtypes.ListNestedObjectValueOf[openSearchManagedClusterConfigurationModel] `tfsdk:"opensearch_managed_cluster_configuration"`
+	OpenSearchServerlessConfiguration     fwtypes.ListNestedObjectValueOf[openSearchServerlessConfigurationModel]     `tfsdk:"opensearch_serverless_configuration"`
+	PineconeConfiguration                 fwtypes.ListNestedObjectValueOf[pineconeConfigurationModel]                 `tfsdk:"pinecone_configuration"`
+	RDSConfiguration                      fwtypes.ListNestedObjectValueOf[rdsConfigurationModel]                      `tfsdk:"rds_configuration"`
+	RedisEnterpriseCloudConfiguration     fwtypes.ListNestedObjectValueOf[redisEnterpriseCloudConfigurationModel]     `tfsdk:"redis_enterprise_cloud_configuration"`
+	S3VectorsConfiguration                fwtypes.ListNestedObjectValueOf[s3VectorsConfigurationModel]                `tfsdk:"s3_vectors_configuration"`
+	Type                                  fwtypes.StringEnum[awstypes.KnowledgeBaseStorageType]                       `tfsdk:"type"`
+}
+
+type mongoDBAtlasConfigurationModel struct {
+	CollectionName       types.String                                                   `tfsdk:"collection_name"`
+	CredentialsSecretARN fwtypes.ARN                                                    `tfsdk:"credentials_secret_arn"`
+	DatabaseName         types.String                                                   `tfsdk:"database_name"`
+	Endpoint             types.String                                                   `tfsdk:"endpoint"`
+	EndpointServiceName  types.String                                                   `tfsdk:"endpoint_service_name"`
+	FieldMapping         fwtypes.ListNestedObjectValueOf[mongoDBAtlasFieldMappingModel] `tfsdk:"field_mapping"`
+	TextIndexName        types.String                                                   `tfsdk:"text_index_name"`
+	VectorIndexName      types.String                                                   `tfsdk:"vector_index_name"`
+}
+
+type mongoDBAtlasFieldMappingModel struct {
+	MetadataField types.String `tfsdk:"metadata_field"`
+	TextField     types.String `tfsdk:"text_field"`
+	VectorField   types.String `tfsdk:"vector_field"`
+}
+
+type neptuneAnalyticsConfigurationModel struct {
+	FieldMapping fwtypes.ListNestedObjectValueOf[neptuneAnalyticsFieldMappingModel] `tfsdk:"field_mapping"`
+	GraphARN     fwtypes.ARN                                                        `tfsdk:"graph_arn"`
+}
+
+type neptuneAnalyticsFieldMappingModel struct {
+	MetadataField types.String `tfsdk:"metadata_field"`
+	TextField     types.String `tfsdk:"text_field"`
+}
+
+type openSearchManagedClusterConfigurationModel struct {
+	DomainARN       fwtypes.ARN                                                                `tfsdk:"domain_arn"`
+	DomainEndpoint  types.String                                                               `tfsdk:"domain_endpoint"`
+	FieldMapping    fwtypes.ListNestedObjectValueOf[opensearchManagedClusterFieldMappingModel] `tfsdk:"field_mapping"`
+	VectorIndexName types.String                                                               `tfsdk:"vector_index_name"`
+}
+
+type opensearchManagedClusterFieldMappingModel struct {
+	MetadataField types.String `tfsdk:"metadata_field"`
+	TextField     types.String `tfsdk:"text_field"`
+	VectorField   types.String `tfsdk:"vector_field"`
 }
 
-type opensearchServerlessConfigurationModel struct {
+type openSearchServerlessConfigurationModel struct {
 	CollectionARN   fwtypes.ARN                                                            `tfsdk:"collection_arn"`
-	FieldMapping    fwtypes.ListNestedObjectValueOf[opensearchServerlessFieldMappingModel] `tfsdk:"field_mapping"`
+	FieldMapping    fwtypes.ListNestedObjectValueOf[openSearchServerlessFieldMappingModel] `tfsdk:"field_mapping"`
 	VectorIndexName types.String                                                           `tfsdk:"vector_index_name"`
 }
 
-type opensearchServerlessFieldMappingModel struct {
+type openSearchServerlessFieldMappingModel struct {
 	MetadataField types.String `tfsdk:"metadata_field"`
 	TextField     types.String `tfsdk:"text_field"`
 	VectorField   types.String `tfsdk:"vector_field"`
@@ -896,3 +1748,9 @@ type redisEnterpriseCloudFieldMappingModel struct {
 	TextField     types.String `tfsdk:"text_field"`
 	VectorField   types.String `tfsdk:"vector_field"`
 }
+
+type s3VectorsConfigurationModel struct {
+	IndexARN        fwtypes.ARN  `tfsdk:"index_arn"`
+	IndexName       types.String `tfsdk:"index_name"`
+	VectorBucketARN fwtypes.ARN  `tfsdk:"vector_bucket_arn"`
+}
diff --git a/internal/service/bedrockagent/knowledge_base_test.go b/internal/service/bedrockagent/knowledge_base_test.go
index 068968121584..88edb748eae3 100644
--- a/internal/service/bedrockagent/knowledge_base_test.go
+++ b/internal/service/bedrockagent/knowledge_base_test.go
@@ -6,11 +6,9 @@ package bedrockagent_test
 import (
 	"context"
 	"fmt"
-	"os"
-	"strconv"
 	"testing"
 
-	"github.com/aws/aws-sdk-go-v2/service/bedrockagent/types"
+	awstypes "github.com/aws/aws-sdk-go-v2/service/bedrockagent/types"
 	sdkacctest "github.com/hashicorp/terraform-plugin-testing/helper/acctest"
 	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
 	"github.com/hashicorp/terraform-plugin-testing/knownvalue"
@@ -19,66 +17,74 @@ import (
 	"github.com/hashicorp/terraform-plugin-testing/terraform"
 	"github.com/hashicorp/terraform-plugin-testing/tfjsonpath"
 	"github.com/hashicorp/terraform-provider-aws/internal/acctest"
+	tfknownvalue "github.com/hashicorp/terraform-provider-aws/internal/acctest/knownvalue"
 	"github.com/hashicorp/terraform-provider-aws/internal/conns"
 	"github.com/hashicorp/terraform-provider-aws/internal/retry"
 	tfbedrockagent "github.com/hashicorp/terraform-provider-aws/internal/service/bedrockagent"
 	"github.com/hashicorp/terraform-provider-aws/names"
 )
 
-// Prerequisites:
-// * psql run via null_resource/provisioner "local-exec"
-// * jq for parsing output from aws cli to retrieve postgres password
-func testAccKnowledgeBase_basic(t *testing.T) {
-	acctest.SkipIfExeNotOnPath(t, "psql")
-	acctest.SkipIfExeNotOnPath(t, "jq")
-	acctest.SkipIfExeNotOnPath(t, "aws")
-
+func testAccKnowledgeBase_disappears(t *testing.T) {
 	ctx := acctest.Context(t)
-	var knowledgebase types.KnowledgeBase
+	var knowledgebase awstypes.KnowledgeBase
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	resourceName := "aws_bedrockagent_knowledge_base.test"
-	foundationModel := "amazon.titan-embed-text-v1"
+	foundationModel := "amazon.titan-embed-text-v2:0"
 
 	resource.Test(t, resource.TestCase{
-		PreCheck: func() {
-			acctest.PreCheck(ctx, t)
-		},
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
 		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		ExternalProviders: map[string]resource.ExternalProvider{
-			"null": {
-				Source:            "hashicorp/null",
-				VersionConstraint: "3.2.2",
-			},
-		},
-		CheckDestroy: testAccCheckKnowledgeBaseDestroy(ctx),
+		CheckDestroy:             testAccCheckKnowledgeBaseDestroy(ctx),
 		Steps: []resource.TestStep{
 			{
-				Config: testAccKnowledgeBaseConfig_basicRDS(rName, foundationModel, ""),
+				Config: testAccKnowledgeBaseConfig_S3VectorsByIndexARN(rName, foundationModel),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckKnowledgeBaseExists(ctx, resourceName, &knowledgebase),
+					acctest.CheckFrameworkResourceDisappears(ctx, acctest.Provider, tfbedrockagent.ResourceKnowledgeBase, resourceName),
+				),
+				ExpectNonEmptyPlan: true,
 				ConfigPlanChecks: resource.ConfigPlanChecks{
 					PreApply: []plancheck.PlanCheck{
 						plancheck.ExpectResourceAction(resourceName, plancheck.ResourceActionCreate),
 					},
+					PostApplyPostRefresh: []plancheck.PlanCheck{
+						plancheck.ExpectResourceAction(resourceName, plancheck.ResourceActionCreate),
+					},
 				},
+			},
+		},
+	})
+}
+
+func testAccKnowledgeBase_tags(t *testing.T) {
+	ctx := acctest.Context(t)
+	var knowledgebase awstypes.KnowledgeBase
+	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
+	resourceName := "aws_bedrockagent_knowledge_base.test"
+	foundationModel := "amazon.titan-embed-text-v2:0"
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
+		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
+		CheckDestroy:             testAccCheckKnowledgeBaseDestroy(ctx),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccKnowledgeBaseConfig_tags1(rName, foundationModel, acctest.CtKey1, acctest.CtValue1),
 				Check: resource.ComposeTestCheckFunc(
 					testAccCheckKnowledgeBaseExists(ctx, resourceName, &knowledgebase),
-					resource.TestCheckNoResourceAttr(resourceName, names.AttrDescription),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.0.vector_knowledge_base_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.0.type", "VECTOR"),
-					resource.TestCheckResourceAttr(resourceName, names.AttrName, rName),
-					resource.TestCheckResourceAttrPair(resourceName, names.AttrRoleARN, "aws_iam_role.test", names.AttrARN),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.type", "RDS"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.rds_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.rds_configuration.0.table_name", "bedrock_integration.bedrock_kb"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.rds_configuration.0.field_mapping.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.rds_configuration.0.field_mapping.0.vector_field", "embedding"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.rds_configuration.0.field_mapping.0.text_field", "chunks"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.rds_configuration.0.field_mapping.0.metadata_field", "metadata"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.rds_configuration.0.field_mapping.0.primary_key_field", names.AttrID),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.rds_configuration.0.field_mapping.0.custom_metadata_field", "custom_metadata"),
 				),
+				ConfigPlanChecks: resource.ConfigPlanChecks{
+					PreApply: []plancheck.PlanCheck{
+						plancheck.ExpectResourceAction(resourceName, plancheck.ResourceActionCreate),
+					},
+				},
+				ConfigStateChecks: []statecheck.StateCheck{
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New(names.AttrTags), knownvalue.MapExact(map[string]knownvalue.Check{
+						acctest.CtKey1: knownvalue.StringExact(acctest.CtValue1),
+					})),
+				},
 			},
 			{
 				ResourceName:      resourceName,
@@ -86,31 +92,37 @@ func testAccKnowledgeBase_basic(t *testing.T) {
 				ImportStateVerify: true,
 			},
 			{
-				Config: testAccKnowledgeBaseConfig_updateRDS(rName, foundationModel, "test description"),
+				Config: testAccKnowledgeBaseConfig_tags2(rName, foundationModel, acctest.CtKey1, acctest.CtValue1Updated, acctest.CtKey2, acctest.CtValue2),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckKnowledgeBaseExists(ctx, resourceName, &knowledgebase),
+				),
 				ConfigPlanChecks: resource.ConfigPlanChecks{
 					PreApply: []plancheck.PlanCheck{
 						plancheck.ExpectResourceAction(resourceName, plancheck.ResourceActionUpdate),
 					},
 				},
+				ConfigStateChecks: []statecheck.StateCheck{
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New(names.AttrTags), knownvalue.MapExact(map[string]knownvalue.Check{
+						acctest.CtKey1: knownvalue.StringExact(acctest.CtValue1Updated),
+						acctest.CtKey2: knownvalue.StringExact(acctest.CtValue2),
+					})),
+				},
+			},
+			{
+				Config: testAccKnowledgeBaseConfig_tags1(rName, foundationModel, acctest.CtKey2, acctest.CtValue2),
 				Check: resource.ComposeTestCheckFunc(
 					testAccCheckKnowledgeBaseExists(ctx, resourceName, &knowledgebase),
-					resource.TestCheckResourceAttr(resourceName, names.AttrDescription, "test description"),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.0.vector_knowledge_base_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.0.type", "VECTOR"),
-					resource.TestCheckResourceAttr(resourceName, names.AttrName, rName+"-update"),
-					resource.TestCheckResourceAttrPair(resourceName, names.AttrRoleARN, "aws_iam_role.test_update", names.AttrARN),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.type", "RDS"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.rds_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.rds_configuration.0.table_name", "bedrock_integration.bedrock_kb"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.rds_configuration.0.field_mapping.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.rds_configuration.0.field_mapping.0.vector_field", "embedding"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.rds_configuration.0.field_mapping.0.text_field", "chunks"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.rds_configuration.0.field_mapping.0.metadata_field", "metadata"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.rds_configuration.0.field_mapping.0.primary_key_field", names.AttrID),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.rds_configuration.0.field_mapping.0.custom_metadata_field", "custom_metadata"),
 				),
+				ConfigPlanChecks: resource.ConfigPlanChecks{
+					PreApply: []plancheck.PlanCheck{
+						plancheck.ExpectResourceAction(resourceName, plancheck.ResourceActionUpdate),
+					},
+				},
+				ConfigStateChecks: []statecheck.StateCheck{
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New(names.AttrTags), knownvalue.MapExact(map[string]knownvalue.Check{
+						acctest.CtKey2: knownvalue.StringExact(acctest.CtValue2),
+					})),
+				},
 			},
 		},
 	})
@@ -119,13 +131,13 @@ func testAccKnowledgeBase_basic(t *testing.T) {
 // Prerequisites:
 // * psql run via null_resource/provisioner "local-exec"
 // * jq for parsing output from aws cli to retrieve postgres password
-func testAccKnowledgeBase_disappears(t *testing.T) {
+func testAccKnowledgeBase_RDS_basic(t *testing.T) {
 	acctest.SkipIfExeNotOnPath(t, "psql")
 	acctest.SkipIfExeNotOnPath(t, "jq")
 	acctest.SkipIfExeNotOnPath(t, "aws")
 
 	ctx := acctest.Context(t)
-	var knowledgebase types.KnowledgeBase
+	var knowledgebase awstypes.KnowledgeBase
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	resourceName := "aws_bedrockagent_knowledge_base.test"
 	foundationModel := "amazon.titan-embed-text-v1"
@@ -145,137 +157,218 @@ func testAccKnowledgeBase_disappears(t *testing.T) {
 		CheckDestroy: testAccCheckKnowledgeBaseDestroy(ctx),
 		Steps: []resource.TestStep{
 			{
-				Config: testAccKnowledgeBaseConfig_basicRDS(rName, foundationModel, ""),
+				Config: testAccKnowledgeBaseConfig_RDS_basic(rName, foundationModel),
 				Check: resource.ComposeTestCheckFunc(
 					testAccCheckKnowledgeBaseExists(ctx, resourceName, &knowledgebase),
-					acctest.CheckFrameworkResourceDisappears(ctx, acctest.Provider, tfbedrockagent.ResourceKnowledgeBase, resourceName),
 				),
-				ExpectNonEmptyPlan: true,
+				ConfigPlanChecks: resource.ConfigPlanChecks{
+					PreApply: []plancheck.PlanCheck{
+						plancheck.ExpectResourceAction(resourceName, plancheck.ResourceActionCreate),
+					},
+				},
+				ConfigStateChecks: []statecheck.StateCheck{
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New("knowledge_base_configuration"), knownvalue.ListExact([]knownvalue.Check{
+						knownvalue.MapExact(map[string]knownvalue.Check{
+							"kendra_knowledge_base_configuration": knownvalue.ListSizeExact(0),
+							"sql_knowledge_base_configuration":    knownvalue.ListSizeExact(0),
+							names.AttrType:                        tfknownvalue.StringExact(awstypes.KnowledgeBaseTypeVector),
+							"vector_knowledge_base_configuration": knownvalue.ListSizeExact(1),
+						}),
+					})),
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New("storage_configuration"), knownvalue.ListExact([]knownvalue.Check{
+						knownvalue.MapExact(map[string]knownvalue.Check{
+							"mongo_db_atlas_configuration":             knownvalue.ListSizeExact(0),
+							"neptune_analytics_configuration":          knownvalue.ListSizeExact(0),
+							"opensearch_managed_cluster_configuration": knownvalue.ListSizeExact(0),
+							"opensearch_serverless_configuration":      knownvalue.ListSizeExact(0),
+							names.AttrType:                             tfknownvalue.StringExact(awstypes.KnowledgeBaseStorageTypeRds),
+							"pinecone_configuration":                   knownvalue.ListSizeExact(0),
+							"rds_configuration":                        knownvalue.ListSizeExact(1),
+							"redis_enterprise_cloud_configuration":     knownvalue.ListSizeExact(0),
+							"s3_vectors_configuration":                 knownvalue.ListSizeExact(0),
+						}),
+					})),
+				},
+			},
+			{
+				ResourceName:      resourceName,
+				ImportState:       true,
+				ImportStateVerify: true,
 			},
 		},
 	})
 }
 
-// Prerequisites:
-// * psql run via null_resource/provisioner "local-exec"
-// * jq for parsing output from aws cli to retrieve postgres password
-func testAccKnowledgeBase_tags(t *testing.T) {
-	acctest.SkipIfExeNotOnPath(t, "psql")
-	acctest.SkipIfExeNotOnPath(t, "jq")
-	acctest.SkipIfExeNotOnPath(t, "aws")
-
+func testAccKnowledgeBase_OpenSearchServerless_basic(t *testing.T) {
 	ctx := acctest.Context(t)
-	var knowledgebase types.KnowledgeBase
+	collectionName := skipIfOSSCollectionNameEnvVarNotSet(t)
+	var knowledgebase awstypes.KnowledgeBase
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	resourceName := "aws_bedrockagent_knowledge_base.test"
-	foundationModel := "amazon.titan-embed-text-v1"
+	foundationModel := "amazon.titan-embed-text-v2:0"
 
 	resource.Test(t, resource.TestCase{
-		PreCheck: func() {
-			acctest.PreCheck(ctx, t)
-		},
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
 		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		ExternalProviders: map[string]resource.ExternalProvider{
-			"null": {
-				Source:            "hashicorp/null",
-				VersionConstraint: "3.2.2",
-			},
-		},
-		CheckDestroy: testAccCheckKnowledgeBaseDestroy(ctx),
+		CheckDestroy:             testAccCheckKnowledgeBaseDestroy(ctx),
 		Steps: []resource.TestStep{
 			{
-				Config: testAccKnowledgeBaseConfig_tags1(rName, foundationModel, acctest.CtKey1, acctest.CtValue1),
+				Config: testAccKnowledgeBaseConfig_OpenSearchServerless_basic(rName, collectionName, foundationModel),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckKnowledgeBaseExists(ctx, resourceName, &knowledgebase),
+				),
 				ConfigPlanChecks: resource.ConfigPlanChecks{
 					PreApply: []plancheck.PlanCheck{
 						plancheck.ExpectResourceAction(resourceName, plancheck.ResourceActionCreate),
 					},
 				},
 				ConfigStateChecks: []statecheck.StateCheck{
-					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New(names.AttrTags), knownvalue.MapExact(map[string]knownvalue.Check{
-						acctest.CtKey1: knownvalue.StringExact(acctest.CtValue1),
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New("knowledge_base_configuration"), knownvalue.ListExact([]knownvalue.Check{
+						knownvalue.MapExact(map[string]knownvalue.Check{
+							"kendra_knowledge_base_configuration": knownvalue.ListSizeExact(0),
+							"sql_knowledge_base_configuration":    knownvalue.ListSizeExact(0),
+							names.AttrType:                        tfknownvalue.StringExact(awstypes.KnowledgeBaseTypeVector),
+							"vector_knowledge_base_configuration": knownvalue.ListSizeExact(1),
+						}),
+					})),
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New("storage_configuration"), knownvalue.ListExact([]knownvalue.Check{
+						knownvalue.MapExact(map[string]knownvalue.Check{
+							"mongo_db_atlas_configuration":             knownvalue.ListSizeExact(0),
+							"neptune_analytics_configuration":          knownvalue.ListSizeExact(0),
+							"opensearch_managed_cluster_configuration": knownvalue.ListSizeExact(0),
+							"opensearch_serverless_configuration":      knownvalue.ListSizeExact(1),
+							names.AttrType:                             tfknownvalue.StringExact(awstypes.KnowledgeBaseStorageTypeOpensearchServerless),
+							"pinecone_configuration":                   knownvalue.ListSizeExact(0),
+							"rds_configuration":                        knownvalue.ListSizeExact(0),
+							"redis_enterprise_cloud_configuration":     knownvalue.ListSizeExact(0),
+							"s3_vectors_configuration":                 knownvalue.ListSizeExact(0),
+						}),
 					})),
 				},
-				Check: resource.ComposeTestCheckFunc(
-					testAccCheckKnowledgeBaseExists(ctx, resourceName, &knowledgebase),
-				),
 			},
 			{
 				ResourceName:      resourceName,
 				ImportState:       true,
 				ImportStateVerify: true,
 			},
+		},
+	})
+}
+
+func testAccKnowledgeBase_update(t *testing.T) {
+	ctx := acctest.Context(t)
+	var knowledgebase awstypes.KnowledgeBase
+	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
+	resourceName := "aws_bedrockagent_knowledge_base.test"
+	foundationModel := "amazon.titan-embed-text-v2:0"
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
+		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
+		CheckDestroy:             testAccCheckKnowledgeBaseDestroy(ctx),
+		Steps: []resource.TestStep{
 			{
-				Config: testAccKnowledgeBaseConfig_tags2(rName, foundationModel, acctest.CtKey1, acctest.CtValue1Updated, acctest.CtKey2, acctest.CtValue2),
+				Config: testAccKnowledgeBaseConfig_description(rName, foundationModel, "desc1"),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckKnowledgeBaseExists(ctx, resourceName, &knowledgebase),
+				),
 				ConfigPlanChecks: resource.ConfigPlanChecks{
 					PreApply: []plancheck.PlanCheck{
-						plancheck.ExpectResourceAction(resourceName, plancheck.ResourceActionUpdate),
+						plancheck.ExpectResourceAction(resourceName, plancheck.ResourceActionCreate),
 					},
 				},
 				ConfigStateChecks: []statecheck.StateCheck{
-					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New(names.AttrTags), knownvalue.MapExact(map[string]knownvalue.Check{
-						acctest.CtKey1: knownvalue.StringExact(acctest.CtValue1Updated),
-						acctest.CtKey2: knownvalue.StringExact(acctest.CtValue2),
-					})),
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New(names.AttrDescription), knownvalue.StringExact("desc1")),
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New(names.AttrName), knownvalue.StringExact(rName)),
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New(names.AttrTags), knownvalue.Null()),
 				},
+			},
+			{
+				ResourceName:      resourceName,
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+			{
+				Config: testAccKnowledgeBaseConfig_description(rName, foundationModel, "desc2"),
 				Check: resource.ComposeTestCheckFunc(
 					testAccCheckKnowledgeBaseExists(ctx, resourceName, &knowledgebase),
 				),
-			},
-			{
-				Config: testAccKnowledgeBaseConfig_tags1(rName, foundationModel, acctest.CtKey2, acctest.CtValue2),
 				ConfigPlanChecks: resource.ConfigPlanChecks{
 					PreApply: []plancheck.PlanCheck{
 						plancheck.ExpectResourceAction(resourceName, plancheck.ResourceActionUpdate),
 					},
 				},
 				ConfigStateChecks: []statecheck.StateCheck{
-					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New(names.AttrTags), knownvalue.MapExact(map[string]knownvalue.Check{
-						acctest.CtKey2: knownvalue.StringExact(acctest.CtValue2),
-					})),
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New(names.AttrDescription), knownvalue.StringExact("desc2")),
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New(names.AttrName), knownvalue.StringExact(rName)),
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New(names.AttrTags), knownvalue.Null()),
 				},
-				Check: resource.ComposeTestCheckFunc(
-					testAccCheckKnowledgeBaseExists(ctx, resourceName, &knowledgebase),
-				),
 			},
 		},
 	})
 }
 
-func testAccKnowledgeBase_OpenSearch_basic(t *testing.T) {
-	ctx := acctest.Context(t)
-	collectionName := skipIfOSSCollectionNameEnvVarNotSet(t)
+func testAccKnowledgeBase_RDS_supplementalDataStorage(t *testing.T) {
+	acctest.SkipIfExeNotOnPath(t, "psql")
+	acctest.SkipIfExeNotOnPath(t, "jq")
+	acctest.SkipIfExeNotOnPath(t, "aws")
 
-	var knowledgebase types.KnowledgeBase
+	ctx := acctest.Context(t)
+	var knowledgebase awstypes.KnowledgeBase
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	resourceName := "aws_bedrockagent_knowledge_base.test"
-	foundationModel := "amazon.titan-embed-text-v2:0"
+	foundationModel := "amazon.titan-embed-text-v1"
 
 	resource.Test(t, resource.TestCase{
-		PreCheck: func() {
-			acctest.PreCheck(ctx, t)
-		},
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
 		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		CheckDestroy:             testAccCheckKnowledgeBaseDestroy(ctx),
+		ExternalProviders: map[string]resource.ExternalProvider{
+			"null": {
+				Source:            "hashicorp/null",
+				VersionConstraint: "3.2.2",
+			},
+		},
+		CheckDestroy: testAccCheckKnowledgeBaseDestroy(ctx),
 		Steps: []resource.TestStep{
 			{
-				Config: testAccKnowledgeBaseConfig_OpenSearch_basic(rName, collectionName, foundationModel),
+				Config: testAccKnowledgeBaseConfig_RDS_supplementalDataStorage(rName, foundationModel),
 				Check: resource.ComposeTestCheckFunc(
 					testAccCheckKnowledgeBaseExists(ctx, resourceName, &knowledgebase),
-					resource.TestCheckResourceAttrPair(resourceName, names.AttrRoleARN, "aws_iam_role.test", names.AttrARN),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.0.vector_knowledge_base_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.0.type", "VECTOR"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.type", "OPENSEARCH_SERVERLESS"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.0.vector_index_name", "bedrock-knowledge-base-default-index"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.0.field_mapping.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.0.field_mapping.0.vector_field", "bedrock-knowledge-base-default-vector"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.0.field_mapping.0.text_field", "AMAZON_BEDROCK_TEXT_CHUNK"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.0.field_mapping.0.metadata_field", "AMAZON_BEDROCK_METADATA"),
 				),
+				ConfigPlanChecks: resource.ConfigPlanChecks{
+					PreApply: []plancheck.PlanCheck{
+						plancheck.ExpectResourceAction(resourceName, plancheck.ResourceActionCreate),
+					},
+				},
+				ConfigStateChecks: []statecheck.StateCheck{
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New(names.AttrDescription), knownvalue.Null()),
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New("knowledge_base_configuration"), knownvalue.ListExact([]knownvalue.Check{
+						knownvalue.MapExact(map[string]knownvalue.Check{
+							"kendra_knowledge_base_configuration": knownvalue.ListSizeExact(0),
+							"sql_knowledge_base_configuration":    knownvalue.ListSizeExact(0),
+							names.AttrType:                        tfknownvalue.StringExact(awstypes.KnowledgeBaseTypeVector),
+							"vector_knowledge_base_configuration": knownvalue.ListExact([]knownvalue.Check{
+								knownvalue.ObjectPartial(map[string]knownvalue.Check{
+									"supplemental_data_storage_configuration": knownvalue.ListExact([]knownvalue.Check{
+										knownvalue.ObjectExact(map[string]knownvalue.Check{
+											"storage_location": knownvalue.ListExact([]knownvalue.Check{
+												knownvalue.ObjectExact(map[string]knownvalue.Check{
+													"s3_location":  knownvalue.ListSizeExact(1),
+													names.AttrType: tfknownvalue.StringExact(awstypes.SupplementalDataStorageLocationTypeS3),
+												}),
+											}),
+										}),
+									}),
+								}),
+							}),
+						}),
+					})),
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New(names.AttrName), knownvalue.StringExact(rName)),
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New(names.AttrTags), knownvalue.Null()),
+				},
 			},
 			{
 				ResourceName:      resourceName,
@@ -286,81 +379,48 @@ func testAccKnowledgeBase_OpenSearch_basic(t *testing.T) {
 	})
 }
 
-func testAccKnowledgeBase_OpenSearch_update(t *testing.T) {
+func testAccKnowledgeBase_Kendra_basic(t *testing.T) {
 	ctx := acctest.Context(t)
-	collectionName := skipIfOSSCollectionNameEnvVarNotSet(t)
-
-	var knowledgebase types.KnowledgeBase
+	var knowledgebase awstypes.KnowledgeBase
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	resourceName := "aws_bedrockagent_knowledge_base.test"
-	foundationModel := "amazon.titan-embed-text-v2:0"
+	// Index should be created with the "GEN_AI_ENTERPRISE_EDITION" edition and be "ACTIVE".
+	kendraIndexARN := acctest.SkipIfEnvVarNotSet(t, "TF_AWS_KENDRA_INDEX_ARN")
 
 	resource.Test(t, resource.TestCase{
-		PreCheck: func() {
-			acctest.PreCheck(ctx, t)
-		},
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
 		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
 		CheckDestroy:             testAccCheckKnowledgeBaseDestroy(ctx),
 		Steps: []resource.TestStep{
 			{
-				Config: testAccKnowledgeBaseConfig_OpenSearch_basic(rName, collectionName, foundationModel),
-				Check: resource.ComposeTestCheckFunc(
-					testAccCheckKnowledgeBaseExists(ctx, resourceName, &knowledgebase),
-					resource.TestCheckResourceAttr(resourceName, names.AttrName, rName),
-					resource.TestCheckResourceAttrPair(resourceName, names.AttrRoleARN, "aws_iam_role.test", names.AttrARN),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.0.vector_knowledge_base_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.0.type", "VECTOR"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.type", "OPENSEARCH_SERVERLESS"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.0.vector_index_name", "bedrock-knowledge-base-default-index"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.0.field_mapping.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.0.field_mapping.0.vector_field", "bedrock-knowledge-base-default-vector"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.0.field_mapping.0.text_field", "AMAZON_BEDROCK_TEXT_CHUNK"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.0.field_mapping.0.metadata_field", "AMAZON_BEDROCK_METADATA"),
-				),
-			},
-			{
-				ResourceName:      resourceName,
-				ImportState:       true,
-				ImportStateVerify: true,
-			},
-			{
-				Config: testAccKnowledgeBaseConfig_OpenSearch_update(rName, collectionName, foundationModel),
+				Config: testAccKnowledgeBaseConfig_Kendra_basic(rName, kendraIndexARN),
 				Check: resource.ComposeTestCheckFunc(
 					testAccCheckKnowledgeBaseExists(ctx, resourceName, &knowledgebase),
-					resource.TestCheckResourceAttr(resourceName, names.AttrName, rName+"-updated"),
-					resource.TestCheckResourceAttr(resourceName, names.AttrDescription, rName),
-					resource.TestCheckResourceAttrPair(resourceName, names.AttrRoleARN, "aws_iam_role.test", names.AttrARN),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.0.vector_knowledge_base_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.0.type", "VECTOR"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.type", "OPENSEARCH_SERVERLESS"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.0.vector_index_name", "bedrock-knowledge-base-default-index"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.0.field_mapping.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.0.field_mapping.0.vector_field", "bedrock-knowledge-base-default-vector"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.0.field_mapping.0.text_field", "AMAZON_BEDROCK_TEXT_CHUNK"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.0.field_mapping.0.metadata_field", "AMAZON_BEDROCK_METADATA"),
 				),
-			},
-			{
-				ResourceName:      resourceName,
-				ImportState:       true,
-				ImportStateVerify: true,
+				ConfigPlanChecks: resource.ConfigPlanChecks{
+					PreApply: []plancheck.PlanCheck{
+						plancheck.ExpectResourceAction(resourceName, plancheck.ResourceActionCreate),
+					},
+				},
+				ConfigStateChecks: []statecheck.StateCheck{
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New("knowledge_base_configuration"), knownvalue.ListExact([]knownvalue.Check{
+						knownvalue.MapExact(map[string]knownvalue.Check{
+							"kendra_knowledge_base_configuration": knownvalue.ListSizeExact(1),
+							"sql_knowledge_base_configuration":    knownvalue.ListSizeExact(0),
+							names.AttrType:                        tfknownvalue.StringExact(awstypes.KnowledgeBaseTypeKendra),
+							"vector_knowledge_base_configuration": knownvalue.ListSizeExact(0),
+						}),
+					})),
+				},
 			},
 		},
 	})
 }
 
-func testAccKnowledgeBase_OpenSearch_supplementalDataStorage(t *testing.T) {
+func testAccKnowledgeBase_OpenSearchManagedCluster_basic(t *testing.T) {
 	ctx := acctest.Context(t)
-	collectionName := skipIfOSSCollectionNameEnvVarNotSet(t)
-
-	var knowledgebase types.KnowledgeBase
+	var knowledgebase awstypes.KnowledgeBase
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	resourceName := "aws_bedrockagent_knowledge_base.test"
 	foundationModel := "amazon.titan-embed-text-v2:0"
@@ -368,52 +428,318 @@ func testAccKnowledgeBase_OpenSearch_supplementalDataStorage(t *testing.T) {
 	resource.Test(t, resource.TestCase{
 		PreCheck: func() {
 			acctest.PreCheck(ctx, t)
+			acctest.PreCheckIAMServiceLinkedRole(ctx, t, "/aws-service-role/opensearchservice.amazonaws.com")
 		},
 		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		CheckDestroy:             testAccCheckKnowledgeBaseDestroy(ctx),
+		ExternalProviders: map[string]resource.ExternalProvider{
+			"opensearch": {
+				Source:            "opensearch-project/opensearch",
+				VersionConstraint: "~> 2.2.0",
+			},
+		},
+		CheckDestroy: testAccCheckKnowledgeBaseDestroy(ctx),
 		Steps: []resource.TestStep{
 			{
-				Config: testAccKnowledgeBaseConfig_OpenSearch_supplementalDataStorage(rName, collectionName, foundationModel),
+				Config: testAccKnowledgeBaseConfig_OpenSearchManagedCluster_basic(rName, foundationModel),
 				Check: resource.ComposeTestCheckFunc(
 					testAccCheckKnowledgeBaseExists(ctx, resourceName, &knowledgebase),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.0.vector_knowledge_base_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.0.type", "VECTOR"),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.0.vector_knowledge_base_configuration.0.embedding_model_configuration.0.bedrock_embedding_model_configuration.0.dimensions", "1024"),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.0.vector_knowledge_base_configuration.0.embedding_model_configuration.0.bedrock_embedding_model_configuration.0.embedding_data_type", "FLOAT32"),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.0.vector_knowledge_base_configuration.0.supplemental_data_storage_configuration.0.storage_location.0.type", "S3"),
-					resource.TestCheckResourceAttr(resourceName, "knowledge_base_configuration.0.vector_knowledge_base_configuration.0.supplemental_data_storage_configuration.0.storage_location.0.s3_location.0.uri", fmt.Sprintf("s3://%s", rName)),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.type", "OPENSEARCH_SERVERLESS"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.0.vector_index_name", "bedrock-knowledge-base-default-index"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.0.field_mapping.#", "1"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.0.field_mapping.0.vector_field", "bedrock-knowledge-base-default-vector"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.0.field_mapping.0.text_field", "AMAZON_BEDROCK_TEXT_CHUNK"),
-					resource.TestCheckResourceAttr(resourceName, "storage_configuration.0.opensearch_serverless_configuration.0.field_mapping.0.metadata_field", "AMAZON_BEDROCK_METADATA"),
 				),
-			},
-			{
-				ResourceName:            resourceName,
-				ImportState:             true,
-				ImportStateVerify:       true,
-				ImportStateVerifyIgnore: []string{},
+				ConfigPlanChecks: resource.ConfigPlanChecks{
+					PreApply: []plancheck.PlanCheck{
+						plancheck.ExpectResourceAction(resourceName, plancheck.ResourceActionCreate),
+					},
+				},
+				ConfigStateChecks: []statecheck.StateCheck{
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New("knowledge_base_configuration"), knownvalue.ListExact([]knownvalue.Check{
+						knownvalue.MapExact(map[string]knownvalue.Check{
+							"kendra_knowledge_base_configuration": knownvalue.ListSizeExact(0),
+							"sql_knowledge_base_configuration":    knownvalue.ListSizeExact(0),
+							names.AttrType:                        tfknownvalue.StringExact(awstypes.KnowledgeBaseTypeVector),
+							"vector_knowledge_base_configuration": knownvalue.ListSizeExact(1),
+						}),
+					})),
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New("storage_configuration"), knownvalue.ListExact([]knownvalue.Check{
+						knownvalue.MapExact(map[string]knownvalue.Check{
+							"mongo_db_atlas_configuration":             knownvalue.ListSizeExact(0),
+							"neptune_analytics_configuration":          knownvalue.ListSizeExact(0),
+							"opensearch_managed_cluster_configuration": knownvalue.ListSizeExact(1),
+							"opensearch_serverless_configuration":      knownvalue.ListSizeExact(0),
+							names.AttrType:                             tfknownvalue.StringExact(awstypes.KnowledgeBaseStorageTypeOpensearchManagedCluster),
+							"pinecone_configuration":                   knownvalue.ListSizeExact(0),
+							"rds_configuration":                        knownvalue.ListSizeExact(0),
+							"redis_enterprise_cloud_configuration":     knownvalue.ListSizeExact(0),
+							"s3_vectors_configuration":                 knownvalue.ListSizeExact(0),
+						}),
+					})),
+				},
 			},
 		},
 	})
 }
 
-func testAccCheckKnowledgeBaseDestroy(ctx context.Context) resource.TestCheckFunc {
-	return func(s *terraform.State) error {
-		conn := acctest.Provider.Meta().(*conns.AWSClient).BedrockAgentClient(ctx)
-
-		for _, rs := range s.RootModule().Resources {
-			if rs.Type != "aws_bedrockagent_knowledge_base" {
-				continue
-			}
-
-			_, err := tfbedrockagent.FindKnowledgeBaseByID(ctx, conn, rs.Primary.ID)
+func testAccKnowledgeBase_S3Vectors_update(t *testing.T) {
+	ctx := acctest.Context(t)
+	var knowledgebase awstypes.KnowledgeBase
+	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
+	resourceName := "aws_bedrockagent_knowledge_base.test"
+	foundationModel := "amazon.titan-embed-text-v2:0"
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
+		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
+		CheckDestroy:             testAccCheckKnowledgeBaseDestroy(ctx),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccKnowledgeBaseConfig_S3VectorsByIndexARN(rName, foundationModel),
+				ConfigPlanChecks: resource.ConfigPlanChecks{
+					PreApply: []plancheck.PlanCheck{
+						plancheck.ExpectResourceAction(resourceName, plancheck.ResourceActionCreate),
+					},
+				},
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckKnowledgeBaseExists(ctx, resourceName, &knowledgebase),
+				),
+				ConfigStateChecks: []statecheck.StateCheck{
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New("knowledge_base_configuration"), knownvalue.ListExact([]knownvalue.Check{
+						knownvalue.MapExact(map[string]knownvalue.Check{
+							"kendra_knowledge_base_configuration": knownvalue.ListSizeExact(0),
+							"sql_knowledge_base_configuration":    knownvalue.ListSizeExact(0),
+							names.AttrType:                        tfknownvalue.StringExact(awstypes.KnowledgeBaseTypeVector),
+							"vector_knowledge_base_configuration": knownvalue.ListSizeExact(1),
+						}),
+					})),
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New("storage_configuration"), knownvalue.ListExact([]knownvalue.Check{
+						knownvalue.MapExact(map[string]knownvalue.Check{
+							"mongo_db_atlas_configuration":             knownvalue.ListSizeExact(0),
+							"neptune_analytics_configuration":          knownvalue.ListSizeExact(0),
+							"opensearch_managed_cluster_configuration": knownvalue.ListSizeExact(0),
+							"opensearch_serverless_configuration":      knownvalue.ListSizeExact(0),
+							names.AttrType:                             tfknownvalue.StringExact(awstypes.KnowledgeBaseStorageTypeS3Vectors),
+							"pinecone_configuration":                   knownvalue.ListSizeExact(0),
+							"rds_configuration":                        knownvalue.ListSizeExact(0),
+							"redis_enterprise_cloud_configuration":     knownvalue.ListSizeExact(0),
+							"s3_vectors_configuration":                 knownvalue.ListSizeExact(1),
+						}),
+					})),
+				},
+			},
+			{
+				ResourceName:      resourceName,
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+			{
+				Config: testAccKnowledgeBaseConfig_S3VectorsByIndexName(rName, foundationModel),
+				ConfigPlanChecks: resource.ConfigPlanChecks{
+					PreApply: []plancheck.PlanCheck{
+						plancheck.ExpectResourceAction(resourceName, plancheck.ResourceActionDestroyBeforeCreate),
+					},
+				},
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckKnowledgeBaseExists(ctx, resourceName, &knowledgebase),
+				),
+				ConfigStateChecks: []statecheck.StateCheck{
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New("storage_configuration"), knownvalue.ListExact([]knownvalue.Check{
+						knownvalue.MapExact(map[string]knownvalue.Check{
+							"mongo_db_atlas_configuration":             knownvalue.ListSizeExact(0),
+							"neptune_analytics_configuration":          knownvalue.ListSizeExact(0),
+							"opensearch_managed_cluster_configuration": knownvalue.ListSizeExact(0),
+							"opensearch_serverless_configuration":      knownvalue.ListSizeExact(0),
+							names.AttrType:                             tfknownvalue.StringExact(awstypes.KnowledgeBaseStorageTypeS3Vectors),
+							"pinecone_configuration":                   knownvalue.ListSizeExact(0),
+							"rds_configuration":                        knownvalue.ListSizeExact(0),
+							"redis_enterprise_cloud_configuration":     knownvalue.ListSizeExact(0),
+							"s3_vectors_configuration":                 knownvalue.ListSizeExact(1),
+						}),
+					})),
+				},
+			},
+		},
+	})
+}
+
+func testAccKnowledgeBase_StructuredDataStore_redshiftProvisioned(t *testing.T) {
+	ctx := acctest.Context(t)
+	var knowledgebase awstypes.KnowledgeBase
+	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
+	resourceName := "aws_bedrockagent_knowledge_base.test"
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
+		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
+		CheckDestroy:             testAccCheckKnowledgeBaseDestroy(ctx),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccKnowledgeBaseConfig_StructuredDataStore_redshiftProvisioned(rName),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckKnowledgeBaseExists(ctx, resourceName, &knowledgebase),
+				),
+				ConfigPlanChecks: resource.ConfigPlanChecks{
+					PreApply: []plancheck.PlanCheck{
+						plancheck.ExpectResourceAction(resourceName, plancheck.ResourceActionCreate),
+					},
+				},
+				ConfigStateChecks: []statecheck.StateCheck{
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New("knowledge_base_configuration"), knownvalue.ListExact([]knownvalue.Check{
+						knownvalue.MapExact(map[string]knownvalue.Check{
+							"kendra_knowledge_base_configuration": knownvalue.ListSizeExact(0),
+							"sql_knowledge_base_configuration": knownvalue.ListExact([]knownvalue.Check{
+								knownvalue.ObjectExact(map[string]knownvalue.Check{
+									names.AttrType: tfknownvalue.StringExact(awstypes.QueryEngineTypeRedshift),
+									"redshift_configuration": knownvalue.ListExact([]knownvalue.Check{
+										knownvalue.ObjectExact(map[string]knownvalue.Check{
+											"query_engine_configuration": knownvalue.ListExact([]knownvalue.Check{
+												knownvalue.ObjectExact(map[string]knownvalue.Check{
+													names.AttrType:              tfknownvalue.StringExact(awstypes.RedshiftQueryEngineTypeProvisioned),
+													"provisioned_configuration": knownvalue.ListSizeExact(1),
+													"serverless_configuration":  knownvalue.ListSizeExact(0),
+												}),
+											}),
+											"query_generation_configuration": knownvalue.ListSizeExact(0),
+											"storage_configuration": knownvalue.ListExact([]knownvalue.Check{
+												knownvalue.ObjectExact(map[string]knownvalue.Check{
+													names.AttrType:                   tfknownvalue.StringExact(awstypes.RedshiftQueryEngineStorageTypeRedshift),
+													"aws_data_catalog_configuration": knownvalue.ListSizeExact(0),
+													"redshift_configuration":         knownvalue.ListSizeExact(1),
+												}),
+											}),
+										}),
+									}),
+								}),
+							}),
+							names.AttrType:                        tfknownvalue.StringExact(awstypes.KnowledgeBaseTypeSql),
+							"vector_knowledge_base_configuration": knownvalue.ListSizeExact(0),
+						}),
+					})),
+				},
+			},
+		},
+	})
+}
+
+func testAccKnowledgeBase_StructuredDataStore_redshiftServerless(t *testing.T) {
+	ctx := acctest.Context(t)
+	var knowledgebase awstypes.KnowledgeBase
+	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
+	resourceName := "aws_bedrockagent_knowledge_base.test"
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
+		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
+		CheckDestroy:             testAccCheckKnowledgeBaseDestroy(ctx),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccKnowledgeBaseConfig_StructuredDataStore_redshiftServerless(rName),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckKnowledgeBaseExists(ctx, resourceName, &knowledgebase),
+				),
+				ConfigPlanChecks: resource.ConfigPlanChecks{
+					PreApply: []plancheck.PlanCheck{
+						plancheck.ExpectResourceAction(resourceName, plancheck.ResourceActionCreate),
+					},
+				},
+				ConfigStateChecks: []statecheck.StateCheck{
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New("knowledge_base_configuration"), knownvalue.ListExact([]knownvalue.Check{
+						knownvalue.MapExact(map[string]knownvalue.Check{
+							"kendra_knowledge_base_configuration": knownvalue.ListSizeExact(0),
+							"sql_knowledge_base_configuration": knownvalue.ListExact([]knownvalue.Check{
+								knownvalue.ObjectExact(map[string]knownvalue.Check{
+									names.AttrType: tfknownvalue.StringExact(awstypes.QueryEngineTypeRedshift),
+									"redshift_configuration": knownvalue.ListExact([]knownvalue.Check{
+										knownvalue.ObjectExact(map[string]knownvalue.Check{
+											"query_engine_configuration": knownvalue.ListExact([]knownvalue.Check{
+												knownvalue.ObjectExact(map[string]knownvalue.Check{
+													names.AttrType:              tfknownvalue.StringExact(awstypes.RedshiftQueryEngineTypeServerless),
+													"provisioned_configuration": knownvalue.ListSizeExact(0),
+													"serverless_configuration":  knownvalue.ListSizeExact(1),
+												}),
+											}),
+											"query_generation_configuration": knownvalue.ListSizeExact(1),
+											"storage_configuration": knownvalue.ListExact([]knownvalue.Check{
+												knownvalue.ObjectExact(map[string]knownvalue.Check{
+													names.AttrType:                   tfknownvalue.StringExact(awstypes.RedshiftQueryEngineStorageTypeRedshift),
+													"aws_data_catalog_configuration": knownvalue.ListSizeExact(0),
+													"redshift_configuration":         knownvalue.ListSizeExact(1),
+												}),
+											}),
+										}),
+									}),
+								}),
+							}),
+							names.AttrType:                        tfknownvalue.StringExact(awstypes.KnowledgeBaseTypeSql),
+							"vector_knowledge_base_configuration": knownvalue.ListSizeExact(0),
+						}),
+					})),
+				},
+			},
+		},
+	})
+}
+
+func testAccKnowledgeBase_NeptuneAnalytics_basic(t *testing.T) {
+	ctx := acctest.Context(t)
+	var knowledgebase awstypes.KnowledgeBase
+	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
+	resourceName := "aws_bedrockagent_knowledge_base.test"
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:                 func() { acctest.PreCheck(ctx, t) },
+		ErrorCheck:               acctest.ErrorCheck(t, names.BedrockAgentServiceID),
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
+		CheckDestroy:             testAccCheckKnowledgeBaseDestroy(ctx),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccKnowledgeBaseConfig_NeptuneAnalytics_basic(rName),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckKnowledgeBaseExists(ctx, resourceName, &knowledgebase),
+				),
+				ConfigPlanChecks: resource.ConfigPlanChecks{
+					PreApply: []plancheck.PlanCheck{
+						plancheck.ExpectResourceAction(resourceName, plancheck.ResourceActionCreate),
+					},
+				},
+				ConfigStateChecks: []statecheck.StateCheck{
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New("knowledge_base_configuration"), knownvalue.ListExact([]knownvalue.Check{
+						knownvalue.MapExact(map[string]knownvalue.Check{
+							"kendra_knowledge_base_configuration": knownvalue.ListSizeExact(0),
+							"sql_knowledge_base_configuration":    knownvalue.ListSizeExact(0),
+							names.AttrType:                        tfknownvalue.StringExact(awstypes.KnowledgeBaseTypeVector),
+							"vector_knowledge_base_configuration": knownvalue.ListSizeExact(1),
+						}),
+					})),
+					statecheck.ExpectKnownValue(resourceName, tfjsonpath.New("storage_configuration"), knownvalue.ListExact([]knownvalue.Check{
+						knownvalue.MapExact(map[string]knownvalue.Check{
+							"mongo_db_atlas_configuration":             knownvalue.ListSizeExact(0),
+							"neptune_analytics_configuration":          knownvalue.ListSizeExact(1),
+							"opensearch_managed_cluster_configuration": knownvalue.ListSizeExact(0),
+							"opensearch_serverless_configuration":      knownvalue.ListSizeExact(0),
+							names.AttrType:                             tfknownvalue.StringExact(awstypes.KnowledgeBaseStorageTypeNeptuneAnalytics),
+							"pinecone_configuration":                   knownvalue.ListSizeExact(0),
+							"rds_configuration":                        knownvalue.ListSizeExact(0),
+							"redis_enterprise_cloud_configuration":     knownvalue.ListSizeExact(0),
+							"s3_vectors_configuration":                 knownvalue.ListSizeExact(0),
+						}),
+					})),
+				},
+			},
+		},
+	})
+}
+
+func testAccCheckKnowledgeBaseDestroy(ctx context.Context) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		conn := acctest.Provider.Meta().(*conns.AWSClient).BedrockAgentClient(ctx)
+
+		for _, rs := range s.RootModule().Resources {
+			if rs.Type != "aws_bedrockagent_knowledge_base" {
+				continue
+			}
+
+			_, err := tfbedrockagent.FindKnowledgeBaseByID(ctx, conn, rs.Primary.ID)
 
 			if retry.NotFound(err) {
 				continue
@@ -430,7 +756,7 @@ func testAccCheckKnowledgeBaseDestroy(ctx context.Context) resource.TestCheckFun
 	}
 }
 
-func testAccCheckKnowledgeBaseExists(ctx context.Context, n string, v *types.KnowledgeBase) resource.TestCheckFunc {
+func testAccCheckKnowledgeBaseExists(ctx context.Context, n string, v *awstypes.KnowledgeBase) resource.TestCheckFunc {
 	return func(s *terraform.State) error {
 		rs, ok := s.RootModule().Resources[n]
 		if !ok {
@@ -478,147 +804,307 @@ func testAccCheckKnowledgeBaseExists(ctx context.Context, n string, v *types.Kno
 // environment variable below.
 func skipIfOSSCollectionNameEnvVarNotSet(t *testing.T) string {
 	t.Helper()
-
-	v := os.Getenv("TF_AWS_BEDROCK_OSS_COLLECTION_NAME")
-	if v == "" {
-		acctest.Skip(t, "This test requires external configuration of an OpenSearch collection vector index. "+
-			"Set the TF_AWS_BEDROCK_OSS_COLLECTION_NAME environment variable to the OpenSearch collection name "+
-			"where the vector index is configured.")
-	}
-	return v
+	return acctest.SkipIfEnvVarNotSet(t, "TF_AWS_BEDROCK_OSS_COLLECTION_NAME")
 }
 
-func testAccKnowledgeBaseConfig_basicRDS(rName, model, description string) string {
-	if description == "" {
-		description = "null"
-	} else {
-		description = strconv.Quote(description)
-	}
-
-	return acctest.ConfigCompose(acctest.ConfigBedrockAgentKnowledgeBaseRDSBase(rName, model), fmt.Sprintf(`
+func testAccKnowledgeBaseConfig_tags1(rName, model, tag1Key, tag1Value string) string {
+	return acctest.ConfigCompose(acctest.ConfigBedrockAgentKnowledgeBaseS3VectorsBase(rName), fmt.Sprintf(`
 resource "aws_bedrockagent_knowledge_base" "test" {
+  depends_on = [
+    aws_iam_role_policy.test,
+  ]
+
   name     = %[1]q
   role_arn = aws_iam_role.test.arn
 
-  description = %[3]s
-
   knowledge_base_configuration {
+    type = "VECTOR"
+
     vector_knowledge_base_configuration {
       embedding_model_arn = "arn:${data.aws_partition.current.partition}:bedrock:${data.aws_region.current.region}::foundation-model/%[2]s"
+      embedding_model_configuration {
+        bedrock_embedding_model_configuration {
+          dimensions          = 256
+          embedding_data_type = "FLOAT32"
+        }
+      }
     }
-    type = "VECTOR"
   }
 
   storage_configuration {
-    type = "RDS"
-    rds_configuration {
-      resource_arn           = aws_rds_cluster.test.arn
-      credentials_secret_arn = tolist(aws_rds_cluster.test.master_user_secret)[0].secret_arn
-      database_name          = aws_rds_cluster.test.database_name
-      table_name             = "bedrock_integration.bedrock_kb"
-      field_mapping {
-        vector_field          = "embedding"
-        text_field            = "chunks"
-        metadata_field        = "metadata"
-        primary_key_field     = "id"
-        custom_metadata_field = "custom_metadata"
-      }
+    type = "S3_VECTORS"
+
+    s3_vectors_configuration {
+      index_arn = aws_s3vectors_index.test.index_arn
     }
   }
 
-  depends_on = [aws_iam_role_policy.test, null_resource.db_setup]
+  tags = {
+    %[3]q = %[4]q
+  }
 }
-`, rName, model, description))
+`, rName, model, tag1Key, tag1Value))
 }
 
-func testAccKnowledgeBaseConfig_updateRDS(rName, model, description string) string {
-	return acctest.ConfigCompose(acctest.ConfigBedrockAgentKnowledgeBaseRDSUpdateBase(rName, model), fmt.Sprintf(`
+func testAccKnowledgeBaseConfig_tags2(rName, model, tag1Key, tag1Value, tag2Key, tag2Value string) string {
+	return acctest.ConfigCompose(acctest.ConfigBedrockAgentKnowledgeBaseS3VectorsBase(rName), fmt.Sprintf(`
 resource "aws_bedrockagent_knowledge_base" "test" {
-  name     = "%[1]s-update"
-  role_arn = aws_iam_role.test_update.arn
+  depends_on = [
+    aws_iam_role_policy.test,
+  ]
 
-  description = %[3]q
+  name     = %[1]q
+  role_arn = aws_iam_role.test.arn
 
   knowledge_base_configuration {
+    type = "VECTOR"
+
     vector_knowledge_base_configuration {
       embedding_model_arn = "arn:${data.aws_partition.current.partition}:bedrock:${data.aws_region.current.region}::foundation-model/%[2]s"
+      embedding_model_configuration {
+        bedrock_embedding_model_configuration {
+          dimensions          = 256
+          embedding_data_type = "FLOAT32"
+        }
+      }
     }
-    type = "VECTOR"
   }
 
   storage_configuration {
-    type = "RDS"
-    rds_configuration {
-      resource_arn           = aws_rds_cluster.test.arn
-      credentials_secret_arn = tolist(aws_rds_cluster.test.master_user_secret)[0].secret_arn
-      database_name          = aws_rds_cluster.test.database_name
-      table_name             = "bedrock_integration.bedrock_kb"
-      field_mapping {
-        vector_field          = "embedding"
-        text_field            = "chunks"
-        metadata_field        = "metadata"
-        primary_key_field     = "id"
-        custom_metadata_field = "custom_metadata"
-      }
+    type = "S3_VECTORS"
+
+    s3_vectors_configuration {
+      index_arn = aws_s3vectors_index.test.index_arn
     }
   }
 
-  depends_on = [aws_iam_role_policy.test_update, null_resource.db_setup]
+  tags = {
+    %[3]q = %[4]q
+    %[5]q = %[6]q
+  }
 }
-`, rName, model, description))
+`, rName, model, tag1Key, tag1Value, tag2Key, tag2Value))
 }
 
-func testAccKnowledgeBaseConfig_tags1(rName, model, tag1Key, tag1Value string) string {
-	return acctest.ConfigCompose(acctest.ConfigBedrockAgentKnowledgeBaseRDSBase(rName, model), fmt.Sprintf(`
+func testAccKnowledgeBaseConfig_description(rName, model, description string) string {
+	return acctest.ConfigCompose(acctest.ConfigBedrockAgentKnowledgeBaseS3VectorsBase(rName), fmt.Sprintf(`
 resource "aws_bedrockagent_knowledge_base" "test" {
-  name     = %[1]q
-  role_arn = aws_iam_role.test.arn
+  depends_on = [
+    aws_iam_role_policy.test,
+  ]
+
+  name        = %[1]q
+  role_arn    = aws_iam_role.test.arn
+  description = %[3]q
 
   knowledge_base_configuration {
+    type = "VECTOR"
+
     vector_knowledge_base_configuration {
       embedding_model_arn = "arn:${data.aws_partition.current.partition}:bedrock:${data.aws_region.current.region}::foundation-model/%[2]s"
+      embedding_model_configuration {
+        bedrock_embedding_model_configuration {
+          dimensions          = 256
+          embedding_data_type = "FLOAT32"
+        }
+      }
     }
-    type = "VECTOR"
   }
 
   storage_configuration {
-    type = "RDS"
-    rds_configuration {
-      resource_arn           = aws_rds_cluster.test.arn
-      credentials_secret_arn = tolist(aws_rds_cluster.test.master_user_secret)[0].secret_arn
-      database_name          = aws_rds_cluster.test.database_name
-      table_name             = "bedrock_integration.bedrock_kb"
-      field_mapping {
-        vector_field          = "embedding"
-        text_field            = "chunks"
-        metadata_field        = "metadata"
-        primary_key_field     = "id"
-        custom_metadata_field = "custom_metadata"
-      }
-    }
-  }
+    type = "S3_VECTORS"
 
-  tags = {
-    %[3]q = %[4]q
+    s3_vectors_configuration {
+      index_arn = aws_s3vectors_index.test.index_arn
+    }
   }
-
-  depends_on = [aws_iam_role_policy.test, null_resource.db_setup]
 }
-`, rName, model, tag1Key, tag1Value))
+`, rName, model, description))
 }
 
-func testAccKnowledgeBaseConfig_tags2(rName, model, tag1Key, tag1Value, tag2Key, tag2Value string) string {
-	return acctest.ConfigCompose(acctest.ConfigBedrockAgentKnowledgeBaseRDSBase(rName, model), fmt.Sprintf(`
-resource "aws_bedrockagent_knowledge_base" "test" {
-  name     = %[1]q
-  role_arn = aws_iam_role.test.arn
+func testAccKnowledgeBaseConfig_baseRDS(rName, model string) string {
+	return acctest.ConfigCompose(acctest.ConfigVPCWithSubnetsEnableDNSHostnames(rName, 2), fmt.Sprintf(`
+data "aws_partition" "current" {}
+data "aws_region" "current" {}
 
-  knowledge_base_configuration {
-    vector_knowledge_base_configuration {
-      embedding_model_arn = "arn:${data.aws_partition.current.partition}:bedrock:${data.aws_region.current.region}::foundation-model/%[2]s"
-    }
-    type = "VECTOR"
-  }
+resource "aws_iam_role" "test" {
+  name               = %[1]q
+  path               = "/service-role/"
+  assume_role_policy = <<POLICY
+{
+	"Version": "2012-10-17",
+	"Statement": [{
+		"Action": "sts:AssumeRole",
+		"Principal": {
+		"Service": "bedrock.amazonaws.com"
+		},
+		"Effect": "Allow"
+	}]
+}
+POLICY
+}
+
+# See https://docs.aws.amazon.com/bedrock/latest/userguide/kb-permissions.html.
+resource "aws_iam_role_policy" "test" {
+  name   = %[1]q
+  role   = aws_iam_role.test.name
+  policy = <<POLICY
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Action": [
+        "bedrock:ListFoundationModels",
+        "bedrock:ListCustomModels"
+      ],
+      "Resource": "*"
+    },
+    {
+      "Effect": "Allow",
+      "Action": [
+        "bedrock:InvokeModel"
+      ],
+      "Resource": [
+        "arn:${data.aws_partition.current.partition}:bedrock:${data.aws_region.current.region}::foundation-model/%[2]s"
+      ]
+    }
+  ]
+}
+POLICY
+}
+
+resource "aws_iam_role_policy_attachment" "rds_data_full_access" {
+  role       = aws_iam_role.test.name
+  policy_arn = "arn:${data.aws_partition.current.partition}:iam::${data.aws_partition.current.partition}:policy/AmazonRDSDataFullAccess"
+}
+
+resource "aws_iam_role_policy_attachment" "secrets_manager_read_write" {
+  role       = aws_iam_role.test.name
+  policy_arn = "arn:${data.aws_partition.current.partition}:iam::${data.aws_partition.current.partition}:policy/SecretsManagerReadWrite"
+}
+
+data "aws_rds_orderable_db_instance" "test" {
+  engine                     = "aurora-postgresql"
+  engine_latest_version      = true
+  preferred_instance_classes = ["db.serverless"]
+}
+
+resource "aws_rds_cluster" "test" {
+  cluster_identifier          = %[1]q
+  master_username             = "test"
+  manage_master_user_password = true
+  database_name               = "test"
+  skip_final_snapshot         = true
+  engine                      = data.aws_rds_orderable_db_instance.test.engine
+  engine_version              = data.aws_rds_orderable_db_instance.test.engine_version
+  enable_http_endpoint        = true
+  vpc_security_group_ids      = [aws_security_group.test.id]
+  db_subnet_group_name        = aws_db_subnet_group.test.name
+
+  serverlessv2_scaling_configuration {
+    max_capacity = 1.0
+    min_capacity = 0.5
+  }
+}
+
+resource "aws_rds_cluster_instance" "test" {
+  cluster_identifier  = aws_rds_cluster.test.id
+  instance_class      = "db.serverless"
+  engine              = aws_rds_cluster.test.engine
+  engine_version      = aws_rds_cluster.test.engine_version
+  publicly_accessible = true
+}
+
+resource "aws_db_subnet_group" "test" {
+  name       = %[1]q
+  subnet_ids = aws_subnet.test[*].id
+}
+
+resource "aws_internet_gateway" "test" {
+  vpc_id = aws_vpc.test.id
+
+  tags = {
+    Name = %[1]q
+  }
+}
+
+resource "aws_default_route_table" "test" {
+  default_route_table_id = aws_vpc.test.default_route_table_id
+
+  route {
+    cidr_block = "0.0.0.0/0"
+    gateway_id = aws_internet_gateway.test.id
+  }
+
+  tags = {
+    Name = %[1]q
+  }
+}
+
+resource "aws_security_group" "test" {
+  name   = %[1]q
+  vpc_id = aws_vpc.test.id
+
+  ingress {
+    from_port   = 5432
+    to_port     = 5432
+    protocol    = "tcp"
+    cidr_blocks = ["0.0.0.0/0"]
+  }
+
+  egress {
+    from_port   = 0
+    to_port     = 0
+    protocol    = "-1"
+    cidr_blocks = ["0.0.0.0/0"]
+  }
+
+  tags = {
+    Name = %[1]q
+  }
+}
+
+data "aws_secretsmanager_secret_version" "test" {
+  secret_id     = aws_rds_cluster.test.master_user_secret[0].secret_arn
+  version_stage = "AWSCURRENT"
+  depends_on    = [aws_rds_cluster.test]
+}
+
+resource "null_resource" "db_setup" {
+  depends_on = [aws_rds_cluster_instance.test, aws_rds_cluster.test, data.aws_secretsmanager_secret_version.test]
+
+  provisioner "local-exec" {
+    command = <<EOT
+      sleep 60
+      export PGPASSWORD=$(aws secretsmanager get-secret-value --secret-id '${aws_rds_cluster.test.master_user_secret[0].secret_arn}' --version-stage AWSCURRENT --region ${data.aws_region.current.region} --query SecretString --output text | jq -r '."password"')
+      psql -h ${aws_rds_cluster.test.endpoint} -U ${aws_rds_cluster.test.master_username} -d ${aws_rds_cluster.test.database_name} -c "CREATE EXTENSION IF NOT EXISTS vector;"
+      psql -h ${aws_rds_cluster.test.endpoint} -U ${aws_rds_cluster.test.master_username} -d ${aws_rds_cluster.test.database_name} -c "CREATE SCHEMA IF NOT EXISTS bedrock_integration;"
+      psql -h ${aws_rds_cluster.test.endpoint} -U ${aws_rds_cluster.test.master_username} -d ${aws_rds_cluster.test.database_name} -c "CREATE SCHEMA IF NOT EXISTS bedrock_new;"
+      psql -h ${aws_rds_cluster.test.endpoint} -U ${aws_rds_cluster.test.master_username} -d ${aws_rds_cluster.test.database_name} -c "CREATE ROLE bedrock_user WITH PASSWORD '$PGPASSWORD' LOGIN;"
+      psql -h ${aws_rds_cluster.test.endpoint} -U ${aws_rds_cluster.test.master_username} -d ${aws_rds_cluster.test.database_name} -c "GRANT ALL ON SCHEMA bedrock_integration TO bedrock_user;"
+      psql -h ${aws_rds_cluster.test.endpoint} -U ${aws_rds_cluster.test.master_username} -d ${aws_rds_cluster.test.database_name} -c "CREATE TABLE bedrock_integration.bedrock_kb (id uuid PRIMARY KEY, embedding vector(1536), chunks text, metadata json, custom_metadata jsonb);"
+      psql -h ${aws_rds_cluster.test.endpoint} -U ${aws_rds_cluster.test.master_username} -d ${aws_rds_cluster.test.database_name} -c "CREATE INDEX ON bedrock_integration.bedrock_kb USING hnsw (embedding vector_cosine_ops);"
+      psql -h ${aws_rds_cluster.test.endpoint} -U ${aws_rds_cluster.test.master_username} -d ${aws_rds_cluster.test.database_name} -c "CREATE INDEX ON bedrock_integration.bedrock_kb USING gin (to_tsvector('simple', chunks));"
+      psql -h ${aws_rds_cluster.test.endpoint} -U ${aws_rds_cluster.test.master_username} -d ${aws_rds_cluster.test.database_name} -c "CREATE INDEX ON bedrock_integration.bedrock_kb USING gin (custom_metadata);"
+    EOT
+  }
+}
+`, rName, model))
+}
+
+func testAccKnowledgeBaseConfig_RDS_basic(rName, model string) string {
+	return acctest.ConfigCompose(testAccKnowledgeBaseConfig_baseRDS(rName, model), fmt.Sprintf(`
+resource "aws_bedrockagent_knowledge_base" "test" {
+  name     = %[1]q
+  role_arn = aws_iam_role.test.arn
+
+  knowledge_base_configuration {
+    vector_knowledge_base_configuration {
+      embedding_model_arn = "arn:${data.aws_partition.current.partition}:bedrock:${data.aws_region.current.region}::foundation-model/%[2]s"
+    }
+    type = "VECTOR"
+  }
 
   storage_configuration {
     type = "RDS"
@@ -637,17 +1123,101 @@ resource "aws_bedrockagent_knowledge_base" "test" {
     }
   }
 
-  tags = {
-    %[3]q = %[4]q
-    %[5]q = %[6]q
+  depends_on = [aws_iam_role_policy.test, null_resource.db_setup]
+}
+`, rName, model))
+}
+
+func testAccKnowledgeBaseConfig_RDS_supplementalDataStorage(rName, model string) string {
+	return acctest.ConfigCompose(testAccKnowledgeBaseConfig_baseRDS(rName, model), fmt.Sprintf(`
+data "aws_caller_identity" "current" {}
+
+resource "aws_s3_bucket" "test" {
+  bucket        = %[1]q
+  force_destroy = true
+}
+
+data "aws_iam_policy_document" "test_s3" {
+  statement {
+    effect = "Allow"
+    actions = [
+      "s3:DeleteObject",
+      "s3:GetObject",
+      "s3:ListBucket",
+      "s3:PutObject",
+    ]
+    resources = [
+      "arn:${data.aws_partition.current.partition}:s3:::${aws_s3_bucket.test.bucket}",
+      "arn:${data.aws_partition.current.partition}:s3:::${aws_s3_bucket.test.bucket}/*",
+    ]
+    condition {
+      test     = "StringEquals"
+      variable = "aws:PrincipalAccount"
+      values = [
+        data.aws_caller_identity.current.account_id,
+      ]
+    }
   }
+}
 
-  depends_on = [aws_iam_role_policy.test, null_resource.db_setup]
+resource "aws_iam_policy" "test_s3" {
+  name   = "%[1]s-s3"
+  policy = data.aws_iam_policy_document.test_s3.json
 }
-`, rName, model, tag1Key, tag1Value, tag2Key, tag2Value))
+
+resource "aws_iam_role_policy_attachment" "test_s3" {
+  role       = aws_iam_role.test.name
+  policy_arn = aws_iam_policy.test_s3.arn
 }
 
-func testAccKnowledgeBaseConfigBase_openSearch(rName, collectionName, model string) string {
+resource "aws_bedrockagent_knowledge_base" "test" {
+  name     = %[1]q
+  role_arn = aws_iam_role.test.arn
+
+  knowledge_base_configuration {
+    vector_knowledge_base_configuration {
+      embedding_model_arn = "arn:${data.aws_partition.current.partition}:bedrock:${data.aws_region.current.region}::foundation-model/%[2]s"
+
+      supplemental_data_storage_configuration {
+        storage_location {
+          type = "S3"
+          s3_location {
+            uri = "s3://${aws_s3_bucket.test.bucket}"
+          }
+        }
+      }
+    }
+
+    type = "VECTOR"
+
+
+  }
+
+  storage_configuration {
+    type = "RDS"
+
+    rds_configuration {
+      resource_arn           = aws_rds_cluster.test.arn
+      credentials_secret_arn = tolist(aws_rds_cluster.test.master_user_secret)[0].secret_arn
+      database_name          = aws_rds_cluster.test.database_name
+      table_name             = "bedrock_integration.bedrock_kb"
+
+      field_mapping {
+        vector_field          = "embedding"
+        text_field            = "chunks"
+        metadata_field        = "metadata"
+        primary_key_field     = "id"
+        custom_metadata_field = "custom_metadata"
+      }
+    }
+  }
+
+  depends_on = [aws_iam_role_policy.test, aws_iam_role_policy_attachment.test_s3, null_resource.db_setup]
+}
+`, rName, model))
+}
+
+func testAccKnowledgeBaseConfig_baseOpenSearchServerless(rName, collectionName, model string) string {
 	return fmt.Sprintf(`
 data "aws_caller_identity" "current" {}
 data "aws_region" "current" {}
@@ -785,10 +1355,8 @@ resource "aws_opensearchserverless_access_policy" "test" {
 `, rName, collectionName, model)
 }
 
-func testAccKnowledgeBaseConfig_OpenSearch_basic(rName, collectionName, model string) string {
-	return acctest.ConfigCompose(
-		testAccKnowledgeBaseConfigBase_openSearch(rName, collectionName, model),
-		fmt.Sprintf(`
+func testAccKnowledgeBaseConfig_OpenSearchServerless_basic(rName, collectionName, model string) string {
+	return acctest.ConfigCompose(testAccKnowledgeBaseConfig_baseOpenSearchServerless(rName, collectionName, model), fmt.Sprintf(`
 resource "aws_bedrockagent_knowledge_base" "test" {
   depends_on = [
     aws_iam_role_policy_attachment.test,
@@ -821,90 +1389,430 @@ resource "aws_bedrockagent_knowledge_base" "test" {
 `, rName, model))
 }
 
-func testAccKnowledgeBaseConfig_OpenSearch_update(rName, collectionName, model string) string {
-	return acctest.ConfigCompose(
-		testAccKnowledgeBaseConfigBase_openSearch(rName, collectionName, model),
-		fmt.Sprintf(`
+func testAccKnowledgeBaseConfig_Kendra_basic(rName, kendraIndexArn string) string {
+	return fmt.Sprintf(`
+data "aws_caller_identity" "current" {}
+data "aws_region" "current" {}
+data "aws_partition" "current" {}
+
+resource "aws_iam_role" "test" {
+  name = %[1]q
+
+  assume_role_policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [
+      {
+        Action = "sts:AssumeRole"
+        Effect = "Allow"
+        Principal = {
+          Service = "bedrock.amazonaws.com"
+        }
+        Condition = {
+          StringEquals = {
+            "aws:SourceAccount" = data.aws_caller_identity.current.account_id
+          }
+          ArnLike = {
+            "aws:SourceArn" = "arn:${data.aws_partition.current.partition}:bedrock:${data.aws_region.current.region}:${data.aws_caller_identity.current.account_id}:knowledge-base/*"
+          }
+        }
+      }
+    ]
+  })
+}
+
+resource "aws_iam_role_policy" "test" {
+  name = "%[1]s-bedrock"
+  role = aws_iam_role.test.id
+
+  policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [
+      {
+        Effect = "Allow"
+        Action = [
+          "kendra:Retrieve",
+          "kendra:DescribeIndex"
+        ]
+        Resource = %[2]q
+      }
+    ]
+  })
+}
+
 resource "aws_bedrockagent_knowledge_base" "test" {
+  name     = %[1]q
+  role_arn = aws_iam_role.test.arn
+
+  knowledge_base_configuration {
+    type = "KENDRA"
+    kendra_knowledge_base_configuration {
+      kendra_index_arn = %[2]q
+    }
+  }
+
+  depends_on = [aws_iam_role_policy.test]
+}
+`, rName, kendraIndexArn)
+}
+
+func testAccKnowledgeBaseConfig_baseOpenSearchManagedCluster(rName, model string) string {
+	// lintignore:AT004
+	return fmt.Sprintf(`
+terraform {
+  required_providers {
+    opensearch = {
+      source  = "opensearch-project/opensearch"
+      version = "~> 2.2.0"
+    }
+  }
+}
+
+data "aws_partition" "current" {}
+data "aws_region" "current" {}
+data "aws_caller_identity" "current" {}
+data "aws_iam_role" "opensearch" {
+  name = "AWSServiceRoleForAmazonOpenSearchService"
+}
+
+resource "aws_iam_role" "bedrock_kb_role" {
+  name = %[1]q
+
+  assume_role_policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [
+      {
+        Effect = "Allow"
+        Principal = {
+          Service = "bedrock.${data.aws_partition.current.dns_suffix}"
+        }
+        Action = "sts:AssumeRole"
+        Condition = {
+          StringEquals = {
+            "aws:SourceAccount" : data.aws_caller_identity.current.account_id
+          },
+        }
+      }
+    ]
+  })
+}
+
+resource "aws_iam_policy" "bedrock_models_access" {
+  name        = "bedrock-%[1]s"
+  description = "IAM policy for Amazon Bedrock to access embedding models"
+
+  policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [
+      {
+        Effect = "Allow"
+        Action = [
+          "bedrock:RetrieveAndGenerate"
+        ]
+        Resource = "*"
+      },
+      {
+        Effect = "Allow"
+        Action = [
+          "bedrock:ListFoundationModels",
+          "bedrock:ListCustomModels"
+        ]
+        Resource = "*"
+      },
+      {
+        Effect = "Allow"
+        Action = [
+          "bedrock:InvokeModel"
+        ]
+        Resource = [
+          "arn:${data.aws_partition.current.partition}:bedrock:${data.aws_region.current.region}::foundation-model/%[2]s"
+        ]
+      }
+    ]
+  })
+}
+
+resource "aws_iam_policy" "opensearch_access" {
+  name        = "os-%[1]s"
+  description = "IAM policy for Amazon Bedrock to access OpenSearch domain"
+
+  policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [
+      {
+        Effect = "Allow"
+        Action = [
+          "es:ESHttpGet",
+          "es:ESHttpPost",
+          "es:ESHttpPut",
+          "es:ESHttpDelete"
+        ]
+        Resource = [
+          "*"
+        ]
+      },
+      {
+        Effect = "Allow"
+        Action = [
+          "es:DescribeDomain",
+          "es:DescribeElasticsearchDomain"
+        ]
+        Resource = [
+          "*"
+        ]
+      }
+    ]
+  })
+}
+
+resource "aws_iam_role_policy_attachment" "bedrock_models_access" {
+  role       = aws_iam_role.bedrock_kb_role.name
+  policy_arn = aws_iam_policy.bedrock_models_access.arn
+}
+
+resource "aws_iam_role_policy_attachment" "opensearch_access" {
+  role       = aws_iam_role.bedrock_kb_role.name
+  policy_arn = aws_iam_policy.opensearch_access.arn
+}
+
+resource "aws_opensearch_domain" "knowledge_base" {
+  domain_name     = substr(%[1]q, 0, 28)
+  engine_version  = "OpenSearch_3.1"
+  access_policies = local.opensearch_access_policy
+
+  cluster_config {
+    instance_type            = "or2.medium.search"
+    instance_count           = 1
+    zone_awareness_enabled   = false
+    dedicated_master_enabled = false
+  }
+
+  # Configure EBS volumes for the data nodes
+  ebs_options {
+    ebs_enabled = true
+    volume_size = 20
+    volume_type = "gp3"
+  }
+
+  # Enable encryption at rest
+  encrypt_at_rest {
+    enabled = true
+  }
+
+  # Enable node to node encryption
+  node_to_node_encryption {
+    enabled = true
+  }
+
+  # Configure domain endpoint options
+  domain_endpoint_options {
+    enforce_https       = true
+    tls_security_policy = "Policy-Min-TLS-1-2-PFS-2023-10"
+  }
+
+  # Configure advanced security options
+  advanced_security_options {
+    enabled                        = true
+    internal_user_database_enabled = true
+
+    master_user_options {
+      master_user_name     = "admin"
+      master_user_password = "Barbarbarbar1!"
+    }
+  }
+
+  # Auto-Tune options
+  auto_tune_options {
+    desired_state = "ENABLED"
+  }
+
+  # Software update options
+  software_update_options {
+    auto_software_update_enabled = true
+  }
+
+  # This is required to reference the existing service-linked role
   depends_on = [
-    aws_iam_role_policy_attachment.test,
-    aws_opensearchserverless_access_policy.test,
+    data.aws_iam_role.opensearch
   ]
+}
 
-  name        = "%[1]s-updated"
-  description = %[1]q
-  role_arn    = aws_iam_role.test.arn
+locals {
+  opensearch_access_policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [
+      {
+        Effect = "Allow"
+        Principal = {
+          AWS = "*"
+        }
+        Action   = "es:*"
+        Resource = "arn:${data.aws_partition.current.partition}:es:${data.aws_region.current.region}:${data.aws_caller_identity.current.account_id}:domain/${substr(%[1]q, 0, 28)}/*"
+      }
+    ]
+  })
+}
+
+provider "opensearch" {
+  url               = "https://${aws_opensearch_domain.knowledge_base.endpoint}"
+  username          = "admin"
+  password          = aws_opensearch_domain.knowledge_base.advanced_security_options[0].master_user_options[0].master_user_password
+  insecure          = false
+  aws_region        = data.aws_region.current.region
+  healthcheck       = false
+  sniff             = false
+  sign_aws_requests = false
+}
+
+resource "opensearch_role" "os_kb_role" {
+  role_name   = "kb-%[1]s"
+  description = "Knowledge Base Role"
+
+  cluster_permissions = ["*"]
+
+  index_permissions {
+    index_patterns  = ["*"]
+    allowed_actions = ["*"]
+  }
+
+  tenant_permissions {
+    tenant_patterns = ["*"]
+    allowed_actions = ["*"]
+  }
+}
+
+resource "opensearch_roles_mapping" "mapper" {
+  role_name   = opensearch_role.os_kb_role.role_name
+  description = "Mapping AWS IAM roles to ES role"
+
+  backend_roles = [
+    aws_iam_role.bedrock_kb_role.arn,
+    data.aws_caller_identity.current.arn
+  ]
+}
+
+resource "opensearch_index" "vector_index" {
+  name               = "knowledge-index"
+  number_of_shards   = "5"
+  number_of_replicas = "1"
+  index_knn          = true
+
+  # Mappings for Bedrock Knowledge Base compatibility
+  mappings = jsonencode({
+    "properties" : {
+      "vector_embedding" : {
+        "type" : "knn_vector",
+        "dimension" : 1024,
+        "space_type" : "l2",
+        "method" : {
+          "name" : "hnsw",
+          "engine" : "faiss",
+          "parameters" : {
+            "ef_construction" : 128,
+            "m" : 24
+          }
+        }
+      },
+      "text" : {
+        "type" : "text",
+        "index" : true
+      },
+      "metadata" : {
+        "type" : "text",
+        "index" : false
+      }
+    }
+  })
+
+  lifecycle {
+    ignore_changes = [mappings]
+  }
+
+  depends_on = [aws_opensearch_domain.knowledge_base]
+}
+`, rName, model)
+}
+
+func testAccKnowledgeBaseConfig_OpenSearchManagedCluster_basic(rName, model string) string {
+	return acctest.ConfigCompose(testAccKnowledgeBaseConfig_baseOpenSearchManagedCluster(rName, model), fmt.Sprintf(`
+resource "aws_bedrockagent_knowledge_base" "test" {
+  name     = %[1]q
+  role_arn = aws_iam_role.bedrock_kb_role.arn
 
   knowledge_base_configuration {
+    type = "VECTOR"
+
     vector_knowledge_base_configuration {
       embedding_model_arn = "arn:${data.aws_partition.current.partition}:bedrock:${data.aws_region.current.region}::foundation-model/%[2]s"
     }
-    type = "VECTOR"
   }
 
   storage_configuration {
-    type = "OPENSEARCH_SERVERLESS"
-    opensearch_serverless_configuration {
-      collection_arn    = data.aws_opensearchserverless_collection.test.arn
-      vector_index_name = "bedrock-knowledge-base-default-index"
+    type = "OPENSEARCH_MANAGED_CLUSTER"
+
+    opensearch_managed_cluster_configuration {
+      domain_arn        = aws_opensearch_domain.knowledge_base.arn
+      domain_endpoint   = "https://${aws_opensearch_domain.knowledge_base.endpoint}"
+      vector_index_name = "knowledge-index"
+
       field_mapping {
-        vector_field   = "bedrock-knowledge-base-default-vector"
-        text_field     = "AMAZON_BEDROCK_TEXT_CHUNK"
-        metadata_field = "AMAZON_BEDROCK_METADATA"
+        vector_field   = "vector_embedding"
+        text_field     = "text"
+        metadata_field = "metadata"
       }
     }
   }
+
+  depends_on = [
+    aws_opensearch_domain.knowledge_base,
+    opensearch_index.vector_index,
+    opensearch_roles_mapping.mapper,
+    aws_iam_role_policy_attachment.opensearch_access,
+    aws_iam_role_policy_attachment.bedrock_models_access,
+  ]
 }
 `, rName, model))
 }
 
-func testAccKnowledgeBaseConfig_OpenSearch_supplementalDataStorage(rName, collectionName, model string) string {
-	return acctest.ConfigCompose(
-		testAccKnowledgeBaseConfigBase_openSearch(rName, collectionName, model),
-		fmt.Sprintf(`
-resource "aws_s3_bucket" "test" {
-  bucket        = %[1]q
-  force_destroy = true
-}
+func testAccKnowledgeBaseConfig_S3VectorsByIndexARN(rName, model string) string {
+	return acctest.ConfigCompose(acctest.ConfigBedrockAgentKnowledgeBaseS3VectorsBase(rName), fmt.Sprintf(`
+resource "aws_bedrockagent_knowledge_base" "test" {
+  depends_on = [
+    aws_iam_role_policy.test,
+  ]
 
-data "aws_iam_policy_document" "test_s3" {
-  statement {
-    effect = "Allow"
-    actions = [
-      "s3:DeleteObject",
-      "s3:GetObject",
-      "s3:ListBucket",
-      "s3:PutObject",
-    ]
-    resources = [
-      "arn:${data.aws_partition.current.partition}:s3:::${aws_s3_bucket.test.bucket}",
-      "arn:${data.aws_partition.current.partition}:s3:::${aws_s3_bucket.test.bucket}/*",
-    ]
-    condition {
-      test     = "StringEquals"
-      variable = "aws:PrincipalAccount"
-      values = [
-        data.aws_caller_identity.current.account_id,
-      ]
+  name     = %[1]q
+  role_arn = aws_iam_role.test.arn
+
+  knowledge_base_configuration {
+    type = "VECTOR"
+
+    vector_knowledge_base_configuration {
+      embedding_model_arn = "arn:${data.aws_partition.current.partition}:bedrock:${data.aws_region.current.region}::foundation-model/%[2]s"
+      embedding_model_configuration {
+        bedrock_embedding_model_configuration {
+          dimensions          = 256
+          embedding_data_type = "FLOAT32"
+        }
+      }
     }
   }
-}
 
-resource "aws_iam_policy" "test_s3" {
-  name   = "%[1]s-s3"
-  policy = data.aws_iam_policy_document.test_s3.json
-}
+  storage_configuration {
+    type = "S3_VECTORS"
 
-resource "aws_iam_role_policy_attachment" "test_s3" {
-  role       = aws_iam_role.test.name
-  policy_arn = aws_iam_policy.test_s3.arn
+    s3_vectors_configuration {
+      index_arn = aws_s3vectors_index.test.index_arn
+    }
+  }
+}
+`, rName, model))
 }
 
+func testAccKnowledgeBaseConfig_S3VectorsByIndexName(rName, model string) string {
+	return acctest.ConfigCompose(acctest.ConfigBedrockAgentKnowledgeBaseS3VectorsBase(rName), fmt.Sprintf(`
 resource "aws_bedrockagent_knowledge_base" "test" {
   depends_on = [
-    aws_iam_role_policy_attachment.test,
-    aws_iam_role_policy_attachment.test_s3,
-    aws_opensearchserverless_access_policy.test,
+    aws_iam_role_policy.test,
   ]
 
   name     = %[1]q
@@ -912,37 +1820,391 @@ resource "aws_bedrockagent_knowledge_base" "test" {
 
   knowledge_base_configuration {
     type = "VECTOR"
+
     vector_knowledge_base_configuration {
       embedding_model_arn = "arn:${data.aws_partition.current.partition}:bedrock:${data.aws_region.current.region}::foundation-model/%[2]s"
       embedding_model_configuration {
         bedrock_embedding_model_configuration {
-          dimensions          = 1024
+          dimensions          = 256
           embedding_data_type = "FLOAT32"
         }
       }
-      supplemental_data_storage_configuration {
-        storage_location {
-          type = "S3"
-          s3_location {
-            uri = "s3://${aws_s3_bucket.test.bucket}"
+    }
+  }
+
+  storage_configuration {
+    type = "S3_VECTORS"
+
+    s3_vectors_configuration {
+      index_name        = aws_s3vectors_index.test.index_name
+      vector_bucket_arn = aws_s3vectors_vector_bucket.test.vector_bucket_arn
+    }
+  }
+}
+`, rName, model))
+}
+
+func testAccKnowledgeBaseConfig_StructuredDataStore_redshiftProvisioned(rName string) string {
+	return fmt.Sprintf(`
+data "aws_caller_identity" "current" {}
+data "aws_region" "current" {}
+data "aws_partition" "current" {}
+
+resource "aws_iam_role" "test" {
+  name = %[1]q
+
+  assume_role_policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [
+      {
+        Action = "sts:AssumeRole"
+        Effect = "Allow"
+        Principal = {
+          Service = "bedrock.amazonaws.com"
+        }
+        Condition = {
+          StringEquals = {
+            "aws:SourceAccount" = data.aws_caller_identity.current.account_id
+          }
+          ArnLike = {
+            "aws:SourceArn" = "arn:${data.aws_partition.current.partition}:bedrock:${data.aws_region.current.region}:${data.aws_caller_identity.current.account_id}:knowledge-base/*"
+          }
+        }
+      }
+    ]
+  })
+}
+
+resource "aws_iam_role_policy" "test" {
+  name = "%[1]s-bedrock"
+  role = aws_iam_role.test.id
+
+  policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [
+      {
+        Sid    = "RedshiftDataAPIStatementPermissions"
+        Effect = "Allow"
+        Action = [
+          "redshift-data:GetStatementResult",
+          "redshift-data:DescribeStatement",
+          "redshift-data:CancelStatement"
+        ]
+        Resource = ["*"]
+      },
+      {
+        Sid    = "RedshiftDataAPIExecutePermissions"
+        Effect = "Allow"
+        Action = [
+          "redshift-data:ExecuteStatement"
+        ]
+        Resource = ["*"]
+      },
+      {
+        Sid    = "SqlWorkbenchAccess"
+        Effect = "Allow"
+        Action = [
+          "sqlworkbench:GetSqlRecommendations",
+          "sqlworkbench:PutSqlGenerationContext",
+          "sqlworkbench:GetSqlGenerationContext",
+          "sqlworkbench:DeleteSqlGenerationContext"
+        ]
+        Resource = ["*"]
+      },
+      {
+        Sid    = "GenerateQueryAccess"
+        Effect = "Allow"
+        Action = [
+          "bedrock:GenerateQuery"
+        ]
+        Resource = ["*"]
+      },
+      {
+        Sid    = "GetCredentialsWithClusterCredentials"
+        Effect = "Allow"
+        Action = [
+          "redshift:GetClusterCredentials"
+        ]
+        Resource = ["*"]
+      }
+    ]
+  })
+}
+
+resource "aws_redshift_cluster" "test" {
+  cluster_identifier    = %[1]q
+  database_name         = "mydb"
+  master_username       = "foo_test"
+  master_password       = "Mustbe8characters"
+  node_type             = "ra3.large"
+  allow_version_upgrade = false
+  skip_final_snapshot   = true
+}
+
+resource "aws_bedrockagent_knowledge_base" "test" {
+  name     = %[1]q
+  role_arn = aws_iam_role.test.arn
+
+  knowledge_base_configuration {
+    type = "SQL"
+
+    sql_knowledge_base_configuration {
+      type = "REDSHIFT"
+
+      redshift_configuration {
+        query_engine_configuration {
+          type = "PROVISIONED"
+
+          provisioned_configuration {
+            cluster_identifier = aws_redshift_cluster.test.cluster_identifier
+
+            auth_configuration {
+              type          = "USERNAME"
+              database_user = aws_redshift_cluster.test.master_username
+            }
+          }
+        }
+
+        storage_configuration {
+          type = "REDSHIFT"
+
+          redshift_configuration {
+            database_name = aws_redshift_cluster.test.database_name
+          }
+        }
+      }
+    }
+  }
+
+  depends_on = [aws_iam_role_policy.test]
+}
+`, rName)
+}
+
+func testAccKnowledgeBaseConfig_StructuredDataStore_redshiftServerless(rName string) string {
+	return fmt.Sprintf(`
+data "aws_caller_identity" "current" {}
+data "aws_region" "current" {}
+data "aws_partition" "current" {}
+
+resource "aws_iam_role" "test" {
+  name = %[1]q
+
+  assume_role_policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [
+      {
+        Action = "sts:AssumeRole"
+        Effect = "Allow"
+        Principal = {
+          Service = "bedrock.amazonaws.com"
+        }
+        Condition = {
+          StringEquals = {
+            "aws:SourceAccount" = data.aws_caller_identity.current.account_id
+          }
+          ArnLike = {
+            "aws:SourceArn" = "arn:${data.aws_partition.current.partition}:bedrock:${data.aws_region.current.region}:${data.aws_caller_identity.current.account_id}:knowledge-base/*"
+          }
+        }
+      }
+    ]
+  })
+}
+
+resource "aws_iam_role_policy" "test" {
+  name = "%[1]s-bedrock"
+  role = aws_iam_role.test.id
+
+  policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [
+      {
+        Sid    = "SqlWorkbenchAccess"
+        Effect = "Allow"
+        Action = [
+          "sqlworkbench:GetSqlRecommendations",
+          "sqlworkbench:PutSqlGenerationContext",
+          "sqlworkbench:GetSqlGenerationContext",
+          "sqlworkbench:DeleteSqlGenerationContext"
+        ]
+        Resource = ["*"]
+      },
+      {
+        Sid    = "RedshiftServerlessGetCredentials"
+        Effect = "Allow"
+        Action = [
+          "redshift-serverless:GetClusterCredentials"
+        ]
+        Resource = ["*"]
+      }
+    ]
+  })
+}
+
+resource "aws_redshiftserverless_namespace" "test" {
+  namespace_name        = %[1]q
+  manage_admin_password = true
+}
+
+resource "aws_redshiftserverless_workgroup" "test" {
+  namespace_name = aws_redshiftserverless_namespace.test.namespace_name
+  workgroup_name = %[1]q
+}
+
+resource "aws_bedrockagent_knowledge_base" "test" {
+  name     = %[1]q
+  role_arn = aws_iam_role.test.arn
+
+  knowledge_base_configuration {
+    type = "SQL"
+
+    sql_knowledge_base_configuration {
+      type = "REDSHIFT"
+
+      redshift_configuration {
+        query_engine_configuration {
+          type = "SERVERLESS"
+
+          serverless_configuration {
+            workgroup_arn = aws_redshiftserverless_workgroup.test.arn
+
+            auth_configuration {
+              type                         = "USERNAME_PASSWORD"
+              username_password_secret_arn = aws_redshiftserverless_namespace.test.admin_password_secret_arn
+            }
+          }
+        }
+
+        storage_configuration {
+          type = "REDSHIFT"
+
+          redshift_configuration {
+            database_name = aws_redshiftserverless_namespace.test.db_name
+          }
+        }
+
+        query_generation_configuration {
+          generation_context {
+            curated_query {
+              natural_language = "Find all the things"
+              sql              = "SELECT * FROM things;"
+            }
           }
         }
       }
     }
   }
 
+  depends_on = [aws_iam_role_policy.test]
+}
+`, rName)
+}
+
+func testAccKnowledgeBaseConfig_NeptuneAnalytics_basic(rName string) string {
+	return fmt.Sprintf(`
+data "aws_caller_identity" "current" {}
+data "aws_region" "current" {}
+data "aws_partition" "current" {}
+
+resource "aws_iam_role" "test" {
+  name = %[1]q
+
+  assume_role_policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [
+      {
+        Action = "sts:AssumeRole"
+        Effect = "Allow"
+        Principal = {
+          Service = "bedrock.amazonaws.com"
+        }
+        Condition = {
+          StringEquals = {
+            "aws:SourceAccount" = data.aws_caller_identity.current.account_id
+          }
+          ArnLike = {
+            "aws:SourceArn" = "arn:${data.aws_partition.current.partition}:bedrock:${data.aws_region.current.region}:${data.aws_caller_identity.current.account_id}:knowledge-base/*"
+          }
+        }
+      }
+    ]
+  })
+}
+
+resource "aws_iam_role_policy" "test" {
+  name = "%[1]s-bedrock"
+  role = aws_iam_role.test.id
+
+  policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [
+      {
+        Sid    = "AllowAllPermissionsForRDS"
+        Effect = "Allow"
+        Action = [
+          "rds:*"
+        ]
+        Resource = ["*"]
+      },
+      {
+        Sid    = "AllowDataAccessForNeptune"
+        Effect = "Allow"
+        Action = [
+          "neptune-db:*"
+        ]
+        Resource = ["*"]
+      },
+      {
+        Sid    = "AllowAllPermissionsForNeptuneGraph"
+        Effect = "Allow"
+        Action = [
+          "neptune-graph:*"
+        ]
+        Resource = ["*"]
+      }
+    ]
+  })
+}
+
+resource "aws_neptunegraph_graph" "test" {
+  graph_name          = %[1]q
+  provisioned_memory  = 16
+  public_connectivity = false
+  replica_count       = 0
+  deletion_protection = false
+
+  vector_search_configuration {
+    vector_search_dimension = 1024
+  }
+}
+
+resource "aws_bedrockagent_knowledge_base" "test" {
+  name     = %[1]q
+  role_arn = aws_iam_role.test.arn
+
+  knowledge_base_configuration {
+    type = "VECTOR"
+
+    vector_knowledge_base_configuration {
+      embedding_model_arn = "arn:${data.aws_partition.current.partition}:bedrock:${data.aws_region.current.region}::foundation-model/cohere.embed-english-v3"
+    }
+  }
+
   storage_configuration {
-    type = "OPENSEARCH_SERVERLESS"
-    opensearch_serverless_configuration {
-      collection_arn    = data.aws_opensearchserverless_collection.test.arn
-      vector_index_name = "bedrock-knowledge-base-default-index"
+    type = "NEPTUNE_ANALYTICS"
+
+    neptune_analytics_configuration {
+      graph_arn = aws_neptunegraph_graph.test.arn
+
       field_mapping {
-        vector_field   = "bedrock-knowledge-base-default-vector"
-        text_field     = "AMAZON_BEDROCK_TEXT_CHUNK"
-        metadata_field = "AMAZON_BEDROCK_METADATA"
+        metadata_field = "metadata"
+        text_field     = "text"
       }
     }
   }
+
+  depends_on = [aws_iam_role_policy.test]
 }
-`, rName, model))
+`, rName)
 }
diff --git a/internal/service/logs/delivery_source_test.go b/internal/service/logs/delivery_source_test.go
index 4a189ae78d7e..b8a437091b13 100644
--- a/internal/service/logs/delivery_source_test.go
+++ b/internal/service/logs/delivery_source_test.go
@@ -22,10 +22,6 @@ import (
 )
 
 func testAccDeliverySource_basic(t *testing.T) {
-	acctest.SkipIfExeNotOnPath(t, "psql")
-	acctest.SkipIfExeNotOnPath(t, "jq")
-	acctest.SkipIfExeNotOnPath(t, "aws")
-
 	ctx := acctest.Context(t)
 	var v awstypes.DeliverySource
 	rName := acctest.RandomWithPrefix(t, acctest.ResourcePrefix)
@@ -37,13 +33,7 @@ func testAccDeliverySource_basic(t *testing.T) {
 		},
 		ErrorCheck:               acctest.ErrorCheck(t, names.LogsServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		ExternalProviders: map[string]resource.ExternalProvider{
-			"null": {
-				Source:            "hashicorp/null",
-				VersionConstraint: "3.2.2",
-			},
-		},
-		CheckDestroy: testAccCheckDeliverySourceDestroy(ctx, t),
+		CheckDestroy:             testAccCheckDeliverySourceDestroy(ctx, t),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDeliverySourceConfig_basic(rName),
@@ -75,10 +65,6 @@ func testAccDeliverySource_basic(t *testing.T) {
 }
 
 func testAccDeliverySource_disappears(t *testing.T) {
-	acctest.SkipIfExeNotOnPath(t, "psql")
-	acctest.SkipIfExeNotOnPath(t, "jq")
-	acctest.SkipIfExeNotOnPath(t, "aws")
-
 	ctx := acctest.Context(t)
 	var v awstypes.DeliverySource
 	rName := acctest.RandomWithPrefix(t, acctest.ResourcePrefix)
@@ -90,13 +76,7 @@ func testAccDeliverySource_disappears(t *testing.T) {
 		},
 		ErrorCheck:               acctest.ErrorCheck(t, names.LogsServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		ExternalProviders: map[string]resource.ExternalProvider{
-			"null": {
-				Source:            "hashicorp/null",
-				VersionConstraint: "3.2.2",
-			},
-		},
-		CheckDestroy: testAccCheckDeliverySourceDestroy(ctx, t),
+		CheckDestroy:             testAccCheckDeliverySourceDestroy(ctx, t),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDeliverySourceConfig_basic(rName),
@@ -111,10 +91,6 @@ func testAccDeliverySource_disappears(t *testing.T) {
 }
 
 func testAccDeliverySource_tags(t *testing.T) {
-	acctest.SkipIfExeNotOnPath(t, "psql")
-	acctest.SkipIfExeNotOnPath(t, "jq")
-	acctest.SkipIfExeNotOnPath(t, "aws")
-
 	ctx := acctest.Context(t)
 	var v awstypes.DeliverySource
 	rName := acctest.RandomWithPrefix(t, acctest.ResourcePrefix)
@@ -126,13 +102,7 @@ func testAccDeliverySource_tags(t *testing.T) {
 		},
 		ErrorCheck:               acctest.ErrorCheck(t, names.LogsServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		ExternalProviders: map[string]resource.ExternalProvider{
-			"null": {
-				Source:            "hashicorp/null",
-				VersionConstraint: "3.2.2",
-			},
-		},
-		CheckDestroy: testAccCheckDeliverySourceDestroy(ctx, t),
+		CheckDestroy:             testAccCheckDeliverySourceDestroy(ctx, t),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDeliverySourceConfig_tags1(rName, acctest.CtKey1, acctest.CtValue1),
@@ -303,37 +273,36 @@ resource "aws_cloudfront_distribution" "test" {
 }
 
 func testAccDeliverySourceConfig_base(rName string) string {
-	foundationModel := "amazon.titan-embed-text-v1"
+	foundationModel := "amazon.titan-embed-text-v2:0"
 
-	return acctest.ConfigCompose(acctest.ConfigBedrockAgentKnowledgeBaseRDSBase(rName, foundationModel), fmt.Sprintf(`
+	return acctest.ConfigCompose(acctest.ConfigBedrockAgentKnowledgeBaseS3VectorsBase(rName), fmt.Sprintf(`
 resource "aws_bedrockagent_knowledge_base" "test" {
   name     = %[1]q
   role_arn = aws_iam_role.test.arn
 
   knowledge_base_configuration {
+    type = "VECTOR"
+
     vector_knowledge_base_configuration {
       embedding_model_arn = "arn:${data.aws_partition.current.partition}:bedrock:${data.aws_region.current.region}::foundation-model/%[2]s"
+      embedding_model_configuration {
+        bedrock_embedding_model_configuration {
+          dimensions          = 256
+          embedding_data_type = "FLOAT32"
+        }
+      }
     }
-    type = "VECTOR"
   }
 
   storage_configuration {
-    type = "RDS"
-    rds_configuration {
-      resource_arn           = aws_rds_cluster.test.arn
-      credentials_secret_arn = tolist(aws_rds_cluster.test.master_user_secret)[0].secret_arn
-      database_name          = aws_rds_cluster.test.database_name
-      table_name             = "bedrock_integration.bedrock_kb"
-      field_mapping {
-        vector_field      = "embedding"
-        text_field        = "chunks"
-        metadata_field    = "metadata"
-        primary_key_field = "id"
-      }
+    type = "S3_VECTORS"
+
+    s3_vectors_configuration {
+      index_arn = aws_s3vectors_index.test.index_arn
     }
   }
 
-  depends_on = [aws_iam_role_policy.test, null_resource.db_setup]
+  depends_on = [aws_iam_role_policy.test]
 }
 `, rName, foundationModel))
 }
diff --git a/internal/service/logs/delivery_test.go b/internal/service/logs/delivery_test.go
index 0ea1f9ad4593..821903583cb6 100644
--- a/internal/service/logs/delivery_test.go
+++ b/internal/service/logs/delivery_test.go
@@ -23,10 +23,6 @@ import (
 )
 
 func testAccDelivery_basic(t *testing.T) {
-	acctest.SkipIfExeNotOnPath(t, "psql")
-	acctest.SkipIfExeNotOnPath(t, "jq")
-	acctest.SkipIfExeNotOnPath(t, "aws")
-
 	ctx := acctest.Context(t)
 	var v awstypes.Delivery
 	rName := acctest.RandomWithPrefix(t, acctest.ResourcePrefix)
@@ -38,13 +34,7 @@ func testAccDelivery_basic(t *testing.T) {
 		},
 		ErrorCheck:               acctest.ErrorCheck(t, names.LogsServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		ExternalProviders: map[string]resource.ExternalProvider{
-			"null": {
-				Source:            "hashicorp/null",
-				VersionConstraint: "3.2.2",
-			},
-		},
-		CheckDestroy: testAccCheckDeliveryDestroy(ctx, t),
+		CheckDestroy:             testAccCheckDeliveryDestroy(ctx, t),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDeliveryConfig_basic(rName),
@@ -76,10 +66,6 @@ func testAccDelivery_basic(t *testing.T) {
 }
 
 func testAccDelivery_disappears(t *testing.T) {
-	acctest.SkipIfExeNotOnPath(t, "psql")
-	acctest.SkipIfExeNotOnPath(t, "jq")
-	acctest.SkipIfExeNotOnPath(t, "aws")
-
 	ctx := acctest.Context(t)
 	var v awstypes.Delivery
 	rName := acctest.RandomWithPrefix(t, acctest.ResourcePrefix)
@@ -91,13 +77,7 @@ func testAccDelivery_disappears(t *testing.T) {
 		},
 		ErrorCheck:               acctest.ErrorCheck(t, names.LogsServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		ExternalProviders: map[string]resource.ExternalProvider{
-			"null": {
-				Source:            "hashicorp/null",
-				VersionConstraint: "3.2.2",
-			},
-		},
-		CheckDestroy: testAccCheckDeliveryDestroy(ctx, t),
+		CheckDestroy:             testAccCheckDeliveryDestroy(ctx, t),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDeliveryConfig_basic(rName),
@@ -112,10 +92,6 @@ func testAccDelivery_disappears(t *testing.T) {
 }
 
 func testAccDelivery_tags(t *testing.T) {
-	acctest.SkipIfExeNotOnPath(t, "psql")
-	acctest.SkipIfExeNotOnPath(t, "jq")
-	acctest.SkipIfExeNotOnPath(t, "aws")
-
 	ctx := acctest.Context(t)
 	var v awstypes.Delivery
 	rName := acctest.RandomWithPrefix(t, acctest.ResourcePrefix)
@@ -127,13 +103,7 @@ func testAccDelivery_tags(t *testing.T) {
 		},
 		ErrorCheck:               acctest.ErrorCheck(t, names.LogsServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		ExternalProviders: map[string]resource.ExternalProvider{
-			"null": {
-				Source:            "hashicorp/null",
-				VersionConstraint: "3.2.2",
-			},
-		},
-		CheckDestroy: testAccCheckDeliveryDestroy(ctx, t),
+		CheckDestroy:             testAccCheckDeliveryDestroy(ctx, t),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDeliveryConfig_tags1(rName, acctest.CtKey1, acctest.CtValue1),
@@ -198,10 +168,6 @@ func testAccDelivery_tags(t *testing.T) {
 }
 
 func testAccDelivery_update(t *testing.T) {
-	acctest.SkipIfExeNotOnPath(t, "psql")
-	acctest.SkipIfExeNotOnPath(t, "jq")
-	acctest.SkipIfExeNotOnPath(t, "aws")
-
 	ctx := acctest.Context(t)
 	var v awstypes.Delivery
 	rName := acctest.RandomWithPrefix(t, acctest.ResourcePrefix)
@@ -213,13 +179,7 @@ func testAccDelivery_update(t *testing.T) {
 		},
 		ErrorCheck:               acctest.ErrorCheck(t, names.LogsServiceID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
-		ExternalProviders: map[string]resource.ExternalProvider{
-			"null": {
-				Source:            "hashicorp/null",
-				VersionConstraint: "3.2.2",
-			},
-		},
-		CheckDestroy: testAccCheckDeliveryDestroy(ctx, t),
+		CheckDestroy:             testAccCheckDeliveryDestroy(ctx, t),
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDeliveryConfig_allAttributes(rName, " ", "{region}/{yyyy}/{MM}/"),
diff --git a/website/docs/cdktf/typescript/r/bedrockagent_knowledge_base.html.markdown b/website/docs/cdktf/typescript/r/bedrockagent_knowledge_base.html.markdown
index 6b687c69aae4..94abfffffe29 100644
--- a/website/docs/cdktf/typescript/r/bedrockagent_knowledge_base.html.markdown
+++ b/website/docs/cdktf/typescript/r/bedrockagent_knowledge_base.html.markdown
@@ -144,6 +144,22 @@ class MyConvertedCode extends TerraformStack {
 
 ```
 
+### Kendra Knowledge Base
+
+```hcl
+resource "aws_bedrockagent_knowledge_base" "kendra_example" {
+  name     = "example-kendra-kb"
+  role_arn = aws_iam_role.example.arn
+
+  knowledge_base_configuration {
+    type = "KENDRA"
+    kendra_knowledge_base_configuration {
+      kendra_index_arn = "arn:aws:kendra:us-east-1:123456789012:index/example-index-id"
+    }
+  }
+}
+```
+
 ## Argument Reference
 
 The following arguments are required:
@@ -163,8 +179,9 @@ The following arguments are optional:
 
 The `knowledgeBaseConfiguration` configuration block supports the following arguments:
 
-* `type` - (Required) Type of data that the data source is converted into for the knowledge base. Valid Values: `VECTOR`.
-* `vectorKnowledgeBaseConfiguration` - (Optional) Details about the embeddings model that'sused to convert the data source. See [`vectorKnowledgeBaseConfiguration` block](#vector_knowledge_base_configuration-block) for details.
+* `type` - (Required) Type of data that the data source is converted into for the knowledge base. Valid Values: `VECTOR`, `KENDRA`.
+* `vectorKnowledgeBaseConfiguration` - (Optional) Details about the embeddings model that's used to convert the data source. See [`vectorKnowledgeBaseConfiguration` block](#vector_knowledge_base_configuration-block) for details.
+* `kendraKnowledgeBaseConfiguration` - (Optional) Configuration for Kendra knowledge base. See [`kendraKnowledgeBaseConfiguration` block](#kendra_knowledge_base_configuration-block) for details.
 
 ### `vectorKnowledgeBaseConfiguration` block
 
@@ -206,6 +223,12 @@ The `s3Location` configuration block supports the following arguments:
 
 * `uri` - (Required) URI of the location.
 
+### `kendraKnowledgeBaseConfiguration` block
+
+The `kendraKnowledgeBaseConfiguration` configuration block supports the following arguments:
+
+* `kendraIndexArn` - (Required) ARN of the Amazon Kendra index.
+
 ### `storageConfiguration` block
 
 The `storageConfiguration` configuration block supports the following arguments:
diff --git a/website/docs/r/bedrockagent_knowledge_base.html.markdown b/website/docs/r/bedrockagent_knowledge_base.html.markdown
index d25ab2183c34..4bdc408616cc 100644
--- a/website/docs/r/bedrockagent_knowledge_base.html.markdown
+++ b/website/docs/r/bedrockagent_knowledge_base.html.markdown
@@ -39,6 +39,93 @@ resource "aws_bedrockagent_knowledge_base" "example" {
 }
 ```
 
+### Kendra Knowledge Base
+
+```hcl
+resource "aws_bedrockagent_knowledge_base" "kendra_example" {
+  name     = "example-kendra-kb"
+  role_arn = aws_iam_role.example.arn
+
+  knowledge_base_configuration {
+    type = "KENDRA"
+    kendra_knowledge_base_configuration {
+      kendra_index_arn = "arn:aws:kendra:us-east-1:123456789012:index/example-index-id"
+    }
+  }
+}
+```
+
+### Structured Data Store
+
+```hcl
+resource "aws_bedrockagent_knowledge_base" "example" {
+  name     = "example-kb"
+  role_arn = aws_iam_role.example.arn
+
+  knowledge_base_configuration {
+    type = "SQL"
+
+    sql_knowledge_base_configuration {
+      type = "REDSHIFT"
+
+      redshift_configuration {
+        query_engine_configuration {
+          type = "PROVISIONED"
+
+          provisioned_configuration {
+            cluster_identifier = aws_redshift_cluster.example.cluster_identifier
+
+            auth_configuration {
+              type          = "USERNAME"
+              database_user = aws_redshift_cluster.example.master_username
+            }
+          }
+        }
+
+        storage_configuration {
+          type = "REDSHIFT"
+
+          redshift_configuration {
+            database_name = aws_redshift_cluster.example.database_name
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+### OpenSearch Managed Cluster Configuration
+
+```terraform
+resource "aws_bedrockagent_knowledge_base" "example" {
+  name     = "example"
+  role_arn = aws_iam_role.example.arn
+
+  knowledge_base_configuration {
+    vector_knowledge_base_configuration {
+      embedding_model_arn = "arn:aws:bedrock:us-west-2::foundation-model/amazon.titan-embed-text-v2:0"
+    }
+    type = "VECTOR"
+  }
+
+  storage_configuration {
+    type = "OPENSEARCH_MANAGED_CLUSTER"
+    opensearch_managed_cluster_configuration {
+      domain_arn        = "arn:aws:es:us-west-2:123456789012:domain/example-domain"
+      domain_endpoint   = "https://search-example-domain.us-west-2.es.amazonaws.com"
+      vector_index_name = "example_index"
+
+      field_mapping {
+        metadata_field = "metadata"
+        text_field     = "chunks"
+        vector_field   = "embedding"
+      }
+    }
+  }
+}
+```
+
 ### With Supplemental Data Storage Configuration
 
 ```terraform
@@ -68,6 +155,7 @@ resource "aws_bedrockagent_knowledge_base" "example" {
     }
     type = "VECTOR"
   }
+
   storage_configuration {
     type = "OPENSEARCH_SERVERLESS"
     opensearch_serverless_configuration {
@@ -83,6 +171,48 @@ resource "aws_bedrockagent_knowledge_base" "example" {
 }
 ```
 
+### S3 Vectors Configuration
+
+```terraform
+resource "aws_s3vectors_vector_bucket" "example" {
+  vector_bucket_name = "example-bucket"
+}
+
+resource "aws_s3vectors_index" "example" {
+  index_name         = "example-index"
+  vector_bucket_name = aws_s3vectors_vector_bucket.example.vector_bucket_name
+
+  data_type       = "float32"
+  dimension       = 256
+  distance_metric = "euclidean"
+}
+
+resource "aws_bedrockagent_knowledge_base" "example" {
+  name     = "example-s3vectors-kb"
+  role_arn = aws_iam_role.example.arn
+
+  knowledge_base_configuration {
+    vector_knowledge_base_configuration {
+      embedding_model_arn = "arn:aws:bedrock:us-west-2::foundation-model/amazon.titan-embed-text-v2:0"
+      embedding_model_configuration {
+        bedrock_embedding_model_configuration {
+          dimensions          = 256
+          embedding_data_type = "FLOAT32"
+        }
+      }
+    }
+    type = "VECTOR"
+  }
+
+  storage_configuration {
+    type = "S3_VECTORS"
+    s3_vectors_configuration {
+      index_arn = aws_s3vectors_index.example.index_arn
+    }
+  }
+}
+```
+
 ## Argument Reference
 
 The following arguments are required:
@@ -90,20 +220,138 @@ The following arguments are required:
 * `knowledge_base_configuration` - (Required, Forces new resource) Details about the embeddings configuration of the knowledge base. See [`knowledge_base_configuration` block](#knowledge_base_configuration-block) for details.
 * `name` - (Required) Name of the knowledge base.
 * `role_arn` - (Required) ARN of the IAM role with permissions to invoke API operations on the knowledge base.
-* `storage_configuration` - (Required, Forces new resource) Details about the storage configuration of the knowledge base. See [`storage_configuration` block](#storage_configuration-block) for details.
 
 The following arguments are optional:
 
-* `region` - (Optional) Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the [provider configuration](https://registry.terraform.io/providers/hashicorp/aws/latest/docs#aws-configuration-reference).
 * `description` - (Optional) Description of the knowledge base.
+* `region` - (Optional) Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the [provider configuration](https://registry.terraform.io/providers/hashicorp/aws/latest/docs#aws-configuration-reference).
+* `storage_configuration` - (Optional, Forces new resource) Details about the storage configuration of the knowledge base. See [`storage_configuration` block](#storage_configuration-block) for details.
 * `tags` - (Optional) Map of tags assigned to the resource. If configured with a provider [`default_tags` configuration block](/docs/providers/aws/index.html#default_tags-configuration-block) present, tags with matching keys will overwrite those defined at the provider-level.
 
 ### `knowledge_base_configuration` block
 
 The `knowledge_base_configuration` configuration block supports the following arguments:
 
-* `type` - (Required) Type of data that the data source is converted into for the knowledge base. Valid Values: `VECTOR`.
-* `vector_knowledge_base_configuration` - (Optional) Details about the embeddings model that'sused to convert the data source. See [`vector_knowledge_base_configuration` block](#vector_knowledge_base_configuration-block) for details.
+* `type` - (Required) Type of data that the data source is converted into for the knowledge base. Valid Values: `VECTOR`, `KENDRA`, `SQL`.
+* `kendra_knowledge_base_configuration` - (Optional) Settings for an Amazon Kendra knowledge base. See [`kendra_knowledge_base_configuration` block](#kendra_knowledge_base_configuration-block) for details.
+* `sql_knowledge_base_configuration` - (Optional) Configurations for a knowledge base connected to an SQL database. See [`sql_knowledge_base_configuration` block](#sql_knowledge_base_configuration-block) for details.
+* `vector_knowledge_base_configuration` - (Optional) Details about the model that's used to convert the data source into vector embeddings. See [`vector_knowledge_base_configuration` block](#vector_knowledge_base_configuration-block) for details.
+
+### `kendra_knowledge_base_configuration` block
+
+The `kendra_knowledge_base_configuration` configuration block supports the following arguments:
+
+* `kendra_index_arn` - (Required) ARN of the Amazon Kendra index.
+
+### `sql_knowledge_base_configuration` block
+
+The `sql_knowledge_base_configuration` configuration block supports the following arguments:
+
+* `redshift_configuration` - (Optional) Configurations for a knowledge base connected to an Amazon Redshift database. See [`redshift_configuration` block](#knowledge-base-redshift_configuration-block) for details.
+* `type` - (Required) Type of SQL database to connect to the knowledge base. Valid values: `REDSHIFT`.
+
+### Knowledge Base `redshift_configuration` block
+
+The `redshift_configuration` configuration block supports the following arguments:
+
+* `query_engine_configuration` - (Required) Configurations for an Amazon Redshift query engine. See [`query_engine_configuration` block](#query_engine_configuration-block) for details.
+* `query_generation_configuration` - (Optional) Configurations for generating queries. See [`query_generation_configuration` block](#query_generation_configuration-block) for details.
+* `storage_configuration` - (Required) Configurations for Amazon Redshift database storage. See [`storage_configuration` block](#redshift-storage_configuration-block) for details.
+
+### `query_engine_configuration` block
+
+The `query_engine_configuration` configuration block supports the following arguments:
+
+* `provisioned_configuration` - (Optional) Configurations for a provisioned Amazon Redshift query engine. See [`provisioned_configuration` block](#provisioned_configuration-block) for details.
+* `serverless_configuration` - (Optional) Configurations for a serverless Amazon Redshift query engine. See [`serverless_configuration` block](#serverless_configuration-block) for details.
+* `type` - (Required) Type of query engine. Valid values: `SERVERLESS`, `PROVISIONED`.
+
+### `provisioned_configuration` block
+
+The `provisioned_configuration` configuration block supports the following arguments:
+
+* `auth_configuration` - (Required) Configurations for authentication to Amazon Redshift. See [`auth_configuration` block](#provisioned-auth_configuration-block) for details.
+* `cluster_identifier` - (Required) ID of the Amazon Redshift cluster.
+
+### Provisioned `auth_configuration` block
+
+The `auth_configuration` configuration block supports the following arguments:
+
+* `database_user` - (Optional) Database username for authentication to an Amazon Redshift provisioned data warehouse.
+* `type` - (Required) Type of authentication to use. Valid values: `IAM`, `USERNAME_PASSWORD`, ``USERNAME`.
+* `username_password_secret_arn` - (Optional) ARN of a Secrets Manager secret for authentication.
+
+### `serverless_configuration` block
+
+The `serverless_configuration` configuration block supports the following arguments:
+
+* `auth_configuration` - (Required) Configurations for authentication to a Redshift Serverless. See [`auth_configuration` block](#serverless-auth_configuration-block) for details.
+* `workgroup_arn` - (Required) ARN of the Amazon Redshift workgroup.
+
+### Serverless `auth_configuration` block
+
+The `auth_configuration` configuration block supports the following arguments:
+
+* `type` - (Required) Type of authentication to use. Valid values: `IAM`, `USERNAME_PASSWORD`.
+* `username_password_secret_arn` - (Optional) ARN of a Secrets Manager secret for authentication.
+
+### `query_generation_configuration` block
+
+The `query_generation_configuration` configuration block supports the following arguments:
+
+* `execution_timeout_seconds` - (Optional) Time after which query generation will time out.
+* `generation_context` - (Optional) Configurations for context to use during query generation. See [`generation_context` block](#generation_context-block) for details.
+
+### `generation_context` block
+
+The `generation_context` configuration block supports the following arguments:
+
+* `curated_query` - (Optional) Information about example queries to help the query engine generate appropriate SQL queries. See [`curated_query` block](#curated_query-block) for details.
+* `table` - (Optional) Information about a table in the database. See [`table` block](#table-block) for details.
+
+### `curated_query` block
+
+The `curated_query` configuration block supports the following arguments:
+
+* `natural_language` - (Required) Example natural language query.
+* `sql` - (Required) SQL equivalent of `natural_language`.
+
+### `table` block
+
+The `table` configuration block supports the following arguments:
+
+* `column` - (Optional) Information about a column in the table. See [`column` block](#column-block) for details.
+* `description` - (Optional) Description of the table that helps the query engine understand the contents of the table.
+* `inclusion` - (Optional) Whether to include or exclude the table during query generation. Valid values `INCLUDE`, `EXCLUDE`.
+* `name` - (Required) Name of the table for which the other fields in this object apply.
+
+### `column` block
+
+The `column` configuration block supports the following arguments:
+
+* `description` - (Optional) Description of the column that helps the query engine understand the contents of the column.
+* `inclusion` - (Optional) Whether to include or exclude the column during query generation. Valid values `INCLUDE`, `EXCLUDE`.
+* `name` - (Required) Name of the column for which the other fields in this object apply.
+
+### Redshift `storage_configuration` block
+
+The `storage_configuration` configuration block supports the following arguments:
+
+* `aws_data_catalog_configuration` - (Optional) Configurations for storage in AWS Glue Data Catalog. See [`aws_data_catalog_configuration` block](#aws_data_catalog_configuration-block) for details.
+* `redshift_configuration` - (Optional) Configurations for storage in Amazon Redshift. See [`redshift_configuration` block](#storage-redshift_configuration-block) for details.
+* `type` - (Required) Data storage service to use. Valid values: `REDSHIFT`, `AWS_DATA_CATALOG`.
+
+### `aws_data_catalog_configuration` block
+
+The `aws_data_catalog_configuration` configuration block supports the following arguments:
+
+* `table_names` - (Required) List of names of the tables to use.
+
+### Storage `redshift_configuration` block
+
+The `redshift_configuration` configuration block supports the following arguments:
+
+* `database_name` - (Required) Name of the Amazon Redshift database.
 
 ### `vector_knowledge_base_configuration` block
 
@@ -149,11 +397,52 @@ The `s3_location` configuration block supports the following arguments:
 
 The `storage_configuration` configuration block supports the following arguments:
 
-* `type` - (Required) Vector store service in which the knowledge base is stored. Valid Values: `OPENSEARCH_SERVERLESS`, `PINECONE`, `REDIS_ENTERPRISE_CLOUD`, `RDS`.
-* `opensearch_serverless_configuration` - (Optional) The storage configuration of the knowledge base in Amazon OpenSearch Service. See [`opensearch_serverless_configuration` block](#opensearch_serverless_configuration-block) for details.
+* `type` - (Required) Vector store service in which the knowledge base is stored. Valid Values: `MONGO_DB_ATLAS`, `OPENSEARCH_SERVERLESS`, `OPENSEARCH_MANAGED_CLUSTER`, `PINECONE`, `REDIS_ENTERPRISE_CLOUD`, `RDS`, `S3_VECTORS`, `NEPTUNE_ANALYTICS`.
+* `mongo_db_atlas_configuration` – (Optional) The storage configuration of the knowledge base in MongoDB Atlas. See [`mongo_db_atlas_configuration` block](#mongo_db_atlas_configuration-block) for details.
+* `neptune_analytics_configuration` – (Optional) The storage configuration of the knowledge base in Amazon Neptune Analytics. See [`neptune_analytics_configuration` block](#neptune_analytics_configuration-block) for details.
+* `opensearch_managed_cluster_configuration` - (Optional) The storage configuration of the knowledge base in Amazon OpenSearch Service Managed Cluster. See [`opensearch_managed_cluster_configuration` block](#opensearch_managed_cluster_configuration-block) for details.
+* `opensearch_serverless_configuration` - (Optional) The storage configuration of the knowledge base in Amazon OpenSearch Service Serverless. See [`opensearch_serverless_configuration` block](#opensearch_serverless_configuration-block) for details.
 * `pinecone_configuration` - (Optional)  The storage configuration of the knowledge base in Pinecone. See [`pinecone_configuration` block](#pinecone_configuration-block) for details.
 * `rds_configuration` - (Optional) Details about the storage configuration of the knowledge base in Amazon RDS. For more information, see [Create a vector index in Amazon RDS](https://docs.aws.amazon.com/bedrock/latest/userguide/knowledge-base-setup.html). See [`rds_configuration` block](#rds_configuration-block) for details.
 * `redis_enterprise_cloud_configuration` - (Optional) The storage configuration of the knowledge base in Redis Enterprise Cloud. See [`redis_enterprise_cloud_configuration` block](#redis_enterprise_cloud_configuration-block) for details.
+* `s3_vectors_configuration` - (Optional) The storage configuration of the knowledge base in Amazon S3 Vectors. See [`s3_vectors_configuration` block](#s3_vectors_configuration-block) for details.
+
+### `mongo_db_atlas_configuration` block
+
+The `mongo_db_atlas_configuration` configuration block supports the following arguments:
+
+* `collection_name` – (Required) The name of the collection in the MongoDB Atlas database.
+* `credentials_secret_arn` – (Required) The ARN of the secret that you created in AWS Secrets Manager that is linked to your MongoDB Atlas database.
+* `database_name` – (Required) The name of the database in the MongoDB Atlas database.
+* `endpoint` – (Required) The endpoint URL of the MongoDB Atlas database.
+* `field_mapping` – (Required) Contains the names of the fields to which to map information about the vector store.
+    * `metadata_field` – (Required) The name of the field in which Amazon Bedrock stores metadata about the vector store.
+    * `text_field` – (Required) The name of the field in which Amazon Bedrock stores the raw text from your data. The text is split according to the chunking strategy you choose.
+    * `vector_field` – (Required) The name of the field in which Amazon Bedrock stores the vector embeddings for your data sources.
+* `vector_index_name` – (Required) The name of the vector index.
+* `endpoint_service_name` – (Optional) The name of the service that hosts the MongoDB Atlas database.
+* `text_index_name` – (Optional) The name of the vector index.
+
+### `neptune_analytics_configuration` block
+
+The `neptune_analytics_configuration` configuration block supports the following arguments:
+
+* `field_mapping` - (Required) The names of the fields to which to map information about the vector store. This block supports the following arguments:
+    * `metadata_field` - (Required) Name of the field in which Amazon Bedrock stores metadata about the vector store.
+    * `text_field` - (Required) Name of the field in which Amazon Bedrock stores the raw text from your data. The text is split according to the chunking strategy you choose.
+* `graph_arn` - (Required) ARN of the Neptune Analytics vector store.
+
+### `opensearch_managed_cluster_configuration` block
+
+The `opensearch_managed_cluster_configuration` configuration block supports the following arguments:
+
+* `domain_arn` - (Required) ARN of the OpenSearch domain.
+* `domain_endpoint` - (Required) Endpoint URL of the OpenSearch domain.
+* `field_mapping` - (Required) The names of the fields to which to map information about the vector store. This block supports the following arguments:
+    * `metadata_field` - (Required) Name of the field in which Amazon Bedrock stores metadata about the vector store.
+    * `text_field` - (Required) Name of the field in which Amazon Bedrock stores the raw text from your data. The text is split according to the chunking strategy you choose.
+    * `vector_field` - (Required) Name of the field in which Amazon Bedrock stores the vector embeddings for your data sources.
+* `vector_index_name` - (Required) Name of the vector store.
 
 ### `opensearch_serverless_configuration` block
 
@@ -204,6 +493,15 @@ The `redis_enterprise_cloud_configuration` configuration block supports the foll
     * `vector_field` - (Required) Name of the field in which Amazon Bedrock stores the vector embeddings for your data sources.
 * `vector_index_name` - (Required) Name of the vector index.
 
+### `s3_vectors_configuration` block
+
+The `s3_vectors_configuration` configuration block supports the following arguments.
+Either `index_arn`, or both `index_name` and `vector_bucket_arn` must be specified.
+
+* `index_arn` - (Optional) ARN of the S3 Vectors index. Conflicts with `index_name` and `vector_bucket_arn`.
+* `index_name` - (Optional) Name of the S3 Vectors index. Must be specified with `vector_bucket_arn`. Conflicts with `index_arn`.
+* `vector_bucket_arn` - (Optional) ARN of the S3 Vectors vector bucket. Must be specified with `index_name`. Conflicts with `index_arn`.
+
 ## Attribute Reference
 
 This resource exports the following attributes in addition to the arguments above: