Amazon SageMaker ServiceMCP Configuration & Schema Registry
The Amazon SageMaker Service Model Context Protocol (MCP) configuration provides a validated, machine-readable JSON schema and executable bridge that connects state-of-the-art AI coding assistants — including Claude Desktop, Cursor IDE, Windsurf, Cline, and VS Code Copilot — directly to the Amazon SageMaker Service REST API. By leveraging the standardized open Model Context Protocol, AI agents can dynamically discover capabilities, validate input parameters against strict JSON Schemas, and execute live API operations without context switching or manual copy-pasting.
Quick Specs & Integration Summary
Technical Architecture & Protocol Semantics
Under the Model Context Protocol specification, the Amazon SageMaker Service configuration functions as an isolated protocol adapter. When an AI agent initializes a session, the client establishes a bidirectional JSON-RPC 2.0 communication channel over standard input/output (stdio) or Server-Sent Events (SSE). During the initial handshake, the server publishes its tool manifest extracted from the Amazon SageMaker Service OpenAPI specification (version 2017-07-24).
The Amazon SageMaker Service API is a comprehensive programmatic interface provided by Amazon Web Services (AWS) that enables developers, data scientists, and MLOps engineers to fully automate the end-to-end machine learning lifecycle. It serves as the foundational control plane for Amazon SageMaker, a fully managed service that makes it easy to build, train, and deploy machine learning (ML) models at scale. The API's core capabilities span the entire ML workflow, including creating and managing infrastructure (like notebook instances, training clusters, and endpoints), defining and orchestrating training jobs and experiments, registering and versioning models, and deploying models for real-time or batch inference. Enterprises leverage this API to build scalable, automated ML pipelines, enforce governance and reproducibility across teams, and rapidly deploy models into production applications, turning data science initiatives into reliable, operational assets. Exposing this API as a set of tools via the Model Context Protocol (MCP) to an AI coding assistant unlocks a powerful paradigm for natural language-driven infrastructure management. Instead of manually writing boilerplate code or navigating complex consoles, a developer can converse with an AI agent to perform sophisticated actions. The value lies in abstraction and context: the AI assistant, equipped with the API's tools, can interpret high-level intent like "provision a training environment for a computer vision model" and translate it into the precise sequence of API calls—creating an algorithm, a training job, and an associated endpoint. This drastically accelerates prototyping, reduces cognitive load, and democratizes access to SageMaker's advanced features, allowing teams to focus on model logic rather than plumbing. The AI can act as an expert co-pilot, suggesting configurations, checking resource status, and ensuring best practices are followed through guided interaction. Practically, a developer can instruct an AI agent to execute a wide range of dynamic, workflow-driven tasks. For instance, an instruction like "query my SageMaker experiments to find the training job with the highest accuracy on the validation set, then create a model package from its artifacts and deploy it to a staging endpoint" becomes feasible. The AI could use the `BatchDescribeModelPackage` or equivalent tools to inspect job metrics, then orchestrate a deployment workflow using tools like `CreateModel` and `CreateEndpoint`. Another example is instructing the agent to "audit all my active SageMaker endpoints, identify any that have been idle for more than 24 hours, and either tag them for review or shut them down to optimize costs," leveraging tools such as `AddTags` and `DeleteEndpoint`. The agent can also automate repetitive tasks like "set up a weekly training pipeline for our fraud detection model with these specific hyperparameters," creating the necessary resources in sequence and scheduling the job. Critical to the secure and effective operation of this API integration are strict adherence to authentication and authorization best practices. While the API call itself may be abstracted by the MCP server, the underlying AWS credentials used to invoke the SageMaker API must be handled with the utmost care. The principle of least privilege is paramount: the IAM role or user credentials configured for the AI assistant should only have permissions for the specific SageMaker actions required for its intended use case (e.g., only `CreateEndpoint` and `DeleteEndpoint` if its role is endpoint lifecycle management). Developers must never use long-term root or administrative credentials. Instead, they should create dedicated IAM roles with fine-grained policies, leverage AWS Security Token Service (STS) for temporary credentials where possible, and ensure all API calls are made over encrypted connections. The MCP server configuration must securely manage these credentials, preferably through environment variables or a secrets manager, to prevent exposure within logs or code repositories. This architecture guarantees strict process boundary isolation: all sensitive authorization headers and secret tokens remain sandboxed inside the client runtime, never leaking into language model context windows or external logging endpoints.
Hosted Remote Configuration URL
MCP Configuration FileProvide this hosted URL in any client that supports remote MCP schema auto-loading.
https://mcpbridge.org/config/amazonaws-com-sagemaker.json2. AI Assistant Use Cases & Practical Workflows
Tailored for AI & MLReal-world execution scenarios demonstrating how LLM agents (Claude 3.7, GPT-4o, Cursor Agent) invoke Amazon SageMaker Service tools to automate developer workflows.
1. Automated Model Evaluation & Benchmark Harness
Model EvaluationSubmit standardized prompt evaluation suites to models, aggregate latency and accuracy metrics, and compile comparative benchmark markdown tables.
"Run our evaluation test suite against Amazon SageMaker Service. Record completion token latency, context recall scores, and output a formatted markdown performance benchmark table."
2. High-Throughput Embedding & Vector Ingestion
Vector PipelinesBatch process unstructured markdown documentation through embedding endpoints, validate dimensionalities, and push vectors to indexes.
"Generate text embeddings for our updated documentation articles using Amazon SageMaker Service. Validate that vector dimensions equal 1536 and prepare upsert payloads for the vector database."
3. Fine-Tuning Job Monitoring & Loss Curve Auditing
Fine-Tuning OpsInspect active fine-tuning job telemetry, summarize training loss progression, and alert if validation loss starts diverging.
"Check the current status and training loss progression of our fine-tuning job in Amazon SageMaker Service. Summarize epoch completion percentages and estimate remaining completion time."
4. Token Quota & Cost Optimization Governance
LLMOps FinOpsTrack organization token burn rates across teams, enforce departmental quotas, and optimize prompt cache hit rates.
"Query organization usage metrics in Amazon SageMaker Service for the past 7 days. Break down token consumption by model version and highlight optimization opportunities for cached prompts."
End-to-End Multi-Step Agent Execution Lifecycle
When an engineer submits a task to Claude Desktop or Cursor, the LLM executes an autonomous 4-phase Model Context Protocol loop:
Schema Introspection
Handshake lists all 10 tools and builds argument validators.
Argument Synthesis
Model extracts parameters from prompt and validates types against OpenAPI rules.
Stdio Execution
Bridge invokes live API with injected local credentials and captures raw HTTP response.
Output Remediation
LLM parses JSON results, handles status codes, and presents synthesized answers.
3. Multi-Client Installation Matrix & Setup Guides
Select your AI assistant below to view exact configuration file paths, JSON installation snippets, and launch commands.
Claude Desktop
claude_desktop_config.json~/Library/Application Support/Claude/claude_desktop_config.json%APPDATA%\Claude\claude_desktop_config.json~/.config/Claude/claude_desktop_config.json{
"mcpServers": {
"amazonaws-com-sagemaker": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-openapi",
"https://api.apis.guru/v2/specs/amazonaws.com/sagemaker/2017-07-24/openapi.json"
],
"env": {
"AMAZON_SAGEMAKER_SERVICE_API_KEY": "your_amazon_sagemaker_service_api_key"
}
}
}
}Cursor IDE
.cursor/mcp.jsonOpen Cursor Settings → Features → MCP Servers, or create .cursor/mcp.json in your project root.
{
"mcpServers": {
"amazonaws-com-sagemaker": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-openapi",
"https://api.apis.guru/v2/specs/amazonaws.com/sagemaker/2017-07-24/openapi.json"
],
"env": {
"AMAZON_SAGEMAKER_SERVICE_API_KEY": "your_amazon_sagemaker_service_api_key"
}
}
}
}Saves as .cursor/mcp.json in the download. Move it to your project root.
VS Code / Cline Extension
cline_mcp_settings.jsonPaste into your Cline extension MCP configuration or Roo Code host settings.
{
"mcpServers": {
"amazonaws-com-sagemaker": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-openapi",
"https://api.apis.guru/v2/specs/amazonaws.com/sagemaker/2017-07-24/openapi.json"
],
"env": {
"AMAZON_SAGEMAKER_SERVICE_API_KEY": "your_amazon_sagemaker_service_api_key"
}
}
}
}Zed Editor & Docker CLI
Zed / DockerDocker container execution command:
docker run -i --rm -e AMAZON_SAGEMAKER_SERVICE_API_KEY="YOUR_SECRET_VALUE" node:20-alpine npx -y @modelcontextprotocol/server-openapi https://api.apis.guru/v2/specs/amazonaws.com/sagemaker/2017-07-24/openapi.json
Zed settings context servers JSON:
{
"context_servers": {
"amazonaws-com-sagemaker": {
"command": {
"path": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-openapi",
"https://api.apis.guru/v2/specs/amazonaws.com/sagemaker/2017-07-24/openapi.json"
],
"env": {
"AMAZON_SAGEMAKER_SERVICE_API_KEY": "your_amazon_sagemaker_service_api_key"
}
}
}
}
}Programmatic SDK Integration (TypeScript / Python)
Initialize the Amazon SageMaker Service MCP client directly in your backend codebase.
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
// Initialize Amazon SageMaker Service MCP client transport over stdio
const transport = new StdioClientTransport({
command: "npx",
args: ["-y","@modelcontextprotocol/server-openapi","https://api.apis.guru/v2/specs/amazonaws.com/sagemaker/2017-07-24/openapi.json"],
env: { AMAZON_SAGEMAKER_SERVICE_API_KEY: process.env.AMAZON_SAGEMAKER_SERVICE_API_KEY || "YOUR_SECRET_KEY" }
});
const client = new Client(
{ name: "amazonaws-com-sagemaker-client", version: "1.0.0" },
{ capabilities: { tools: {}, resources: {}, prompts: {} } }
);
async function connectAndRun() {
await client.connect(transport);
const tools = await client.listTools();
console.log("Connected to Amazon SageMaker Service MCP Server.");
console.log("Discovered 10 mapped tools:", tools);
}
connectAndRun().catch(console.error);Raw Stdio Schema Definition
schema.jsonFor standalone CLI wrappers, background daemon daemons, or custom script integrations:
{
"mcpServers": {
"amazonaws-com-sagemaker": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-openapi",
"https://api.apis.guru/v2/specs/amazonaws.com/sagemaker/2017-07-24/openapi.json"
],
"env": {
"AMAZON_SAGEMAKER_SERVICE_API_KEY": "your_amazon_sagemaker_service_api_key"
}
}
}
}4. Security, Authentication & Credential Management
Safely configure authentication tokens, isolate execution environments, and implement enterprise security best practices.
Required Environment Keys Reference
| Variable Name | Required | Type | Default | Purpose & Guidance |
|---|---|---|---|---|
| AMAZON_SAGEMAKER_SERVICE_API_KEY | REQUIRED | Secret Key / Token | None (Set in env) | your_amazon_sagemaker_service_api_key |
Zero-Downtime Token Rotation Protocol
- Generate Secondary Key: Create a new secret API token with identical scopes in your Amazon SageMaker Service developer portal.
- Update Client Configuration: Insert the new token inside the
envblock of your MCP client JSON config. - Validate Connection: Issue a test query in Claude or Cursor to ensure handshake and tool calls succeed.
- Revoke Stale Token: Decommission the legacy key on the vendor portal to prevent unauthorized access.
Least-Privilege & Sandboxing Rules
- Read-Only Token Scoping: Whenever your workflow only requires querying data, provision read-only credentials to prevent accidental mutations.
- Local Process Isolation: Stdio transports run in isolated local subprocesses; secret credentials are never sent across the internet to MCP Bridge servers.
- Prompt Injection Defense: AI model responses are sandboxed; verify generated destructive arguments before confirming execution in agent mode.
Enterprise Security Checklist (Mandatory Practices)
- Never commit
claude_desktop_config.jsonor.cursor/mcp.jsoncontaining raw secrets into public GitHub repositories. - Add
.cursor/mcp.jsonand.env.localto your project's.gitignorefile. - Always enforce TLS/HTTPS encryption on outbound network requests initiated by the server process.
5. Tool Parameter Schemas & Natural Language Execution
Mapped OpenAPI operations converted into discrete Model Context Protocol tools with strict JSON-RPC payload validators.
/#X-Amz-Target=SageMaker.AddAssociationAddAssociation
{
"jsonrpc": "2.0",
"id": 1,
"method": "tools/call",
"params": {
"name": "amazonaws-com-sagemaker_post_X_Amz_Target_SageMaker_AddAssociation",
"arguments": {}
}
}"Use Amazon SageMaker Service to execute AddAssociation and output the formatted result."
/#X-Amz-Target=SageMaker.AddTagsAddTags
{
"jsonrpc": "2.0",
"id": 2,
"method": "tools/call",
"params": {
"name": "amazonaws-com-sagemaker_post_X_Amz_Target_SageMaker_AddTags",
"arguments": {}
}
}"Use Amazon SageMaker Service to execute AddTags and output the formatted result."
/#X-Amz-Target=SageMaker.AssociateTrialComponentAssociateTrialComponent
{
"jsonrpc": "2.0",
"id": 3,
"method": "tools/call",
"params": {
"name": "amazonaws-com-sagemaker_post_X_Amz_Target_SageMaker_AssociateTrialComponent",
"arguments": {}
}
}"Use Amazon SageMaker Service to execute AssociateTrialComponent and output the formatted result."
/#X-Amz-Target=SageMaker.BatchDescribeModelPackageBatchDescribeModelPackage
{
"jsonrpc": "2.0",
"id": 4,
"method": "tools/call",
"params": {
"name": "amazonaws-com-sagemaker_post_X_Amz_Target_SageMaker_BatchDescribeModelPackage",
"arguments": {}
}
}"Use Amazon SageMaker Service to execute BatchDescribeModelPackage and output the formatted result."
/#X-Amz-Target=SageMaker.CreateActionCreateAction
{
"jsonrpc": "2.0",
"id": 5,
"method": "tools/call",
"params": {
"name": "amazonaws-com-sagemaker_post_X_Amz_Target_SageMaker_CreateAction",
"arguments": {}
}
}"Use Amazon SageMaker Service to execute CreateAction and output the formatted result."
/#X-Amz-Target=SageMaker.CreateAlgorithmCreateAlgorithm
{
"jsonrpc": "2.0",
"id": 6,
"method": "tools/call",
"params": {
"name": "amazonaws-com-sagemaker_post_X_Amz_Target_SageMaker_CreateAlgorithm",
"arguments": {}
}
}"Use Amazon SageMaker Service to execute CreateAlgorithm and output the formatted result."
/#X-Amz-Target=SageMaker.CreateAppCreateApp
{
"jsonrpc": "2.0",
"id": 7,
"method": "tools/call",
"params": {
"name": "amazonaws-com-sagemaker_post_X_Amz_Target_SageMaker_CreateApp",
"arguments": {}
}
}"Use Amazon SageMaker Service to execute CreateApp and output the formatted result."
/#X-Amz-Target=SageMaker.CreateAppImageConfigCreateAppImageConfig
{
"jsonrpc": "2.0",
"id": 8,
"method": "tools/call",
"params": {
"name": "amazonaws-com-sagemaker_post_X_Amz_Target_SageMaker_CreateAppImageConfig",
"arguments": {}
}
}"Use Amazon SageMaker Service to execute CreateAppImageConfig and output the formatted result."
6. Interactive Troubleshooting & FAQ Accordion
Diagnose and resolve common JSON-RPC protocol error codes, connection disconnects, and schema refresh issues.
A 401 Unauthorized response indicates that the upstream Amazon SageMaker Service API rejected the authentication credential supplied in your MCP client's environment configuration. To resolve this: (1) Verify that your secret token is defined inside the "env" block of claude_desktop_config.json or .cursor/mcp.json rather than hardcoded in the command string. (2) Check whether Amazon SageMaker Service requires a prefix such as "Bearer <token>" in the authorization header. (3) Confirm that your API key has not expired and has been granted sufficient least-privilege scopes on the Amazon SageMaker Service developer dashboard.
If your MCP client fails to initialize tools for Amazon SageMaker Service: (1) Test the bridge launcher command ("npx -y @modelcontextprotocol/server-openapi https://api.apis.guru/v2/specs/amazonaws.com/sagemaker/2017-07-24/openapi.json") directly inside your terminal or shell to inspect stdout/stderr diagnostic traces. (2) Verify network connectivity to the schema source (https://api.apis.guru/v2/specs/amazonaws.com/sagemaker/2017-07-24/openapi.json). (3) Ensure Node.js (v18+) is installed and accessible in your system PATH. (4) For authenticated APIs, confirm credentials are configured in your client's "env" mapping rather than command arguments.
MCP clients like Claude Desktop and Cursor query the server's tools list ("tools/list") during startup and cache the resulting JSON Schema for the duration of the application session. If new endpoints or parameters are added to Amazon SageMaker Service: (1) Fully quit and restart Claude Desktop (Cmd+Q on macOS or File > Exit on Windows). (2) In Cursor IDE, navigate to Settings > Features > MCP Servers, toggle the Amazon SageMaker Service server off and on, or click the refresh icon to re-execute the initialization handshake.
If the AI model hallucinates parameters or fails to invoke a tool automatically: (1) Add explicit system instructions in your project's .cursorrules or Claude project prompt (e.g., "When querying AI & ML, always invoke the amazonaws-com-sagemaker MCP server tools first"). (2) Ensure parameter types match schema specifications (e.g., passing integers as numbers rather than strings). (3) Check that required parameters marked in Section 5 are not omitted from the model's generated payload.
When the Amazon SageMaker Service upstream endpoint returns an HTTP 429 Too Many Requests response, the MCP server bubbles the structured error payload back to the AI client over stdio. Modern LLMs like Claude 3.7 and Cursor Agent recognize rate-limiting status codes, inspect the "Retry-After" header if present, and will automatically introduce backoff delays or ask the user before retrying the operation.
The Hosted Config URL (https://mcpbridge.org/config/amazonaws-com-sagemaker.json) provides a static, remote JSON schema definition that cloud-native MCP clients can fetch over HTTPS for dynamic discovery. In contrast, local stdio configurations execute a local subprocess on your workstation. Local stdio processes offer maximum security because secret API keys remain strictly on your local machine and never transit third-party proxy servers.
Similar AI & ML Configurations
Explore related API bridges with ready-to-use Model Context Protocol schemas.
Openai
AI & MLGenerate text, images, and embeddings. Integrate GPT models and DALL-E into your AI agent.
https://mcpbridge.org/config/openai.jsonAnthropic API
AI & MLAccess Claude AI models for text generation, analysis, and code assistance through the Anthropic API.
https://mcpbridge.org/config/anthropic.jsonOpenAI API
AI & MLThe 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
AI & MLAmazon 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