Connect Elation Health to ChatGPT: Update Patient Notes & Billing

If you need to connect Elation Health to ChatGPT to automate clinical documentation, orchestrate medical billing, or pull patient histories, you need a Model Context Protocol (MCP) server. This server translates ChatGPT's natural language tool calls into Elation Health's strict Electronic Health Record (EHR) API requirements. You can spend weeks building, hosting, and maintaining a custom MCP server, or you can use a managed integration layer to dynamically generate a secure, authenticated MCP URL instantly.

If your team uses Claude, check out our guide on connecting Elation Health to Claude or explore our broader architectural overview on connecting Elation Health to AI Agents.

Giving a Large Language Model (LLM) read and write access to an EHR system like Elation Health introduces massive engineering friction. You are dealing with highly structured clinical schemas, complex pagination, relational data (e.g., tying a CPT billing code to a specific visit note for a specific patient), and strict rate limits. Every time Elation Health updates a resource schema, your custom server code must be updated and redeployed.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Elation Health, connect it natively to ChatGPT, and execute complex clinical and administrative workflows using natural language.

The Engineering Reality of the Elation Health API

A custom MCP server is essentially a self-hosted integration middleware. While the open MCP standard provides a predictable way for LLMs to discover tools, implementing it against Elation Health's API requires significant operational overhead.

If you decide to build a custom MCP server for Elation Health, you own the entire integration lifecycle. Here are the specific integration challenges that make Elation Health a difficult API to map to static MCP schemas:

Relational Complexity in Clinical Workflows

Unlike generic SaaS APIs where resources operate independently, Elation Health enforces strict relational constraints. You cannot simply "create a bill." A bill (/api/2.0/bills/) requires an array of CPT codes, a patient ID, a physician ID, a practice ID, and usually a signed visit_note ID. If an LLM attempts to generate a bill without first verifying the existence and signature status of the visit note, the API will reject the payload. Your MCP tools must be carefully scoped so the LLM understands it must query the patient, check the visit note, and then generate the bill.

Dual Note Schemas (Legacy vs. V2)

Elation Health supports two distinct note schemas. There are legacy notes (created before the sections schema) and modern EN2.1 sections-based layout notes. The API exposes separate endpoints for these (/api/2.0/notes/ vs /api/2.0/notes_v1/). If an LLM tries to update an EN2.1 note using the V1 endpoint, it throws an HTTP 400 error. The MCP server must dynamically expose the correct schemas and descriptions so the LLM knows which endpoint to call based on the note format.

Strict Rate Limiting and Client-Side Backoff

Elation Health strictly enforces API rate limits to protect EHR stability. A critical architectural detail when using Truto as your MCP layer is that Truto does not retry, throttle, or apply backoff on rate limit errors. When Elation Health returns an HTTP 429 (Too Many Requests), Truto passes that error directly back to the caller (ChatGPT).

To help you handle this, Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The caller (your LLM client or agent framework) is entirely responsible for reading these headers and implementing retry/backoff logic. Do not build an integration expecting the middle tier to absorb HTTP 429s.

Step 1: Create the Elation Health MCP Server

To connect ChatGPT to Elation Health, we first need to generate an MCP server URL scoped to a specific authenticated Elation practice account.

Truto dynamically derives the MCP tool definitions directly from the integration's documentation and resource schemas. This means you don't write custom JSON-RPC handlers; the tools exist because the API documentation exists.

First, authenticate the Elation Health account via the Truto dashboard (Integrated Accounts -> New Integrated Account). Once connected, you can generate the MCP server using either the UI or the API.

Method A: Via the Truto UI

1. Navigate to the Integrated Account page for your Elation Health connection in the Truto dashboard.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., allow read and write methods, filter by tags like patients or billing).
5. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3...).

Method B: Via the Truto API

You can programmatically generate this server for any connected practice using a single POST request. This is ideal if you are provisioning AI workspaces dynamically.

curl -X POST https://api.truto.one/integrated-account/<INTEGRATED_ACCOUNT_ID>/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Elation Health Clinical Assistant",
    "config": {
      "methods": ["read", "write"],
      "tags": ["patients", "notes", "billing", "appointments"]
    }
  }'

The API will return a JSON object containing the secure url. This single URL handles all routing, schema translation, and authentication for ChatGPT. Treat it like a production secret.

