HealthGPT: an Apple Health chat app built on Stanford Spezi

What HealthGPT is and who it is for

HealthGPT is an experimental iOS app that lets a person ask questions about their own Apple Health data in plain language. The README describes it as an open-source project of the Stanford Biodesign Digital Health team, built on Stanford Spezi, and the repository is written in Swift with an MIT licence. It is not a consumer product with a support team behind it. It is a reference implementation: the README states it offers an easy-to-extend solution for those looking to make LLM-powered apps within the Apple Health ecosystem.

The audience follows from that. If you are an iOS developer who has been asked to put a chat interface on top of HealthKit, HealthGPT shows one way to wire the pieces together. If you are a researcher who needs a prototype that reads sleep, step count, active energy, exercise minutes, heart rate and body mass, the app supports those out of the box. If you are a clinician or a patient looking for something to install and trust, this is the wrong category of software, and the disclaimer in the README says so directly: it is for general informational purposes only, not a substitute for professional medical advice, and large language models are known to hallucinate.

The Spezi module chain behind a HealthGPT answer

The architecture is a composition of separate Spezi packages rather than one monolith. SpeziHealthKit handles the Apple Health integration, SpeziChat provides the chat interface with speech-to-text, text-to-speech and chat export, and SpeziLLM carries the model queries. The README names GPT-3.5 and GPT-4 as the cloud options and SpeziLLMLocal with Llama3 8B as the on-device option, where model files are downloaded and stored during onboarding.

A query flows through three files that the README points at explicitly. HealthGPTAppDelegate.swift holds the SpeziHealthKit configuration and decides which data types the app is allowed to read. HealthDataFetcher.swift builds the query for those types. PromptGenerator.swift assembles the retrieved samples into the prompt that goes to the model. That split is the useful part of the design: adding a new HealthKit quantity means touching all three, and the README walks through exactly that sequence. The cost is that the prompt construction is hand-written per data type, so the quality of an answer depends on how well PromptGenerator.swift framed the numbers, not on any general schema.

There is also a third execution path beyond device and cloud. The README describes a fog mode where inference runs on nearby machines in your local network, discovered over mDNS, with responses streamed back while inference tasks are dispatched. A minimal Docker-based fog node for Linux or macOS is documented in FogNode/README.md.

Installing HealthGPT and running a first query

There is no package manager step and no App Store listing. The README says building and running HealthGPT requires a Mac with Xcode 16.2 or newer. Clone the repository, open the project file, and let Xcode resolve dependencies before running.

git clone https://github.com/StanfordBDHG/HealthGPT.git
cd HealthGPT
open HealthGPT.xcodeproj

After the project opens, Xcode installs the Spezi dependencies and indexes them. Run the app on an iOS device or in the simulator. If you use the simulator, the README carries an important warning: you must add data manually in the Apple Health app, otherwise every result reads zero. That is the first thing most people get wrong.

There is a second constraint on the local model path. Running HealthGPT with a local LLM requires a physical device, because SpeziLLMLocal needs a modern Metal MTLGPUFamily and simulators do not provide it. So the simulator is fine for a cloud-model chat over hand-entered samples, and useless for testing Llama3 8B.

To add a HealthKit quantity the app does not cover, the README gives three steps. Update the SpeziHealthKit configuration in HealthGPT/HealthGPTAppDelegate.swift, edit HealthGPT/HealthGPT/HealthDataFetcher.swift to build the query, and update HealthGPT/HealthGPT/PromptGenerator.swift so the new data reaches the API. The README also points to a TestFlight link for people who want to try the app on a device without building it.

Where HealthGPT breaks down

The privacy model is the sharpest limitation, and the README states it without hedging: aggregated HealthKit data for the past 14 days will be uploaded to OpenAI, with a pointer to the OpenAI privacy policy. Local execution through SpeziLLMLocal avoids that upload, but it costs you the simulator workflow and requires hardware with a suitable Metal GPU family. The fog mode is a middle path, and it assumes you have machines on your network to run as nodes.

The second limitation is hallucination. The disclaimer says large language models such as those provided by OpenAI are known to hallucinate and at times return false information, and that use of HealthGPT is at your own risk. A chat interface makes this worse than a chart would, because a fluent sentence about a heart rate trend reads as authoritative even when the underlying retrieval was wrong.

The third is scope. Six data types are supported out of the box: sleep, step count, active energy, exercise minutes, heart rate and body mass. Anything else is your code, in three files, with no shared abstraction the README describes. And the project is explicitly experimental. The README calls it that in the first sentence, which tells you what kind of stability to expect from the API surface.

HealthGPT compared with a plain HealthKit dashboard

The obvious alternative is not another LLM app. It is a conventional HealthKit dashboard: query the same quantities with HKStatisticsQuery, draw them, and skip the model entirely. The difference in approach is where the interpretation happens. A dashboard puts the numbers in front of the user and lets them reason. HealthGPT puts the numbers into a prompt and lets the model phrase an answer, which is what makes questions like a summary of the last two weeks possible in one turn, and also what makes a wrong answer possible in one turn.

If your goal is a feature that answers free-form questions across several HealthKit types at once, the dashboard approach cannot do it without you writing a query language. If your goal is a reliable display of a single metric, HealthGPT adds a network call, a model dependency and a hallucination surface for something a chart does better. The fog mode is the interesting middle: it keeps the natural language interface while moving inference onto hardware you control, at the cost of running and discovering a node on your network.

Maintenance, releases and the MIT licence

The repository is not archived, and the last push was on 2026-07-14, which is the same date as the 0.5.1 release. That release followed 0.5.0 on 2025-09-26 and 0.4.1 on 2025-05-11, so the cadence has been roughly one minor or patch release every few months. Treat that as the real upgrade cost: HealthGPT sits on top of SpeziHealthKit, SpeziChat, SpeziLLM and SpeziLLMLocal, and a bump in any of those can move the configuration surface in HealthGPTAppDelegate.swift. The README's extension instructions name specific files, not stable protocols, so expect to re-read them after a dependency update.

The licence is MIT, which is permissive and places few conditions on reuse. The README also points to a LICENSES directory and the repository carries REUSE.toml and HealthGPT.xctestplan.license, so the project tracks per-file licensing metadata. That is a practical detail rather than a legal one: if you fork HealthGPT into a product, keep the SPDX headers intact and check the LICENSES directory for anything that is not MIT. Nothing here is legal advice, and the OpenAI terms are a separate agreement you accept by using cloud models.

Editorial conclusion

Adopt HealthGPT if you are an iOS developer who wants a working starting point for LLM features over HealthKit, or a researcher who needs a Spezi-based prototype rather than a product. Do not adopt it if you need a shipping medical app, if you cannot accept that cloud queries send 14 days of aggregated HealthKit data to OpenAI, or if your team has no Mac with Xcode 16.2. Before building on it, read HealthDataFetcher.swift and PromptGenerator.swift together: those two files define exactly which quantities reach the model and in what form, and they are the first things you will have to change.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. Releases
5. StanfordBDHG/HealthGPT on GitHub