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

awslabs/cdk_mcp_server/static/bedrock/knowledgebases/chunking.md

@@ -0,0 +1,137 @@
+# Vector Knowledge Base - Chunking Strategies
+
+## Available Strategies
+
+### Default Chunking
+
+Applies Fixed Chunking with the default chunk size of 300 tokens and 20% overlap.
+
+#### TypeScript
+
+```ts
+ChunkingStrategy.DEFAULT;
+```
+
+#### Python
+
+```python
+ChunkingStrategy.DEFAULT
+```
+
+### Fixed Size Chunking
+
+This method divides the data into fixed-size chunks, with each chunk
+containing a predetermined number of tokens. This strategy is useful when the data is uniform
+in size and structure.
+
+#### TypeScript
+
+```ts
+// Fixed Size Chunking with sane defaults.
+ChunkingStrategy.FIXED_SIZE;
+
+// Fixed Size Chunking with custom values.
+ChunkingStrategy.fixedSize({ maxTokens: 200, overlapPercentage: 25 });
+```
+
+#### Python
+
+```python
+# Fixed Size Chunking with sane defaults.
+ChunkingStrategy.FIXED_SIZE
+
+# Fixed Size Chunking with custom values.
+ChunkingStrategy.fixed_size(
+  max_tokens= 200,
+  overlap_percentage= 25
+)
+```
+
+### Hierarchical Chunking
+
+This strategy organizes data into layers of chunks, with the first
+layer containing large chunks and the second layer containing smaller chunks derived from the first.
+It is ideal for data with inherent hierarchies or nested structures.
+
+#### TypeScript
+
+```ts
+// Hierarchical Chunking with the default for Cohere Models.
+ChunkingStrategy.HIERARCHICAL_COHERE;
+
+// Hierarchical Chunking with the default for Titan Models.
+ChunkingStrategy.HIERARCHICAL_TITAN;
+
+// Hierarchical Chunking with custom values. Tthe maximum chunk size depends on the model.
+// Amazon Titan Text Embeddings: 8192. Cohere Embed models: 512
+ChunkingStrategy.hierarchical({
+  overlapTokens: 60,
+  maxParentTokenSize: 1500,
+  maxChildTokenSize: 300,
+});
+```
+
+#### Python
+
+```python
+# Hierarchical Chunking with the default for Cohere Models.
+ChunkingStrategy.HIERARCHICAL_COHERE
+
+# Hierarchical Chunking with the default for Titan Models.
+ChunkingStrategy.HIERARCHICAL_TITAN
+
+# Hierarchical Chunking with custom values. Tthe maximum chunk size depends on the model.
+# Amazon Titan Text Embeddings: 8192. Cohere Embed models: 512
+chunking_strategy= ChunkingStrategy.hierarchical(
+    overlap_tokens=60,
+    max_parent_token_size=1500,
+    max_child_token_size=300
+)
+```
+
+### Semantic Chunking
+
+This method splits data into smaller documents based on groups of similar
+content derived from the text using natural language processing. It helps preserve contextual
+relationships and ensures accurate and contextually appropriate results.
+
+#### TypeScript
+
+```ts
+// Semantic Chunking with sane defaults.
+ChunkingStrategy.SEMANTIC;
+
+// Semantic Chunking with custom values.
+ChunkingStrategy.semantic({ bufferSize: 0, breakpointPercentileThreshold: 95, maxTokens: 300 });
+```
+
+#### Python
+
+```python
+# Semantic Chunking with sane defaults.
+ChunkingStrategy.SEMANTIC
+
+# Semantic Chunking with custom values.
+ChunkingStrategy.semantic(
+  buffer_size=0,
+  breakpoint_percentile_threshold=95,
+  max_tokens=300
+)
+```
+
+### No Chunking
+
+This strategy treats each file as one chunk. If you choose this option,
+you may want to pre-process your documents by splitting them into separate files.
+
+#### TypeScript
+
+```ts
+ChunkingStrategy.NONE;
+```
+
+#### Python
+
+```python
+ChunkingStrategy.NONE
+```

