Cloud Resource Ledger and Cost Query Engine

Introduction

The Model Context Protocol (MCP) enables sophisticated, context-aware interactions between large language models and external data systems. This specific collection of AWS-oriented servers extends AI capabilities by integrating deep technical knowledge about cloud services with principles found in financial data management. Just as financial data vendors aggregate information from stock exchange feeds and regulatory filings (like SEC documents), these servers aggregate current AWS documentation, pricing structures, and operational data. This integration enhances AI accuracy when discussing cloud deployments, cost projections, and architecture.

Related Topics

• Financial Data Vendor Operations
• Regulatory Filing Analysis (SEC context)
• Infrastructure as Code Security Auditing
• Cloud Resource Provisioning
• Market Data Distribution

Server Sent Events Support Removal

Crucial Update: Support for Server Sent Events (SSE) was discontinued in the latest major releases on May 26th, 2025. This adjustment adheres to the Model Context Protocol specification's rules regarding transport compatibility. We are currently developing support for Streamable HTTP protocols for future updates. If your application still requires SSE functionality, you must utilize the preceding major version of the server until migration to newer transport mechanisms is complete.

Why AWS MCP Servers?

These specialized servers significantly augment foundation model performance in several specific ways. They inject precise, current AWS context, which reduces inaccuracies, often termed hallucinations, in AI responses. Models gain immediate access to the most recent service updates and API specifications, overcoming knowledge gaps from their training cutoffs. Furthermore, these tools translate routine operational procedures, such as managing Terraform state or CDK stacks, into actionable capabilities the AI can execute directly. This specialization ensures recommendations align with current, verified AWS architectural standards.

Available MCP Servers: Quick Installation

Installation is streamlined via direct integration buttons provided for popular development environments like Cursor and VS Code. Initial setup generally involves obtaining the uv package manager from Astral and ensuring your AWS security credentials are correctly configured. After these prerequisites, you simply select the relevant server link below.

🚀 Getting Started with AWS

Start here for general AWS interactions and comprehensive API support:

Server Name	Description	Install
AWS API MCP Server	Facilitates general AWS interaction. Offers extensive AWS API support, including validation checks, security oversight, and access to all services for natural language infrastructure management.
AWS Knowledge MCP Server	A remote, managed service from AWS providing current documentation, API references, recent news, architectural guidance, and Well-Architected reviews.

🏗️ Infrastructure & Deployment

Implement infrastructure deployment cycles following established security compliance methods.

Server Name	Description	Install
AWS CDK MCP Server	Supports AWS CDK development, integrating security compliance checks and best practice enforcement.
AWS Terraform MCP Server	Enhances Terraform workflows by embedding security posture scanning capabilities.

📊 Data & Analytics

Manage data persistence layers, including relational and non-relational databases.

Server Name	Description	Install
Amazon DynamoDB MCP Server	Offers full operational control and schema management for DynamoDB tables.
Amazon Aurora PostgreSQL MCP Server	Executes PostgreSQL queries against Aurora instances using the RDS Data API endpoint.

💰 Cost & Operations

Query financial data related to cloud consumption directly through natural language interfaces.

Server Name	Description	Install
AWS Pricing MCP Server	Provides estimations and retrieval of AWS service pricing schedules.
AWS Cost Explorer MCP Server	Enables querying granular cost consumption metrics and generating expenditure reports.
Amazon CloudWatch MCP Server	Analyzes system metrics, alerts, and log streams for operational diagnostics.

MCP AWS Lambda Handler Module

This Python module facilitates the creation of serverless HTTP dispatchers for the Model Context Protocol using AWS Lambda functions. It provides a modular structure for building MCP endpoints, complete with support for pluggable session handling, notably utilizing DynamoDB for persistence. This allows for the rapid deployment of backend context providers within a serverless environment.

When to use Local vs Remote MCP Servers?

Deciding between local and remote execution of AWS MCP servers depends on workflow requirements. Local instances offer minimal network latency and direct control over the environment, which is ideal for isolated testing and development. Remote deployments, conversely, benefit from inherent team standardization, automatic updates managed by the provider, and reduced local resource load. For externally managed services, such as the AWS Knowledge MCP Server, no local setup is necessary; connection configuration is the only requirement.

Local MCP Servers

• Preferable for debugging and local testing cycles.
• Ensures operational continuity without constant internet access.
• Maintains sensitive configuration data exclusively within the local perimeter.

Remote MCP Servers

• Facilitates unified configuration standards across development teams.
• Offloads computationally heavy processing tasks to scalable cloud infrastructure.
• Maintains constant availability regardless of the developer's location.

Installation and Setup

Installation requires the uv package manager, obtainable from Astral, followed by Python setup. You must also establish valid AWS credentials granting necessary service access. After these preliminary steps, integrate the required server into your chosen MCP client configuration file.

