intu

intu is a Git-native, AI-friendly healthcare interoperability framework that lets teams build, version, and deploy integration pipelines using YAML configuration and TypeScript transformers.

Install

npm i -g intu-dev

Commands

Project & Build

Channel Management

Deployment & Operations

Message Browser

Advanced

Quick Start

intu init my-project
cd my-project
npm run dev

intu init scaffolds the project and runs npm install automatically. npm run dev starts the engine with hot-reload (auto-compiles TypeScript, restarts channels on file changes).

Dashboard: http://localhost:3000 (admin / admin)

npm Scripts

Test the included channels

# JSON pass-through
curl -X POST http://localhost:8081/ingest \
  -H "Content-Type: application/json" -d '{"hello":"world"}'

# FHIR Patient → HL7 ADT (also serves /fhir/r4/metadata)
curl -X POST http://localhost:8082/fhir/r4/Patient \
  -H "Content-Type: application/json" \
  -d '{"resourceType":"Patient","id":"123","name":[{"family":"Smith","given":["John"]}],"gender":"male","birthDate":"1990-01-15"}'

Add a new channel:

intu c my-channel

Project Structure (after intu init)

my-project/
├── intu.yaml              # Root config + named destinations
├── intu.dev.yaml          # Dev profile overrides
├── intu.prod.yaml         # Production profile
├── .env                   # Environment variables
├── package.json           # npm scripts + dependencies
├── tsconfig.json          # TypeScript compiler config
├── types/
│   └── hl7-standard.d.ts  # Type declarations for hl7-standard
├── channels/
│   ├── http-to-file/      # JSON pass-through channel
│   └── fhir-to-adt/       # FHIR Patient → HL7 ADT channel
├── Dockerfile
├── docker-compose.yml
└── README.md

Channel Structure (after intu c my-channel)

channels/my-channel/
├── channel.yaml       # Listener, validator, transformer, destinations
├── transformer.ts     # Pure function: JSON in → JSON out
└── validator.ts       # Validates input, throws on invalid

Included Packages

Scaffolded projects include these npm packages for working with healthcare data:

Destinations

Define named destinations in intu.yaml, reference in channels:

destinations:
  kafka-output:
    type: kafka
    kafka:
      brokers: [${INTU_KAFKA_BROKER}]
      topic: output-topic
    retry:
      max_attempts: 3
      backoff: exponential

Channels support multi-destination:

destinations:
  - kafka-output
  - name: audit-http
    type: http
    http:
      url: https://audit.example.com/events

Sources & Destinations

This package ships the prebuilt intu CLI binary. All connectors listed below are fully implemented in the current runtime.

Supported Sources (12 types)

• HTTP (listener.type: http): REST listener with path, methods, TLS, and auth (bearer, basic, api_key, mTLS).
• TCP/MLLP (listener.type: tcp): Raw TCP or MLLP mode for HL7 transport, with TLS and ACK/NACK.
• File (listener.type: file): Local filesystem poller with glob patterns, move/error dirs, and ordering.
• Kafka (listener.type: kafka): Kafka consumer with TLS and SASL auth.
• Database (listener.type: database): SQL polling reader for Postgres, MySQL, MSSQL, SQLite.
• SFTP (listener.type: sftp): SFTP poller with password/key auth.
• Channel (listener.type: channel): In-memory channel-to-channel bridge for fan-in/fan-out.
• Email (listener.type: email): IMAP/POP3 reader with TLS.
• DICOM (listener.type: dicom): DICOM SCP with AE title validation and TLS.
• SOAP (listener.type: soap): SOAP/WSDL listener with TLS and auth.
• FHIR (listener.type: fhir): FHIR R4 server with capability statement and subscriptions.
• IHE (listener.type: ihe): IHE profiles (XDS Repository/Registry, PIX, PDQ).

Supported Destinations (13 types)

• HTTP (type: http): HTTP sender with headers, auth (bearer, basic, api_key, OAuth2), and TLS.
• Kafka (type: kafka): Kafka producer with TLS and SASL auth.
• TCP/MLLP (type: tcp): TCP sender with MLLP support and TLS.
• File (type: file): Filesystem writer with templated filenames.
• Database (type: database): SQL writer with parameterized statements.
• SFTP (type: sftp): SFTP file writer with auth.
• SMTP (type: smtp): Email sender with TLS and STARTTLS.
• Channel (type: channel): In-memory channel-to-channel routing.
• DICOM (type: dicom): DICOM SCU sender with TLS.
• JMS (type: jms): JMS via HTTP REST (ActiveMQ, etc.).
• FHIR (type: fhir): FHIR R4 client for create/update/transaction bundles.
• Direct (type: direct): Direct messaging protocol for HIE.
• Log (type: log): Structured logging destination.

Runtime Features

• Hot Reload: Edit channel.yaml or .ts files and the affected channel restarts automatically — TypeScript is recompiled on the fly.
• Pipeline Stages: Preprocessor, validator, source filter, transformer, per-destination filter/transformer, response transformer, postprocessor.
• Retry & DLQ: Configurable retry with backoff (fixed, linear, exponential) and dead-letter queue.
• Destination Queuing: Per-destination queues with overflow policies and concurrent workers.
• Metrics: Message counts (received, processed, filtered, errored), latency tracking.
• Message Storage: Persist messages at each pipeline stage for audit and replay.
• Alerting: Periodic alert evaluation with configurable triggers (error count, queue depth).
• Batch Processing: Split inbound messages using HL7 batch, FHIR bundle, newline, or XML splitters.
• Map Variables: globalMap, channelMap, responseMap, and connectorMap for sharing data across pipeline stages.
• Code Template Libraries: Share TypeScript functions across channels.
• Channel Dependencies: depends_on and startup_order for controlling channel boot sequence.
• Channel Clone/Export/Import: Clone channels, export as .tar.gz, import from archives.

Data Types

HL7v2, FHIR R4, X12, CCDA, JSON, XML, CSV, binary, and raw pass-through.