server.json

{
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
  "_meta": {
    "io.modelcontextprotocol.registry/publisher-provided": {
      "io.github.stacklok": {
        "public.ecr.aws/f3y8w4n0/awslabs/aws-pricing-mcp-server:1.0.25": {
          "metadata": {
            "last_updated": "2026-03-05T20:39:52Z",
            "stars": 8259
          },
          "overview": "## AWS Pricing MCP Server\n\nThe aws-pricing MCP server is a Model Context Protocol (MCP) server that gives AI assistants programmatic access to AWS pricing data through a structured interface. It allows AI-driven workflows to retrieve up-to-date pricing information for AWS services, instances, and usage dimensions, enabling cost estimation, comparison, and optimization tasks without manual navigation of pricing pages or spreadsheets. This server is particularly useful for cost modeling, architectural tradeoff analysis, and budget-aware automation inside AI assistants.",
          "permissions": {
            "network": {
              "outbound": {
                "allow_host": [
                  "aws.amazon.com",
                  "pricing.us-east-1.amazonaws.com",
                  "api.pricing.us-east-1.amazonaws.com",
                  "api.pricing.eu-central-1.amazonaws.com",
                  "api.pricing.ap-southeast-1.amazonaws.com"
                ],
                "allow_port": [
                  443
                ]
              }
            }
          },
          "status": "Active",
          "tags": [
            "aws",
            "cost-analysis",
            "pricing",
            "estimates",
            "cost-insights",
            "aws-costs",
            "aws-pricing"
          ],
          "tier": "Official",
          "tool_definitions": [
            {
              "annotations": {
                "readOnlyHint": true
              },
              "description": "Analyze a CDK project to identify AWS services used. This tool dynamically extracts service information from CDK constructs without relying on hardcoded service mappings.",
              "inputSchema": {
                "properties": {
                  "project_path": {
                    "description": "Path to the project directory",
                    "title": "Project Path",
                    "type": "string"
                  }
                },
                "required": [
                  "project_path"
                ],
                "type": "object"
              },
              "name": "analyze_cdk_project"
            },
            {
              "annotations": {
                "readOnlyHint": true
              },
              "description": "Analyze a Terraform project to identify AWS services used. This tool dynamically extracts service information from Terraform resource declarations.",
              "inputSchema": {
                "properties": {
                  "project_path": {
                    "description": "Path to the project directory",
                    "title": "Project Path",
                    "type": "string"
                  }
                },
                "required": [
                  "project_path"
                ],
                "type": "object"
              },
              "name": "analyze_terraform_project"
            },
            {
              "annotations": {
                "readOnlyHint": true
              },
              "description": "Generate a detailed cost analysis report based on pricing data for one or more AWS services.\n\nThis tool requires AWS pricing data and provides options for adding detailed cost information.\n\nIMPORTANT REQUIREMENTS:\n- ALWAYS include detailed unit pricing information (e.g., \"$0.0008 per 1K input tokens\")\n- ALWAYS show calculation breakdowns (unit price × usage = total cost)\n- ALWAYS specify the pricing model (e.g., \"ON DEMAND\")\n- ALWAYS list all assumptions and exclusions explicitly\n\nOutput Format Options:\n- 'markdown' (default): Generates a well-formatted markdown report\n- 'csv': Generates a CSV format report with sections for service information, unit pricing, cost calculations, etc.\n\nExample usage:\n\n```json\n{\n  // Required parameters\n  \"pricing_data\": {\n    // This should contain pricing data retrieved from get_pricing\n    \"status\": \"success\",\n    \"service_name\": \"bedrock\",\n    \"data\": \"... pricing information ...\",\n    \"message\": \"Retrieved pricing for bedrock from AWS Pricing url\"\n  },\n  \"service_name\": \"Amazon Bedrock\",\n\n  // Core parameters (commonly used)\n  \"related_services\": [\"Lambda\", \"S3\"],\n  \"pricing_model\": \"ON DEMAND\",\n  \"assumptions\": [\n    \"Standard ON DEMAND pricing model\",\n    \"No caching or optimization applied\",\n    \"Average request size of 4KB\"\n  ],\n  \"exclusions\": [\n    \"Data transfer costs between regions\",\n    \"Custom model training costs\",\n    \"Development and maintenance costs\"\n  ],\n  \"output_file\": \"cost_analysis_report.md\",  // or \"cost_analysis_report.csv\" for CSV format\n  \"format\": \"markdown\",  // or \"csv\" for CSV format\n\n  // Advanced parameter for complex scenarios\n  \"detailed_cost_data\": {\n    \"services\": {\n      \"Amazon Bedrock Foundation Models\": {\n        \"usage\": \"Processing 1M input tokens and 500K output tokens with Claude 3.5 Haiku\",\n        \"estimated_cost\": \"$80.00\",\n        \"free_tier_info\": \"No free tier for Bedrock foundation models\",\n        \"unit_pricing\": {\n          \"input_tokens\": \"$0.0008 per 1K tokens\",\n          \"output_tokens\": \"$0.0016 per 1K tokens\"\n        },\n        \"usage_quantities\": {\n          \"input_tokens\": \"1,000,000 tokens\",\n          \"output_tokens\": \"500,000 tokens\"\n        },\n        \"calculation_details\": \"$0.0008/1K × 1,000K input tokens + $0.0016/1K × 500K output tokens = $80.00\"\n      },\n      \"AWS Lambda\": {\n        \"usage\": \"6,000 requests per month with 512 MB memory\",\n        \"estimated_cost\": \"$0.38\",\n        \"free_tier_info\": \"First 12 months: 1M requests/month free\",\n        \"unit_pricing\": {\n          \"requests\": \"$0.20 per 1M requests\",\n          \"compute\": \"$0.0000166667 per GB-second\"\n        },\n        \"usage_quantities\": {\n          \"requests\": \"6,000 requests\",\n          \"compute\": \"6,000 requests × 1s × 0.5GB = 3,000 GB-seconds\"\n        },\n        \"calculation_details\": \"$0.20/1M × 0.006M requests + $0.0000166667 × 3,000 GB-seconds = $0.38\"\n      }\n    }\n  },\n\n  // Recommendations parameter - can be provided directly or generated\n  \"recommendations\": {\n    \"immediate\": [\n      \"Optimize prompt engineering to reduce token usage for Claude 3.5 Haiku\",\n      \"Configure Knowledge Base OCUs based on actual query patterns\",\n      \"Implement response caching for common queries to reduce token usage\"\n    ],\n    \"best_practices\": [\n      \"Monitor OCU utilization metrics and adjust capacity as needed\",\n      \"Use prompt caching for repeated context across API calls\",\n      \"Consider provisioned throughput for predictable workloads\"\n    ]\n  }\n}\n```\n",
              "inputSchema": {
                "properties": {
                  "assumptions": {
                    "anyOf": [
                      {
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "default": null,
                    "description": "List of assumptions for cost analysis",
                    "title": "Assumptions"
                  },
                  "detailed_cost_data": {
                    "anyOf": [
                      {
                        "additionalProperties": true,
                        "type": "object"
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "default": null,
                    "description": "Detailed cost information for complex scenarios",
                    "title": "Detailed Cost Data"
                  },
                  "exclusions": {
                    "anyOf": [
                      {
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "default": null,
                    "description": "List of items excluded from cost analysis",
                    "title": "Exclusions"
                  },
                  "format": {
                    "default": "markdown",
                    "description": "Output format (\"markdown\" or \"csv\")",
                    "title": "Format",
                    "type": "string"
                  },
                  "output_file": {
                    "anyOf": [
                      {
                        "type": "string"
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "default": null,
                    "description": "Path to save the report file",
                    "title": "Output File"
                  },
                  "pricing_data": {
                    "additionalProperties": true,
                    "description": "Raw pricing data from AWS pricing tools",
                    "title": "Pricing Data",
                    "type": "object"
                  },
                  "pricing_model": {
                    "default": "ON DEMAND",
                    "description": "Pricing model (e.g., \"ON DEMAND\", \"Reserved\")",
                    "title": "Pricing Model",
                    "type": "string"
                  },
                  "recommendations": {
                    "anyOf": [
                      {
                        "additionalProperties": true,
                        "type": "object"
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "default": null,
                    "description": "Direct recommendations or guidance for generation",
                    "title": "Recommendations"
                  },
                  "related_services": {
                    "anyOf": [
                      {
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "default": null,
                    "description": "List of related AWS services",
                    "title": "Related Services"
                  },
                  "service_name": {
                    "description": "Name of the AWS service",
                    "title": "Service Name",
                    "type": "string"
                  }
                },
                "required": [
                  "pricing_data",
                  "service_name"
                ],
                "type": "object"
              },
              "name": "generate_cost_report"
            },
            {
              "annotations": {
                "readOnlyHint": true
              },
              "description": "Get architecture patterns for Amazon Bedrock applications, including component relationships and cost considerations",
              "inputSchema": {
                "properties": {},
                "required": [],
                "type": "object"
              },
              "name": "get_bedrock_patterns"
            },
            {
              "annotations": {
                "readOnlyHint": true
              },
              "description": "Get download URLs for bulk pricing data files.\n\n    **PURPOSE:** Access complete AWS pricing datasets as downloadable files for historical analysis and bulk processing.\n\n    **WORKFLOW:** Use this for historical pricing analysis or bulk data processing when current pricing from get_pricing() isn't sufficient.\n\n    **PARAMETERS:**\n    - Service code from get_pricing_service_codes() (e.g., 'AmazonEC2', 'AmazonS3')\n    - AWS region (e.g., 'us-east-1', 'eu-west-1')\n    - Optional: effective_date for historical pricing (default: current date)\n\n    **RETURNS:** Dictionary with download URLs for different formats:\n    - 'csv': Direct download URL for CSV format\n    - 'json': Direct download URL for JSON format\n\n    **USE CASES:**\n    - Historical pricing analysis (get_pricing() only provides current pricing)\n    - Bulk data processing without repeated API calls\n    - Offline analysis of complete pricing datasets\n    - Savings Plans analysis across services\n\n    **FILE PROCESSING:**\n    - CSV files: Lines 1-5 are metadata, Line 6 contains headers, Line 7+ contains pricing data\n    - Use `tail -n +7 pricing.csv | grep \"t3.medium\"` to filter data\n    ",
              "inputSchema": {
                "properties": {
                  "effective_date": {
                    "anyOf": [
                      {
                        "type": "string"
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "default": null,
                    "description": "Effective date for pricing in format \"YYYY-MM-DD HH:MM\" (default: current timestamp)",
                    "title": "Effective Date"
                  },
                  "region": {
                    "description": "AWS region (e.g., \"us-east-1\", \"eu-west-1\")",
                    "title": "Region",
                    "type": "string"
                  },
                  "service_code": {
                    "description": "AWS service code (e.g., \"AmazonEC2\", \"AmazonS3\", \"AmazonES\")",
                    "title": "Service Code",
                    "type": "string"
                  }
                },
                "required": [
                  "service_code",
                  "region"
                ],
                "type": "object"
              },
              "name": "get_price_list_urls"
            },
            {
              "annotations": {
                "readOnlyHint": true
              },
              "description": "\n    Get detailed pricing information from AWS Price List API with optional filters.\n\n    **PARAMETERS:**\n    - service_code (required): AWS service code (e.g., 'AmazonEC2', 'AmazonS3', 'AmazonES')\n    - 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.\n    - filters (optional): List of filter dictionaries in format {'Field': str, 'Type': str, 'Value': str}\n    - max_allowed_characters (optional): Response size limit in characters (default: 100,000, use -1 for unlimited)\n    - output_options (optional): OutputOptions object for response transformation and size reduction\n    - max_results (optional): Maximum number of results to return per page (default: 100, min: 1, max: 100)\n    - next_token (optional): Pagination token from previous response to get next page of results\n\n    **MANDATORY WORKFLOW - ALWAYS FOLLOW:**\n\n    **Step 1: Discover Available Options**\n    ```python\n    service_codes = get_pricing_service_codes()                              # Find correct service (skip if known)\n    attributes = get_pricing_service_attributes('AmazonEC2')                 # Discover filterable dimensions\n    attribute_values = get_pricing_attribute_values('AmazonEC2', 'memory')   # Get valid values for filtering\n    ```\n\n    **Step 2: Build Precise Filters**\n    ```python\n    # Use ONLY values discovered in Step 1\n    filters = [\n       {\"Field\": \"memory\", \"Value\": [\"8 GiB\", \"16 GiB\", \"32 GiB\"], \"Type\": \"ANY_OF\"},     # Multiple options\n       {\"Field\": \"instanceType\", \"Value\": \"m5\", \"Type\": \"CONTAINS\"},                      # Pattern matching\n       {\"Field\": \"instanceType\", \"Value\": [\"t2\", \"m4\"], \"Type\": \"NONE_OF\"}                # Exclude older\n   ]\n    ```\n\n    **Step 3: Execute Query**\n    ```python\n    pricing = get_pricing('AmazonEC2', 'us-east-1', filters)\n    ```\n\n    **FILTER TYPES:**\n    - **EQUALS**: Exact match (default) - `{\"Field\": \"instanceType\", \"Value\": \"m5.large\"}`\n    - **ANY_OF**: Multiple options - `{\"Field\": \"memory\", \"Value\": [\"8 GiB\", \"16 GiB\"], \"Type\": \"ANY_OF\"}`\n    - **CONTAINS**: Pattern match - `{\"Field\": \"instanceType\", \"Value\": \"m5\", \"Type\": \"CONTAINS\"}`\n    - **NONE_OF**: Exclusion - `{\"Field\": \"instanceType\", \"Value\": [\"t2\", \"m4\"], \"Type\": \"NONE_OF\"}`\n\n    **CRITICAL: ANY_OF FILTER VALUE LIMITS:**\n    - **1024 CHARACTER LIMIT**: Total length of all values in ANY_OF arrays cannot exceed 1024 characters\n    - **PROGRESSIVE FILTERING**: Start with minimal qualifying options, expand if needed\n    - **EXAMPLE VIOLATION**: `[\"8 GiB\", \"16 GiB\", \"32 GiB\", \"64 GiB\", \"96 GiB\", \"128 GiB\", ...]` (TOO LONG)\n    - **CORRECT APPROACH**: `[\"8 GiB\", \"16 GiB\", \"32 GiB\", \"36 GiB\", \"48 GiB\"]` (TARGETED LIST)\n\n    **COMMON USE CASES:**\n\n    **COST OPTIMIZATION - EXHAUSTIVE MINIMUM-FIRST APPROACH:** When users ask for \"lowest price\", \"cheapest\", or cost optimization\n    - **LOWER = CHEAPER ASSUMPTION**: For cost optimization, assume lower capabilities cost less than higher ones\n      * 32 GB storage is cheaper than 300 GB storage\n      * 8 GiB RAM is cheaper than 64 GiB RAM\n    - **CRITICAL FOR COST QUERIES**: Start IMMEDIATELY above minimum requirement and test ALL options incrementally\n    - **EXHAUSTIVE ENUMERATION REQUIRED**: Each storage/memory tier is MUTUALLY EXCLUSIVE - must list each one explicitly\n    - **STOP AT REASONABLE UPPER BOUND**: For cost optimization, limit upper bound to 2-3x minimum requirement to avoid expensive options\n    - **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\n    - Use ANY_OF for efficient multi-option comparison in single API call\n    - Multi-attribute capability filtering for minimum requirements\n    - Combine CONTAINS + NONE_OF for refined discovery\n\n    **OUTPUT OPTIONS (Response Size \u0026 Performance Control):**\n    - **PURPOSE**: Transform and optimize API responses for ALL services, especially critical for large services (EC2, RDS)\n    - **IMMEDIATE COMBINED APPROACH**: `{\"pricing_terms\": [\"OnDemand\", \"FlatRate\"], \"product_attributes\": [\"instanceType\", \"location\", \"memory\"]}`\n    - **ATTRIBUTE DISCOVERY**: Use get_pricing_service_attributes() - same names for filters and output_options\n    - **SIZE REDUCTION**: 80%+ reduction with combined pricing_terms + product_attributes\n    - **exclude_free_products**: Remove products with $0.00 OnDemand pricing (useful when you know service has paid tiers)\n    - **WHEN TO USE**: Always for large services, recommended for all services to improve performance\n\n    **CRITICAL REQUIREMENTS:**\n    - **NEVER GUESS VALUES**: Always use get_pricing_attribute_values() to discover valid options\n    - **EXHAUSTIVE ENUMERATION**: For cost optimization, list ALL qualifying tiers individually - they are mutually exclusive\n    - **USE SPECIFIC FILTERS**: Large services (EC2, RDS) require 2-3 filters minimum\n    - **NEVER USE MULTIPLE CALLS**: When ANY_OF can handle it in one call\n    - **VERIFY EXISTENCE**: Ensure all filter values exist in the service before querying\n    - **FOR \"CHEAPEST\" QUERIES**: Focus on lower-end options that meet minimum requirements, test incrementally\n    - **EXPLORE ALTERNATIVES**: When response includes \"alternatives\" field, MUST fetch their pricing if applicable to the use case before answering\n\n    **CONSTRAINTS:**\n    - **CURRENT PRICING ONLY**: Use get_price_list_urls for historical data\n    - **NO SPOT/SAVINGS PLANS**: Only OnDemand, FlatRate, and Reserved Instance pricing available (ANY combination possible)\n    - **CHARACTER LIMIT**: 100,000 characters default response limit (use output_options to reduce)\n    - **REGION AUTO-FILTER**: Region parameter automatically creates regionCode filter\n\n    **ANTI-PATTERNS:**\n    - DO NOT make multiple API calls that could be combined with ANY_OF\n    - DO NOT build cross-products manually when API can handle combinations\n    - DO NOT call get_pricing_service_codes() when service code is already known (e.g., \"AmazonEC2\")\n    - DO NOT use EQUALS without first checking get_pricing_attribute_values()\n    - DO NOT skip discovery workflow for any use case\n    - DO NOT use broad queries without specific filters on large services\n    - DO NOT assume attribute values exist across different services/regions\n    - DO NOT skip intermediate tiers: Missing 50GB, 59GB options when testing 32GB → 75GB jump\n    - DO NOT set upper bounds too high: Including 500GB+ storage when user needs ≥30GB (wastes character limit)\n    - DO NOT ignore alternatives field or use only [\"OnDemand\"] in output_options\n\n    **EXAMPLE USE CASES:**\n\n    **1. Cost-Optimized Multi-Attribute Filtering (CORRECT APPROACH):**\n    ```python\n    # Find cheapest EC2 instances meeting minimum requirements (\u003e= 8 GiB memory, \u003e= 30 GB storage)\n    # EXHAUSTIVE ENUMERATION of qualifying tiers - each is mutually exclusive\n    filters = [\n       {\"Field\": \"memory\", \"Value\": [\"8 GiB\", \"16 GiB\", \"32 GiB\"], \"Type\": \"ANY_OF\"},  # All tiers ≥8GB up to reasonable limit\n       {\"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\n       {\"Field\": \"instanceType\", \"Value\": [\"t2\", \"m4\"], \"Type\": \"NONE_OF\"},  # Exclude older generations\n       {\"Field\": \"tenancy\", \"Value\": \"Shared\", \"Type\": \"EQUALS\"}  # Exclude more expensive dedicated\n    ]\n    pricing = get_pricing('AmazonEC2', 'us-east-1', filters)\n    ```\n\n    **2. Efficient Multi-Region Comparison:**\n    ```python\n    # Compare same configuration across regions - use region parameter for multi-region\n    filters = [{\"Field\": \"instanceType\", \"Value\": \"m5.large\", \"Type\": \"EQUALS\"}]\n    pricing = get_pricing('AmazonEC2', ['us-east-1', 'us-west-2', 'eu-west-1'], filters)\n    ```\n\n    **3. Large service with output optimization (recommended approach):**\n    ```python\n    output_options = {\"pricing_terms\": [\"OnDemand\", \"FlatRate\"], \"product_attributes\": [\"instanceType\", \"location\"], \"exclude_free_products\": true}\n    pricing = get_pricing('AmazonEC2', 'us-east-1', filters, output_options=output_options)\n    ```\n\n    **4. Pattern-Based Discovery:**\n    ```python\n    # Find all Standard storage tiers except expensive ones\n    filters = [\n        {\"Field\": \"storageClass\", \"Value\": \"Standard\", \"Type\": \"CONTAINS\"},\n        {\"Field\": \"storageClass\", \"Value\": [\"Standard-IA\"], \"Type\": \"NONE_OF\"}\n    ]\n    ```\n\n    **FILTERING STRATEGY:**\n    - **Large Services (EC2, RDS)**: ALWAYS use 2-3 specific filters to prevent 200+ record responses\n    - **Small Services**: May work with single filter or no filters\n    - **Multi-Option Analysis**: Use ANY_OF instead of multiple API calls\n    - **Pattern Discovery**: Use CONTAINS for finding families or tiers\n    - **Smart Exclusion**: Use NONE_OF for compliance or cost filtering\n\n    **SUCCESS CRITERIA:**\n    - Used discovery workflow (skip get_pricing_service_codes() if service known)\n    - Applied appropriate filters for the service size\n    - Used exact values from get_pricing_attribute_values()\n    - Used ANY_OF for multi-option scenarios instead of multiple calls\n    - For cost optimization: tested ALL qualifying tiers exhaustively (in a reasonable range)\n    - Included [\"OnDemand\", \"FlatRate\"] in output_options and explored all alternatives\n    ",
              "inputSchema": {
                "$defs": {
                  "OutputOptions": {
                    "description": "Output filtering options for pricing responses to reduce response size.",
                    "properties": {
                      "exclude_free_products": {
                        "anyOf": [
                          {
                            "type": "boolean"
                          },
                          {
                            "type": "null"
                          }
                        ],
                        "default": false,
                        "description": "Filter out products with $0.00 OnDemand pricing to reduce response size",
                        "title": "Exclude Free Products"
                      },
                      "pricing_terms": {
                        "anyOf": [
                          {
                            "items": {
                              "type": "string"
                            },
                            "type": "array"
                          },
                          {
                            "type": "null"
                          }
                        ],
                        "default": null,
                        "description": "List of pricing terms to include (e.g., [\"OnDemand\", \"FlatRate\"], [\"Reserved\"]). Default: include all terms. Use [\"OnDemand\", \"FlatRate\"] to significantly reduce response size for large services like EC2.",
                        "title": "Pricing Terms"
                      },
                      "product_attributes": {
                        "anyOf": [
                          {
                            "items": {
                              "type": "string"
                            },
                            "type": "array"
                          },
                          {
                            "type": "null"
                          }
                        ],
                        "default": null,
                        "description": "List of product attribute keys to include (e.g., [\"instanceType\", \"location\", \"memory\"]). Default: include all attributes. Filtering to essential attributes can provide additional 20-40% size reduction.",
                        "title": "Product Attributes"
                      }
                    },
                    "title": "OutputOptions",
                    "type": "object"
                  },
                  "PricingFilter": {
                    "description": "Filter model for AWS Price List API queries.",
                    "properties": {
                      "Field": {
                        "description": "The field to filter on (e.g., 'instanceType', 'location')",
                        "title": "Field",
                        "type": "string"
                      },
                      "Type": {
                        "default": "EQUALS",
                        "description": "The type of filter match",
                        "title": "Type",
                        "type": "string"
                      },
                      "Value": {
                        "anyOf": [
                          {
                            "type": "string"
                          },
                          {
                            "items": {
                              "type": "string"
                            },
                            "type": "array"
                          }
                        ],
                        "description": "The value(s) to match against - string for EQUALS/CONTAINS, list for ANY_OF/NONE_OF",
                        "title": "Value"
                      }
                    },
                    "required": [
                      "Field",
                      "Value"
                    ],
                    "title": "PricingFilter",
                    "type": "object"
                  }
                },
                "properties": {
                  "filters": {
                    "anyOf": [
                      {
                        "items": {
                          "$ref": "#/$defs/PricingFilter"
                        },
                        "type": "array"
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "default": null,
                    "description": "Optional list of filters to apply to the pricing query",
                    "title": "Filters"
                  },
                  "max_allowed_characters": {
                    "default": 100000,
                    "description": "Maximum response length in characters (default: 100,000, use -1 for unlimited)",
                    "title": "Max Allowed Characters",
                    "type": "integer"
                  },
                  "max_results": {
                    "default": 100,
                    "description": "Maximum number of results to return per page (default: 100, max: 100)",
                    "maximum": 100,
                    "minimum": 1,
                    "title": "Max Results",
                    "type": "integer"
                  },
                  "next_token": {
                    "anyOf": [
                      {
                        "type": "string"
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "default": null,
                    "description": "Pagination token from previous response to get next page of results",
                    "title": "Next Token"
                  },
                  "output_options": {
                    "anyOf": [
                      {
                        "$ref": "#/$defs/OutputOptions"
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "default": null,
                    "description": "Optional output filtering options to reduce response size. Use {\"pricing_terms\": [\"OnDemand\", \"FlatRate\"]} to significantly reduce response size for large services like EC2."
                  },
                  "region": {
                    "anyOf": [
                      {
                        "type": "string"
                      },
                      {
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "default": null,
                    "description": "AWS region(s) - single region string (e.g., \"us-east-1\") or list for multi-region comparison (e.g., [\"us-east-1\", \"us-west-2\", \"eu-west-1\"]). Optional: omit for global services like DataTransfer or CloudFront that don't have region-specific pricing.",
                    "title": "Region"
                  },
                  "service_code": {
                    "description": "AWS service code (e.g., \"AmazonEC2\", \"AmazonS3\", \"AmazonES\")",
                    "title": "Service Code",
                    "type": "string"
                  }
                },
                "required": [
                  "service_code"
                ],
                "type": "object"
              },
              "name": "get_pricing"
            },
            {
              "annotations": {
                "readOnlyHint": true
              },
              "description": "Get valid values for pricing filter attributes.\n\n    **PURPOSE:** Discover what values are available for specific pricing filter attributes of an AWS service.\n\n    **WORKFLOW:** Use this after get_pricing_service_attributes() to see valid values for each filter attribute.\n\n    **PARAMETERS:**\n    - Service code from get_pricing_service_codes() (e.g., 'AmazonEC2', 'AmazonRDS')\n    - List of attribute names from get_pricing_service_attributes() (e.g., ['instanceType', 'location'])\n    - filters (optional): Dictionary mapping attribute names to regex patterns (e.g., {'instanceType': 't3'})\n\n    **RETURNS:** Dictionary mapping attribute names to their valid values. Filtered attributes return only matching values, unfiltered attributes return all values.\n\n    **EXAMPLE RETURN:**\n    ```\n    {\n        'instanceType': ['t2.micro', 't3.medium', 'm5.large', ...],\n        'location': ['US East (N. Virginia)', 'EU (London)', ...]\n    }\n    ```\n\n    **NEXT STEPS:** Use these values in get_pricing() filters to get specific pricing data.\n\n    **ERROR HANDLING:** Uses \"all-or-nothing\" approach - if any attribute fails, the entire operation fails.\n\n    **EXAMPLES:**\n    - Single attribute: ['instanceType'] returns {'instanceType': ['t2.micro', 't3.medium', ...]}\n    - Multiple attributes: ['instanceType', 'location'] returns both mappings\n    - Partial filtering: filters={'instanceType': 't3'} applies only to instanceType, location returns all values\n    ",
              "inputSchema": {
                "properties": {
                  "attribute_names": {
                    "description": "List of attribute names (e.g., [\"instanceType\", \"location\", \"storageClass\"])",
                    "items": {
                      "type": "string"
                    },
                    "title": "Attribute Names",
                    "type": "array"
                  },
                  "filters": {
                    "anyOf": [
                      {
                        "additionalProperties": {
                          "type": "string"
                        },
                        "type": "object"
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "default": null,
                    "description": "Optional dictionary mapping attribute names to regex patterns for filtering their values (e.g., {\"instanceType\": \"t3\", \"operatingSystem\": \"Linux\"})",
                    "title": "Filters"
                  },
                  "service_code": {
                    "description": "AWS service code (e.g., \"AmazonEC2\", \"AmazonS3\", \"AmazonES\")",
                    "title": "Service Code",
                    "type": "string"
                  }
                },
                "required": [
                  "service_code",
                  "attribute_names"
                ],
                "type": "object"
              },
              "name": "get_pricing_attribute_values"
            },
            {
              "annotations": {
                "readOnlyHint": true
              },
              "description": "Get filterable attributes available for an AWS service in the Pricing API.\n\n    **PURPOSE:** Discover what pricing dimensions (filters) are available for a specific AWS service.\n\n    **WORKFLOW:** Use this after get_pricing_service_codes() to see what filters you can apply to narrow down pricing queries.\n\n    **PARAMETERS:**\n    - service_code: AWS service code from get_pricing_service_codes() (e.g., 'AmazonEC2', 'AmazonRDS')\n    - filter (optional): Case-insensitive regex pattern to filter attribute names (e.g., \"instance\" matches \"instanceType\", \"instanceFamily\")\n\n    **RETURNS:** List of attribute names (e.g., 'instanceType', 'location', 'storageClass') that can be used as filters.\n\n    **NEXT STEPS:**\n    - Use get_pricing_attribute_values() to see valid values for each attribute\n    - Use these attributes in get_pricing() filters to get specific pricing data\n\n    **EXAMPLE:** For 'AmazonRDS' you might get ['engineCode', 'instanceType', 'deploymentOption', 'location'].\n    ",
              "inputSchema": {
                "properties": {
                  "filter": {
                    "anyOf": [
                      {
                        "type": "string"
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "default": null,
                    "description": "Optional case-insensitive regex pattern to filter service attribute names",
                    "title": "Filter"
                  },
                  "service_code": {
                    "description": "AWS service code (e.g., \"AmazonEC2\", \"AmazonS3\", \"AmazonES\")",
                    "title": "Service Code",
                    "type": "string"
                  }
                },
                "required": [
                  "service_code"
                ],
                "type": "object"
              },
              "name": "get_pricing_service_attributes"
            },
            {
              "annotations": {
                "readOnlyHint": true
              },
              "description": "Get AWS service codes available in the Price List API.\n\n    **PURPOSE:** Discover which AWS services have pricing information available in the AWS Price List API.\n\n    **PARAMETERS:**\n    - filter (optional): Case-insensitive regex pattern to filter service codes (e.g., \"bedrock\" matches \"AmazonBedrock\", \"AmazonBedrockService\")\n\n    **WORKFLOW:** This is the starting point for any pricing query. Use this first to find the correct service code.\n\n    **RETURNS:** List of service codes (e.g., 'AmazonEC2', 'AmazonS3', 'AWSLambda') that can be used with other pricing tools.\n\n    **NEXT STEPS:**\n    - Use get_pricing_service_attributes() to see what filters are available for a service\n    - Use get_pricing() to get actual pricing data for a service\n\n    **NOTE:** Service codes may differ from AWS console names (e.g., 'AmazonES' for OpenSearch, 'AWSLambda' for Lambda).\n    ",
              "inputSchema": {
                "properties": {
                  "filter": {
                    "anyOf": [
                      {
                        "type": "string"
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "default": null,
                    "description": "Optional case-insensitive regex pattern to filter service codes",
                    "title": "Filter"
                  }
                },
                "required": [],
                "type": "object"
              },
              "name": "get_pricing_service_codes"
            }
          ],
          "tools": [
            "analyze_cdk_project",
            "analyze_terraform_project",
            "generate_cost_report",
            "get_bedrock_patterns",
            "get_price_list_urls",
            "get_pricing",
            "get_pricing_attribute_values",
            "get_pricing_service_attributes",
            "get_pricing_service_codes"
          ]
        }
      }
    }
  },
  "description": "Generate upfront AWS service cost estimates and cost insights.",
  "icons": [
    {
      "mimeType": "image/svg+xml",
      "sizes": [
        "any"
      ],
      "src": "https://raw.githubusercontent.com/stacklok/toolhive-registry/main/registries/toolhive/servers/aws-pricing/icon.svg"
    }
  ],
  "name": "io.github.stacklok/aws-pricing",
  "packages": [
    {
      "environmentVariables": [
        {
          "description": "AWS access key ID with access to the AWS Pricing API",
          "isSecret": true,
          "name": "AWS_ACCESS_KEY_ID"
        },
        {
          "description": "AWS secret access key",
          "isSecret": true,
          "name": "AWS_SECRET_ACCESS_KEY"
        },
        {
          "description": "AWS session token for temporary credentials",
          "isSecret": true,
          "name": "AWS_SESSION_TOKEN"
        },
        {
          "default": "us-east-1",
          "description": "AWS region for the Pricing API endpoint (us-east-1, eu-central-1, ap-southeast-1)",
          "name": "AWS_REGION"
        },
        {
          "default": "ERROR",
          "description": "Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
          "name": "FASTMCP_LOG_LEVEL"
        }
      ],
      "identifier": "public.ecr.aws/f3y8w4n0/awslabs/aws-pricing-mcp-server:1.0.25",
      "registryType": "oci",
      "transport": {
        "type": "stdio"
      }
    }
  ],
  "repository": {
    "source": "github",
    "url": "https://github.com/awslabs/mcp"
  },
  "title": "AWS Pricing",
  "version": "1.0.0"
}