Harness the ability of MCP servers with Amazon Bedrock Brokers

AI brokers prolong giant language fashions (LLMs) by interacting with exterior techniques, executing complicated workflows, and sustaining contextual consciousness throughout operations. Amazon Bedrock Brokers allows this performance by orchestrating basis fashions (FMs) with knowledge sources, functions, and consumer inputs to finish goal-oriented duties by way of API integration and information base augmentation. Nevertheless, up to now, connecting these brokers to numerous enterprise techniques has created growth bottlenecks, with every integration requiring {custom} code and ongoing upkeep—a standardization problem that slows the supply of contextual AI help throughout a company’s digital ecosystem. This can be a drawback which you could remedy by utilizing Mannequin Context Protocol (MCP), which offers a standardized approach for LLMs to hook up with knowledge sources and instruments.

Right now, MCP is offering brokers normal entry to an increasing listing of accessible instruments that you should use to perform quite a lot of duties. In time, MCP can promote higher discoverability of brokers and instruments by way of marketplaces, enabling brokers to share context and have widespread workspaces for higher interplay, and scale agent interoperability throughout the business.

On this publish, we present you easy methods to construct an Amazon Bedrock agent that makes use of MCP to entry knowledge sources to shortly construct generative AI functions. Utilizing Amazon Bedrock Brokers, your agent may be assembled on the fly with MCP-based instruments as on this instance:

InlineAgent(
    foundation_model="us.anthropic.claude-3-5-sonnet-20241022-v2:0",
    instruction="You're a pleasant assistant for resolving consumer queries",
    agent_name="SampleAgent",
    action_groups=[
        ActionGroup(
            name="SampleActionGroup",
            mcp_clients=[mcp_client_1, mcp_client_2],
        )
    ],
).invoke(input_text=”Convert 11am from NYC time to London time”)

We showcase an instance of constructing an agent to grasp your Amazon Net Service (AWS) spend by connecting to AWS Price Explorer, Amazon CloudWatch, and Perplexity AI by way of MCP. You need to use the code referenced on this publish to attach your brokers to different MCP servers to handle challenges for what you are promoting. We envision a world the place brokers have entry to an ever-growing listing of MCP servers that they will use for undertaking all kinds of duties.

Mannequin Context Protocol

Developed by Anthropic as an open protocol, MCP offers a standardized strategy to join AI fashions to just about any knowledge supply or device. Utilizing a client-server structure, MCP allows builders to reveal their knowledge by way of light-weight MCP servers whereas constructing AI functions as MCP shoppers that join to those servers. Via this structure, MCP allows customers to construct extra highly effective, context-aware AI brokers that may seamlessly entry the data and instruments they want. Whether or not you’re connecting to exterior techniques or inside knowledge shops or instruments, now you can use MCP to interface with all of them in the identical approach. The client-server structure of MCP allows your agent to entry new capabilities because the MCP server updates with out requiring any adjustments to the applying code.

MCP structure

MCP makes use of a client-server structure that accommodates the next elements and is proven within the following determine:

• Host: An MCP host is a program or AI device that requires entry to knowledge by way of the MCP protocol, reminiscent of Claude Desktop, an built-in growth atmosphere (IDE), or some other AI utility.
• Consumer: Protocol shoppers that keep one-to-one connections with servers.
• Server: Light-weight packages that expose capabilities by way of standardized MCP.
• Native knowledge sources: Your databases, native knowledge sources, and companies that MCP servers can securely entry.
• Distant companies: Exterior techniques out there over the web by way of APIs that MCP servers can hook up with.

Let’s stroll by way of easy methods to arrange Amazon Bedrock brokers that benefit from MCP servers.

Utilizing MCP with Amazon Bedrock brokers

On this publish, we offer a step-by-step information for easy methods to join your favourite MCP servers with Amazon Bedrock brokers as Motion Teams that an agent can use to perform duties offered by the consumer. The AgentInlineSDK offers an easy strategy to create inline brokers, containing a built-in MCP consumer implementation that gives you with direct entry to instruments delivered by an MCP server.

As a part of creating an agent, the developer creates an MCP consumer particular to every MCP server that requires agent communication. When invoked, the agent determines which instruments are wanted for the consumer’s job; if MCP server instruments are required, it makes use of the corresponding MCP consumer to request device execution from that server. The consumer code doesn’t want to concentrate on the MCP protocol as a result of that’s dealt with by the MCP consumer offered the InlineAgent code repository.

To orchestrate this workflow, you benefit from the return management functionality of Amazon Bedrock Brokers. The next diagram illustrates the end-to-end move of an agent dealing with a request that makes use of two instruments. Within the first move, a Lambda-based motion is taken, and within the second, the agent makes use of an MCP server.

