Making Your Data Agent-Ready with EnrichMCP // Simba Khadder // Agents in Production 2025
Simba Khadder explains that the primary bottleneck for LLM agents is not intelligence, but access to structured data. He introduces EnrichMCP, an open-source framework that creates a semantic layer over data models, enabling agents to discover, reason about, and query data sources like SQL databases effectively, moving beyond the limitations of RAG and direct API conversions.
The way we interact with applications is fundamentally changing. Instead of manually navigating SaaS products like Jira or Salesforce, we are moving towards a model where agents become the primary interface. The agent interacts with various applications on our behalf, with those apps serving as systems of record. The Machine-Readable Capability Protocol (MCP) is the standard that enables this shift, allowing developers to build API servers that agents can connect to.
While many associate MCP with connecting to external apps like Slack or Gmail, its real killer use case, especially in the enterprise, is providing agents with access to internal, structured data.
The Limitations of Current Data Access Methods
The primary bottleneck for today’s powerful LLMs is not their intelligence, but their limited access to the right data at the right time. Two common approaches to solve this have significant drawbacks:
- Retrieval-Augmented Generation (RAG): RAG is effective for summarizing unstructured documents but fails in scenarios requiring specific, real-time data. For example, if a customer asks, “Why is my DoorDash order taking so long?”, a RAG system trained on help center documents will likely provide a generic answer like, “Here are common reasons for delays.” This creates a poor user experience because the LLM lacks access to the actual order, restaurant, and dasher data needed to give a precise answer.
- Direct API-to-MCP Conversion: A common approach is to take an existing REST API spec and convert its endpoints one-to-one into MCP tools. This method generally fails for several reasons:
- Tool Overload: Enterprise APIs often have hundreds of endpoints, which overwhelms the agent with too many tools to reason about.
- Parameter Complexity: API endpoints are designed for human developers and often have numerous parameters. An LLM can get inundated trying to understand and select from all the options.
- Poor Descriptions: API documentation is written for humans who can ask for clarification, not for LLMs that require precise, machine-readable descriptions to function effectively.
- Authorization Mismatch: Authorization models built for standard APIs often don’t map cleanly to the needs of an agent.
A Data-First Solution: EnrichMCP
To solve these challenges, the open-source framework EnrichMCP was created. It approaches the problem from the data up, rather than from the API down. The core idea is to build a semantic layer that explains your business’s data model to the agent.
If you were to rebuild GraphQL for agents, you’d end up with EnrichMCP.
The process involves:
- Defining the Data Model: You start by defining your core business entities (e.g.,
User,Order,Product), their attributes, and the relationships between them (e.g., aUserhas a list ofOrders). - Creating Resolvers: You tie this semantic model to data-serving logic, such as SQL queries or API calls, using resolvers that define how to fetch specific data.
- Applying Governance: Security and access controls are added directly at the data layer.
This structured, data-first approach generates a highly optimized MCP server. The framework automatically creates a special tool called explore_data_model, which allows the agent to first understand the entire data landscape—what entities exist, what their attributes are, and how they connect. This enables the agent to intelligently navigate the semantic graph, find the information it needs, and solve complex problems, as demonstrated by an agent successfully identifying a fraudulent transaction by traversing user, order, and product data.
Parallels with MLOps
This evolution mirrors challenges solved in the traditional MLOps space. The hardest problems for LLM builders today are data access and evaluation, just as they were for ML platforms. The core difference between a feature for a classical ML model and context for an LLM is that the agent must discover the relevant features (context) on its own, whereas they are typically hardcoded for a classical model. EnrichMCP provides the framework for this critical discovery step.