the-momentum Apple Health MCP Server vs MetricBridge: DuckDB vs Zero-Dependency Showdown

You want your agent answering from your real Apple Health data, not a stale file. Two MCP servers get you there by very different routes. One (281 ★ on GitHub, read 27 October 2026) needs Docker or uv, Python, a database backend and a manual XML export from your iPhone. The other is zero-dependency Node.js with a companion iOS app that syncs by itself. Here is how they compare, with the facts dated.

By MetricBridge · Published 3 August 2026 · Updated 27 October 2026 · ~10 min read

AI-assisted, human reviewed. How we use AI

Disclosure. MetricBridge makes one of the products compared. Third-party facts come from their own pages and repositories, read on 27 October 2026.

Quick answer: which Apple Health MCP server should you use?

If you want the least friction and you own an iPhone, use health-export-mcp. Install the companion iOS app, it syncs your 194 HealthKit metrics as clean JSON automatically. Point the MCP server at that folder. Done. No Docker, no Python, no DuckDB, no manual XML export.

If you already run DuckDB for data analysis, or you don't own an iPhone, the-momentum works. It parses Apple's raw export.xml into DuckDB tables (Elasticsearch and ClickHouse are also supported backends), which is useful if you want to write SQL against your health data or already run one of those stores. But the setup cost is higher: you must manually export the XML from your iPhone, transfer it, install Docker (or uv), configure environment variables, and run the Python server.

Note: As of mid-2026, the-momentum's Apple Health MCP Server has evolved into Open Wearables, a self-hosted platform unifying data from multiple wearable brands (Garmin, Polar, Whoop). The original Apple-Health-only server still works; its last commit was on 9 July 2026 and its README points to Open Wearables (read 27 October 2026). MetricBridge's MCP server remains focused on Apple Health, with the server and the companion iOS app both under active development.

Side-by-side comparison

the-momentum

  • 281 ★ on GitHub (read 27 October 2026)
  • Requires Docker or uv
  • Python runtime
  • DuckDB, Elasticsearch or ClickHouse backend
  • Manual export.xml from iPhone
  • ~15 min setup in our run
  • Fixed tools: summary, search, statistics, trend, values
  • Evolving into Open Wearables
  • No companion iOS app
  • No on-device AI

health-export-mcp ✓

  • Zero npm dependencies
  • Pure Node.js, no Docker
  • No Python, no DuckDB
  • Reads clean JSON, not raw XML
  • Auto-sync from iOS companion app
  • ~2 min setup (first time)
  • 16 purpose-built MCP tools
  • Focused on Apple Health
  • Paired with on-device AI app
  • Full provenance on every answer

Setup: 2 minutes vs 15 minutes

The difference in setup time isn't small. It's the difference between trying something and setting up a project.

Setting up health-export-mcp

  1. Install MetricBridge on iOS. Grant Apple Health read access.
  2. Turn on export to iCloud Drive. The app syncs your data automatically: no buttons to press.
  3. Install the MCP server from npm: npx -y health-export-mcp
  4. Add the config to your MCP client. One JSON block.

That's it. The iOS app handles the complex part: reading HealthKit, structuring 194 metrics with units and metadata, and writing a compact JSON cache. The MCP server just reads that cache. No import step, no format conversion, no XML parsing.

Setting up the-momentum

  1. On your iPhone, go to Settings → Privacy → Health → Export All Health Data. Wait for the export to generate. The resulting export.xml can be 500 MB to 2+ GB.
  2. Transfer that file to your computer (AirDrop, iCloud, USB cable, all manual steps).
  3. Clone the repo: git clone https://github.com/the-momentum/apple-health-mcp-server
  4. Install Docker, or install uv and configure a Python environment.
  5. Run the import, which parses the XML into the backend database (DuckDB by default in the local setup).
  6. Configure environment variables in config/.env.
  7. Start the server from your MCP client config, with docker run or uv run. It speaks MCP over stdio.

Each step is documented and straightforward on its own. But the total friction adds up, and you need to repeat steps 1-2 every time you want fresh data.

Data model: parsed XML vs native HealthKit JSON

This is the deeper architectural difference.

the-momentum parses Apple's raw export.xml into DuckDB tables. The XML format is Apple's internal HealthKit serialization: it uses Apple's HKObjectType identifiers (e.g., HKQuantityTypeIdentifierHeartRateVariabilitySDNN), has nested <Record> and <MetadataEntry> elements, and is not designed for direct consumption. DuckDB gives you SQL access to the parsed data, which is useful if you know what you're looking for. But the parsing step is heavy, and the raw XML can be 1-2 GB, so the import takes time.

health-export-mcp reads a JSON file written by the companion iOS app. The app reads HealthKit through Apple's native Swift APIs and writes structured JSON with metric names, values, units, dates, and metadata already cleanly organized. The server doesn't parse anything: it serves pre-structured data. The cache file is typically 2-5 MB (vs 500 MB+ for the raw XML) because it stores aggregates and daily summaries, not every individual HealthKit sample.

This also means the-momentum requires you to manually re-export and re-import for fresh data. health-export-mcp just reads whatever the iOS app has written, which refreshes in the background roughly hourly when iOS allows it (the app asks for that cadence; iOS decides the actual timing).

Tools and query interface

the-momentum exposes a fixed set of tools: three for the XML import, then five per backend (a health summary, record search, statistics by type, trend data and value search). The agent picks the tool; there is no English-to-SQL step inside the server (its docs, read 27 October 2026). Raw SQL stays available if you open the database yourself. Earlier versions of this post described an NL-to-SQL tool; that was wrong.

