AWS DynamoDB

Calculate DynamoDB capacity units and monthly costs from access patterns.

Call after completing data model design. Extracts patterns from Access Pattern Mapping table and tables from Table Designs section in dynamodb_data_model.md.

Args: access_pattern_list: Access patterns with fields:

• operation: GetItem|Query|Scan|PutItem|UpdateItem|DeleteItem|BatchGetItem|BatchWriteItem|TransactGetItems|TransactWriteItems
• pattern, description, table, rps (>0), item_size_bytes (1-409600)
• item_count: required for Query/Scan/Batch/Transact operations (>0)
• strongly_consistent: optional for GetItem/Query/Scan/BatchGetItem (default: false)
• gsi: optional for Query/Scan (target index name)
• gsi_list: optional for write operations (affected index names) table_list: Tables with name, item_count (>0), item_size_bytes (1-409600), gsi_list (each GSI needs name, item_count, item_size_bytes) workspace_dir: Absolute path to the folder containing dynamodb_data_model.md - report will be appended

Returns: {'status': 'success', 'message': <success_message>} or {'status': 'error', 'message': <error_reason>}

Example: { "access_pattern_list": [ { "operation": "GetItem", "pattern": "get-user", "description": "Get user by ID", "table": "users", "rps": 100, "item_size_bytes": 2000 }, { "operation": "Query", "pattern": "query-by-email", "description": "Query user by email", "table": "users", "rps": 50, "item_size_bytes": 1500, "item_count": 1, "gsi": "email-index" }, { "operation": "PutItem", "pattern": "put-user", "description": "Create user", "table": "users", "rps": 20, "item_size_bytes": 2000, "gsi_list": ["email-index", "status-index"] }, { "operation": "Query", "pattern": "query-orders", "description": "Query user orders", "table": "orders", "rps": 50, "item_size_bytes": 800, "item_count": 10 } ], "table_list": [ { "name": "users", "item_size_bytes": 2500, "item_count": 10000, "gsi_list": [ {"name": "email-index", "item_size_bytes": 1500, "item_count": 10000}, {"name": "status-index", "item_size_bytes": 500, "item_count": 10000} ] }, { "name": "orders", "item_size_bytes": 1024, "item_count": 50000 } ], "workspace_dir": "/absolute/path/to/workspace" }

Retrieves the DynamoDB Data Model Schema Converter Expert prompt.

This tool returns a specialized prompt for converting DynamoDB data models (dynamodb_data_model.md) into schema.json - a structured JSON representation used for generating type-safe entities and repositories. By default, also includes instructions for generating usage_data.json with realistic sample data.

The prompt guides through:

• Reading and parsing dynamodb_data_model.md files
• Converting table designs, GSIs, and access patterns into structured JSON format
• Validating generated schemas using the dynamodb_data_model_schema_validator tool
• Iteratively fixing validation errors (up to 8 iterations)
• Generating usage_data.json with realistic sample data from markdown tables (unless generate_usage_data=False)
• Creating isolated output folders with schema.json (and optionally usage_data.json)

When to set generate_usage_data=False:

• User explicitly asks for "schema only", "just schema", "without usage data", "without examples"
• User wants to skip sample data generation
• User only needs the schema structure for validation or review

Args: generate_usage_data: If True (default), includes instructions for generating usage_data.json. If False, only generates schema.json.

Returns: Complete schema converter expert prompt as text

Validates a schema.json file - the structured JSON representation of your DynamoDB data model.

This tool validates that your schema.json file is properly formatted and contains all required fields for use with the repository generation tool and other automation tools. It provides detailed error messages with suggestions for fixing any issues found.

Optionally, if usage_data_path is provided, it will also validate the usage_data.json file against the schema to ensure consistency.

The validation checks:

• Required sections (table_config, entities) exist
• All required fields are present
• Field types are valid (string, integer, decimal, boolean, array, object, uuid)
• Enum values are correct (operation types, return types, etc.)
• Pattern IDs are unique across all entities
• GSI names match between gsi_list and gsi_mappings
• Fields referenced in templates exist in entity fields
• Range conditions are valid and have correct parameter counts
• Access patterns have valid operations and return types
• Usage data validation (if usage_data_path provided)

Security:

• Schema files must be within the current working directory or subdirectories
• Path traversal attempts (e.g., ../../../../etc/passwd) are blocked

Args: schema_path: Absolute path to the schema.json file to validate usage_data_path: Optional absolute path to the usage_data.json file to validate

Returns: Validation result with either success message or detailed error messages with suggestions

Example Usage: dynamodb_data_model_schema_validator("/path/to/schema.json") dynamodb_data_model_schema_validator("/path/to/schema.json", "/path/to/usage_data.json")

Example Success Output: "✅ Schema validation passed!" or "✅ Schema validation passed! ✅ Usage data validation passed!"

Example Error Output: "❌ Schema validation failed:

• entities.User.fields[0].type: Invalid type value 'strng' 💡 Did you mean 'string'? Valid options: string, integer, decimal, boolean, array, object, uuid"

Validates and tests DynamoDB data models against DynamoDB Local.

Use this tool to validate, test, and verify your DynamoDB data model after completing the design phase. This tool automatically checks that all access patterns work correctly by executing them against a local DynamoDB instance.

WHEN TO USE:

• After completing data model design with dynamodb_data_modeling tool
• When user asks to "validate", "test", "check", or "verify" their DynamoDB data model
• To ensure all access patterns execute correctly before deploying to production

