NeoIntegrate™: Detailed Features
(for more images and NeoIntegrate 3.1.1 screen shots, view the detailed features pdf)
View print-friendly PDF Version 
NeoIntegrate is a new generation of interface engine that provides flexibility in message management, routing, mapping, and database access. The engine is designed around easier workflow and lower cost of ownership compared to other engines. Graphical tools and a published API make it possible to quickly build real world healthcare interfaces, including support for many message formats (HL7, XML, CSV, Clinical Document Architecture - CDA, Continuity of Care Record - CCR, Continuity of Care Document - CCD, custom formats, etc.) and communications protocols (TCP/IP, MLP, files, HTTP, MSMQ, Web Services, etc.)
NeoIntegrate can be used to:
- Provide a hospital, imaging center, clinic, lab, ASP, or other facility a core interface engine. It provides message routing, filtering, and message transformation using powerful tools and adaptable publish/subscribe techniques. (Described below)
- HL7-enable a commercial or internally-developed clinical application. It provides for direct mapping of HL7 messages into a database via query/read/write and flexible data manipulation. (Described on the following page)
Clinical application development teams create HL7 export and import modules using NeoIntegrate (see example above). There are many benefits to having a fully-featured HL7-subsystem:
- Leverage proven interfacing technology that provides fast, customer-focused implementation cycle
- Achieve full HL7 compliance with support for the different versions of HL7 2.X messaging
- Extend application integration reach through flexible HL7 derivatives, data mapping, code set conversion, and custom Z segments, data types, and message triggers
- Ensure message delivery with extensive support for HL7’s MLP protocol and acknowledgement handling
- Provide high quality clinical data through message validation
Healthcare Provider: Using NeoIntegrate as an Interface Engine
As illustrated above, healthcare providers and vendors use NeoIntegrate as an interface engine to map, route, and filter messages. The key benefits in using NeoIntegrate as an interface engine include:
- Lowering the cost of initial implementation and on-going support of interface environment
- Leveraging investment in interfaces by repurposing existing data flows
- Broadening the role of interfaces though data extraction and the creation of an operational data store in any database
- Focusing on interface quality through industry-leading monitoring, alerting, and debugging tools
Healthcare Vendor: Using NeoIntegrate as a HL7 Subsystem
Clinical application development teams create HL7 export and import modules that manage the sending and receiving of healthcare messages typically in an HL7 message format through TCP/IP connections. These modules are created using custom code or built with third-party tools. There are many benefits to having a fully-featured HL7-subsystem based on NeoIntegrate:
- Leveraging proven interfacing technology that provides a fast customer-focused implementation cycle
- Achieving full HL7 compliance with support for all versions of HL7 2.X messaging, HL7 Version 3, CDA, CCD, CCR, IHE, and CCHIT
- Extending application integration reach through flexible HL7 derivatives, data mapping, code set conversion, custom Z segments, data types, and message triggers
- Ensuring message delivery with extensive support for HL7’s MLP protocol and acknowledgment handling
- Providing high quality clinical data through message validation
- Focusing product development efforts on a single iteration touch point with other applications and mapping foreign workflows, data models, and code sets onto native application functionality
You do not need to be a programmer or an HL7 expert to create and maintain interfaces using NeoIntegrate. Simply define the data you want and where it should be sent.
NeoIntegrate makes it simple to:
- Create new interfaces
- Monitor connection states
- Define database relationships
- Review messages sent across an interface
- Resend selected messages one at a time or in batches
- Enhance service levels through automated alerting (visual and e-mail) of unusual conditions
Key NeoIntegrate Features
- API for extending NeoIntegrate’s core functionality
- GUI driven Routing, Mapping, and Filtering
- Agile connection creation
- Processes HL7 2.X and HL7 3.0 messages
- Built-in support for CDA, CCR, and CCD
- GUI driven process to define your specific HL7 messages and Z segments
- Complete TCP/IP (MLP) communication infrastructure
- Robust intuitive and integrated testing tools
- Remote management and monitoring
- Configurable proactive alerting
- Centralized configuration GUI
- Comprehensive message/activity logging
- Log viewing tools to filter and display message traces
- Message resend (inbound/outbound) support
- Handles cardinality during message processing
- Database access (read/write/query) extensions
- XSLT (XML-to-XML) support
- File Read and Write
- Robust testing tools
- Web Services (HTTP) connectivity
- XML support including custom XSDs
- Highly available for continuous processing
NeoIntegrate Architecture
As illustrated in the following diagram, NeoIntegrate is able to receive messages from a wide variety of external systems, modify the messages and route them to other external systems. Throughout the processing, NeoIntegrate archives the message activity and provides alerts when issues arise.
NeoIntegrate contains a core engine and various graphical user interfaces that interact with the core engine. NeoIntegrate contains the following main functional areas:
Communication
- Generate outbound messages and acknowledgements
- Manage inbound messages and acknowledgements
- Handle HL7 resends
- Manage communication with multiple applications
- Support unrestricted and non-blocking data flow
- Resolve MLP implementation and communication problems
- Provide pre-configured sender and receiver logic
- Read, write, query, insert, and/or delete data in an ODBC database
- Store-and-forward message persistence
- Use preloaded definitions of messages, segments, fields and data types for all HL7 2.X versions actively used in the field
- Support 2.X messages, segments, fields, and data types including customizations such as Z segments
- Preloaded support for HL7 V3
- Process repeating fields, repeating segments, groups of segments, etc
- Support for XML messages created using Version 3 and custom XSDs
- Support for CCR, CCD and CDA messages
- Handle one input message to produce 0-to-N output messages through dynamic, content-based routing
- Run HL7 conformance checks using sample messages, testing the HL7 derivative configuration; reinforce the HL7 objective of keeping compatible versions and ensuring data integrity
- No coding or scripting required
Alert
- Configurable alerts by day, time, type of day, and connection.
- Automatically monitor connection states and related conditions, and raise alerts when problems occur
- Escalation of alerts based on severity of problem
- Send alerts via email to pagers, cell phones, etc.
- Support for quick resolution of alerts
- History stored in alert logs including documented resolution
Archive
- View message logs for each connection by day, including session, error, and alert information
- View messages over a range of days
- Search for messages by message content, history, and metadata attached to the message
- Edit messages easily, especially useful in testing
- Re-send messages to resolve problems quickly
Configure and Test
- Perform all configuration tasks in a single GUI with a streamlined work flow
- Allow user-defined variations in messages (e.g., making segments optional, required or rearranging, etc.)
- Validation check on defined HL7 messages
- Configure alerts flexibly according to time and severity thresholds
- Test alerting components prior to implementation
- Store and view alert and resolution log
- Configure message mapping easily to reduce integration work
- Define filter criteria such as ‘Only send A04 and A08’ and ‘Remove all outpatients from data stream’ through GUI-based tool
- Point-and-click GUI to move data from point A to B in a message
- Print HL7 definition and configuration files for clear documentation
- Completely re-format interface message without writing any compiled code or interpreted scripts
- Test mapping operations in GUI testing screen before using in a running connection
Communication
The communication layer of NeoIntegrate manages all communications with other systems while supporting an unrestricted store-and-forward data flow. NeoIntegrate can communicate with virtually any protocol including TCP/IP, file systems, web services, and databases while managing HL7 acknowledgement messages and resolving MLP problems. Connections are configured remotely with an easy to use graphical interface. This same interface provides the ability to remotely monitor connection information and view system logs.
The communication functionality in NeoIntegrate includes:
- TCP/IP Communication
- Creating Connections
- File Read/Write
- Connection Monitoring
- XSLT
- Non-Standard MLP characters
- ACK Management
TCP/IP Communication
TCP/IP MLP communication is simple with NeoIntegrate. Define the connection’s role (client or server), the port the connection will be using, and the framing of the message. Select the appropriate HL7 acknowledgement options and you have completed TCP/IP MLP configuration.
In the background NeoIntegrate:
|
 |
