Skip to main content
Glama

clinic-frontdesk-mcp

Give your LLM a front desk.

CI Python 3.11+ License: MIT MCP tests

An open-source MCP server that turns any MCP-compatible client — Claude Desktop, Claude Code, or your own agent — into an AI receptionist for a small medical clinic.

It handles the front desk: booking and rescheduling appointments, registering patients, taking pre-visit intake, sending reminders, and answering questions about timings, fees and location. The LLM is the brain; this server is the hands.

You:    Book Mr. Shah with Dr. Mehta tomorrow evening for a diabetes follow-up.
Claude: Dr. Mehta has 6:00, 6:30 and 7:00 PM open tomorrow. Which suits him?
You:    6 PM.
Claude: Booked — Rajesh Shah with Dr. Anjali Mehta on Mon 10 Aug 2026 at 6:00 PM,
        for diabetes follow-up. A reminder goes out 24 hours before. Reference #1.

You:    He's had a headache for three days, should he take something?
Claude: I can't advise on that one — it's best discussed with the doctor. Dr. Mehta
        has 11:00 AM free on Tuesday if you'd like to bring the visit forward.

You:    Cancel it, actually.
Claude: That's Rajesh Shah with Dr. Mehta, Mon 6:00 PM, diabetes follow-up.
        Shall I cancel it?          ← nothing has happened yet

Behind those four turns: a patient lookup, a live availability check, a transactional booking, a queued reminder, a clinical question routed away from the model's own opinion, and a destructive action held back for confirmation.

Here is the same conversation from the server's side — the tools the model reaches for, and what comes back. Every line was captured from a real session; nothing here is mocked up.

Terminal recording: find_patient returns one match for Shah; check_availability lists 14 open
slots; book_appointment confirms Rajesh Shah with Dr. Anjali Mehta at 6:00 PM with a reminder
queued; answer_faq flags a medical question and returns the doctor redirect; cancel_appointment
returns confirmation_required with a preview and cancels
nothing.

Why it's not just a CRUD wrapper

A calendar with tool descriptions bolted on gets the happy path right and the other paths wrong. The interesting work here is in the failure modes:

The awkward bit

How it's handled

Two agents grab the same slot at once

Overlap check + insert in one BEGIN IMMEDIATE transaction, behind a partial unique index — details

Clocks jump forward and back

Non-existent wall-clock slots skipped, ambiguous ones offered once, durations measured in real elapsed time

"Should he take something for the headache?"

A curated clinical vocabulary short-circuits to the doctor redirect — a rule, not a similarity score that can drift

The FAQ has no good answer

Returns match: none so the agent escalates instead of inventing clinic policy

The requested slot is gone

Returns the nearest alternatives, not a bare error, so the conversation keeps moving

Logs are patient records too

Names collapse to initials, phone numbers are masked, before anything is written

Related MCP server: MCP Medical Appointments Demo

What it will not do

This server handles logistics only. It has no clinical knowledge and is not a medical device.

  • No clinical advice. Medical questions return the clinic's standard "please discuss this with the doctor" response, with an offer to book an appointment. This is enforced in code, not left to the model's judgement — see Clinical safety.

  • No diagnoses stored. Intake records what the patient said, in their words.

  • Confirmation before destructive actions. cancel_appointment does nothing without an explicit confirm=true; called without it, it returns a preview to read back to the caller.

Privacy

Patient data stays on the machine running the server, in a single SQLite file. There are no external calls in v1 unless you explicitly configure the optional Twilio adapter.

Logs go to stderr only (stdout is the MCP transport) and PII is redacted before anything is written: phone numbers are masked and names collapse to initials. The audit_log table records every write action in the same redacted form.

The database is not encrypted at rest. Store CLINIC_DB_PATH on an encrypted volume and treat that file as you would any other patient record.

Setting it up — no coding required

This server has no screen of its own. It plugs into an app you already talk to — Claude Desktop is the easiest one — and that app grows a set of front-desk abilities. You do the talking; it does the booking.