Step 2: Connect the MCP Server to ChatGPT

Now that you have your Truto MCP URL, you need to register it with your LLM client. We will cover both the ChatGPT UI method and the manual configuration file method.

Method A: Via the ChatGPT UI

(Note: Custom connectors require a ChatGPT Pro, Plus, Business, Enterprise, or Education account with Developer Mode enabled).

1. In ChatGPT, navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode on.
3. Under MCP servers / Custom connectors, click to add a new server.
4. Name: Enter a descriptive name (e.g., "Elation Health Automation").
5. Server URL: Paste the https://api.truto.one/mcp/... URL generated in Step 1.
6. Click Save. ChatGPT will immediately ping the endpoint, execute the handshake, and load the Elation Health tools.

(If you are configuring this for Claude Desktop instead, the path is: Settings -> Integrations -> Add MCP Server -> Paste URL -> Add).

Method B: Via Manual Config File

If you are using an agentic framework or a local MCP client (like Claude Desktop via config or a custom LangChain setup), you can configure the server manually using the standard SSE transport command.

Add the following to your mcp_config.json (or claude_desktop_config.json):

{
  "mcpServers": {
    "elation_health": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/<YOUR_TRUTO_MCP_TOKEN>"
      ]
    }
  }
}

Restart your client. The agent will read the config, establish the Server-Sent Events (SSE) connection, and pull the tool schemas.

Elation Health Hero Tools for ChatGPT

When ChatGPT connects to the Truto MCP server, it inherits a massive inventory of proxy tools. Instead of exposing everything, you should use Truto's method and tag filtering to restrict the LLM to high-leverage operations. Here are the core "hero tools" that unlock the most value for clinical and administrative workflows.

Retrieve a Patient Profile

get_single_elation_health_patient_by_id

This tool fetches the core demographics, primary physician data, and metadata for a specific patient. It is the mandatory first step in almost any workflow, as downstream endpoints (like notes and bills) require a validated patient_id.

"Find the patient record for ID 554321 and summarize their primary care physician assignment and demographic details."

Create a Clinical Visit Note

create_a_elation_health_visit_note

Generates a new visit note in Elation. The LLM must supply the patient, physician, chart_date, and the actual note bullets. Because Truto automatically injects required schema definitions, ChatGPT knows exactly how to format the nested bullet objects.

"Create a new visit note for patient 554321 with today's date. The chief complaint is a mild tension headache. Add an assessment bullet noting no neurological deficits, and a plan bullet recommending over-the-counter ibuprofen."

Generate a Patient Bill

create_a_elation_health_bill

Creates and stores a bill in Elation Health, ready for downstream Practice Management System (PMS) consumption. This requires the LLM to provide cpts (billing codes), patient, physician, practice, and optionally the visit_note ID.

"Draft a bill for patient 554321 for today's visit. Attach CPT code 99213 to the bill. Assign it to physician ID 887 and practice ID 102."

Schedule an Appointment

create_a_elation_health_appointment

Books a new appointment. The LLM must navigate date formatting requirements and supply the correct provider and practice references.

"Book a follow-up appointment for patient 554321 on November 15th at 10:00 AM with Dr. Smith (physician ID 887) at the main clinic (practice ID 102)."

Add a Clinical Problem

create_a_elation_health_problem

Adds a diagnosis or clinical problem to the patient's record. The LLM must supply the description, a valid dx (diagnosis code data), the patient ID, and the status (e.g., active or resolved).

"Add 'Essential Hypertension' to the problem list for patient 554321. Mark the status as active and set the start date to today."

List Upcoming Appointments

list_all_elation_health_appointments

Fetches a paginated list of appointments. Because Truto standardizes the cursor-based pagination, ChatGPT is explicitly instructed by the generated tool description to pass the next_cursor back unchanged if it needs to read beyond the first 100 results.

"List all appointments scheduled for tomorrow at practice ID 102. If there are more than 100, paginate through the results and give me a complete summary."

To view the complete inventory of available proxy tools, including endpoints for lab orders, medications, allergies, and care gaps, check out the Elation Health integration page.

Workflows in Action

Connecting tools to an LLM is only useful if the agent can chain them together to solve real business problems. Here are two concrete, multi-step workflows ChatGPT can execute autonomously using the Elation Health MCP server.

