Skip to content
Design & CreativeQuality Score: 46

EC2 Image Builder MCP Configuration

The EC2 Image Builder MCP configuration provides a hosted JSON schema that connects AI assistants — including Claude Desktop, Cursor, Windsurf, and VS Code Copilot — to the EC2 Image Builder API via the Model Context Protocol. This configuration maps 10 API endpoints as callable tools, including CancelImageCreation, CreateComponent, CreateContainerRecipe, and more. No authentication credentials are needed — it works out of the box. The configuration is auto-generated from the EC2 Image Builder OpenAPI specification (v2019-12-02) and has a quality score of 46/99 (fair documentation coverage). Use the hosted URL below to auto-load this schema into any compatible MCP client.

Quick Specs Reference

AuthenticationNo Auth Required
Available Endpoints10 tools mapped
Integration Modeauto Generation

Hosted Config URL

Use this hosted URL in any client that supports remote MCP schema auto-loading.

https://mcpbridge.org/config/amazonaws-com-imagebuilder.json

One-Click Client Setup

Copy the configurations below to wire your local coding assistant directly.

Claude Desktop

claude_desktop_config.json
{
  "mcpServers": {
    "amazonaws-com-imagebuilder": {
      "command": "npx",
      "args": [
        "-y",
        "@mcp/amazonaws-com-imagebuilder"
      ],
      "env": {
        "EC2_IMAGE_BUILDER_API_KEY": "your_ec2_image_builder_api_key"
      }
    }
  }
}

Cursor & VS Code

MCP Server URL Setup
{
  "mcpServers": {
    "amazonaws-com-imagebuilder": {
      "url": "https://mcpbridge.org/config/amazonaws-com-imagebuilder.json"
    }
  }
}

Raw Configuration JSON

For local command line wrappers or dynamic shell bindings.

{
  "mcpServers": {
    "amazonaws-com-imagebuilder": {
      "command": "npx",
      "args": ["-y","@mcp/amazonaws-com-imagebuilder"],
      "env": {
      "EC2_IMAGE_BUILDER_API_KEY": "your_ec2_image_builder_api_key"
}
    }
  }
}

Required Environment Keys

Substitute these secrets inside your configuration directory environment definitions.

EC2_IMAGE_BUILDER_API_KEY
Replace your_ec2_image_builder_api_key with your secret key credential

Mapped Web APIs & Tools

The following routes will be exposed directly as protocol tools for the LLM.

PUT/CancelImageCreation

CancelImageCreation

PUT/CreateComponent

CreateComponent

PUT/CreateContainerRecipe

CreateContainerRecipe

PUT/CreateDistributionConfiguration

CreateDistributionConfiguration

PUT/CreateImage

CreateImage

PUT/CreateImagePipeline

CreateImagePipeline

PUT/CreateImageRecipe

CreateImageRecipe

PUT/CreateInfrastructureConfiguration

CreateInfrastructureConfiguration

DELETE/DeleteComponent#componentBuildVersionArn

DeleteComponent

DELETE/DeleteContainerRecipe#containerRecipeArn

DeleteContainerRecipe

Similar Configurations

Figma API

Access Figma files, components, and styles for design-to-code workflows in your AI development environment.

https://mcpbridge.org/config/figma.json

Amazon Kinesis Video Streams Media

