AWS AppSync

AWS AppSync

Manage applications powered by AWS AppSync.

10K+

10 Tools

Packaged by
Requires Secrets
Add to Docker Desktop

Version 4.43 or later needs to be installed to add the server automatically

Use cases

About

AWS AppSync MCP Server

Manage applications powered by AWS AppSync.

What is an MCP Server?

MCP Info

Image Building Info

AttributeDetails
Dockerfilehttps://github.com/awslabs/mcp/blob/636aca8e109b5559006044f035bb89c16e9e5410/src/aws-appsync-mcp-server/Dockerfile
Commit636aca8e109b5559006044f035bb89c16e9e5410
Docker Image built byDocker Inc.
Docker Scout Health ScoreDocker Scout Health Score
Verify SignatureCOSIGN_REPOSITORY=mcp/signatures cosign verify mcp/aws-appsync-mcp-server --key https://raw.githubusercontent.com/docker/keyring/refs/heads/main/public/mcp/latest.pub
LicenceApache License 2.0

Available Tools (10)

Tools provided by this ServerShort Description
create_apiCreate AppSync API
create_api_cacheCreate API Cache
create_api_keyCreate API Key
create_channel_namespaceCreate Channel Namespace
create_datasourceCreate Data Source
create_domain_nameCreate Domain Name
create_functionCreate Function
create_graphql_apiCreate GraphQL API
create_resolverCreate Resolver
create_schemaCreate Schema

Tools Details

Tool: create_api

Creates a new AppSync API.

    This operation creates a new AppSync API with the specified configuration.
    The API will be created with default settings and can be further configured
    using additional AppSync operations.
ParametersTypeDescription
namestringThe name of the API
event_configstringoptionalThe event configuration for the API
owner_contactstringoptionalThe owner contact information for the API
tagsstringoptionalA map of tags to assign to the resource

Tool: create_api_cache

Creates a cache for the GraphQL API.

    This operation creates an API cache for the specified GraphQL API. Caching improves
    performance by storing frequently requested data and reducing the number of requests
    to data sources.
ParametersTypeDescription
api_caching_behaviorstringCaching behavior. Valid values: FULL_REQUEST_CACHING, PER_RESOLVER_CACHING
api_idstringThe GraphQL API ID
ttlintegerTTL in seconds for entries in the API cache. Valid values are 1-3600 seconds
typestringThe cache instance type. Valid values: SMALL, MEDIUM, LARGE, XLARGE, LARGE_2X, LARGE_4X, LARGE_8X, LARGE_12X
at_rest_encryption_enabledstringoptionalAt-rest encryption flag for cache
health_metrics_configstringoptionalThe health metrics configuration. Valid values: ENABLED, DISABLED
transit_encryption_enabledstringoptionalTransit encryption flag when connecting to cache

Tool: create_api_key

Creates a unique key that you can distribute to clients who invoke your API.

    This operation creates an API key for the specified GraphQL API. API keys are used
    to authenticate requests when the API uses API_KEY authentication type.
ParametersTypeDescription
api_idstringThe ID for the GraphQL API
descriptionstringoptionalA description of the purpose of the API key
expiresstringoptionalFrom the creation time, the time after which the API key expires (Unix timestamp)

Tool: create_channel_namespace

Creates a ChannelNamespace for an Api.

    This operation creates a channel namespace for the specified GraphQL API.
    Channel namespaces provide a way to organize and manage real-time subscriptions
    in AppSync APIs, enabling event-driven architectures and real-time data updates.
ParametersTypeDescription
api_idstringThe ID of the Api associated with the ChannelNamespace
namestringThe name of the ChannelNamespace
code_handlersstringoptionalThe event handler functions that run custom business logic to process published events and subscribe requests
handler_configsstringoptionalConfiguration for event handlers that process published events and subscribe requests
publish_auth_modesstringoptionalThe authorization mode to use for publishing messages on the channel namespace
subscribe_auth_modesstringoptionalThe authorization mode to use for subscribing to messages on the channel namespace
tagsstringoptionalA map of tags to assign to the resource

Tool: create_datasource

Creates a DataSource object for a GraphQL API.

    This operation creates a data source for the specified GraphQL API. Data sources
    connect your GraphQL API to various backend services like DynamoDB, Lambda,
    HTTP endpoints, and more.
ParametersTypeDescription
api_idstringThe API ID for the GraphQL API for the DataSource
namestringA user-supplied name for the DataSource
typestringThe type of the DataSource. Valid values: AWS_LAMBDA, AMAZON_DYNAMODB, AMAZON_ELASTICSEARCH, HTTP, NONE, RELATIONAL_DATABASE, AMAZON_EVENTBRIDGE, AMAZON_OPENSEARCH_SERVICE
descriptionstringoptionalA description of the DataSource
dynamodb_configstringoptionalAmazon DynamoDB settings
elasticsearch_configstringoptionalAmazon OpenSearch Service settings
event_bridge_configstringoptionalAmazon EventBridge settings
http_configstringoptionalHTTP endpoint settings
lambda_configstringoptionalAWS Lambda settings
metrics_configstringoptionalEnables or disables enhanced DataSource metrics. Valid values: ENABLED, DISABLED
open_search_service_configstringoptionalAmazon OpenSearch Service settings
relational_database_configstringoptionalRelational database settings
service_role_arnstringoptionalThe AWS IAM service role ARN for the data source. Format: arn:aws:iam::ACCOUNT-ID:role/ROLE-NAME

Tool: create_domain_name

Creates a custom domain name for use with AppSync APIs.

    This operation creates a custom domain name that can be associated with
    AppSync APIs, allowing you to use your own domain instead of the default
    AppSync domain. Requires an SSL certificate from AWS Certificate Manager.