Workflow 1: Post-Visit Documentation & Billing

Persona: Clinical Scribe / Medical Assistant

"Patient ID 88912 came in for a routine checkup today. Everything was normal. Create a visit note documenting a healthy exam. Then, add a resolved problem for 'seasonal allergies' to their chart. Finally, create a bill for this encounter using CPT code 99214 and release it to the PMS."

Execution Steps:

1. ChatGPT calls create_a_elation_health_visit_note to draft the clinical note, passing the patient, physician, and examination bullets.
2. The agent extracts the generated visit_note ID from the response.
3. ChatGPT calls create_a_elation_health_problem to add "seasonal allergies" with a status of "resolved".
4. ChatGPT calls create_a_elation_health_bill, passing the patient, cpts (99214), and the visit_note ID.
5. Finally, the agent calls elation_health_bills_release_to_pms using the newly generated bill ID to push it to the external billing system.

Result: The LLM successfully documents the visit, updates the patient's medical history, and orchestrates the revenue cycle - all in one conversational prompt.

sequenceDiagram
    participant ChatGPT as ChatGPT
    participant TrutoMCP as Truto MCP Server
    participant Elation as Elation Health API

    ChatGPT->>TrutoMCP: call(create_a_elation_health_visit_note)
    TrutoMCP->>Elation: POST /api/2.0/visit_notes/
    Elation-->>TrutoMCP: 201 Created (Note ID: 443)
    TrutoMCP-->>ChatGPT: Tool Result
    
    ChatGPT->>TrutoMCP: call(create_a_elation_health_problem)
    TrutoMCP->>Elation: POST /api/2.0/problems/
    Elation-->>TrutoMCP: 201 Created
    TrutoMCP-->>ChatGPT: Tool Result
    
    ChatGPT->>TrutoMCP: call(create_a_elation_health_bill)
    TrutoMCP->>Elation: POST /api/2.0/bills/
    Elation-->>TrutoMCP: 201 Created (Bill ID: 992)
    TrutoMCP-->>ChatGPT: Tool Result

Workflow 2: Morning Patient Briefing

Persona: Primary Care Physician

"Look up all my appointments for today. For the first two patients on the schedule, retrieve their profiles and list any active drug intolerances or allergies they have so I'm prepared for the visits."

Execution Steps:

1. ChatGPT calls list_all_elation_health_appointments, filtering by today's date and the physician's ID.
2. The agent extracts the patient IDs for the first two appointments in the array.
3. For Patient A, the agent calls get_single_elation_health_patient_by_id to get baseline context, followed by list_all_elation_health_allergies and list_all_elation_health_drug_intolerances.
4. The agent repeats step 3 for Patient B.
5. ChatGPT synthesizes the JSON responses into a clean, readable briefing.

Result: The physician receives a targeted, human-readable summary of critical safety data for their upcoming appointments without ever clicking through the EHR interface.

Security and Access Control

Giving an AI agent access to sensitive Electronic Health Records requires strict governance. Truto's MCP servers provide granular access controls natively:

• Method Filtering: Configure config.methods: ["read"] to ensure the MCP server only exposes GET and LIST tools. This creates a strictly read-only AI agent, preventing accidental data modification.
• Tag Filtering: Use config.tags: ["appointments", "patients"] to restrict the agent's scope. If you don't want the agent touching billing or prescriptions, simply exclude those tags during server creation.
• API Token Authentication: By default, anyone with the Truto MCP URL can connect. To secure it, set config.require_api_token_auth: true. The client must then pass a valid Truto API token in the Authorization header, adding a critical second layer of identity verification.
• Expiration (expires_at): You can set a precise ISO datetime for the MCP server to self-destruct. This is perfect for granting temporary agent access to a contractor or auditor (e.g., "access revokes on Friday at 5 PM").

Simplify Healthcare Integrations with Truto

Building a custom MCP server for an EHR like Elation Health requires deep knowledge of clinical data models, pagination state management, and rate limit orchestration.

With Truto, you bypass the infrastructure build entirely. Truto automatically generates the tools, handles the JSON-RPC lifecycle, normalizes the rate-limit headers for your client, and enforces granular security controls - all through a single API endpoint.

Whether you are building an AI scribe, an automated billing agent, or a clinical intelligence dashboard, Truto provides the fastest path to production.