Setup is five steps and takes about ten minutes. Exactly one of them uses a terminal, and it's a single line you copy and paste.

1. Install Claude Desktop

Download it from claude.ai/download, install it like any other app, and sign in.

2. Install uv

uv is a small free tool that fetches and runs this server for you. It brings its own copy of Python, so there is nothing else to install.

Open a terminal — on a Mac press ⌘+Space, type Terminal, press Enter; on Windows click Start, type PowerShell, press Enter — then paste one of these and press Enter:

# macOS or Linux
curl -LsSf https://astral.sh/uv/install.sh | sh
# Windows
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

Close the terminal window when it finishes. That's the last command you'll type.

3. Open Claude's settings file

In Claude Desktop, go to Settings → Developer → Edit Config. That opens a file called claude_desktop_config.json in a text editor. If you'd rather open it by hand, it lives at:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Windows: %APPDATA%\Claude\claude_desktop_config.json

4. Paste in the clinic

Replace everything in that file with the block below, then save. If the file already has other entries under mcpServers, add just the "clinic-frontdesk" section alongside them.

{
  "mcpServers": {
    "clinic-frontdesk": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/prashant-cr/Clinic-front-desk-MCP-server",
        "clinic-frontdesk-mcp"
      ],
      "env": {
        "CLINIC_DB_PATH": "/Users/you/clinic-data/clinic.db",
        "CLINIC_NAME": "Demo Family Clinic",
        "CLINIC_TIMEZONE": "Asia/Kolkata"
      }
    }
  }
}

Three things to change for your clinic:

Line

Change it to

CLINIC_DB_PATH

Where the patient file should live. Windows example: C:\\Users\\you\\clinic-data\\clinic.db. Must be a full path — see the warning below

CLINIC_NAME

Your clinic's name, as it should read in confirmations and reminders

CLINIC_TIMEZONE

Your timezone, in IANA form — Asia/Kolkata, Europe/London, America/New_York

Use a full path for CLINIC_DB_PATH, starting from the drive or your home folder. Claude Desktop doesn't start the server from any particular folder, so a short path like clinic.db ends up somewhere you won't find it.

5. Restart Claude Desktop

Quit it completely — ⌘+Q on a Mac, or right-click the taskbar icon and Quit on Windows; closing the window isn't enough — then open it again. The first launch takes a few extra seconds while uv downloads the server.

Check it worked

Look for the tools icon near the message box; clinic-frontdesk should be listed. Then just ask:

Who are the doctors at the clinic?

If you get three doctors and their hours back, you're done. The first run creates the patient file and fills it with a demo clinic — three doctors, four patients and a small FAQ — so you have something to practise on before real data goes in.

Pick the receptionist_system prompt in Claude's prompt menu to put it into a warm, careful receptionist frame of mind, with the safety rules already in place.

Talking to it

Plain sentences work. There are no commands to memorise.

Say something like

What happens

"What's free with Dr. Mehta on Thursday afternoon?"

Reads out the open slots

"Book Mrs. Rao with Dr. Iyer on Tuesday at 11, for a vaccination."

Checks the slot, books it, reads the booking back

"New patient — Anil Kumar, 98200 12345."

Registers him, or finds him if that number is already on file

"Move appointment 14 to Friday morning."

Reschedules and moves the reminder with it

"Cancel appointment 14."

Shows you the appointment and waits for you to confirm

"What's on today?"

Each doctor's day: appointments, gaps, missing intake forms

"Do you take insurance?"

Answers from the clinic FAQ, or says it doesn't know

Ask it a medical question and it won't answer one — it will point the caller to the doctor and offer an appointment. That's deliberate; see What it will not do.

If something goes wrong

What you see

Try this

No clinic-frontdesk in the tools list

Quit Claude Desktop completely and reopen it. Check the config file for a missing comma or bracket

"command not found: uvx" in the logs

uv isn't installed, or the terminal was open before you installed it. Redo step 2, then restart Claude Desktop

