Accelerating AI innovation: Scale MCP servers for enterprise workloads with Amazon Bedrock

Generative AI has been shifting at a speedy tempo, with new instruments, choices, and fashions launched often. Based on Gartner, agentic AI is without doubt one of the prime expertise traits of 2025, and organizations are performing prototypes on methods to use brokers of their enterprise setting. Brokers depend upon instruments, and every device may need its personal mechanism to ship and obtain data. Mannequin Context Protocol (MCP) by Anthropic is an open supply protocol that makes an attempt to resolve this problem. It gives a protocol and communication normal that’s cross-compatible with completely different instruments, and can be utilized by an agentic utility’s massive language mannequin (LLM) to connect with enterprise APIs or exterior instruments utilizing a normal mechanism. Nonetheless, massive enterprise organizations like monetary companies are inclined to have advanced knowledge governance and working fashions, which makes it difficult to implement brokers working with MCP.

One main problem is the siloed method by which particular person groups construct their very own instruments, resulting in duplication of efforts and wasted assets. This method slows down innovation and creates inconsistencies in integrations and enterprise design. Moreover, managing a number of disconnected MCP instruments throughout groups makes it troublesome to scale AI initiatives successfully. These inefficiencies hinder enterprises from absolutely making the most of generative AI for duties like post-trade processing, customer support automation, and regulatory compliance.

On this submit, we current a centralized MCP server implementation utilizing Amazon Bedrock that gives an modern method by offering shared entry to instruments and assets. With this method, groups can concentrate on constructing AI capabilities quite than spending time creating or sustaining instruments. By standardizing entry to assets and instruments by way of MCP, organizations can speed up the event of AI brokers, so groups can attain manufacturing sooner. Moreover, a centralized method gives consistency and standardization and reduces operational overhead, as a result of the instruments are managed by a devoted workforce quite than throughout particular person groups. It additionally permits centralized governance that enforces managed entry to MCP servers, which reduces the danger of knowledge exfiltration and prevents unauthorized or insecure device use throughout the group.

Answer overview

The next determine illustrates a proposed resolution primarily based on a monetary companies use case that makes use of MCP servers throughout a number of traces of enterprise (LoBs), equivalent to compliance, buying and selling, operations, and threat administration. Every LoB performs distinct capabilities tailor-made to their particular enterprise. As an example, the buying and selling LoB focuses on commerce execution, whereas the danger LoB performs threat restrict checks. For performing these capabilities, every division gives a set of MCP servers that facilitate actions and entry to related knowledge inside their LoBs. These servers are accessible to brokers developed throughout the respective LoBs and may also be uncovered to brokers exterior LoBs.

The event of MCP servers is decentralized. Every LoB is liable for creating the servers that help their particular capabilities. When the event of a server is full, it’s hosted centrally and accessible throughout LoBs. It takes the type of a registry or market that facilitates integration of AI-driven options throughout divisions whereas sustaining management and governance over shared assets.

Within the following sections, we discover what the answer appears like on a conceptual degree.

Agentic utility interplay with a central MCP server hub

The next movement diagram showcases how an agentic utility constructed utilizing Amazon Bedrock interacts with one of many MCP servers positioned within the MCP server hub.

The movement consists of the next steps:

1. The appliance connects to the central MCP hub by way of the load balancer and requests a listing of obtainable instruments from the particular MCP server. This may be fine-grained primarily based on what servers the agentic utility has entry to.
2. The commerce server responds with record of instruments accessible, together with particulars equivalent to device identify, description, and required enter parameters.
3. The agentic utility invokes an Amazon Bedrock agent and gives the record of instruments accessible.
4. Utilizing this data, the agent determines what to do subsequent primarily based on the given process and the record of instruments accessible to it.
5. The agent chooses essentially the most appropriate device and responds with the device identify and enter parameters. The management comes again to the agentic utility.
6. The agentic utility requires the execution of the device by way of the MCP server utilizing the device identify and enter parameters.
7. The commerce MCP server executes the device and returns the outcomes of the execution again to the appliance.
8. The appliance returns the outcomes of the device execution again to the Amazon Bedrock agent.
9. The agent observes the device execution outcomes and determines the following step.

Let’s dive into the technical structure of the answer.

Structure overview

The next diagram illustrates the structure to host the centralized cluster of MCP servers for an LoB.

The structure may be cut up in 5 sections:

• MCP server discovery API
• Agentic purposes
• Central MCP server hub
• Instruments and assets

Let’s discover every part intimately:

