iflow-mcp_aws-samples-aws-cost-explorer-mcp 0.1.0__py3-none-any.whl

iflow_mcp_aws_samples_aws_cost_explorer_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,361 @@
+Metadata-Version: 2.4
+Name: iflow-mcp_aws-samples-aws-cost-explorer-mcp
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: <3.13,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: boto3>=1.37.9
+Requires-Dist: botocore>=1.37.9
+Requires-Dist: chainlit>=2.4.1
+Requires-Dist: jmespath>=1.0.1
+Requires-Dist: langchain>=0.3.20
+Requires-Dist: langchain-anthropic>=0.3.9
+Requires-Dist: langchain-aws>=0.2.15
+Requires-Dist: langchain-mcp-adapters>=0.0.4
+Requires-Dist: langgraph>=0.3.10
+Requires-Dist: mcp>=1.3.0
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: pydantic>=2.10.6
+Requires-Dist: tabulate>=0.9.0
+Requires-Dist: typing-extensions>=4.12.2
+Dynamic: license-file
+
+# A sample MCP server for understanding cloud spend
+
+An MCP server for getting AWS spend data via Cost Explorer and Amazon Bedrock usage data via [`Model invocation logs`](https://docs.aws.amazon.com/bedrock/latest/userguide/model-invocation-logging.html) in Amazon Cloud Watch through [Anthropic's MCP (Model Control Protocol)](https://www.anthropic.com/news/model-context-protocol). See section on ["secure" remote MCP server](#secure-remote-mcp-server) to see how you can run your MCP server over HTTPS.
+
+```mermaid
+flowchart LR
+    User([User]) --> UserApp[User Application]
+    UserApp --> |Queries| Host[Host]
+    
+    subgraph "Claude Desktop"
+        Host --> MCPClient[MCP Client]
+    end
+    
+    MCPClient --> |MCP Protocol over HTTPS| MCPServer[AWS Cost Explorer MCP Server]
+    
+    subgraph "AWS Services"
+        MCPServer --> |API Calls| CostExplorer[(AWS Cost Explorer)]
+        MCPServer --> |API Calls| CloudWatchLogs[(AWS CloudWatch Logs)]
+    end
+```
+
+You can run the MCP server locally and access it via the Claude Desktop or you could also run a Remote MCP server on Amazon EC2 and access it via a MCP client built into a LangGraph Agent.
+
+## Overview
+
+This tool provides a convenient way to analyze and visualize AWS cloud spending data using Anthropic's Claude model as an interactive interface. It functions as an MCP server that exposes AWS Cost Explorer API functionality to Claude Desktop, allowing you to ask questions about your AWS spend in natural language.
+
+## Features
+
+- **Amazon EC2 Spend Analysis**: View detailed breakdowns of EC2 spending for the last day
+- **Amazon Bedrock Spend Analysis**: View breakdown by region, users and models over the last 30 days
+- **Service Spend Reports**: Analyze spending across all AWS services for the last 30 days
+- **Detailed Cost Breakdown**: Get granular cost data by day, region, service, and instance type
+- **Interactive Interface**: Use Claude to query your cost data through natural language
+
+## Requirements
+
+- Python 3.12
+- AWS credentials with Cost Explorer access
+- Anthropic API access (for Claude integration)
+- [Optional] Amazon Bedrock access (for LangGraph Agent)
+- [Optional] Amazon EC2 for running a remote MCP server
+
+## Installation
+
+1. Install `uv`:
+   ```bash
+   # On macOS and Linux
+   curl -LsSf https://astral.sh/uv/install.sh | sh
+   ```
+   
+   
+   ```powershell
+   # On Windows
+   powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
+   ```
+   Additional installation options are documented [here](https://docs.astral.sh/uv/getting-started/installation/)
+
+2. Clone this repository: (assuming this will be updated to point to aws-samples?)
+   ```
+   git clone https://github.com/aws-samples/sample-cloud-spend-mcp-server
+   cd aws-cost-explorer-mcp
+   ```
+
+3. Set up the Python virtual environment and install dependencies:
+   ```
+   uv venv --python 3.12 && source .venv/bin/activate && uv pip install --requirement pyproject.toml
+   ```
+   
+4. Configure your AWS credentials:
+   ```
+   mkdir -p ~/.aws
+   # Set up your credentials in ~/.aws/credentials and ~/.aws/config
+   ```
+   If you use AWS IAM Identity Center, follow the [docs](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.html) to configure your short-term credentials
+
+## Usage
+
+### Prerequisites
+
+1. Setup [model invocation logs](https://docs.aws.amazon.com/bedrock/latest/userguide/model-invocation-logging.html#setup-cloudwatch-logs-destination) in Amazon CloudWatch.
+1. Ensure that the IAM user/role being used has full read-only access to Amazon Cost Explorer and Amazon CloudWatch, this is required for the MCP server to retrieve data from these services.
+See [here](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/billing-example-policies.html) and [here](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchLogsReadOnlyAccess.html) for sample policy examples that you can use & modify as per your requirements.
+
+### Local setup
+
+Uses `stdio` as a transport for MCP, both the MCP server and client are running on your local machine.
+
+#### Starting the Server (local)
+
+Run the server using:
+
+```
+export MCP_TRANSPORT=stdio
+export BEDROCK_LOG_GROUP_NAME=YOUR_BEDROCK_CW_LOG_GROUP_NAME
+python server.py
+```
+
+#### Claude Desktop Configuration
+
+There are two ways to configure this tool with Claude Desktop:
+
+##### Option 1: Using Docker
+
+Add the following to your Claude Desktop configuration file. The file can be found out these paths depending upon you operating system.
+
+- macOS: ~/Library/Application Support/Claude/claude_desktop_config.json.
+- Windows: %APPDATA%\Claude\claude_desktop_config.json.
+- Linux: ~/.config/Claude/claude_desktop_config.json.
+
+```json
+{
+  "mcpServers": {
+    "aws-cost-explorer": {
+      "command": "docker",
+      "args": [ "run", "-i", "--rm", "-e", "AWS_PROFILE", "-e", "AWS_REGION", "-e", "BEDROCK_LOG_GROUP_NAME", "-e", "MCP_TRANSPORT", "aws-cost-explorer-mcp:latest" ],
+      "env": {
+        "AWS_PROFILE": "YOUR_AWS_PROFILE_NAME",
+        "AWS_REGION": "us-east-1",
+        "BEDROCK_LOG_GROUP_NAME": "YOUR_CLOUDWATCH_BEDROCK_MODEL_INVOCATION_LOG_GROUP_NAME",
+        "MCP_TRANSPORT": "stdio"
+      }
+    }
+  }
+}
+```
+
+> **IMPORTANT**: Replace `YOUR_AWS_PROFILE_NAME` with your actual AWS profile name. This profile should be configured in your `~/.aws/credentials` and `~/.aws/config` files.
+
+##### Option 2: Using UV (without Docker)
+
+If you prefer to run the server directly without Docker, you can use UV:
+
+```json
+{
+  "mcpServers": {
+    "aws_cost_explorer": {
+      "command": "uv",
+      "args": [
+          "--directory",
+          "/path/to/aws-cost-explorer-mcp-server",
+          "run",
+          "server.py"
+      ],
+      "env": {
+        "AWS_PROFILE": "YOUR_AWS_PROFILE_NAME",
+        "AWS_REGION": "us-east-1",
+        "BEDROCK_LOG_GROUP_NAME": "YOUR_CLOUDWATCH_BEDROCK_MODEL_INVOCATION_LOG_GROUP_NAME",
+        "MCP_TRANSPORT": "stdio"
+      }
+    }
+  }
+}
+```
+
+Make sure to replace the directory path with the actual path to your repository on your system.
+
+### Remote setup
+
+Uses `sse` as a transport for MCP, the MCP servers on EC2 and the client is running on your local machine. Note that Claude Desktop does not support remote MCP servers at this time (see [this](https://github.com/orgs/modelcontextprotocol/discussions/16) GitHub issue).
+
+#### Starting the Server (remote)
+
+You can start a remote MCP server on Amazon EC2 by following the same instructions as above. Make sure to set the `MCP_TRANSPORT` as `sse` (server side events) as shown below. **Note that the MCP uses JSON-RPC 2.0 as its wire format, therefore the protocol itself does not include authorization and authentication (see [this GitHub issue](https://github.com/modelcontextprotocol/specification/discussions/102)), do not send or receive sensitive data over MCP**.
+
+Run the server using:
+
+```
+export MCP_TRANSPORT=sse
+export BEDROCK_LOG_GROUP_NAME=YOUR_BEDROCK_CW_LOG_GROUP_NAME
+python server.py
+```
+
+1. The MCP server will start listening on TCP port 8000.
+1. Configure an ingress rule in the security group associated with your EC2 instance to allow access to TCP port 8000 from your local machine (where you are running the MCP client/LangGraph based app) to your EC2 instance.
+
+>Also see section on running a ["secure" remote MCP server](#secure-remote-mcp-server) i.e. a server to which your MCP clients can connect over HTTPS.
+
+#### Testing with a CLI MCP client
+
+You can test your remote MCP server with the `mcp_sse_client.py` script. Running this script will print the list of tools available from the MCP server and an output for the `get_bedrock_daily_usage_stats` tool.
+
+```{.bashrc}
+MCP_SERVER_HOSTNAME=YOUR_MCP_SERVER_EC2_HOSTNAME
+python mcp_sse_client.py --host $MCP_SERVER_HOSTNAME
+```
+
+
+#### Testing with Chainlit app
+
+The `app.py` file in this repo provides a Chainlit app (chatbot) which creates a LangGraph agent that uses the [`LangChain MCP Adapter`](https://github.com/langchain-ai/langchain-mcp-adapters) to import the tools provided by the MCP server as tools in a LangGraph Agent. The Agent is then able to use an LLM to respond to user questions and use the tools available to it as needed. Thus if the user asks a question such as "_What was my Bedrock usage like in the last one week?_" then the Agent will use the tools available to it via the remote MCP server to answer that question. We use Claude 3.5 Haiku model available via Amazon Bedrock to power this agent.
+
+Run the Chainlit app using:
+
+```{.bashrc}
+chainlit run app.py --port 8080 
+```
+
+A browser window should open up on `localhost:8080` and you should be able to use the chatbot to get details about your AWS spend.
+
+### Available Tools
+
+The server exposes the following tools that Claude can use:
+
+1. **`get_ec2_spend_last_day()`**: Retrieves EC2 spending data for the previous day
+1. **`get_detailed_breakdown_by_day(days=7)`**: Delivers a comprehensive analysis of costs by region, service, and instance type
+1. **`get_bedrock_daily_usage_stats(days=7, region='us-east-1', log_group_name='BedrockModelInvocationLogGroup')`**: Delivers a per-day breakdown of model usage by region and users.
+1. **`get_bedrock_hourly_usage_stats(days=7, region='us-east-1', log_group_name='BedrockModelInvocationLogGroup')`**: Delivers a per-day per-hour breakdown of model usage by region and users.
+
+### Example Queries
+
+Once connected to Claude through an MCP-enabled interface, you can ask questions like:
+
+- "Help me understand my Bedrock spend over the last few weeks"
+- "What was my EC2 spend yesterday?"
+- "Show me my top 5 AWS services by cost for the last month"
+- "Analyze my spending by region for the past 14 days"
+- "Which instance types are costing me the most money?"
+- "Which services had the highest month-over-month cost increase?"
+
+## Docker Support
+
+A Dockerfile is included for containerized deployment:
+
+```
+docker build -t aws-cost-explorer-mcp .
+docker run -v ~/.aws:/root/.aws aws-cost-explorer-mcp
+```
+
+## Development
+
+### Project Structure
+
+- `server.py`: Main server implementation with MCP tools
+- `pyproject.toml`: Project dependencies and metadata
+- `Dockerfile`: Container definition for deployments
+
+### Adding New Cost Analysis Tools
+
+To extend the functionality:
+
+1. Add new functions to `server.py`
+2. Annotate them with `@mcp.tool()`
+3. Implement the AWS Cost Explorer API calls
+4. Format the results for easy readability
+
+## Secure "remote" MCP server
+
+We can use [`nginx`](https://nginx.org/) as a reverse-proxy so that it can provide an HTTPS endpoint for connecting to the MCP server. Remote MCP clients can connect to `nginx` over HTTPS and then it can proxy traffic internally to `http://localhost:8000`. The following steps describe how to do this.
+
+1. Enable access to TCP port 443 from the IP address of your MCP client (your laptop, or anywhere) in the inbound rules in the security group associated with your EC2 instance.
+
+1. You would need to have an HTTPS certificate and private key to proceed. Let's say you use `your-mcp-server-domain-name.com` as the domain for your MCP server then you will need an SSL cert for `your-mcp-server-domain-name.com` and it will be accessible to MCP clients as `https://your-mcp-server-domain-name.com/sse`. _While you can use a self-signed cert but it would require disabling SSL verification on the MCP client, we DO NOT recommend you do that_. If you are hosting your MCP server on EC2 then you could generate an SSL cert using [no-ip](https://www.noip.com/) or [Let's Encrypt](https://letsencrypt.org/) or other similar services. Place the SSL cert and private key files in `/etc/ssl/certs` and `/etc/ssl/privatekey` folders respectively on your EC2 machine.
+
+1. Install `nginx` on your EC2 machine using the following commands.
+
+    ```{.bashrc}
+    sudo apt-get install nginx
+    sudo nginx -t
+    sudo systemctl reload nginx
+    ```
+
+1. Get the hostname for your EC2 instance, this would be needed for configuring the `nginx` reverse proxy.
+
+    ```{.bashrc}
+    TOKEN=$(curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600") && curl -H "X-aws-ec2-metadata-token: $TOKEN" -s http://169.254.169.254/latest/meta-data/public-hostname
+    ```
+
+1. Copy the following content into a new file `/etc/nginx/conf.d/ec2.conf`. Replace `YOUR_EC2_HOSTNAME`, `/etc/ssl/certs/cert.pem` and `/etc/ssl/privatekey/privkey.pem` with values appropriate for your setup.
+
+   ```{.bashrc}
+   server {
+    listen 80;
+    server_name YOUR_EC2_HOSTNAME;
+
+    # Optional: Redirect HTTP to HTTPS
+    return 301 https://$host$request_uri;
+    }
+
+    server {
+        listen 443 ssl;
+        server_name YOUR_EC2_HOSTNAME;
+
+        # Self-signed certificate paths
+        ssl_certificate     /etc/ssl/certs/cert.pem;
+        ssl_certificate_key /etc/ssl/privatekey/privkey.pem; 
+
+        # Optional: Good practice
+        ssl_protocols       TLSv1.2 TLSv1.3;
+        ssl_ciphers         HIGH:!aNULL:!MD5;
+
+        location / {
+            # Reverse proxy to your local app (e.g., port 8000)
+            proxy_pass http://127.0.0.1:8000;
+            proxy_http_version 1.1;
+            proxy_set_header Host $host;
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        }
+    }
+
+   ```
+
+1. Restart `nginx`.
+
+    ```{.bashrc}
+    sudo systemctl start nginx
+    ```
+
+1. Start your MCP server as usual as described in the [remote setup](#remote-setup) section.
+
+1. Your MCP server is now accessible over HTTPS as `https://your-mcp-server-domain-name.com/sse` to your MCP client.
+
+1. On the client side now (say on your laptop or in your Agent) configure your MCP client to communicate to your MCP server as follows.
+
+    ```{.bashrc}
+    MCP_SERVER_HOSTNAME=YOUR_MCP_SERVER_DOMAIN_NAME
+    python mcp_sse_client.py --host $MCP_SERVER_HOSTNAME --port 443
+    ```
+
+    Similarly you could run the chainlit app to talk to remote MCP server over HTTPS.
+
+    ```{.bashrc}
+    export MCP_SERVER_URL=YOUR_MCP_SERVER_DOMAIN_NAME
+    export MCP_SERVER_PORT=443
+    chainlit run app.py --port 8080
+    ```
+
+    Similarly you could run the LangGraph Agent to talk to remote MCP server over HTTPS.
+
+    ```{.bashrc}
+    python langgraph_agent_mcp_sse_client.py --host YOUR_MCP_SERVER_DOMAIN_NAME --port 443 
+    ```
+
+## License
+
+[MIT License](LICENSE)
+

iflow_mcp_aws_samples_aws_cost_explorer_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+server.py,sha256=mfJYeZuSx_rHLcklkp_7JUdMZB8UHzCxMLjz1zF29fg,33590
+iflow_mcp_aws_samples_aws_cost_explorer_mcp-0.1.0.dist-info/licenses/LICENSE,sha256=UCXHu-28jahottziq2iSJbPzPEOz8DNosKMxgJtq2iY,946
+iflow_mcp_aws_samples_aws_cost_explorer_mcp-0.1.0.dist-info/METADATA,sha256=ydRpesdz_KrYlLAROAzu2YON9mtaGFGVIbxHKFNgF3g,15102
+iflow_mcp_aws_samples_aws_cost_explorer_mcp-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+iflow_mcp_aws_samples_aws_cost_explorer_mcp-0.1.0.dist-info/entry_points.txt,sha256=roffbUYMExb5EUZKKGTPZorXsmJgUpOiwUJQTBYGrOw,76
+iflow_mcp_aws_samples_aws_cost_explorer_mcp-0.1.0.dist-info/top_level.txt,sha256=StKOSmRhvWS5IPcvhsDRbtxUTEofJgYFGOu5AAJdSWo,7
+iflow_mcp_aws_samples_aws_cost_explorer_mcp-0.1.0.dist-info/RECORD,,

iflow_mcp_aws_samples_aws_cost_explorer_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

iflow_mcp_aws_samples_aws_cost_explorer_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+iflow-mcp_aws-samples-aws-cost-explorer-mcp = server:main

iflow_mcp_aws_samples_aws_cost_explorer_mcp-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,16 @@
+MIT No Attribution
+
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

iflow_mcp_aws_samples_aws_cost_explorer_mcp-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+server

server.py

@@ -0,0 +1,845 @@
+"""
+AWS Cost Explorer MCP Server.
+
+This server provides MCP tools to interact with AWS Cost Explorer API.
+"""
+import os
+import argparse
+from collections import defaultdict
+from datetime import datetime, timedelta
+from typing import Any, Dict, List, Optional, Union
+
+import boto3
+import pandas as pd
+import json
+from mcp.server.fastmcp import FastMCP
+from pydantic import BaseModel, Field
+from tabulate import tabulate
+
+
+
+class DaysParam(BaseModel):
+    """Parameters for specifying the number of days to look back."""
+    
+    days: int = Field(
+        default=7,
+        description="Number of days to look back for cost data"
+    )
+
+
+
+class BedrockLogsParams(BaseModel):
+    """Parameters for retrieving Bedrock invocation logs."""
+    days: int = Field(
+        default=7,
+        description="Number of days to look back for Bedrock logs",
+        ge=1,
+        le=90
+    )
+    region: str = Field(
+        default="us-east-1",
+        description="AWS region to retrieve logs from"
+    )
+    log_group_name: str = Field(
+        description="Bedrock Log Group Name",
+        default=os.environ.get('BEDROCK_LOG_GROUP_NAME', 'BedrockModelInvocationLogGroup')
+    )
+
+
+def get_bedrock_logs(params: BedrockLogsParams) -> Optional[pd.DataFrame]:
+    """
+    Retrieve Bedrock invocation logs for the last n days in a given region as a dataframe
+
+    Args:
+        params: Pydantic model containing parameters:
+            - days: Number of days to look back (default: 7)
+            - region: AWS region to query (default: us-east-1)
+
+    Returns:
+        pd.DataFrame: DataFrame containing the log data with columns:
+            - timestamp: Timestamp of the invocation
+            - region: AWS region
+            - modelId: Bedrock model ID
+            - userId: User ARN
+            - inputTokens: Number of input tokens
+            - completionTokens: Number of completion tokens
+            - totalTokens: Total tokens used
+    """
+    # Initialize CloudWatch Logs client
+    client = boto3.client("logs", region_name=params.region)
+
+    # Calculate time range
+    end_time = datetime.now()
+    start_time = end_time - timedelta(days=params.days)
+
+    # Convert to milliseconds since epoch
+    start_time_ms = int(start_time.timestamp() * 1000)
+    end_time_ms = int(end_time.timestamp() * 1000)
+
+    filtered_logs = []
+
+    try:
+        paginator = client.get_paginator("filter_log_events")
+
+        # Parameters for the log query        
+        query_params = {
+            "logGroupName": params.log_group_name,  # Use the provided log group name
+            "logStreamNames": [
+                "aws/bedrock/modelinvocations"
+            ],  # The specific log stream
+            "startTime": start_time_ms,
+            "endTime": end_time_ms,
+        }
+        
+        # Paginate through results
+        for page in paginator.paginate(**query_params):
+            for event in page.get("events", []):
+                try:
+                    # Parse the message as JSON
+                    message = json.loads(event["message"])
+
+                    # Get user prompt from the input messages
+                    prompt = ""
+                    if (
+                        message.get("input", {})
+                        .get("inputBodyJson", {})
+                        .get("messages")
+                    ):
+                        for msg in message["input"]["inputBodyJson"]["messages"]:
+                            if msg.get("role") == "user" and msg.get("content"):
+                                for content in msg["content"]:
+                                    if content.get("text"):
+                                        prompt += content["text"] + " "
+                        prompt = prompt.strip()
+
+                    # Extract only the required fields
+                    filtered_event = {
+                        "timestamp": message.get("timestamp"),
+                        "region": message.get("region"),
+                        "modelId": message.get("modelId"),
+                        "userId": message.get("identity", {}).get("arn"),
+                        "inputTokens": message.get("input", {}).get("inputTokenCount"),
+                        "completionTokens": message.get("output", {}).get(
+                            "outputTokenCount"
+                        ),
+                        "totalTokens": (
+                            message.get("input", {}).get("inputTokenCount", 0)
+                            + message.get("output", {}).get("outputTokenCount", 0)
+                        ),
+                    }
+
+                    filtered_logs.append(filtered_event)
+                except json.JSONDecodeError:
+                    continue  # Skip non-JSON messages
+                except KeyError:
+                    continue  # Skip messages missing required fields
+        
+        # Create DataFrame if we have logs
+        if filtered_logs:
+            df = pd.DataFrame(filtered_logs)
+            df["timestamp"] = pd.to_datetime(df["timestamp"])
+            return df
+        else:
+            print("No logs found for the specified time period.")
+            return None
+
+    except client.exceptions.ResourceNotFoundException:
+        print(
+            f"Log group '{params.log_group_name}' or stream 'aws/bedrock/modelinvocations' not found"
+        )
+        return None
+    except Exception as e:
+        print(f"Error retrieving logs: {str(e)}")
+        return None
+
+
+
+# Initialize FastMCP server
+mcp = FastMCP("aws_cloudwatch_logs")
+
+@mcp.tool()
+def get_bedrock_daily_usage_stats(params: BedrockLogsParams) -> str:
+    """
+    Get daily usage statistics with detailed breakdowns.
+
+    Args:
+        params: Parameters specifying the number of days to look back and region
+
+    Returns:
+        str: Formatted string representation of daily usage statistics
+    """
+    df = get_bedrock_logs(params)
+
+    if df is None or df.empty:
+        return "No usage data found for the specified period."
+    
+    # Initialize result string
+    result_parts = []
+    
+    # Add header
+    result_parts.append(f"Bedrock Usage Statistics (Past {params.days} days - {params.region})")
+    result_parts.append("=" * 80)
+    
+    # Add a date column for easier grouping
+    df['date'] = df['timestamp'].dt.date
+    
+    # === REGION -> MODEL GROUPING ===
+    result_parts.append("\n=== Daily Region-wise -> Model-wise Analysis ===")
+    
+    # Group by date, region, model and calculate metrics
+    region_model_stats = df.groupby(['date', 'region', 'modelId']).agg({
+        'inputTokens': ['count', 'sum', 'mean', 'max', 'median'],
+        'completionTokens': ['sum', 'mean', 'max', 'median'],
+        'totalTokens': ['sum', 'mean', 'max', 'median']
+    })
+    
+    # Flatten the column multi-index
+    region_model_stats.columns = [f"{col[0]}_{col[1]}" for col in region_model_stats.columns]
+    
+    # Reset the index to get a flat dataframe
+    flattened_stats = region_model_stats.reset_index()
+    
+    # Rename inputTokens_count to request_count
+    flattened_stats = flattened_stats.rename(columns={'inputTokens_count': 'request_count'})
+    
+    # Add the flattened stats to result
+    result_parts.append(flattened_stats.to_string(index=False))
+    
+    # Add summary statistics
+    result_parts.append("\n=== Summary Statistics ===")
+    
+    # Total requests and tokens
+    total_requests = flattened_stats['request_count'].sum()
+    total_input_tokens = flattened_stats['inputTokens_sum'].sum()
+    total_completion_tokens = flattened_stats['completionTokens_sum'].sum()
+    total_tokens = flattened_stats['totalTokens_sum'].sum()
+    
+    result_parts.append(f"Total Requests: {total_requests:,}")
+    result_parts.append(f"Total Input Tokens: {total_input_tokens:,}")
+    result_parts.append(f"Total Completion Tokens: {total_completion_tokens:,}")
+    result_parts.append(f"Total Tokens: {total_tokens:,}")
+    
+    # === REGION SUMMARY ===
+    result_parts.append("\n=== Region Summary ===")
+    region_summary = df.groupby('region').agg({
+        'inputTokens': ['count', 'sum'],
+        'completionTokens': ['sum'],
+        'totalTokens': ['sum']
+    })
+    
+    # Flatten region summary columns
+    region_summary.columns = [f"{col[0]}_{col[1]}" for col in region_summary.columns]
+    region_summary = region_summary.reset_index()
+    region_summary = region_summary.rename(columns={'inputTokens_count': 'request_count'})
+    
+    result_parts.append(region_summary.to_string(index=False))
+    
+    # === MODEL SUMMARY ===
+    result_parts.append("\n=== Model Summary ===")
+    model_summary = df.groupby('modelId').agg({
+        'inputTokens': ['count', 'sum'],
+        'completionTokens': ['sum'],
+        'totalTokens': ['sum']
+    })
+    
+    # Flatten model summary columns
+    model_summary.columns = [f"{col[0]}_{col[1]}" for col in model_summary.columns]
+    model_summary = model_summary.reset_index()
+    model_summary = model_summary.rename(columns={'inputTokens_count': 'request_count'})
+    
+    # Format model IDs to be more readable
+    model_summary['modelId'] = model_summary['modelId'].apply(
+        lambda model: model.split('.')[-1] if '.' in model else model.split('/')[-1]
+    )
+    
+    result_parts.append(model_summary.to_string(index=False))
+    
+    # === USER SUMMARY ===
+    if 'userId' in df.columns:
+        result_parts.append("\n=== User Summary ===")
+        user_summary = df.groupby('userId').agg({
+            'inputTokens': ['count', 'sum'],
+            'completionTokens': ['sum'],
+            'totalTokens': ['sum']
+        })
+        
+        # Flatten user summary columns
+        user_summary.columns = [f"{col[0]}_{col[1]}" for col in user_summary.columns]
+        user_summary = user_summary.reset_index()
+        user_summary = user_summary.rename(columns={'inputTokens_count': 'request_count'})
+        
+        result_parts.append(user_summary.to_string(index=False))
+        
+    # === REGION -> USER -> MODEL DETAILED SUMMARY ===
+    if 'userId' in df.columns:
+        result_parts.append("\n=== Region -> User -> Model Detailed Summary ===")
+        region_user_model_summary = df.groupby(['region', 'userId', 'modelId']).agg({
+            'inputTokens': ['count', 'sum', 'mean'],
+            'completionTokens': ['sum', 'mean'],
+            'totalTokens': ['sum', 'mean']
+        })
+        
+        # Flatten columns
+        region_user_model_summary.columns = [f"{col[0]}_{col[1]}" for col in region_user_model_summary.columns]
+        region_user_model_summary = region_user_model_summary.reset_index()
+        region_user_model_summary = region_user_model_summary.rename(columns={'inputTokens_count': 'request_count'})
+        
+        # Format model IDs to be more readable
+        region_user_model_summary['modelId'] = region_user_model_summary['modelId'].apply(
+            lambda model: model.split('.')[-1] if '.' in model else model.split('/')[-1]
+        )
+        
+        result_parts.append(region_user_model_summary.to_string(index=False))
+
+    
+    # Combine all parts into a single string
+    result = "\n".join(result_parts)
+    
+    return result
+
+@mcp.tool()
+def get_bedrock_hourly_usage_stats(params: BedrockLogsParams) -> str:
+    """
+    Get hourly usage statistics with detailed breakdowns.
+
+    Args:
+        params: Parameters specifying the number of days to look back and region
+
+    Returns:
+        str: Formatted string representation of hourly usage statistics
+    """
+    df = get_bedrock_logs(params)
+
+    if df is None or df.empty:
+        return "No usage data found for the specified period."
+    
+    # Initialize result string
+    result_parts = []
+    
+    # Add header
+    result_parts.append(f"Hourly Bedrock Usage Statistics (Past {params.days} days - {params.region})")
+    result_parts.append("=" * 80)
+    
+    # Add date and hour columns for easier grouping
+    df['date'] = df['timestamp'].dt.date
+    df['hour'] = df['timestamp'].dt.hour
+    df['datetime'] = df['timestamp'].dt.strftime('%Y-%m-%d %H:00')
+    
+    # === HOURLY USAGE ANALYSIS ===
+    result_parts.append("\n=== Hourly Usage Analysis ===")
+    
+    # Group by datetime (date + hour)
+    hourly_stats = df.groupby('datetime').agg({
+        'inputTokens': ['count', 'sum', 'mean'],
+        'completionTokens': ['sum', 'mean'],
+        'totalTokens': ['sum', 'mean']
+    })
+    
+    # Flatten the column multi-index
+    hourly_stats.columns = [f"{col[0]}_{col[1]}" for col in hourly_stats.columns]
+    
+    # Reset the index to get a flat dataframe
+    hourly_stats = hourly_stats.reset_index()
+    
+    # Rename inputTokens_count to request_count
+    hourly_stats = hourly_stats.rename(columns={'inputTokens_count': 'request_count'})
+    
+    # Add the hourly stats to result
+    result_parts.append(hourly_stats.to_string(index=False))
+    
+    # === HOURLY REGION -> MODEL GROUPING ===
+    result_parts.append("\n=== Hourly Region-wise -> Model-wise Analysis ===")
+    
+    # Group by datetime, region, model and calculate metrics
+    hourly_region_model_stats = df.groupby(['datetime', 'region', 'modelId']).agg({
+        'inputTokens': ['count', 'sum', 'mean', 'max', 'median'],
+        'completionTokens': ['sum', 'mean', 'max', 'median'],
+        'totalTokens': ['sum', 'mean', 'max', 'median']
+    })
+    
+    # Flatten the column multi-index
+    hourly_region_model_stats.columns = [f"{col[0]}_{col[1]}" for col in hourly_region_model_stats.columns]
+    
+    # Reset the index to get a flat dataframe
+    hourly_region_model_stats = hourly_region_model_stats.reset_index()
+    
+    # Rename inputTokens_count to request_count
+    hourly_region_model_stats = hourly_region_model_stats.rename(columns={'inputTokens_count': 'request_count'})
+    
+    # Format model IDs to be more readable
+    hourly_region_model_stats['modelId'] = hourly_region_model_stats['modelId'].apply(
+        lambda model: model.split('.')[-1] if '.' in model else model.split('/')[-1]
+    )
+    
+    # Add the hourly region-model stats to result
+    result_parts.append(hourly_region_model_stats.to_string(index=False))
+    
+    # Add summary statistics
+    result_parts.append("\n=== Summary Statistics ===")
+    
+    # Total requests and tokens
+    total_requests = hourly_stats['request_count'].sum()
+    total_input_tokens = hourly_stats['inputTokens_sum'].sum()
+    total_completion_tokens = hourly_stats['completionTokens_sum'].sum()
+    total_tokens = hourly_stats['totalTokens_sum'].sum()
+    
+    result_parts.append(f"Total Requests: {total_requests:,}")
+    result_parts.append(f"Total Input Tokens: {total_input_tokens:,}")
+    result_parts.append(f"Total Completion Tokens: {total_completion_tokens:,}")
+    result_parts.append(f"Total Tokens: {total_tokens:,}")
+    
+    # === REGION SUMMARY ===
+    result_parts.append("\n=== Region Summary ===")
+    region_summary = df.groupby('region').agg({
+        'inputTokens': ['count', 'sum'],
+        'completionTokens': ['sum'],
+        'totalTokens': ['sum']
+    })
+    
+    # Flatten region summary columns
+    region_summary.columns = [f"{col[0]}_{col[1]}" for col in region_summary.columns]
+    region_summary = region_summary.reset_index()
+    region_summary = region_summary.rename(columns={'inputTokens_count': 'request_count'})
+    
+    result_parts.append(region_summary.to_string(index=False))
+    
+    # === MODEL SUMMARY ===
+    result_parts.append("\n=== Model Summary ===")
+    model_summary = df.groupby('modelId').agg({
+        'inputTokens': ['count', 'sum'],
+        'completionTokens': ['sum'],
+        'totalTokens': ['sum']
+    })
+    
+    # Flatten model summary columns
+    model_summary.columns = [f"{col[0]}_{col[1]}" for col in model_summary.columns]
+    model_summary = model_summary.reset_index()
+    model_summary = model_summary.rename(columns={'inputTokens_count': 'request_count'})
+    
+    # Format model IDs to be more readable
+    model_summary['modelId'] = model_summary['modelId'].apply(
+        lambda model: model.split('.')[-1] if '.' in model else model.split('/')[-1]
+    )
+    
+    result_parts.append(model_summary.to_string(index=False))
+    
+    # === USER SUMMARY ===
+    if 'userId' in df.columns:
+        result_parts.append("\n=== User Summary ===")
+        user_summary = df.groupby('userId').agg({
+            'inputTokens': ['count', 'sum'],
+            'completionTokens': ['sum'],
+            'totalTokens': ['sum']
+        })
+        
+        # Flatten user summary columns
+        user_summary.columns = [f"{col[0]}_{col[1]}" for col in user_summary.columns]
+        user_summary = user_summary.reset_index()
+        user_summary = user_summary.rename(columns={'inputTokens_count': 'request_count'})
+        
+        result_parts.append(user_summary.to_string(index=False))
+        
+    # === HOURLY REGION -> USER -> MODEL DETAILED SUMMARY ===
+    if 'userId' in df.columns:
+        result_parts.append("\n=== Hourly Region -> User -> Model Detailed Summary ===")
+        hourly_region_user_model_summary = df.groupby(['datetime', 'region', 'userId', 'modelId']).agg({
+            'inputTokens': ['count', 'sum', 'mean'],
+            'completionTokens': ['sum', 'mean'],
+            'totalTokens': ['sum', 'mean']
+        })
+        
+        # Flatten columns
+        hourly_region_user_model_summary.columns = [f"{col[0]}_{col[1]}" for col in hourly_region_user_model_summary.columns]
+        hourly_region_user_model_summary = hourly_region_user_model_summary.reset_index()
+        hourly_region_user_model_summary = hourly_region_user_model_summary.rename(columns={'inputTokens_count': 'request_count'})
+        
+        # Format model IDs to be more readable
+        hourly_region_user_model_summary['modelId'] = hourly_region_user_model_summary['modelId'].apply(
+            lambda model: model.split('.')[-1] if '.' in model else model.split('/')[-1]
+        )
+        
+        result_parts.append(hourly_region_user_model_summary.to_string(index=False))
+    
+    # === HOURLY USAGE PATTERN ANALYSIS ===
+    result_parts.append("\n=== Hourly Usage Pattern Analysis ===")
+    
+    # Group by hour of day (ignoring date) to see hourly patterns
+    hour_pattern = df.groupby(df['timestamp'].dt.hour).agg({
+        'inputTokens': ['count', 'sum'],
+        'totalTokens': ['sum']
+    })
+    
+    # Flatten hour pattern columns
+    hour_pattern.columns = [f"{col[0]}_{col[1]}" for col in hour_pattern.columns]
+    hour_pattern = hour_pattern.reset_index()
+    hour_pattern = hour_pattern.rename(columns={
+        'timestamp': 'hour_of_day',
+        'inputTokens_count': 'request_count'
+    })
+    
+    # Format the hour to be more readable
+    hour_pattern['hour_of_day'] = hour_pattern['hour_of_day'].apply(
+        lambda hour: f"{hour:02d}:00 - {hour:02d}:59"
+    )
+    
+    result_parts.append(hour_pattern.to_string(index=False))
+    
+    # Combine all parts into a single string
+    result = "\n".join(result_parts)
+    
+    return result
+
+@mcp.tool()
+async def get_ec2_spend_last_day() -> Dict[str, Any]:
+    """
+    Retrieve EC2 spend for the last day using standard AWS Cost Explorer API.
+    
+    Returns:
+        Dict[str, Any]: The raw response from the AWS Cost Explorer API, or None if an error occurs.
+    """
+    # Initialize the Cost Explorer client
+    ce_client = boto3.client('ce')
+    
+    # Calculate the time period - last day
+    end_date = datetime.now().strftime('%Y-%m-%d')
+    start_date = (datetime.now() - timedelta(days=1)).strftime('%Y-%m-%d')
+    
+    try:
+        # Make the API call using get_cost_and_usage (standard API)
+        response = ce_client.get_cost_and_usage(
+            TimePeriod={
+                'Start': start_date,
+                'End': end_date
+            },
+            Granularity='DAILY',
+            Filter={
+                'Dimensions': {
+                    'Key': 'SERVICE',
+                    'Values': [
+                        'Amazon Elastic Compute Cloud - Compute'
+                    ]
+                }
+            },
+            Metrics=[
+                'UnblendedCost',
+                'UsageQuantity'
+            ],
+            GroupBy=[
+                {
+                    'Type': 'DIMENSION',
+                    'Key': 'INSTANCE_TYPE'
+                }
+            ]
+        )
+        
+        # Process and print the results
+        print(f"EC2 Spend from {start_date} to {end_date}:")
+        print("-" * 50)
+        
+        total_cost = 0.0
+        
+        if 'ResultsByTime' in response and response['ResultsByTime']:
+            time_period_data = response['ResultsByTime'][0]
+            
+            if 'Groups' in time_period_data:
+                for group in time_period_data['Groups']:
+                    instance_type = group['Keys'][0]
+                    cost = float(group['Metrics']['UnblendedCost']['Amount'])
+                    currency = group['Metrics']['UnblendedCost']['Unit']
+                    usage = float(group['Metrics']['UsageQuantity']['Amount'])
+                    
+                    print(f"Instance Type: {instance_type}")
+                    print(f"Cost: {cost:.4f} {currency}")
+                    print(f"Usage: {usage:.2f}")
+                    print("-" * 30)
+                    
+                    total_cost += cost
+            
+            # If no instance-level breakdown, show total
+            if not time_period_data.get('Groups'):
+                if 'Total' in time_period_data:
+                    total = time_period_data['Total']
+                    cost = float(total['UnblendedCost']['Amount'])
+                    currency = total['UnblendedCost']['Unit']
+                    print(f"Total EC2 Cost: {cost:.4f} {currency}")
+                else:
+                    print("No EC2 costs found for this period")
+            else:
+                print(f"Total EC2 Cost: {total_cost:.4f} {currency if 'currency' in locals() else 'USD'}")
+                
+            # Check if results are estimated
+            if 'Estimated' in time_period_data:
+                print(f"Note: These results are {'estimated' if time_period_data['Estimated'] else 'final'}")
+        
+        return response
+        
+    except Exception as e:
+        print(f"Error retrieving EC2 cost data: {str(e)}")
+        return None
+
+
+@mcp.tool()
+async def get_detailed_breakdown_by_day(params: DaysParam) -> str: #Dict[str, Any]:
+    """
+    Retrieve daily spend breakdown by region, service, and instance type.
+    
+    Args:
+        params: Parameters specifying the number of days to look back
+    
+    Returns:
+        Dict[str, Any]: A tuple containing:
+            - A nested dictionary with cost data organized by date, region, and service
+            - A string containing the formatted output report
+        or (None, error_message) if an error occurs.
+    """
+    # Initialize the Cost Explorer client
+    ce_client = boto3.client('ce')
+    
+    # Get the days parameter
+    days = params.days
+    
+    # Calculate the time period
+    end_date = datetime.now().strftime('%Y-%m-%d')
+    start_date = (datetime.now() - timedelta(days=days)).strftime('%Y-%m-%d')
+    
+    # Initialize output buffer
+    output_buffer = []
+    
+    try:
+        output_buffer.append(f"\nDetailed Cost Breakdown by Region, Service, and Instance Type ({days} days):")
+        output_buffer.append("-" * 75)
+        
+        # First get the daily costs by region and service
+        response = ce_client.get_cost_and_usage(
+            TimePeriod={
+                'Start': start_date,
+                'End': end_date
+            },
+            Granularity='DAILY',
+            Metrics=['UnblendedCost'],
+            GroupBy=[
+                {
+                    'Type': 'DIMENSION',
+                    'Key': 'REGION'
+                },
+                {
+                    'Type': 'DIMENSION',
+                    'Key': 'SERVICE'
+                }
+            ]
+        )
+        
+        # Create data structure to hold the results
+        all_data = defaultdict(lambda: defaultdict(lambda: defaultdict(float)))
+        
+        # Process the results
+        for time_data in response['ResultsByTime']:
+            date = time_data['TimePeriod']['Start']
+            
+            output_buffer.append(f"\nDate: {date}")
+            output_buffer.append("=" * 50)
+            
+            if 'Groups' in time_data and time_data['Groups']:
+                # Create data structure for this date
+                region_services = defaultdict(lambda: defaultdict(float))
+                
+                # Process groups
+                for group in time_data['Groups']:
+                    region, service = group['Keys']
+                    cost = float(group['Metrics']['UnblendedCost']['Amount'])
+                    currency = group['Metrics']['UnblendedCost']['Unit']
+                    
+                    region_services[region][service] = cost
+                    all_data[date][region][service] = cost
+                
+                # Add the results for this date to the buffer
+                for region in sorted(region_services.keys()):
+                    output_buffer.append(f"\nRegion: {region}")
+                    output_buffer.append("-" * 40)
+                    
+                    # Create a DataFrame for this region's services
+                    services_df = pd.DataFrame({
+                        'Service': list(region_services[region].keys()),
+                        'Cost': list(region_services[region].values())
+                    })
+                    
+                    # Sort by cost descending
+                    services_df = services_df.sort_values('Cost', ascending=False)
+                    
+                    # Get top services by cost
+                    top_services = services_df.head(5)
+                    
+                    # Add region's services table to buffer
+                    output_buffer.append(tabulate(top_services.round(2), headers='keys', tablefmt='pretty', showindex=False))
+                    
+                    # If there are more services, indicate the total for other services
+                    if len(services_df) > 5:
+                        other_cost = services_df.iloc[5:]['Cost'].sum()
+                        output_buffer.append(f"... and {len(services_df) - 5} more services totaling {other_cost:.2f} {currency}")
+                    
+                    # For EC2, get instance type breakdown
+                    if any(s.startswith('Amazon Elastic Compute') for s in region_services[region].keys()):
+                        try:
+                            instance_response = get_instance_type_breakdown(
+                                ce_client, 
+                                date, 
+                                region, 
+                                'Amazon Elastic Compute Cloud - Compute', 
+                                'INSTANCE_TYPE'
+                            )
+                            
+                            if instance_response:
+                                output_buffer.append("\n  EC2 Instance Type Breakdown:")
+                                output_buffer.append("  " + "-" * 38)
+                                
+                                # Get table with indentation
+                                instance_table = tabulate(instance_response.round(2), headers='keys', tablefmt='pretty', showindex=False)
+                                for line in instance_table.split('\n'):
+                                    output_buffer.append(f"  {line}")
+                        
+                        except Exception as e:
+                            output_buffer.append(f"  Note: Could not retrieve EC2 instance type breakdown: {str(e)}")
+                    
+                    # For SageMaker, get instance type breakdown
+                    if any(s == 'Amazon SageMaker' for s in region_services[region].keys()):
+                        try:
+                            sagemaker_instance_response = get_instance_type_breakdown(
+                                ce_client,
+                                date,
+                                region,
+                                'Amazon SageMaker',
+                                'INSTANCE_TYPE'
+                            )
+                            
+                            if sagemaker_instance_response is not None and not sagemaker_instance_response.empty:
+                                output_buffer.append("\n  SageMaker Instance Type Breakdown:")
+                                output_buffer.append("  " + "-" * 38)
+                                
+                                # Get table with indentation
+                                sagemaker_table = tabulate(sagemaker_instance_response.round(2), headers='keys', tablefmt='pretty', showindex=False)
+                                for line in sagemaker_table.split('\n'):
+                                    output_buffer.append(f"  {line}")
+                            
+                            # Also try to get usage type breakdown for SageMaker (notebooks, endpoints, etc.)
+                            sagemaker_usage_response = get_instance_type_breakdown(
+                                ce_client,
+                                date,
+                                region,
+                                'Amazon SageMaker',
+                                'USAGE_TYPE'
+                            )
+                            
+                            if sagemaker_usage_response is not None and not sagemaker_usage_response.empty:
+                                output_buffer.append("\n  SageMaker Usage Type Breakdown:")
+                                output_buffer.append("  " + "-" * 38)
+                                
+                                # Get table with indentation
+                                usage_table = tabulate(sagemaker_usage_response.round(2), headers='keys', tablefmt='pretty', showindex=False)
+                                for line in usage_table.split('\n'):
+                                    output_buffer.append(f"  {line}")
+                        
+                        except Exception as e:
+                            output_buffer.append(f"  Note: Could not retrieve SageMaker breakdown: {str(e)}")
+            else:
+                output_buffer.append("No data found for this date")
+            
+            output_buffer.append("\n" + "-" * 75)
+        
+        # Join the buffer into a single string
+        formatted_output = "\n".join(output_buffer)
+        
+        # Return both the raw data and the formatted output
+        #return {"data": all_data, "formatted_output": formatted_output}
+        return formatted_output
+    
+    except Exception as e:
+        error_message = f"Error retrieving detailed breakdown: {str(e)}"
+        #return {"data": None, "formatted_output": error_message}
+        return error_message
+
+def get_instance_type_breakdown(ce_client, date, region, service, dimension_key):
+    """
+    Helper function to get instance type or usage type breakdown for a specific service.
+    
+    Args:
+        ce_client: The Cost Explorer client
+        date: The date to query
+        region: The AWS region
+        service: The AWS service name
+        dimension_key: The dimension to group by (e.g., 'INSTANCE_TYPE' or 'USAGE_TYPE')
+    
+    Returns:
+        DataFrame containing the breakdown or None if no data
+    """
+    tomorrow = (datetime.strptime(date, '%Y-%m-%d') + timedelta(days=1)).strftime('%Y-%m-%d')
+    
+    instance_response = ce_client.get_cost_and_usage(
+        TimePeriod={
+            'Start': date,
+            'End': tomorrow
+        },
+        Granularity='DAILY',
+        Filter={
+            'And': [
+                {
+                    'Dimensions': {
+                        'Key': 'REGION',
+                        'Values': [region]
+                    }
+                },
+                {
+                    'Dimensions': {
+                        'Key': 'SERVICE',
+                        'Values': [service]
+                    }
+                }
+            ]
+        },
+        Metrics=['UnblendedCost'],
+        GroupBy=[
+            {
+                'Type': 'DIMENSION',
+                'Key': dimension_key
+            }
+        ]
+    )
+    
+    if ('ResultsByTime' in instance_response and 
+        instance_response['ResultsByTime'] and 
+        'Groups' in instance_response['ResultsByTime'][0] and 
+        instance_response['ResultsByTime'][0]['Groups']):
+        
+        instance_data = instance_response['ResultsByTime'][0]
+        instance_costs = []
+        
+        for instance_group in instance_data['Groups']:
+            type_value = instance_group['Keys'][0]
+            cost_value = float(instance_group['Metrics']['UnblendedCost']['Amount'])
+            
+            # Add a better label for the dimension used
+            column_name = 'Instance Type' if dimension_key == 'INSTANCE_TYPE' else 'Usage Type'
+            
+            instance_costs.append({
+                column_name: type_value,
+                'Cost': cost_value
+            })
+        
+        # Create DataFrame and sort by cost
+        result_df = pd.DataFrame(instance_costs)
+        if not result_df.empty:
+            result_df = result_df.sort_values('Cost', ascending=False)
+            return result_df
+    
+    return None
+
+@mcp.resource("config://app")
+def get_config() -> str:
+    """Static configuration data"""
+    return "App configuration here"
+
+def main():
+    # Run the server with the specified transport
+    mcp.run(transport=os.environ.get('MCP_TRANSPORT', 'stdio'))
+
+if __name__ == "__main__":
+    main()