health-export-mcp exposes twenty-two deterministic tools that agents call directly, twenty of them read-only, including:

  • get_mcp_status: confirms connectivity
  • get_freshness: says how current the export is, against a stated staleness threshold
  • list_metrics: lists available metrics with metadata
  • get_health_metrics: pulls raw values for a metric + date range
  • get_trends: computes week-over-week or month-over-month trends
  • compare_periods: A/B two time windows with statistics
  • get_structured_export: tidy bundle for deeper analysis
  • query_health_data: flexible plain-language queries
  • resolve_metric: maps any metric spelling or alias to one canonical name and unit

Because the tools are deterministic, agents can chain them predictably. An agent knows get_trends returns a trend with mean, direction, and variance for a specific metric and period. It can call compare_periods to benchmark against the previous period. The results are type-safe and structured.

Privacy model comparison

Both servers are local-first: they run on your own machine and read data from your own disk. Neither sends data to a cloud. But there are differences:

  • the-momentum is fully open-source under MIT. The server runs locally. However, the manual export-transfer-import loop means your raw XML (containing every HealthKit sample you've ever recorded) lives in multiple locations during the transfer process.
  • health-export-mcp is also MIT open-source and runs locally. The iOS app reads HealthKit read-only (never modifies it). The JSON cache can go to iCloud Drive, a local folder, or a webhook: you control the destination. The server itself makes no outbound network calls: no telemetry, no analytics, no phone-home.

Both are privacy-respecting. The practical difference is that health-export-mcp eliminates the manual file transfer step: your data goes from iPhone to iCloud to your Mac via the OS sync layer, with no manual copy involved.

Who should use which?

Choose the-momentum if:

  • You already use DuckDB and prefer SQL-based data exploration
  • You don't own an iPhone (the server can work with any XML export)
  • You want SQL over the parsed tables, or an Elasticsearch or ClickHouse backend
  • You're interested in Open Wearables' multi-brand wearable data platform

Choose health-export-mcp if:

  • You own an iPhone and want the least-friction setup
  • You want auto-syncing data without manual exports
  • You prefer tools that return trends and comparisons already computed
  • You want the companion on-device AI app for iPhone (Ask + Weekly Brief)
  • You want zero dependencies: just Node.js

The bottom line

the-momentum's Apple Health MCP Server is a solid project: 281 stars is earned, not bought. Where it is stronger: full SQL over every raw HealthKit sample, a choice of three database backends, and no iPhone app required. The team's move to Open Wearables shows they're thinking bigger.

But for the specific use case of getting Apple Health data into your AI agent with minimal friction, health-export-mcp wins on every practical dimension: setup time, dependency footprint, data freshness, and companion app integration. One iOS app install, one sync, one MCP config block. Your agent has access to your live health data in under two minutes.

For the full setup, see the MCP server documentation or the Claude MCP setup guide. The full list of 194 metrics shows what the JSON covers, and on-device AI explains how the companion app answers questions without the export.

Try the zero-dependency Apple Health MCP server

194 Apple Health metrics as clean JSON. Twenty-two deterministic MCP tools, twenty of them read-only. Companion iOS app with auto-sync. No Docker, no DuckDB, no manual exports.

Download on the App Store Read the MCP docs → View on GitHub

Nothing reaches us: the app writes JSON to a folder you pick, and the server reads that folder. 194 metrics, 22 tools (20 read-only), 23 prompts. About two minutes to set up. $24.99 one time after a 7-day free trial, not a subscription. Works on any iPhone; Apple Intelligence is not needed for the export or MCP.

Frequently asked questions

What is the-momentum Apple Health MCP Server?

The-momentum Apple Health MCP Server is an open-source MCP server by the-momentum.ai that parses Apple Health's export.xml into DuckDB and exposes it via MCP tools. It requires Docker or uv for dependencies, Python for the server runtime, and a manual XML export from your iPhone. DuckDB is one of three storage backends it supports, with Elasticsearch and ClickHouse. It had 281 GitHub stars on 27 October 2026.

What is health-export-mcp?

health-export-mcp is an open-source, zero-dependency MCP server by MetricBridge. It reads a JSON file written by the companion iOS app (MetricBridge). No Docker, no Python, no manual XML export. Just Node.js and a folder path. It ships 22 tools (20 read-only) and pairs with an on-device health AI app for iPhone.

Which Apple Health MCP server is easier to set up?

health-export-mcp is significantly easier. You install the iOS app (auto-syncs to iCloud), then point the MCP server at that folder. No Docker, no Python, no XML export, no environment configuration. The-momentum requires cloning a repo, installing Docker/uv, manually exporting export.xml from your iPhone, transferring it to your computer, and configuring environment variables.

Can I use both servers together?

Yes. They use different data sources (health-export-mcp reads JSON, the-momentum reads a database built from parsed XML), and both speak MCP over stdio, so there is no port to collide. Add both to your client config under different names. They don't conflict.

Which server has more tools?

health-export-mcp ships 22 tools (20 read-only) and 23 prompts. the-momentum ships three XML tools plus five query tools per backend (summary, search, statistics, trend, values). Counting is less useful than fit: the-momentum gives you the raw samples in a database you can query; health-export-mcp returns trends and period comparisons already computed, with units and dates attached.

Related reading