Model Context Protocol (MCP)

In one line

MCP standardises how an AI application discovers and calls external capabilities — so any compliant assistant can use any compliant tool server without custom integration code on either side.

The problem it solves

Before MCP, every AI app integrated every tool bespoke — an M×N problem: M assistants times N tools, each pairing hand-built. The result was brittle, duplicated glue code and no portability. MCP makes it M+N: a tool implements the protocol once (an MCP server) and every compliant assistant can use it; an assistant speaks the protocol once (an MCP client) and reaches every server. The USB-C analogy is apt — one connector, many devices.

The three things a server exposes

• Tools — functions the model may call, with JSON-schema parameters (e.g. searchKosha(query)). This is the agent tool-use surface.
• Resources — readable data the assistant can pull into context (documents, records).
• Prompts — reusable, parameterised templates the server offers for common tasks.

How it connects

An MCP client — Claude, an IDE, your own agent — connects to a server over stdio (local process) or HTTP (remote), lists what's available, and lets the model invoke tools with structured arguments. The protocol handles discovery, typing and transport; what it deliberately does not dictate is your security model.

Security is the host's job

MCP standardises the wire, not the trust. Authentication, scoping, rate limits, and consent live at the server and host — which in healthcare is the whole ballgame. A health MCP server must expose only safe, scoped operations, on synthetic or consented data, with audit logging and guardrails — the protocol won't do that for you.

Where it shows up in digital health

• EHR vendors and health platforms exposing safe, scoped query tools to AI assistants.
• Clinical-knowledge services answering grounded questions as a tool.
• Terminology lookups (SNOMED/LOINC) as callable tools.

This platform will ship its own MCP server (roadmap M6) so a user's assistant can search Kosha and query Shabda directly — distribution for the agent era, with citations required and free-tier content only.

Common pitfalls

• Assuming the protocol secures you — it doesn't; auth/scoping/consent are yours to build.
• Exposing broad or write-capable tools without human gates — least privilege still applies.
• Leaking PHI through a "resource" — resources are data the model reads; govern them like any other disclosure.

Key takeaways

• MCP turns M×N bespoke integrations into M+N — write a tool once, every assistant can use it.
• Servers expose tools, resources, prompts; clients discover and invoke them over stdio/HTTP.
• The protocol handles plumbing; security and consent are the host's responsibility.
• HealthAtoms' planned MCP server brings Kosha/Shabda to any assistant — grounded and gated.