awslabs.cdk-mcp-server 0.0.10417__py3-none-any.whl

awslabs/cdk_mcp_server/static/bedrock/knowledgebases/vector/aurora.md

@@ -0,0 +1,185 @@
+#### Example of `Amazon RDS Aurora PostgreSQL`:
+
+##### TypeScript
+
+```ts
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import { amazonaurora, bedrock } from '@cdklabs/generative-ai-cdk-constructs';
+
+// Dimension of your vector embedding
+embeddingsModelVectorDimension = 1024;
+const auroraDb = new amazonaurora.AmazonAuroraVectorStore(stack, 'AuroraDefaultVectorStore', {
+  embeddingsModelVectorDimension: embeddingsModelVectorDimension,
+});
+
+const kb = new bedrock.VectorKnowledgeBase(this, 'KnowledgeBase', {
+  vectorStore: auroraDb,
+  embeddingsModel: foundation_models.BedrockFoundationModel.TITAN_EMBED_TEXT_V1,
+  instruction: 'Use this knowledge base to answer questions about books. ' + 'It contains the full text of novels.',
+});
+
+const docBucket = new s3.Bucket(this, 'DocBucket');
+
+new bedrock.S3DataSource(this, 'DataSource', {
+  bucket: docBucket,
+  knowledgeBase: kb,
+  dataSourceName: 'books',
+  chunkingStrategy: bedrock.ChunkingStrategy.FIXED_SIZE,
+});
+```
+
+##### Python
+
+```python
+
+from aws_cdk import (
+    aws_s3 as s3,
+    aws_rds as rds,
+    aws_ec2 as ec2,
+    Stack,
+    ArnFormat
+)
+from cdklabs.generative_ai_cdk_constructs import (
+    bedrock,
+    amazonaurora,
+)
+
+# Dimension of your vector embedding
+embeddings_model_vector_dimension = 1024
+aurora_db = amazonaurora.AmazonAuroraVectorStore(self, 'AuroraDefaultVectorStore',
+  embeddings_model_vector_dimension=embeddings_model_vector_dimension
+)
+
+kb = bedrock.VectorKnowledgeBase(self, 'KnowledgeBase',
+  vector_store= aurora_db,
+  embeddings_model= foundation_models.BedrockFoundationModel.TITAN_EMBED_TEXT_V1,
+  instruction=  'Use this knowledge base to answer questions about books. ' +
+'It contains the full text of novels.'
+)
+
+docBucket = s3.Bucket(self, 'DockBucket')
+
+bedrock.S3DataSource(self, 'DataSource',
+  bucket= docBucket,
+  knowledge_base=kb,
+  data_source_name='books',
+  chunking_strategy= bedrock.ChunkingStrategy.FIXED_SIZE,
+)
+
+```
+
+#### Example of importing existing `Amazon RDS Aurora PostgreSQL` using `fromExistingAuroraVectorStore()` method.
+
+**Note** - you need to provide `clusterIdentifier`, `databaseName`, `vpc`, `secret` and `auroraSecurityGroupId` used in deployment of your existing RDS Amazon Aurora DB, as well as `embeddingsModel` that you want to be used by a Knowledge Base for chunking:
+
+##### TypeScript
+
+```ts
+import * as s3 from "aws-cdk-lib/aws-s3";
+import { amazonaurora, bedrock } from '@cdklabs/generative-ai-cdk-constructs';
+
+const auroraDb = aurora.AmazonAuroraVectorStore.fromExistingAuroraVectorStore(stack, 'ExistingAuroraVectorStore', {
+  clusterIdentifier: 'aurora-serverless-vector-cluster',
+  databaseName: 'bedrock_vector_db',
+  schemaName: 'bedrock_integration',
+  tableName: 'bedrock_kb',
+  vectorField: 'embedding',
+  textField: 'chunks',
+  metadataField: 'metadata',
+  primaryKeyField: 'id',
+  embeddingsModel: bedrock.BedrockFoundationModel.COHERE_EMBED_ENGLISH_V3,
+  vpc: cdk.aws_ec2.Vpc.fromLookup(stack, 'VPC', {
+    vpcId: 'vpc-0c1a234567ee8bc90',
+  }),
+  auroraSecurityGroupId: 'sg-012ef345678c98a76',,
+  secret: cdk.aws_rds.DatabaseSecret.fromSecretCompleteArn(
+    stack,
+    'Secret',
+    cdk.Stack.of(stack).formatArn({
+      service: 'secretsmanager',
+      resource: 'secret',
+      resourceName: 'rds-db-credentials/cluster-1234567890',
+      region: cdk.Stack.of(stack).region,
+      account: cdk.Stack.of(stack).account,
+      arnFormat: cdk.ArnFormat.COLON_RESOURCE_NAME,
+    }),
+  ),
+});
+
+const kb = new bedrock.VectorKnowledgeBase(this, "KnowledgeBase", {
+  vectorStore: auroraDb,
+  embeddingsModel: bedrock.BedrockFoundationModel.COHERE_EMBED_ENGLISH_V3,
+  instruction:
+    "Use this knowledge base to answer questions about books. " +
+    "It contains the full text of novels.",
+});
+
+const docBucket = new s3.Bucket(this, "DocBucket");
+
+new bedrock.S3DataSource(this, "DataSource", {
+  bucket: docBucket,
+  knowledgeBase: kb,
+  dataSourceName: "books",
+  chunkingStrategy: bedrock.ChunkingStrategy.FIXED_SIZE,
+});
+```
+
+##### Python
+
+```python
+
+from aws_cdk import (
+    aws_s3 as s3,
+    aws_rds as rds,
+    aws_ec2 as ec2,
+    Stack,
+    ArnFormat
+)
+from cdklabs.generative_ai_cdk_constructs import (
+    bedrock,
+    amazonaurora,
+)
+
+aurora_db = amazonaurora.AmazonAuroraVectorStore.from_existing_aurora_vector_store(
+    self, 'ExistingAuroraVectorStore',
+    cluster_identifier='aurora-serverless-vector-cluster',
+    database_name='bedrock_vector_db',
+    schema_name='bedrock_integration',
+    table_name='bedrock_kb',
+    vector_field='embedding',
+    text_field='chunks',
+    metadata_field='metadata',
+    primary_key_field='id',
+    embeddings_model=bedrock.BedrockFoundationModel.COHERE_EMBED_ENGLISH_V3,
+    vpc=ec2.Vpc.from_lookup(self, 'VPC', vpc_id='vpc-0c1a234567ee8bc90'),
+    aurora_security_group_id='sg-012ef345678c98a76',,
+    secret=rds.DatabaseSecret.from_secret_complete_arn(
+        self,
+        'Secret',
+        Stack.of(self).format_arn(
+            service= 'secretsmanager',
+            resource= 'secret',
+            resource_name= 'rds-db-credentials/cluster-1234567890',
+            region= Stack.of(self).region,
+            account= Stack.of(self).account,
+            arn_format= ArnFormat.COLON_RESOURCE_NAME
+        )
+    )
+)
+
+kb = bedrock.VectorKnowledgeBase(self, 'KnowledgeBase',
+            vector_store= aurora_db,
+            embeddings_model= bedrock.BedrockFoundationModel.COHERE_EMBED_ENGLISH_V3,
+            instruction=  'Use this knowledge base to answer questions about books. ' +
+    'It contains the full text of novels.'
+        )
+
+docBucket = s3.Bucket(self, 'DockBucket')
+
+bedrock.S3DataSource(self, 'DataSource',
+    bucket= docBucket,
+    knowledge_base=kb,
+    data_source_name='books',
+    chunking_strategy= bedrock.ChunkingStrategy.FIXED_SIZE,
+)
+```

