Azure FHIR logo

Azure FHIR

Community
erikhoward

Azure AHDS FHIR MCP Server

Publishererikhoward
Repositoryazure-fhir-mcp-server
LanguagePython
Forks
9
Stars
18
Available tools
0
Transport typestdio
Categories
LicenseMIT
Links
  • Connect tools to AI workflows

    Azure FHIR exposes MCP capabilities that can be used by compatible AI clients and agents.

  • 0 available tools

    Browse the callable actions below, including names and descriptions when provided by the server.

  • Ready-to-copy setup

    Use the installation snippets to configure this server in your preferred MCP client.

  • Open source signals

    18 stars and 9 forks from the linked repository.

Azure AHDS FHIR MCP Server 🚀

A Model Context Protocol (MCP) server implementation for Azure Health Data Services FHIR (Fast Healthcare Interoperability Resources). This service provides a standardized interface for interacting with Azure FHIR servers, enabling healthcare data operations through MCP tools.

License Python Version MCP

Setup 🛠️

Installation 📦

Requires Python 3.13 or higher and uv.

Install uv first.

Configuration ⚙️

See the FastMCP guidance on mcp.json here: https://gofastmcp.com/integrations/mcp-json-configuration

Client Credentials Flow (default):

  • Used for service-to-service authentication
  • Leave USE_FAST_MCP_OAUTH_PROXY=false
  • Keep HTTP_TRANSPORT=false to use stdio transport
  • Uses Azure AD client credentials flow
json
{
    "mcpServers": {
        "fhir": {
            "type": "stdio",
            "command": "uvx",
            "args": [
                "azure-fhir-mcp-server"
            ],
            "env": {
                "fhirUrl": "https://your-fhir-server.azurehealthcareapis.com/fhir",
                "clientId": "your-client-id",
                "clientSecret": "your-client-secret",
                "tenantId": "your-tenant-id"
            }
        }
    }
}

OAuth On-Behalf-Of Flow:

Create the Azure App Registration

The OAuth on-behalf-of flow requires a confidential Azure AD application that represents the MCP server.

  1. In the Azure portal, go to Microsoft Entra ID ➜ App registrations ➜ New registration. Give it a descriptive name such as FHIR-MCP-Server, set Supported account types to Single tenant, and leave the redirect URI unset for now.
  2. After the app is created, capture the generated Application (client) ID and Directory (tenant) ID for later use.
  3. Under Expose an API, select Set for the Application ID URI and accept the suggested value api://{appId}. Add a scope named user_impersonation with admin consent display/description also set to user_impersonation.
  4. Under Certificates & secrets, create a New client secret (for example FHIR-MCP-Secret-New). Copy the secret value immediately; it is required for the MCP server clientSecret setting.
  5. Under Authentication, add the following Web redirect URIs to support the FastMCP OAuth proxy:
    • http://localhost:9002/auth/callback Ensure Default client type remains No so the app stays confidential.
  6. Under API permissions, choose Add a permission ➜ APIs my organization uses, search for your Azure Health Data Services FHIR server, and add the delegated scopes required for your scenario. Grant admin consent so the FastMCP proxy can request tokens without an interactive prompt.
  • Environment variables:

    • Set USE_FAST_MCP_OAUTH_PROXY=true
    • Requires HTTP_TRANSPORT=true
  • Start the MCP server with:

bash
uv pip install -e .
uv run --env-file .env azure-fhir-mcp-server
  • Update mcp.json:
json
{
    "mcpServers": {
        "fhir": {
            "type": "http",
            "url": "http://localhost:9002/mcp"
        }
    }
}

The following is a table of available environment configuration variables:

