awslabs.cdk-mcp-server 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

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

@@ -1,116 +0,0 @@
-# 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/genai_cdk/bedrock/knowledgebases/parsing.md

@@ -1,36 +0,0 @@
-# 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/genai_cdk/bedrock/knowledgebases/transformation.md

@@ -1,30 +0,0 @@
-# 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/'
-)
-```

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

@@ -1,185 +0,0 @@
-#### 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/genai_cdk/bedrock/knowledgebases/vector/creation.md

@@ -1,80 +0,0 @@
-# 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/genai_cdk/bedrock/knowledgebases/vector/opensearch.md

@@ -1,56 +0,0 @@
-
-# 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/genai_cdk/bedrock/knowledgebases/vector/pinecone.md

@@ -1,66 +0,0 @@
-#### 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', # pragma: allowlist secret
-  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', # pragma: allowlist secret
-            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,
-)
-```