Use case: remodel the way you handle your AWS spend throughout completely different AWS companies together with Amazon Bedrock

To indicate how an Amazon Bedrock agent can use MCP servers, let’s stroll by way of a pattern use case. Think about asking questions like “Assist me perceive my Bedrock spend over the previous few weeks” or “What had been my EC2 prices final month throughout areas and occasion varieties?” and getting a human-readable evaluation of the info as a substitute of uncooked numbers on a dashboard. The system interprets your intent and delivers exactly what you want—whether or not that’s detailed breakdowns, development analyses, visualizations, or cost-saving suggestions. That is helpful as a result of what you’re excited about is insights moderately than knowledge. You may accomplish this utilizing two MCP servers: a custom-built MCP server for retrieving the AWS spend knowledge and an open supply MCP server from Perplexity AI to interpret the info. You add these two MCP servers as motion teams in an inline Amazon Bedrock agent. This provides you an AI agent that may remodel the way in which you handle your AWS spend. All of the code for this publish is on the market within the GitHub repository.

Let’s stroll by way of how this agent is created utilizing inline brokers. You need to use inline brokers to outline and configure Amazon Bedrock brokers dynamically at runtime. They supply higher flexibility and management over agent capabilities, enabling customers to specify FMs, directions, motion teams, guardrails, and information bases as wanted with out counting on pre-configured management aircraft settings. It’s price noting which you could additionally orchestrate this habits with out inline brokers by utilizing RETURN_CONTROL with the InvokeAgent API.

MCP elements in Amazon Bedrock Brokers

1. Host: That is the Amazon Bedrock inline agent. This agent provides MCP shoppers as motion teams that may be invoked by way of RETURN_CONTROL when the consumer asks an AWS spend-related query.
2. Consumer: You create two shoppers that set up one-to-one connections with their respective servers: a value explorer consumer with particular price server parameters and a Perplexity AI consumer with Perplexity server parameters.
3. Servers: You create two MCP servers that every run domestically in your machine and talk to your utility over normal enter/output (alternatively, you would additionally configure the consumer to speak to distant MCP servers).
   1. Price Explorer and Amazon CloudWatch Logs (for Amazon Bedrock mannequin invocation log knowledge) and an MCP server to retrieve the AWS spend knowledge.
   2. Perplexity AI MCP server to interpret the AWS spend knowledge.
4. Knowledge sources: The MCP servers speak to distant knowledge sources reminiscent of Price Explorer API, CloudWatch Logs and the Perplexity AI search API.

Stipulations

You want the next stipulations to get began implementing the answer on this publish:

1. An AWS account
2. Familiarity with FMs and Amazon Bedrock
3. Set up AWS Command Line Interface (AWS CLI) and arrange credentials
4. Python 3.11 or later
5. AWS Cloud Growth Package (AWS CDK) CLI
6. Allow mannequin entry for Anthropic’s Claude 3.5 Sonnet v2
7. You want to have your AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY in an effort to set them utilizing atmosphere variables for the server
8. The 2 MCP servers are run as Docker daemons, so you could have Docker put in and operating in your pc

The MCP servers run domestically in your pc and must entry AWS companies and the Perplexity API. You may learn extra about AWS credentials in Handle entry keys for IAM customers. Guarantee that your credentials embrace AWS Identification and Entry Supervisor (IAM) learn entry to Price Explorer and CloudWatch. You are able to do this by utilizing AWSBillingReadOnlyAccess and CloudWatchReadOnlyAccess managed IAM permissions. You may get the Perplexity API key from the Perplexity Sonar API web page.

Steps to run

With the stipulations in place, you’re able to implement the answer.

1. Navigate to the InlineAgent GitHub repository.
2. Observe the setup steps.
3. Navigate to the cost_explorer_agent This folder accommodates the code for this publish.

   cd examples/mcp/cost_explorer_agent

4. Create a .env file in cost_explorer_agent listing utilizing instance.

   AWS_ACCESS_KEY_ID=
   AWS_SECRET_ACCESS_KEY=
   AWS_REGION=
   BEDROCK_LOG_GROUP_NAME=
   PERPLEXITY_API_KEY=

5. Construct aws-cost-explorer-mcp server

   git clone https://github.com/aarora79/aws-cost-explorer-mcp-server.git
   cd aws-cost-explorer-mcp-server/
   docker construct -t aws-cost-explorer-mcp

