Cloud Resource Interface Protocol (CRIP) Server Suite

Introduction

This repository provides an extensive suite of servers implementing the Model Context Protocol (MCP). MCP acts as an open interface, allowing large language models (LLMs) integrated into development tools to access external, timely data and operational capabilities. By leveraging these specialized servers, AI assistants gain deep, contextual awareness of cloud services, improving response accuracy for technical guidance and code generation. This architecture effectively integrates cloud service knowledge directly into the development workflow.

Server Sent Events Support Removal

Critical Update: Support for Server Sent Events (SSE) transport was discontinued across all current major versions of these MCP servers as of May 26th, 2025. This aligns with the Model Context Protocol specification's backward compatibility mandates. Development is currently focused on incorporating Streamable HTTP for enhanced transport mechanisms in forthcoming releases. Users dependent on SSE functionality should temporarily maintain usage of older server versions until transitioning to newer transport protocols.

Why AWS MCP Servers?

Integrating these servers significantly enhances foundation model utility within cloud service contexts. They provide several core benefits:

• Accuracy Enhancement: By supplying domain-specific, current information, the servers substantially refine model output quality for specialized cloud topics. This precision minimizes factual errors and ensures generated code adheres to current AWS architectural guidelines.
• Timely Information Access: Foundation models often lack knowledge of recent service updates or API revisions. These servers dynamically fetch the latest documentation, keeping AI guidance current.
• Workflow Enablement: Servers translate repetitive operational patterns, like Infrastructure as Code (IaC) execution, into tools that AI agents can utilize efficiently.
• Specialized Context: They inject granular knowledge regarding specific cloud services, unavailable in general training corpora, leading to more helpful interactions for platform engineering tasks.

Related Topics

• Cloud Computing (ISO definition of scalable, elastic, self-service resources)
• Model Context Protocol (MCP) Specification
• Infrastructure as Code (IaC) patterns (CDK, Terraform)
• Retrieval-Augmented Generation (RAG) architectures
• Serverless computing lifecycle management
• Cloud Cost Management principles

Available CRIP Servers: Quick Installation

Rapid deployment options are available for popular AI clients like Cursor and VS Code. Use the provided links to install servers directly into your chosen environment.

🚀 Getting Started with AWS

We advise initiating general AWS interactions with the following primary servers:

Server Name	Description	Install
AWS API CRIP Server	Provides complete support for AWS API interactions, including validation and broad service access. Excellent for natural language infrastructure management.
AWS Knowledge CRIP Server	A remote service from AWS offering access to the latest documentation, API guides, architectural references, and Well-Architected advice.

🏗️ Infrastructure & Deployment

Tools supporting the construction and management of cloud resources through code methodologies.

Server Name	Description	Install
AWS Cloud Control API CRIP Server	Facilitates direct management of AWS resources, incorporating security scanning and adherence to best practices.
AWS CDK CRIP Server	Assists with AWS CDK development, emphasizing security compliance and established best practices.
AWS Terraform CRIP Server	Integrates security scanning directly into Terraform configuration workflows.

Container Platforms

Server Name	Description	Install
Amazon EKS CRIP Server	Manages Kubernetes clusters and facilitates EKS application deployments.
Amazon ECS CRIP Server	Orchestrates container deployment specifically for ECS applications.

Serverless & Functions

Server Name	Description	Install
AWS Serverless CRIP Server	Manages the complete lifecycle of serverless applications using SAM CLI integrations.

MCP AWS Lambda Handler Module

A utility module written in Python facilitates the creation of serverless HTTP endpoints suitable for the Model Context Protocol (MCP) using AWS Lambda functions. This framework supports pluggable session management capabilities, including a native backend implementation using DynamoDB. Developers can efficiently construct secure, scalable communication channels for AI tools.

Refer to src/mcp-lambda-handler/README.md for comprehensive deployment guides, dependency management, and usage examples.

Installation and Setup

Deployment instructions vary slightly based on the client application. The foundational steps involve installing the uv package manager, setting up Python, and correctly configuring AWS authentication credentials.

1. Install uv utilizing the latest distribution from Astral.
2. Install a compatible Python version using the command: uv python install 3.10.
3. Ensure your AWS credentials permit necessary service access.
4. Integrate the server into your chosen MCP client's configuration structure.

Configuration Example for Amazon Q CLI (Global Scope):

For macOS/Linux

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

For detailed configuration parameters specific to each server, consult the individual server documentation files. If installation via uvx <tool>@latest results in slow startup times, remove the @latest suffix and manually manage the uv cache.

Running CRIP Servers in Containers

Container images for all listed servers are currently accessible via the public AWS ECR registry located at public.ecr.aws/awslabs-mcp.

When deploying via Docker, environment variables must be explicitly passed using --env or --env-file, as the standard JSON configuration environment section is inaccessible within the container runtime.

{
  "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": {}
    }
  }
}

When to use Local vs Remote CRIP Servers?

AWS CRIP servers support both local execution and deployment across cloud infrastructure.

Local CRIP Servers

Local execution is optimal for initial development, intensive debugging cycles, and situations requiring immediate, low-latency tool responses. This option also ensures sensitive operational data remains confined to the local workstation.

Remote CRIP Servers

Remote servers are beneficial for collaborative team settings, ensuring uniform configuration access for all developers. They also provide necessary scalability for resource-heavy analytical tasks, accessible from diverse client devices.

Note that services like the AWS Knowledge CRIP Server are offered as fully managed cloud solutions, requiring zero infrastructure setup for immediate utilization.

Use Cases for the Servers

Illustratively, the AWS Documentation CRIP Server allows an AI assistant to retrieve current specifications for services like Amazon Bedrock Agents. Subsequently, the AWS CDK CRIP Server or AWS Terraform CRIP Server can translate that knowledge into executable IaC templates. Furthermore, using the AWS Pricing CRIP Server, queries such as estimating deployment expenses can be addressed proactively, providing budget foresight before provisioning resources.

Security

Refer to CONTRIBUTING documentation regarding proper procedures for reporting security vulnerabilities.

Extra Details

The Data Analytics category prominently features several specialized databases. For instance, the Amazon DynamoDB CRIP Server manages NoSQL table operations. For relational workloads, the Amazon Aurora PostgreSQL CRIP Server executes queries against Aurora instances via the RDS Data API. Additionally, the Amazon DocumentDB CRIP Server provides standard operational interfaces compatible with MongoDB environments. Finally, the Amazon Neptune CRIP Server supports complex graph traversals using both openCypher and Gremlin query languages.

Samples

Working examples demonstrating the practical application of various AWS CRIP Servers are organized within the samples directory. These assets include requisite code snippets and procedural instructions for rapid adoption.

Contributing

We highly value contributions from the community. Please review our contributor guide for guidance on submitting enhancements or fixes.

Developer guide

Individuals aiming to integrate novel CRIP servers should review the development guide and adhere strictly to established design guidelines.

Conclusion

These Model Context Protocol extension servers significantly enhance AI tooling by grounding responses in real-time cloud context. This bridging mechanism improves automation fidelity, accelerates cloud-native development cycles, and supports complex operational tasks inherent in managing scalable cloud services infrastructure.

Getting Started with Amazon Q Developer CLI

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

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.core-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR",
        "MCP_SETTINGS_PATH": "path to your mcp settings file"
      }
    }
   }
  }
 ```

6.  After saving, enable the servers in the Installed tab. Next, switch the **API Provider** in Cline settings from `Cline` to `AWS Bedrock`, selecting `AWS Profile` for authentication, which is preferred over static credentials for security.

7.  In the Custom Instructions textbox, add directives to prioritize tool usage: