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

awslabs/cdk_mcp_server/static/genai_cdk/bedrock/profiles.md

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

awslabs/cdk_mcp_server/static/genai_cdk/opensearch-vectorindex/overview.md

@@ -0,0 +1,135 @@
+# Amazon OpenSearch Vector Index Construct Library
+
+## Table of contents
+
+- [Amazon OpenSearch Vector Index Construct Library](#amazon-opensearch-vector-index-construct-library)
+  - [Table of contents](#table-of-contents)
+  - [API](#api)
+  - [Vector Index](#vector-index)
+  - [Example](#example)
+    - [TypeScript](#typescript)
+    - [Python](#python)
+  - [Default values](#default-values)
+
+## API
+
+See the [API documentation](../../../apidocs/namespaces/opensearch_vectorindex/README.md).
+
+## Vector Index
+
+The `VectorIndex` resource connects to OpenSearch and creates an index suitable for use with Amazon Bedrock Knowledge Bases.
+
+## Example
+
+### TypeScript
+
+```ts
+import {
+  opensearchserverless,
+  opensearch_vectorindex,
+} from '@cdklabs/generative-ai-cdk-constructs';
+
+const vectorStore = new opensearchserverless.VectorCollection(
+  this,
+  'VectorCollection'
+);
+
+new opensearch_vectorindex.VectorIndex(this, 'VectorIndex', {
+  collection: vectorStore,
+  indexName: 'bedrock-knowledge-base-default-index',
+  vectorField: 'bedrock-knowledge-base-default-vector',
+  vectorDimensions: 1536,
+  precision: 'float',
+  distanceType: 'l2',
+  mappings: [
+    {
+      mappingField: 'AMAZON_BEDROCK_TEXT_CHUNK',
+      dataType: 'text',
+      filterable: true,
+    },
+    {
+      mappingField: 'AMAZON_BEDROCK_METADATA',
+      dataType: 'text',
+      filterable: false,
+    },
+  ],
+  analyzer: {
+    characterFilters: [opensearchserverless.CharacterFilterType.ICU_NORMALIZER],
+    tokenizer: opensearchserverless.TokenizerType.KUROMOJI_TOKENIZER,
+    tokenFilters: [
+      opensearchserverless.TokenFilterType.KUROMOJI_BASEFORM,
+      opensearchserverless.TokenFilterType.JA_STOP,
+    ],
+  },
+});
+```
+
+### Python
+
+```python
+from cdklabs.generative_ai_cdk_constructs import (
+    opensearchserverless,
+    opensearch_vectorindex,
+)
+
+vectorCollection = opensearchserverless.VectorCollection(self, "VectorCollection")
+
+vectorIndex = opensearch_vectorindex.VectorIndex(self, "VectorIndex",
+    vector_dimensions= 1536,
+    collection=vectorCollection,
+    index_name='bedrock-knowledge-base-default-index',
+    vector_field='bedrock-knowledge-base-default-vector',
+    precision='float',
+    distance_type='l2',
+    mappings= [
+        opensearch_vectorindex.MetadataManagementFieldProps(
+            mapping_field='AMAZON_BEDROCK_TEXT_CHUNK',
+            data_type='text',
+            filterable=True
+        ),
+        opensearch_vectorindex.MetadataManagementFieldProps(
+            mapping_field='AMAZON_BEDROCK_METADATA',
+            data_type='text',
+            filterable=False
+        )
+    ],
+    analyzer=opensearchserverless.AnalyzerProps(
+        character_filters=[opensearchserverless.CharacterFilterType.ICU_NORMALIZER],
+        tokenizer=opensearchserverless.TokenizerType.KUROMOJI_TOKENIZER,
+        token_filters=[
+            opensearchserverless.TokenFilterType.KUROMOJI_BASEFORM,
+            opensearchserverless.TokenFilterType.JA_STOP,
+        ],
+    )
+)
+```
+
+## Default values
+
+Behind the scenes, the custom resource creates a k-NN vector in the OpenSearch index, allowing to perform different kinds of k-NN search. The knn_vector field is highly configurable and can serve many different k-NN workloads. It is created as follows:
+
+Python
+
+```py
+"properties": {
+            vector_field: {
+                "type": "knn_vector",
+                "dimension": dimensions,
+                "data_type": precision,
+                "method": {
+                    "engine": "faiss",
+                    "space_type": distance_type,
+                    "name": "hnsw",
+                    "parameters": {},
+                },
+            },
+            "id": {
+                "type": "text",
+                "fields": {"keyword": {"type": "keyword", "ignore_above": 256}},
+            },
+        },
+```
+
+Users can currently configure the ```vector_field```, ```dimension```, ```data_type```, and ```distance_type``` fields through the construct interface.
+
+For details on the different settings, you can refer to the [Knn plugin documentation](https://opensearch.org/docs/latest/search-plugins/knn/knn-index/).

awslabs/cdk_mcp_server/static/genai_cdk/opensearchserverless/overview.md

@@ -0,0 +1,17 @@
+# Amazon OpenSearch Serverless Construct Library
+
+## Table of contents
+
+- [API](#api)
+- [Vector Collection](#vector-collection)
+
+## API
+See the [API documentation](../../../apidocs/namespaces/opensearchserverless/README.md).
+
+## Vector Collection
+
+This resource creates an Amazon OpenSearch Serverless collection configured for `VECTORSEARCH`. It creates default encryption, network, and data policies for use with Amazon Bedrock Knowledge Bases. For encryption, it uses the default AWS owned KMS key. It allows network connections from the public internet, but access is restricted to specific IAM principals.
+
+### Granting Data Access
+
+The `grantDataAccess` method grants the specified role access to read and write the data in the collection.

awslabs/cdk_mcp_server/static/lambda_powertools/bedrock.md

@@ -0,0 +1,127 @@
+# Bedrock Agent Integration
+
+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 pydantic import BaseModel, Field
+
+# Initialize Powertools
+logger = Logger(service="agent-actions")
+app = BedrockAgentResolver()
+
+# Define request/response models with type hints
+class Product(BaseModel):
+    product_id: str = Field(description="Unique product identifier")
+    name: str = Field(description="Product name")
+    price: float = Field(description="Product price in USD")
+
+@app.get("/products", description="List all products")
+def list_products(
+    category: Optional[str] = Query(None, description="Filter by category")
+) -> List[Product]:
+    """Get a list of products, optionally filtered by category"""
+    logger.info("Listing products", extra={"category": category})
+
+    # Your business logic here
+    products = get_products_from_database(category)
+
+    return products
+
+@logger.inject_lambda_context
+def lambda_handler(event, context):
+    """Main Lambda handler for Bedrock Agent actions"""
+    return app.resolve(event, context)
+```
+
+## Key Benefits
+
+- **Type Safety**: Pydantic models ensure type safety and validation
+- **OpenAPI Schema Generation**: Automatically generates OpenAPI schemas for Bedrock Agents
+- **Structured Logging**: Integrates with Lambda Powertools logging
+- **Parameter Validation**: Automatically validates request parameters
+- **Documentation**: Generates documentation for your API
+
+## 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="GenerateBedrockAgentSchemaFromFile",
+    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
+
+## 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
+
+## CDK Integration
+
+```typescript
+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 * as path from 'path';
+
+// 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,
+  environment: {
+    POWERTOOLS_SERVICE_NAME: "agent-actions",
+    LOG_LEVEL: "INFO",
+  },
+});
+
+// Create a Bedrock Agent
+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',
+    description: 'Actions for managing products',
+    executor: bedrock.ActionGroupExecutor.fromlambdaFunction(actionFunction),
+    apiSchema: bedrock.ApiSchema.fromAsset(
+      path.join(__dirname, '../schema/product_actions.json')
+    ),
+  })
+);
+
+// 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

@@ -0,0 +1,99 @@
+# CDK Integration
+
+Integrate Lambda Powertools with CDK:
+
+> **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`.
+
+```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
+
+  // Enable X-Ray tracing
+  tracing: Tracing.ACTIVE,
+
+  // Configure Powertools environment variables
+  environment: {
+    POWERTOOLS_SERVICE_NAME: "payment-service",
+    POWERTOOLS_METRICS_NAMESPACE: "PaymentService",
+    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
+- **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
+  },
+});
+```
+
+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.

awslabs/cdk_mcp_server/static/lambda_powertools/dependencies.md

@@ -0,0 +1,45 @@
+# Dependencies
+
+When using Lambda Powertools features, use the appropriate extras syntax to ensure all required dependencies are included:
+
+```bash
+# For tracing only
+pip install "aws-lambda-powertools[tracer]"
+
+# For validation and parser features
+pip install "aws-lambda-powertools[validation]"
+
+# For all features
+pip install "aws-lambda-powertools[all]"
+```
+
+This approach ensures that all required dependencies (like aws_xray_sdk for tracing) are automatically included without having to specify them individually.
+
+## Why Extras Are Important
+
+Since version 2.0.0 of Lambda Powertools, the package has been optimized to reduce its size by making certain dependencies optional. This means:
+
+1. The base package (`aws-lambda-powertools`) does not include all dependencies
+2. Features like Tracer require additional dependencies (e.g., `aws_xray_sdk`)
+3. Using extras ensures you get the right dependencies for the features you use
+
+## Available Extras
+
+| Extra | Description | Key Dependencies |
+|-------|-------------|-----------------|
+| `tracer` | For X-Ray tracing | `aws_xray_sdk` |
+| `validation` | For event validation | `pydantic` |
+| `parser` | For event parsing | `pydantic` |
+| `all` | All features | All dependencies |
+
+## In requirements.txt
+
+For CDK deployments, make sure your dependency management system uses these extras specifications rather than just the base package:
+
+```
+# For specific features
+aws-lambda-powertools[tracer]>=2.0.0
+
+# OR for all features
+aws-lambda-powertools[all]>=2.0.0
+```

awslabs/cdk_mcp_server/static/lambda_powertools/index.md

@@ -0,0 +1,36 @@
+# AWS Lambda Powertools Guidance
+
+This guide provides essential patterns for implementing AWS Lambda Powertools to enhance your serverless applications with observability and operational excellence.
+
+## Core Capabilities
+
+AWS Lambda Powertools provides three core capabilities to improve your serverless applications:
+
+1. **Structured Logging**: Transform text logs into JSON objects with consistent fields for better filtering and analysis
+2. **Tracing**: Gain visibility into request flows across distributed services with AWS X-Ray integration
+3. **Metrics**: Collect quantitative data about your application's behavior with CloudWatch Metrics
+
+## Table of Contents
+
+- [Structured Logging](lambda-powertools://logging): Transform text logs into JSON objects with consistent fields
+- [Tracing](lambda-powertools://tracing): Gain visibility into request flows across distributed services
+- [Metrics](lambda-powertools://metrics): Collect quantitative data about your application's behavior
+- [CDK Integration](lambda-powertools://cdk): Integrate Lambda Powertools with AWS CDK
+- [Dependencies](lambda-powertools://dependencies): Manage Lambda Powertools dependencies correctly
+- [Lambda Insights](lambda-powertools://insights): Enhanced monitoring with CloudWatch Lambda Insights
+- [Bedrock Agent Integration](lambda-powertools://bedrock): Use Lambda Powertools with Amazon Bedrock Agents
+
+## Getting Started
+
+To get started with Lambda Powertools, install the package with the appropriate extras for your needs:
+
+```bash
+# For all features
+pip install "aws-lambda-powertools[all]"
+
+# For specific features
+pip install "aws-lambda-powertools[tracer]"  # For tracing only
+pip install "aws-lambda-powertools[validation]"  # For validation only
+```
+
+Then follow the guidance in the specific sections for each capability.