appmod-catalog-blueprints 1.6.1__py3-none-any.whl → 1.7.1__py3-none-any.whl

appmod_catalog_blueprints/__init__.py

@@ -417,6 +417,80 @@ class AccessLogProps:
         )
 
 
+@jsii.data_type(
+    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.AclConfiguration",
+    jsii_struct_bases=[],
+    name_mapping={"enabled": "enabled", "metadata_field": "metadataField"},
+)
+class AclConfiguration:
+    def __init__(
+        self,
+        *,
+        enabled: builtins.bool,
+        metadata_field: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''(experimental) Configuration for Access Control List (ACL) based filtering.
+
+        When enabled, retrieval queries will be filtered based on user identity
+        context, ensuring users only retrieve documents they have permission to access.
+
+        :param enabled: (experimental) Enable ACL-based filtering for retrieval queries. When true, the retrieval tool will require user context and apply metadata filters based on user permissions. Default: false
+        :param metadata_field: (experimental) Metadata field containing access permissions. This field in the document metadata should contain the group or permission identifier that controls access. The retrieval tool will filter results where this field matches the user's permissions. Default: 'group'
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__899807b7dca2d7be5f310df5984cd7a0c5fe3c612a8995f0927c15acbec703da)
+            check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
+            check_type(argname="argument metadata_field", value=metadata_field, expected_type=type_hints["metadata_field"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "enabled": enabled,
+        }
+        if metadata_field is not None:
+            self._values["metadata_field"] = metadata_field
+
+    @builtins.property
+    def enabled(self) -> builtins.bool:
+        '''(experimental) Enable ACL-based filtering for retrieval queries.
+
+        When true, the retrieval tool will require user context and apply
+        metadata filters based on user permissions.
+
+        :default: false
+
+        :stability: experimental
+        '''
+        result = self._values.get("enabled")
+        assert result is not None, "Required property 'enabled' is missing"
+        return typing.cast(builtins.bool, result)
+
+    @builtins.property
+    def metadata_field(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Metadata field containing access permissions.
+
+        This field in the document metadata should contain the group or
+        permission identifier that controls access. The retrieval tool
+        will filter results where this field matches the user's permissions.
+
+        :default: 'group'
+
+        :stability: experimental
+        '''
+        result = self._values.get("metadata_field")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "AclConfiguration(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.data_type(
     jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.AdditionalDistributionProps",
     jsii_struct_bases=[],
@@ -517,7 +591,9 @@ class AdditionalDistributionProps:
     name_mapping={
         "bedrock_model": "bedrockModel",
         "system_prompt": "systemPrompt",
+        "additional_policy_statements_for_knowledge_bases": "additionalPolicyStatementsForKnowledgeBases",
         "additional_policy_statements_for_tools": "additionalPolicyStatementsForTools",
+        "knowledge_bases": "knowledgeBases",
         "lambda_layers": "lambdaLayers",
         "tools": "tools",
     },
@@ -528,7 +604,9 @@ class AgentDefinitionProps:
         *,
         bedrock_model: typing.Union["BedrockModelProps", typing.Dict[builtins.str, typing.Any]],
         system_prompt: "_aws_cdk_aws_s3_assets_ceddda9d.Asset",
+        additional_policy_statements_for_knowledge_bases: typing.Optional[typing.Sequence["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]] = None,
         additional_policy_statements_for_tools: typing.Optional[typing.Sequence["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]] = None,
+        knowledge_bases: typing.Optional[typing.Sequence["IKnowledgeBase"]] = None,
         lambda_layers: typing.Optional[typing.Sequence["_aws_cdk_aws_lambda_ceddda9d.LayerVersion"]] = None,
         tools: typing.Optional[typing.Sequence["_aws_cdk_aws_s3_assets_ceddda9d.Asset"]] = None,
     ) -> None:
@@ -536,7 +614,9 @@ class AgentDefinitionProps:
 
         :param bedrock_model: (experimental) Configuration for the Bedrock Model to be used.
         :param system_prompt: (experimental) The system prompt of the agent.
+        :param additional_policy_statements_for_knowledge_bases: (experimental) Additional IAM policy statements for knowledge base access. Use this when knowledge bases require permissions beyond what is automatically generated by the IKnowledgeBase implementations. These statements will be added to the agent's IAM role in addition to the auto-generated permissions. Default: - Only auto-generated permissions from knowledge bases
         :param additional_policy_statements_for_tools: (experimental) If tools need additional IAM permissions, these statements would be attached to the Agent's IAM role.
+        :param knowledge_bases: (experimental) Knowledge bases available to the agent for Retrieval-Augmented Generation (RAG). When configured, the agent will have access to a built-in retrieval tool that can query these knowledge bases. The agent's system prompt will be automatically augmented with information about available knowledge bases. Each knowledge base must implement the IKnowledgeBase interface, which handles IAM permission generation and runtime configuration. Default: - No knowledge bases configured
         :param lambda_layers: (experimental) Any dependencies needed by the provided tools.
         :param tools: (experimental) List of tools defined in python files. This tools would automatically be loaded by the agent. You can also use this to incorporate other specialized agents as tools.
 
@@ -548,15 +628,21 @@ class AgentDefinitionProps:
             type_hints = typing.get_type_hints(_typecheckingstub__4a2d1deab0cc9bf96473ffb32138a2c564c47ae7382fe5d2d1f0e43da3324272)
             check_type(argname="argument bedrock_model", value=bedrock_model, expected_type=type_hints["bedrock_model"])
             check_type(argname="argument system_prompt", value=system_prompt, expected_type=type_hints["system_prompt"])
+            check_type(argname="argument additional_policy_statements_for_knowledge_bases", value=additional_policy_statements_for_knowledge_bases, expected_type=type_hints["additional_policy_statements_for_knowledge_bases"])
             check_type(argname="argument additional_policy_statements_for_tools", value=additional_policy_statements_for_tools, expected_type=type_hints["additional_policy_statements_for_tools"])
+            check_type(argname="argument knowledge_bases", value=knowledge_bases, expected_type=type_hints["knowledge_bases"])
             check_type(argname="argument lambda_layers", value=lambda_layers, expected_type=type_hints["lambda_layers"])
             check_type(argname="argument tools", value=tools, expected_type=type_hints["tools"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "bedrock_model": bedrock_model,
             "system_prompt": system_prompt,
         }
+        if additional_policy_statements_for_knowledge_bases is not None:
+            self._values["additional_policy_statements_for_knowledge_bases"] = additional_policy_statements_for_knowledge_bases
         if additional_policy_statements_for_tools is not None:
             self._values["additional_policy_statements_for_tools"] = additional_policy_statements_for_tools
+        if knowledge_bases is not None:
+            self._values["knowledge_bases"] = knowledge_bases
         if lambda_layers is not None:
             self._values["lambda_layers"] = lambda_layers
         if tools is not None:
@@ -582,6 +668,24 @@ class AgentDefinitionProps:
         assert result is not None, "Required property 'system_prompt' is missing"
         return typing.cast("_aws_cdk_aws_s3_assets_ceddda9d.Asset", result)
 
+    @builtins.property
+    def additional_policy_statements_for_knowledge_bases(
+        self,
+    ) -> typing.Optional[typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]]:
+        '''(experimental) Additional IAM policy statements for knowledge base access.
+
+        Use this when knowledge bases require permissions beyond what is
+        automatically generated by the IKnowledgeBase implementations.
+        These statements will be added to the agent's IAM role in addition
+        to the auto-generated permissions.
+
+        :default: - Only auto-generated permissions from knowledge bases
+
+        :stability: experimental
+        '''
+        result = self._values.get("additional_policy_statements_for_knowledge_bases")
+        return typing.cast(typing.Optional[typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]], result)
+
     @builtins.property
     def additional_policy_statements_for_tools(
         self,
@@ -593,6 +697,24 @@ class AgentDefinitionProps:
         result = self._values.get("additional_policy_statements_for_tools")
         return typing.cast(typing.Optional[typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]], result)
 
+    @builtins.property
+    def knowledge_bases(self) -> typing.Optional[typing.List["IKnowledgeBase"]]:
+        '''(experimental) Knowledge bases available to the agent for Retrieval-Augmented Generation (RAG).
+
+        When configured, the agent will have access to a built-in retrieval tool
+        that can query these knowledge bases. The agent's system prompt will be
+        automatically augmented with information about available knowledge bases.
+
+        Each knowledge base must implement the IKnowledgeBase interface, which
+        handles IAM permission generation and runtime configuration.
+
+        :default: - No knowledge bases configured
+
+        :stability: experimental
+        '''
+        result = self._values.get("knowledge_bases")
+        return typing.cast(typing.Optional[typing.List["IKnowledgeBase"]], result)
+
     @builtins.property
     def lambda_layers(
         self,
@@ -1029,6 +1151,34 @@ class BaseAgent(
         '''
         return typing.cast("_aws_cdk_aws_kms_ceddda9d.Key", jsii.get(self, "encryptionKey"))
 
+    @builtins.property
+    @jsii.member(jsii_name="knowledgeBaseConfigs")
+    def _knowledge_base_configs(self) -> typing.List["KnowledgeBaseRuntimeConfig"]:
+        '''(experimental) Knowledge base configurations for runtime use.
+
+        This array contains the exported configurations from all configured
+        knowledge bases. Subclasses use this to set the KNOWLEDGE_BASES_CONFIG
+        environment variable on the agent Lambda function.
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.List["KnowledgeBaseRuntimeConfig"], jsii.get(self, "knowledgeBaseConfigs"))
+
+    @builtins.property
+    @jsii.member(jsii_name="knowledgeBaseLayers")
+    def _knowledge_base_layers(
+        self,
+    ) -> typing.List["_aws_cdk_aws_lambda_ceddda9d.LayerVersion"]:
+        '''(experimental) Lambda layers required by knowledge base retrieval tools.
+
+        This array contains Lambda layers from all configured knowledge bases.
+        Subclasses should add these layers to the agent Lambda function to
+        ensure retrieval tools have access to required dependencies.
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.List["_aws_cdk_aws_lambda_ceddda9d.LayerVersion"], jsii.get(self, "knowledgeBaseLayers"))
+
     @builtins.property
     @jsii.member(jsii_name="logGroupDataProtection")
     def _log_group_data_protection(self) -> "LogGroupDataProtectionProps":
@@ -1046,6 +1196,20 @@ class BaseAgent(
         '''
         return typing.cast(typing.Optional["BedrockModelProps"], jsii.get(self, "bedrockModel"))
 
+    @builtins.property
+    @jsii.member(jsii_name="knowledgeBaseToolAsset")
+    def _knowledge_base_tool_asset(
+        self,
+    ) -> typing.Optional["_aws_cdk_aws_s3_assets_ceddda9d.Asset"]:
+        '''(experimental) Asset containing the knowledge base retrieval tool.
+
+        This is automatically created when knowledge bases are configured.
+        The asset is added to the agent's tools and granted read access.
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional["_aws_cdk_aws_s3_assets_ceddda9d.Asset"], jsii.get(self, "knowledgeBaseToolAsset"))
+
 
 class _BaseAgentProxy(BaseAgent):
     @builtins.property
@@ -1062,6 +1226,132 @@ class _BaseAgentProxy(BaseAgent):
 typing.cast(typing.Any, BaseAgent).__jsii_proxy_class__ = lambda : _BaseAgentProxy
 
 
+@jsii.data_type(
+    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.BaseKnowledgeBaseProps",
+    jsii_struct_bases=[],
+    name_mapping={
+        "description": "description",
+        "name": "name",
+        "acl": "acl",
+        "retrieval": "retrieval",
+    },
+)
+class BaseKnowledgeBaseProps:
+    def __init__(
+        self,
+        *,
+        description: builtins.str,
+        name: builtins.str,
+        acl: typing.Optional[typing.Union["AclConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
+        retrieval: typing.Optional[typing.Union["RetrievalConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
+    ) -> None:
+        '''(experimental) Base configuration for all knowledge base implementations.
+
+        This interface defines the common properties shared by all knowledge
+        base types. Specific implementations (like BedrockKnowledgeBase) extend
+        this with additional properties.
+
+        :param description: (experimental) Description of what this knowledge base contains and when to use it. This description is shown to the agent in its system prompt to help it decide when to query this knowledge base. Be specific about the type of information contained and appropriate use cases.
+        :param name: (experimental) Human-readable name/identifier for this knowledge base. Used for logging, display purposes, and to help the agent identify which knowledge base to query. Should be unique within the set of knowledge bases configured for an agent.
+        :param acl: (experimental) Access control configuration for identity-aware retrieval. When enabled, retrieval queries will be filtered based on user identity context to ensure users only access permitted documents. Default: - ACL disabled
+        :param retrieval: (experimental) Retrieval configuration options. Controls the number of results returned and optional metadata filtering. Default: { numberOfResults: 5 }
+
+        :stability: experimental
+        '''
+        if isinstance(acl, dict):
+            acl = AclConfiguration(**acl)
+        if isinstance(retrieval, dict):
+            retrieval = RetrievalConfiguration(**retrieval)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__40fa4a59f1a0502756f07aba8d6cba5255e1743cbc160af92ff68cb3b17fef23)
+            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
+            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+            check_type(argname="argument acl", value=acl, expected_type=type_hints["acl"])
+            check_type(argname="argument retrieval", value=retrieval, expected_type=type_hints["retrieval"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "description": description,
+            "name": name,
+        }
+        if acl is not None:
+            self._values["acl"] = acl
+        if retrieval is not None:
+            self._values["retrieval"] = retrieval
+
+    @builtins.property
+    def description(self) -> builtins.str:
+        '''(experimental) Description of what this knowledge base contains and when to use it.
+
+        This description is shown to the agent in its system prompt to help
+        it decide when to query this knowledge base. Be specific about the
+        type of information contained and appropriate use cases.
+
+        :stability: experimental
+
+        Example::
+
+            'Contains product documentation, user guides, and FAQs. Use when answering questions about product features or troubleshooting.'
+        '''
+        result = self._values.get("description")
+        assert result is not None, "Required property 'description' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def name(self) -> builtins.str:
+        '''(experimental) Human-readable name/identifier for this knowledge base.
+
+        Used for logging, display purposes, and to help the agent identify
+        which knowledge base to query. Should be unique within the set of
+        knowledge bases configured for an agent.
+
+        :stability: experimental
+
+        Example::
+
+            'product-documentation'
+        '''
+        result = self._values.get("name")
+        assert result is not None, "Required property 'name' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def acl(self) -> typing.Optional["AclConfiguration"]:
+        '''(experimental) Access control configuration for identity-aware retrieval.
+
+        When enabled, retrieval queries will be filtered based on user
+        identity context to ensure users only access permitted documents.
+
+        :default: - ACL disabled
+
+        :stability: experimental
+        '''
+        result = self._values.get("acl")
+        return typing.cast(typing.Optional["AclConfiguration"], result)
+
+    @builtins.property
+    def retrieval(self) -> typing.Optional["RetrievalConfiguration"]:
+        '''(experimental) Retrieval configuration options.
+
+        Controls the number of results returned and optional metadata filtering.
+
+        :default: { numberOfResults: 5 }
+
+        :stability: experimental
+        '''
+        result = self._values.get("retrieval")
+        return typing.cast(typing.Optional["RetrievalConfiguration"], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "BaseKnowledgeBaseProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 class BatchAgent(
     BaseAgent,
     metaclass=jsii.JSIIMeta,
@@ -1078,6 +1368,7 @@ class BatchAgent(
         *,
         prompt: builtins.str,
         expect_json: typing.Optional[builtins.bool] = None,
+        invoke_type: typing.Optional["InvokeType"] = None,
         agent_definition: typing.Union["AgentDefinitionProps", typing.Dict[builtins.str, typing.Any]],
         agent_name: builtins.str,
         enable_observability: typing.Optional[builtins.bool] = None,
@@ -1093,6 +1384,7 @@ class BatchAgent(
         :param id: -
         :param prompt: 
         :param expect_json: 
+        :param invoke_type: (experimental) Agent invocation type. Defines how the agent is invoked and what processing mode to use. Default: InvokeType.BATCH
         :param agent_definition: (experimental) Agent related parameters.
         :param agent_name: (experimental) Name of the agent.
         :param enable_observability: (experimental) Enable observability. Default: false
@@ -1112,6 +1404,7 @@ class BatchAgent(
         props = BatchAgentProps(
             prompt=prompt,
             expect_json=expect_json,
+            invoke_type=invoke_type,
             agent_definition=agent_definition,
             agent_name=agent_name,
             enable_observability=enable_observability,
@@ -1159,6 +1452,243 @@ class BedrockCrossRegionInferencePrefix(enum.Enum):
     '''
 
 
+@jsii.data_type(
+    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.BedrockKnowledgeBaseProps",
+    jsii_struct_bases=[BaseKnowledgeBaseProps],
+    name_mapping={
+        "description": "description",
+        "name": "name",
+        "acl": "acl",
+        "retrieval": "retrieval",
+        "knowledge_base_id": "knowledgeBaseId",
+        "create": "create",
+        "guardrail": "guardrail",
+        "knowledge_base_arn": "knowledgeBaseArn",
+        "vector_store": "vectorStore",
+    },
+)
+class BedrockKnowledgeBaseProps(BaseKnowledgeBaseProps):
+    def __init__(
+        self,
+        *,
+        description: builtins.str,
+        name: builtins.str,
+        acl: typing.Optional[typing.Union["AclConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
+        retrieval: typing.Optional[typing.Union["RetrievalConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
+        knowledge_base_id: builtins.str,
+        create: typing.Optional[typing.Union["CreateKnowledgeBaseConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
+        guardrail: typing.Optional[typing.Union["GuardrailConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
+        knowledge_base_arn: typing.Optional[builtins.str] = None,
+        vector_store: typing.Optional[typing.Union["VectorStoreConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
+    ) -> None:
+        '''(experimental) Configuration for Amazon Bedrock Knowledge Base.
+
+        This interface extends the base configuration with Bedrock-specific
+        properties for connecting to an existing Bedrock Knowledge Base.
+
+        :param description: (experimental) Description of what this knowledge base contains and when to use it. This description is shown to the agent in its system prompt to help it decide when to query this knowledge base. Be specific about the type of information contained and appropriate use cases.
+        :param name: (experimental) Human-readable name/identifier for this knowledge base. Used for logging, display purposes, and to help the agent identify which knowledge base to query. Should be unique within the set of knowledge bases configured for an agent.
+        :param acl: (experimental) Access control configuration for identity-aware retrieval. When enabled, retrieval queries will be filtered based on user identity context to ensure users only access permitted documents. Default: - ACL disabled
+        :param retrieval: (experimental) Retrieval configuration options. Controls the number of results returned and optional metadata filtering. Default: { numberOfResults: 5 }
+        :param knowledge_base_id: (experimental) Unique identifier for the Bedrock Knowledge Base. This is the ID assigned by Bedrock when the knowledge base was created. You can find this in the Bedrock console or via the AWS CLI. Required when referencing an existing knowledge base. Not required when using the ``create`` property to create a new KB.
+        :param create: (experimental) Configuration for creating a new knowledge base. When provided, a new Bedrock Knowledge Base will be created with the specified data source and embedding configuration. Note: This is an advanced feature that creates AWS resources. For most use cases, referencing an existing knowledge base by ID is recommended. Default: - Reference existing KB only (no creation)
+        :param guardrail: (experimental) Guardrail configuration for content filtering. When configured, the guardrail will be applied during retrieval operations to filter inappropriate or sensitive content. Default: - No guardrail applied
+        :param knowledge_base_arn: (experimental) ARN of the Bedrock Knowledge Base. If not provided, the ARN will be constructed from the knowledgeBaseId using the current region and account. Default: - Constructed from knowledgeBaseId
+        :param vector_store: (experimental) Vector store configuration. Defines the type of vector store used by this knowledge base. This is informational and used for generating appropriate IAM permissions when needed. Default: - S3 Vectors (type: 's3-vectors')
+
+        :stability: experimental
+        '''
+        if isinstance(acl, dict):
+            acl = AclConfiguration(**acl)
+        if isinstance(retrieval, dict):
+            retrieval = RetrievalConfiguration(**retrieval)
+        if isinstance(create, dict):
+            create = CreateKnowledgeBaseConfiguration(**create)
+        if isinstance(guardrail, dict):
+            guardrail = GuardrailConfiguration(**guardrail)
+        if isinstance(vector_store, dict):
+            vector_store = VectorStoreConfiguration(**vector_store)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__fa5a5937a282e8ddfa91598805b072febd3483c7f6ad9ed8eed9f52e4f0912e9)
+            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
+            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+            check_type(argname="argument acl", value=acl, expected_type=type_hints["acl"])
+            check_type(argname="argument retrieval", value=retrieval, expected_type=type_hints["retrieval"])
+            check_type(argname="argument knowledge_base_id", value=knowledge_base_id, expected_type=type_hints["knowledge_base_id"])
+            check_type(argname="argument create", value=create, expected_type=type_hints["create"])
+            check_type(argname="argument guardrail", value=guardrail, expected_type=type_hints["guardrail"])
+            check_type(argname="argument knowledge_base_arn", value=knowledge_base_arn, expected_type=type_hints["knowledge_base_arn"])
+            check_type(argname="argument vector_store", value=vector_store, expected_type=type_hints["vector_store"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "description": description,
+            "name": name,
+            "knowledge_base_id": knowledge_base_id,
+        }
+        if acl is not None:
+            self._values["acl"] = acl
+        if retrieval is not None:
+            self._values["retrieval"] = retrieval
+        if create is not None:
+            self._values["create"] = create
+        if guardrail is not None:
+            self._values["guardrail"] = guardrail
+        if knowledge_base_arn is not None:
+            self._values["knowledge_base_arn"] = knowledge_base_arn
+        if vector_store is not None:
+            self._values["vector_store"] = vector_store
+
+    @builtins.property
+    def description(self) -> builtins.str:
+        '''(experimental) Description of what this knowledge base contains and when to use it.
+
+        This description is shown to the agent in its system prompt to help
+        it decide when to query this knowledge base. Be specific about the
+        type of information contained and appropriate use cases.
+
+        :stability: experimental
+
+        Example::
+
+            'Contains product documentation, user guides, and FAQs. Use when answering questions about product features or troubleshooting.'
+        '''
+        result = self._values.get("description")
+        assert result is not None, "Required property 'description' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def name(self) -> builtins.str:
+        '''(experimental) Human-readable name/identifier for this knowledge base.
+
+        Used for logging, display purposes, and to help the agent identify
+        which knowledge base to query. Should be unique within the set of
+        knowledge bases configured for an agent.
+
+        :stability: experimental
+
+        Example::
+
+            'product-documentation'
+        '''
+        result = self._values.get("name")
+        assert result is not None, "Required property 'name' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def acl(self) -> typing.Optional["AclConfiguration"]:
+        '''(experimental) Access control configuration for identity-aware retrieval.
+
+        When enabled, retrieval queries will be filtered based on user
+        identity context to ensure users only access permitted documents.
+
+        :default: - ACL disabled
+
+        :stability: experimental
+        '''
+        result = self._values.get("acl")
+        return typing.cast(typing.Optional["AclConfiguration"], result)
+
+    @builtins.property
+    def retrieval(self) -> typing.Optional["RetrievalConfiguration"]:
+        '''(experimental) Retrieval configuration options.
+
+        Controls the number of results returned and optional metadata filtering.
+
+        :default: { numberOfResults: 5 }
+
+        :stability: experimental
+        '''
+        result = self._values.get("retrieval")
+        return typing.cast(typing.Optional["RetrievalConfiguration"], result)
+
+    @builtins.property
+    def knowledge_base_id(self) -> builtins.str:
+        '''(experimental) Unique identifier for the Bedrock Knowledge Base.
+
+        This is the ID assigned by Bedrock when the knowledge base was created.
+        You can find this in the Bedrock console or via the AWS CLI.
+
+        Required when referencing an existing knowledge base.
+        Not required when using the ``create`` property to create a new KB.
+
+        :stability: experimental
+        '''
+        result = self._values.get("knowledge_base_id")
+        assert result is not None, "Required property 'knowledge_base_id' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def create(self) -> typing.Optional["CreateKnowledgeBaseConfiguration"]:
+        '''(experimental) Configuration for creating a new knowledge base.
+
+        When provided, a new Bedrock Knowledge Base will be created with
+        the specified data source and embedding configuration.
+
+        Note: This is an advanced feature that creates AWS resources.
+        For most use cases, referencing an existing knowledge base by ID
+        is recommended.
+
+        :default: - Reference existing KB only (no creation)
+
+        :stability: experimental
+        '''
+        result = self._values.get("create")
+        return typing.cast(typing.Optional["CreateKnowledgeBaseConfiguration"], result)
+
+    @builtins.property
+    def guardrail(self) -> typing.Optional["GuardrailConfiguration"]:
+        '''(experimental) Guardrail configuration for content filtering.
+
+        When configured, the guardrail will be applied during retrieval
+        operations to filter inappropriate or sensitive content.
+
+        :default: - No guardrail applied
+
+        :stability: experimental
+        '''
+        result = self._values.get("guardrail")
+        return typing.cast(typing.Optional["GuardrailConfiguration"], result)
+
+    @builtins.property
+    def knowledge_base_arn(self) -> typing.Optional[builtins.str]:
+        '''(experimental) ARN of the Bedrock Knowledge Base.
+
+        If not provided, the ARN will be constructed from the knowledgeBaseId
+        using the current region and account.
+
+        :default: - Constructed from knowledgeBaseId
+
+        :stability: experimental
+        '''
+        result = self._values.get("knowledge_base_arn")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def vector_store(self) -> typing.Optional["VectorStoreConfiguration"]:
+        '''(experimental) Vector store configuration.
+
+        Defines the type of vector store used by this knowledge base.
+        This is informational and used for generating appropriate IAM
+        permissions when needed.
+
+        :default: - S3 Vectors (type: 's3-vectors')
+
+        :stability: experimental
+        '''
+        result = self._values.get("vector_store")
+        return typing.cast(typing.Optional["VectorStoreConfiguration"], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "BedrockKnowledgeBaseProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.data_type(
     jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.BedrockModelProps",
     jsii_struct_bases=[],
@@ -2739,25 +3269,178 @@ class CloudfrontDistributionObservabilityPropertyInjector(
 
 
 @jsii.data_type(
-    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.CustomDomainConfig",
+    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.CreateKnowledgeBaseConfiguration",
     jsii_struct_bases=[],
     name_mapping={
-        "certificate": "certificate",
-        "domain_name": "domainName",
-        "hosted_zone": "hostedZone",
+        "data_source_bucket_name": "dataSourceBucketName",
+        "chunking_strategy": "chunkingStrategy",
+        "data_source_prefix": "dataSourcePrefix",
+        "embedding_model_id": "embeddingModelId",
+        "max_tokens": "maxTokens",
+        "overlap_tokens": "overlapTokens",
     },
 )
-class CustomDomainConfig:
+class CreateKnowledgeBaseConfiguration:
     def __init__(
         self,
         *,
-        certificate: "_aws_cdk_aws_certificatemanager_ceddda9d.ICertificate",
-        domain_name: builtins.str,
-        hosted_zone: typing.Optional["_aws_cdk_aws_route53_ceddda9d.IHostedZone"] = None,
+        data_source_bucket_name: builtins.str,
+        chunking_strategy: typing.Optional[builtins.str] = None,
+        data_source_prefix: typing.Optional[builtins.str] = None,
+        embedding_model_id: typing.Optional[builtins.str] = None,
+        max_tokens: typing.Optional[jsii.Number] = None,
+        overlap_tokens: typing.Optional[jsii.Number] = None,
     ) -> None:
-        '''(experimental) Custom domain configuration for the frontend.
+        '''(experimental) Configuration for creating a new Bedrock Knowledge Base.
 
-        :param certificate: (experimental) SSL certificate for the domain (required when domainName is provided).
+        When provided to BedrockKnowledgeBase, a new knowledge base will be
+        created with the specified data source and embedding configuration.
+
+        Note: This is an advanced feature. For most use cases, referencing
+        an existing knowledge base by ID is recommended.
+
+        :param data_source_bucket_name: (experimental) S3 bucket name containing source documents. The bucket must exist and contain the documents to be indexed.
+        :param chunking_strategy: (experimental) Chunking strategy for document processing. - 'fixed-size': Split documents into fixed-size chunks - 'semantic': Use semantic boundaries for chunking - 'none': No chunking (use entire documents) Default: 'fixed-size'
+        :param data_source_prefix: (experimental) S3 prefix for source documents within the bucket. Only documents under this prefix will be indexed. Default: - Root of bucket (all documents)
+        :param embedding_model_id: (experimental) Embedding model to use for vectorization. Must be a valid Bedrock embedding model ID. Default: 'amazon.titan-embed-text-v2:0'
+        :param max_tokens: (experimental) Maximum chunk size in tokens (for fixed-size chunking). Only used when chunkingStrategy is 'fixed-size'. Default: 300
+        :param overlap_tokens: (experimental) Overlap between chunks in tokens (for fixed-size chunking). Only used when chunkingStrategy is 'fixed-size'. Default: 20
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__5a66ad6b4c71f08ad11270f15622825326a8ae23d1f4b8349ee45ee1997ed029)
+            check_type(argname="argument data_source_bucket_name", value=data_source_bucket_name, expected_type=type_hints["data_source_bucket_name"])
+            check_type(argname="argument chunking_strategy", value=chunking_strategy, expected_type=type_hints["chunking_strategy"])
+            check_type(argname="argument data_source_prefix", value=data_source_prefix, expected_type=type_hints["data_source_prefix"])
+            check_type(argname="argument embedding_model_id", value=embedding_model_id, expected_type=type_hints["embedding_model_id"])
+            check_type(argname="argument max_tokens", value=max_tokens, expected_type=type_hints["max_tokens"])
+            check_type(argname="argument overlap_tokens", value=overlap_tokens, expected_type=type_hints["overlap_tokens"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "data_source_bucket_name": data_source_bucket_name,
+        }
+        if chunking_strategy is not None:
+            self._values["chunking_strategy"] = chunking_strategy
+        if data_source_prefix is not None:
+            self._values["data_source_prefix"] = data_source_prefix
+        if embedding_model_id is not None:
+            self._values["embedding_model_id"] = embedding_model_id
+        if max_tokens is not None:
+            self._values["max_tokens"] = max_tokens
+        if overlap_tokens is not None:
+            self._values["overlap_tokens"] = overlap_tokens
+
+    @builtins.property
+    def data_source_bucket_name(self) -> builtins.str:
+        '''(experimental) S3 bucket name containing source documents.
+
+        The bucket must exist and contain the documents to be indexed.
+
+        :stability: experimental
+        '''
+        result = self._values.get("data_source_bucket_name")
+        assert result is not None, "Required property 'data_source_bucket_name' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def chunking_strategy(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Chunking strategy for document processing.
+
+        - 'fixed-size': Split documents into fixed-size chunks
+        - 'semantic': Use semantic boundaries for chunking
+        - 'none': No chunking (use entire documents)
+
+        :default: 'fixed-size'
+
+        :stability: experimental
+        '''
+        result = self._values.get("chunking_strategy")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def data_source_prefix(self) -> typing.Optional[builtins.str]:
+        '''(experimental) S3 prefix for source documents within the bucket.
+
+        Only documents under this prefix will be indexed.
+
+        :default: - Root of bucket (all documents)
+
+        :stability: experimental
+        '''
+        result = self._values.get("data_source_prefix")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def embedding_model_id(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Embedding model to use for vectorization.
+
+        Must be a valid Bedrock embedding model ID.
+
+        :default: 'amazon.titan-embed-text-v2:0'
+
+        :stability: experimental
+        '''
+        result = self._values.get("embedding_model_id")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def max_tokens(self) -> typing.Optional[jsii.Number]:
+        '''(experimental) Maximum chunk size in tokens (for fixed-size chunking).
+
+        Only used when chunkingStrategy is 'fixed-size'.
+
+        :default: 300
+
+        :stability: experimental
+        '''
+        result = self._values.get("max_tokens")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def overlap_tokens(self) -> typing.Optional[jsii.Number]:
+        '''(experimental) Overlap between chunks in tokens (for fixed-size chunking).
+
+        Only used when chunkingStrategy is 'fixed-size'.
+
+        :default: 20
+
+        :stability: experimental
+        '''
+        result = self._values.get("overlap_tokens")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "CreateKnowledgeBaseConfiguration(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.CustomDomainConfig",
+    jsii_struct_bases=[],
+    name_mapping={
+        "certificate": "certificate",
+        "domain_name": "domainName",
+        "hosted_zone": "hostedZone",
+    },
+)
+class CustomDomainConfig:
+    def __init__(
+        self,
+        *,
+        certificate: "_aws_cdk_aws_certificatemanager_ceddda9d.ICertificate",
+        domain_name: builtins.str,
+        hosted_zone: typing.Optional["_aws_cdk_aws_route53_ceddda9d.IHostedZone"] = None,
+    ) -> None:
+        '''(experimental) Custom domain configuration for the frontend.
+
+        :param certificate: (experimental) SSL certificate for the domain (required when domainName is provided).
         :param domain_name: (experimental) Domain name for the frontend (e.g., 'app.example.com').
         :param hosted_zone: (experimental) Optional hosted zone for automatic DNS record creation.
 
@@ -4239,6 +4922,78 @@ class FrontendProps:
         )
 
 
+@jsii.data_type(
+    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.GuardrailConfiguration",
+    jsii_struct_bases=[],
+    name_mapping={
+        "guardrail_id": "guardrailId",
+        "guardrail_version": "guardrailVersion",
+    },
+)
+class GuardrailConfiguration:
+    def __init__(
+        self,
+        *,
+        guardrail_id: builtins.str,
+        guardrail_version: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''(experimental) Configuration for Bedrock Guardrails.
+
+        Guardrails filter content during retrieval operations to prevent
+        inappropriate or sensitive content from being returned.
+
+        :param guardrail_id: (experimental) ID of the Bedrock Guardrail to apply. The guardrail must exist in the same region as the knowledge base.
+        :param guardrail_version: (experimental) Version of the guardrail to use. Use 'DRAFT' for testing or a specific version number for production. Default: 'DRAFT'
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__d604d1407a674dc8a1780469f6fca800816236372c95a3b5438a97e1c9faff32)
+            check_type(argname="argument guardrail_id", value=guardrail_id, expected_type=type_hints["guardrail_id"])
+            check_type(argname="argument guardrail_version", value=guardrail_version, expected_type=type_hints["guardrail_version"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "guardrail_id": guardrail_id,
+        }
+        if guardrail_version is not None:
+            self._values["guardrail_version"] = guardrail_version
+
+    @builtins.property
+    def guardrail_id(self) -> builtins.str:
+        '''(experimental) ID of the Bedrock Guardrail to apply.
+
+        The guardrail must exist in the same region as the knowledge base.
+
+        :stability: experimental
+        '''
+        result = self._values.get("guardrail_id")
+        assert result is not None, "Required property 'guardrail_id' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def guardrail_version(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Version of the guardrail to use.
+
+        Use 'DRAFT' for testing or a specific version number for production.
+
+        :default: 'DRAFT'
+
+        :stability: experimental
+        '''
+        result = self._values.get("guardrail_version")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "GuardrailConfiguration(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.data_type(
     jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.HybridConfig",
     jsii_struct_bases=[],
@@ -4699,6 +5454,250 @@ class _IAdapterProxy:
 typing.cast(typing.Any, IAdapter).__jsii_proxy_class__ = lambda : _IAdapterProxy
 
 
+@jsii.interface(jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.IKnowledgeBase")
+class IKnowledgeBase(typing_extensions.Protocol):
+    '''(experimental) Interface for knowledge base implementations.
+
+    This interface defines the contract that all knowledge base implementations must satisfy,
+    allowing different KB backends (Bedrock KB, OpenSearch, custom) to be used interchangeably
+    with the agent framework.
+
+    Implementations of this interface are responsible for:
+
+    - Providing metadata about the knowledge base (name, description)
+    - Generating the IAM permissions required for the agent to access the KB
+    - Exporting runtime configuration for the retrieval tool
+    - Optionally providing a custom retrieval tool implementation
+
+    :stability: experimental
+    '''
+
+    @builtins.property
+    @jsii.member(jsii_name="description")
+    def description(self) -> builtins.str:
+        '''(experimental) Human-readable description of what this knowledge base contains.
+
+        This description is included in the agent's system prompt to help
+        the agent decide when to query this knowledge base. It should clearly
+        indicate what type of information the KB contains and when it should
+        be used.
+
+        :stability: experimental
+
+        Example::
+
+            'Contains product documentation, user guides, and FAQs. Use when answering questions about product features or troubleshooting.'
+        '''
+        ...
+
+    @builtins.property
+    @jsii.member(jsii_name="name")
+    def name(self) -> builtins.str:
+        '''(experimental) Human-readable name for this knowledge base.
+
+        This name is used for logging, display purposes, and to help the agent
+        identify which knowledge base to query. It should be unique within
+        the set of knowledge bases configured for an agent.
+
+        :stability: experimental
+
+        Example::
+
+            'product-documentation'
+        '''
+        ...
+
+    @jsii.member(jsii_name="exportConfiguration")
+    def export_configuration(self) -> "KnowledgeBaseRuntimeConfig":
+        '''(experimental) Export configuration for runtime use by the retrieval tool.
+
+        This method returns a configuration object that will be serialized
+        and passed to the retrieval tool via environment variables. The
+        configuration includes all information needed to query the KB at runtime.
+
+        :return: Runtime configuration object for the retrieval tool
+
+        :stability: experimental
+        '''
+        ...
+
+    @jsii.member(jsii_name="generateIamPermissions")
+    def generate_iam_permissions(
+        self,
+    ) -> typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]:
+        '''(experimental) Generate IAM policy statements required for accessing this knowledge base.
+
+        This method returns the IAM permissions that the agent's Lambda function
+        role needs to query this knowledge base. The permissions should follow
+        the principle of least privilege, scoped to the specific resources.
+
+        :return: Array of IAM PolicyStatement objects granting necessary permissions
+
+        :stability: experimental
+        '''
+        ...
+
+    @jsii.member(jsii_name="retrievalToolAsset")
+    def retrieval_tool_asset(
+        self,
+    ) -> typing.Optional["_aws_cdk_aws_s3_assets_ceddda9d.Asset"]:
+        '''(experimental) Provide the retrieval tool asset for this knowledge base type.
+
+        This optional method allows knowledge base implementations to provide
+        a custom retrieval tool. If not implemented or returns undefined,
+        the framework's default retrieval tool will be used.
+
+        :return: S3 Asset containing the retrieval tool code, or undefined to use the default
+
+        :stability: experimental
+        '''
+        ...
+
+    @jsii.member(jsii_name="retrievalToolLayers")
+    def retrieval_tool_layers(
+        self,
+    ) -> typing.Optional[typing.List["_aws_cdk_aws_lambda_ceddda9d.LayerVersion"]]:
+        '''(experimental) Provide Lambda layers required by the retrieval tool.
+
+        This optional method allows knowledge base implementations to provide
+        Lambda layers containing dependencies needed by their retrieval tool.
+        For example, a knowledge base might need specific boto3 versions,
+        custom libraries, or SDK extensions.
+
+        The layers will be added to the agent's Lambda function, making the
+        dependencies available to the retrieval tool at runtime.
+
+        :return: Array of Lambda LayerVersion objects, or undefined if no layers needed
+
+        :stability: experimental
+        '''
+        ...
+
+
+class _IKnowledgeBaseProxy:
+    '''(experimental) Interface for knowledge base implementations.
+
+    This interface defines the contract that all knowledge base implementations must satisfy,
+    allowing different KB backends (Bedrock KB, OpenSearch, custom) to be used interchangeably
+    with the agent framework.
+
+    Implementations of this interface are responsible for:
+
+    - Providing metadata about the knowledge base (name, description)
+    - Generating the IAM permissions required for the agent to access the KB
+    - Exporting runtime configuration for the retrieval tool
+    - Optionally providing a custom retrieval tool implementation
+
+    :stability: experimental
+    '''
+
+    __jsii_type__: typing.ClassVar[str] = "@cdklabs/cdk-appmod-catalog-blueprints.IKnowledgeBase"
+
+    @builtins.property
+    @jsii.member(jsii_name="description")
+    def description(self) -> builtins.str:
+        '''(experimental) Human-readable description of what this knowledge base contains.
+
+        This description is included in the agent's system prompt to help
+        the agent decide when to query this knowledge base. It should clearly
+        indicate what type of information the KB contains and when it should
+        be used.
+
+        :stability: experimental
+
+        Example::
+
+            'Contains product documentation, user guides, and FAQs. Use when answering questions about product features or troubleshooting.'
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "description"))
+
+    @builtins.property
+    @jsii.member(jsii_name="name")
+    def name(self) -> builtins.str:
+        '''(experimental) Human-readable name for this knowledge base.
+
+        This name is used for logging, display purposes, and to help the agent
+        identify which knowledge base to query. It should be unique within
+        the set of knowledge bases configured for an agent.
+
+        :stability: experimental
+
+        Example::
+
+            'product-documentation'
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "name"))
+
+    @jsii.member(jsii_name="exportConfiguration")
+    def export_configuration(self) -> "KnowledgeBaseRuntimeConfig":
+        '''(experimental) Export configuration for runtime use by the retrieval tool.
+
+        This method returns a configuration object that will be serialized
+        and passed to the retrieval tool via environment variables. The
+        configuration includes all information needed to query the KB at runtime.
+
+        :return: Runtime configuration object for the retrieval tool
+
+        :stability: experimental
+        '''
+        return typing.cast("KnowledgeBaseRuntimeConfig", jsii.invoke(self, "exportConfiguration", []))
+
+    @jsii.member(jsii_name="generateIamPermissions")
+    def generate_iam_permissions(
+        self,
+    ) -> typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]:
+        '''(experimental) Generate IAM policy statements required for accessing this knowledge base.
+
+        This method returns the IAM permissions that the agent's Lambda function
+        role needs to query this knowledge base. The permissions should follow
+        the principle of least privilege, scoped to the specific resources.
+
+        :return: Array of IAM PolicyStatement objects granting necessary permissions
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"], jsii.invoke(self, "generateIamPermissions", []))
+
+    @jsii.member(jsii_name="retrievalToolAsset")
+    def retrieval_tool_asset(
+        self,
+    ) -> typing.Optional["_aws_cdk_aws_s3_assets_ceddda9d.Asset"]:
+        '''(experimental) Provide the retrieval tool asset for this knowledge base type.
+
+        This optional method allows knowledge base implementations to provide
+        a custom retrieval tool. If not implemented or returns undefined,
+        the framework's default retrieval tool will be used.
+
+        :return: S3 Asset containing the retrieval tool code, or undefined to use the default
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional["_aws_cdk_aws_s3_assets_ceddda9d.Asset"], jsii.invoke(self, "retrievalToolAsset", []))
+
+    @jsii.member(jsii_name="retrievalToolLayers")
+    def retrieval_tool_layers(
+        self,
+    ) -> typing.Optional[typing.List["_aws_cdk_aws_lambda_ceddda9d.LayerVersion"]]:
+        '''(experimental) Provide Lambda layers required by the retrieval tool.
+
+        This optional method allows knowledge base implementations to provide
+        Lambda layers containing dependencies needed by their retrieval tool.
+        For example, a knowledge base might need specific boto3 versions,
+        custom libraries, or SDK extensions.
+
+        The layers will be added to the agent's Lambda function, making the
+        dependencies available to the retrieval tool at runtime.
+
+        :return: Array of Lambda LayerVersion objects, or undefined if no layers needed
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional[typing.List["_aws_cdk_aws_lambda_ceddda9d.LayerVersion"]], jsii.invoke(self, "retrievalToolLayers", []))
+
+# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
+typing.cast(typing.Any, IKnowledgeBase).__jsii_proxy_class__ = lambda : _IKnowledgeBaseProxy
+
+
 @jsii.interface(jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.IObservable")
 class IObservable(typing_extensions.Protocol):
     '''(experimental) Interface providing configuration parameters for constructs that support Observability.
@@ -4781,6 +5780,247 @@ class _IObservableProxy:
 typing.cast(typing.Any, IObservable).__jsii_proxy_class__ = lambda : _IObservableProxy
 
 
+@jsii.enum(jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.InvokeType")
+class InvokeType(enum.Enum):
+    '''(experimental) Agent invocation type enumeration.
+
+    Defines the processing mode for the agent.
+    Must match the Python InvokeType enum in batch.py.
+
+    :stability: experimental
+    '''
+
+    BATCH = "BATCH"
+    '''(experimental) Batch processing mode - processes one document at a time.
+
+    Default mode for most agent operations.
+
+    :stability: experimental
+    '''
+    INTERACTIVE = "INTERACTIVE"
+    '''(experimental) Interactive conversation mode (future).
+
+    For real-time chat and conversational interfaces.
+
+    :stability: experimental
+    '''
+    ATTACH_DIRECTLY = "ATTACH_DIRECTLY"
+    '''(experimental) Direct invocation mode.
+
+    Used for RAG applications, API endpoints, and direct agent calls.
+
+    :stability: experimental
+    '''
+    CLASSIFICATION = "CLASSIFICATION"
+    '''(experimental) Document classification step.
+
+    Used in document processing workflows for classification phase.
+
+    :stability: experimental
+    '''
+    PROCESSING = "PROCESSING"
+    '''(experimental) Document processing step.
+
+    Used in document processing workflows for extraction/processing phase.
+
+    :stability: experimental
+    '''
+    AGGREGATION = "AGGREGATION"
+    '''(experimental) Document aggregation step.
+
+    Used in document processing workflows for aggregating chunked results.
+
+    :stability: experimental
+    '''
+
+
+@jsii.data_type(
+    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.KnowledgeBaseRuntimeConfig",
+    jsii_struct_bases=[],
+    name_mapping={
+        "description": "description",
+        "name": "name",
+        "retrieval": "retrieval",
+        "acl": "acl",
+        "guardrail": "guardrail",
+        "knowledge_base_arn": "knowledgeBaseArn",
+        "knowledge_base_id": "knowledgeBaseId",
+        "type": "type",
+        "vector_store": "vectorStore",
+    },
+)
+class KnowledgeBaseRuntimeConfig:
+    def __init__(
+        self,
+        *,
+        description: builtins.str,
+        name: builtins.str,
+        retrieval: typing.Union["RetrievalConfiguration", typing.Dict[builtins.str, typing.Any]],
+        acl: typing.Optional[typing.Union["AclConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
+        guardrail: typing.Optional[typing.Union["GuardrailConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
+        knowledge_base_arn: typing.Optional[builtins.str] = None,
+        knowledge_base_id: typing.Optional[builtins.str] = None,
+        type: typing.Optional[builtins.str] = None,
+        vector_store: typing.Optional[typing.Union["VectorStoreConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
+    ) -> None:
+        '''(experimental) Runtime configuration exported for the retrieval tool.
+
+        This interface defines the structure of the configuration object
+        that is serialized and passed to the retrieval tool via environment
+        variables. It contains all information needed to query the knowledge
+        base at runtime.
+
+        :param description: (experimental) Description of what this knowledge base contains.
+        :param name: (experimental) Human-readable name for this knowledge base.
+        :param retrieval: (experimental) Retrieval configuration.
+        :param acl: (experimental) ACL configuration for identity-aware retrieval.
+        :param guardrail: (experimental) Guardrail configuration (for Bedrock implementations).
+        :param knowledge_base_arn: (experimental) Bedrock Knowledge Base ARN (for Bedrock implementations).
+        :param knowledge_base_id: (experimental) Bedrock Knowledge Base ID (for Bedrock implementations).
+        :param type: (experimental) Type of knowledge base implementation. Used by the retrieval tool to determine how to query the KB.
+        :param vector_store: (experimental) Vector store configuration (for Bedrock implementations).
+
+        :stability: experimental
+        '''
+        if isinstance(retrieval, dict):
+            retrieval = RetrievalConfiguration(**retrieval)
+        if isinstance(acl, dict):
+            acl = AclConfiguration(**acl)
+        if isinstance(guardrail, dict):
+            guardrail = GuardrailConfiguration(**guardrail)
+        if isinstance(vector_store, dict):
+            vector_store = VectorStoreConfiguration(**vector_store)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__eba4c5624b16f91d89be2a09eeaf9e99f078cde0dfdfdaa2d50e663d366ce5a1)
+            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
+            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+            check_type(argname="argument retrieval", value=retrieval, expected_type=type_hints["retrieval"])
+            check_type(argname="argument acl", value=acl, expected_type=type_hints["acl"])
+            check_type(argname="argument guardrail", value=guardrail, expected_type=type_hints["guardrail"])
+            check_type(argname="argument knowledge_base_arn", value=knowledge_base_arn, expected_type=type_hints["knowledge_base_arn"])
+            check_type(argname="argument knowledge_base_id", value=knowledge_base_id, expected_type=type_hints["knowledge_base_id"])
+            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
+            check_type(argname="argument vector_store", value=vector_store, expected_type=type_hints["vector_store"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "description": description,
+            "name": name,
+            "retrieval": retrieval,
+        }
+        if acl is not None:
+            self._values["acl"] = acl
+        if guardrail is not None:
+            self._values["guardrail"] = guardrail
+        if knowledge_base_arn is not None:
+            self._values["knowledge_base_arn"] = knowledge_base_arn
+        if knowledge_base_id is not None:
+            self._values["knowledge_base_id"] = knowledge_base_id
+        if type is not None:
+            self._values["type"] = type
+        if vector_store is not None:
+            self._values["vector_store"] = vector_store
+
+    @builtins.property
+    def description(self) -> builtins.str:
+        '''(experimental) Description of what this knowledge base contains.
+
+        :stability: experimental
+        '''
+        result = self._values.get("description")
+        assert result is not None, "Required property 'description' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def name(self) -> builtins.str:
+        '''(experimental) Human-readable name for this knowledge base.
+
+        :stability: experimental
+        '''
+        result = self._values.get("name")
+        assert result is not None, "Required property 'name' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def retrieval(self) -> "RetrievalConfiguration":
+        '''(experimental) Retrieval configuration.
+
+        :stability: experimental
+        '''
+        result = self._values.get("retrieval")
+        assert result is not None, "Required property 'retrieval' is missing"
+        return typing.cast("RetrievalConfiguration", result)
+
+    @builtins.property
+    def acl(self) -> typing.Optional["AclConfiguration"]:
+        '''(experimental) ACL configuration for identity-aware retrieval.
+
+        :stability: experimental
+        '''
+        result = self._values.get("acl")
+        return typing.cast(typing.Optional["AclConfiguration"], result)
+
+    @builtins.property
+    def guardrail(self) -> typing.Optional["GuardrailConfiguration"]:
+        '''(experimental) Guardrail configuration (for Bedrock implementations).
+
+        :stability: experimental
+        '''
+        result = self._values.get("guardrail")
+        return typing.cast(typing.Optional["GuardrailConfiguration"], result)
+
+    @builtins.property
+    def knowledge_base_arn(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Bedrock Knowledge Base ARN (for Bedrock implementations).
+
+        :stability: experimental
+        '''
+        result = self._values.get("knowledge_base_arn")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def knowledge_base_id(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Bedrock Knowledge Base ID (for Bedrock implementations).
+
+        :stability: experimental
+        '''
+        result = self._values.get("knowledge_base_id")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def type(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Type of knowledge base implementation.
+
+        Used by the retrieval tool to determine how to query the KB.
+
+        :stability: experimental
+
+        Example::
+
+            'bedrock'
+        '''
+        result = self._values.get("type")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def vector_store(self) -> typing.Optional["VectorStoreConfiguration"]:
+        '''(experimental) Vector store configuration (for Bedrock implementations).
+
+        :stability: experimental
+        '''
+        result = self._values.get("vector_store")
+        return typing.cast(typing.Optional["VectorStoreConfiguration"], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "KnowledgeBaseRuntimeConfig(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 class LambdaIamUtils(
     metaclass=jsii.JSIIMeta,
     jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.LambdaIamUtils",
@@ -6386,6 +7626,84 @@ class QueuedS3AdapterProps:
         )
 
 
+@jsii.data_type(
+    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.RetrievalConfiguration",
+    jsii_struct_bases=[],
+    name_mapping={
+        "number_of_results": "numberOfResults",
+        "retrieval_filter": "retrievalFilter",
+    },
+)
+class RetrievalConfiguration:
+    def __init__(
+        self,
+        *,
+        number_of_results: typing.Optional[jsii.Number] = None,
+        retrieval_filter: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+    ) -> None:
+        '''(experimental) Configuration for retrieval operations.
+
+        Controls how many results are returned and optional metadata filtering
+        applied to all queries against the knowledge base.
+
+        :param number_of_results: (experimental) Number of results to return per query. Higher values provide more context but increase token usage. Lower values are faster but may miss relevant information. Default: 5
+        :param retrieval_filter: (experimental) Metadata filter to apply to all queries. This filter is applied in addition to any ACL filters. Use this for static filtering based on document metadata (e.g., document type, category, or date range). Default: - No filter applied
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__0389e881defd6b748c16712149b25f1d6a9c2415742f6287f9424ffee6d97ac9)
+            check_type(argname="argument number_of_results", value=number_of_results, expected_type=type_hints["number_of_results"])
+            check_type(argname="argument retrieval_filter", value=retrieval_filter, expected_type=type_hints["retrieval_filter"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if number_of_results is not None:
+            self._values["number_of_results"] = number_of_results
+        if retrieval_filter is not None:
+            self._values["retrieval_filter"] = retrieval_filter
+
+    @builtins.property
+    def number_of_results(self) -> typing.Optional[jsii.Number]:
+        '''(experimental) Number of results to return per query.
+
+        Higher values provide more context but increase token usage.
+        Lower values are faster but may miss relevant information.
+
+        :default: 5
+
+        :stability: experimental
+        '''
+        result = self._values.get("number_of_results")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def retrieval_filter(
+        self,
+    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
+        '''(experimental) Metadata filter to apply to all queries.
+
+        This filter is applied in addition to any ACL filters. Use this
+        for static filtering based on document metadata (e.g., document type,
+        category, or date range).
+
+        :default: - No filter applied
+
+        :stability: experimental
+        '''
+        result = self._values.get("retrieval_filter")
+        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "RetrievalConfiguration(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.implements(_aws_cdk_ceddda9d.IPropertyInjector)
 class StateMachineObservabilityPropertyInjector(
     metaclass=jsii.JSIIMeta,
@@ -6598,38 +7916,130 @@ class TokenBasedConfig:
 
         Ensures no chunk exceeds model token limits.
 
-        :default: 100000
+        :default: 100000
+
+        :stability: experimental
+        '''
+        result = self._values.get("max_tokens_per_chunk")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def overlap_tokens(self) -> typing.Optional[jsii.Number]:
+        '''(experimental) Number of overlapping tokens between consecutive chunks.
+
+        Provides context continuity across chunks.
+
+        :default: 5000
+
+        :stability: experimental
+        '''
+        result = self._values.get("overlap_tokens")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def token_threshold(self) -> typing.Optional[jsii.Number]:
+        '''(experimental) Threshold for triggering chunking based on token count.
+
+        Documents with tokens > threshold will be chunked.
+
+        :default: 150000
+
+        :stability: experimental
+        '''
+        result = self._values.get("token_threshold")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "TokenBasedConfig(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.VectorStoreConfiguration",
+    jsii_struct_bases=[],
+    name_mapping={"bucket_name": "bucketName", "prefix": "prefix", "type": "type"},
+)
+class VectorStoreConfiguration:
+    def __init__(
+        self,
+        *,
+        bucket_name: typing.Optional[builtins.str] = None,
+        prefix: typing.Optional[builtins.str] = None,
+        type: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''(experimental) Configuration for vector store used by the knowledge base.
+
+        Defines the type of vector store and any type-specific configuration.
+        S3 Vectors is the default and recommended option for most use cases.
+
+        :param bucket_name: (experimental) S3 bucket name for S3 Vectors storage. Only used when type is 's3-vectors'. If not provided, the default bucket created by Bedrock will be used. Default: - Uses Bedrock's default bucket
+        :param prefix: (experimental) S3 prefix for vectors within the bucket. Only used when type is 's3-vectors'. Default: 'vectors/'
+        :param type: (experimental) Type of vector store. - 's3-vectors': Amazon S3 vector storage (default, recommended) - 'opensearch-serverless': Amazon OpenSearch Serverless - 'pinecone': Pinecone vector database - 'rds': Amazon RDS with pgvector Default: 's3-vectors'
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__98230924b191ba0192b7d818a592221249c2b38f4ddd572cfc62d08a37b84b42)
+            check_type(argname="argument bucket_name", value=bucket_name, expected_type=type_hints["bucket_name"])
+            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
+            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if bucket_name is not None:
+            self._values["bucket_name"] = bucket_name
+        if prefix is not None:
+            self._values["prefix"] = prefix
+        if type is not None:
+            self._values["type"] = type
+
+    @builtins.property
+    def bucket_name(self) -> typing.Optional[builtins.str]:
+        '''(experimental) S3 bucket name for S3 Vectors storage.
+
+        Only used when type is 's3-vectors'. If not provided, the default
+        bucket created by Bedrock will be used.
+
+        :default: - Uses Bedrock's default bucket
 
         :stability: experimental
         '''
-        result = self._values.get("max_tokens_per_chunk")
-        return typing.cast(typing.Optional[jsii.Number], result)
+        result = self._values.get("bucket_name")
+        return typing.cast(typing.Optional[builtins.str], result)
 
     @builtins.property
-    def overlap_tokens(self) -> typing.Optional[jsii.Number]:
-        '''(experimental) Number of overlapping tokens between consecutive chunks.
+    def prefix(self) -> typing.Optional[builtins.str]:
+        '''(experimental) S3 prefix for vectors within the bucket.
 
-        Provides context continuity across chunks.
+        Only used when type is 's3-vectors'.
 
-        :default: 5000
+        :default: 'vectors/'
 
         :stability: experimental
         '''
-        result = self._values.get("overlap_tokens")
-        return typing.cast(typing.Optional[jsii.Number], result)
+        result = self._values.get("prefix")
+        return typing.cast(typing.Optional[builtins.str], result)
 
     @builtins.property
-    def token_threshold(self) -> typing.Optional[jsii.Number]:
-        '''(experimental) Threshold for triggering chunking based on token count.
+    def type(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Type of vector store.
 
-        Documents with tokens > threshold will be chunked.
+        - 's3-vectors': Amazon S3 vector storage (default, recommended)
+        - 'opensearch-serverless': Amazon OpenSearch Serverless
+        - 'pinecone': Pinecone vector database
+        - 'rds': Amazon RDS with pgvector
 
-        :default: 150000
+        :default: 's3-vectors'
 
         :stability: experimental
         '''
-        result = self._values.get("token_threshold")
-        return typing.cast(typing.Optional[jsii.Number], result)
+        result = self._values.get("type")
+        return typing.cast(typing.Optional[builtins.str], result)
 
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
@@ -6638,7 +8048,7 @@ class TokenBasedConfig:
         return not (rhs == self)
 
     def __repr__(self) -> str:
-        return "TokenBasedConfig(%s)" % ", ".join(
+        return "VectorStoreConfiguration(%s)" % ", ".join(
             k + "=" + repr(v) for k, v in self._values.items()
         )
 
@@ -7484,6 +8894,226 @@ class BaseDocumentProcessingProps(ObservableProps):
         )
 
 
+@jsii.implements(IKnowledgeBase)
+class BaseKnowledgeBase(
+    _constructs_77d1e7e8.Construct,
+    metaclass=jsii.JSIIAbstractClass,
+    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.BaseKnowledgeBase",
+):
+    '''(experimental) Abstract base class for knowledge base implementations.
+
+    This class provides common functionality for all knowledge base implementations,
+    including configuration management, validation, and default behaviors. Concrete
+    implementations (like BedrockKnowledgeBase) extend this class and implement
+    the abstract methods.
+
+    The base class handles:
+
+    - Props validation (name and description are required)
+    - Default retrieval configuration (numberOfResults defaults to 5)
+    - ACL configuration storage
+    - Base runtime configuration export
+
+    Subclasses must implement:
+
+    - ``generateIamPermissions()``: Return IAM permissions specific to the KB type
+
+    :stability: experimental
+    '''
+
+    def __init__(
+        self,
+        scope: "_constructs_77d1e7e8.Construct",
+        id: builtins.str,
+        *,
+        description: builtins.str,
+        name: builtins.str,
+        acl: typing.Optional[typing.Union["AclConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
+        retrieval: typing.Optional[typing.Union["RetrievalConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
+    ) -> None:
+        '''(experimental) Creates a new BaseKnowledgeBase instance.
+
+        :param scope: - The scope in which to define this construct.
+        :param id: - The scoped construct ID.
+        :param description: (experimental) Description of what this knowledge base contains and when to use it. This description is shown to the agent in its system prompt to help it decide when to query this knowledge base. Be specific about the type of information contained and appropriate use cases.
+        :param name: (experimental) Human-readable name/identifier for this knowledge base. Used for logging, display purposes, and to help the agent identify which knowledge base to query. Should be unique within the set of knowledge bases configured for an agent.
+        :param acl: (experimental) Access control configuration for identity-aware retrieval. When enabled, retrieval queries will be filtered based on user identity context to ensure users only access permitted documents. Default: - ACL disabled
+        :param retrieval: (experimental) Retrieval configuration options. Controls the number of results returned and optional metadata filtering. Default: { numberOfResults: 5 }
+
+        :stability: experimental
+        :throws: Error if description is empty or not provided
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__1ffdc1300a392d74aedab074831b812725fc7d9f0b3c025e42cefd06be3e3273)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        props = BaseKnowledgeBaseProps(
+            description=description, name=name, acl=acl, retrieval=retrieval
+        )
+
+        jsii.create(self.__class__, self, [scope, id, props])
+
+    @jsii.member(jsii_name="exportConfiguration")
+    def export_configuration(self) -> "KnowledgeBaseRuntimeConfig":
+        '''(experimental) Export configuration for runtime use by the retrieval tool.
+
+        Returns a configuration object containing the base knowledge base
+        settings. Subclasses should override this method to add implementation-
+        specific configuration, calling super.exportConfiguration() to include
+        the base configuration.
+
+        :return: Runtime configuration object for the retrieval tool
+
+        :stability: experimental
+        '''
+        return typing.cast("KnowledgeBaseRuntimeConfig", jsii.invoke(self, "exportConfiguration", []))
+
+    @jsii.member(jsii_name="generateIamPermissions")
+    @abc.abstractmethod
+    def generate_iam_permissions(
+        self,
+    ) -> typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]:
+        '''(experimental) Generate IAM policy statements required for accessing this knowledge base.
+
+        This abstract method must be implemented by subclasses to return the
+        specific IAM permissions needed for their knowledge base type.
+
+        :return: Array of IAM PolicyStatement objects granting necessary permissions
+
+        :stability: experimental
+        '''
+        ...
+
+    @jsii.member(jsii_name="retrievalToolAsset")
+    def retrieval_tool_asset(
+        self,
+    ) -> typing.Optional["_aws_cdk_aws_s3_assets_ceddda9d.Asset"]:
+        '''(experimental) Provide the retrieval tool asset for this knowledge base type.
+
+        By default, returns undefined to use the framework's default retrieval
+        tool. Subclasses can override this method to provide a custom retrieval
+        tool implementation.
+
+        :return: undefined to use the default retrieval tool
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional["_aws_cdk_aws_s3_assets_ceddda9d.Asset"], jsii.invoke(self, "retrievalToolAsset", []))
+
+    @jsii.member(jsii_name="retrievalToolLayers")
+    def retrieval_tool_layers(
+        self,
+    ) -> typing.Optional[typing.List["_aws_cdk_aws_lambda_ceddda9d.LayerVersion"]]:
+        '''(experimental) Provide Lambda layers required by the retrieval tool.
+
+        By default, returns undefined indicating no additional layers are needed.
+        Subclasses can override this method to provide Lambda layers containing
+        dependencies required by their retrieval tool.
+
+        :return: undefined indicating no additional layers needed
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional[typing.List["_aws_cdk_aws_lambda_ceddda9d.LayerVersion"]], jsii.invoke(self, "retrievalToolLayers", []))
+
+    @jsii.member(jsii_name="validateProps")
+    def _validate_props(
+        self,
+        *,
+        description: builtins.str,
+        name: builtins.str,
+        acl: typing.Optional[typing.Union["AclConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
+        retrieval: typing.Optional[typing.Union["RetrievalConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
+    ) -> None:
+        '''(experimental) Validates the provided props at construction time.
+
+        Ensures that required fields (name and description) are provided
+        and not empty. Subclasses can override this method to add additional
+        validation, but should call super.validateProps() first.
+
+        :param description: (experimental) Description of what this knowledge base contains and when to use it. This description is shown to the agent in its system prompt to help it decide when to query this knowledge base. Be specific about the type of information contained and appropriate use cases.
+        :param name: (experimental) Human-readable name/identifier for this knowledge base. Used for logging, display purposes, and to help the agent identify which knowledge base to query. Should be unique within the set of knowledge bases configured for an agent.
+        :param acl: (experimental) Access control configuration for identity-aware retrieval. When enabled, retrieval queries will be filtered based on user identity context to ensure users only access permitted documents. Default: - ACL disabled
+        :param retrieval: (experimental) Retrieval configuration options. Controls the number of results returned and optional metadata filtering. Default: { numberOfResults: 5 }
+
+        :stability: experimental
+        :throws: Error if description is empty or not provided
+        '''
+        props = BaseKnowledgeBaseProps(
+            description=description, name=name, acl=acl, retrieval=retrieval
+        )
+
+        return typing.cast(None, jsii.invoke(self, "validateProps", [props]))
+
+    @builtins.property
+    @jsii.member(jsii_name="description")
+    def description(self) -> builtins.str:
+        '''(experimental) Human-readable description of what this knowledge base contains.
+
+        This description is included in the agent's system prompt to help
+        the agent decide when to query this knowledge base.
+
+        :stability: experimental
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "description"))
+
+    @builtins.property
+    @jsii.member(jsii_name="name")
+    def name(self) -> builtins.str:
+        '''(experimental) Human-readable name for this knowledge base.
+
+        This name is used for logging, display purposes, and to help the agent
+        identify which knowledge base to query.
+
+        :stability: experimental
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "name"))
+
+    @builtins.property
+    @jsii.member(jsii_name="retrievalConfig")
+    def _retrieval_config(self) -> "RetrievalConfiguration":
+        '''(experimental) Retrieval configuration for this knowledge base.
+
+        Contains settings like numberOfResults and optional metadata filters.
+        Defaults to { numberOfResults: 5 } if not provided.
+
+        :stability: experimental
+        '''
+        return typing.cast("RetrievalConfiguration", jsii.get(self, "retrievalConfig"))
+
+    @builtins.property
+    @jsii.member(jsii_name="aclConfig")
+    def _acl_config(self) -> typing.Optional["AclConfiguration"]:
+        '''(experimental) ACL configuration for identity-aware retrieval.
+
+        When enabled, retrieval queries will be filtered based on user
+        identity context.
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional["AclConfiguration"], jsii.get(self, "aclConfig"))
+
+
+class _BaseKnowledgeBaseProxy(BaseKnowledgeBase):
+    @jsii.member(jsii_name="generateIamPermissions")
+    def generate_iam_permissions(
+        self,
+    ) -> typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]:
+        '''(experimental) Generate IAM policy statements required for accessing this knowledge base.
+
+        This abstract method must be implemented by subclasses to return the
+        specific IAM permissions needed for their knowledge base type.
+
+        :return: Array of IAM PolicyStatement objects granting necessary permissions
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"], jsii.invoke(self, "generateIamPermissions", []))
+
+# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
+typing.cast(typing.Any, BaseKnowledgeBase).__jsii_proxy_class__ = lambda : _BaseKnowledgeBaseProxy
+
+
 @jsii.data_type(
     jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.BatchAgentProps",
     jsii_struct_bases=[BaseAgentProps],
@@ -7499,6 +9129,7 @@ class BaseDocumentProcessingProps(ObservableProps):
         "removal_policy": "removalPolicy",
         "prompt": "prompt",
         "expect_json": "expectJson",
+        "invoke_type": "invokeType",
     },
 )
 class BatchAgentProps(BaseAgentProps):
@@ -7516,6 +9147,7 @@ class BatchAgentProps(BaseAgentProps):
         removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
         prompt: builtins.str,
         expect_json: typing.Optional[builtins.bool] = None,
+        invoke_type: typing.Optional["InvokeType"] = None,
     ) -> None:
         '''
         :param log_group_data_protection: (experimental) Data protection related configuration. Default: a new KMS key would be generated
@@ -7529,6 +9161,7 @@ class BatchAgentProps(BaseAgentProps):
         :param removal_policy: (experimental) Removal policy for resources created by this construct. Default: RemovalPolicy.DESTROY
         :param prompt: 
         :param expect_json: 
+        :param invoke_type: (experimental) Agent invocation type. Defines how the agent is invoked and what processing mode to use. Default: InvokeType.BATCH
 
         :stability: experimental
         '''
@@ -7549,6 +9182,7 @@ class BatchAgentProps(BaseAgentProps):
             check_type(argname="argument removal_policy", value=removal_policy, expected_type=type_hints["removal_policy"])
             check_type(argname="argument prompt", value=prompt, expected_type=type_hints["prompt"])
             check_type(argname="argument expect_json", value=expect_json, expected_type=type_hints["expect_json"])
+            check_type(argname="argument invoke_type", value=invoke_type, expected_type=type_hints["invoke_type"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "agent_definition": agent_definition,
             "agent_name": agent_name,
@@ -7570,6 +9204,8 @@ class BatchAgentProps(BaseAgentProps):
             self._values["removal_policy"] = removal_policy
         if expect_json is not None:
             self._values["expect_json"] = expect_json
+        if invoke_type is not None:
+            self._values["invoke_type"] = invoke_type
 
     @builtins.property
     def log_group_data_protection(
@@ -7687,6 +9323,19 @@ class BatchAgentProps(BaseAgentProps):
         result = self._values.get("expect_json")
         return typing.cast(typing.Optional[builtins.bool], result)
 
+    @builtins.property
+    def invoke_type(self) -> typing.Optional["InvokeType"]:
+        '''(experimental) Agent invocation type.
+
+        Defines how the agent is invoked and what processing mode to use.
+
+        :default: InvokeType.BATCH
+
+        :stability: experimental
+        '''
+        result = self._values.get("invoke_type")
+        return typing.cast(typing.Optional["InvokeType"], result)
+
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -8504,6 +10153,158 @@ class BedrockDocumentProcessingProps(BaseDocumentProcessingProps):
         )
 
 
+class BedrockKnowledgeBase(
+    BaseKnowledgeBase,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.BedrockKnowledgeBase",
+):
+    '''(experimental) Amazon Bedrock Knowledge Base implementation.
+
+    This class provides integration with Amazon Bedrock Knowledge Bases,
+    which use vector stores (S3 Vectors by default) for semantic search.
+    It is the default knowledge base implementation when none is specified.
+
+    The implementation handles:
+
+    - ARN construction from knowledge base ID (if ARN not provided)
+    - IAM permission generation for Bedrock Retrieve and RetrieveAndGenerate APIs
+    - Optional guardrail configuration for content filtering
+    - Runtime configuration export for the retrieval tool
+
+    :stability: experimental
+    '''
+
+    def __init__(
+        self,
+        scope: "_constructs_77d1e7e8.Construct",
+        id: builtins.str,
+        *,
+        knowledge_base_id: builtins.str,
+        create: typing.Optional[typing.Union["CreateKnowledgeBaseConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
+        guardrail: typing.Optional[typing.Union["GuardrailConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
+        knowledge_base_arn: typing.Optional[builtins.str] = None,
+        vector_store: typing.Optional[typing.Union["VectorStoreConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
+        description: builtins.str,
+        name: builtins.str,
+        acl: typing.Optional[typing.Union["AclConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
+        retrieval: typing.Optional[typing.Union["RetrievalConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
+    ) -> None:
+        '''(experimental) Creates a new BedrockKnowledgeBase instance.
+
+        :param scope: - The scope in which to define this construct.
+        :param id: - The scoped construct ID.
+        :param knowledge_base_id: (experimental) Unique identifier for the Bedrock Knowledge Base. This is the ID assigned by Bedrock when the knowledge base was created. You can find this in the Bedrock console or via the AWS CLI. Required when referencing an existing knowledge base. Not required when using the ``create`` property to create a new KB.
+        :param create: (experimental) Configuration for creating a new knowledge base. When provided, a new Bedrock Knowledge Base will be created with the specified data source and embedding configuration. Note: This is an advanced feature that creates AWS resources. For most use cases, referencing an existing knowledge base by ID is recommended. Default: - Reference existing KB only (no creation)
+        :param guardrail: (experimental) Guardrail configuration for content filtering. When configured, the guardrail will be applied during retrieval operations to filter inappropriate or sensitive content. Default: - No guardrail applied
+        :param knowledge_base_arn: (experimental) ARN of the Bedrock Knowledge Base. If not provided, the ARN will be constructed from the knowledgeBaseId using the current region and account. Default: - Constructed from knowledgeBaseId
+        :param vector_store: (experimental) Vector store configuration. Defines the type of vector store used by this knowledge base. This is informational and used for generating appropriate IAM permissions when needed. Default: - S3 Vectors (type: 's3-vectors')
+        :param description: (experimental) Description of what this knowledge base contains and when to use it. This description is shown to the agent in its system prompt to help it decide when to query this knowledge base. Be specific about the type of information contained and appropriate use cases.
+        :param name: (experimental) Human-readable name/identifier for this knowledge base. Used for logging, display purposes, and to help the agent identify which knowledge base to query. Should be unique within the set of knowledge bases configured for an agent.
+        :param acl: (experimental) Access control configuration for identity-aware retrieval. When enabled, retrieval queries will be filtered based on user identity context to ensure users only access permitted documents. Default: - ACL disabled
+        :param retrieval: (experimental) Retrieval configuration options. Controls the number of results returned and optional metadata filtering. Default: { numberOfResults: 5 }
+
+        :stability: experimental
+        :throws: Error if knowledgeBaseId is empty or not provided
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__881273bf12c7a325cf85df5cec4c868a102b3e1454218addb9ce294190f2a295)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        props = BedrockKnowledgeBaseProps(
+            knowledge_base_id=knowledge_base_id,
+            create=create,
+            guardrail=guardrail,
+            knowledge_base_arn=knowledge_base_arn,
+            vector_store=vector_store,
+            description=description,
+            name=name,
+            acl=acl,
+            retrieval=retrieval,
+        )
+
+        jsii.create(self.__class__, self, [scope, id, props])
+
+    @jsii.member(jsii_name="exportConfiguration")
+    def export_configuration(self) -> "KnowledgeBaseRuntimeConfig":
+        '''(experimental) Export configuration for runtime use by the retrieval tool.
+
+        Returns a configuration object containing all Bedrock-specific
+        settings needed to query the knowledge base at runtime, including:
+
+        - Base configuration (name, description, retrieval, acl)
+        - Knowledge base type ('bedrock')
+        - Knowledge base ID and ARN
+        - Vector store configuration
+        - Guardrail configuration (if present)
+
+        :return: Runtime configuration object for the retrieval tool
+
+        :stability: experimental
+        '''
+        return typing.cast("KnowledgeBaseRuntimeConfig", jsii.invoke(self, "exportConfiguration", []))
+
+    @jsii.member(jsii_name="generateIamPermissions")
+    def generate_iam_permissions(
+        self,
+    ) -> typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]:
+        '''(experimental) Generate IAM policy statements required for accessing this Bedrock Knowledge Base.
+
+        Returns permissions for:
+
+        - bedrock:Retrieve - Query the knowledge base
+        - bedrock:RetrieveAndGenerate - Query and generate responses
+        - bedrock:ApplyGuardrail - Apply guardrail (if configured)
+        - s3:GetObject - Access S3 vectors (if using S3 Vectors with custom bucket)
+        - s3:GetObject - Access data source bucket (if create config provided)
+
+        All permissions are scoped to the specific knowledge base ARN
+        following the principle of least privilege.
+
+        :return: Array of IAM PolicyStatement objects granting necessary permissions
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"], jsii.invoke(self, "generateIamPermissions", []))
+
+    @jsii.member(jsii_name="retrievalToolAsset")
+    def retrieval_tool_asset(self) -> "_aws_cdk_aws_s3_assets_ceddda9d.Asset":
+        '''(experimental) Provide the Bedrock-specific retrieval tool asset.
+
+        Returns an Asset containing the Python retrieval tool that uses
+        the Amazon Bedrock Agent Runtime API to query knowledge bases.
+        This tool is automatically added to agents that use Bedrock
+        knowledge bases.
+
+        :return: Asset containing the Bedrock retrieval tool
+
+        :stability: experimental
+        '''
+        return typing.cast("_aws_cdk_aws_s3_assets_ceddda9d.Asset", jsii.invoke(self, "retrievalToolAsset", []))
+
+    @builtins.property
+    @jsii.member(jsii_name="knowledgeBaseArn")
+    def knowledge_base_arn(self) -> builtins.str:
+        '''(experimental) The ARN of the Bedrock Knowledge Base.
+
+        If not provided in props, this is constructed from the knowledgeBaseId
+        using the current region and account.
+
+        :stability: experimental
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "knowledgeBaseArn"))
+
+    @builtins.property
+    @jsii.member(jsii_name="knowledgeBaseId")
+    def knowledge_base_id(self) -> builtins.str:
+        '''(experimental) The unique identifier for the Bedrock Knowledge Base.
+
+        This is the ID assigned by Bedrock when the knowledge base was created.
+
+        :stability: experimental
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "knowledgeBaseId"))
+
+
 class AgenticDocumentProcessing(
     BedrockDocumentProcessing,
     metaclass=jsii.JSIIMeta,
@@ -9101,6 +10902,7 @@ class AgenticDocumentProcessingProps(BedrockDocumentProcessingProps):
 __all__ = [
     "AccessLog",
     "AccessLogProps",
+    "AclConfiguration",
     "AdditionalDistributionProps",
     "AgentDefinitionProps",
     "AgentToolsLocationDefinition",
@@ -9112,11 +10914,15 @@ __all__ = [
     "BaseAgentProps",
     "BaseDocumentProcessing",
     "BaseDocumentProcessingProps",
+    "BaseKnowledgeBase",
+    "BaseKnowledgeBaseProps",
     "BatchAgent",
     "BatchAgentProps",
     "BedrockCrossRegionInferencePrefix",
     "BedrockDocumentProcessing",
     "BedrockDocumentProcessingProps",
+    "BedrockKnowledgeBase",
+    "BedrockKnowledgeBaseProps",
     "BedrockModelProps",
     "BedrockModelUtils",
     "ChunkClassificationResult",
@@ -9131,6 +10937,7 @@ __all__ = [
     "CleanupRequest",
     "CleanupResponse",
     "CloudfrontDistributionObservabilityPropertyInjector",
+    "CreateKnowledgeBaseConfiguration",
     "CustomDomainConfig",
     "DataLoader",
     "DataLoaderProps",
@@ -9149,9 +10956,13 @@ __all__ = [
     "FixedPagesConfig",
     "Frontend",
     "FrontendProps",
+    "GuardrailConfiguration",
     "HybridConfig",
     "IAdapter",
+    "IKnowledgeBase",
     "IObservable",
+    "InvokeType",
+    "KnowledgeBaseRuntimeConfig",
     "LambdaIamUtils",
     "LambdaIamUtilsStackInfo",
     "LambdaLogsPermissionsProps",
@@ -9166,9 +10977,11 @@ __all__ = [
     "PowertoolsConfig",
     "QueuedS3Adapter",
     "QueuedS3AdapterProps",
+    "RetrievalConfiguration",
     "StateMachineObservabilityPropertyInjector",
     "TokenAnalysis",
     "TokenBasedConfig",
+    "VectorStoreConfiguration",
 ]
 
 publication.publish()
@@ -9209,6 +11022,14 @@ def _typecheckingstub__b0d5807bf69e9243b9fd452b7437cfe9f4102d78752673f223f3ae140
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__899807b7dca2d7be5f310df5984cd7a0c5fe3c612a8995f0927c15acbec703da(
+    *,
+    enabled: builtins.bool,
+    metadata_field: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__14d3ed5928e5166082cd47a907ab754473c20bb045dc424135b4690811543601(
     *,
     comment: typing.Optional[builtins.str] = None,
@@ -9223,7 +11044,9 @@ def _typecheckingstub__4a2d1deab0cc9bf96473ffb32138a2c564c47ae7382fe5d2d1f0e43da
     *,
     bedrock_model: typing.Union[BedrockModelProps, typing.Dict[builtins.str, typing.Any]],
     system_prompt: _aws_cdk_aws_s3_assets_ceddda9d.Asset,
+    additional_policy_statements_for_knowledge_bases: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
     additional_policy_statements_for_tools: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
+    knowledge_bases: typing.Optional[typing.Sequence[IKnowledgeBase]] = None,
     lambda_layers: typing.Optional[typing.Sequence[_aws_cdk_aws_lambda_ceddda9d.LayerVersion]] = None,
     tools: typing.Optional[typing.Sequence[_aws_cdk_aws_s3_assets_ceddda9d.Asset]] = None,
 ) -> None:
@@ -9278,12 +11101,23 @@ def _typecheckingstub__71b734ed2750632299f59fd7513ccde0ee5f9974b68f8c52b53e2255c
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__40fa4a59f1a0502756f07aba8d6cba5255e1743cbc160af92ff68cb3b17fef23(
+    *,
+    description: builtins.str,
+    name: builtins.str,
+    acl: typing.Optional[typing.Union[AclConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+    retrieval: typing.Optional[typing.Union[RetrievalConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__c2677306b18b77c5114d824ae734b83ac837c5ea4a5b8805948f0388f1dd7995(
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
     *,
     prompt: builtins.str,
     expect_json: typing.Optional[builtins.bool] = None,
+    invoke_type: typing.Optional[InvokeType] = None,
     agent_definition: typing.Union[AgentDefinitionProps, typing.Dict[builtins.str, typing.Any]],
     agent_name: builtins.str,
     enable_observability: typing.Optional[builtins.bool] = None,
@@ -9297,6 +11131,21 @@ def _typecheckingstub__c2677306b18b77c5114d824ae734b83ac837c5ea4a5b8805948f0388f
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__fa5a5937a282e8ddfa91598805b072febd3483c7f6ad9ed8eed9f52e4f0912e9(
+    *,
+    description: builtins.str,
+    name: builtins.str,
+    acl: typing.Optional[typing.Union[AclConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+    retrieval: typing.Optional[typing.Union[RetrievalConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+    knowledge_base_id: builtins.str,
+    create: typing.Optional[typing.Union[CreateKnowledgeBaseConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+    guardrail: typing.Optional[typing.Union[GuardrailConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+    knowledge_base_arn: typing.Optional[builtins.str] = None,
+    vector_store: typing.Optional[typing.Union[VectorStoreConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__e45242c855c6631d66b287b02966cc10c7006e63b282779a6fdb35ce0a2a7a67(
     *,
     cross_region_inference_prefix: typing.Optional[BedrockCrossRegionInferencePrefix] = None,
@@ -9450,6 +11299,18 @@ def _typecheckingstub__2270aedab8c9db027e16b28fd9de8610d0f7e47778cdf1d501539d0e4
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__5a66ad6b4c71f08ad11270f15622825326a8ae23d1f4b8349ee45ee1997ed029(
+    *,
+    data_source_bucket_name: builtins.str,
+    chunking_strategy: typing.Optional[builtins.str] = None,
+    data_source_prefix: typing.Optional[builtins.str] = None,
+    embedding_model_id: typing.Optional[builtins.str] = None,
+    max_tokens: typing.Optional[jsii.Number] = None,
+    overlap_tokens: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__45e622c5dc8075e1ee5cdf9df72ea9b7ca33e0a7cf348dfaf54f93e635e9dde8(
     *,
     certificate: _aws_cdk_aws_certificatemanager_ceddda9d.ICertificate,
@@ -9608,6 +11469,14 @@ def _typecheckingstub__2648a6f2c6f02177f5b324264b7de549aa23b0c1d93c8d6cccbc307a8
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__d604d1407a674dc8a1780469f6fca800816236372c95a3b5438a97e1c9faff32(
+    *,
+    guardrail_id: builtins.str,
+    guardrail_version: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__d99de61f167223b9a43c96878ed271835a461896851550035527119e8b896dfb(
     *,
     max_pages_per_chunk: typing.Optional[jsii.Number] = None,
@@ -9677,6 +11546,21 @@ def _typecheckingstub__17f7e7f35ea8e49cf6ded248435aa1e1dcf416e61c549f3e7b74baad3
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__eba4c5624b16f91d89be2a09eeaf9e99f078cde0dfdfdaa2d50e663d366ce5a1(
+    *,
+    description: builtins.str,
+    name: builtins.str,
+    retrieval: typing.Union[RetrievalConfiguration, typing.Dict[builtins.str, typing.Any]],
+    acl: typing.Optional[typing.Union[AclConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+    guardrail: typing.Optional[typing.Union[GuardrailConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+    knowledge_base_arn: typing.Optional[builtins.str] = None,
+    knowledge_base_id: typing.Optional[builtins.str] = None,
+    type: typing.Optional[builtins.str] = None,
+    vector_store: typing.Optional[typing.Union[VectorStoreConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__8fea74c9846ad0c5bdddcbfe10063247cb7bcf58aac91e0be80d1226246784e4(
     table_arn: builtins.str,
     actions: typing.Optional[typing.Sequence[builtins.str]] = None,
@@ -9947,6 +11831,14 @@ def _typecheckingstub__c2db7ec0d4b3e93062e1f20f29f9821e5a0fd526ecf05f9ccaa6db663
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__0389e881defd6b748c16712149b25f1d6a9c2415742f6287f9424ffee6d97ac9(
+    *,
+    number_of_results: typing.Optional[jsii.Number] = None,
+    retrieval_filter: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__011b55520774139b52c951d9cc59273f686e377b5415ee42a57650da571d43e7(
     original_props: typing.Any,
     *,
@@ -9975,6 +11867,15 @@ def _typecheckingstub__a334bfb54e6a69272a4fe5b2f56f0a97d104fadd629c1aeb6ce670eb3
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__98230924b191ba0192b7d818a592221249c2b38f4ddd572cfc62d08a37b84b42(
+    *,
+    bucket_name: typing.Optional[builtins.str] = None,
+    prefix: typing.Optional[builtins.str] = None,
+    type: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__feb650555d9014f75886d26d16787c0c2e83a042e7e61844bf4d21c890ce479c(
     *,
     log_group_data_protection: typing.Optional[typing.Union[LogGroupDataProtectionProps, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -10038,6 +11939,18 @@ def _typecheckingstub__75e07bce24d48571be58cad69f751b10a17a738fdb9db601acdc689ff
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__1ffdc1300a392d74aedab074831b812725fc7d9f0b3c025e42cefd06be3e3273(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    description: builtins.str,
+    name: builtins.str,
+    acl: typing.Optional[typing.Union[AclConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+    retrieval: typing.Optional[typing.Union[RetrievalConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__30511d5990f52f2808903d144bad5a5c502c00b0b8c98b4fd52a3df61c18b19d(
     *,
     log_group_data_protection: typing.Optional[typing.Union[LogGroupDataProtectionProps, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -10051,6 +11964,7 @@ def _typecheckingstub__30511d5990f52f2808903d144bad5a5c502c00b0b8c98b4fd52a3df61
     removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
     prompt: builtins.str,
     expect_json: typing.Optional[builtins.bool] = None,
+    invoke_type: typing.Optional[InvokeType] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -10121,6 +12035,23 @@ def _typecheckingstub__9606a6418d69bde20176ec33b27eaa22c0e0cdb6b105d382e9d038566
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__881273bf12c7a325cf85df5cec4c868a102b3e1454218addb9ce294190f2a295(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    knowledge_base_id: builtins.str,
+    create: typing.Optional[typing.Union[CreateKnowledgeBaseConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+    guardrail: typing.Optional[typing.Union[GuardrailConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+    knowledge_base_arn: typing.Optional[builtins.str] = None,
+    vector_store: typing.Optional[typing.Union[VectorStoreConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+    description: builtins.str,
+    name: builtins.str,
+    acl: typing.Optional[typing.Union[AclConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+    retrieval: typing.Optional[typing.Union[RetrievalConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__b7f396236f637ec7234d81b355cf773497392b537455f3d888c4b7170ceed70a(
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
@@ -10179,5 +12110,5 @@ def _typecheckingstub__da9ccab0035a06d18b5aa3f2de69201b3bbd6e30f7707a291977a0e4f
     """Type checking stubs"""
     pass
 
-for cls in [IAdapter, IObservable]:
+for cls in [IAdapter, IKnowledgeBase, IObservable]:
     typing.cast(typing.Any, cls).__protocol_attrs__ = typing.cast(typing.Any, cls).__protocol_attrs__ - set(['__jsii_proxy_class__', '__jsii_type__'])