Add to Docker Desktop
Version 4.43 or later needs to be installed to add the server automatically
Tools
| Name | Description |
|---|---|
get_pricing | Get detailed pricing information from AWS Price List API with optional filters. **PARAMETERS:** - service_code (required): AWS service code (e.g., 'AmazonEC2', 'AmazonS3', 'AmazonES') - region (optional): AWS region string (e.g., 'us-east-1') OR list for multi-region comparison (e.g., ['us-east-1', 'eu-west-1']). Omit for global services like DataTransfer or CloudFront that don't have region-specific pricing. - filters (optional): List of filter dictionaries in format {'Field': str, 'Type': str, 'Value': str} - max_allowed_characters (optional): Response size limit in characters (default: 100,000, use -1 for unlimited) - output_options (optional): OutputOptions object for response transformation and size reduction - max_results (optional): Maximum number of results to return per page (default: 100, min: 1, max: 100) - next_token (optional): Pagination token from previous response to get next page of results **MANDATORY WORKFLOW - ALWAYS FOLLOW:** **Step 1: Discover Available Options** ```python service_codes = get_pricing_service_codes() # Find correct service (skip if known) attributes = get_pricing_service_attributes('AmazonEC2') # Discover filterable dimensions attribute_values = get_pricing_attribute_values('AmazonEC2', 'memory') # Get valid values for filtering ``` **Step 2: Build Precise Filters** ```python # Use ONLY values discovered in Step 1 filters = [ {"Field": "memory", "Value": ["8 GiB", "16 GiB", "32 GiB"], "Type": "ANY_OF"}, # Multiple options {"Field": "instanceType", "Value": "m5", "Type": "CONTAINS"}, # Pattern matching {"Field": "instanceType", "Value": ["t2", "m4"], "Type": "NONE_OF"} # Exclude older ] ``` **Step 3: Execute Query** ```python pricing = get_pricing('AmazonEC2', 'us-east-1', filters) ``` **FILTER TYPES:** - **EQUALS**: Exact match (default) - `{"Field": "instanceType", "Value": "m5.large"}` - **ANY_OF**: Multiple options - `{"Field": "memory", "Value": ["8 GiB", "16 GiB"], "Type": "ANY_OF"}` - **CONTAINS**: Pattern match - `{"Field": "instanceType", "Value": "m5", "Type": "CONTAINS"}` - **NONE_OF**: Exclusion - `{"Field": "instanceType", "Value": ["t2", "m4"], "Type": "NONE_OF"}` **CRITICAL: ANY_OF FILTER VALUE LIMITS:** - **1024 CHARACTER LIMIT**: Total length of all values in ANY_OF arrays cannot exceed 1024 characters - **PROGRESSIVE FILTERING**: Start with minimal qualifying options, expand if needed - **EXAMPLE VIOLATION**: `["8 GiB", "16 GiB", "32 GiB", "64 GiB", "96 GiB", "128 GiB", ...]` (TOO LONG) - **CORRECT APPROACH**: `["8 GiB", "16 GiB", "32 GiB", "36 GiB", "48 GiB"]` (TARGETED LIST) **COMMON USE CASES:** **COST OPTIMIZATION - EXHAUSTIVE MINIMUM-FIRST APPROACH:** When users ask for "lowest price", "cheapest", or cost optimization - **LOWER = CHEAPER ASSUMPTION**: For cost optimization, assume lower capabilities cost less than higher ones * 32 GB storage is cheaper than 300 GB storage * 8 GiB RAM is cheaper than 64 GiB RAM - **CRITICAL FOR COST QUERIES**: Start IMMEDIATELY above minimum requirement and test ALL options incrementally - **EXHAUSTIVE ENUMERATION REQUIRED**: Each storage/memory tier is MUTUALLY EXCLUSIVE - must list each one explicitly - **STOP AT REASONABLE UPPER BOUND**: For cost optimization, limit upper bound to 2-3x minimum requirement to avoid expensive options - **exclude_free_products**: ESSENTIAL for cost analysis - removes $0.00 reservation placeholders, SQL licensing variants, and special pricing entries that obscure actual billable instances when finding cheapest options - Use ANY_OF for efficient multi-option comparison in single API call - Multi-attribute capability filtering for minimum requirements - Combine CONTAINS + NONE_OF for refined discovery **OUTPUT OPTIONS (Response Size & Performance Control):** - **PURPOSE**: Transform and optimize API responses for ALL services, especially critical for large services (EC2, RDS) - **IMMEDIATE COMBINED APPROACH**: `{"pricing_terms": ["OnDemand", "FlatRate"], "product_attributes": ["instanceType", "location", "memory"]}` - **ATTRIBUTE DISCOVERY**: Use get_pricing_service_attributes() - same names for filters and output_options - **SIZE REDUCTION**: 80%+ reduction with combined pricing_terms + product_attributes - **exclude_free_products**: Remove products with $0.00 OnDemand pricing (useful when you know service has paid tiers) - **WHEN TO USE**: Always for large services, recommended for all services to improve performance **CRITICAL REQUIREMENTS:** - **NEVER GUESS VALUES**: Always use get_pricing_attribute_values() to discover valid options - **EXHAUSTIVE ENUMERATION**: For cost optimization, list ALL qualifying tiers individually - they are mutually exclusive - **USE SPECIFIC FILTERS**: Large services (EC2, RDS) require 2-3 filters minimum - **NEVER USE MULTIPLE CALLS**: When ANY_OF can handle it in one call - **VERIFY EXISTENCE**: Ensure all filter values exist in the service before querying - **FOR "CHEAPEST" QUERIES**: Focus on lower-end options that meet minimum requirements, test incrementally - **EXPLORE ALTERNATIVES**: When response includes "alternatives" field, MUST fetch their pricing if applicable to the use case before answering **CONSTRAINTS:** - **CURRENT PRICING ONLY**: Use get_price_list_urls for historical data - **NO SPOT/SAVINGS PLANS**: Only OnDemand, FlatRate, and Reserved Instance pricing available (ANY combination possible) - **CHARACTER LIMIT**: 100,000 characters default response limit (use output_options to reduce) - **REGION AUTO-FILTER**: Region parameter automatically creates regionCode filter **ANTI-PATTERNS:** - DO NOT make multiple API calls that could be combined with ANY_OF - DO NOT build cross-products manually when API can handle combinations - DO NOT call get_pricing_service_codes() when service code is already known (e.g., "AmazonEC2") - DO NOT use EQUALS without first checking get_pricing_attribute_values() - DO NOT skip discovery workflow for any use case - DO NOT use broad queries without specific filters on large services - DO NOT assume attribute values exist across different services/regions - DO NOT skip intermediate tiers: Missing 50GB, 59GB options when testing 32GB → 75GB jump - DO NOT set upper bounds too high: Including 500GB+ storage when user needs ≥30GB (wastes character limit) - DO NOT ignore alternatives field or use only ["OnDemand"] in output_options **EXAMPLE USE CASES:** **1. Cost-Optimized Multi-Attribute Filtering (CORRECT APPROACH):** ```python # Find cheapest EC2 instances meeting minimum requirements (>= 8 GiB memory, >= 30 GB storage) # EXHAUSTIVE ENUMERATION of qualifying tiers - each is mutually exclusive filters = [ {"Field": "memory", "Value": ["8 GiB", "16 GiB", "32 GiB"], "Type": "ANY_OF"}, # All tiers ≥8GB up to reasonable limit {"Field": "storage", "Value": ["1 x 32 SSD", "1 x 60 SSD", "1 x 75 NVMe SSD"], "Type": "ANY_OF"}, # All tiers ≥30GB up to reasonable limit {"Field": "instanceType", "Value": ["t2", "m4"], "Type": "NONE_OF"}, # Exclude older generations {"Field": "tenancy", "Value": "Shared", "Type": "EQUALS"} # Exclude more expensive dedicated ] pricing = get_pricing('AmazonEC2', 'us-east-1', filters) ``` **2. Efficient Multi-Region Comparison:** ```python # Compare same configuration across regions - use region parameter for multi-region filters = [{"Field": "instanceType", "Value": "m5.large", "Type": "EQUALS"}] pricing = get_pricing('AmazonEC2', ['us-east-1', 'us-west-2', 'eu-west-1'], filters) ``` **3. Large service with output optimization (recommended approach):** ```python output_options = {"pricing_terms": ["OnDemand", "FlatRate"], "product_attributes": ["instanceType", "location"], "exclude_free_products": true} pricing = get_pricing('AmazonEC2', 'us-east-1', filters, output_options=output_options) ``` **4. Pattern-Based Discovery:** ```python # Find all Standard storage tiers except expensive ones filters = [ {"Field": "storageClass", "Value": "Standard", "Type": "CONTAINS"}, {"Field": "storageClass", "Value": ["Standard-IA"], "Type": "NONE_OF"} ] ``` **FILTERING STRATEGY:** - **Large Services (EC2, RDS)**: ALWAYS use 2-3 specific filters to prevent 200+ record responses - **Small Services**: May work with single filter or no filters - **Multi-Option Analysis**: Use ANY_OF instead of multiple API calls - **Pattern Discovery**: Use CONTAINS for finding families or tiers - **Smart Exclusion**: Use NONE_OF for compliance or cost filtering **SUCCESS CRITERIA:** - Used discovery workflow (skip get_pricing_service_codes() if service known) - Applied appropriate filters for the service size - Used exact values from get_pricing_attribute_values() - Used ANY_OF for multi-option scenarios instead of multiple calls - For cost optimization: tested ALL qualifying tiers exhaustively (in a reasonable range) - Included ["OnDemand", "FlatRate"] in output_options and explored all alternatives |
get_pricing_attribute_values | Get valid values for pricing filter attributes. **PURPOSE:** Discover what values are available for specific pricing filter attributes of an AWS service. **WORKFLOW:** Use this after get_pricing_service_attributes() to see valid values for each filter attribute. **PARAMETERS:** - Service code from get_pricing_service_codes() (e.g., 'AmazonEC2', 'AmazonRDS') - List of attribute names from get_pricing_service_attributes() (e.g., ['instanceType', 'location']) - filters (optional): Dictionary mapping attribute names to regex patterns (e.g., {'instanceType': 't3'}) **RETURNS:** Dictionary mapping attribute names to their valid values. Filtered attributes return only matching values, unfiltered attributes return all values. **EXAMPLE RETURN:** ``` { 'instanceType': ['t2.micro', 't3.medium', 'm5.large', ...], 'location': ['US East (N. Virginia)', 'EU (London)', ...] } ``` **NEXT STEPS:** Use these values in get_pricing() filters to get specific pricing data. **ERROR HANDLING:** Uses "all-or-nothing" approach - if any attribute fails, the entire operation fails. **EXAMPLES:** - Single attribute: ['instanceType'] returns {'instanceType': ['t2.micro', 't3.medium', ...]} - Multiple attributes: ['instanceType', 'location'] returns both mappings - Partial filtering: filters={'instanceType': 't3'} applies only to instanceType, location returns all values |
get_pricing_service_attributes | Get filterable attributes available for an AWS service in the Pricing API. **PURPOSE:** Discover what pricing dimensions (filters) are available for a specific AWS service. **WORKFLOW:** Use this after get_pricing_service_codes() to see what filters you can apply to narrow down pricing queries. **PARAMETERS:** - service_code: AWS service code from get_pricing_service_codes() (e.g., 'AmazonEC2', 'AmazonRDS') - filter (optional): Case-insensitive regex pattern to filter attribute names (e.g., "instance" matches "instanceType", "instanceFamily") **RETURNS:** List of attribute names (e.g., 'instanceType', 'location', 'storageClass') that can be used as filters. **NEXT STEPS:** - Use get_pricing_attribute_values() to see valid values for each attribute - Use these attributes in get_pricing() filters to get specific pricing data **EXAMPLE:** For 'AmazonRDS' you might get ['engineCode', 'instanceType', 'deploymentOption', 'location']. |
get_pricing_service_codes | Get AWS service codes available in the Price List API. **PURPOSE:** Discover which AWS services have pricing information available in the AWS Price List API. **PARAMETERS:** - filter (optional): Case-insensitive regex pattern to filter service codes (e.g., "bedrock" matches "AmazonBedrock", "AmazonBedrockService") **WORKFLOW:** This is the starting point for any pricing query. Use this first to find the correct service code. **RETURNS:** List of service codes (e.g., 'AmazonEC2', 'AmazonS3', 'AWSLambda') that can be used with other pricing tools. **NEXT STEPS:** - Use get_pricing_service_attributes() to see what filters are available for a service - Use get_pricing() to get actual pricing data for a service **NOTE:** Service codes may differ from AWS console names (e.g., 'AmazonES' for OpenSearch, 'AWSLambda' for Lambda). |