Example configuration for the general MCP orchestrator (~/.aws/amazonq/mcp.json):

For macOS/Linux

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.core-mcp-server@latest"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
  }
}

For Windows

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "disabled": false,
      "timeout": 60,
      "type": "stdio",
      "command": "uv",
      "args": [
        "tool",
        "run",
        "--from",
        "awslabs.core-mcp-server@latest",
        "awslabs.core-mcp-server.exe"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
  }
}

If parameter invocation appears problematic, you can simulate execution time constraints manually:

# Execute MCP server with a 15-second operational ceiling
$ timeout 15s uv tool run <MCP Name> <args> 2>&1 || echo "Command completed or timed out"

# Example call resulting in argument error message
$ timeout 15s uv tool run awslabs.mysql-mcp-server --resource_arn <Your Resource ARN> --secret_arn <Your Secret ARN> ... 2>&1 || echo "Command completed or timed out"

# Expected output indicating missing required parameters:
usage: awslabs.mysql-mcp-server [-h] --resource_arn RESOURCE_ARN --secret_arn SECRET_ARN --database DATABASE
                                --region REGION --readonly READONLY
awslabs.mysql-mcp-server: error: the following arguments are required: --resource_arn, --secret_arn, --database, --region, --readonly

Running MCP servers in containers

Docker images for all servers are readily available via the public AWS ECR repository under the awslabs-mcp namespace. This methodology shifts context execution away from the host system.

This demonstration uses docker for the awslabs.nova-canvas-mcp-server and illustrates the mapping of required environment variables.

If necessary, temporarily store credentials in a configuration file, for instance, .env:

# Fictitious AWS temporary credentials content
AWS_ACCESS_KEY_ID=ASIAIOSFODNN7EXAMPLE
AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
AWS_SESSION_TOKEN=AQoEXAMPLEH4aoAH0gNCAPy...truncated...zrkuWJOgQs8IZZaIv2BXIa2R4Olgk

Container execution demands manual specification of runtime parameters, unlike the JSON configuration:

{
  "mcpServers": {
    "awslabs.nova-canvas-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "--interactive",
        "--env",
        "FASTMCP_LOG_LEVEL=ERROR",
        "--env",
        "AWS_REGION=us-east-1",
        "--env-file",
        "/full/path/to/.env",
        "--volume",
        "/full/path/to/.aws:/app/.aws",
        "public.ecr.aws/awslabs-mcp/awslabs/nova-canvas-mcp-server:latest"
      ],
      "env": {}
    }
  }
}

To test custom server code, build and tag your local image, subsequently updating the MCP configuration to reference your local tag instead of the registry version.

cd src/nova-canvas-mcp-server
docker build -t awslabs/nova-canvas-mcp-server .

Getting Started with Amazon Q Developer CLI

Access the configuration through the Q Developer panel interface, selecting the tools icon, then the plus sign to specify global or project-specific settings within ~/.aws/amazonq/mcp.json or .amazonq/mcp.json.

~/.aws/amazonq/mcp.json

Configuration for macOS/Linux using the standard invocation:

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.core-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
  }
}

Samples

Functional demonstration artifacts for utilizing the AWS MCP Servers are organized within the samples directory. These resources provide complete examples and instructional paths for immediate engagement with each server component.

Security

Review the guidelines outlined in CONTRIBUTING concerning the protocol for reporting security vulnerabilities.

Contributing

We deeply appreciate contributions from the community that enhance this project's capabilities. Detailed contribution guidelines are available in the contributor guide.

Developer guide

Individuals wishing to integrate a new MCP Server into this repository should consult our comprehensive development guide and strictly adhere to the established design guidelines.

License

This software is distributed under the terms of the Apache-2.0 License.

Disclaimer

Users must conduct their own due diligence to confirm that their utilization of any MCP Server aligns with their internal security standards, quality mandates, and all applicable laws and regulations governing their operations and data handling practices.

Extra Details

The Model Context Protocol (MCP) functions as an essential bridge, standardizing how AI applications access external, timely data. This mirrors how established financial market data vendors consolidate disparate sources—including exchange feeds and regulatory reports—into a cohesive, reliable stream for traders. While this repository focuses on AWS services, the underlying protocol enables AI tools to move beyond pre-trained knowledge toward real-time, fact-checked operational context. For instance, querying cost data through natural language, as demonstrated by the Cost Explorer MCP Server, parallels querying market data for asset valuation, demanding immediate, accurate responses.

Conclusion

This suite of specialized servers effectively embeds operational and financial context directly into AI workflows via the Model Context Protocol. This capability allows AI assistants to manage cloud infrastructure, analyze expenditure against benchmarks, and generate architecture compliant with current best practices. By providing factual, service-specific knowledge, these tools transform generalized models into highly effective, domain-specific collaborators for cloud engineering and financial planning.