The Eureka MCP server

We run a first-party Model Context Protocol server at https://api.eureka.md/mcp. In one sentence: any AI tool you already use, Claude, ChatGPT, Cursor, or a custom agent, can connect to it with your own API key and read or act on your practice's patients, appointments, notes, and orders, the same data our own Slack assistant uses. It runs in production today: about 37 tools across roughly 20 domains, six resource types, and two built-in prompts, one for planning the day and one for closing out a visit.

We built it on the belief that the EHR itself should be the agent substrate, the place an agent reads and acts directly, rather than a system other agents bolt onto from outside. See our rundown of EHR MCP servers for how that compares to what other EHRs have shipped. This page is the technical reference; if you're deciding whether Eureka is your EHR at all, start at eureka.md/mcp.

What can an agent do through Eureka's MCP server?

The server exposes roughly 20 domains. Most pair a read tool with a matching _action write tool: patient and patient_action, order and order_action, and so on.

The read and action tools are registered separately. A client can wire up only the read half of that table, and the resulting agent has no write tool to call: the capability was never registered.

Resources

The server also exposes six MCP resource templates for direct reads by URI: patient://{id} (plus patient://{id}/chart and patient://{id}/timeline), note://{id}, appointment://{id}, order://{id}, form://{id}, and schedule://{date}. A client that supports resources can pull one straight into context instead of calling a tool.

Built-in prompts

Two MCP prompts ship with the server: /prep-day builds a morning brief across the schedule, and /post-visit walks a visit from note through finalizing and handoff. Claude Code lists these as slash commands, for example /mcp__eureka__prep-day; other clients use their own prompt picker.

How does auth work?

Every request carries a per-doctor API key as a bearer token: Authorization: Bearer eur_.... A key scopes to that doctor's own practice, so it can't reach another doctor's patients. Keys are revocable, stored hashed with SHA-256, and we track last-used time so a doctor can tell whether a key is still active before revoking it.

We provision keys per doctor on request, through your practice Slack channel or our support team, and issue one to paste into whichever client you're connecting.

How do I connect Claude Code?

Claude Code talks to the server over HTTP transport with a single command:

claude mcp add --transport http eureka https://api.eureka.md/mcp \
  --header "Authorization: Bearer eur_your_key_here"

Run claude mcp list to confirm the connection, or /mcp in a session to check status. A fuller walkthrough lives at /docs/connect-claude.

How do I connect Claude Desktop or claude.ai?

Claude Desktop and claude.ai both offer custom connectors: Settings > Connectors > Add custom connector, with https://api.eureka.md/mcp as the server URL. Header-based auth is rolling out unevenly there and isn't always available, especially on claude.ai's web connector, which has been OAuth-only for most accounts. If you don't see a headers field, or the connector won't authenticate, run the mcp-remote proxy locally, which adds the header for you:

{
  "mcpServers": {
    "eureka": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://api.eureka.md/mcp",
        "--header",
        "Authorization:${EUREKA_MCP_KEY}"
      ],
      "env": {
        "EUREKA_MCP_KEY": "Bearer eur_your_key_here"
      }
    }
  }
}

That block goes in Claude Desktop's claude_desktop_config.json. See /docs/connect-claude for where that file lives.

How do I connect Codex CLI?

Codex reads MCP servers from ~/.codex/config.toml. Add a streamable-HTTP entry, keeping the key out of the file:

[mcp_servers.eureka]
url = "https://api.eureka.md/mcp"
bearer_token_env_var = "EUREKA_MCP_KEY"

Set EUREKA_MCP_KEY to eur_your_key_here in your shell before starting Codex, which sends it as the bearer token on every request.

How do I connect Cursor?

Cursor reads MCP servers from .cursor/mcp.json per project, or ~/.cursor/mcp.json globally:

{
  "mcpServers": {
    "eureka": {
      "url": "https://api.eureka.md/mcp",
      "headers": {
        "Authorization": "Bearer ${env:EUREKA_MCP_KEY}"
      }
    }
  }
}

Set EUREKA_MCP_KEY in your shell profile so the key never sits in the JSON file, then enable the server from Cursor's Customize panel.

How do I connect ChatGPT?

ChatGPT reaches MCP servers through developer mode: Settings > Connectors or Apps > Advanced settings on a personal account, or Workspace Settings on a Business, Enterprise, or Edu account. Create a custom connector, paste https://api.eureka.md/mcp as the server URL, pick the option for a static key or bearer token, enter Bearer eur_your_key_here, then run Scan Tools and Create.

One limit worth knowing: OpenAI has gated write-capable MCP connectors by plan tier at various points, so what your account gets through developer mode may be read-only. Check /docs/connect-chatgpt and OpenAI's current MCP docs for what your plan supports, since it has changed before.

How do I connect any other streamable-HTTP client?

Any client that speaks the MCP streamable-HTTP transport works, built-in Eureka support or not. Point it at https://api.eureka.md/mcp, send the key as a standard Authorization header, and include Accept: application/json, text/event-stream, which the spec requires even though our server always answers with one JSON object rather than opening a stream:

curl -X POST https://api.eureka.md/mcp \
  -H "Authorization: Bearer eur_your_key_here" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

There's no session to establish or track between calls. Each request stands alone: send it, get a JSON-RPC response, done.

How is the MCP server designed to be safe?

The read and action split above is the load-bearing pattern: a harness can register only the read tools for a domain, leaving the resulting agent with no write tool to call. We use this ourselves. Eureka's own Slack assistant, which drafts replies to patient messages, runs on a locked-down read-only subset (fetch, patient, message, appointment, availability), because patient-authored text drives it and we treat that text as a prompt-injection boundary.

The same philosophy runs through the product. Reschedules, cancellations, and refill orders arrive as one-click proposals in Slack; the doctor approves each one, and nothing clinical executes on its own. Reminders and recall outreach are the exception, since they're administrative rather than clinical, so once turned on they run without further approval. We automate administrative work; clinical judgment stays with the doctor, who signs every note and approves every order.

Risky defaults are chosen conservatively. Scheduling a new appointment through the agent leaves the visit unpaid rather than touching the patient's card, unless a card hold is explicitly requested, and the patient is not messaged unless the agent explicitly asks for that. Prescribing is excluded from the order tools entirely; e-Rx stays in the app.

What about HIPAA?

Eureka signs a BAA with every practice we work with, covering data that flows through eureka.md itself. Connecting your own AI tool to this MCP server, Claude, ChatGPT, or anything else, is a separate question: your practice is the covered entity, responsible for that vendor agreement before PHI flows through it. Most consumer AI subscriptions don't include a BAA. Some vendors offer one on enterprise or API tiers; Anthropic and OpenAI both launched healthcare-specific offerings in January 2026. Confirm BAA status with your vendor before connecting. This isn't legal advice, just a prompt to check before sending patient data anywhere new.

One practical mitigation in the meantime: registering only the read tools limits what a misconfigured or compromised connection can do, even before the BAA question is settled.

Ready for a key? Ask in your practice Slack channel, or reach us at eureka.md/support.