The Amazon Kinesis Video Streams Media API is a specialized streaming service provided by Amazon Web Services (AWS) that enables developers to reliably ingest, store, and retrieve media streams such as video and audio at scale. The core endpoint, POST /getMedia, facilitates the retrieval of media fragments from Kinesis Video Streams, allowing applications to pull continuous or on-demand video and audio data from cloud-hosted streams. This API is particularly powerful for enterprises and organizations dealing with large volumes of real-time or archival media content originating from cameras, microphones, drones, and other media-producing devices. Typical use cases span security and surveillance systems where footage must be accessed and analyzed on demand, media broadcasting platforms that require low-latency stream retrieval, healthcare applications involving remote patient monitoring video feeds, industrial inspection systems where drones capture inspection footage, and smart city infrastructure that processes live feeds from traffic and public safety cameras. By abstracting the complexity of managing massive media storage and delivery, Kinesis Video Streams Media allows developers to focus on building application logic rather than infrastructure. When exposed as a tool through the Model Context Protocol (MCP) and made available to AI coding assistants such as Claude Desktop, Cursor, or Cline, this API gains a significant new dimension of utility. Developers can interact with their Kinesis Video Streams infrastructure conversationally, eliminating the need to write boilerplate SDK code, manually construct request payloads, or navigate dense AWS documentation for every interaction. The AI assistant, acting as an intermediary that understands both natural language instructions and the API's structured contract, can help developers quickly prototype media retrieval logic, debug stream connectivity issues, and generate production-ready integration code. This MCP integration is especially valuable in complex projects where developers are simultaneously juggling multiple AWS services and need rapid, context-aware assistance in wiring up media stream consumption within broader application architectures. The tool surface transforms the API from a purely programmatic endpoint into an accessible, queryable resource that accelerates development cycles and reduces cognitive load during implementation. In practical workflow scenarios, a developer working with this MCP server can instruct the AI assistant to perform a range of dynamic tasks. For instance, a developer might ask the AI to generate a script that retrieves the latest media fragment from a specific video stream identified by its stream name or stream ARN, parses the returned binary payload, and saves it locally as a playable file for debugging. Another common workflow involves asking the AI to build a function that continuously polls a stream using the getMedia endpoint, detects gaps in fragment availability, and logs anomalies that could indicate upstream device connectivity problems. Developers can also request that the AI construct an integration pipeline that fetches media data from Kinesis Video Streams and pipes it directly into an AWS Lambda function or a computer vision model for real-time inference, such as object detection or facial recognition. Additionally, an AI assistant can help orchestrate multi-stream operations, such as querying media from several surveillance camera streams simultaneously, aggregating results, and producing a consolidated metadata report. These examples illustrate how MCP-enabled access to the getMedia endpoint empowers developers to move from intent to implementation with minimal friction, turning high-level architectural ideas into working code within conversational iterations. Proper authentication and security configuration are critical when setting up this MCP server for use with the Amazon Kinesis Video Streams Media API. Although the endpoint itself may be described as having no direct authentication at the API surface level when proxied through the MCP tool layer, the underlying AWS infrastructure absolutely requires valid credentials. Developers must ensure that the MCP server is configured with an AWS Identity and Access Management (IAM) role or user credentials that possess the minimal permissions necessary to interact with the target Kinesis Video Streams, ideally scoped to the specific stream ARNs the application needs to access, following the principle of least privilege. Environment variables or secure secret managers such as AWS Secrets Manager or HashiCorp Vault should be used to store access keys and session tokens rather than hardcoding them into configuration files. When deploying the MCP server in a shared or production environment, developers should enable AWS CloudTrail logging for all Kinesis Video Streams API calls, enforce encryption at rest and in transit for stream data, and regularly audit IAM policies to ensure that permissions remain tightly aligned with actual usage patterns. Network-level security such as VPC endpoints for Kinesis Video Streams access can further reduce exposure by keeping traffic within the AWS backbone rather than traversing the public internet. Following these practices ensures that the convenience of conversational AI-driven development does not come at the cost of security or compliance.

https://mcpbridge.org/config/amazonaws-com-kinesis-video-media.json

Amazon Kinesis Video Streams Archived Media

The Amazon Kinesis Video Streams Archived Media API is a specialized service provided by Amazon Web Services (AWS) that enables programmatic access to retrieve and transform archived video and audio streams stored within Kinesis Video Streams. Its core capabilities center on on-demand data extraction, allowing users to pull specific clips, generate adaptive streaming manifests (HLS and DASH), extract individual image frames, and query the underlying fragment metadata of archived streams. This API is fundamental for enterprises that need to analyze historical video footage, such as for security and surveillance retrospectives, media asset management, industrial IoT inspection, and smart city analytics. Typical use cases include forensic investigation where an operator needs a precise clip of an incident, content creators repurposing raw footage from cloud-based cameras, or automated systems pulling frames for machine learning model training and validation. It serves as the critical data plane for unlocking the value of video data stored in the cloud. When exposed as tools via the Model Context Protocol (MCP) to an AI coding assistant, this API transforms from a set of static endpoints into a dynamic, conversational interface for video data manipulation. The value lies in dramatically lowering the barrier to complex video operations, enabling developers to instruct an AI agent in natural language to perform precise, multi-step tasks that would otherwise require deep knowledge of the API specifications, authentication flows, and data formats. The AI assistant can act as an expert bridge, translating high-level requests into the correct sequence of API calls. For instance, a developer could ask the AI to "generate a 5-minute HLS streaming session URL for the last 24 hours of camera footage from 'Warehouse-12' to review a security event," and the AI would handle the required timestamp calculations, endpoint selection, and parameter construction. Practical workflows enabled by this MCP integration are powerful and varied. A developer could instruct an AI agent to "create a Python function that extracts all motion-triggered images from the archived stream 'Drone-07' between 10:00 and 12:00 UTC yesterday and saves them to an S3 bucket." The AI would generate code using the `getImages` endpoint with appropriate fragment selection logic. Another task could be, "Update our monitoring dashboard script to automatically query and display the five most recent 30-second video clips from the 'Public-Square' camera whenever a motion alert is triggered." This involves dynamically using `getClip` and potentially `listFragments` in response to external events. The AI can also assist in debugging by interpreting error messages and suggesting the correct API call or parameter adjustment, effectively becoming a knowledgeable collaborator in the development process. Critical configuration and security practices are paramount when setting up an MCP server for this API. Although the API endpoint itself does not handle authentication, all requests must be signed with valid AWS credentials using Signature Version 4. The developer must provision an IAM user or role with the principle of least privilege, granting only the specific Kinesis Video Streams permissions required (e.g., `kinesisvideo:GetClip`, `kinesisvideo:GetHLSStreamingSessionURL`) and scoped to specific streams via resource ARNs. Best practices include using short-lived temporary credentials via the AWS Security Token Service, encrypting all data in transit and at rest (leveraging the Kinesis Video Streams encryption), and implementing strict API gateway controls or VPC endpoints if the MCP server is deployed within a private network. Comprehensive logging via AWS CloudTrail should be enabled to audit all API calls made through the MCP interface, ensuring traceability and compliance.

