Features

Open, code-first HL7 — with the tooling to match

A small, sharp engine focused on doing the common interfaces well — durable delivery, tolerant parsing, code-first routing, and PHI-aware operations — now with VS Code authoring, a PHI-safe AI assistant, AI-assisted migration, and a store that runs on the database you already have. Everything below is Available now unless marked planned.

Open source, no lock-in

Your integration logic is yours

AGPL-licensed and code-first: the routing graph is plain Python in your git repository, running on standard databases — nothing locked inside a vendor's runtime, language, or contract.

AGPL-3.0-or-later — read it, run it, fork it. A contributor agreement also enables a commercial / dual license.
Configuration is code — Connections, Routers, and Handlers are diffable, reviewable Python modules; the database holds runtime state and messages only, never configuration.
Standard databases — no proprietary data platform required, and no proprietary scripting language to staff for.
No runtime or contract lock-in — self-hosted, on your infrastructure, on your terms.

Reliability

Durable by construction

The message store is the queue. A transactional inbox/outbox is the reliability backbone — no separate broker to run, patch, or monitor.

At-least-once delivery — the inbound is ACKed only after the message and its outbox rows are committed.
Per-outbound workers — each destination drains independently; one slow or failing peer never blocks the others.
Retries with backoff and automatic dead-lettering, plus a dead-letter bulk-replay view for recovery.
Replay — re-drive a stored message through delivery from the console or API.
Nothing silently dropped — every received message is persisted with a disposition before it is acknowledged.

Parsing & validation

Two-tier, by design

Fast and tolerant on the hot path; strict and version-aware only where you ask for it. Real-world HL7 is frequently non-conformant — the engine is built to expect that.

python-hl7 for fast field peek during routing and filtering.
hl7apy for opt-in, version-aware strict validation, per inbound connection — kept off the routing path.
Encoding from MSH — field, component, repetition, escape, and subcomponent separators are read from the message, never hardcoded.
Raw message preserved alongside the transformed form, so an operator always sees exactly what arrived.
Parse failures are routed to the error / dead-letter path and logged as ERROR — a bad message never crashes a connection.

Connections

Pluggable transports, resolved through a registry

New connection types are registered, not special-cased in the pipeline.

MLLP built

Correct 0x0B … 0x1C 0x0D framing, inbound and outbound. ACK/NAK generation (AA / AE / AR) with the ack mode — original, enhanced, or none — configurable per inbound connection.

File built

File source and destination, with templated output names (e.g. {MSH-10}.hl7) drawn from message fields.

TCP · HTTP · DB planned

Additional transports — plus REST/FHIR destinations and a database poller — are on the roadmap, implemented against the same connector contract.

Count-and-log invariant. Every message a connection takes in or puts out is counted and logged — a router or filter decision is a recorded outcome (UNROUTED / FILTERED), never a silent drop.

Routing & handling

Code-first, pure functions

A Router decides forwarding (and optional filtering); a Handler filters, transforms, then returns Sends. They're pure Python functions, registered by name — no declarative filter/transform DSL to learn.

@router returns the handler name(s) a message should go to — or an empty list to leave it unrouted.
@handler returns None to filter, or one or more Sends addressed to outbound connections.
Wired by name — inbound names a Router, Routers name Handlers, Handlers send to outbound Connections.
Shared helpers live in _-prefixed modules the loader skips, so config stays DRY.
Transforms stay pure where possible — message in, message out; side effects belong in connections.

Security & PHI

PHI is a first-class concern

This engine carries PHI, so authentication, authorization, audit, and encryption-at-rest are built in — not bolted on. The API binds 127.0.0.1 by default and requires authentication.

Authentication — local users, Active Directory (LDAP), and Kerberos / Windows SSO, with opaque sessions.
RBAC — fixed built-in roles, deny-by-default, per-route and per-channel scoping.
Tamper-evident audit log — a hash-chained, user-attributed record of every PHI access (raw view, summary, replay), with a verification command.
Encryption-at-rest — message bodies are encrypted with AES-256-GCM in the store.
Roadmap planned — a de-identification framework, centralized log redaction, retention/purge enforcement, and MLLP-over-TLS with outbound allow-listing.

Operate

A console and an editor, both talking to one API

PySide6 admin console

Connection dashboard, message browser, an HL7 parse-tree viewer, delivery and audit trail, and one-click replay. A separate process that reaches the engine only over the localhost API.

VS Code extension

Author and operate interfaces in your editor: completion, live HL7-aware validate-on-save, a graph view of your integration, source-control integration, and Stage → Promote to a running engine.

CLI & localhost API

messagefoundry serve runs the engine and exposes connection control, message search/detail, replay, stats, and a live WebSocket feed. check gates commits; generate produces synthetic, PHI-free HL7.

Operational niceties. Configuration hot-reload and environment promotion (DEV/PROD values layer over the same modules), configurable ACK modes, message-size and segment guards, and a synthetic HL7 generator for testing — all included.

Author faster

Wizards and a PHI-safe AI assistant lower the barrier

Code-first power without the blank-page tax — guided generation and AI help that never sees a message body.

Setup wizards

Guided New Connection and New Route flows that generate the Python for you — Corepoint-style guided authoring, but the output is plain code you own and review.

PHI-safe AI assistance

An in-editor assistant governed by a central, environment-aware policy that sends only code, never message bodies, gated by role-based access control.

AI-assisted migration

Moving from another engine is AI-assisted by design: paste your existing Mirth / Cloverleaf / Rhapsody logic and the assistant helps you express it as Python — typically far less effort than re-platforming. Code-only and governed.

Test & verify

A full test harness, included

Exercise interfaces with synthetic, PHI-free traffic before anything touches production — interactively or in CI.

Send / receive / file / compose / monitor test bench for driving MLLP and file endpoints by hand.
Headless scenario runner for CI — assert routing and transform behavior on every commit.
Test Bench dry-runs in VS Code — run .hl7 files through a route with before/after diffs.
Synthetic HL7 generator — realistic, PHI-free messages for load and edge-case testing.
check commit gate — validate configuration before it ships.

Database flexibility

Runs on the database you already have

A pluggable message store on standard databases — zero-config to start, enterprise RDBMS when you need it. No proprietary data platform required.

SQLite (WAL) by default — embedded and zero-config; the reliability backbone for the inbox/outbox queue.
SQL Server, PostgreSQL, MySQL, and Oracle — point the store at your existing RDBMS.
One store contract — the same dispositions, retries, replay, and audit semantics across backends.
No data-platform lock-in — your messages live in a database you control.

Deploy & support

Runs headless, where your data lives

On-premises by default — no PHI leaves the local environment without explicit, reviewed configuration — backed by commercial support when you need it.

Windows service via NSSM — install/uninstall scripts included.
Headless engine — no GUI imports; testable and runnable as a service.
One config, many environments — DEV/PROD values layer over the same Python modules.
24×7 support & consulting — commercial support and expert HL7 + Python consulting: migration assistance, custom connectors, and on-call operations.

Planned

On the roadmap — not yet shipped

We don't market roadmap as available. These are planned as of June 2026.

More transports planned

TCP, HTTP, and database connections, plus REST/FHIR destinations and a database poller — today the shipped transports are MLLP and File.

PHI hardening planned

A de-identification framework, MLLP-over-TLS with outbound destination allow-listing, centralized log redaction, and retention/purge enforcement.

Managed, BAA-backed AI planned

An engine-brokered managed provider under a BAA for PHI-scoped assistance — today the assistant is strictly code-only.

See it run in five minutes

Get started See how it compares →