ParametersTypeDescription
certificate_arnstringThe ARN of the certificate from AWS Certificate Manager
domain_namestringThe domain name to create (e.g., api.example.com)
descriptionstringoptionalA description of the domain name
tagsstringoptionalA map of tags to assign to the resource

Tool: create_function

Creates a Function object for a GraphQL API.

    This operation creates a function for the specified GraphQL API. Functions
    are reusable pieces of resolver logic that can be attached to multiple fields
    in your GraphQL schema.
ParametersTypeDescription
api_idstringThe GraphQL API ID
data_source_namestringThe Function DataSource name
namestringThe Function name
codestringoptionalThe function code that contains the request and response functions
descriptionstringoptionalThe Function description
function_versionstringoptionalThe version of the request mapping template. Currently, the supported value is 2018-05-29
max_batch_sizestringoptionalThe maximum batching size for a resolver
request_mapping_templatestringoptionalThe Function request mapping template
response_mapping_templatestringoptionalThe Function response mapping template
runtimestringoptionalDescribes a runtime used by an AWS AppSync pipeline resolver or AWS AppSync function
sync_configstringoptionalDescribes a Sync configuration for a resolver

Tool: create_graphql_api

Creates a GraphQL API.

    This operation creates a new GraphQL API with the specified configuration.
    The API will be created with the authentication type and other settings provided.
    Supports various authentication types including API_KEY, AWS_IAM, AMAZON_COGNITO_USER_POOLS,
    OPENID_CONNECT, and AWS_LAMBDA.

    When authentication_type is API_KEY, an API key is automatically created with a 7-day expiry.
ParametersTypeDescription
authentication_typestringThe authentication type: API_KEY, AWS_IAM, AMAZON_COGNITO_USER_POOLS, OPENID_CONNECT, AWS_LAMBDA
namestringA user-supplied name for the GraphQL API
additional_authentication_providersstringoptionalA list of additional authentication providers
api_typestringoptionalThe value that indicates whether the GraphQL API is a standard API (GRAPHQL) or merged API (MERGED)
enhanced_metrics_configstringoptionalThe enhancedMetricsConfig object
introspection_configstringoptionalSets the value of the GraphQL API to enable (ENABLED) or disable (DISABLED) introspection
lambda_authorizer_configstringoptionalConfiguration for AWS Lambda function authorization
log_configstringoptionalThe Amazon CloudWatch Logs configuration
merged_api_execution_role_arnstringoptionalThe Identity and Access Management service role ARN for a merged API
open_id_connect_configstringoptionalThe OpenID Connect configuration
owner_contactstringoptionalThe owner contact information for an API resource
query_depth_limitstringoptionalThe maximum depth a query can have in a single request
resolver_count_limitstringoptionalThe maximum number of resolvers that can be invoked in a single request
tagsstringoptionalA TagMap object
user_pool_configstringoptionalThe Amazon Cognito user pool configuration
visibilitystringoptionalSets the value of the GraphQL API to public (GLOBAL) or private (PRIVATE)
xray_enabledstringoptionalA flag indicating whether to enable X-Ray tracing

Tool: create_resolver

Creates a resolver for a GraphQL field in an AppSync API.

    A resolver is the bridge between your GraphQL schema and your data sources.
    It defines how to fetch or modify data for a specific field in your schema.
    Resolvers can be unit resolvers (attached to a single data source) or
    pipeline resolvers (composed of multiple functions).
ParametersTypeDescription
api_idstringThe API ID for the GraphQL API
field_namestringThe name of the field to attach the resolver to
type_namestringThe name of the type (e.g., Query, Mutation, Subscription)
caching_configstringoptionalCaching configuration for the resolver
codestringoptionalThe resolver code for JavaScript/TypeScript resolvers
data_source_namestringoptionalThe name of the data source (required for unit resolvers)
kindstringoptionalThe resolver kind: UNIT or PIPELINE
max_batch_sizestringoptionalMaximum batch size for batch operations
metrics_configstringoptionalMetrics configuration: ENABLED or DISABLED
pipeline_configstringoptionalPipeline configuration for PIPELINE resolvers with functions list
request_mapping_templatestringoptionalThe request mapping template in VTL (Velocity Template Language)
response_mapping_templatestringoptionalThe response mapping template in VTL (Velocity Template Language)
runtimestringoptionalRuntime configuration (name and runtimeVersion)
sync_configstringoptionalSync configuration for conflict resolution

Tool: create_schema

Creates a GraphQL schema for an AppSync API and polls until completion.

    This tool starts the schema creation process and automatically polls for the status
    until the operation completes (either SUCCESS or FAILED). The schema defines the
    structure of your GraphQL API, including types, queries, mutations, and subscriptions.
ParametersTypeDescription
api_idstringThe API ID for the GraphQL API
definitionstringThe schema definition in GraphQL Schema Definition Language (SDL)

Use this MCP Server

{
  "mcpServers": {
    "aws-appsync": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "AWS_REGION",
        "-e",
        "AWS_PROFILE",
        "-e",
        "AWS_ACCESS_KEY_ID",
        "-e",
        "AWS_SECRET_ACCESS_KEY",
        "-e",
        "AWS_SESSION_TOKEN",
        "mcp/aws-appsync-mcp-server"
      ],
      "env": {
        "AWS_REGION": "us-east-1",
        "AWS_PROFILE": "default",
        "AWS_ACCESS_KEY_ID": "AKIAIOSFODNN7EXAMPLE",
        "AWS_SECRET_ACCESS_KEY": "your-aws-secret-access-key",
        "AWS_SESSION_TOKEN": "your-aws-session-token"
      }
    }
  }
}

Why is it safer to run MCP Servers with Docker?

Related servers