
Model context protocol explained for enterprise data teams
NOV. 6, 2026
6 Min Read
The model context protocol gives every AI agent one standard way to reach your tools and data, which makes it the integration layer your data team now has to govern.
Anthropic introduced the model context protocol, usually shortened to MCP, in November 2024 as an open standard for connecting AI models to external systems. Before it, each agent needed custom code for every database, file store and business application it touched. MCP replaces that tangle with one protocol, so a single connector to your warehouse can serve any compliant agent.
Agents are arriving fast, and Gartner predicts that by the end of 2026 40% of enterprise applications will be integrated with task-specific AI agents, up from less than 5% in 2025. Most of those agents will reach enterprise data through MCP. If your data team treats MCP servers as plumbing that someone else installs, access rules you spent years building will be bypassed by the first well-meaning connector.
Key Takeaways
- 1. The model context protocol gives every compliant AI agent one standard way to reach tools and data, so one server can serve every assistant.
- 2. Enterprise risk sits inside each MCP server, in the credentials it holds and the filters it applies, more than in the protocol itself.
- 3. MCP servers should pass the user's identity through and enforce catalog permissions, so access rules travel with the data to every agent.
What the model context protocol does for enterprise AI
The model context protocol defines how an AI application asks an external system for data or actions and how that system answers. It standardizes three things a server can offer, which are tools the model can call, resources it can read and prompts it can reuse. Any MCP-compatible client can then use any MCP server.
Think about a finance analyst using an AI assistant that needs to read the general ledger, check a forecast in a spreadsheet and open a contract in a document store. Without MCP, the assistant's developers write three integrations. With MCP, each system exposes one server, and every assistant in the company can use all three without new code.
The protocol is no longer tied to one company. Anthropic donated MCP to the Agentic AI Foundation under the Linux Foundation in December 2025, which is part of why other model providers and software vendors adopted it so widely.
How MCP works with enterprise data sources
MCP works through a client and server pair. The AI application runs an MCP client, and each data source sits behind an MCP server that describes what it offers. When the model needs data, the client calls the server, the server queries the source with its own credentials and returns the result to the model.
Take an agent asked for open orders above $50,000 in the northeast region. The client sees that the sales data server offers a query tool, sends the request with the user's identity and receives rows back. The model never connects to the database directly. Everything it learns arrives through the server.
That design puts the server in a powerful position. Whatever credentials it holds and whatever filters it applies decide what the agent can see. A server that connects with a service account holding full read access will return rows the user could never open in the reporting tool.
This is where data teams should focus. The protocol itself is simple. The decisions about identity, scope and filtering inside each server are where enterprise risk actually sits.
Why MCP matters for AI agents in production
MCP matters for agents in production because agents act, and every action needs a reliable, inspectable path to a system. A shared protocol lets you monitor, log and secure those paths in one place. Without it, each agent carries its own integration code, and nobody can see the full set of connections running in the company.
"The decisions about identity, scope and filtering inside each server are where enterprise risk actually sits."
A procurement agent that checks supplier records, reads contract terms and drafts a purchase order touches three systems in one task. Through MCP, all three calls pass through servers your platform team can log and rate-limit. Through custom code, they're buried in the agent's application, where a security review would have to read the source to find them.
MCP versus custom API integrations for enterprise teams
The main difference between MCP and custom API integrations is reuse. A custom integration connects one application to one system. An MCP server connects one system to every compliant AI application, so you build and secure the connection once. Custom APIs still make sense for high-volume transactional paths that never involve a model.
Picture a retailer with five AI assistants that each need inventory data. Custom integrations mean five codebases, five sets of credentials and five security reviews. One inventory MCP server means one of each, and a sixth assistant can connect the day it launches.
| Consideration | Custom API integration | MCP server |
|---|---|---|
| Reuse across AI applications | Each application builds and maintains its own connection | Any compliant client can use the same server without new code |
| Discovery | Developers read documentation to learn what the API offers | The server describes its tools so a model can find and call them |
| Security review | Every integration needs its own review of credentials and scope | One server gets reviewed once and inherited by every client |
| Monitoring | Calls are logged inside each application, if at all | Calls pass through a server the platform team can log centrally |
| Best fit | High-volume transactional paths with no model involved | Agent and assistant access to data and business tools |
The pattern in the table is that MCP moves integration cost from each application to the platform team. That trade pays off once two or more AI applications need the same system, so a practical starting point is one MCP server for the most requested data source, with custom APIs kept for transactional paths that never touch a model.
Where MCP fits on a governed data platform
MCP fits on top of a governed data platform, as the access layer agents use to reach data that's already catalogued, classified and permissioned. The platform holds the rules. The MCP server should enforce them by acting as the requesting user, so an agent sees exactly what that person could see in any other tool.
Databricks now brings MCP servers under its governance layer, treating them alongside models, agents and tools. That's the right direction, because context for an agent includes the permissions and definitions that tell it what a table means and who may read it.
As an Anthropic Select Partner, Lumenalta®builds MCP connections on top of governed data platforms with decision traceability and compliance controls embedded in delivery. A server built that way passes the user's identity through, reads row and column policies from the catalog and logs every call next to the data it touched.
Is MCP secure enough for enterprise use today?
MCP is secure enough for enterprise use when you run it like any other production interface, with authentication, scoped permissions, approved servers and logging. The protocol supports these controls. Many public servers skip them, so the risk lies mostly in how servers are built and deployed rather than in the standard.
Independent research shows how often the basics are missing. A July 2026 study of internet-facing MCP servers found 91.8% of the servers it audited lacked OAuth authentication. An enterprise that lets teams install any server they find is inheriting that exposure.
A short control list covers most of the risk.
- Require authentication on every server, tied to your identity provider
- Pass the end user's identity through so permissions match their role
- Allow only approved servers from an internal registry
- Require human approval for tools that write, delete or send data
- Log every tool call with the user, the agent and the data returned
How to roll out MCP servers across data domains
Roll out MCP servers one data domain at a time, starting with read-only access to a governed domain that a live agent use case needs. Prove identity passthrough and logging there, then add write tools, then extend the same server template to the next domain. Each stage reuses the controls the previous one proved.
"MCP doesn't need a new organization."
A logistics company might begin with a read-only server over shipment data for a customer service assistant. Once audit confirms that agents only see shipments for the accounts each user manages, the team adds a tool for rebooking deliveries with human approval. Carrier and warehouse data follow on the same template.
Going domain by domain also keeps the server registry honest. Each new server arrives with an owner, a scope and a review date, instead of appearing quietly on a developer's laptop.
Who should own MCP servers inside a data organization
The team that owns a data domain should own its MCP server, with the platform team owning the shared template, registry and security standards. Domain owners understand what the data means and who should see it. Platform engineers make sure every server authenticates, logs and inherits catalog policies the same way.
At a bank, the payments data team would own the payments server and decide which tools it exposes. The platform team would supply the template that handles authentication and logging, and run the registry that agents check before connecting. Security reviews the template once, rather than reviewing every server from scratch. That split mirrors how most enterprises already run data products. MCP doesn't need a new organization. It needs the existing one to treat agent access as another consumer of governed data.
Why access rules have to travel with the data
Access rules have to travel with the data because agents will reach it through more paths than any team can track by hand. When permissions live in the catalog and every MCP server enforces them, a new agent inherits the right access on day one. When they live in each integration, the gaps multiply with every agent.
The data teams that handle MCP well rarely start with the protocol. They start with governed data, clear domain ownership and a catalog that already knows who can see what. MCP then becomes a thin, well-watched layer on top.
That's how Lumenalta® approaches MCP work, building connections on governed data platforms so access rules move with the data wherever an agent asks for it.
Table of contents
- What the model context protocol does for enterprise AI
- How MCP works with enterprise data sources
- Why MCP matters for AI agents in production
- MCP versus custom API integrations for enterprise teams
- Where MCP fits on a governed data platform
- Is MCP secure enough for enterprise use today?
- How to roll out MCP servers across data domains
- Who should own MCP servers inside a data organization
- Why access rules have to travel with the data
See how a governed MCP layer improves AI accuracy and controls spend.
