From Portal Hopping to Instant Answers: HEMA's Engineering Transformation with MCP and Amazon Bedrock

Modern software engineering teams in large enterprises face a silent productivity killer: context switching across fragmented documentation portals, internal APIs, code repositories, and ticket systems. HEMA, the iconic 100-year-old Dutch retail giant, tackled this exact challenge head-on. By replacing tedious "portal-hopping" with an intelligent AI assistant named HAL, HEMA empowered developers to access governed enterprise knowledge directly inside their daily workflows.

HAL is built on top of Amazon Bedrock AgentCore and leverages Anthropic's open Model Context Protocol (MCP). It ensures enterprise-grade security by anchoring authentication in Microsoft Entra ID and eliminating raw AWS client credentials on user machines. In this deep dive, we explore how HEMA engineered HAL, how MCP redefines internal tool connectivity, and how modern developers can apply these architectural patterns alongside multi-model LLM platforms like n1n.ai to build secure, scalable AI tooling.

The Friction: The "Portal-Hopping" Overhead in Enterprise IT

As enterprise tech stacks grow, internal knowledge becomes heavily siloed. Developers building microservices or configuring retail supply-chain integrations frequently find themselves juggling multiple systems:

1. Confluence and Notion for architecture decision records (ADRs) and business logic.
2. Swagger/OpenAPI UI for API specification lookups.
3. Jira for ticket state and sprint context.
4. Internal Wiki / Developer Portals for deployment pipelines and cloud infrastructure rules.

According to internal developer experience metrics common in legacy retail transformations, engineers spend up to 20% to 30% of their time searching for information rather than writing business logic. Furthermore, answers retrieved from static documentation are frequently outdated or lack contextual security parameters.

HEMA sought to transform this experience from passive documentation retrieval to interactive, context-aware execution.

Architectural Overview: HAL on Bedrock AgentCore with MCP

To bridge developer interfaces (Slack, VS Code, CLI) with back-end enterprise intelligence, HEMA designed HAL. The system's core architecture decouples client interfaces from core backend infrastructure while ensuring strict identity propagation.

+-----------------------------------------------------------------------+
|                           Developer Clients                           |
|               (VS Code Extension / Slack Bot / CLI Tool)               |
+-----------------------------------------------------------------------+
                                   |
                      Bearer Token (Entra ID OIDC)
                                   v
+-----------------------------------------------------------------------+
|                        API Gateway / Guardrails                       |
|               (Token Validation & Rate Limiting Engine)               |
+-----------------------------------------------------------------------+
                                   |
                                   v
+-----------------------------------------------------------------------+
|                   Amazon Bedrock AgentCore Runtime                    |
|  +-----------------------------------------------------------------+  |
|  | Orchestrator Model (e.g., Claude 3.5 Sonnet via Bedrock / n1n)  |  |
|  +-----------------------------------------------------------------+  |
|                                   |                                   |
|                         Model Context Protocol                        |
|                                   v                                   |
|   +-------------------+   +------------------+   +----------------+   |
|   | Internal API Server|   | Confluence Knowledge|   | Jira / GitHub  |   |
|   +-------------------+   +------------------+   +----------------+   |
+-----------------------------------------------------------------------+

Core Pillars of the Solution

1. Zero Client-Side Cloud Credentials: Developers do not possess persistent AWS IAM keys on their laptops. Client tools interact with the backend purely through standard user OAuth 2.0 / OIDC tokens issued by Microsoft Entra ID.
2. Model Context Protocol (MCP): Standardizes how the underlying LLM queries external data schemas, endpoints, and knowledge repositories without hardcoding bespoke integrations for every single system.
3. Amazon Bedrock AgentCore Orchestration: Manages the agent loop, safety guardrails, state management, and tool invocation execution.
4. High-Performance LLM Routing: Securely forwards standardized prompts to frontier models (such as Claude 3.5 Sonnet or DeepSeek-V3) while maintaining tight audit trails. Enterprise aggregators such as n1n.ai provide unified endpoint access and fallback options for development and production environments.

Deep Dive into Model Context Protocol (MCP)

The Model Context Protocol (MCP), introduced by Anthropic, acts as an open standard for connecting AI assistants to data sources and tools. Prior to MCP, connecting an AI model to enterprise endpoints required custom middleware for each data source.

With MCP, data sources expose standardized endpoints containing:

• Resources: Readable data context (e.g., system logs, documentation pages).
• Tools: Executable functions (e.g., trigger deployment pipeline, search API catalog).
• Prompts: Pre-engineered system instruction templates.

Sample Implementation: Building an Enterprise MCP Server in Python

Below is an example of an enterprise MCP server built with Python using FastMCP. This server allows HAL to search internal API endpoints securely.

import os
import requests
from mcp.server.fastmcp import FastMCP

# Initialize FastMCP Server for HEMA API Registry
mcp = FastMCP("HEMA-Internal-API-Catalog")

INTERNAL_CATALOG_URL = os.getenv("INTERNAL_CATALOG_URL