DEV Community: Adrian Kereky

We loaded Synthea patients into a FHIR server: 182 of 221 resources made it

Adrian Kereky — Tue, 13 Oct 2026 17:22:23 +0000

Synthea (MITRE's open-source patient simulator) is the default source of synthetic FHIR data. We generated two patients (java -jar synthea-with-dependencies.jar -p 2 -s 4242 Massachusetts) and loaded them into Anpheros, the FHIR backend I work on. The first bundle had 221 entries.

What did not fit: 39 entries of types the server does not store — Claim (13), ExplanationOfBenefit (13), SupplyDelivery (9), Device (2), ImagingStudy (1), MedicationRequest (1). Synthea models US billing in detail; a clinical record usually doesn't need it.

The loader asks the server which types it supports and posts the rest as one transaction:

import { readFile } from 'node:fs/promises';
import { Anpheros, apiKey } from '@anpheros/sdk';

const anpheros = new Anpheros({ auth: apiKey(process.env.ANPHEROS_KEY!) });   // a sandbox key, sk_test_…
const SUPPORTED = new Set(((await anpheros.fhir.metadata()) as any).rest[0].resource.map((r: any) => r.type));
const bundle = JSON.parse(await readFile(process.argv[2], 'utf8'));            // one Synthea patient file
const kept = bundle.entry.filter((e: any) => SUPPORTED.has(e.resource.resourceType));
const out: any = await anpheros.fhir.transaction({ ...bundle, entry: kept } as any);
console.log('created', out.entry.length);

182 resources were created in one transaction, urn:uuid references resolved, and the patient's International Patient Summary came out with 15 problems, 6 immunizations, 15 results and 28 vital signs.

Three things to watch if you do the same with any server:

Conditional references. Synthea points to practitioners and organisations as Practitioner?identifier=…. Servers differ: ours stored them as written and did not resolve them. Check yours before following those links.
Removed is not converted. Dropping MedicationRequest means the medication disappears. Convert it to MedicationStatement first if you need it.
Names with numbers (Marcelo725 Gulgowski816) are deliberate, so no one mistakes synthetic people for real ones.

Full guide, including when to use Synthea vs hand-made personas and what good test data must contain: Synthetic patient data for testing.

Mapping an HL7 v2 lab result to a FHIR Observation (and the traps that create duplicates)

Adrian Kereky — Tue, 13 Oct 2026 17:21:19 +0000

Most labs still send results as HL7 v2 ORU^R01 messages. Most new apps want FHIR. The mapping looks trivial:

OBX|1|NM|2093-3^Cholesterol^LN||212|mg/dL|<200|H|||F|||20261002074500

OBX field	FHIR R4 Observation
OBX-3 `2093-3^Cholesterol^LN`	`code.coding` (LOINC)
OBX-5 + OBX-6	`valueQuantity`
OBX-7 `<200`	`referenceRange.high`
OBX-8 `H`	`interpretation`
OBX-11 `F`	`status = final`
OBX-14	`effectiveDateTime`

The field mapping is the easy 20%. The 80% that breaks production:

Time zones. 20261002074500 has no offset. FHIR requires one whenever a time is present. Decide the sender's zone explicitly; don't let a library guess.
Local codes. Many labs put their own code in OBX-3. Keep it next to the LOINC code you map to, never drop it.
Resends. v2 senders retransmit on timeouts. Without a stable identifier per result (report id + code + time + value), your FHIR store fills with duplicates.
Corrections. OBX-11 C means corrected. Decide whether a correction updates the earlier Observation (keeping history) or arrives as a new one, and mark the old one entered-in-error if so.
Values that are not numbers. <5, 6,4, positive: parse them deliberately, or store them as valueString rather than inventing a number.

All five are cases the lab import of Anpheros (I work on it) has to handle. The full write-up, with a real import response and the FHIR Observation it produced, is here: Lab results API: HL7 v2, FHIR and LOINC.

If you want to check a translated Observation quickly, there is a free FHIR R4 validator that lists every structural error with its path (it does not check terminology; use the official HL7 validator for full conformance).

Giving an LLM a patient's record without dumping the whole FHIR bundle

Adrian Kereky — Mon, 12 Oct 2026 20:15:50 +0000

Disclosure: I work on Anpheros, the platform used in the examples. The approach (budgeted, provenance-labelled context) applies to any FHIR backend.

If you have ever pushed a FHIR $everything Bundle into a prompt, you know the problem: a few months of vitals is already thousands of Observations. Most of it is irrelevant to the question, all of it costs tokens, and the model has no way to tell a lab-measured value from one the patient typed in or one an earlier AI step guessed.

Three things matter when a model reads a medical record:

Relevance. A medication review before a cardiology visit needs blood pressure trends, current medications and a few labs, not every step count.
A budget. You decide how many tokens the record may take, and you want to know what was left out.
Provenance. Each fact should carry who wrote it (device, practitioner, patient, import, AI) and from where. AI-generated values should never be mixed with measured ones.

Doing it by hand

On a plain FHIR server you would: search Observations by LOINC code and date, compute weekly trends, pull active MedicationStatements and Conditions, look up each resource's Provenance, rank, trim to a token count, and keep a list of what you dropped. It is all doable, and it is a week of work you will redo for every new question type.

Asking the backend for a context instead

Anpheros exposes this as one call. Get a free sandbox key (sign in with Google at platform.anpheros.com/dashboard → Get a sandbox key); every sandbox project comes with 30 synthetic patients with six months of history.

npm install @anpheros/sdk
export ANPHEROS_KEY=sk_test_...

import { Anpheros, apiKey } from '@anpheros/sdk';

const anpheros = new Anpheros({ auth: apiKey(process.env.ANPHEROS_KEY!) });

const { data: patients } = await anpheros.patients.list();
const patient = patients[0];

// Raw data is still there when you need it
const labs = await anpheros.observations.list(patient.id, { category: 'laboratory', limit: 10 });

// A budgeted context for a specific task
const ctx = await anpheros.context.build({
  patient: patient.id,
  task: 'weekly check-in',
  budget_tokens: 1500,
  format: 'text',
});

The same call over HTTP:

curl -X POST "https://platform.anpheros.com/v1/context" \
  -H "Authorization: Bearer $ANPHEROS_KEY" -H 'content-type: application/json' -d '{
  "patient": "'$PID'",
  "task": "medication review before a cardiology visit",
  "question": "How did blood pressure evolve over the last 3 months?",
  "budget_tokens": 1500,
  "format": "text"
}'