Creating Connections
Receiver, Sender and Bidirectional connections are created in seconds using the NeoIntegrate Configuration GUI. Connections can be monitored and managed remotely through the NeoIntegrate Administrative Console.
File Read Write
NeoIntegrate can write a message stream into a series of uniquely named files. It can also read files from a local directory based on a specified file name pattern (e.g., *.hl7 or mes*.txt) and then archive the files once processed.
When paired with NeoIntegrate’s base TCP/IP functionality, this allows many uses, including turning a TCP/IP real-time message stream into a set of files for testing, development or interfacing to non-real-time applications.
Connection Monitoring
NeoIntegrate allows you to remotely create HL7 connections, view connection information, and read system event logs. The tools needed to configure and manage NeoIntegrate, and your HL7 connections, are at your fingertips in a familiar format.
NeoIntegrate provides comprehensive, real-time information about each connection. Example of displayed information is:
- The state of the connection, displayed by color and state column
- How long it has been since a message has been sent or received, displayed as idle time
- How behind the connection is in processing data, displayed as queue depths
- Active, resolved, and inactive alerts
XSLT
XSLT was defined by W3C as a standard method for transforming XML documents. NeoIntegrate’s XSLT gear provides a solution when two healthcare applications use XML messages that do not agree on the tags or document structure. This XSLT gear provides set of Xpath expressions that invoke external XSLT maps. These XSLT maps can be defined using a third party graphical mapper such as Altova XMLSpy.®
Non-Standard MLP
NeoIntegrate provides a simple way during connection creation to configure for the use of non-standard characters. Therefore, any character-based wrapping scheme is supported providing maximum flexibility to deal with non-standard MLP implementations.
ACK Management
NeoIntegrate allows for maximum flexibility in sending and receiving ACK messages through the configuration of the sending and receiving connections.
The sending application can be configured to:
- Require an HL7 2.x response
- Require an HL7 2.X ACK response
- Resend the message if the response does not conform to the required ACK format
- Resend the message if it does not receive any acknowledgement after a specified period of time for a specified number of times
The receiving application can be configured to:
- Send ACKs
- Send an HL7 ACK
- Omit an ACK trigger
- Send a static ACK string
Message: Map & Route
Messages are modified and prepared for sending to other applications in NeoIntegrate’s message layer.
NeoIntegrate's message layer includes:
- Message Routing, Mapping and Filtering
- HL7 Support for version 2.x and 3.0
- HL7-to-XML-to-HL7 Conversion
- Database Query, Read, Write
- Native XML support including importing XSDs
- Support for CCR, HL7 CCD, HL7 CDA, and ELINCS
Message Routing, Mapping and Filtering
NeoIntegrate provides the ability to perform:
- Routing: Dynamically transform input message to 0-n output messages and then deliver messages to subscribing connections.
- Filtering: Content based message filtering, such as only sending A04 and A08 messages to the LIS and then only sending inpatients plus outpatients with a hospital service of “breast center” to the RIS.
- Mapping: Adjust message structure such as move data from Z segments to the right place, modify data, select correct patient IDs, change coded values, or allow a “strict” HL7 system to take a non-compliant feed.
HL7 Support
NeoIntegrate supports all versions of HL7 as evidenced by:
- Support for user-defined variations in HL7 messages
- Configuration tools to reduce customer site integration
- Adherence to standard HL7 file formats - message delimiters in each MSH segment
- Handling of non-standard HL7 formats
- Inclusion of ASCII or UNICODE character sets
- Configurable Z segments and custom messages
- Support for 2.X messages, segments, fields, and data types
- Support for Version 3 XSDs and XML messages
- Parsing repeating fields, repeating segments, groups of segments, groups of groups, etc.
NeoIntegrate can communicate with any HL7-enabled application. The message format differences between “standard HL7” and the way a given vendor implements HL7 are handled effectively in NeoIntegrate. When you exchange messages with a variety of healthcare applications, NeoIntegrate allows you to create and manage the differently defined HL7 messages.
HL7-to-XML-to-HL7 Conversion
NeoIntegrate’s HL7-to-XML parsing software converts inbound HL7 messages into XML documents before passing them on to your application. NeoIntegrate also converts XML documents into HL7 messages, allowing you to send HL7 information to your external healthcare providers or internal healthcare applications.
NeoIntegrate:
- Transforms logically tagged XML documents into fully parsed HL7 messages
- Creates hierarchical XML documents from received HL7 messages
- Provides XML schemas for 2.X HL7 versions
XML Support
NeoIntegrate has the ability to import custom XSD files and use the message structure defined in the XSD to parse and encode the messages. Additionally, NeoIntegrate contains all the HL7 Version 3 schemas.
Database Query, Read, Write
NeoIntegrate can read, write, query, insert or delete data in an ODBC database. The database schemas are not “fixed”, thus allowing you to use your existing database, or design a new one. Extensive debugging support allows viewing of database updates made while processing a given message.
Database interaction is accomplished through record set interaction and the ability to execute stored procedures.
Focused on reliability, ease of debugging, and field maintenance, the database interactions are logically created and flexible.
Alerting
NeoIntegrate’s proactive alerting provides immediate notification of any interfacing event that needs attention. This allows staff to quickly respond to the issue without constantly manually monitoring the system. Ultimately, issues are resolved more quickly – often before there is a business or clinical impact.
The alerting functionality in NeoIntegrate includes:
- Alert Configuration
- Managing Service Levels
- Alert Logging
Alert Configuration
Alerts are easily configured allowing complete control over which events will trigger an alert. Configuration can be by connection, by day, and by time. The alert sub-system can proactively monitor for any number of events, where each event may have the following unique attributes:
- Day and time of the event
- Type of event:
- Message events (Send Fail, Errored Message)
- Connection oriented events (Stopped, Not Connected, Idle, No Response)
- Queue depth events
- Severity of event required to create an alert
- Escalation of alerts in the case of unresolved issues
- E-mail notification in the case of an alert
Managing Service Levels
Alerts are automatically displayed in the NeoIntegrate administrative console sorted by all alerts, active alerts, or resolved alerts. In addition, the system can be configured to send an e-mail to the appropriate staff when an alert occurs.
When conditions cause an alert to occur, it is displayed under the Active Alerts column for the connection on the administrative console. Alerts can be viewed and filtered by state (Active or Unresolved) and by user for whom the alert is targeted (e.g., operator, engine manager, or clinical application team).
The administrative console is also used to record resolution to alerts. The resolution information is recorded in the alert log to be reviewed in the future.
Alert Logging
All alerts are logged in NeoIntegrate providing a history of alerts and resolution taken to resolve the alerts. NeoIntegrate creates a log that contains each alert and resolution for each connection.
Archiving
NeoIntegrate archives every message that flows on each connection. NeoIntegrate’s logging feature allows for:
- Archiving Logs
- Message Resends
- Log Maintenance
Archiving Logs
NeoIntegrate logs messages that flow through each connection. The logs are automatically sorted per-connection and per-day for easy review. Messages that fail processing are stored in a special file for review, repair, and resubmission.
In addition to message logging, NeoIntegrate logs connection state changes per your specification during connection creation. This allows you to maintain the desirable amount of history for each connection.
Using NeoIntegrate’s logging features, message, error, and alert logs are easily viewed.
NeoIntegrate provides the ability to:
- Track a message throughout the system
- Know exactly when a message was sent, received and acknowledged, and what information the message contained
- Easily troubleshoot communication problems
- View message body in text, tree, or hex form
- Edit messages for testing and resubmission purposes
- View a date range of logs for message load trending
Message Resend
NeoIntegrate provides the ability to resend messages. The value of this very powerful feature is quickly realized when messages must be reprocessed due to an ancillary system issue or reload.
Log Maintenance
NeoIntegrate automated the deletion of log file that reach a configured age. NeoIntegrate provides the ability to configure what time the log file maintenance is performed, a different number of purge days for different types of logs, and how verbose the logging information is. Additionally, the number of days logs are kept can be configured separately by connection.
Configuration and Testing
NeoIntegrate aids in the development of quality interfaces by allowing detailed configuration and testing of those interfaces with the following features:
- Message Format Conformance Checking
- Configuration and Testing of Business Rule Logic
- Support for Production and Test Environments
Message Format Conformance Checking
In addition to allowing you to define different message formats for different healthcare partners, NeoIntegrate also serves as a testing tool to check conformance between messages received from an external healthcare partner and the expected message format.
Of the 133 sample messages, none conformed to the “lab” message format. The Conversion Errors window details the reasons for nonconformance and how many messages were affected by each issue.
Once the errors in the messages have been identified, NeoIntegrate provides the ability to edit the messages or the expected format and resend to test again.
Configuration and Testing of Business Rule Logic
NeoIntegrate provides the ability to configure business rules to use in the mapping, filtering, and routing of messages without any programming. Additionally it provides a method to instantly test the configured business rule logic with sample messages to confirm that the business logic is correct before putting it into a test or production environment.
Above: After the test file of sample messages is run through the action list containing the business logic, the Test pane shows the history, original format, and modified format for each message and a summary of all messages, providing confidence in the actions taken by the logic.
Support for Production and Test Environments
In addition to unit testing for message formats and business rule logic, NeoIntegrate provides support for a test environment so the entire system can be tested prior to affecting actual healthcare messages.
NeoIntegrate provides the ability to export all the configuration elements into a single file that can be imported into another system to exactly duplicate the test environment. If there is a database involved in your environment, you can change all the database interactions with only one small modification. These features provide an efficient method of maintaining test and production environments.
Summary
NeoIntegrate can be used to:
- Provide a hospital, imaging center, clinic, lab, ASP or other facility a core interface engine
- HL7-enable a commercially or internally-developed clinical application
In both scenarios, NeoIntegrate provides a powerful tool to manage all communications with virtually any protocol while supporting unrestricted data flow. In support of that communication, NeoIntegrate provides robust mapping and routing functionality that allow for modification and preparation of messages to be sent to other applications based upon message content. During processing, NeoIntegrate archives all the message activity for easy retrieval and recovery and constantly monitors for any conditions that might affect message delivery. All the powerful functionality of NeoIntegrate is configurable with easy-to-use GUI application that provides for unit testing of each part of the interface
About NeoTool
NeoTool is a leading provider of healthcare integration solutions that empower organizations to develop, test, deploy, and manage data exchanges between healthcare applications and providers. Through software, training, and consulting, NeoTool is the largest firm dedicated solely to HL7 and healthcare application interfacing. NeoTool customers include healthcare providers (e.g., hospitals, imaging centers, labs, and clinics) and healthcare software application providers and medical device manufacturers.