# 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](/docs/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](/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.

| Domain             | What it covers                                                             |
| ------------------ | -------------------------------------------------------------------------- |
| `search`           | Free-text search across patients, appointments, and notes                  |
| `fetch`            | Reads a single record by URI                                               |
| `patient`          | Patient demographics and chart                                             |
| `appointment`      | Scheduling and appointment detail                                          |
| `availability`     | The doctor's open slots                                                    |
| `billing`          | Charges, card-on-file state, superbills                                    |
| `note`             | Visit notes                                                                |
| `order`            | Labs, referrals, and other non-prescription orders (e-Rx stays in the app) |
| `handoff`          | Handoff from visit to note to orders                                       |
| `form`             | Intake forms                                                               |
| `message`          | Patient messaging over SMS and email                                       |
| `profile`          | Doctor and practice profile                                                |
| `pipeline`         | Booking pipeline status                                                    |
| `google_calendar`  | Google Calendar sync                                                       |
| `payout`           | Stripe payout state                                                        |
| `note_ai_settings` | Note AI drafting configuration                                             |
| `document`         | Documents and inbound fax                                                  |
| `recall`           | Recall and follow-up outreach                                              |
| `report`           | Practice reporting                                                         |
| `skill`            | Skill templates                                                            |
| `worklist`         | Task and worklist items                                                    |

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:

```bash
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](/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:

```json
{
  "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](/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:

```toml
[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:

```json
{
  "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](/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:

```bash
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](https://eureka.md/support).


---

Source: https://eureka.md/docs/mcp (updated 2026-07-27). Eureka is an EHR and practice platform for private practices, with a first-party MCP server for AI agents: https://eureka.md/docs/mcp