VariableDescriptionDefaultRequired
fhirUrlAzure FHIR server base URL (include /fhir)-Yes
clientIdAzure App registration client ID-Yes
clientSecretAzure App registration client secret-Yes
tenantIdAzure AD tenant ID-Yes
USE_FAST_MCP_OAUTH_PROXYEnable FastMCP Azure OAuth proxy integrationfalseNo
HTTP_TRANSPORTRun the MCP server over HTTP transport (required for OAuth proxy)falseNo
FASTMCP_HTTP_PORTPort exposed when HTTP_TRANSPORT=true9002No
FHIR_SCOPEOverride FHIR audience scope for the OBO flow (space-separated){fhirUrl}/.defaultNo
FASTMCP_SERVER_AUTH_AZURE_BASE_URLPublic base URL of your FastMCP serverhttp://localhost:9002No
FASTMCP_SERVER_AUTH_AZURE_REDIRECT_PATHOAuth callback path appended to the base URL/auth/callbackNo
FASTMCP_SERVER_AUTH_AZURE_IDENTIFIER_URIAzure App registration Application ID URIapi://{clientId}No
FASTMCP_SERVER_AUTH_AZURE_REQUIRED_SCOPESSpace-separated scopes requested by the Azure provideruser_impersonationNo
FASTMCP_SERVER_AUTH_AZURE_ADDITIONAL_AUTHORIZE_SCOPESOptional space-separated scopes added to the authorize request-No
LOG_LEVELLogging levelINFONo

Available Tools 🔧

FHIR Resource Operations

  • search_fhir - Search for FHIR resources based on a dictionary of search parameters
  • get_user_info - (OAuth only) Returns information about the authenticated Azure user

Resource Access

The server provides access to all standard FHIR resources through the MCP resource protocol:

  • fhir://Patient/ - Access all Patient resources
  • fhir://Patient/{id} - Access a specific Patient resource
  • fhir://Observation/ - Access all Observation resources
  • fhir://Observation/{id} - Access a specific Observation resource
  • fhir://Medication/ - Access all Medication resources
  • fhir://Medication/{id} - Access a specific Medication resource
  • And many more...

Development 💻

Local Development Setup

1 - Clone the repository:

bash
git clone https://github.com/erikhoward/azure-fhir-mcp-server.git
cd azure-fhir-mcp-server

2 - Create and activate virtual environment:

Linux/macOS:

bash
python -m venv .venv
source .venv/bin/activate

Windows:

bash
python -m venv .venv
.venv\Scripts\activate

3 - Install dependencies:

bash
pip install -e ".[dev]"

4 - Copy and configure environment variables:

bash
cp .env.example .env

Edit .env with your settings:

env
fhirUrl=https://your-fhir-server.azurehealthcareapis.com/fhir
clientId=your-client-id
clientSecret=your-client-secret
tenantId=your-tenant-id

5 - Claude Desktop Configuration

Open claude_desktop_config.json and add the following configuration.

On MacOs, the file is located here: ~/Library/Application Support/Claude Desktop/claude_desktop_config.json.

On Windows, the file is located here: %APPDATA%\Claude Desktop\claude_desktop_config.json.

json
{
    "mcpServers": {
        "fhir": {
            "command": "uv",
            "args": [
                "--directory",
                "/path/to/azure-fhir-mcp-server/repo",
                "run",
                "azure_fhir_mcp_server"
            ],
            "env": {
                "LOG_LEVEL": "DEBUG",
                "fhirUrl": "https://your-fhir-server.azurehealthcareapis.com/fhir",
                "clientId": "your-client-id",
                "clientSecret": "your-client-secret",
                "tenantId": "your-tenant-id"
            }
        }
    }
}

6 - Restart Claude Desktop.

Running Tests

bash
# Run all tests
python -m pytest tests/ -v

# Run with coverage
pytest tests/ --cov=src/azure_fhir_mcp_server

# Run specific test
pytest tests/test_fastmcp_metadata.py::TestFastMCPMetadata::test_fastmcp_server_discovery -v

# Run with detailed output
pytest tests/test_fastmcp_metadata.py::TestFastMCPMetadata::test_output_detailed_metadata -v -s

Contributions 🤝

Contributions are welcome! Please feel free to submit a Pull Request.

  1. Fork the repository
  2. Create your feature branch (git checkout -b feature/AmazingFeature)
  3. Commit your changes (git commit -m '✨ Add some AmazingFeature')
  4. Push to the branch (git push origin feature/AmazingFeature)
  5. Open a Pull Request

License ⚖️

Licensed under MIT - see LICENSE.md file.

This is not an official Microsoft or Azure product.

Installation

TypingMind
Prerequisites:

Node.js 18+