It answers but never books anything

It's answering from memory rather than the tools. Ask directly: "Use the clinic tools to check Dr. Mehta's availability tomorrow."

Times look wrong

CLINIC_TIMEZONE is off. Fix it and restart Claude Desktop

You want to start with an empty clinic

Add "CLINIC_SEED": "false" to the env block, delete the clinic.db file, and restart

Where your data lives

Everything sits in the single file at CLINIC_DB_PATH on your own machine. Nothing is uploaded anywhere. To back it up, copy that file — the way you'd copy a photo — and keep the copy somewhere safe and encrypted. To move to a new computer, install the server there and copy the file across.

Try it: a five-step demo

Start a conversation with the server connected and try these in order. The first run seeds a demo clinic with three doctors, four patients and a FAQ.

  1. "Who are the doctors at the clinic and when do they work?" → list_doctors. Dr. Mehta (general practice, split morning/evening shifts), Dr. Iyer (pediatrics, 20-minute slots), Dr. Sheikh (dermatology, 45-minute consultations).

  2. "What's open with Dr. Mehta next Monday evening?" → check_availability. Returns real bookable slots in clinic-local time, past ones excluded.

  3. "Book Mr. Shah with Dr. Mehta tomorrow evening for a diabetes follow-up." → find_patient, then book_appointment. Read back the confirmation. A reminder is queued for 24 hours before. Try booking the same slot again — you will get the nearest alternatives instead of a bare failure.

  4. "He's been tired in the afternoons for about two months, takes metformin 500mg twice daily, allergic to penicillin." → submit_intake. Then ask "what will the doctor see?" → get_intake returns a one-paragraph brief a doctor can read in ten seconds.

  5. "Actually, can we move that to Wednesday morning? And what are your consultation fees?" → reschedule_appointment (old → new summary, reminder re-queued) and answer_faq.

Then try the guardrails:

  • "He's had a bad headache for three days — should he take something for it?" → the doctor redirect, not advice.

  • "Cancel his appointment." → a preview and a request to confirm. Nothing is cancelled until you say yes.

  • "What's the wifi password?" → match: none, so the agent offers to check with the front desk rather than inventing an answer.

For developers

# Run straight from the repository, no clone needed
uvx --from git+https://github.com/prashant-cr/Clinic-front-desk-MCP-server clinic-frontdesk-mcp

# Or clone and install
git clone https://github.com/prashant-cr/Clinic-front-desk-MCP-server
cd Clinic-front-desk-MCP-server
uv pip install -e .

# With the optional SMS adapter
uv pip install -e '.[twilio]'

Requirements: Python 3.11 or newer, and nothing else — SQLite is created and seeded on first run.

Not yet on PyPI. Until the first release, use the git forms above. After publication, uvx clinic-frontdesk-mcp becomes the one-line install and the config args shorten to ["clinic-frontdesk-mcp"]. If you cloned the repo, point command at /path/to/repo/.venv/bin/clinic-frontdesk-mcp with "args": [].

Other MCP clients

Any MCP-compatible client works — the server speaks stdio and nothing else. Claude Code:

claude mcp add clinic-frontdesk \
  --env CLINIC_DB_PATH=/absolute/path/to/clinic.db \
  --env CLINIC_TIMEZONE=Asia/Kolkata \
  -- uvx --from git+https://github.com/prashant-cr/Clinic-front-desk-MCP-server clinic-frontdesk-mcp

For other clients, give them the same command, arguments and environment variables as the JSON above in whatever format they use.

Tools

Read

Tool

What it does

list_doctors

Doctors with specialty and usual weekly hours

check_availability

Open slots for a doctor; falls back to the next three openings when a day is full

find_patient

Partial search by name or phone. Returns all matches — never guesses

get_appointments

Filter by patient, doctor, date and status

get_intake

Intake form plus the ten-second doctor_brief

answer_faq

Best FAQ match with a confidence level, or match: none to escalate