awslabs/cdk_mcp_server/static/bedrock/knowledgebases/datasources.md

@@ -0,0 +1,225 @@
+# Knowledge Base Data Sources
+
+## Overview
+
+This document provides examples of adding various data sources to a Knowledge Base in Amazon Bedrock.
+
+## 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',
+  embeddingsModel: BedrockFoundationModel.COHERE_EMBED_MULTILINGUAL_V3,
+});
+
+const bucket = new Bucket(stack, 'Bucket', {});
+const lambdaFunction = new Function(stack, 'MyFunction', {
+  runtime: cdk.aws_lambda.Runtime.PYTHON_3_9,
+  handler: 'index.handler',
+  code: cdk.aws_lambda.Code.fromInline('print("Hello, World!")'),
+});
+
+const secret = new Secret(stack, 'Secret');
+const key = new Key(stack, 'Key');
+
+kb.addWebCrawlerDataSource({
+  sourceUrls: ['https://docs.aws.amazon.com/'],
+  chunkingStrategy: ChunkingStrategy.HIERARCHICAL_COHERE,
+  customTransformation: CustomTransformation.lambda({
+    lambdaFunction: lambdaFunction,
+    s3BucketUri: `s3://${bucket.bucketName}/chunk-processor/`,
+  }),
+});
+
+kb.addS3DataSource({
+  bucket,
+  chunkingStrategy: ChunkingStrategy.SEMANTIC,
+  parsingStrategy: ParsingStategy.foundationModel({
+    model: BedrockFoundationModel.ANTHROPIC_CLAUDE_SONNET_V1_0,
+  }),
+});
+
+kb.addConfluenceDataSource({
+  dataSourceName: 'TestDataSource',
+  authSecret: secret,
+  kmsKey: key,
+  confluenceUrl: 'https://example.atlassian.net',
+  filters: [
+    {
+      objectType: ConfluenceObjectType.ATTACHMENT,
+      includePatterns: ['.*\\.pdf'],
+      excludePatterns: ['.*private.*\\.pdf'],
+    },
+    {
+      objectType: ConfluenceObjectType.PAGE,
+      includePatterns: ['.*public.*\\.pdf'],
+      excludePatterns: ['.*confidential.*\\.pdf'],
+    },
+  ],
+});
+
+kb.addSalesforceDataSource({
+  authSecret: secret,
+  endpoint: 'https://your-instance.my.salesforce.com',
+  kmsKey: key,
+  filters: [
+    {
+      objectType: SalesforceObjectType.ATTACHMENT,
+      includePatterns: ['.*\\.pdf'],
+      excludePatterns: ['.*private.*\\.pdf'],
+    },
+    {
+      objectType: SalesforceObjectType.CONTRACT,
+      includePatterns: ['.*public.*\\.pdf'],
+      excludePatterns: ['.*confidential.*\\.pdf'],
+    },
+  ],
+});
+
+kb.addSharePointDataSource({
+  dataSourceName: 'SharepointDataSource',
+  authSecret: secret,
+  kmsKey: key,
+  domain: 'yourdomain',
+  siteUrls: ['https://yourdomain.sharepoint.com/sites/mysite'],
+  tenantId: '888d0b57-69f1-4fb8-957f-e1f0bedf64de',
+  filters: [
+    {
+      objectType: SharePointObjectType.PAGE,
+      includePatterns: ['.*\\.pdf'],
+      excludePatterns: ['.*private.*\\.pdf'],
+    },
+    {
+      objectType: SharePointObjectType.FILE,
+      includePatterns: ['.*public.*\\.pdf'],
+      excludePatterns: ['.*confidential.*\\.pdf'],
+    },
+  ],
+});
+
+kb.addCustomDataSource({
+  dataSourceName: 'CustomDataSource',
+  chunkingStrategy: ChunkingStrategy.FIXED_SIZE,
+});
+```
+
+### Python
+
+```python
+from aws_cdk import (
+    Stack,
+    aws_s3 as s3,
+    aws_lambda as _lambda,
+    aws_secretsmanager as secretsmanager,
+    aws_kms as kms
+)
+from constructs import Construct
+from cdklabs.generative_ai_cdk_constructs import (
+    bedrock
+)
+
+class PythonTestStack(Stack):
+
+    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
+        super().__init__(scope, construct_id, **kwargs)
+
+        kb = bedrock.VectorKnowledgeBase(self, 'MyKnowledgeBase',
+                    embeddings_model= bedrock.BedrockFoundationModel.COHERE_EMBED_MULTILINGUAL_V3,
+                )
+
+        docBucket = s3.Bucket(self, 'Bucket')
+
+        function = _lambda.Function(self, 'MyFunction',
+            runtime=_lambda.Runtime.PYTHON_3_12,
+            handler='index.handler',
+            code=_lambda.Code.from_inline('print("Hello, World!")'),
+        )
+
+        kb.add_web_crawler_data_source(
+            source_urls= ['https://docs.aws.amazon.com/'],
+            chunking_strategy= bedrock.ChunkingStrategy.HIERARCHICAL_COHERE,
+            custom_transformation= bedrock.CustomTransformation.lambda_(
+                lambda_function= function,
+                s3_bucket_uri= f's3://{docBucket.bucket_name}/chunk-processor/'
+            )
+        )
+
+        kb.add_s3_data_source(
+            bucket= docBucket,
+            chunking_strategy= bedrock.ChunkingStrategy.SEMANTIC,
+            parsing_strategy= bedrock.ParsingStategy.foundation_model(
+                parsing_model= bedrock.BedrockFoundationModel.ANTHROPIC_CLAUDE_SONNET_V1_0.as_i_model(self)
+            )
+        )
+
+        secret = secretsmanager.Secret(self, 'Secret')
+        key = kms.Key(self, 'Key')
+
+        kb.add_confluence_data_source(
+            data_source_name='TestDataSource',
+            auth_secret=secret,
+            kms_key=key,
+            confluence_url='https://example.atlassian.net',
+            filters=[
+                bedrock.ConfluenceCrawlingFilters(
+                    object_type=bedrock.ConfluenceObjectType.ATTACHMENT,
+                    include_patterns= [".*\\.pdf"],
+                    exclude_patterns= [".*private.*\\.pdf"],
+                ),
+                bedrock.ConfluenceCrawlingFilters(
+                    object_type=bedrock.ConfluenceObjectType.PAGE,
+                    include_patterns= [".*public.*\\.pdf"],
+                    exclude_patterns= [".*confidential.*\\.pdf"],
+                ),
+            ]
+        )
+
+        kb.add_salesforce_data_source(
+            auth_secret=secret,
+            endpoint='https://your-instance.my.salesforce.com',
+            kms_key=key,
+            filters=[
+                bedrock.SalesforceCrawlingFilters(
+                    object_type=bedrock.SalesforceObjectType.ATTACHMENT,
+                    include_patterns= [".*\\.pdf"],
+                    exclude_patterns= [".*private.*\\.pdf"],
+                ),
+                bedrock.SalesforceCrawlingFilters(
+                    object_type=bedrock.SalesforceObjectType.CONTRACT,
+                    include_patterns= [".*public.*\\.pdf"],
+                    exclude_patterns= [".*confidential.*\\.pdf"],
+                ),
+            ]
+        )
+
+        kb.add_share_point_data_source(
+            data_source_name='SharepointDataSource',
+            auth_secret=secret,
+            kms_key=key,
+            domain='yourDomain',
+            site_urls= ['https://yourdomain.sharepoint.com/sites/mysite'],
+            tenant_id='888d0b57-69f1-4fb8-957f-e1f0bedf64de',
+            filters=[
+                bedrock.SharePointCrawlingFilters(
+                    object_type=bedrock.SharePointObjectType.PAGE,
+                    include_patterns= [".*\\.pdf"],
+                    exclude_patterns= [".*private.*\\.pdf"],
+                ),
+                bedrock.SharePointCrawlingFilters(
+                    object_type=bedrock.SharePointObjectType.FILE,
+                    include_patterns= [".*public.*\\.pdf"],
+                    exclude_patterns= [".*confidential.*\\.pdf"],
+                ),
+            ]
+        )
+
+        kb.add_custom_data_source(
+            data_source_name='CustomDataSource',
+            chunking_strategy=bedrock.ChunkingStrategy.FIXED_SIZE,
+        )
+```

awslabs/cdk_mcp_server/static/bedrock/knowledgebases/kendra.md

@@ -0,0 +1,81 @@
+# Kendra Knowledge Base
+
+## Overview
+
+With Amazon Bedrock Knowledge Bases, you can build a knowledge base from an Amazon Kendra GenAI index to create more sophisticated and accurate Retrieval Augmented Generation (RAG)-powered digital assistants. By combining an Amazon Kendra GenAI index with Amazon Bedrock Knowledge Bases, you can:
+
+- Reuse your indexed content across multiple Amazon Bedrock applications without rebuilding indexes or re-ingesting data.
+- Leverage the advanced GenAI capabilities of Amazon Bedrock while benefiting from the high-accuracy information retrieval of Amazon Kendra.
+- Customize your digital assistant's behavior using the tools of Amazon Bedrock while maintaining the semantic accuracy of an Amazon Kendra GenAI index.
+
+## Kendra Knowledge Base Properties
+
+| Name | Type | Required | Description |
+|------|------|----------|-------------|
+| kendraIndex | IKendraGenAiIndex | Yes | The Kendra Index to use for the knowledge base. |
+| name | string | No | The name of the knowledge base. If not provided, a name will be auto-generated. |
+| description | string | No | Description of the knowledge base. |
+| instruction | string | No | Instructions for the knowledge base. |
+| existingRole | iam.IRole | No | An existing IAM role to use for the knowledge base. If not provided, a new role will be created. |
+
+## Example
+
+### TypeScript
+
+```ts
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import { bedrock, kendra } from '@cdklabs/generative-ai-cdk-constructs';
+
+const cmk = new kms.Key(stack, 'cmk', {});
+
+// you can create a new index using the api below
+const index = new kendra.KendraGenAiIndex(this, 'index', {
+  name: 'kendra-index-cdk',
+  kmsKey: cmk,
+  documentCapacityUnits: 1, // 40K documents
+  queryCapacityUnits: 1,    // 0.2 QPS
+});
+
+// or import an existing one
+const index = kendra.KendraGenAiIndex.fromAttrs(this, 'myindex', {
+  indexId: 'myindex',
+  role: myRole
+});
+
+new bedrock.KendraKnowledgeBase(this, 'kb', {
+  name: 'kendra-kb-cdk',
+  kendraIndex: index,
+});
+```
+
+### Python
+
+```py
+from aws_cdk import aws_kms as kms
+from cdklabs.generative_ai_cdk_constructs import bedrock, kendra
+
+# Create a KMS key
+cmk = kms.Key(stack, 'cmk')
+
+# Create a new Kendra index
+index = kendra.KendraGenAiIndex(self, 'index',
+    name='kendra-index-cdk',
+    kms_key=cmk,
+    document_capacity_units=1,  # 40K documents
+    query_capacity_units=1      # 0.2 QPS
+)
+
+# Or import an existing index
+index = kendra.KendraGenAiIndex.from_attrs(self, 'myindex',
+    index_id='myindex',
+    role=my_role
+)
+
+# Create a Kendra Knowledge Base
+kb = bedrock.KendraKnowledgeBase(self, 'kb',
+    name='kendra-kb-cdk',
+    kendra_index=index
+)
+```
+
+[View full documentation](https://github.com/awslabs/generative-ai-cdk-constructs/blob/main/src/cdk-lib/bedrock/README.md)

awslabs/cdk_mcp_server/static/bedrock/knowledgebases/overview.md

@@ -0,0 +1,116 @@
+# Amazon Bedrock Knowledge Bases
+
+Amazon Bedrock Knowledge Bases enable you to provide foundation models and agents with contextual information from your company's private data sources. This enhances the relevance, accuracy, and customization of their responses.
+
+## Table of Contents
+
+- [Amazon Bedrock Knowledge Bases](#amazon-bedrock-knowledge-bases)
+  - [Table of Contents](#table-of-contents)
+  - [Key Concepts](#key-concepts)
+  - [Knowledge Base Types](#knowledge-base-types)
+  - [Knowledge Base Components](#knowledge-base-components)
+  - [When to Use Knowledge Bases](#when-to-use-knowledge-bases)
+  - [Related Resources](#related-resources)
+  - [Quick Start Example](#quick-start-example)
+    - [Next Steps](#next-steps)
+
+## Key Concepts
+
+- **Knowledge Base**: A repository of information that foundation models can access to provide context-aware responses
+- **Vector Store**: A specialized database that stores and retrieves text as vector embeddings
+- **Chunking**: The process of breaking documents into smaller pieces for efficient storage and retrieval
+- **Data Source**: The origin of information ingested into a knowledge base (S3, web crawler, etc.)
+- **Embeddings Model**: A model that converts text into vector representations
+
+## Knowledge Base Types
+
+- **Vector Knowledge Base**: Uses vector embeddings to find semantically similar content (most common)
+- **Kendra Knowledge Base**: Leverages Amazon Kendra's semantic search capabilities
+- **Structured Data Retrieval**: Enables querying structured data sources (coming soon)
+
+> **Note**: Vector Knowledge Base is the most common type and currently has the most comprehensive support in the GenAI CDK. See [Vector Knowledge Base Creation](vector/creation.md) to get started.
+
+## Knowledge Base Components
+
+```mermaid
+graph TD
+    A[Knowledge Base] --> B[Vector Store]
+    A --> C[Data Sources]
+    A --> D[Embeddings Model]
+    B --> E[OpenSearch Serverless]
+    B --> F[Aurora PostgreSQL]
+    B --> G[Pinecone]
+    C --> H[S3]
+    C --> I[Web Crawler]
+    C --> J[Confluence]
+    C --> K[SharePoint]
+    C --> L[Salesforce]
+    A --> M[Chunking Strategy]
+    M --> N[Fixed Size]
+    M --> O[Hierarchical]
+    M --> P[Semantic]
+```
+
+## When to Use Knowledge Bases
+
+- **Domain-Specific Knowledge**: Provide specialized information not in the model's training data
+- **Private Information**: Allow models to access your organization's proprietary information
+- **Up-to-Date Information**: Supply models with the latest information beyond their training cutoff
+- **RAG Applications**: Implement Retrieval Augmented Generation for more accurate responses
+
+## Related Resources
+
+- **Chunking Strategies**: `genai-cdk-constructs://bedrock/knowledgebases/chunking`
+- **Data Sources**: `genai-cdk-constructs://bedrock/knowledgebases/datasources`
+- **Kendra Integration**: `genai-cdk-constructs://bedrock/knowledgebases/kendra`
+- **Parsing Strategies**: `genai-cdk-constructs://bedrock/knowledgebases/parsing`
+- **Custom Transformations**: `genai-cdk-constructs://bedrock/knowledgebases/transformation`
+- **Vector Stores**:
+  - `genai-cdk-constructs://bedrock/knowledgebases/vector/creation`
+  - `genai-cdk-constructs://bedrock/knowledgebases/vector/opensearch`
+  - `genai-cdk-constructs://bedrock/knowledgebases/vector/aurora`
+  - `genai-cdk-constructs://bedrock/knowledgebases/vector/pinecone`
+
+## Quick Start Example
+
+```typescript
+import { bedrock } from '@cdklabs/generative-ai-cdk-constructs';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+
+// Create a vector knowledge base
+const kb = new bedrock.VectorKnowledgeBase(this, 'KnowledgeBase', {
+  // Use TITAN_EMBED_TEXT_V2 with appropriate dimension size based on your needs:
+  // - 256: Fastest, lowest storage requirements, good for simple use cases
+  // - 512: Balanced performance and accuracy, recommended for most use cases
+  // - 1024: Highest accuracy, best for complex semantic relationships
+  embeddingsModel: bedrock.BedrockFoundationModel.TITAN_EMBED_TEXT_V2_512,
+  instruction: 'Use this knowledge base to answer questions about our company policies.',
+});
+
+// Create a secure S3 bucket for data
+const dataBucket = new s3.Bucket(this, 'DataBucket');
+
+// Add an S3 data source with chunking strategy
+new bedrock.S3DataSource(this, 'DataSource', {
+  bucket: dataBucket,
+  knowledgeBase: kb,
+  dataSourceName: 'CompanyPolicies',
+  chunkingStrategy: bedrock.ChunkingStrategy.fixedSize({
+    maxTokens: 300,
+    overlapPercentage: 20,
+  }),
+});
+
+// Note: When choosing an embedding model version:
+// - TITAN_EMBED_TEXT_V2_256: Lower dimension, faster, smaller storage footprint
+// - TITAN_EMBED_TEXT_V2_512: Balanced performance and accuracy (recommended)
+// - TITAN_EMBED_TEXT_V2_1024: Higher dimension, more accurate but more expensive
+
+### Next Steps
+
+For more detailed information:
+
+- [Vector Knowledge Base Creation](vector/creation.md) - Detailed properties and configuration options
+- [Vector Stores](vector/opensearch.md) - Different vector store options (OpenSearch, Aurora, Pinecone)
+- [Chunking Strategies](chunking.md) - Options for chunking your data
+- [Data Sources](datasources.md) - Different data source types and configuration

awslabs/cdk_mcp_server/static/bedrock/knowledgebases/parsing.md

@@ -0,0 +1,36 @@
+# Vector Knowledge Base - Parsing Strategy
+
+## Overview
+
+A parsing strategy in Amazon Bedrock is a configuration that determines how the service
+processes and interprets the contents of a document. It involves converting the document's
+contents into text and splitting it into smaller chunks for analysis. Amazon Bedrock offers
+two parsing strategies:
+
+### Default Parsing Strategy
+
+This strategy converts the document's contents into text
+and splits it into chunks using a predefined approach. It is suitable for most use cases
+but may not be optimal for specific document types or requirements.
+
+### Foundation Model Parsing Strategy
+
+This strategy uses a foundation model to describe
+the contents of the document. It is particularly useful for improved processing of PDF files
+with tables and images. To use this strategy, set the `parsingStrategy` in a data source as below.
+
+#### TypeScript
+
+```ts
+bedrock.ParsingStategy.foundationModel({
+  model: BedrockFoundationModel.ANTHROPIC_CLAUDE_SONNET_V1_0,
+});
+```
+
+#### Python
+
+```python
+bedrock.ParsingStategy.foundation_model(
+    parsing_model=BedrockFoundationModel.ANTHROPIC_CLAUDE_SONNET_V1_0
+)
+```

awslabs/cdk_mcp_server/static/bedrock/knowledgebases/transformation.md

@@ -0,0 +1,30 @@
+# Knowledge Base - Custom Transformation
+
+## Overview
+
+Custom Transformation in Amazon Bedrock is a feature that allows you to create and apply
+custom processing steps to documents moving through a data source ingestion pipeline.
+
+Custom Transformation uses AWS Lambda functions to process documents, enabling you to
+perform custom operations such as data extraction, normalization, or enrichment. To
+create a custom transformation, set the `customTransformation` in a data source as below.
+
+## Example
+
+### TypeScript
+
+```ts
+CustomTransformation.lambda({
+  lambdaFunction: lambdaFunction,
+  s3BucketUri: `s3://${bucket.bucketName}/chunk-processor/`,
+}),
+```
+
+### Python
+
+```python
+CustomTransformation.lambda_(
+  lambda_function= function,
+  s3_bucket_uri= f's3://{docBucket.bucket_name}/chunk-processor/'
+)
+```