awslabs.cdk-mcp-server 0.0.81650__py3-none-any.whl → 0.0.101004__py3-none-any.whl

awslabs/cdk_mcp_server/core/server.py

@@ -63,6 +63,7 @@ mcp.tool(name='CheckCDKNagSuppressions')(tools.check_cdk_nag_suppressions_tool)
 mcp.tool(name='GenerateBedrockAgentSchema')(tools.bedrock_schema_generator_from_file)
 mcp.tool(name='GetAwsSolutionsConstructPattern')(tools.get_aws_solutions_construct_pattern)
 mcp.tool(name='SearchGenAICDKConstructs')(tools.search_genai_cdk_constructs)
+mcp.tool(name='LambdaLayerDocumentationProvider')(tools.lambda_layer_documentation_provider)
 
 
 def main():

awslabs/cdk_mcp_server/core/tools.py

@@ -22,6 +22,7 @@ from awslabs.cdk_mcp_server.data.cdk_nag_parser import (
 from awslabs.cdk_mcp_server.data.genai_cdk_loader import (
     list_available_constructs,
 )
+from awslabs.cdk_mcp_server.data.lambda_layer_parser import LambdaLayerParser
 from awslabs.cdk_mcp_server.data.schema_generator import generate_bedrock_schema_from_file
 from awslabs.cdk_mcp_server.data.solutions_constructs_parser import (
     fetch_pattern_list,
@@ -476,3 +477,55 @@ async def search_genai_cdk_constructs(
         }
     except Exception as e:
         return {'error': f'Error searching constructs: {str(e)}', 'status': 'error'}
+
+
+async def lambda_layer_documentation_provider(
+    ctx: Context,
+    layer_type: str,  # "generic" or "python"
+) -> Dict[str, Any]:
+    """Provide documentation sources for Lambda layers.
+
+    This tool returns information about where to find documentation for Lambda layers
+    and instructs the MCP Client to fetch and process this documentation.
+
+    Args:
+        ctx: MCP context
+        layer_type: Type of layer ("generic" or "python")
+
+    Returns:
+        Dictionary with documentation source information
+    """
+    if layer_type.lower() == 'python':
+        # For Python layers, use AWS Documentation MCP Server
+        return {
+            'layer_type': 'python',
+            'documentation_source': {
+                'server': 'awslabs.aws-documentation-mcp-server',
+                'tool': 'read_documentation',
+                'parameters': {'url': LambdaLayerParser.PYTHON_LAYER_URL, 'max_length': 10000},
+            },
+            'documentation_usage_guide': {
+                'when_to_fetch_full_docs': 'Fetch full documentation to view detailed property definitions, learn about optional parameters, and find additional code examples',
+                'contains_sample_code': True,
+                'contains_props_documentation': True,
+            },
+            'code_generation_guidance': {
+                'imports': [
+                    "import { PythonLayerVersion } from '@aws-cdk/aws-lambda-python-alpha'"
+                ],
+                'construct_types': {'python': 'PythonLayerVersion'},
+                'required_properties': {'python': ['entry']},
+                'sample_code': "new python.PythonLayerVersion(this, 'MyLayer', {\n  entry: '/path/to/my/layer', // point this to your library's directory\n})",
+            },
+        }
+    else:
+        # For all other layer types (including generic), use the existing parser
+        docs = await LambdaLayerParser.fetch_lambda_layer_docs()
+        layer_docs = docs['generic_layers']
+
+        return {
+            'layer_type': 'generic',
+            'code_examples': layer_docs['examples'],
+            'directory_structure': layer_docs['directory_structure'],
+            'source_url': layer_docs['url'],
+        }

awslabs/cdk_mcp_server/data/lambda_layer_parser.py

@@ -0,0 +1,231 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+# with the License. A copy of the License is located at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+# OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+# and limitations under the License.
+
+"""Lambda layer documentation parser module."""
+
+import httpx
+import logging
+from bs4 import BeautifulSoup
+from bs4.element import Tag
+from typing import Any, Dict, List, Optional
+
+
+# Set up logging
+logger = logging.getLogger(__name__)
+
+
+class LambdaLayerParser:
+    """Parser for Lambda layer documentation from AWS docs."""
+
+    # Documentation URLs
+    GENERIC_LAYER_URL = (
+        'https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html#layers'
+    )
+    PYTHON_LAYER_URL = 'https://docs.aws.amazon.com/cdk/api/v2/docs/@aws-cdk_aws-lambda-python-alpha.PythonLayerVersion.html'
+
+    # Search patterns to directly find sections when headers aren't working
+    LAYER_SECTION_PATTERNS = ['layers', 'layer version', 'layerversion']
+
+    @classmethod
+    async def fetch_page(cls, url: str) -> Optional[str]:
+        """Fetch a page from AWS documentation."""
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(url)
+                if response.status_code == 200:
+                    return response.text
+                else:
+                    logger.error(f'Failed to fetch {url}: HTTP {response.status_code}')
+                    return None
+        except Exception as e:
+            logger.error(f'Error fetching {url}: {str(e)}')
+            return None
+
+    @classmethod
+    def extract_code_examples(cls, html_section: Optional[str]) -> List[Dict[str, str]]:
+        """Extract code examples from an HTML section."""
+        if not html_section:
+            return []
+
+        soup = BeautifulSoup(html_section, 'html.parser')
+        code_blocks = soup.find_all('pre')
+
+        examples = []
+        for block in code_blocks:
+            # Make sure we're working with a Tag
+            if not isinstance(block, Tag):
+                continue
+
+            # Try to determine the language
+            language = 'typescript'  # Default
+            classes = block.attrs.get('class', [])
+
+            # Make sure classes is a list of strings
+            if not isinstance(classes, list):
+                classes = [str(classes)]
+
+            class_str = ' '.join(classes)
+
+            if 'python' in class_str.lower():
+                language = 'python'
+            elif 'javascript' in class_str.lower():
+                language = 'javascript'
+
+            # Get the code content
+            code = block.get_text()
+            examples.append({'language': language, 'code': code})
+
+        return examples
+
+    @classmethod
+    def extract_directory_structure(cls, html_section: Optional[str]) -> Optional[str]:
+        """Extract directory structure information from HTML section."""
+        if not html_section:
+            return None
+
+        soup = BeautifulSoup(html_section, 'html.parser')
+
+        # Look for pre blocks that might contain directory structure
+        pre_blocks = soup.find_all('pre')
+        for block in pre_blocks:
+            text = block.get_text()
+            if '/' in text and (
+                'directory' in text.lower()
+                or 'structure' in text.lower()
+                or 'layer' in text.lower()
+            ):
+                return text
+
+        # Look for paragraphs that might describe directory structure
+        paragraphs = soup.find_all('p')
+        for p in paragraphs:
+            text = p.get_text()
+            if (
+                'directory' in text.lower() and 'structure' in text.lower()
+            ) or 'layer' in text.lower():
+                return text
+
+        return None
+
+    @classmethod
+    def find_layer_content(cls, html: Optional[str]) -> Optional[str]:
+        """Find Lambda layer content using multiple strategies."""
+        if not html:
+            return None
+
+        soup = BeautifulSoup(html, 'html.parser')
+
+        # Strategy 1: Find section by id
+        section = soup.find(id='layers')
+        if section and isinstance(section, Tag):
+            # If we found an anchor, get its parent and look for the actual content
+            if section.name == 'a':
+                parent = section.parent
+                if parent and isinstance(parent, Tag) and parent.name and parent.name[0] == 'h':
+                    # We found a header, extract all content until the next header of same or higher level
+                    content = []
+                    content.append(str(parent))
+
+                    header_level = int(parent.name[1])
+                    sibling = parent.next_sibling
+
+                    while sibling:
+                        if (
+                            isinstance(sibling, Tag)
+                            and sibling.name
+                            and sibling.name[0] == 'h'
+                            and int(sibling.name[1]) <= header_level
+                        ):
+                            break
+                        if isinstance(sibling, Tag) and sibling.name:
+                            content.append(str(sibling))
+                        sibling = sibling.next_sibling
+
+                    return ''.join(content)
+
+        # Strategy 2: Look for headers containing layer keywords
+        for tag in ['h1', 'h2', 'h3', 'h4']:
+            headers = soup.find_all(tag)
+            for header in headers:
+                if not isinstance(header, Tag):
+                    continue
+
+                text = header.get_text().lower()
+                if any(pattern in text for pattern in cls.LAYER_SECTION_PATTERNS):
+                    # Found a relevant header, extract all content until the next header of same or higher level
+                    content = []
+                    content.append(str(header))
+
+                    if not header.name:
+                        continue
+
+                    header_level = int(header.name[1])
+                    sibling = header.next_sibling
+
+                    while sibling:
+                        if (
+                            isinstance(sibling, Tag)
+                            and sibling.name
+                            and sibling.name[0] == 'h'
+                            and int(sibling.name[1]) <= header_level
+                        ):
+                            break
+                        if isinstance(sibling, Tag) and sibling.name:
+                            content.append(str(sibling))
+                        sibling = sibling.next_sibling
+
+                    return ''.join(content)
+
+        # Strategy 3: Look for content div with class="api" or class="props"
+        content_divs = soup.find_all('div', class_=['api', 'props'])
+        if content_divs:
+            return ''.join(str(div) for div in content_divs)
+
+        # Strategy 4: Look for table with class containing 'cdk'
+        tables = soup.find_all('table')
+        for table in tables:
+            if not isinstance(table, Tag):
+                continue
+
+            classes = table.attrs.get('class', [])
+            if not isinstance(classes, list):
+                classes = [str(classes)]
+
+            if any('cdk' in str(cls_name) for cls_name in classes):
+                return str(table)
+
+        return None
+
+    @classmethod
+    async def fetch_lambda_layer_docs(cls) -> Dict[str, Any]:
+        """Fetch Lambda layer documentation from AWS docs."""
+        logger.info('Fetching Lambda layer documentation from AWS')
+
+        # Fetch only the generic page
+        generic_html = await cls.fetch_page(cls.GENERIC_LAYER_URL)
+
+        # Extract relevant sections using our specialized finder
+        generic_layers_section = cls.find_layer_content(generic_html)
+
+        # Extract code examples and directory structure
+        generic_examples = cls.extract_code_examples(generic_layers_section)
+        generic_dir_structure = cls.extract_directory_structure(generic_layers_section)
+
+        # Compile the results
+        result = {
+            'generic_layers': {
+                'examples': generic_examples,
+                'directory_structure': generic_dir_structure,
+                'url': cls.GENERIC_LAYER_URL,
+            }
+        }
+
+        return result

awslabs/cdk_mcp_server/data/solutions_constructs_parser.py

@@ -288,7 +288,7 @@ def extract_services_from_pattern_name(pattern_name: str) -> List[str]:
         'iot': 'IoT Core',
         'elasticsearch': 'Elasticsearch',
         'opensearch': 'OpenSearch',
-        'secretsmanager': 'Secrets Manager',
+        'secretsmanager': 'Secrets Manager',  # pragma: allowlist secret
         'sagemakerendpoint': 'SageMaker Endpoint',
         'stepfunctions': 'Step Functions',
         'wafwebacl': 'WAF Web ACL',

awslabs/cdk_mcp_server/static/CDK_GENERAL_GUIDANCE.md

@@ -45,84 +45,106 @@ cdk diff
 - Generates CloudFormation templates for inspection
 - Provides more informative error messages for debugging
 
-## Decision Flow for CDK Implementation
-
-When implementing AWS infrastructure with CDK, consider these complementary approaches:
-
-1. **For Common Architecture Patterns: AWS Solutions Constructs**
-   - Use the `GetAwsSolutionsConstructPattern` tool to search for patterns that match your use case
-   - Example: `GetAwsSolutionsConstructPattern(services=["lambda", "dynamodb"])`
-   - AWS Solutions Constructs implement AWS best practices by default
-   - For complete documentation: `aws-solutions-constructs://{pattern_name}`
-   - Ideal for REST APIs, serverless backends, data processing pipelines, etc.
-
-2. **For GenAI/AI/ML Use Cases: GenAI CDK Constructs**
-   - Use the `SearchGenAICDKConstructs` tool for specialized AI/ML constructs
-   - These simplify implementation of Bedrock, SageMaker, and other AI services
-   - Perfect for agents, knowledge bases, vector stores, and other GenAI components
-
-   **Installation:**
-
-   ```typescript
-   // TypeScript
-   // Create or use an existing CDK application
-   cdk init app --language typescript
-   // Install the package
-   npm install @cdklabs/generative-ai-cdk-constructs
-   // Import the library
-   import * as genai from '@cdklabs/generative-ai-cdk-constructs';
-   ```
-
-   ```python
-   # Python
-   # Create or use an existing CDK application
-   cdk init app --language python
-   # Install the package
-   pip install cdklabs.generative-ai-cdk-constructs
-   # Import the library
-   import cdklabs.generative_ai_cdk_constructs
-   ```
-
-3. **For All Projects: Apply CDK Nag**
-   - Always apply CDK Nag to ensure security best practices
-   - Use the `ExplainCDKNagRule` tool to understand specific rules
+## CDK Implementation Approach and Workflow
 
-4. **For Custom Requirements: Custom Implementation**
-   - Create custom CDK code when no suitable constructs exist
-   - Follow AWS Well-Architected best practices
+# Compare deployed stack with current state
 
-> **IMPORTANT**: AWS Solutions Constructs and GenAI CDK Constructs are complementary and can be used together in the same project. For example, you might use GenAI CDK Constructs for Bedrock components and AWS Solutions Constructs for the REST API and database layers of your application.
+### Common Architecture Patterns
 
-## Key Principles
+**For standard application architectures:**
 
-- **Security First**: Always implement security best practices by default
-- **Cost Optimization**: Design resources to minimize costs while meeting requirements
-- **Operational Excellence**: Implement proper monitoring, logging, and observability
-- **Serverless-First**: Prefer serverless services when possible
-- **Infrastructure as Code**: Use CDK to define all infrastructure
-- **Use Vetted Patterns**: Prefer AWS Solutions Constructs over custom implementations
-- **Regional Awareness**: Consider regional availability and constraints for services
+- Use the `GetAwsSolutionsConstructPattern` tool to find pre-built patterns
+- AWS Solutions Constructs implement AWS best practices by default
+- Ideal for REST APIs, serverless backends, data processing pipelines, etc.
+- Example: `GetAwsSolutionsConstructPattern(services=["lambda", "dynamodb"])`
+- For complete documentation: `aws-solutions-constructs://{pattern_name}`
 
-## Amazon Bedrock Cross-Region Inference Profiles
+**Key benefits:**
+- Accelerated development with vetted patterns
+- Built-in security and best practices
+- Reduced complexity for multi-service architectures
 
-When working with Amazon Bedrock foundation models, many models (including Claude models, Meta Llama models, and Amazon's own Nova models) require the use of inference profiles rather than direct on-demand usage in specific regions.
+### GenAI/AI/ML Implementations
 
-### Key Considerations
+**For AI/ML and generative AI workloads:**
 
-- **Required for Many Models**: Foundation models like Claude 3 often require inference profiles
-- **Regional Configuration**: Profiles are configured for specific geographic regions (US, EU, APAC)
-- **Error Prevention**: Prevents errors like "Invocation with on-demand throughput isn't supported"
-- **Implementation**: Use the `CrossRegionInferenceProfile` class from the GenAI CDK constructs
+- Use the `SearchGenAICDKConstructs` tool for specialized AI/ML constructs
+- These simplify implementation of Bedrock, SageMaker, and other AI services
+- Perfect for agents, knowledge bases, vector stores, and other GenAI components
 
-For detailed implementation examples, see the `genai-cdk-constructs://bedrock/profiles` resource.
+**Installation:**
 
-### Regional Considerations
+```typescript
+// TypeScript
+npm install @cdklabs/generative-ai-cdk-constructs
+import * as genai from '@cdklabs/generative-ai-cdk-constructs';
+```
+
+```python
+# Python
+pip install cdklabs.generative-ai-cdk-constructs
+import cdklabs.generative_ai_cdk_constructs
+```
 
-- **Model Availability**: Not all foundation models are available in all regions
-- **Performance**: Choose the region closest to your users for optimal latency
-- **Compliance**: Consider data residency requirements when selecting regions
+**Regional considerations for Bedrock:**
+- Many foundation models require inference profiles in specific regions
+- Use `CrossRegionInferenceProfile` class for proper configuration
+- For details: `genai-cdk-constructs://bedrock/profiles`
 
-Always check the [Amazon Bedrock documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) for the latest information on model availability and regional constraints.
+### Combined Implementation Patterns
+
+**Important:** AWS Solutions Constructs and GenAI CDK Constructs can be used together in the same project:
+
+- Use GenAI CDK Constructs for Bedrock components (agents, knowledge bases)
+- Use AWS Solutions Constructs for REST APIs, databases, and other infrastructure
+- Apply CDK Nag across all components for security validation
+
+**Example combined architecture:**
+- REST API backend using aws-apigateway-lambda-dynamodb construct
+- Bedrock Agent using GenAI CDK constructs for natural language processing
+- Shared data layer between traditional and AI components
+
+### Implementation Workflow
+
+Follow this step-by-step workflow for developing AWS CDK applications:
+
+1. **Get CDK Guidance**: Start with the **CDKGeneralGuidance** tool to understand best practices.
+
+2. **Initialize CDK Project**: Use `cdk init app` to create your project with proper structure.
+
+3. **Choose Implementation Approach**:
+   - For common patterns: Use **GetAwsSolutionsConstructPattern** tool
+   - For GenAI applications: Use **SearchGenAICDKConstructs** tool
+   - For custom requirements: Develop custom CDK code following best practices
+
+4. **For Lambda Functions**:
+   - For observability: Implement Lambda Powertools (see `lambda-powertools://cdk` for details)
+   - For Lambda layers: Use **LambdaLayerDocumentationProvider** tool
+
+5. **For Bedrock Agents with Action Groups**:
+   - Create Lambda function with BedrockAgentResolver from Lambda Powertools
+   - Use **GenerateBedrockAgentSchema** tool to generate OpenAPI schema
+   - Integrate schema into Agent CDK code
+
+6. **Apply Security Best Practices**:
+   - Always apply CDK Nag to ensure security best practices
+   - Use **ExplainCDKNagRule** tool to understand specific rules
+   - Validate suppressions with **CheckCDKNagSuppressions** tool
+
+7. **Validate and Deploy**:
+   - Run `cdk synth` to check for errors and generate CloudFormation
+   - Ensure all CDK Nag warnings are resolved or properly justified
+   - Deploy using `cdk deploy`
+
+## Key Principles
+
+- **Security First**: Always implement security best practices by default
+- **Cost Optimization**: Design resources to minimize costs while meeting requirements
+- **Operational Excellence**: Implement proper monitoring, logging, and observability
+- **Serverless-First**: Prefer serverless services when possible
+- **Infrastructure as Code**: Use CDK to define all infrastructure
+- **Use Vetted Patterns**: Prefer AWS Solutions Constructs over custom implementations
+- **Regional Awareness**: Consider regional availability and constraints for services
 
 ## AWS Solutions Constructs
 
@@ -148,10 +170,12 @@ To discover available patterns, use the `GetAwsSolutionsConstructPattern` tool.
 CDK Nag ensures your CDK applications follow AWS security best practices. **Always apply CDK Nag to all stacks.**
 
 **When to use CDK Nag tools:**
+
 - **ExplainCDKNagRule**: When encountering warnings that need remediation
 - **CheckCDKNagSuppressions**: During code reviews to verify suppression justifications
 
 Key security practices:
+
 - Follow least privilege for IAM
 - Secure S3 buckets with encryption and access controls
 - Implement secure authentication with Cognito
@@ -161,6 +185,10 @@ Key security practices:
 
 **Always implement Lambda Powertools** for structured logging, tracing, and metrics. For detailed guidance, use the `lambda-powertools://cdk` resource.
 
+> **CRITICAL**: Lambda Powertools libraries are NOT included in the default Lambda runtime. You MUST create a Lambda layer to include these dependencies. Use the **LambdaLayerDocumentationProvider** tool for comprehensive guidance on creating and configuring Lambda layers.
+
+**Critical for Bedrock Agents**: When creating Bedrock Agents with Action Groups, use BedrockAgentResolver from Lambda Powertools with the **GenerateBedrockAgentSchema** tool to generate the required OpenAPI schema.
+
 ## Tool Selection Guide
 
 Match CDK tasks to appropriate tools:
@@ -171,110 +199,6 @@ Match CDK tasks to appropriate tools:
 | Understand CDK Nag rules | ExplainCDKNagRule | ❌ Ignoring security warnings without understanding remediation steps |
 | Find architecture patterns | GetAwsSolutionsConstructPattern | ❌ Building common patterns from scratch instead of using vetted constructs |
 | Implement GenAI features | SearchGenAICDKConstructs | ❌ Building GenAI components without specialized constructs |
-| Add Lambda observability | lambda-powertools://cdk | ❌ Missing Layer creation, structured logging and monitoring |
+| Access Lambda layer docs | LambdaLayerDocumentationProvider | ❌ Missing proper Lambda layer structure or configuration |
+| Add Lambda observability | lambda-powertools://cdk | ❌ Missing Lambda layer for Powertools or incomplete monitoring setup |
 | Audit CDK Nag suppressions | CheckCDKNagSuppressions | ❌ Insufficient documentation for security suppressions |
-
-## Lambda Powertools Implementation
-
-> **CRITICAL:** All Lambda functions should implement Lambda Powertools for proper observability.
-
-**Key requirements:**
-- Use language-specific constructs (PythonFunction, NodejsFunction)
-- Include Powertools dependencies with appropriate extras
-- Configure required environment variables
-- Create Lambda layers when needed
-
-**Example Lambda layer for Python:**
-```typescript
-const lambdaPowertoolsLayer = new PythonLayerVersion(this, "LambdaPowertoolsLayer", {
-  entry: path.join("src", "layers", "aws_lambda_powertools"),
-  compatibleRuntimes: [Runtime.PYTHON_3_13],
-  description: "Lambda Powertools for Python",
-});
-```
-
-For complete implementation details and examples for all languages, see the [lambda-powertools://cdk](lambda-powertools://cdk) resource.
-
-## CDK Implementation Workflow
-
-```mermaid
-graph TD
-    Start([Start]) --> Init["cdk init app"]
-    
-    Init --> B{Choose Approach}
-    B -->|"Common Patterns"| C1["GetAwsSolutionsConstructPattern"]
-    B -->|"GenAI Features"| C2["SearchGenAICDKConstructs"]
-    B -->|"Custom Needs"| C3["Custom CDK Code"]
-    
-    C1 --> D1["Implement Solutions Construct"]
-    C2 --> D2["Implement GenAI Constructs"]
-    C3 --> D3["Implement Custom Resources"]
-    
-    %% Bedrock Agent with Action Groups specific flow
-    D2 -->|"For Bedrock Agents<br/>with Action Groups"| BA["Create Lambda with<br/>BedrockAgentResolver"]
-    
-    %% Schema generation flow
-    BA --> BS["GenerateBedrockAgentSchema"]
-    BS -->|"Success"| JSON["openapi.json created"]
-    BS -->|"Import Errors"| BSF["Tool generates<br/>generate_schema.py"]
-    BSF --> BSR["Run script manually:<br/>python generate_schema.py"]
-    BSR --> JSON["openapi.json created"]
-    
-    %% Use schema in Agent CDK
-    JSON --> AgentCDK["Use schema in<br/>Agent CDK code"]
-    AgentCDK --> D2
-    
-    %% Conditional Lambda Powertools implementation
-    D1 & D2 & D3 --> HasLambda{"Using Lambda<br/>Functions?"}
-    HasLambda -->|"Yes"| L["Add Lambda Powertools<br/>and create Layer"]
-    HasLambda -->|"No"| SkipL["Skip Lambda<br/>Powertools"]
-    
-    %% Rest of workflow
-    L --> Synth["cdk synth"]
-    SkipL --> Synth
-    
-    Synth --> Nag{"CDK Nag<br/>warnings?"}
-    Nag -->|Yes| E["ExplainCDKNagRule"]
-    Nag -->|No| Deploy["cdk deploy"]
-    
-    E --> Fix["Fix or Add Suppressions"]
-    Fix --> CN["CheckCDKNagSuppressions"]
-    CN --> Synth
-    
-    %% Styling with darker colors
-    classDef default fill:#424242,stroke:#ffffff,stroke-width:1px,color:#ffffff;
-    classDef cmd fill:#4a148c,stroke:#ffffff,stroke-width:1px,color:#ffffff;
-    classDef tool fill:#01579b,stroke:#ffffff,stroke-width:1px,color:#ffffff;
-    classDef note fill:#1b5e20,stroke:#ffffff,stroke-width:1px,color:#ffffff;
-    classDef output fill:#006064,stroke:#ffffff,stroke-width:1px,color:#ffffff;
-    classDef decision fill:#5d4037,stroke:#ffffff,stroke-width:1px,color:#ffffff;
-    
-    class Init,Synth,Deploy,BSR cmd;
-    class C1,C2,BS,E,CN tool;
-    class JSON output;
-    class HasLambda,Nag decision;
-```
-
-## Available MCP Tools
-
-This MCP server provides several tools to help you implement AWS CDK best practices:
-
-1. **CDKGeneralGuidance**: This document - general CDK best practices
-2. **ExplainCDKNagRule**: Explain a specific CDK Nag rule with AWS Well-Architected guidance
-3. **CheckCDKNagSuppressions**: Check if CDK code contains Nag suppressions that require human review
-4. **GenerateBedrockAgentSchema**: Generate OpenAPI schema for Bedrock Agent Action Groups from Lambda functions
-5. **GetAwsSolutionsConstructPattern**: Search and discover AWS Solutions Constructs patterns
-6. **SearchGenAICDKConstructs**: Search for GenAI CDK constructs by name or type
-
-## Available MCP Resources
-
-This MCP server also provides several resources for accessing documentation:
-
-1. **cdk-nag://rules/{rule_pack}**: Get all rules for a specific CDK Nag rule pack
-2. **cdk-nag://warnings/{rule_pack}**: Get warnings for a specific CDK Nag rule pack
-3. **cdk-nag://errors/{rule_pack}**: Get errors for a specific CDK Nag rule pack
-4. **lambda-powertools://{topic}**: Get Lambda Powertools guidance on a specific topic
-5. **aws-solutions-constructs://{pattern_name}**: Get complete documentation for an AWS Solutions Constructs pattern
-6. **genai-cdk-constructs://{construct_type}/{construct_name}**: Get documentation for a GenAI CDK construct
-
-Always check for these tools and resources when implementing CDK infrastructure to ensure you're following AWS best practices.

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

@@ -8,7 +8,7 @@ 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',
+  credentialsSecretArn: 'arn:aws:secretsmanager:your-region:123456789876:secret:your-key-name', # pragma: allowlist secret
   textField: 'question',
   metadataField: 'metadata',
 });
@@ -43,7 +43,7 @@ from cdklabs.generative_ai_cdk_constructs import (
 
 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',
+            credentials_secret_arn='arn:aws:secretsmanager:your-region:123456789876:secret:your-key-name', # pragma: allowlist secret
             text_field='question',
             metadata_field='metadata'
         )

awslabs/cdk_mcp_server/static/lambda_powertools/bedrock.md

@@ -1,12 +1,20 @@
 # Bedrock Agent Integration
 
+## Lambda Layer Requirement
+
+> **CRITICAL**: Lambda Powertools libraries are NOT included in the default Lambda runtime. You MUST create a Lambda layer to include these dependencies. Use the **LambdaLayerDocumentationProvider** tool for comprehensive guidance
+
+This is especially important for Bedrock Agent integration, as the BedrockAgentResolver is required for generating proper OpenAPI schemas.
+
+## Implementation
+
 Use Lambda Powertools with Bedrock Agent actions:
 
 ```python
 from typing import Dict, List, Optional
 from aws_lambda_powertools import Logger
 from aws_lambda_powertools.event_handler import BedrockAgentResolver
-from aws_lambda_powertools.event_handler.openapi.params import Body, Path, Query
+from aws_lambda_powertools.event_handler.openapi.params import Query
 from pydantic import BaseModel, Field
 
 # Initialize Powertools
@@ -47,35 +55,14 @@ def lambda_handler(event, context):
 
 ## Generating OpenAPI Schema
 
-To generate a Bedrock-compatible OpenAPI schema:
-
-```python
-# Generate schema from a file
-result = await use_mcp_tool(
-    server_name="awslabs.cdk-mcp-server",
-    tool_name="GenerateBedrockAgentSchema",
-    arguments={
-        "lambda_code_path": "/path/to/your/agent_actions.py",
-        "output_path": "/path/to/output/schema.json"
-    }
-)
-```
-
-## Common Schema Issues
-
-- **OpenAPI version**: Must be exactly 3.0.0
-- **operationId**: Each operation needs a unique operationId
-- **Response schemas**: All responses must have properly defined schemas
-- **Parameter descriptions**: All parameters should have descriptions
+To generate a Bedrock-compatible OpenAPI schema, use **GenerateBedrockAgentSchema** tool.
 
 ## Best Practices
 
 1. **Use Pydantic models**: Define request and response models with Pydantic
 2. **Add descriptions**: Add descriptions to all fields and parameters
 3. **Use type hints**: Specify return types for all route handlers
-4. **Handle errors gracefully**: Return appropriate error responses
-5. **Log with context**: Use structured logging with business context
-6. **Validate inputs**: Use the validation features to ensure valid inputs
+4. **Log with context**: Use structured logging with business context
 
 ## CDK Integration
 
@@ -83,30 +70,35 @@ result = await use_mcp_tool(
 import { bedrock } from '@cdklabs/generative-ai-cdk-constructs';
 import { PythonFunction } from '@aws-cdk/aws-lambda-python-alpha';
 import { Runtime, Tracing } from 'aws-cdk-lib/aws-lambda';
+import { PythonLayerVersion } from '@aws-cdk/aws-lambda-python-alpha';
 import * as path from 'path';
 
+// Create Lambda layer for Powertools
+const powertoolsLayer = new PythonLayerVersion(this, "PowertoolsLayer", {
+  entry: path.join(__dirname, '../layers/powertools'),
+  compatibleRuntimes: [Runtime.PYTHON_3_13],
+  description: "Lambda Powertools for Python",
+});
+
 // Create Lambda function for Bedrock Agent actions
 const actionFunction = new PythonFunction(this, 'AgentActionFunction', {
   entry: path.join(__dirname, '../src/agent_actions'),
   runtime: Runtime.PYTHON_3_13,
   tracing: Tracing.ACTIVE,
+  layers: [powertoolsLayer],  // Attach the Powertools layer
   environment: {
     POWERTOOLS_SERVICE_NAME: "agent-actions",
     LOG_LEVEL: "INFO",
   },
 });
 
-// Create a Bedrock Agent
+// Create a Bedrock Agent with action group
 const agent = new bedrock.Agent(this, 'Agent', {
   name: 'PowertoolsAgent',
   foundationModel: bedrock.BedrockFoundationModel.ANTHROPIC_CLAUDE_3_5_HAIKU_V1_0,
-  shouldPrepareAgent: true,
-  userInputEnabled: true,
   instruction: 'You are a helpful assistant that can perform product-related actions.',
-  description: 'Agent for product management',
 });
 
-// Add action group to the agent
 agent.addActionGroup(
   new bedrock.AgentActionGroup({
     name: 'product-actions',
@@ -117,11 +109,4 @@ agent.addActionGroup(
     ),
   })
 );
-
-// Create agent alias for deployment
-const agentAlias = new bedrock.AgentAlias(this, 'AgentAlias', {
-  aliasName: 'latest',
-  agent: agent,
-  description: 'Latest agent alias',
-});
 ```

awslabs/cdk_mcp_server/static/lambda_powertools/cdk.md

@@ -1,99 +1,53 @@
 # CDK Integration
 
-Integrate Lambda Powertools with CDK:
+## Lambda Layer Requirement
 
-> **IMPORTANT**: When using Tracer functionality with CDK, ensure your dependency management includes the tracer extras. For Python, your package specification should use `aws-lambda-powertools[tracer]` or `aws-lambda-powertools[all]` rather than just `aws-lambda-powertools`.
+> **CRITICAL**: Lambda Powertools libraries are NOT included in the default Lambda runtime. You MUST create a Lambda layer to include these dependencies. Use the **LambdaLayerDocumentationProvider** tool for comprehensive guidance:
+>
+> ```
+> LambdaLayerDocumentationProvider(layer_type="python")
+> ```
+
+## Basic Implementation
 
 ```typescript
 import * as path from "path";
-import { Duration } from 'aws-cdk-lib';
 import { PythonFunction } from "@aws-cdk/aws-lambda-python-alpha";
 import { Runtime, Tracing } from "aws-cdk-lib/aws-lambda";
-import { RetentionDays } from 'aws-cdk-lib/aws-logs';
-
-// Create Lambda function with Powertools
-const paymentFunction = new PythonFunction(this, 'PaymentFunction', {
-  entry: path.join(__dirname, '../src/payment_function'),  // Directory containing requirements.txt
-  runtime: Runtime.PYTHON_3_13,  // Always use the latest available runtime
+import { PythonLayerVersion } from "@aws-cdk/aws-lambda-python-alpha";
 
-  // Enable X-Ray tracing
-  tracing: Tracing.ACTIVE,
+// Create Lambda layer for Powertools
+const powertoolsLayer = new PythonLayerVersion(this, "PowertoolsLayer", {
+  entry: path.join(__dirname, '../layers/powertools'),  // Directory with requirements.txt
+  compatibleRuntimes: [Runtime.PYTHON_3_13],
+  description: "Lambda Powertools for Python",
+});
 
-  // Configure Powertools environment variables
+// Create Lambda function with Powertools
+const myFunction = new PythonFunction(this, 'MyFunction', {
+  entry: path.join(__dirname, '../src/my_function'),
+  runtime: Runtime.PYTHON_3_13,
+  layers: [powertoolsLayer],  // Attach the Powertools layer
+  tracing: Tracing.ACTIVE,    // Enable X-Ray tracing
   environment: {
-    POWERTOOLS_SERVICE_NAME: "payment-service",
-    POWERTOOLS_METRICS_NAMESPACE: "PaymentService",
+    POWERTOOLS_SERVICE_NAME: "my-service",
+    POWERTOOLS_METRICS_NAMESPACE: "MyService",
     LOG_LEVEL: "INFO",
-    POWERTOOLS_LOGGER_LOG_EVENT: "true",  // Log event for debugging
   },
-
-  // Set appropriate log retention
-  logRetention: RetentionDays.ONE_WEEK,
 });
 ```
 
 ## Best Practices
 
 - **Always use language-specific function constructs** instead of the generic Function construct
+- **Create a dedicated Lambda layer** for Powertools dependencies
 - **Enable X-Ray tracing** by setting `tracing: Tracing.ACTIVE`
 - **Configure Powertools environment variables** for consistent naming
-- **Set appropriate log retention** to manage CloudWatch Logs costs
-- **Ensure requirements.txt includes the correct extras** (e.g., `aws-lambda-powertools[tracer]`)
-
-## Language-Specific Function Constructs
 
-When implementing Lambda functions with CDK, it's recommended to use language-specific constructs instead of the generic Function construct:
-
-### PythonFunction Benefits
-
-- **Automatic Dependency Management**: Bundles Python dependencies from requirements.txt without manual packaging
-- **Proper Python Runtime Configuration**: Sets up the correct Python runtime environment with appropriate file permissions
-- **Simplified Asset Bundling**: Handles asset bundling with appropriate exclusions for Python-specific files
-- **Poetry/Pipenv Support**: Works with modern Python dependency management tools
-- **Layer Management**: Simplifies the creation and attachment of Lambda layers
-
-### NodeJSFunction Benefits
-
-- **TypeScript Support**: Automatically transpiles TypeScript to JavaScript
-- **Dependency Bundling**: Uses esbuild to bundle only required dependencies for smaller packages
-- **Source Map Support**: Maintains source maps for easier debugging
-- **Minification Options**: Provides options for code minification
-- **Tree Shaking**: Eliminates unused code from the final bundle
-
-## Example requirements.txt
-
-For a Python Lambda function using Powertools with tracing:
-
-```
-aws-lambda-powertools[tracer]>=2.0.0
-```
-
-Or for all Powertools features:
-
-```
-aws-lambda-powertools[all]>=2.0.0
-```
-
-## Combining with Lambda Insights
-
-For comprehensive observability, combine Lambda Powertools with Lambda Insights:
-
-```typescript
-import { LambdaInsightsVersion } from 'aws-cdk-lib/aws-lambda';
-
-const function = new PythonFunction(this, 'MyFunction', {
-  // ... other configuration
-
-  // Enable Lambda Insights
-  insightsVersion: LambdaInsightsVersion.VERSION_1_0_119_0,
-
-  // Configure Powertools
-  environment: {
-    POWERTOOLS_SERVICE_NAME: "my-service",
-    POWERTOOLS_METRICS_NAMESPACE: "MyService",
-    // ... other environment variables
-  },
-});
-```
+## Feature-Specific Resources
 
-This approach provides both system-level metrics (Lambda Insights) and business-level metrics (Powertools) for complete observability. See the [Lambda Insights](lambda-powertools://insights) section for more details.
+For implementation details of specific features, refer to:
+- `lambda-powertools://logging`
+- `lambda-powertools://metrics`
+- `lambda-powertools://tracing`
+- `lambda-powertools://bedrock`

awslabs/cdk_mcp_server/static/lambda_powertools/insights.md

@@ -17,39 +17,30 @@ Lambda Insights is an extension of CloudWatch that provides system-level metrics
 
 ## CDK Integration
 
-```typescript
-import { LambdaInsightsVersion } from 'aws-cdk-lib/aws-lambda';
-import { PythonFunction } from '@aws-cdk/aws-lambda-python-alpha';
-
-// Create Lambda function with Lambda Insights enabled
-const function = new PythonFunction(this, 'MyFunction', {
-  entry: path.join(__dirname, '../src/my_function'),
-  runtime: Runtime.PYTHON_3_13,
-
-  // Enable Lambda Insights with specific version
-  insightsVersion: LambdaInsightsVersion.VERSION_1_0_119_0,
-
-  // Other configuration...
-});
-```
-
-## Combining with Lambda Powertools
-
-Lambda Insights works seamlessly alongside Lambda Powertools to provide a complete observability solution:
+> **REMINDER**: Lambda Powertools requires a Lambda layer. See `lambda-powertools://cdk` for details.
 
 ```typescript
 import { LambdaInsightsVersion } from 'aws-cdk-lib/aws-lambda';
 import { PythonFunction } from '@aws-cdk/aws-lambda-python-alpha';
+import { Runtime, Tracing } from 'aws-cdk-lib/aws-lambda';
+import { PythonLayerVersion } from '@aws-cdk/aws-lambda-python-alpha';
+import * as path from 'path';
 
 // Create Lambda function with both Lambda Insights and Powertools
-const function = new PythonFunction(this, 'MyFunction', {
+const myFunction = new PythonFunction(this, 'MyFunction', {
   entry: path.join(__dirname, '../src/my_function'),
   runtime: Runtime.PYTHON_3_13,
 
+  // Attach Lambda layer (see lambda-powertools://cdk)
+  layers: [powertoolsLayer],
+
   // Enable Lambda Insights
   insightsVersion: LambdaInsightsVersion.VERSION_1_0_119_0,
 
-  // Configure Powertools for business metrics
+  // Enable X-Ray tracing
+  tracing: Tracing.ACTIVE,
+
+  // Configure Powertools environment variables
   environment: {
     POWERTOOLS_SERVICE_NAME: "my-service",
     POWERTOOLS_METRICS_NAMESPACE: "MyService",

awslabs/cdk_mcp_server/static/lambda_powertools/metrics.md

@@ -55,39 +55,8 @@ def lambda_handler(event, context: LambdaContext):
 5. **Track both success and failure metrics**: Record metrics for both outcomes
 6. **Use consistent naming**: Follow a consistent naming convention for metrics
 
-## CloudWatch Dashboard Integration
-
-You can create CloudWatch dashboards to visualize your metrics:
-
-```typescript
-import { Dashboard, GraphWidget, Metric } from 'aws-cdk-lib/aws-cloudwatch';
-
-// Create a dashboard
-const dashboard = new Dashboard(this, 'PaymentsDashboard', {
-  dashboardName: 'PaymentsDashboard',
-});
-
-// Add a widget for payment metrics
-dashboard.addWidgets(
-  new GraphWidget({
-    title: 'Payment Processing',
-    left: [
-      new Metric({
-        namespace: 'PaymentService',
-        metricName: 'SuccessfulPayment',
-        dimensionsMap: {
-          service: 'payment-service',
-        },
-        statistic: 'Sum',
-      }),
-      new Metric({
-        namespace: 'PaymentService',
-        metricName: 'FailedPayment',
-        dimensionsMap: {
-          service: 'payment-service',
-        },
-        statistic: 'Sum',
-      }),
-    ],
-  })
-);
+## CDK Integration
+
+> **REMINDER**: Lambda Powertools requires a Lambda layer. See `lambda-powertools://cdk` for CDK integration details.
+
+For CloudWatch dashboard integration and other CDK-specific guidance, refer to `lambda-powertools://cdk`.

{awslabs_cdk_mcp_server-0.0.81650.dist-info → awslabs_cdk_mcp_server-0.0.101004.dist-info}/METADATA

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: awslabs.cdk-mcp-server
-Version: 0.0.81650
+Version: 0.0.101004
 Summary: An AWS CDK MCP server that provides guidance on AWS Cloud Development Kit best practices, infrastructure as code patterns, and security compliance with CDK Nag. This server offers tools to validate infrastructure designs, explain CDK Nag rules, analyze suppressions, generate Bedrock Agent schemas, and discover Solutions Constructs patterns.
 Requires-Python: >=3.10
 Requires-Dist: aws-lambda-powertools>=2.30.0
+Requires-Dist: bs4>=0.0.2
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: mcp[cli]>=1.6.0
 Requires-Dist: pydantic>=2.10.6
@@ -39,6 +40,13 @@ MCP server for AWS Cloud Development Kit (CDK) best practices, infrastructure as
 - Discover specialized constructs for AI/ML workloads
 - Get implementation guidance for generative AI applications
 
+### Lambda Layer Documentation Provider
+
+- Access comprehensive documentation for AWS Lambda layers
+- Get code examples for generic Lambda layers and Python-specific layers
+- Retrieve directory structure information and implementation best practices
+- Seamless integration with AWS Documentation MCP Server for detailed documentation
+
 ### Amazon Bedrock Agent Schema Generation
 
 - Use this tool when creating Bedrock Agents with Action Groups that use Lambda functions
@@ -57,20 +65,21 @@ This diagram provides a comprehensive view of the recommended CDK implementation
 
 ```mermaid
 graph TD
-    Start([Start]) --> Init["cdk init app"]
-    
+    Start([Start]) --> A["CDKGeneralGuidance"]
+    A --> Init["cdk init app"]
+
     Init --> B{Choose Approach}
     B -->|"Common Patterns"| C1["GetAwsSolutionsConstructPattern"]
     B -->|"GenAI Features"| C2["SearchGenAICDKConstructs"]
     B -->|"Custom Needs"| C3["Custom CDK Code"]
-    
+
     C1 --> D1["Implement Solutions Construct"]
     C2 --> D2["Implement GenAI Constructs"]
     C3 --> D3["Implement Custom Resources"]
-    
+
     %% Bedrock Agent with Action Groups specific flow
     D2 -->|"For Bedrock Agents<br/>with Action Groups"| BA["Create Lambda with<br/>BedrockAgentResolver"]
-    
+
     %% Schema generation flow
     BA --> BS["GenerateBedrockAgentSchema"]
     BS -->|"Success"| JSON["openapi.json created"]
@@ -78,28 +87,30 @@ graph TD
     BSF -->|"Missing dependencies?"| InstallDeps["Install dependencies"]
     InstallDeps --> BSR["Run script manually:<br/>python generate_schema.py"]
     BSR --> JSON["openapi.json created"]
-    
+
     %% Use schema in Agent CDK
     JSON --> AgentCDK["Use schema in<br/>Agent CDK code"]
     AgentCDK --> D2
-    
+
     %% Conditional Lambda Powertools implementation
     D1 & D2 & D3 --> HasLambda{"Using Lambda<br/>Functions?"}
-    HasLambda -->|"Yes"| L["Add Lambda Powertools<br/>and create Layer"]
-    HasLambda -->|"No"| SkipL["Skip Lambda<br/>Powertools"]
-    
+    HasLambda --> UseLayer{"Using Lambda<br/>Layers?"}
+    UseLayer -->|"Yes"| LLDP["LambdaLayerDocumentationProvider"]
+
+    HasLambda -->|"No"| SkipL["Skip"]
+
     %% Rest of workflow
-    L --> Synth["cdk synth"]
+    LLDP["LambdaLayerDocumentationProvider"] --> Synth["cdk synth"]
     SkipL --> Synth
-    
+
     Synth --> Nag{"CDK Nag<br/>warnings?"}
     Nag -->|Yes| E["ExplainCDKNagRule"]
     Nag -->|No| Deploy["cdk deploy"]
-    
+
     E --> Fix["Fix or Add Suppressions"]
     Fix --> CN["CheckCDKNagSuppressions"]
     CN --> Synth
-    
+
     %% Styling with darker colors
     classDef default fill:#424242,stroke:#ffffff,stroke-width:1px,color:#ffffff;
     classDef cmd fill:#4a148c,stroke:#ffffff,stroke-width:1px,color:#ffffff;
@@ -107,24 +118,35 @@ graph TD
     classDef note fill:#1b5e20,stroke:#ffffff,stroke-width:1px,color:#ffffff;
     classDef output fill:#006064,stroke:#ffffff,stroke-width:1px,color:#ffffff;
     classDef decision fill:#5d4037,stroke:#ffffff,stroke-width:1px,color:#ffffff;
-    
+
     class Init,Synth,Deploy,BSR cmd;
-    class C1,C2,BS,E,CN tool;
+    class A,C1,C2,BS,E,CN,LLDP tool;
     class JSON output;
-    class HasLambda,Nag decision;
+    class HasLambda,UseLayer,Nag decision;
 ```
 
-## Tools and Resources
+## Available MCP Tools
+
+- **CDKGeneralGuidance**: Get prescriptive advice for building AWS applications with CDK
+- **GetAwsSolutionsConstructPattern**: Find vetted architecture patterns combining AWS services
+- **SearchGenAICDKConstructs**: Discover GenAI CDK constructs by name or features
+- **GenerateBedrockAgentSchema**: Create OpenAPI schemas for Bedrock Agent action groups
+- **LambdaLayerDocumentationProvider**: Access documentation for Lambda layers implementation
+- **ExplainCDKNagRule**: Get detailed guidance on CDK Nag security rules
+- **CheckCDKNagSuppressions**: Validate CDK Nag suppressions in your code
+
+## Available MCP Resources
 
 - **CDK Nag Rules**: Access rule packs via `cdk-nag://rules/{rule_pack}`
-- **Lambda Powertools**: Get guidance on Lambda Powertools via `lambda-powertools://{topic}`
 - **AWS Solutions Constructs**: Access patterns via `aws-solutions-constructs://{pattern_name}`
 - **GenAI CDK Constructs**: Access documentation via `genai-cdk-constructs://{construct_type}/{construct_name}`
+- **Lambda Powertools**: Get guidance on Lambda Powertools via `lambda-powertools://{topic}`
 
 ## Prerequisites
 
 1. Install `uv` from [Astral](https://docs.astral.sh/uv/getting-started/installation/) or the [GitHub README](https://github.com/astral-sh/uv#installation)
 2. Install Python using `uv python install 3.10`
+3. Install AWS CDK CLI using `npm install -g aws-cdk` (Note: The MCP server itself doesn't use the CDK CLI directly, but it guides users through CDK application development that requires the CLI)
 
 ## Installation
 

{awslabs_cdk_mcp_server-0.0.81650.dist-info → awslabs_cdk_mcp_server-0.0.101004.dist-info}/RECORD

@@ -4,16 +4,17 @@ awslabs/cdk_mcp_server/server.py,sha256=Mom-3sv93jLG-KdESEfbrIEo3isXdAMhHcyTxANF
 awslabs/cdk_mcp_server/core/__init__.py,sha256=P5jMlOb_nAqCEM22QnIe9RZMUCLVHwmAnwqJInvcQfc,605
 awslabs/cdk_mcp_server/core/resources.py,sha256=DBIgjzhBorbjtDp-qRxq16oGnK39KHtZlKlUXXhKKC4,10152
 awslabs/cdk_mcp_server/core/search_utils.py,sha256=GLaNJBFzmDgwM8OY98R4VHfgj2Cw7GEBk-Y2lLZcPjM,6144
-awslabs/cdk_mcp_server/core/server.py,sha256=FmEb02_yu8kjr7PL-8fZ51Tu7ywl8kbMsxWMjrhvRlY,3145
-awslabs/cdk_mcp_server/core/tools.py,sha256=m_GkmypslKBbhOA8VcDQmXRhwaLUi9BvSi0OO0zqINs,19279
+awslabs/cdk_mcp_server/core/server.py,sha256=KsxXYBcS5TahpAcj0CnBmLvVcMDaZXddQhAKl2yU8pc,3238
+awslabs/cdk_mcp_server/core/tools.py,sha256=txBmmu-qeXWDDOm19gi7fkZ-fhpdb4r_xHwczdAHrIs,21562
 awslabs/cdk_mcp_server/data/__init__.py,sha256=8o7-TnXbiVvfwc_xc6LGnDfERnD9GMPRFfnWcgf--0Y,605
 awslabs/cdk_mcp_server/data/cdk_nag_parser.py,sha256=AKJU0O9lkzeVLAElzgBkV7rpKNUktywIXwmA52m3Vec,11477
 awslabs/cdk_mcp_server/data/construct_descriptions.py,sha256=CBfKFM_pJo6Sn_NA7hr-0oVB8piXdncQ_A5ewnTCx30,3164
 awslabs/cdk_mcp_server/data/genai_cdk_loader.py,sha256=detHbuKZYmJrsJi5UzZYZsU0hZJyykI_-QLw36itbE8,16156
+awslabs/cdk_mcp_server/data/lambda_layer_parser.py,sha256=TWInqjN56Vkhs-sXqLnIvhAPCBbq3Zlm1bAerUGb1cQ,8611
 awslabs/cdk_mcp_server/data/lambda_powertools_loader.py,sha256=XtJb8tTYhmAQ6Ulor6nhKWLQ56aIh2eElpBuw2D9sco,2411
 awslabs/cdk_mcp_server/data/schema_generator.py,sha256=hAVRE2Hue7nQVf61BjYWBhyqQx7s5_YmfPXxYR3t_sg,29251
-awslabs/cdk_mcp_server/data/solutions_constructs_parser.py,sha256=ceIZwKlj_zdxC1Z17NZ2FKCeVFwNZCoj7GwTjDlC_Q4,28215
-awslabs/cdk_mcp_server/static/CDK_GENERAL_GUIDANCE.md,sha256=aFUZvhfELhS7UEffFIzJM-tRS8a7Aj13X9O7FnGN0UI,12245
+awslabs/cdk_mcp_server/data/solutions_constructs_parser.py,sha256=NVOKV0cZl-9PdyoRtPo2JspSAEbCdebE8XR10dpCxyE,28243
+awslabs/cdk_mcp_server/static/CDK_GENERAL_GUIDANCE.md,sha256=-O0LIpmeDXr1JoVxxbQnVp0oNqvSbX20xOgcZqknr_c,8532
 awslabs/cdk_mcp_server/static/CDK_NAG_GUIDANCE.md,sha256=zJtHJp9ruaaJ-xa68k9kDrPmEaXpiWCZZf7JIy8NK0w,5839
 awslabs/cdk_mcp_server/static/__init__.py,sha256=Tq3PnIhXqHDYM8JWmGYaLz4rKX23X2zVxP_DpLVBeZo,770
 awslabs/cdk_mcp_server/static/genai_cdk/bedrock/bedrockguardrails.md,sha256=CX00B7XgDpLbVxvf6B-a13O4NERAJMiaPPeTuKK-8Sw,7386
@@ -34,18 +35,18 @@ awslabs/cdk_mcp_server/static/genai_cdk/bedrock/knowledgebases/transformation.md
 awslabs/cdk_mcp_server/static/genai_cdk/bedrock/knowledgebases/vector/aurora.md,sha256=CjiJDoaui2H4-nu99Sem4rK_8pQGB_ciI5So5pKWMSQ,5766
 awslabs/cdk_mcp_server/static/genai_cdk/bedrock/knowledgebases/vector/creation.md,sha256=jXxrwnor7_YUJc9sYCHjrQnCnHQrVItPI7YttcX-mX8,4491
 awslabs/cdk_mcp_server/static/genai_cdk/bedrock/knowledgebases/vector/opensearch.md,sha256=mM8nILHaFaLfHUaIl7c8Eh0NFx8Z5H4yu5LbC-DmnSU,1368
-awslabs/cdk_mcp_server/static/genai_cdk/bedrock/knowledgebases/vector/pinecone.md,sha256=OnKjSXB6CHBxnXJFGbsIRqpLyA6_S2AiHOJslxQVaOw,2053
+awslabs/cdk_mcp_server/static/genai_cdk/bedrock/knowledgebases/vector/pinecone.md,sha256=VmUGQ8ggMycrqA09RjUot_9gcBMO7H6gYspThGMkEDw,2107
 awslabs/cdk_mcp_server/static/genai_cdk/opensearch-vectorindex/overview.md,sha256=0aSuBwX4ubI5WqwEfrnX1MH2UJlJOzdXZQ003fRIrGM,4121
 awslabs/cdk_mcp_server/static/genai_cdk/opensearchserverless/overview.md,sha256=aUO1BRana_xqUPENP3GQyOSCAvV9mI-ZWls7x0g8ruA,746
-awslabs/cdk_mcp_server/static/lambda_powertools/bedrock.md,sha256=iqmnsoOQlXHOwsvF9U5quIclIBQvv4mEf2TGFnZI_SA,4284
-awslabs/cdk_mcp_server/static/lambda_powertools/cdk.md,sha256=XBj-31YcphHb1BjCYz4nRpAfPuVJVRmDYI2K7e6Ti8E,3826
+awslabs/cdk_mcp_server/static/lambda_powertools/bedrock.md,sha256=vxYfQvp2UcXSszAB4oQQ7xPY808WjKSPRgOnIA31nLk,4114
+awslabs/cdk_mcp_server/static/lambda_powertools/cdk.md,sha256=rcYvoKOEj9R2Ptd5H61spys8j09nLgmpkD_o2niynvs,1900
 awslabs/cdk_mcp_server/static/lambda_powertools/dependencies.md,sha256=nZ2Fv54rG1rUmD_YHkM9h5VNvB81-Hk8Qx3ZNQSFZLY,1520
 awslabs/cdk_mcp_server/static/lambda_powertools/index.md,sha256=yivjInZAZ3tENKGrrAv7geICzUvKUTskWuaNj9nuPbI,1819
-awslabs/cdk_mcp_server/static/lambda_powertools/insights.md,sha256=t-lgyx2AstqXuY7LeWyhQxknrPN27-nAcwW-GTjI058,3445
+awslabs/cdk_mcp_server/static/lambda_powertools/insights.md,sha256=jcyOHZvKHk2CgJwIu0B5SkP1SRMAhIOQ4FtWHlUs_IE,3212
 awslabs/cdk_mcp_server/static/lambda_powertools/logging.md,sha256=6CSgD8QB3Bs4s_x4RnbKwZoWvG6aG4etCnmDH6HU9XY,1797
-awslabs/cdk_mcp_server/static/lambda_powertools/metrics.md,sha256=XpQHtNSQRKN3GUqQWkk1lTfQSRC0LmW6VoX1dlwEvnQ,3182
+awslabs/cdk_mcp_server/static/lambda_powertools/metrics.md,sha256=DQlznxRizJep8jphzFgbk7crH5LwWjSjdygP-1K6mxk,2559
 awslabs/cdk_mcp_server/static/lambda_powertools/tracing.md,sha256=Q3dSCvgktb9sUsuuQ5ONU2Qdb1OTwbNOYpK--MDzBNw,2539
-awslabs_cdk_mcp_server-0.0.81650.dist-info/METADATA,sha256=z_gF-UvglmZxcwqGBNmjT3JGlfKUOMm5R_xFxMaqIO4,6508
-awslabs_cdk_mcp_server-0.0.81650.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-awslabs_cdk_mcp_server-0.0.81650.dist-info/entry_points.txt,sha256=LertzmID_mUU1YYZPySAF1IY1zE7ySTvzFxiGyo3VjY,78
-awslabs_cdk_mcp_server-0.0.81650.dist-info/RECORD,,
+awslabs_cdk_mcp_server-0.0.101004.dist-info/METADATA,sha256=qmFg6QAO3xhcbVS-qL8HP7ALvcrvU_d1uc1tdPEO5yQ,7763
+awslabs_cdk_mcp_server-0.0.101004.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+awslabs_cdk_mcp_server-0.0.101004.dist-info/entry_points.txt,sha256=LertzmID_mUU1YYZPySAF1IY1zE7ySTvzFxiGyo3VjY,78
+awslabs_cdk_mcp_server-0.0.101004.dist-info/RECORD,,