daily_summary

Per-doctor view of a day: appointments, merged free blocks, pending intakes, unsent reminders

Write

Every write appends a PII-redacted row to audit_log.

Tool

What it does

register_patient

Creates a patient, or returns the existing record for that phone number

book_appointment

Validates and books, queues a 24-hour reminder, returns a read-back confirmation

reschedule_appointment

Moves the appointment and re-queues the reminder

cancel_appointment

Requires confirm=true. Without it, returns a preview

submit_intake

Stores intake and regenerates the doctor brief. Re-submitting replaces it

send_reminder

Sends one reminder immediately

process_due_reminders

Sends every reminder that has come due. Run periodically

add_faq

Lets staff grow the FAQ through the agent

Configuration

All settings are environment variables, all with defaults — the server starts with no configuration at all.

Variable

Default

Purpose

CLINIC_DB_PATH

./clinic.db

SQLite file. Created and seeded on first run

CLINIC_NAME

Demo Family Clinic

Name used in confirmations and reminders

CLINIC_TIMEZONE

Asia/Kolkata

IANA zone. All tool input and output is in this zone

CLINIC_SEED

true

Load demo data when the database is first created

CLINIC_LOG_LEVEL

INFO

Log verbosity (stderr)

TWILIO_ACCOUNT_SID

–

All three needed for SMS; otherwise reminders print to stderr

TWILIO_AUTH_TOKEN

–

TWILIO_FROM_NUMBER

–

Seeding happens only when the database file is created. Restarting never duplicates demo rows or resurrects deleted records. Set CLINIC_SEED=false to start empty for a real clinic.

How it works

  caller ──▶ Claude Desktop / Claude Code / your agent      ← the brain: language, judgement
                       │  MCP over stdio
                       ▼
             ┌───────────────────────┐
             │ server.py             │  14 tools, thin — no logic lives here
             ├───────────────────────┤
             │ scheduling  patients  │  slot maths, conflicts, intake
             │ faq         notifs    │  matching, clinical routing, reminders
             ├───────────────────────┤
             │ db.py  → clinic.db    │  SQLite on your disk. UTC in, local out
             └───────────────────────┘  every write mirrored to a redacted audit_log
                       │
                       └─▶ stderr (redacted logs)   ·   Twilio SMS (optional, off by default)

Nothing leaves the machine unless you configure the Twilio adapter yourself.

Time

Every timestamp is stored in UTC and every tool input and output is in clinic-local time. scheduling.py is the single conversion boundary — nothing above it touches UTC, nothing below it touches local time.