{
  "mcpServers": {
    "fhir": {
      "command": "uvx",
      "args": [
        "azure-fhir-mcp-server"
      ],
      "env": {
        "LOG_LEVEL": "INFO",
        "fhirUrl": "https://your-fhir-server.azurehealthcareapis.com/fhir",
        "clientId": "your-client-id",
        "clientSecret": "your-client-secret",
        "tenantId": "your-tenant-id"
      }
    }
  }
}

Use Azure FHIR MCP with multiple AI models

TypingMind connects MCP tools at the workspace level, so once Azure FHIR is connected, you can use it with different AI models in TypingMind instead of setting it up separately for each model. This MCP runs locally through the TypingMind MCP connector on your device.

Setup guide to use the local connector

Use this when the MCP server needs access to local files, apps, or private resources on your computer.

1

Open the MCP settings

In TypingMind, go to Settings, Advanced Settings, then Model Context Protocol and choose Setup Connector.

  1. Open TypingMind in your browser.
  2. Click the Settings icon.
  3. Go to Advanced Settings.
  4. Open the Model Context Protocol section.
  5. Click Setup Connector and choose This Device.
TypingMind MCP connector setup screen with This Device selected
2

Run the connector command

Choose This Device, copy the command from TypingMind, and run it in Terminal. Keep the process running while you use MCP.

  1. Copy the setup command shown by TypingMind.
  2. Open Terminal on macOS or Windows Terminal on Windows.
  3. Paste and run the command.
  4. Approve the package install if Terminal asks you to proceed.
  5. Keep the Terminal window running while using MCP tools.
3

Add Azure FHIR as a server

When the connector status is Ready, click Edit Servers and paste the MCP server configuration.

  1. Wait until the connector status shows Ready.
  2. Click Edit Servers.
  3. Paste the Azure FHIR MCP server configuration.
  4. Save the server list.
  5. Refresh if you want to confirm the connector is still ready.
TypingMind MCP settings showing active server and Edit Servers button
{
  "mcpServers": {
    "azure-fhir": {
      "command": "npx",
      "args": [
        "-y",
        "azure-fhir-mcp-server"
      ]
    }
  }
}
4

Use it across models

Save the server list, open Plugins, enable the Azure FHIR MCP tools, then select any supported AI model in TypingMind and use the tools in chat or assign them to an AI agent.

  1. Open the Plugins page in TypingMind.
  2. Enable the Azure FHIR MCP tools.
  3. Start a chat and choose the AI model you want to use.
  4. Use the MCP tools in chat or assign them to an AI agent.
  5. Switch to another AI model whenever needed without reconnecting MCP.
TypingMind chat using enabled MCP tools with a selected AI model
Can you use Azure FHIR to help me with this task?
Azure FHIR
Sure. I read it.
Here is what I found using Azure FHIR.

Frequently asked questions

What is the Azure FHIR MCP server used for?

Azure FHIR is an MCP server that lets compatible AI clients connect to external tools and context. In TypingMind, you can add this MCP server once and make its tools available in your AI workspace.

Can I use Azure FHIR MCP with multiple AI models in TypingMind?

Yes. TypingMind connects MCP tools at the workspace level, so you can use Azure FHIR with different AI models such as Claude, ChatGPT, Gemini, or other models you have configured in TypingMind without setting up the MCP server separately for each model.

Why use Azure FHIR MCP with TypingMind?

TypingMind is one of the best frontends for LLM chat because it brings multiple AI models, prompts, plugins, AI agents, API keys, and MCP tools into one workspace. With Azure FHIR connected, you can use its MCP tools across your preferred models while keeping your chat workflow organized in TypingMind.

How do I connect Azure FHIR MCP to TypingMind?

Azure FHIR runs through the TypingMind local MCP connector. This is best when the MCP server needs access to local files, desktop apps, command-line tools, or private resources on your computer.

What tools does Azure FHIR MCP provide in TypingMind?

Azure FHIR exposes MCP capabilities that can be enabled from the TypingMind Plugins page and used in chat or assigned to AI agents.

Do I need to share my API keys with TypingMind to use Azure FHIR MCP?

No. TypingMind is local-first and lets you keep your model providers, API keys, prompts, and MCP configuration under your control. If Azure FHIR requires authentication, add the required headers, OAuth settings, or local configuration for that MCP server when you create the connection.

Related MCP Servers

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