6. You’re now able to create an agent that may invoke these MCP servers to offer insights into your AWS spend. You are able to do this by operating the python essential.py command. The output will seem like the next instance. The agent connects with the 2 MCP servers and accesses their respective instruments. Subsequent, the agent lays out a plan to make use of particular instruments sequentially, makes use of code interpreter to generate a chart displaying price distribution, and makes use of Price Explorer and Perplexity API to offer details about Amazon Bedrock and the AWS account’s price expenditure.

   Linked to server with instruments: ['get_bedrock_daily_usage_stats', 'get_bedrock_hourly_usage_stats', 'get_ec2_spend_last_day', 'get_detailed_breakdown_by_day']
   Linked to server with instruments: ['perplexity_ask']
   
   Thought: Let me break this down into elements:
   1. First, I am going to ask about Amazon Bedrock utilizing Perplexity
   2. Then I am going to get the fee breakdown for the final 7 days
   3. Lastly, I am going to create a visualization of the spending knowledge
   
   Instrument use: perplexity_ask with these inputs: messages[[{role=user, content=What is Amazon Bedrock? Provide a concise explanation.}] (array)]
   
   Instrument use: get_detailed_breakdown_by_day with these inputs: days[7 (integer)]
   
   Thought: Let me analyze the info and create a visualization of the highest companies by price. I am going to use Python to course of the info and create a bar chart.
   
   Code interpreter:
   Generated code
   ```
   import pandas as pd
   import matplotlib.pyplot as plt
   ...
   ```
   
   Code interpreter output:
   aws_costs.png (picture/png)
   Listing output created efficiently
   
   Thought: Now I can present a complete reply about Amazon Bedrock and the fee evaluation. Amazon Bedrock is a completely managed service that gives entry to basis fashions (FMs) from main AI firms by way of a single API. Primarily based on the fee evaluation of the final 7 days, your high spending companies had been:
   
   1. Amazon Neptune: $24
   2. Amazon SageMaker: $567
   3. EC2 (Compute + Different): $454
   4. Amazon OpenSearch Service: $34
   5. Amazon Bedrock: $1235
   6. Amazon Q: $178

Implementation particulars

Now that you just perceive the output produced by an agent, let’s raise the curtain and overview a number of the vital items of code that produce the output.

1. Creating MCP shoppers: config.py, defines the 2 MCP shoppers that speak to your two MCP servers.
   1. Server parameters are outlined for the fee explorer and Perplexity shoppers. The answer makes use of StdioServerParameters, which configures how the consumer ought to talk over normal enter/output (stdio) streams. This accommodates the parameters required by the server to entry the required knowledge by way of APIs.

      # Price server parameters
      cost_server_params = StdioServerParameters(
          command="/usr/native/bin/docker",
          args=[
              "run",
              "-i",
              "--rm",
              "-e",
              "AWS_ACCESS_KEY_ID",
              "-e",
              "AWS_SECRET_ACCESS_KEY",
              "-e",
              "AWS_REGION",
              "-e",
              "BEDROCK_LOG_GROUP_NAME",
              "-e",
              "stdio",
              "aws-cost-explorer-mcp:latest",
          ],
          env={
              "AWS_ACCESS_KEY_ID": AWS_ACCESS_KEY_ID,
              "AWS_SECRET_ACCESS_KEY": AWS_SECRET_ACCESS_KEY,
              "AWS_REGION": AWS_REGION,
              "BEDROCK_LOG_GROUP_NAME": BEDROCK_LOG_GROUP_NAME,
          },
      )
      
      # Perplexity server parameters
      perplexity_server_params = StdioServerParameters(
          command="/usr/native/bin/docker",
          args=["run", "-i", "--rm", "-e", "PERPLEXITY_API_KEY", "mcp/perplexity-ask"],
          env={"PERPLEXITY_API_KEY": PERPLEXITY_API_KEY},
      )

   2. In essential.py, the MCP server parameters are imported and used to create your two MCP shoppers.

      cost_explorer_mcp_client = await MCPClient.create(server_params=cost_server_params)
      perplexity_mcp_client = await MCPClient.create(server_params=perplexity_server_params)

2. Configure agent motion group: essential.py creates the motion group that mixes the MCP shoppers right into a single interface that the agent can entry. This allows the agent to ask your utility to invoke both of those MCP servers as wanted by way of return of management.

   # Create motion group with each MCP shoppers
   cost_action_group = ActionGroup(
       title="CostActionGroup",
       mcp_clients=[cost_explorer_mcp_client, perplexity_mcp_client]
   )

