Accelerate development with Amazon Bedrock AgentCore MCP server

We look forward to unveiling our Amazon Bedrock AgentCore Model Context Protocol (MCP) server today. Agent Core MCP Server supports runtime, gateway integration, identity management, agent memory and is dedicated to using agent memory to speed up the creation of Bedlock Agent Core compatible components. Agent-core MCP servers can be used to scale fast prototyping, production AI solutions, or agent infrastructure for enterprises.

Along with agent IDEs such as Kiro, Claude Code, Github Copilot, Cursor, and more, as well as sophisticated MCP servers, it changes the way developers build AI agents. Typically, a considerable amount of time and effort can be learned, for example, about Bedlock Agent Core Services, and the integration of runtime and tool gateways, managing security configurations, and deploying production in just a few minutes via conversation commands with your coding assistant.

In this post, we will introduce you to a new Agent Core MCP server, which will allow you to proceed with the installation procedure and get started.

Agent Core MCP Server Function

Agent Core MCP Servers provide specialized tools that bring new agent development experiences to AWS, automate the full agent lifecycle, eliminate sharp learning curves, and reduce development friction that can slow down innovation cycles. The AgentCore MCP server becomes a challenge to address specific agent development.

1. Convert AgentCore Runtime Integration Agents Extend runtime library imports, update dependencies, and initialize apps by providing guidance to coding assistants on the minimum required functionality changes BedrockAgentCoreApp()converts the entry point to a decorator and changes the direct agent call to payload processing.
2. Automate development environment provisioning By handling the full setup process through the coding assistant: Install the required dependencies (Bedrock-AgentCore SDK, Bedrock-AgentCore-Starter-Toolkit CLI Helpers, Strands-Agents SDK), configure AWS qualifications and AW Regions, and set up roles for roles with Bedrock roles. Configuration file.
3. Simplify tool integration with Bedrock AgentCore Gateway For seamless agent-to-tool communication in a cloud environment.
4. Enable simple agent call and tests Provide natural language commands through the coding assistant to see the complete workflow, including calling provisioning agents at the AgentCore runtime and calls to the AgentCore gateway tool if applicable.

A layered approach

If you use an AgentCore MCP server with your favorite client, we recommend considering a layered architecture designed to provide comprehensive AI agent development support.

1. Layer 1: Agent IDE or Client – Use kilo, claud code, cursor, counter-code extensions, or another natural language interface for developers. For very simple tasks, the Agent IDE is equipped with the appropriate tools to search for documents and perform tasks specific to the Bedlock Agent Core. However, even with this layer alone, developers may observe optimal performance across the AgentCore developer path.
2. Layer 2: AWS Service Documentation – Install an AWS Documentation MCP server for comprehensive AWS Service Documentation, including context for Bedrock AgentCore.
3. Layer 3: Framework Document – Strand, Langgraph, or other framework documentation Install an MCP server or use LLMS.TXT for framework-specific contexts.
4. Layer 4: SDK Document – Install MCP or use LLMS.TXT on the Agent Framework SDK and Bedrock AgentCore SDK for a combined document layer that covers Strands Agents SDK documents and Bedrock AgentCore API references.
5. Layer 5: Steering File – Task-specific guidance for more complex and repeating workflows. Each IDE has a different approach to using steering files (see, for example, steering in Kiro's documentation).

Each layer is built on the previous layer, providing an increasingly specific context for coding assistants to handle everything from basic AWS operations to complex agent transformations and deployments.

install

To start the Amazon Bedrock AgentCore MCP server, you can use a one-click installation of the GitHub repository.

Each IDE is integrated in a different way than MCP using the MCP.JSON file. Check the IDE's MCP documentation, such as Kiro, Cursor, Q CLI, and Claude code, to determine the location of MCP.JSON.

Use the following in MCP.JSON:

{
  "mcpServers": {
    "awslabs.amazon-bedrock-agentcore-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.amazon-bedrock-agentcore-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

For example, Kiro's IDE will show you what happens. AtenterCoreMCP server and two tools, Search_AgentCore_Docs and FETCH_AGENTCORE_DOC, Connected: Connected:

Use an agent-core MCP server for agent development

We use Kiro IDE to view demos for the various use cases below, but the AgentCore MCP server has been tested to work with Claude Code, Amazon Q CLI, Cursor, and VS Code Q plugins. First, let's take a look at the typical agent development lifecycle using the AgentCore service (don't forget that this is just an example of the tools available. Also, you can freely explore such use cases by simply directing the agent in your favorite agent IDE).

The agent development lifecycle follows these steps.

1. The user gets a set of local tools or MCP servers and
   1. Create a Lambda target for the AgentCore Gateway. or
   2. Deploy AS-IS MCP server to AgentCore runtime
2. Users prepare their actual agent code using preferred frameworks such as Strands Agent and Langgraph. The users are:
   1. Start from scratch (servers can retrieve documents from Strands Agent or Langgraph Documents)
   2. Start by working with agent code completely or partially
3. The user asks the agent to convert the code into a format compatible with the AgentCore runtime, with the intention of deploying the agent later. This will make the agent look like this:
   1. Write the appropriate requirements. txt file
   2. Import the required libraries containing bedrock_agentcore
   3. Decorate the main handler (or create), access the core agent and invoke the logic or input handler
4. Users may then ask the agent to deploy to the Agent Core Runtime. Agents can look up documents and deploy agent code to runtime using the Agent Core CLI
5. Users can test the agent by asking the agent to do so. The agent core CLI commands required for this are written and executed by the client
6. The user then changes the code to ask them to use the deployed Agent Core Gateway MCP server within this Agent Core Runtime Agent.
   1. The agent changes the original code and adds an MCP client that can call the deployed gateway
   2. The agent deploys the new version of the agent V2 to the runtime
   3. The agent tests this integration with a new prompt

This is a demo of an MCP server running on the Cursor IDE. You will see the agent perform the following steps:

1. Convert heater_agent.py to be compatible with agent core runtime
2. Deploy the agent using the Agent Core CLI
3. The prompt tests the agent that was deployed successfully

Here is another example of running a cursor IDE that performs the same steps as above to deploy the Rungura Agent at the Agent Core Runtime:

cleaning

If you want to uninstall an MCP server, follow the IDE's MCP documentation and follow the instructions, including Kiro, Cursor, Q CLI, Claude codes.

Conclusion

In this post, I demonstrated how to use the AgentCore MCP server using your favorite agent IDE to speed up your development workflow.

We recommend checking the GitHub repository. We also recommend reading and using the following resources under development:

I recommend trying the AgentCore MCP server and providing feedback via GitHub repository issues.

About the author