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 steadily. In response to Gartner, agentic AI is without doubt one of the prime expertise developments of 2025, and organizations are performing prototypes on how you can use brokers of their enterprise surroundings. Brokers depend upon instruments, and every software might 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 customary that’s cross-compatible with totally different instruments, and can be utilized by an agentic utility’s giant language mannequin (LLM) to hook up with enterprise APIs or exterior instruments utilizing a normal mechanism. Nonetheless, giant enterprise organizations like monetary providers are inclined to have advanced information governance and working fashions, which makes it difficult to implement brokers working with MCP.

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

On this put up, we current a centralized MCP server implementation utilizing Amazon Bedrock that provides an progressive strategy by offering shared entry to instruments and assets. With this strategy, groups can concentrate on constructing AI capabilities quite than spending time growing 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 quicker. Moreover, a centralized strategy gives consistency and standardization and reduces operational overhead, as a result of the instruments are managed by a devoted group 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 software use throughout the group.

Resolution overview

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

The event of MCP servers is decentralized. Every LoB is answerable for growing the servers that assist their particular features. 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 seems to be like on a conceptual degree.

Agentic utility interplay with a central MCP server hub

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

The move consists of the next steps:

1. The appliance connects to the central MCP hub by way of the load balancer and requests an inventory of obtainable instruments from the particular MCP server. This may be fine-grained based mostly on what servers the agentic utility has entry to.
2. The commerce server responds with listing of instruments obtainable, together with particulars akin to software title, description, and required enter parameters.
3. The agentic utility invokes an Amazon Bedrock agent and gives the listing of instruments obtainable.
4. Utilizing this data, the agent determines what to do subsequent based mostly on the given process and the listing of instruments obtainable to it.
5. The agent chooses probably the most appropriate software and responds with the software title and enter parameters. The management comes again to the agentic utility.
6. The agentic utility requires the execution of the software by way of the MCP server utilizing the software title and enter parameters.
7. The commerce MCP server executes the software and returns the outcomes of the execution again to the appliance.
8. The appliance returns the outcomes of the software execution again to the Amazon Bedrock agent.
9. The agent observes the software 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 break 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 numerous MCP servers. Totally different groups can name this API to search out what MCP servers can be found within the registry; learn their description, software, and useful resource particulars; and determine which MCP server could be the correct 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 house owners are answerable for protecting 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 also can 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 may select your personal container deployment resolution. These servers can scale individually with out impacting the opposite server. These servers in flip connect with a number of instruments utilizing personal VPC endpoints.
• Instruments and assets – This part holds the instruments, akin 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 gives 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 issues. Amazon ECS robotically detects and recovers from failures by restarting failed MCP server duties regionally or reprovisioning containers, minimizing downtime. It may possibly additionally redirect site 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 akin 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 surroundings. This prevents useful resource sharing between duties. For utility authentication and authorization, we suggest utilizing an MCP Auth Server (consult with the next GitHub repo) handy off these duties to a devoted part 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, consult with the next GitHub repo.

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

Use case

The implementation is predicated on a monetary providers 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 includes many steps, together with verifying commerce particulars, precise switch of belongings, 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 trade, you may apply the structure and the strategy to different enterprise workloads as effectively. Your complete code of this implementation is accessible on GitHub. We use the AWS Cloud Improvement Package (AWS CDK) for Python to deploy this resolution, which creates an agentic utility related 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 gadgets
        response = desk.scan()
        gadgets = response.get('Objects', [])
        
        # Format the gadgets to incorporate solely id, description, server
        formatted_items = []
        for merchandise in gadgets:
            formatted_item = {
                'id': merchandise.get('id', ''),
                'description': merchandise.get('description', ''),
                'server': merchandise.get('server', ''),
            }
            formatted_items.append(formatted_item)
        
        # Return the formatted gadgets 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 perform. The whole code is accessible within the GitHub repository. The next graphic exhibits the response of the invention API.

Let’s discover a state of affairs 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.software()
async def executeTrade(ticker, amount, value):
    """
    Execute a commerce for the given ticker, amount, and value.
    
    Pattern enter:
    {
        "ticker": "AMZN",
        "amount": 1000,
        "value": 150.25
    }
    """
    # Simulate commerce execution
    return {
        "tradeId": "T12345",
        "standing": "Executed",
        "timestamp": "2025-04-09T22:58:00"
    }
    
@mcp.software()
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 accessible within the following GitHub repo.

The next graphic exhibits the MCP server execution in motion.

This can be a pattern implementation of the use case specializing in the deployment step. For a manufacturing state of affairs, we strongly advocate including a human oversight workflow to watch the execution and supply enter at numerous steps of the commerce execution.

Now you’re able to deploy this resolution.

Conditions

Conditions 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 search out the directions to deploy the answer. Comply with 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, totally different units of MCP servers are listed within the left pane below MCP Server Registry. Every set corresponds to an MCP server and contains the definition of the instruments, such because the title, description, and enter parameters.

In the correct 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 listing of instruments it has entry to, and iterate by way of a collection of instruments execution and analysis to fulfil the request.You possibly can view the hint output to see the instruments that the agent used. For every software used, you may 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 perform executeTrade with enter parameters of ticker=AMZN, amount=100, and value=186
• After the commerce was executed, used the allocateTrade software to allocate the commerce place between two portfolio accounts

Clear up

You’ll incur expenses whenever you devour the providers used on this resolution. Directions to wash up the assets can be found within the README.md of the GitHub repository.

Abstract

This resolution gives an easy and enterprise-ready strategy 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 supply 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 copy the answer in your personal AWS surroundings.

To study extra about how you can run MCP servers on AWS, consult 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 obtainable options within the cloud. Outdoors of labor, Xan dedicates most of his free time to his household, the place he lovingly takes course 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 giant monetary establishments undertake and scale generative AI and ML workloads. He’s the creator of ebook “Generative AI for monetary providers.” 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.