3. Inline agent creation: The inline agent may be created with the next specs:
   1. Basis mannequin: Configure your selection of FM to energy your agent. This may be any mannequin offered on Amazon Bedrock. This instance makes use of Anthropic’s Claude 3.5 Sonnet mannequin.
   2. Agent instruction: Present directions to your agent that comprise the steering and steps for orchestrating responses to consumer queries. These directions anchor the agent’s strategy to dealing with varied kinds of queries
   3. Agent title: Identify of your agent.
   4. Motion teams: Outline the motion teams that your agent can entry. These can embrace single or a number of motion teams, with every group accessing a number of MCP shoppers or AWS Lambda As an possibility, you may configure your agent to make use of Code Interpreter to generate, run, and take a look at code on your utility.

# Create and invoke the inline agent
await InlineAgent(
    foundation_model="us.anthropic.claude-3-5-sonnet-20241022-v2:0",
    instruction="""You're a pleasant assistant that's liable for resolving consumer queries.
    
    You will have entry to look, price device and code interpreter. 
    
    """,
    agent_name="cost_agent",
    action_groups=[
        cost_action_group,
        {
            "name": "CodeInterpreter",
            "builtin_tools": {
                "parentActionGroupSignature": "AMAZON.CodeInterpreter"
            },
        },
    ],
).invoke(
    input_text=""
)

You need to use this instance to construct an inline agent on Amazon Bedrock that establishes connections with completely different MCP servers and teams their shoppers right into a single motion group for the agent to entry.

Conclusion

The Anthropic MCP protocol presents a standardized approach of connecting FMs to knowledge sources, and now you should use this functionality with Amazon Bedrock Brokers. On this publish, you noticed an instance of mixing the ability of Amazon Bedrock and MCP to construct an utility that provides a brand new perspective on understanding and managing your AWS spend.

Organizations can now supply their groups pure, conversational entry to complicated monetary knowledge whereas enhancing responses with contextual intelligence from sources like Perplexity. As AI continues to evolve, the power to securely join fashions to your group’s vital techniques will change into more and more priceless. Whether or not you’re trying to remodel customer support, streamline operations, or achieve deeper enterprise insights, the Amazon Bedrock and MCP integration offers a versatile basis on your subsequent AI innovation. You may dive deeper on this MCP integration by exploring our code samples.

Listed below are some examples of what you may construct by connecting your Amazon Bedrock Brokers to MCP servers:

• A multi-data supply agent that retrieves knowledge from completely different knowledge sources reminiscent of Amazon Bedrock Information Bases, Sqlite, and even your native filesystem.
• A developer productiveness assistant agent that integrates with Slack and GitHub MCP servers.
• A machine studying experiment monitoring agent that integrates with the Opik MCP server from Comet ML for managing, visualizing, and monitoring machine studying experiments immediately inside growth environments.

What enterprise challenges will you deal with with these highly effective new capabilities?

Concerning the authors

Mark Roy is a Principal Machine Studying Architect for AWS, serving to prospects design and construct generative AI options. His focus since early 2023 has been main answer structure efforts for the launch of Amazon Bedrock, the flagship generative AI providing from AWS for builders. Mark’s work covers a variety of use instances, with a main curiosity in generative AI, brokers, and scaling ML throughout the enterprise. He has helped firms in insurance coverage, monetary companies, media and leisure, healthcare, utilities, and manufacturing. Previous to becoming a member of AWS, Mark was an architect, developer, and expertise chief for over 25 years, together with 19 years in monetary companies. Mark holds six AWS certifications, together with the ML Specialty Certification.

Eashan Kaushik is a Specialist Options Architect AI/ML at Amazon Net Companies. He’s pushed by creating cutting-edge generative AI options whereas prioritizing a customer-centric strategy to his work. Earlier than this function, he obtained an MS in Laptop Science from NYU Tandon College of Engineering. Exterior of labor, he enjoys sports activities, lifting, and operating marathons.

Madhur Prashant is an AI and ML Options Architect at Amazon Net Companies. He’s passionate in regards to the intersection of human considering and generative AI. His pursuits lie in generative AI, particularly constructing options which are useful and innocent, and most of all optimum for patrons. Exterior of labor, he loves doing yoga, mountaineering, spending time together with his twin, and enjoying the guitar.

Amit Arora is an AI and ML Specialist Architect at Amazon Net Companies, serving to enterprise prospects use cloud-based machine studying companies to quickly scale their improvements. He’s additionally an adjunct lecturer within the MS knowledge science and analytics program at Georgetown College in Washington, D.C.

Andy Palmer is a Director of Know-how for AWS Strategic Accounts. His groups present Specialist Options Structure expertise throughout plenty of speciality area areas, together with AIML, generative AI, knowledge and analytics, safety, community, and open supply software program. Andy and his crew have been on the forefront of guiding our most superior prospects by way of their generative AI journeys and serving to to search out methods to use these new instruments to each present drawback areas and web new improvements and product experiences.