• MCP server discovery API – This API is a devoted endpoint for locating varied MCP servers. Totally different groups can name this API to seek out what MCP servers can be found within the registry; learn their description, device, and useful resource particulars; and resolve which MCP server can be the suitable one for his or her agentic utility. When a brand new MCP server is revealed, it’s added to an Amazon DynamoDB database. MCP server homeowners are liable for preserving the registry data up-to-date.
• Agentic utility – The agentic purposes are hosted on AWS Fargate for Amazon Elastic Container Service (Amazon ECS) and constructed utilizing Amazon Bedrock Brokers. Groups may also use the newly launched open supply AWS Strands Brokers SDK, or different agentic frameworks of alternative, to construct the agentic utility and their very own containerized resolution to host the agentic utility. The agentic purposes entry Amazon Bedrock by way of a safe personal digital personal cloud (VPC) endpoint. It makes use of personal VPC endpoints to entry MCP servers.
• Central MCP server hub – That is the place the MCP servers are hosted. Entry to servers is enabled by way of an AWS Community Load Balancer. Technically, every server is a Docker container that may is hosted on Amazon ECS, however you possibly can select your personal container deployment resolution. These servers can scale individually with out impacting the opposite server. These servers in flip hook up with a number of instruments utilizing personal VPC endpoints.
• Instruments and assets – This element holds the instruments, equivalent to databases, one other utility, Amazon Easy Storage Service (Amazon S3), or different instruments. For enterprises, entry to the instruments and assets is supplied solely by way of personal VPC endpoints.

Advantages of the answer

The answer presents the next key advantages:

• Scalability and resilience – Since you’re utilizing Amazon ECS on Fargate, you get scalability out of the field with out managing infrastructure and dealing with scaling considerations. Amazon ECS routinely detects and recovers from failures by restarting failed MCP server duties domestically or reprovisioning containers, minimizing downtime. It could possibly additionally redirect visitors away from unhealthy Availability Zones and rebalance duties throughout wholesome Availability Zones to offer uninterrupted entry to the server.
• Safety – Entry to MCP servers is secured on the community degree by way of community controls equivalent to PrivateLink. This makes positive the agentic utility solely connects to trusted MCP servers hosted by the group, and vice versa. Every Fargate workload runs in an remoted setting. This prevents useful resource sharing between duties. For utility authentication and authorization, we suggest utilizing an MCP Auth Server (discuss with the next GitHub repo) handy off these duties to a devoted element that may scale independently.

On the time of writing, the MCP protocol doesn’t present built-in mechanisms for user-level entry management or authorization. Organizations requiring user-specific entry restrictions should implement further safety layers on prime of the MCP protocol. For a reference implementation, discuss with the next GitHub repo.

Let’s dive deeper within the implementation of this resolution.

Use case

The implementation is predicated on a monetary companies use case that includes post-trade execution. Put up-trade execution refers back to the processes and steps that happen after an fairness purchase/promote order has been positioned by a buyer. It entails many steps, together with verifying commerce particulars, precise switch of property, offering an in depth report of the execution, working fraudulent checks, and extra. For simplification of the demo, we concentrate on the order execution step.

Though this use case is tailor-made to the monetary business, you possibly can apply the structure and the method to different enterprise workloads as properly. Your entire code of this implementation is obtainable on GitHub. We use the AWS Cloud Growth Package (AWS CDK) for Python to deploy this resolution, which creates an agentic utility linked to instruments by way of the MCP server. It additionally creates a Streamlit UI to work together with the agentic utility.

The next code snippet gives entry to the MCP discovery API:

def get_server_registry():
    # Initialize DynamoDB consumer
    dynamodb = boto3.useful resource('dynamodb')
    desk = dynamodb.Desk(DDBTBL_MCP_SERVER_REGISTRY)
    
    attempt:
        # Scan the desk to get all objects
        response = desk.scan()
        objects = response.get('Objects', [])
        
        # Format the objects to incorporate solely id, description, server
        formatted_items = []
        for merchandise in objects:
            formatted_item = {
                'id': merchandise.get('id', ''),
                'description': merchandise.get('description', ''),
                'server': merchandise.get('server', ''),
            }
            formatted_items.append(formatted_item)
        
        # Return the formatted objects as JSON
        return {
            'statusCode': 200,
            'headers': cors_headers,
            'physique': json.dumps(formatted_items)
        }
    besides Exception as e:
        # Deal with any errors
        return {
            'statusCode': 500,
            'headers': cors_headers,
            'physique': json.dumps({'error': str(e)})
        }

The previous code is invoked by way of an AWS Lambda operate. The whole code is obtainable within the GitHub repository. The next graphic reveals the response of the invention API.

Let’s discover a situation the place the person submits a query: “Purchase 100 shares of AMZN at USD 186, to be distributed equally between accounts A31 and B12.”To execute this process, the agentic utility invokes the trade-execution MCP server. The next code is the pattern implementation of the MCP server for commerce execution:

from fastmcp import FastMCP
from starlette.requests import Request
from starlette.responses import PlainTextResponse
mcp = FastMCP("server")

@mcp.custom_route("/", strategies=["GET"])
async def health_check(request: Request) -> PlainTextResponse:
    return PlainTextResponse("OK")

@mcp.device()
async def executeTrade(ticker, amount, worth):
    """
    Execute a commerce for the given ticker, amount, and worth.
    
    Pattern enter:
    {
        "ticker": "AMZN",
        "amount": 1000,
        "worth": 150.25
    }
    """
    # Simulate commerce execution
    return {
        "tradeId": "T12345",
        "standing": "Executed",
        "timestamp": "2025-04-09T22:58:00"
    }
    
@mcp.device()
async def sendTradeDetails(tradeId):
    """
    Ship commerce particulars for the given tradeId.
    Pattern enter:
    {
        "tradeId": "T12345"
    }
    """
    return {
        "standing": "Particulars Despatched",
        "recipientSystem": "MiddleOffice",
        "timestamp": "2025-04-09T22:59:00"
    }
if __name__ == "__main__":
    mcp.run(host="0.0.0.0", transport="streamable-http")

The whole code is obtainable within the following GitHub repo.

The next graphic reveals the MCP server execution in motion.

It is a pattern implementation of the use case specializing in the deployment step. For a manufacturing situation, we strongly advocate including a human oversight workflow to watch the execution and supply enter at varied steps of the commerce execution.

Now you’re able to deploy this resolution.

Stipulations

Stipulations for the answer can be found within the README.md of the GitHub repository.

Deploy the appliance

Full the next steps to run this resolution:

1. Navigate to the README.md file of the GitHub repository to seek out the directions to deploy the answer. Observe these steps to finish deployment.

The profitable deployment will exit with a message just like the one proven within the following screenshot.

2. When the deployment is full, entry the Streamlit utility.

Yow will discover the Streamlit URL within the terminal output, just like the next screenshot.

3. Enter the URL of the Streamlit utility in a browser to open the appliance console.

On the appliance console, completely different units of MCP servers are listed within the left pane underneath MCP Server Registry. Every set corresponds to an MCP server and consists of the definition of the instruments, such because the identify, description, and enter parameters.

In the suitable pane, Agentic App, a request is pre-populated: “Purchase 100 shares of AMZN at USD 186, to be distributed equally between accounts A31 and B12.” This request is able to be submitted to the agent for execution.

4. Select Submit to invoke an Amazon Bedrock agent to course of the request.

The agentic utility will consider the request along with the record of instruments it has entry to, and iterate by way of a sequence of instruments execution and analysis to fulfil the request.You’ll be able to view the hint output to see the instruments that the agent used. For every device used, you possibly can see the values of the enter parameters, adopted by the corresponding outcomes. On this case, the agent operated as follows:

• The agent first used the operate executeTrade with enter parameters of ticker=AMZN, amount=100, and worth=186
• After the commerce was executed, used the allocateTrade device to allocate the commerce place between two portfolio accounts

Clear up

You’ll incur expenses once you eat the companies used on this resolution. Directions to scrub up the assets can be found within the README.md of the GitHub repository.

Abstract

This resolution presents an easy and enterprise-ready method to implement MCP servers on AWS. With this centralized working mannequin, groups can concentrate on constructing their purposes quite than sustaining the MCP servers. As enterprises proceed to embrace agentic workflows, centralized MCP servers provide a sensible resolution for overcoming operational silos and inefficiencies. With the AWS scalable infrastructure and superior instruments like Amazon Bedrock Brokers and Amazon ECS, enterprises can speed up their journey towards smarter workflows and higher buyer outcomes.

Try the GitHub repository to duplicate the answer in your personal AWS setting.

To be taught extra about methods to run MCP servers on AWS, discuss with the next assets:

In regards to the authors

Xan Huang is a Senior Options Architect with AWS and is predicated in Singapore. He works with main monetary establishments to design and construct safe, scalable, and extremely accessible options within the cloud. Exterior of labor, Xan dedicates most of his free time to his household, the place he lovingly takes path from his two younger daughters, aged one and 4. Yow will discover Xan on LinkedIn: https://www.linkedin.com/in/xanhuang/

Vikesh Pandey is a Principal GenAI/ML Specialist Options Architect at AWS serving to massive monetary establishments undertake and scale generative AI and ML workloads. He’s the creator of e book “Generative AI for monetary companies.” He carries greater than decade of expertise constructing enterprise-grade purposes on generative AI/ML and associated applied sciences. In his spare time, he performs an unnamed sport along with his son that lies someplace between soccer and rugby.