The fhir-mcp-suite server provides a comprehensive FHIR R4 interface for reading, searching, paginating, and validating clinical resources, with additional terminology and clinical reasoning capabilities.
fhir_capabilities: Retrieve a summary of the FHIR server's CapabilityStatement, including FHIR version, software info, supported resource types, and available search parameters.
fhir_read: Fetch a single FHIR R4 resource (e.g., Patient, Observation, Medication) by resource type and logical ID, returning the full resource as JSON.
fhir_search: Search any FHIR R4 resource type using standard FHIR search parameters, returning a FHIR Bundle with matching entries.
fhir_search_next: Paginate through large result sets by passing the _next_url from a previous Bundle.
validate_against_profile: Validate a FHIR R4 resource against a StructureDefinition profile using the HAPI validator, with support for US Core, IPS, and base FHIR R4 conformance — returns conformance status, error count, and detailed issues.
Terminology services: Perform unified lookups across LOINC, SNOMED, RxNorm, and ICD-10, and expand ValueSets.
Clinical reasoning: Check for drug interactions (via OpenFDA), perform dose checks, and identify potential allergy conflicts.
Three coherent MCP servers for clinical AI — FHIR R4, terminologies, and clinical reasoning.
Server | Status | Install | What it does |
mcp-fhir | ✅ v1.1.1 on PyPI |
| FHIR R4 read/search + HAPI profile validation |
mcp-terminology | ✅ v1.0 on PyPI |
| Unified LOINC / SNOMED / RxNorm / ICD-10 lookup + ValueSet expansion |
mcp-clinical-reasoner | ✅ v1.0 on PyPI |
| Drug interactions (OpenFDA), dose check, allergy conflicts |
Related MCP server: atlas_mcp
Every FHIR MCP server available today (June 2026) is a read proxy — they retrieve resources but
never tell you whether the resource is valid. mcp-fhir adds HAPI profile validation as a
first-class MCP tool. Composing fhir_read → validate_against_profile in one Claude session
enables clinical AI pipelines that are actually safe.
Three sharp differentiators:
Profile validation built into mcp-fhir — HAPI validator sidecar, US Core + IPS profiles supported out of the box
Composable suite — three coherent servers sharing one install, one config convention, one eval harness
Production rigor — latency benchmarks, golden-query eval suite, structured JSON logs, /health + LangFuse traces
# 1-command install (requires Python 3.12+)
uvx mcp-fhir
# Validate a Patient against US Core
# (requires HAPI validator sidecar — see docker-compose.yml)
uvx mcp-fhir --transport sse # or set MCP_TRANSPORT=sseAdd to ~/Library/Application Support/Claude/claude_desktop_config.json
(Windows: %APPDATA%\Claude\claude_desktop_config.json):
{
"mcpServers": {
"fhir": {
"command": "uvx",
"args": ["mcp-fhir"],
"env": {
"FHIR_BASE_URL": "https://hapi.fhir.org/baseR4"
}
},
"terminology": {
"command": "uvx",
"args": ["mcp-terminology"]
},
"clinical-reasoner": {
"command": "uvx",
"args": ["mcp-clinical-reasoner"]
}
}
}# Start HAPI FHIR + validator + Postgres
docker compose up hapi-fhir hapi-validator postgres
# Install workspace
uv sync
# Run unit tests
uv run pytest -m "not integration and not eval"
# Run mcp-fhir locally (stdio, points at local HAPI)
FHIR_BASE_URL=http://localhost:8081/fhir \
HAPI_VALIDATOR_URL=http://localhost:8082 \
uv run mcp-fhirfhir-mcp-suite/
├── packages/
│ ├── mcp-fhir/ # PyPI: mcp-fhir ✅ v1.1
│ ├── mcp-terminology/ # PyPI: mcp-terminology ✅ v1.0
│ └── mcp-clinical-reasoner/ # PyPI: mcp-clinical-reasoner ✅ v1.0
├── shared/ # structlog, LangFuse, base Pydantic models, eval harness
├── evals/ # golden query sets per server
├── docs/ # MkDocs Material site
├── .github/workflows/ # ci.yml (matrix) + release.yml (per-package PyPI on tag)
├── docker-compose.yml # all 3 + HAPI validator + Postgres
├── pyproject.toml # uv workspace root
└── mkdocs.ymlPackage | Version | Released |
| v1.1 | June 2026 |
| v1.0 | June 2026 |
| v1.0 | June 2026 |
See CONTRIBUTING.md. Apache-2.0 licensed — PRs welcome.
Retrieve a summary of the FHIR server's CapabilityStatement: FHIR version, software, supported resource types, and available search parameters. Call this first to understand what the server supports.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description fully discloses behavior: it retrieves a read-only summary of the CapabilityStatement. It does not mention side effects, which are absent, and states it should be called first, implying safety.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two efficient sentences that front-load the purpose and include a usage directive. Every sentence adds value with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (no parameters, no output schema), the description fully covers what it does and when to use it. Sibling tools are contextually present but not detailed, which is appropriate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist, so baseline 4 applies. The description does not need to add parameter meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Retrieve' and the resource 'FHIR server's CapabilityStatement' along with specific contents (version, software, resource types, search parameters). It differentiates from siblings which are for reading, searching, and validation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'Call this first to understand what the server supports,' providing clear when-to-use guidance. It omits explicit when-not-to-use statements, but the context suffices.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read a single FHIR R4 resource by type and logical ID. Returns the full resource JSON.
| Name | Required | Description | Default |
|---|---|---|---|
| resource_type | Yes | FHIR resource type, e.g. 'Patient', 'Observation'. | |
| resource_id | Yes | Server-assigned logical ID. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so description carries full burden. It states it returns full JSON but omits details like error handling (e.g., missing resource) or authorization requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two efficient sentences with no fluff. Front-loaded with action and scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequate for a simple read operation with full schema coverage. Could mention behavior on not found, but not critical given simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 100% description coverage for both parameters, but descriptions are minimal. Overall description adds little beyond schema (reiterates 'by type and logical ID'). Baseline 3 appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it reads a single FHIR R4 resource by type and ID and returns full JSON. Verb 'Read' and resource specification distinguish it from siblings (search, capabilities, validate).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implies use when reading individual resources by type+ID, but does not explicitly mention alternatives like fhir_search for multiple resources or fhir_capabilities for metadata.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search a FHIR R4 resource type. Returns a FHIR Bundle (searchset) with matching entries.
| Name | Required | Description | Default |
|---|---|---|---|
| resource_type | Yes | FHIR resource type to search. | |
| params | No | FHIR search parameters as key-value pairs, e.g. {'family': 'Smith', 'gender': 'female'}. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description alone must disclose behavioral traits. It only states the return type but omits whether the operation is read-only, what happens on no results, rate limits, or authentication requirements. This is insufficient for a search operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with two short sentences. Every word is necessary and front-loaded. No redundant or vague language.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no annotations, the description could have provided more context about return values (e.g., bundle structure) or usage examples. However, the schema is rich and fully covers parameters, partially compensating. The description is minimally complete for a straightforward search tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The tool description adds no extra meaning beyond the schema—it does not explain the 'params' object format or provide examples. The description is adequate but does not enhance parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Search a FHIR R4 resource type' with a specific verb and resource. It also specifies the return type as 'FHIR Bundle (searchset)'. This distinguishes it from sibling tools like fhir_read (single resource) and fhir_search_next (pagination).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like fhir_read or fhir_search_next. It fails to mention use cases, exclusions, or prerequisites such as required authentication or server capabilities.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Follow a Bundle pagination link returned by fhir_search. Pass the '_next_url' value from the previous search result. Returns the next page as a FHIR Bundle, again with '_next_url' if more pages exist.
| Name | Required | Description | Default |
|---|---|---|---|
| next_url | Yes | The '_next_url' from a previous fhir_search Bundle. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It states the return type (FHIR Bundle) and the presence of '_next_url' for further pages, but omits other behavioral traits like read-only nature or potential errors. However, the behavior is straightforward for a pagination tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very concise: two sentences that front-load the action and provide essential details without any fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one required parameter, no output schema, no nested objects), the description covers all necessary aspects: input, behavior, and output format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single parameter 'next_url' is fully described in the schema (100% coverage). The description adds value by clarifying its origin ('from a previous fhir_search Bundle'), but this is largely redundant with the schema description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool's purpose: following a Bundle pagination link returned by fhir_search. It distinguishes itself from siblings like fhir_search and fhir_read by focusing on pagination.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description specifies when to use the tool (after a previous fhir_search result) and what input to provide ('_next_url'). It implicitly excludes use without a prior search, but does not explicitly state when not to use or list alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Validate a FHIR R4 resource against a StructureDefinition profile using the HAPI validator. Supports US Core and IPS profiles as well as base FHIR R4 conformance. Returns conformance status, error count, and issue details.
| Name | Required | Description | Default |
|---|---|---|---|
| resource | Yes | A FHIR resource as a JSON object (or a JSON string that will be parsed). | |
| profile | No | Profile URL or alias (e.g. 'us-core-patient', 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient'). Empty string = base R4 validation only. | |
| fhir_version | No | FHIR version (default '4.0.1'). | 4.0.1 |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and adequately discloses that it validates using a specific validator, returns conformance status, error count, and issue details, which informs the agent about the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences, front-loaded with the primary action, and no unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description adequately explains the return value (conformance status, error count, issue details), and covers the purpose for all parameters. The tool is fully described for an agent to use correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description adds value by specifying supported profiles (US Core, IPS) and the return information, which goes beyond the parameter descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool validates a FHIR R4 resource against a StructureDefinition profile using the HAPI validator, and distinguishes from sibling tools (fhir_capabilities, fhir_read, etc.) which handle other operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool (for validation against US Core, IPS, or base FHIR profiles), but does not explicitly state when not to use it or mention alternatives beyond the sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
fhir_capabilitiesfhir_readfhir_searchfhir_search_nextvalidate_against_profileScored across 5 tools
Each tool serves a unique and clearly distinct purpose: capabilities for metadata, read for single resource retrieval, search for querying, search_next for pagination, and validate for conformance checking. There is no overlap or ambiguity between them.
All tool names follow a consistent verb_noun pattern with lowercase and underscores (e.g., fhir_read, fhir_search). The 'fhir_' prefix is used uniformly, and each name clearly describes the action and domain.
With 5 tools, the set is appropriately scoped for a focused FHIR read/search/validation suite. It is not excessive, and each tool provides essential functionality. A slightly higher count could cover write operations, but the current number is reasonable.
The tool set covers capabilities, read, search, pagination, and validation, but lacks write operations (create, update, delete), history, and transaction support. For a full FHIR interaction, these missing operations are notable gaps, though the validation focus partially justifies the omission.
MCP gateway federating 22 biomedical MCP servers behind one endpoint: gnomAD, ClinVar, HPO, VEP.
Auditable MCP server for PubMed, Europe PMC, ClinicalTrials.gov, and bioRxiv/medRxiv queries
Hosted MCP server for the Healthie EHR & telehealth API: patients, appointments, charting, tasks.
Privacy-preserving synthetic health data generation. FHIR R4/R5 compliant.
