AI & MLQuality Score: 46

Amazon CodeGuru Profiler MCP Configuration

The Amazon CodeGuru Profiler MCP configuration provides a hosted JSON schema that connects AI assistants — including Claude Desktop, Cursor, Windsurf, and VS Code Copilot — to the Amazon CodeGuru Profiler API via the Model Context Protocol. This configuration maps 10 API endpoints as callable tools, including GetNotificationConfiguration, AddNotificationChannels, BatchGetFrameMetricData, and more. No authentication credentials are needed — it works out of the box. The configuration is auto-generated from the Amazon CodeGuru Profiler OpenAPI specification (v2019-07-18) 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-codeguruprofiler.json

Download JSON Claude Desktop Setup →

One-Click Client Setup

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

Claude Desktop

claude_desktop_config.json

{
  "mcpServers": {
    "amazonaws-com-codeguruprofiler": {
      "command": "npx",
      "args": [
        "-y",
        "@mcp/amazonaws-com-codeguruprofiler"
      ],
      "env": {
        "AMAZON_CODEGURU_PROFILER_API_KEY": "your_amazon_codeguru_profiler_api_key"
      }
    }
  }
}

Cursor & VS Code

MCP Server URL Setup

{
  "mcpServers": {
    "amazonaws-com-codeguruprofiler": {
      "url": "https://mcpbridge.org/config/amazonaws-com-codeguruprofiler.json"
    }
  }
}

Raw Configuration JSON

For local command line wrappers or dynamic shell bindings.

{
  "mcpServers": {
    "amazonaws-com-codeguruprofiler": {
      "command": "npx",
      "args": ["-y","@mcp/amazonaws-com-codeguruprofiler"],
      "env": {
      "AMAZON_CODEGURU_PROFILER_API_KEY": "your_amazon_codeguru_profiler_api_key"
}
    }
  }
}

Required Environment Keys

Substitute these secrets inside your configuration directory environment definitions.

AMAZON_CODEGURU_PROFILER_API_KEY

Replace your_amazon_codeguru_profiler_api_key with your secret key credential

Mapped Web APIs & Tools

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

GET/profilingGroups/{profilingGroupName}/notificationConfiguration

GetNotificationConfiguration

POST/profilingGroups/{profilingGroupName}/notificationConfiguration

AddNotificationChannels

POST/profilingGroups/{profilingGroupName}/frames/-/metrics

BatchGetFrameMetricData

POST/profilingGroups/{profilingGroupName}/configureAgent

ConfigureAgent

POST/profilingGroups#clientToken

CreateProfilingGroup

GET/profilingGroups/{profilingGroupName}

DescribeProfilingGroup

PUT/profilingGroups/{profilingGroupName}

UpdateProfilingGroup

DELETE/profilingGroups/{profilingGroupName}

DeleteProfilingGroup

GET/internal/findingsReports

GetFindingsReportAccountSummary

GET/profilingGroups/{profilingGroupName}/policy

GetPolicy

Similar Configurations

OpenAI API

Generate text, images, and embeddings. Integrate GPT models and DALL-E into your AI agent.

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

Anthropic API

Access Claude AI models for text generation, analysis, and code assistance through the Anthropic API.

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

OpenAI 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.json

Amazon CodeGuru Reviewer

The Amazon CodeGuru Reviewer API is a powerful programmatic interface to Amazon's automated code analysis service, designed to elevate code quality and developer productivity. This API exposes the core functionalities of a managed service that combines deep static analysis, machine learning models trained on vast code repositories, and pattern recognition to identify complex defects, security vulnerabilities, and non-idiomatic code patterns that are often missed in manual reviews. Specifically targeting Java and Python codebases, CodeGuru Reviewer analyzes code changes submitted through integrated repositories like AWS CodeCommit, GitHub, or Bitbucket, and generates actionable recommendations. Its primary enterprise use cases are integrated into continuous integration and continuous delivery (CI/CD) pipelines for automated, mandatory code quality gates; conducting security and compliance audits on critical application code; and providing scalable, consistent feedback during the pull request process, thereby reducing the burden on human reviewers and accelerating safe code deployments. When exposed as tools via the Model Context Protocol (MCP) to an AI coding assistant such as Claude Desktop, Cursor, or Cline, this API becomes a force multiplier for AI-driven development workflows. The AI agent gains the ability to not only understand code but to actively invoke professional-grade quality assurance services. Instead of the developer manually switching context to a web console, the AI can be directly instructed to perform sophisticated, context-aware actions. This integration transforms the AI from a code generation helper into a comprehensive code lifecycle manager. The agent can programmatically create and monitor code reviews, retrieve specific line-level recommendations with their explanations, and even manage the feedback loop by reading or submitting developer responses to those recommendations, all through natural language commands within the coding environment. A developer can instruct the AI agent to execute a variety of dynamic, high-value tasks. For example, a command like "Analyze the recent changes in my repository for security issues" would trigger the agent to use the POST /codereviews endpoint to initiate a review on the latest commit or pull request, and then use GET /codereviews/{CodeReviewArn}/Recommendations to fetch and summarize the findings. The agent can be tasked with "Fetch all unresolved 'Critical' recommendations from the last three reviews on this file," which would involve querying GET /codereviews#Type to list recent reviews, filtering by status, and then aggregating recommendations from each. Furthermore, it can automate feedback tracking: "Update the feedback on this recommendation to 'acknowledged' since we've decided to address it in the next sprint," which the agent would accomplish via POST /feedback/{CodeReviewArn}#RecommendationId. These interactions create a seamless bridge between the AI's understanding of the code and the external, authoritative source of truth for its quality. Critical to setting up this API integration is acknowledging the security model. While the described API documentation reference indicates no built-in authentication, accessing the real Amazon CodeGuru Reviewer API requires secure AWS credentials. A dedicated IAM user or role with the least-privilege policy—granting only the specific CodeGuru Reviewer permissions needed (e.g., codeguru-reviewer:CreateCodeReview, codeguru-reviewer:GetCodeReview)—must be configured. These credentials (Access Key ID and Secret Access Key) should be securely managed in the AI tool's environment variables or secret store, never hardcoded. The AI assistant's MCP server implementation must be designed to handle these credentials securely, using them to sign requests via AWS Signature Version 4. Developers must also ensure the AWS region is correctly specified, as CodeGuru Reviewer is a regional service, and they should be mindful of potential costs associated with API calls and analyzed lines of code when enabling automated, large-scale reviews.

https://mcpbridge.org/config/amazonaws-com-codeguru-reviewer.json

← Amazon CodeGuru Profiler MCP Details External API Docs →