https://mcpbridge.org/config/amazonaws-com-kinesis-video-archived-media.json

Amazon Kinesis Video Signaling Channels

The Amazon Kinesis Video Signaling Channels API, provided by Amazon Web Services (AWS) as an integral component of its Kinesis Video Streams service, acts as a critical infrastructure layer for establishing and managing real-time peer-to-peer connections using the WebRTC protocol. This managed signaling service abstracts the inherent complexity of peer discovery, NAT traversal, and session negotiation. Its core capabilities are exposed through two primary endpoints: POST /v1/get-ice-server-config, which provides developers with a list of ICE (Interactive Connectivity Establishment) servers, including STUN and TURN configurations, essential for establishing connections across restrictive networks; and POST /v1/send-alexa-offer-to-master, which facilitates the transmission of a WebRTC SDP (Session Description Protocol) offer to a designated master node in a master-viewer architecture. Enterprise use cases are vast, ranging from building scalable, low-latency video streaming solutions for security and monitoring systems, enabling real-time audio/video communication in telehealth or remote assistance platforms, and powering interactive live sports or event streaming where direct peer connections are paramount. For consumers, this API underpins the connectivity of smart home devices like video doorbells and baby monitors to companion apps, ensuring reliable, real-time interaction. When exposed as tools to an AI coding assistant via the Model Context Protocol (MCP), this API transforms from a set of static endpoints into a dynamic, programmable interface for AI-driven development and automation. The primary value lies in enabling the AI to act as a real-time infrastructure orchestrator. Instead of a developer manually writing boilerplate code to fetch TURN credentials or construct signaling messages, they can instruct the AI to perform these operations contextually. For instance, the AI can be directed to "Provision a complete WebRTC signaling channel for my new smart camera application," prompting it to generate the necessary client-side code that integrates calls to the get-ice-server-config endpoint, handle the response, and embed the credentials securely. It can dynamically adapt configurations, such as querying the current server config to determine if TURN servers are required based on a simulated network environment, thereby automating network adaptation logic. The AI becomes a knowledgeable partner that understands not just the syntax but the architectural purpose of the signaling service. In practical, developer-led workflows, this MCP integration unlocks significant automation potential. A developer can instruct the AI agent to: "Analyze the peer connection setup in my application and optimize it for mobile networks by querying the current ICE server configuration and generating fallback logic for TURN relay usage if direct connections fail." Another powerful task would be: "Automate the end-to-end connection setup for a new viewer joining a live stream. Have the AI agent obtain the necessary ICE configuration, construct the appropriate WebRTC offer using these credentials, and send it via the send-alexa-offer-to-master endpoint to the stream's master, then handle the response to establish the connection." This elevates the AI from a code generator to a runtime collaborator that can prototype, debug, and verify the entire signaling handshake, dramatically reducing the time to implement complex, real-time communication features. Critical security considerations are paramount, even though the basic description indicates "None" for authentication, which likely refers to the API's own endpoint authentication rather than access to the underlying AWS resource. All calls to Kinesis Video Streams APIs must be authenticated and authorized using AWS credentials and IAM policies, following the principle of least privilege. Developers must ensure the AI assistant is configured with an IAM role or user that has only the specific permissions needed for `kinesisvideo:GetIceServerConfig` and `kinesisvideo:SendAlexaOfferToMaster`, scoped to the specific signaling channel ARN. The use of short-lived, temporary credentials is strongly recommended. Furthermore, API access should be restricted via network controls like Amazon VPC endpoints or IP allow-listing where possible. Any credentials or session tokens obtained via the API must be treated as highly sensitive secrets, never hard-coded in client-side applications, and should be refreshed dynamically by the application as needed. Security best practices mandate that the AI agent itself operates within a secure environment, with its access to AWS credentials tightly controlled and audited.

https://mcpbridge.org/config/amazonaws-com-kinesis-video-signaling.json