WHAT IT DOES:

1. If dynamodb_data_model.json doesn't exist:

• Returns complete JSON generation guide from json_generation_guide.md
• Follow the guide to create the JSON file with tables, items, and access_patterns
• Call this tool again after creating the JSON to validate

2. If dynamodb_data_model.json exists:

• Validates the JSON structure (checks for required keys: tables, items, access_patterns)
• Sets up DynamoDB Local environment (Docker/Podman/Finch/nerdctl or Java fallback)
• Cleans up existing tables from previous validation runs
• Creates tables and inserts test data from your model specification
• Tests all defined access patterns by executing their AWS CLI implementations
• Saves detailed validation results to dynamodb_model_validation.json
• Transforms results to markdown format for comprehensive review

WHAT TO DO ON SUCCESSFUL COMPLETION: After validation completes, you MUST present the user with TWO options:

1. Deploy to AWS: Call generate_resources tool with resource_type='cdk' to create a CDK app for provisioning tables
2. Generate Python code: Call dynamodb_data_model_schema_converter to convert the model to schema.json, then generate code

The user can choose one or both options. If they choose CDK first, you can still generate Python code afterward.

Args: workspace_dir: Absolute path of the workspace directory

Returns: JSON generation guide (if file missing) or validation results with transformation prompt (if file exists)

Retrieves the complete DynamoDB Data Modeling Expert prompt.

This tool returns a prompt to help user with data modeling on DynamoDB. The prompt guides through requirements gathering, access pattern analysis, and schema design. The prompt contains:

• Structured 2-phase workflow (requirements → final design)
• Enterprise design patterns: hot partition analysis, write sharding, sparse GSIs, and more
• Cost optimization strategies and RPS-based capacity planning
• Multi-table design philosophy with advanced denormalization patterns
• Integration guidance for OpenSearch, Lambda, and analytics

Usage: Simply call this tool to get the expert prompt.

Returns: Complete expert system prompt as text (no parameters required)

Generate Python code for a data access layer to interact with your DynamoDB tables.

🔴 PREREQUISITE: Before calling this tool, you MUST first call dynamodb_data_model_schema_converter to generate schema.json from dynamodb_data_model.md. This tool ONLY accepts schema.json.

TYPICAL WORKFLOW:

1. Complete data modeling with dynamodb_data_modeling tool (creates dynamodb_data_model.md)
2. Validate with dynamodb_data_model_validation tool (optional but recommended)
3. Optionally deploy infrastructure with generate_resources tool (resource_type='cdk')
4. Convert to schema: Call dynamodb_data_model_schema_converter tool (creates schema.json)
5. Generate code: Call this generate_data_access_layer tool with the path to schema.json

This tool generates a complete data access layer from your schema including:

• Type-safe entity classes with field validation using Pydantic
• Repository classes with optimistic locking and error handling for all operations
• Fully implemented access patterns
• Working usage examples with realistic sample data (if usage_data_path provided)

Args: schema_path: Path to the schema JSON file language: Target programming language for generated code (currently only 'python' supported) generate_sample_usage: Generate usage examples and test cases usage_data_path: Path to usage_data.json file for realistic sample data (optional)

Returns: Success message with output location and implementation guidance

Generates resources from a DynamoDB data model JSON file (dynamodb_data_model.json).

This tool generates various resources based on the provided dynamodb_data_model.json file. Currently supports generating a CDK app for deploying DynamoDB tables.

Supported resource types:

• cdk: CDK app for deploying DynamoDB tables. Generates a CDK app that provisions DynamoDB tables and GSIs as defined in dynamodb_data_model.json.

WHEN TO USE:

• After completing data model validation with dynamodb_data_model_validation tool
• When user asks to "deploy", "create CDK app", "generate CDK", or "provision infrastructure"
• When user wants to deploy their DynamoDB tables and GSIs to AWS using a CDK app

WHEN NOT TO USE:

• Before completing data model validation with dynamodb_data_model_validation tool
• Before having created the dynamodb_data_model.json file
• When user only wants to generate Python code without deploying infrastructure

WHAT TO DO ON SUCCESSFUL COMPLETION: After CDK generation completes, you MUST ask the user if they want to:

1. Deploy the CDK app now (provide deployment instructions)
2. Generate Python data access layer code to interact with the tables (call dynamodb_data_model_schema_converter then generate_data_access_layer)

Args: dynamodb_data_model_json_file: Absolute path to the dynamodb_data_model.json file resource_type: Type of resource to generate, possible values: cdk

Returns: Success message with the destination path, or error message if generation fails

Analyzes source database to extract schema and access patterns for DynamoDB modeling.

WHEN TO USE: Call this tool when the user selects "Existing Database Analysis" option after invoking the dynamodb_data_modeling tool. This extracts schema and query patterns from an existing relational database to accelerate DynamoDB data model design.

IMPORTANT: Always ask the user which execution mode they prefer before calling this tool.

Execution Modes:

• self_service: Generates SQL queries for user to run manually, then parses their results.
• managed (MySQL only): Database connection via RDS Data API or hostname.

Supported Databases: MySQL, PostgreSQL, SQL Server, Oracle

Output: Generates analysis files (schema structure, access patterns, relationships) in Markdown format. These files feed into the DynamoDB data modeling workflow to inform table design, GSI selection, and access pattern mapping.

Returns: Analysis summary with file locations and next steps.