Slots come from a weekly template in schedules, overridden per-day by schedule_exceptions (a holiday closes the day; a time override replaces that day's windows). Slots that would run past the end of a window are dropped, so a 10:00–12:30 window in 20-minute slots ends at 12:20.

DST is handled explicitly: a slot at a wall-clock time that does not exist (spring forward) is skipped, and an ambiguous hour (fall back) is offered once. Slot durations are real elapsed time, so consecutive slots never overlap across a transition.

No double-booking

Two layers, because SQLite has no exclusion constraint:

  1. A partial unique index on (doctor_id, starts_at_utc) for active appointments.

  2. An overlap check and the insert inside one BEGIN IMMEDIATE transaction, which closes the check-then-insert race the index alone cannot cover for partial overlaps.

Clinical safety

Routing medical questions to the doctor is a rule, not a similarity score. Scoring failed it in both directions during development: "I have a bad headache for 3 days" fell below the escalation floor purely for being a long sentence, while the generic keyword take pulled "do you take insurance?" toward the medical entry.

A curated CLINICAL_TERMS vocabulary in faq.py now short-circuits to the redirect entry, which the seed marks with the reserved keyword medical. You can reword that answer for your clinic — just keep the keyword on it.

Development

uv venv
uv pip install -e '.[dev]'

uv run pytest -q                 # 248 tests
uv run ruff check . && uv run ruff format --check .
uv run mypy src/

Inspect the server with the MCP Inspector, pointing it at the installed entry point — the same command Claude Desktop runs:

# Interactive browser UI
npx @modelcontextprotocol/inspector .venv/bin/clinic-frontdesk-mcp

# Or drive it from the terminal
npx @modelcontextprotocol/inspector --cli .venv/bin/clinic-frontdesk-mcp --method tools/list
npx @modelcontextprotocol/inspector --cli .venv/bin/clinic-frontdesk-mcp \
  --method tools/call --tool-name list_doctors

Note that mcp dev src/clinic_frontdesk_mcp/server.py:mcp does not work here: it loads the file as a standalone module, which breaks the package-relative imports. Point the Inspector at the entry point instead, as above — it also exercises the real console script rather than a special-cased import.

Layout

src/clinic_frontdesk_mcp/
├── server.py         # MCP tool definitions only — thin, delegates everything
├── scheduling.py     # slot maths, conflict detection, the local<->UTC boundary
├── patients.py       # patient records and intake
├── faq.py            # FAQ matching and clinical-question detection
├── notifications.py  # reminder delivery adapters
├── db.py             # schema, migrations, seeding, redacted audit log
├── models.py         # domain dataclasses
└── config.py         # environment configuration

Business logic lives in the domain modules and is testable without MCP. If a tool body in server.py grows past a screen, the logic belongs somewhere else.

Not in v1

No web UI, no authentication or multi-tenancy, no real WhatsApp integration (the adapter interface is there), no EMR/FHIR integration, no payments, no multi-clinic support.

License

MIT — see LICENSE.

Available Tools

15 tools
add_faqA

Add an entry to the clinic FAQ so future callers get a consistent answer.

Use this when staff tell you something the FAQ does not cover yet, or after answer_faq returns match: "none" and a human supplies the answer.

Only for clinic logistics — timings, fees, policies, facilities. Never add medical guidance; clinical questions must keep routing to the doctor.

Args: question: The question as a caller would ask it. answer: The exact wording to read back. Write it as speech, not a document. keywords: Comma-separated search terms, including likely synonyms and misspellings, e.g. "parking,park,vehicle,two wheeler,car".

Example: add_faq(question="Do you have parking?", answer="Yes, free two-wheeler parking is available at the rear.", keywords="parking,park,vehicle,two wheeler,bike,car")

Inputs: answer (required), question (required), keywords. Returns: object

answer_faqA

Answer a question about the clinic: timings, fees, location, payment, insurance.

Use this for anything informational rather than transactional.

Read the result carefully before replying:

  • match: "high" — read the answer back as-is.

  • match: "medium" — offer it, but check you understood ("did you mean...?").

  • match: "none" — say you will check with the front desk. Do NOT improvise an answer about fees, insurance or policy; a confident wrong answer about money is worse than a short delay.

Medical questions return the clinic's standard redirect to the doctor. Read it as written and offer to book an appointment — never supplement it with clinical information of your own.

Example: answer_faq(question="what are your timings on saturday?")

Inputs: question (required). Returns: object

book_appointmentA

Book an appointment and queue a reminder for 24 hours beforehand.

Call check_availability first and offer the caller a real opening. Read the returned confirmation back to them.

The slot must be free, inside the doctor's working hours, and aligned to their appointment grid. If it is taken, the error names the nearest alternatives — offer those rather than repeating the request.

Args: patient_id: From find_patient or register_patient. doctor_id: From list_doctors. starts_at: Clinic-local ISO 8601, e.g. '2027-01-25T18:00'. Not UTC. reason: Why they are coming, in the caller's own words.

Example: book_appointment(patient_id=1, doctor_id=1, starts_at="2027-01-25T18:00", reason="diabetes follow-up")

Inputs: reason (required), doctor_id (required), starts_at (required), patient_id (required). Returns: object

cancel_appointmentA

Cancel an appointment. Requires explicit confirmation.

Call it first WITHOUT confirm to get a preview of exactly what would be cancelled. Read that back to the caller, and only call again with confirm=True once they have said yes.

This two-step gate exists because cancelling is not reversible from here — a mistakenly cancelled slot may be taken by someone else within minutes.

Confirming releases the slot and cancels the pending reminder.

Args: appointment_id: From get_appointments. confirm: Must be True to actually cancel.

Example: cancel_appointment(appointment_id=12) # preview cancel_appointment(appointment_id=12, confirm=True) # actually cancel

Inputs: appointment_id (required), confirm. Returns: object

check_availabilityA

Find open appointment slots for a doctor, in clinic-local time.

Always call this before book_appointment so you offer times that are genuinely free. Slots already in the past are excluded automatically.

If the requested date has nothing open, next_available holds the next three openings after it, so you can offer an alternative instead of a dead end.

Args: doctor_id: From list_doctors. date: Clinic-local 'YYYY-MM-DD'. Defaults to today. days_ahead: How many days to scan, starting at date. Use 7 for "sometime next week".

Example: check_availability(doctor_id=1, date="2027-01-25", days_ahead=3)

Inputs: doctor_id (required), date, days_ahead. Returns: object

daily_summaryA

Give a doctor-by-doctor overview of one day: appointments, free time, and gaps.

Use this for "what does today look like?" or when staff want to know where attention is needed. pending_intakes and unsent_reminders are the actionable parts — they are the work the front desk still has to do.

Args: date: Clinic-local 'YYYY-MM-DD'. Defaults to today.

Example: daily_summary(date="2027-01-25")

Inputs: date. Returns: object

find_patientA

Search patients by partial name or phone number.

Use this before booking for someone who says they have been here before.

When count is greater than 1, ask the caller which record is theirs — do not guess. Two people share a surname far more often than you would like, and booking the wrong record is worse than asking one extra question. A count of 0 means they are new: use register_patient.

Example: find_patient(query="Shah") or find_patient(query="9876543210")

Inputs: query (required). Returns: object

get_appointmentsA

List appointments, filtered by any combination of patient, doctor, date and status.

Use this to answer "when is my appointment?", to find the appointment_id needed by reschedule_appointment or cancel_appointment, or to review a doctor's day.

With no filters it returns everything, so pass at least one for a busy clinic.

Args: patient_id: From find_patient. doctor_id: From list_doctors. date: Clinic-local 'YYYY-MM-DD'. status: One of booked, rescheduled, cancelled, completed, no_show.

Example: get_appointments(patient_id=1, status="booked")

Inputs: date, status, doctor_id, patient_id. Returns: object

get_intakeA

Retrieve the intake form for an appointment, plus a ready-to-read doctor brief.

doctor_brief is a single paragraph written to be absorbed in about ten seconds — read that to the doctor rather than reciting every field.

Returns submitted: false when no intake has been taken yet, which is your cue to collect one with submit_intake.

Example: get_intake(appointment_id=12)

Inputs: appointment_id (required). Returns: object

list_doctorsA

List the clinic's doctors with their specialty and usual weekly hours.

Use this first when the caller does not name a doctor, or asks who they can see for a particular problem. The returned doctor_id is what check_availability and book_appointment expect.

The availability_summary is the regular weekly pattern, not live openings — call check_availability for actual free slots.

Example: list_doctors()

Inputs: include_inactive. Returns: object

process_due_remindersA

Send every reminder that has come due. Run this periodically.

Picks up all pending reminders whose send time has passed and whose appointment is still active. Reminders for cancelled appointments are dropped rather than sent. A failed delivery stays pending for the next run.

Args: limit: Maximum to process in one pass.

Example: process_due_reminders()

Inputs: limit. Returns: object

register_patientA

Register a new patient, or return the existing record for that phone number.

Call find_patient first. If the phone number is already on file this returns that patient with created: false instead of creating a duplicate — so a repeat caller keeps one history rather than several.

Confirm the spelling of the name and the phone number with the caller before calling this.

Args: name: Full name as the patient gives it. phone: Any common format; '+91 98765-43210' and '+919876543210' are treated as the same number. dob: 'YYYY-MM-DD', optional but useful for distinguishing same-name patients. notes: Anything the front desk should remember. Not clinical notes.

Example: register_patient(name="Rajesh Shah", phone="+919876543210", dob="1968-04-12")

Inputs: name (required), phone (required), dob, notes. Returns: object

reschedule_appointmentA

Move an existing appointment to a new time and update its reminder.

Use check_availability first to confirm the new time is free. The old slot is released and the 24-hour reminder is re-queued for the new time.

Cancelled appointments cannot be rescheduled — book a new one instead.

Args: appointment_id: From get_appointments. new_starts_at: Clinic-local ISO 8601, e.g. '2027-01-27T09:30'.

Example: reschedule_appointment(appointment_id=12, new_starts_at="2027-01-27T09:30")

Inputs: new_starts_at (required), appointment_id (required). Returns: object

send_reminderA

Send this appointment's reminder now, ahead of its scheduled time.

Use when a caller asks to be reminded again, or to confirm details in writing. Normal reminders go out on their own via process_due_reminders — you do not need this for routine bookings.

Delivery goes through the configured channel: printed to the server log by default, or SMS when Twilio is configured.

Example: send_reminder(appointment_id=12)

Inputs: appointment_id (required). Returns: object

submit_intakeA

Record pre-visit intake for an appointment and regenerate the doctor brief.

Collect this after booking. Ask about medications and allergies explicitly — both change what the doctor can safely prescribe, and "no answer" is not the same as "none".

Record what the patient says in their own words. Do not interpret symptoms, suggest what they might indicate, or add clinical terminology of your own.

Re-submitting replaces the previous intake, so it is safe to call again if the caller corrects themselves.

Args: appointment_id: From get_appointments or book_appointment. chief_complaint: The main reason for the visit, in one line. symptoms: What they are experiencing, as described. duration: How long it has been going on, e.g. "about 3 weeks". current_medications: What they take now, including dosage if offered. allergies: Known allergies, or "none reported" if they say none. notes: Anything else logistically relevant.

Example: submit_intake(appointment_id=12, chief_complaint="blood sugar review", symptoms="tired in the afternoons", duration="2 months", current_medications="metformin 500mg twice daily", allergies="penicillin")

Inputs: appointment_id (required), chief_complaint (required), notes, duration, +3 more. Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.7/5.0

    Scored across 15 tools

    Disambiguation5/5

    Each tool targets a distinct entity and action: doctors, availability, patients, appointments (book/reschedule/cancel/list), intake, reminders, FAQ, and daily summary. There is no overlap in purpose, and descriptions clarify any potential boundary cases.

    Naming Consistency5/5

    All tool names use snake_case and follow a mostly verb_noun pattern (list_doctors, book_appointment, cancel_appointment). The only minor deviation is daily_summary, but it is still a clear noun phrase and consistent in style.

    Tool Count5/5

    15 tools is at the upper edge of the recommended range but each tool earns its place by covering a distinct front-desk operation. The set is well-scoped for a clinic front desk, neither too thin nor bloated.

    Completeness4/5

    The tool set covers the core lifecycle: patients (find/register), appointments (book/reschedule/cancel/list), intake (get/submit), reminders (send/process), and FAQ (answer/add). Minor gaps exist such as no patient update or explicit completion/no-show status change, but these are not critical for the front-desk purpose.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      D
      maintenance
      Enables integration with the Cliniko practice management system through MCP tools and resources. Supports patient management, appointment scheduling, and practice data access through natural language interactions.
      -
    • F
      license
      Not graded
      quality
      D
      maintenance
      Enables users to manage medical appointments by searching for doctors, checking availability, and booking sessions through a natural language interface. It serves as a reference implementation for advanced MCP features like symptom-based specialist recommendations and multi-step scheduling workflows.
      -