MCP for healthcare agents: put the PHI rules in the server
Most healthcare AI agent prototypes I see have the same weak spot. The model is capable. The plumbing is not.
A typical setup wires a model to a pile of hand-built API calls. Each one has its own login method, its own error handling and its own idea of what data it returns. Each one is a place where patient data can leak.
Model Context Protocol, or MCP, is gaining real momentum in enterprise software right now. Identity vendors are shipping MCP servers that give agents least-privilege access. Integration platforms are turning existing workflows into MCP servers any agent can call. MCP is on its way to becoming the standard way agents reach tools, and healthcare should pay attention while the patterns are still forming.
What MCP is and why it helps
MCP is a protocol: a standard contract between an AI agent and outside tools. Instead of each agent building its own connection to your EHR, claims engine or lab system, MCP defines one interface. Here are the tools available. Here’s what each one expects and returns. Here’s how to call it.
It sits between the model and the APIs you already have, and its job is narrow: help the agent find tools and call them. Your API gateway and middleware stay where they are. Any agent that speaks MCP can use your services without custom integration code.
The path looks like this: agent, then MCP client, then MCP server, then your existing FHIR API, Snowflake query, dbt job or clinical workflow.
If you’ve built agents already, you’ve probably built part of this yourself. Every custom tool definition written for a LangChain or CrewAI agent is a private, one-off version of what MCP standardizes.
For data teams, three benefits stand out.
Fewer one-off integrations. A health system AI pilot usually touches several backend systems. Say an agent needs a patient’s labs, formulary status and prior auth requirements. Today that can mean three login methods, three ways of handling errors and three data contracts. MCP puts all of them behind one protocol.
PHI rules you can enforce in code. This is the big one. An MCP server can offer a tool like get_patient_labs that takes a patient ID and returns only the labs the calling context is allowed to see. The PHI boundary lives in the server, not in the prompt. Your data team decides what an agent can touch.
Your analytics become tools. Picture wrapping a dbt model, say mart_readmission_risk, as an MCP tool. An agent can find it, read its schema, call it with parameters and get structured results back. You don’t need custom connectors or a middleware team in the middle.
The PHI risk
MCP servers are meant to be reused across agents. Build once, use anywhere. In healthcare, “anywhere” can mean crossing consent lines, department lines and covered entity lines.
A generic server with a tool like query_patient_data is a compliance problem from day one. Every healthcare MCP server should build in four controls:
- Access based on the agent’s operating context, not only the signed-in user’s session
- Minimum necessary filtering at the tool level, not in the prompt
- Audit logs that record which agent, which user context, which patient and which data elements were returned
- A consent check before any data leaves the server
If those controls aren’t part of the server itself, putting a clean protocol on top doesn’t make it safe.
The setup I’d build
- One MCP server per data domain, such as clinical, claims, operations and genomics. The team that owns the data owns the server, which keeps each server’s scope from creeping.
- FHIR underneath where you can. Your clinical MCP server should be a thin layer over your FHIR API. It shouldn’t be a second path to the data that skips the authorization you already have.
- Snowflake Cortex for analytical tools. Let the server hand analytical work to Cortex functions so the data stays inside Snowflake’s governance. Access History gives you an audit trail with no extra work.
- dbt contracts as tool definitions. A dbt model contract already defines the shape of the data, with column names, types and descriptions. Generate MCP tool definitions from those contracts. The mapping is close to one to one.
- One audit trail. Every tool call should land in your audit tables next to your existing access logs. You want one lineage graph, not two.
I expect MCP to become the default way enterprise agents connect to systems, and soon. Health systems that build PHI-aware servers now, with proper scoping, audit and governance, will be ready when agent workflows move from pilot to production. Those that bolt MCP onto existing APIs without rethinking access will have a hard time explaining who saw what.
I’d also be clear about who owns this. The tool access layer for agents is a data infrastructure problem. It’s about what data goes where, on whose authority, with what record. That’s the data team’s work, more than the AI team’s or the app team’s.
Here’s where I’d start. Before any agent pilot touches patient data, have your data team stand up one MCP server for one domain, with the four controls built in and every call logged to your audit tables. Then point the pilot at that server instead of letting it make direct API calls.
Discussion