What comes back: sections (summary, conditions, medications, allergies, labs, vitals with weekly trends and before/after-treatment markers, symptoms, timeline, documents); every item labelled with author_type and source; a list of what was omitted to fit the budget; warnings; and a manifest_id that ties the call to the audit log, so you can later answer "what exactly did the model see?". Values produced by AI only appear under ai_notes.

You can also be explicit: "needs": ["labs:4548-4", "vitals:trend:85354-9", "timeline:180d"] (HbA1c, blood pressure trend, last 180 days).

Writing back, honestly

Every write says who produced the value. A reading from a glucometer:

curl -X POST "https://platform.anpheros.com/v1/patients/$PID/observations" \
  -H "Authorization: Bearer $ANPHEROS_KEY" -H 'content-type: application/json' \
  -H "Idempotency-Key: $(uuidgen)" -d '{
  "code": "2339-0", "display": "Glucose", "category": "laboratory",
  "value": 112, "unit": "mg/dL", "effective_at": "2026-09-19T08:10:00Z",
  "author_type": "device"
}'

A value your model produced goes in with "author_type": "ai". If you omit the field, it defaults to import, never patient. Every write creates a FHIR Provenance, and /fhir/R4/Observation/{id}/_history keeps prior versions.

Real patients need consent, not keys

API keys only see your own project's patients (its sandbox copies and the ones it created). To read a person's existing record you go through OAuth 2.1 + PKCE (SMART on FHIR standalone launch, SMART v2 scopes); the person picks what to share and for how long, and can revoke. Both SDKs implement the flow.

Limits worth knowing

Sandbox data is synthetic only. The platform is in private beta; EHR launch and Bulk Data are not supported. Anpheros does not run the model; you bring your own (hosted or local).