AWS Data Exchange MCP Configuration
The AWS Data Exchange MCP configuration provides a hosted JSON schema that connects AI assistants — including Claude Desktop, Cursor, Windsurf, and VS Code Copilot — to the AWS Data Exchange API via the Model Context Protocol. This configuration maps 10 API endpoints as callable tools, including GetJob, CancelJob, StartJob, and more. No authentication credentials are needed — it works out of the box. The configuration is auto-generated from the AWS Data Exchange OpenAPI specification (v2017-07-25) 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
Hosted Config URL
Use this hosted URL in any client that supports remote MCP schema auto-loading.
https://mcpbridge.org/config/amazonaws-com-dataexchange.jsonOne-Click Client Setup
Copy the configurations below to wire your local coding assistant directly.
Claude Desktop
claude_desktop_config.json{
"mcpServers": {
"amazonaws-com-dataexchange": {
"command": "npx",
"args": [
"-y",
"@mcp/amazonaws-com-dataexchange"
],
"env": {
"AWS_DATA_EXCHANGE_API_KEY": "your_aws_data_exchange_api_key"
}
}
}
}Cursor & VS Code
MCP Server URL Setup{
"mcpServers": {
"amazonaws-com-dataexchange": {
"url": "https://mcpbridge.org/config/amazonaws-com-dataexchange.json"
}
}
}Raw Configuration JSON
For local command line wrappers or dynamic shell bindings.
{
"mcpServers": {
"amazonaws-com-dataexchange": {
"command": "npx",
"args": ["-y","@mcp/amazonaws-com-dataexchange"],
"env": {
"AWS_DATA_EXCHANGE_API_KEY": "your_aws_data_exchange_api_key"
}
}
}
}Required Environment Keys
Substitute these secrets inside your configuration directory environment definitions.
AWS_DATA_EXCHANGE_API_KEYyour_aws_data_exchange_api_key with your secret key credentialMapped Web APIs & Tools
The following routes will be exposed directly as protocol tools for the LLM.
/v1/jobs/{JobId}GetJob
/v1/jobs/{JobId}CancelJob
/v1/jobs/{JobId}StartJob
/v1/data-setsListDataSets
/v1/data-setsCreateDataSet
/v1/event-actionsListEventActions
/v1/event-actionsCreateEventAction
/v1/jobsListJobs
/v1/jobsCreateJob
/v1/data-sets/{DataSetId}/revisionsListDataSetRevisions
Similar Configurations
OpenAI API
Generate text, images, and embeddings. Integrate GPT models and DALL-E into your AI agent.
https://mcpbridge.org/config/openai.jsonAnthropic API
Access Claude AI models for text generation, analysis, and code assistance through the Anthropic API.
https://mcpbridge.org/config/anthropic.jsonOpenAI API
The OpenAI API, developed and maintained by OpenAI, provides programmatic access to a suite of advanced artificial intelligence capabilities centered around large language models (LLMs). Its core functions enable developers to integrate state-of-the-art natural language processing and generation into applications. Key endpoints support text generation (completions, chat completions), content transformation (edits, classifications), semantic analysis (embeddings), and multimodal processing (audio transcriptions and translations). The API serves a broad spectrum of users, from individual developers and startups building conversational agents or content tools to large enterprises automating complex workflows, enhancing customer support, conducting sentiment analysis on large text corpora, or generating synthetic data for training. Use cases span consumer applications like intelligent writing assistants and enterprise-grade solutions for automated document summarization, code generation, and multilingual communication platforms. When exposed as a tool to an AI coding assistant through the Model Context Protocol (MCP), the OpenAI API’s value is significantly amplified. The AI agent gains dynamic, on-demand access to powerful generative and analytical functions without requiring the developer to manually craft intricate API calls or manage complex prompt engineering for each task. This transforms the assistant from a static code-completion engine into an active collaborator that can reason about and manipulate language in real time. For instance, an AI agent within an IDE can directly invoke the completions endpoint to generate boilerplate code from comments, use the embeddings endpoint to identify semantically similar code snippets within a codebase for refactoring suggestions, or call the translations endpoint to automatically localize string literals in an internationalization workflow. This deep integration streamlines the development lifecycle by embedding advanced AI capabilities directly into the authoring environment. Practical workflows enabled by this MCP integration are numerous and dynamic. A developer can instruct the AI to "generate comprehensive unit tests for this Python class by analyzing its public methods and edge cases," leveraging the completions or chat endpoints. Another command could be, "Analyze the sentiment and key topics of these customer feedback logs and produce a summary report," utilizing classifications and embeddings. For data processing tasks, a developer might say, "Translate the error message strings in this logs.txt file from Japanese to English and categorize them by severity," invoking the translations and classifications endpoints in sequence. In collaborative code review, the AI could be directed to "suggest code improvements for this pull request based on best practices for performance and readability," using the edits endpoint to propose specific, contextual modifications. These interactions demonstrate how the MCP server acts as a bridge, allowing the AI to execute sophisticated, multi-step language tasks as part of the developer's natural workflow. Critical to the secure and effective use of this API is proper authentication and configuration, despite the placeholder "None" in the basic metadata. In practice, authentication is mandatory and is handled via API keys (or potentially OAuth for more complex setups). Developers must treat these keys as high-privilege secrets, never hardcoding them in source code or committing them to version control. Best practices include using environment variables or secure secret management services, adhering to the principle of least privilege by creating separate keys with restricted permissions for different development stages or services, and regularly rotating credentials. When configuring an MCP server to interface with the API, it should be set up to inject these credentials securely at runtime. Developers should also implement robust error handling and rate limiting on the client side to manage API quotas and prevent service disruption, ensuring the integration is both secure and resilient.
https://mcpbridge.org/config/openai-com.jsonAmazon CodeGuru Profiler
Amazon CodeGuru Profiler is an advanced application performance profiling service provided by Amazon Web Services (AWS). It continuously collects runtime performance data—such as CPU utilization, memory allocation, and thread contention—from live production applications, then analyzes this data using machine learning algorithms to pinpoint performance bottlenecks and inefficiencies. The API serves as the programmatic interface for managing the profiling lifecycle, allowing developers to create and configure profiling groups, adjust agent settings, retrieve performance metrics and findings, and manage notification configurations. Enterprise use cases include optimizing microservice latency in high-traffic systems, reducing cloud compute costs by identifying inefficient code paths, and maintaining application health in continuous deployment pipelines where performance regressions must be detected early. For development teams, it provides actionable insights to guide code optimization efforts based on real-world usage rather than synthetic benchmarks. When exposed as tools via the Model Context Protocol (MCP) to AI coding assistants such as Claude Desktop or Cursor, the CodeGuru Profiler API unlocks a powerful paradigm where an AI agent can directly interact with live performance telemetry. The primary value lies in enabling the AI to contextualize code suggestions with actual runtime behavior. Instead of analyzing static code alone, the AI can query the latest profiling data to understand which functions are consuming the most resources under real load, validate whether a suggested refactor addresses a genuine bottleneck, or even predict the performance impact of a proposed change. This transforms the assistant from a generic code generator into a performance-aware partner, capable of providing recommendations that are not just syntactically correct but are also optimized for the specific performance profile of the deployed application. In a practical workflow, a developer could instruct their AI agent to perform dynamic, performance-informed tasks. For example, the AI could use the GET /profilingGroups/{profilingGroupName} endpoint to retrieve the current status and ARN of a profiling group, then use POST /profilingGroups/{profilingGroupName}/configureAgent to dynamically update agent configuration parameters (like sampling intervals) in response to a detected performance anomaly. An AI agent could query GET /internal/findingsReports to pull the latest list of performance findings, analyze the patterns, and then generate a pull request with code fixes targeted at the top recommendations. Furthermore, the agent could automate notification setup by using POST /profilingGroups/{profilingGroupName}/notificationConfiguration to ensure the team is alerted when CPU utilization exceeds a threshold identified through previous profiling data, creating a closed-loop system for performance management. Developers integrating this API via an MCP server must adhere to critical security and configuration practices. Although the listed authentication is "None," the API fundamentally requires AWS Identity and Access Management (IAM) credentials for all calls, as it is an AWS service. The authentication method "None" in this context likely refers to the lack of a separate API key system, relying instead on standard AWS SigV4 signing. Therefore, security best practices are paramount: apply the principle of least privilege by granting the AI's execution environment only the specific CodeGuru Profiler permissions needed (e.g., profiler:DescribeProfilingGroups, profiler:GetFindingsReport), and avoid wildcard permissions. Credentials should be securely managed via environment variables or an AWS role, never hard-coded. Network security should ensure the AI tool operates within a controlled environment (like a VPC or with strict egress rules) to prevent unauthorized data exfiltration, and all API interactions should be logged and audited for compliance.
https://mcpbridge.org/config/amazonaws-com-codeguruprofiler.json