# Prepare Your Data for AI Now, or You're Screwed Later

Simba Khadder, Featureform | Agents in Production 2025 | 22:04

Source: https://www.youtube.com/watch?v=Ki2c8YkZMWU
Channel: MLOps Community, now AAIF Live (https://www.youtube.com/@AAIFLive-x1r). Summarised by MLOps Talks.
Page: https://mlopstalks.com/talks/prepare-your-data-for-ai-now-or-youre-screwed-later
Published: 2025-08-12
Tags: agents, context-engineering, feature-engineering, feature-stores, mcp

## TL;DR
- Agents need direct access to business data because retrieval from help documents cannot answer questions about specific orders, users, or transactions.
- Converting an enterprise API directly into MCP tools gives agents too many endpoints, parameters, and poorly suited descriptions to reason about.
- EnrichMCP starts with a business data model, connects it to SQL or API logic, and generates a semantic MCP interface that agents can explore and call.

## Summary
Simba Khadder argues that agent quality is limited by data access more often than by model intelligence. A retrieval system can explain common delivery delays, but it cannot answer why one customer's order is late without access to order, restaurant, and delivery data. Khadder says direct API-to-MCP conversions usually fail in enterprise settings because they expose too many endpoints, parameters, and descriptions written for human developers. EnrichMCP takes a data-first approach. Developers define entities such as users, orders, and products, describe their relationships, and connect those definitions to SQL queries or API calls. The framework turns the model into structured MCP tools, including an operation that lets the agent explore the available data model. A live shop example shows Claude following relationships to find a hidden fraudulent transaction. Khadder also connects this work to feature stores: agents must discover the context they need, whereas classical models receive hardcoded features. He is direct about the gap between demos and production systems, and about the noise surrounding MCP.

## Key ideas
### Agents need business data to answer specific questions
[02:41](https://www.youtube.com/watch?v=Ki2c8YkZMWU&t=161s)
Khadder says current language models are often capable enough for the situations they face, but they lack access to the data needed to solve real tasks. He contrasts a DoorDash support bot built with retrieval from help-center documents with one that can inspect order, delivery, and restaurant records. The retrieval-only bot can provide common reasons for delays, while a data-connected agent can investigate a particular order. He describes this work as context engineering or semantic enrichment: finding the relevant data wherever it lives and putting it into the model's context.

### Structured data is valuable for agent decisions
[06:20](https://www.youtube.com/watch?v=Ki2c8YkZMWU&t=380s)
Khadder says unstructured data takes up a lot of space because it includes images and PDFs, while much of the valuable information per byte is structured data in systems such as Postgres and Snowflake. Before MCP, he says there was no broadly agreed standard for giving agents access to that structured information. This matters as agents move beyond summarizing documents and begin making decisions or taking actions that require reasoning across many records.

### Direct API-to-MCP conversion overloads agents
[07:08](https://www.youtube.com/watch?v=Ki2c8YkZMWU&t=428s)
Khadder describes one common approach as converting API specifications directly into MCP tools. He says enterprise APIs usually expose too many endpoints, and each endpoint becomes another tool the agent must understand. The endpoints also contain many parameters designed for developers who can select what they need. An LLM can become overloaded by that surface area. API documentation and OpenAPI specifications are written for people who know the company's systems, so they do not automatically provide descriptions that work well for an agent. Authorization also needs a higher-level design for agent use.

### A semantic data model gives MCP useful structure
[08:30](https://www.youtube.com/watch?v=Ki2c8YkZMWU&t=510s)
Featureform's approach starts with the business data model instead of a pile of endpoints. Khadder's example defines users, orders, products, their attributes, and relationships such as a user having a list of orders. Developers then connect those definitions to serving logic, which can use API calls or SQL queries, and place governance at the data layer. He compares the concept to GraphQL, while saying GraphQL was not built for agents. The point is to explain how the business data fits together before generating the agent interface.

### EnrichMCP generates an explorable agent interface
[11:29](https://www.youtube.com/watch?v=Ki2c8YkZMWU&t=689s)
In the demo, Khadder defines a shop backed by SQLite with users, products, orders, relationships, and resolvers. Running the code produces an MCP server. The framework generates an explore data model operation that describes the available entities and relationships to the model. Resolvers become structured tools with defined parameters, and the model can follow relationships to retrieve more information. Khadder says starting from the data model avoids the repetitive, poorly optimized tool definitions that can result from building each MCP tool by hand.

### The demo agent follows relationships to find fraud
[13:18](https://www.youtube.com/watch?v=Ki2c8YkZMWU&t=798s)
Khadder connects Claude to the shop MCP server and asks it to find fraudulent transactions. Claude first inspects the data model, then works through users, orders, products, and related calls. It follows the semantic graph until it finds a fraudulent transaction that Khadder had hidden in the data. He presents this as evidence that the data-first design lets the agent use the tools without extensive prompt tuning or manually enforced call order.

### The same infrastructure pattern links feature stores and agents
[17:13](https://www.youtube.com/watch?v=Ki2c8YkZMWU&t=1033s)
Khadder compares agent context with features in classical machine learning. Both systems need reliable access to useful data, and he says data access and evaluation have been major categories in MLOps as well as AI platforms. The difference is that classical model features are usually fixed in the model definition, while an agent has to discover which information it needs. He also points to vector databases, ranking, and recommender-system methods as older ideas that teams building language-model systems are encountering again.

### MCP adoption has a large gap between demos and production
[19:38](https://www.youtube.com/watch?v=Ki2c8YkZMWU&t=1178s)
Khadder says MCP is a major step because it provides a standard protocol, but he compares the excitement around it with what might have happened if people had treated REST in the same way. He sees substantial hype, fake or overstated demos, and a meaningful gap between a demo and a system that works in reality. His view is that MCP creates opportunity, while the speed and noise around the technology make it harder to tell which approaches actually work.

## Notable quotes
- "The thing that is limiting them, the actual bottleneck on the problem is their access to data." (03:03)
- "The most important thing is optimizing the descriptions." (07:48)
- "If you start with your data first, the last thing I'll share is that we had a case study done with a large Fortune 500 customer." (13:58)
- "The discovery part is a new part." (18:38)
- "There are a lot of big steps between demo and reality." (21:11)

## Tools & references mentioned
- Featureform
- EnrichMCP
- Model Context Protocol
- MCP
- Jira
- Asana
- Salesforce
- Slack
- Gmail
- Calendar
- DoorDash
- Postgres
- Snowflake
- REST
- OpenAPI
- GraphQL
- SQLite
- Claude
- SQLAlchemy
- Pydantic
- LinkedIn

## Who should watch
- You are building an agent that needs to answer questions about operational records rather than summarize documents.
- Your team is considering turning an existing enterprise API into an MCP server and wants to understand why that can overwhelm a model.
- You work on ML or AI platform infrastructure and want to compare feature-store data access with agent context discovery.

## Related talks

- [Enterprise-ready MCP](https://mlopstalks.com/talks/enterprise-ready-mcp) (Jiquan Ngiam, MintMCP, 28:36)
- [Context Engineering 2.0: MCP, Agentic RAG & Memory](https://mlopstalks.com/talks/context-engineering-2-0-mcp-agentic-rag-memory) (Simba Khadder, Redis, 24:35)
- [MCP is not going to change everything (yet)](https://mlopstalks.com/talks/mcp-is-not-going-to-change-everything-yet) (Sam Partee, Arcade AI & Rahul Parundekar, AI Hero, 1:04:43)
- [AI Agents Are About to Get Real, Here's Why It Matters](https://mlopstalks.com/talks/ai-agents-are-about-to-get-real-heres-why-it-matters) (Sam Partee, Arcade AI, 13:20)
- [How AI is Transforming Business Data Forever](https://mlopstalks.com/talks/how-ai-is-transforming-business-data-forever) (Deepti Srivastava, Snow Leopard AI, 57:14)