MessageFoundry™
In your editor

Build your interfaces in VS Code

The MessageFoundry extension turns the editor your team already uses into an HL7-aware workspace for integration — author with wizards or code, autocomplete HL7 as you type, test on synthetic data, and promote to a running engine, all without leaving VS Code. No proprietary IDE to learn, and it's entirely optional.

Get started See the whole toolkit →
HL7-aware editing

Autocomplete the HL7, catch mistakes on save

Write a handler and the editor already knows HL7. Segment and field references autocomplete from a bundled HL7 schema, so PID-5 or MSH-9.2 come from a list — not a spec PDF on your second monitor.

And it's checked the moment you save: validate-on-save flags an unknown segment, a malformed field path, or a typo before it ever reaches a running engine — so HL7 mistakes surface in the editor, not in production.

route_adt.py — MessageFoundry
@handler("route_adt")
def route_adt(msg):
    mrn   = msg["PID-3.1"]    # ⌄ from the HL7 schema
    name  = msg["PID-5.1"]
    event = msg["MSH-9.2"]    # A01 / A04 / A08 …

    if event not in ("A01", "A04", "A08"):
        return None
    return Send("EHR_Out", msg)

# Typo a segment? Flagged the moment you save.
Author, your way

Wizards for the routine, code for the rest

Stand up a whole interface from a guided flow, or drop into Python when you need to — it's the same config either way.

New Route Wizard

Build a full interface in one flow — inbound connection → router → handler → outbound — with the wizard scaffolding the Python and wiring it by name. No blank page to stare at.

Connections sidebar

Every connection in a filterable, groupable tree, with a Home authoring page — see and open your whole config at a glance instead of hunting through files.

connections.toml editor

Edit connection settings as data — in a GUI form, by hand, or with the messagefoundry connection CLI. Your choice, the same file.

Test Bench

Prove it on synthetic data before it ships

Dry-run a .hl7 message through a route right in the editor and see a before/after diff of exactly what your handlers did — no running engine, no PHI required.

  • Step-through debugging — set a breakpoint and walk a message through your router and handlers line by line.
  • Synthetic, PHI-free — the Test Bench runs on generated sample messages, so testing never touches patient data.

Stage → Promote

When a route checks out, push it to a running engine straight from the editor — staged first, then promoted on your say-so. The config you tested is the config that runs; there's no separate proprietary platform to export to or learn.

Every introspection step shells the MessageFoundry CLI — so what the editor does, your git hooks and CI can do too.

Optional AI

An @messagefoundry chat that speaks the API

The extension also includes an optional chat assistant, primed with MessageFoundry's real Router and Handler API. It runs on whatever model you've already set up in VS Code (e.g. GitHub Copilot) — MessageFoundry bundles no model and ships no keys.

PHI-safe by construction: it only ever sees your code and your config-graph names — never a message body, never patient data. Centrally governed, with a hard off switch.

How AI works, and how it's governed →

Slash commands

  • /explain — walk through what a router or handler does.
  • /transform — draft a @handler from a description of the mapping.
  • /review — review the handler you're writing, against the real API.

More commands are in progress.

It's just VS Code. The MessageFoundry editor is a standard extension over the editor your developers already know — your configuration stays plain Python and connections.toml in your git repository, never locked inside a proprietary IDE. Install it or don't: the wizards, autocomplete, and Test Bench are conveniences, and everything they produce is ordinary code you can write and run by hand.

Get started See the whole toolkit →