awslabs/cdk_mcp_server/static/bedrock/knowledgebases/vector/creation.md

@@ -0,0 +1,80 @@
+# Vector Knowledge Base Properties
+
+| Name | Type | Required | Description |
+|---|---|---|---|
+| embeddingsModel | BedrockFoundationModel | Yes | The embeddings model for the knowledge base |
+| name | string | No | The name of the knowledge base |
+| vectorType | VectorType | No | The vector type to store vector embeddings |
+| description | string | No | The description of the knowledge base |
+| instruction | string | No | Instructions for agents based on the design and type of information of the Knowledge Base that will impact how Agents interact with the Knowledge Base |
+| existingRole | iam.IRole | No | Existing IAM role with a policy statement granting permission to invoke the specific embeddings model |
+| indexName | string | No | The name of the vector index (only applicable if vectorStore is of type VectorCollection) |
+| vectorField | string | No | The name of the field in the vector index (only applicable if vectorStore is of type VectorCollection) |
+| vectorStore | VectorCollection \| PineconeVectorStore \| AmazonAuroraVectorStore \| ExistingAmazonAuroraVectorStore | No | The vector store for the knowledge base |
+| vectorIndex | VectorIndex | No | The vector index for the OpenSearch Serverless backed knowledge base |
+| knowledgeBaseState | string | No | Specifies whether to use the knowledge base or not when sending an InvokeAgent request |
+| tags | Record<string, string> | No | Tag (KEY-VALUE) bedrock agent resource |
+
+
+### Vector Knowledge Base - Vector Type
+
+The data type for the vectors when using a model to convert text into vector embeddings. Embeddings type may impact the availability of some embeddings models and vector stores. The following vector types are available:
+
+- Floating point: More precise vector representation of the text, but more costly in storage.
+- Binary: Not as precise vector representation of the text, but not as costly in storage as a standard floating-point (float32). Not all embedding models and vector stores support binary embeddings
+
+See [Supported embeddings models](https://docs.aws.amazon.com/bedrock/latest/userguide/knowledge-base-supported.html) for information on the available models and their vector data types.
+
+#### Example
+
+##### Typescript
+
+```ts
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'aws-cdk-bedrock-data-sources-integ-test');
+
+const kb = new VectorKnowledgeBase(stack, 'MyKnowledgeBase', {
+  name: 'MyKnowledgeBase',
+  vectorType: bedrock.VectorType.BINARY,
+  embeddingsModel: BedrockFoundationModel.COHERE_EMBED_MULTILINGUAL_V3,
+});
+```
+
+##### Python
+
+```python
+
+from aws_cdk import (
+    aws_s3 as s3,
+)
+from cdklabs.generative_ai_cdk_constructs import (
+    bedrock
+)
+
+kb = bedrock.VectorKnowledgeBase(self, 'KnowledgeBase',
+    name= 'MyKnowledgeBase',
+    vector_type= bedrock.VectorType.BINARY,
+    embeddings_model= bedrock.BedrockFoundationModel.COHERE_EMBED_MULTILINGUAL_V3,
+)
+```
+
+### Vector Knowledge Base - Data Sources
+
+Data sources are the various repositories or systems from which information is extracted and ingested into the
+knowledge base. These sources provide the raw content that will be processed, indexed, and made available for
+querying within the knowledge base system. Data sources can include various types of systems such as document
+management systems, databases, file storage systems, and content management platforms. Suuported Data Sources
+include Amazon S3 buckets, Web Crawlers, SharePoint sites, Salesforce instances, and Confluence spaces.
+
+- **Amazon S3**. You can either create a new data source using the `bedrock.S3DataSource(..)` class, or using the
+  `kb.addS3DataSource(..)`.
+- **Web Crawler**. You can either create a new data source using the `bedrock.WebCrawlerDataSource(..)` class, or using the
+  `kb.addWebCrawlerDataSource(..)`.
+- **Confluence**. You can either create a new data source using the `bedrock.ConfluenceDataSource(..)` class, or using the
+  `kb.addConfluenceDataSource(..)`.
+- **SharePoint**. You can either create a new data source using the `bedrock.SharePointDataSource(..)` class, or using the
+  `kb.addSharePointDataSource(..)`.
+- **Salesforce**. You can either create a new data source using the `bedrock.SalesforceDataSource(..)` class, or using the
+  `kb.addSalesforceDataSource(..)`.
+- **Custom**. You can either create a new data source using the `bedrock.CustomDataSource(..)` class, or using the
+  `kb.addCustomDataSource(..)`. This allows you to add your own custom data source to the knowledge base.

awslabs/cdk_mcp_server/static/bedrock/knowledgebases/vector/opensearch.md

@@ -0,0 +1,56 @@
+
+# OpenSearch Serverless Vector Store
+
+## Example
+
+### TypeScript
+
+```ts
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import { bedrock } from '@cdklabs/generative-ai-cdk-constructs';
+
+const kb = new bedrock.VectorKnowledgeBase(this, 'KnowledgeBase', {
+  embeddingsModel: bedrock.BedrockFoundationModel.TITAN_EMBED_TEXT_V1,
+  instruction: 'Use this knowledge base to answer questions about books. ' + 'It contains the full text of novels.',
+});
+
+const docBucket = new s3.Bucket(this, 'DocBucket');
+
+new bedrock.S3DataSource(this, 'DataSource', {
+  bucket: docBucket,
+  knowledgeBase: kb,
+  dataSourceName: 'books',
+  chunkingStrategy: bedrock.ChunkingStrategy.fixedSize({
+    maxTokens: 500,
+    overlapPercentage: 20,
+  }),
+});
+```
+
+### Python
+
+```python
+
+from aws_cdk import (
+    aws_s3 as s3,
+)
+from cdklabs.generative_ai_cdk_constructs import (
+    bedrock
+)
+
+kb = bedrock.VectorKnowledgeBase(self, 'KnowledgeBase',
+            embeddings_model= bedrock.BedrockFoundationModel.TITAN_EMBED_TEXT_V1,
+            instruction=  'Use this knowledge base to answer questions about books. ' +
+    'It contains the full text of novels.'
+        )
+
+docBucket = s3.Bucket(self, 'DockBucket')
+
+bedrock.S3DataSource(self, 'DataSource',
+    bucket= docBucket,
+    knowledge_base=kb,
+    data_source_name='books',
+    chunking_strategy= bedrock.ChunkingStrategy.FIXED_SIZE,
+)
+
+```

awslabs/cdk_mcp_server/static/bedrock/knowledgebases/vector/pinecone.md

@@ -0,0 +1,66 @@
+#### Example of `Pinecone` (manual, you must have Pinecone vector store created):
+
+##### TypeScript
+
+```ts
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import { pinecone, bedrock } from '@cdklabs/generative-ai-cdk-constructs';
+
+const pineconeds = new pinecone.PineconeVectorStore({
+  connectionString: 'https://your-index-1234567.svc.gcp-starter.pinecone.io',
+  credentialsSecretArn: 'arn:aws:secretsmanager:your-region:123456789876:secret:your-key-name',
+  textField: 'question',
+  metadataField: 'metadata',
+});
+
+const kb = new bedrock.VectorKnowledgeBase(this, 'KnowledgeBase', {
+  vectorStore: pineconeds,
+  embeddingsModel: bedrock.BedrockFoundationModel.TITAN_EMBED_TEXT_V1,
+  instruction: 'Use this knowledge base to answer questions about books. ' + 'It contains the full text of novels.',
+});
+
+const docBucket = new s3.Bucket(this, 'DocBucket');
+
+new bedrock.S3DataSource(this, 'DataSource', {
+  bucket: docBucket,
+  knowledgeBase: kb,
+  dataSourceName: 'books',
+  chunkingStrategy: bedrock.ChunkingStrategy.FIXED_SIZE,
+});
+```
+
+##### Python
+
+```python
+
+from aws_cdk import (
+    aws_s3 as s3,
+)
+from cdklabs.generative_ai_cdk_constructs import (
+    bedrock,
+    pinecone,
+)
+
+pineconevs = pinecone.PineconeVectorStore(
+            connection_string='https://your-index-1234567.svc.gcp-starter.pinecone.io',
+            credentials_secret_arn='arn:aws:secretsmanager:your-region:123456789876:secret:your-key-name',
+            text_field='question',
+            metadata_field='metadata'
+        )
+
+kb = bedrock.VectorKnowledgeBase(self, 'KnowledgeBase',
+            vector_store= pineconevs,
+            embeddings_model= bedrock.BedrockFoundationModel.COHERE_EMBED_ENGLISH_V3,
+            instruction=  'Use this knowledge base to answer questions about books. ' +
+    'It contains the full text of novels.'
+        )
+
+docBucket = s3.Bucket(self, 'DockBucket')
+
+bedrock.S3DataSource(self, 'DataSource',
+    bucket= docBucket,
+    knowledge_base=kb,
+    data_source_name='books',
+    chunking_strategy= bedrock.ChunkingStrategy.FIXED_SIZE,
+)
+```

awslabs/cdk_mcp_server/static/bedrock/profiles.md

@@ -0,0 +1,153 @@
+# Bedrock Inference Profiles
+
+## System Defined Inference Profiles
+
+You can build a CrossRegionInferenceProfile using a system defined inference profile. The inference profile will route requests to the Regions defined in the cross region (system-defined) inference profile that you choose. You can find the system defined inference profiles by navigating to your console (Amazon Bedrock -> Cross-region inference) or programmatically, for instance using [boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/bedrock/client/list_inference_profiles.html).
+
+Before using creating a CrossRegionInferenceProfile, ensure that you have access to the models and regions defined in the inference profiles. For instance, if you see the system defined inference profile "us.anthropic.claude-3-5-sonnet-20241022-v2:0" defined in your region, the table mentions that inference requests will be routed to US East (Virginia) us-east-1, US East (Ohio) us-east-2 and US West (Oregon) us-west-2. Thus, you need to have model access enabled in those regions for the model `anthropic.claude-3-5-sonnet-20241022-v2:0`. You can then create the CrossRegionInferenceProfile as follows:
+
+### Examples
+
+#### TypeScript
+
+```ts
+const cris = bedrock.CrossRegionInferenceProfile.fromConfig({
+  geoRegion: bedrock.CrossRegionInferenceProfileRegion.US,
+  model: bedrock.BedrockFoundationModel.ANTHROPIC_CLAUDE_3_5_SONNET_V2_0,
+});
+```
+
+#### Python
+
+```python
+cris = bedrock.CrossRegionInferenceProfile.from_config(
+  geo_region= bedrock.CrossRegionInferenceProfileRegion.US,
+  model= bedrock.BedrockFoundationModel.ANTHROPIC_CLAUDE_3_5_SONNET_V2_0
+)
+```
+
+[View full documentation](https://github.com/awslabs/generative-ai-cdk-constructs/tree/main/src/cdk-lib/bedrock#system-defined-inference-profiles)
+
+## Application Inference Profile
+
+You can create an application inference profile with one or more Regions to track usage and costs when invoking a model.
+
+To create an application inference profile for one Region, specify a foundation model. Usage and costs for requests made to that Region with that model will be tracked.
+
+To create an application inference profile for multiple Regions, specify a cross region (system-defined) inference profile. The inference profile will route requests to the Regions defined in the cross region (system-defined) inference profile that you choose. Usage and costs for requests made to the Regions in the inference profile will be tracked. You can find the system defined inference profiles by navigating to your console (Amazon Bedrock -> Cross-region inference) or programmatically, for instance using [boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/bedrock/client/list_inference_profiles.html):
+
+```
+bedrock = session.client("bedrock", region_name="us-east-1")
+bedrock.list_inference_profiles(typeEquals='SYSTEM_DEFINED')
+```
+
+Before using application inference profiles, ensure that:
+
+- You have appropriate IAM permissions
+- You have access to the models and regions defined in the inference profiles
+- Ensure proper configuration of the required API permissions for inference profile-related actions
+
+Specifically the role you are assuming needs to have permissions for following actions in the IAM policy
+
+```
+"Action": [
+      "bedrock:GetInferenceProfile",
+      "bedrock:ListInferenceProfiles",
+      "bedrock:DeleteInferenceProfile"
+      "bedrock:TagResource",
+      "bedrock:UntagResource",
+      "bedrock:ListTagsForResource"
+  ]
+```
+
+You can restrict to specific resources by applying "Resources" tag in the IAM policy.
+
+```
+"Resource": ["arn:aws:bedrock:*:*:application-inference-profile/*"]
+```
+
+### Examples
+
+#### TypeScript
+
+```ts
+// Create an application inference profile for one Region
+// You can use the 'bedrock.BedrockFoundationModel' or pass the arn as a string
+const appInfProfile1 = new ApplicationInferenceProfile(this, 'myapplicationprofile', {
+  inferenceProfileName: 'claude 3 sonnet v1',
+  modelSource: bedrock.BedrockFoundationModel.ANTHROPIC_CLAUDE_SONNET_V1_0,
+  tags: [{ key: 'test', value: 'test' }],
+});
+
+// To create an application inference profile across regions, specify the cross region inference profile
+const cris = bedrock.CrossRegionInferenceProfile.fromConfig({
+  geoRegion: bedrock.CrossRegionInferenceProfileRegion.US,
+  model: bedrock.BedrockFoundationModel.ANTHROPIC_CLAUDE_3_5_SONNET_V2_0,
+});
+
+const appInfProfile2 = new ApplicationInferenceProfile(this, 'myapplicationprofile2', {
+  inferenceProfileName: 'claude 3 sonnet v1',
+  modelSource: cris,
+});
+
+// Import a Cfn L1 construct created application inference profile
+const cfnapp = new CfnApplicationInferenceProfile(this, 'mytestaip3', {
+  inferenceProfileName: 'mytest',
+  modelSource: {
+    copyFrom: 'arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-3-sonnet-20240229-v1:0',
+  },
+});
+
+const appInfProfile3 = bedrock.ApplicationInferenceProfile.fromCfnApplicationInferenceProfile(cfnapp);
+
+// Import an inference profile through attributes
+const appInfProfile4 = bedrock.ApplicationInferenceProfile.fromApplicationInferenceProfileAttributes(this, 'TestAIP', {
+  inferenceProfileArn: 'arn:aws:bedrock:us-east-1:XXXXX:application-inference-profile/ID',
+  inferenceProfileIdentifier: 'arn:aws:bedrock:us-east-1:XXXXXXX:application-inference-profile/ID',
+});
+```
+
+#### Python
+
+```python
+
+# Create an application inference profile for one Region
+# You can use the 'bedrock.BedrockFoundationModel' or pass the arn as a string
+appInfProfile1 = bedrock.ApplicationInferenceProfile(self, 'myapplicationprofile',
+  inference_profile_name='claude 3 sonnet v1',
+  model_source=bedrock.BedrockFoundationModel.ANTHROPIC_CLAUDE_SONNET_V1_0,
+  tags=[CfnTag(
+    key="key",
+    value="value"
+  )]
+)
+
+# To create an application inference profile across regions, specify the cross region inference profile
+cris = bedrock.CrossRegionInferenceProfile.from_config(
+  geo_region= bedrock.CrossRegionInferenceProfileRegion.US,
+  model= bedrock.BedrockFoundationModel.ANTHROPIC_CLAUDE_3_5_SONNET_V2_0
+)
+
+appInfProfile2 = bedrock.ApplicationInferenceProfile(self, 'myapplicationprofile2',
+  inference_profile_name='claude 35 sonnet v2',
+  model_source=cris
+)
+
+# Import an inference profile through attributes
+appInfProfile3 = bedrock.ApplicationInferenceProfile.from_application_inference_profile_attributes(self, 'TestAIP',
+  inference_profile_arn='arn:aws:bedrock:us-east-1:XXXXX:application-inference-profile/ID',
+  inference_profile_identifier='arn:aws:bedrock:us-east-1:XXXXXXX:application-inference-profile/ID',
+)
+
+# Import a Cfn L1 construct created application inference profile
+cfnaip = CfnApplicationInferenceProfile(this, 'mytestaip4',
+  inference_profile_name='mytest',
+  model_source= CfnApplicationInferenceProfile.InferenceProfileModelSourceProperty(
+    copy_from='arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-3-sonnet-20240229-v1:0'
+  ),
+)
+
+appInfProfile4 = bedrock.ApplicationInferenceProfile.from_cfn_application_inference_profile(cfnaip);
+```
+
+[View full documentation](https://github.com/awslabs/generative-ai-cdk-constructs/tree/main/src/cdk-lib/bedrock#application-inference-profile)

awslabs/cdk_mcp_server/static/genai_cdk/bedrock/agent/actiongroups.md

@@ -0,0 +1,137 @@
+# Action Groups
+
+## Overview
+
+Action groups define functions your agent can call, connecting Bedrock Agents to your business logic via Lambda functions. The agent uses an OpenAPI schema to understand what your functions do and how to call them.
+
+```mermaid
+graph LR
+    A[Agent] --> B[Action Group]
+    B --> C[Lambda Function]
+    B --> D[OpenAPI Schema]
+```
+
+## Action Group Properties
+
+| Name | Type | Required | Description |
+|---|---|---|---|
+| name | string | Yes | The name of the action group |
+| description | string | No | A description of the action group |
+| apiSchema | ApiSchema | No | The API Schema |
+| executor | ActionGroupExecutor | No | The action group executor |
+| enabled | boolean | No | Specifies whether the action group is available for the agent to invoke or not when sending an InvokeAgent request. Defaults to true |
+| forceDelete | boolean | No | Specifies whether to delete the resource even if it's in use. Defaults to false |
+| functionSchema | CfnAgent.FunctionSchemaProperty | No | Defines functions that each define parameters that the agent needs to invoke from the user |
+| parentActionGroupSignature | ParentActionGroupSignature | No | The AWS Defined signature for enabling certain capabilities in your agent. When specified, description, apiSchema, and actionGroupExecutor must be blank |
+
+## OpenAPI Schema Generation & Best Practices
+
+For Action Groups, use the built-in OpenAPI schema generation tool provided by the AWS CDK MCP server:
+
+```typescript
+// Using MCP client
+const result = await use_mcp_tool({
+  server_name: "awslabs.cdk-mcp-server",
+  tool_name: "GenerateBedrockAgentSchemaFromFile",
+  arguments: {
+    lambda_code_path: "path/to/your/lambda.py",
+    output_path: "path/to/output/openapi.json"
+  }
+});
+```
+
+The tool will:
+
+1. Parse your Lambda function code
+2. Extract function signatures and docstrings
+3. Generate a Bedrock-compatible OpenAPI schema
+4. Save it to the specified output path
+
+### Key Requirements
+- Ensure each operation has a unique operationId
+- Define complete response schemas
+- Use `fromLocalAsset` (not `fromAsset`) for API schemas
+- Include detailed descriptions for all endpoints, parameters, and return values
+- Use proper type annotations with Python type hints
+
+### Lambda Function Example
+
+```python
+from aws_lambda_powertools.event_handler import BedrockAgentResolver
+from typing import Annotated, List
+from aws_lambda_powertools.event_handler.openapi.params import Query, Path
+from pydantic import BaseModel, Field
+
+app = BedrockAgentResolver()
+
+class Product(BaseModel):
+    product_id: str = Field(description="Unique product identifier")
+    name: str = Field(description="Product name")
+    price: float = Field(description="Product price in USD")
+
+@app.get("/products", description="List available products")
+def list_products(
+    category: Annotated[str, Query(description="Product category")] = None
+) -> List[Product]:
+    # Your business logic here
+    return [Product(product_id="1", name="Product A", price=19.99)]
+
+def lambda_handler(event, context):
+    return app.resolve(event, context)
+```
+
+## Examples
+
+### TypeScript
+
+```ts
+const actionGroupFunction = new lambda_python.PythonFunction(this, 'ActionGroupFunction', {
+  runtime: lambda.Runtime.PYTHON_3_12,
+  entry: path.join(__dirname, '../lambda/action-group'),
+});
+
+// Example of proper Action Group setup with fromLocalAsset
+const actionGroup = new AgentActionGroup({
+  name: 'query-library',
+  description: 'Use these functions to get information about the books in the library.',
+  executor: bedrock.ActionGroupExecutor.fromlambdaFunction(actionGroupFunction),
+  enabled: true,
+  apiSchema: bedrock.ApiSchema.fromLocalAsset(path.join(__dirname, 'action-group.yaml')),
+});
+
+agent.addActionGroup(actionGroup);
+
+// Real-world example with account actions
+const agentAccountActions = new AgentActionGroup({
+  name: "agent-account-actions",
+  description: "Use these functions to take actions on authenticated user's accounts",
+  executor: bedrock.ActionGroupExecutor.fromlambdaFunction(accountActionsLambda),
+  apiSchema: bedrock.ApiSchema.fromLocalAsset(
+    path.join(agentsLambdaDir, "account_actions", "openapi.json"),
+  ),
+});
+
+agent.addActionGroup(agentAccountActions);
+```
+
+### Python
+
+```python
+action_group_function = PythonFunction(
+            self,
+            "LambdaFunction",
+            runtime=Runtime.PYTHON_3_12,
+            entry="./lambda",
+            index="app.py",
+            handler="lambda_handler",
+)
+
+actionGroup = bedrock.AgentActionGroup(
+    name="query-library",
+    description="Use these functions to get information about the books in the library.",
+    executor= bedrock.ActionGroupExecutor.fromlambda_function(action_group_function),
+    enabled=True,
+    api_schema=bedrock.ApiSchema.from_local_asset("action-group.yaml"))
+
+agent.add_action_group(actionGroup)
+```