Artificial Intelligence (AI) is getting a lot of attention lately because it can change many areas of our lives. Better computer power and more data have helped AI do amazing things, like improving medical tests and making self-driving cars. AI can also help businesses make better decisions and work more efficiently, which is why it's becoming more popular and widely used. How can one integrate the OpenAI API calls into an existing IRIS Interoperability application?

This article will describe and include an example of how to embed an external PDF file into an HL7 segment, specifically ADT_A01:2.3.1 OBX().  This can be useful when attempting to insert pictures or other external data into an HL7 message.  In this example, the name of the PDF file to be embedded is provided in the incoming HL7 message in OBX(1):ObservationValue field.

The basic stipulations for this example are as follows:

1. Accept a PDF file
2. Accept an HL7 message
3. Using the name of the PDF file, embed the PDF data into the HL7 message
4. Output the message to file 

 Using EnsLib.File.

BPL from 10,000 feet

BPL stands for Business Process Language.
This is an XML format for describing complex information orchestration interactions between systems.
InterSystems Integration engine has for two decades, provided a visual designer to build, configure, and maintain, BPL using a graphical interface.
Think of it like drawing a process flow diagram that can be compiled and deployed.

An example: Make a cup of tea

BPL components are added to Integration productions like any other built-in or custom business component.

Prompt

Firstly, we need to understand what prompt words are and what their functions are.

Prompt Engineering

Hint word engineering is a method specifically designed for optimizing language models.
Its goal is to guide these models to generate more accurate and targeted output text by designing and adjusting the input prompt words.

Hi everyone,

I am very pleased to announce that the Readmission Demo has been released as open source. Many thanks to the Solution Factory team that worked hard on making this possible.

Here are the changes:

• It is now running on top of IRIS Community 2019.3.0.308.0.
• It has synthetic data based on Synthea instead of the real data we were using before. But the machine learning models are 100% real
• Image RRLACESrv has been renamed to “image-riskengine”
• Image “readmissionsrv” has been renamed to “image-risksrv"
• We refactored a lot of the code on image-riskengine to look better.

Ever since I started using IRIS, I have wondered if we could create agents on IRIS. It seemed obvious: we have an Interoperability GUI that can trace messages, we have an underlying object database that can store SQL, Vectors and even Base64 images. We currently have a Python SDK that allows us to interface with the platform using Python, but not particularly optimized for developing agentic workflows. This was my attempt to create a Python SDK that can leverage several parts of IRIS to support development of agentic systems.

A few months ago, Jose and I were discussing the article Video Smart Data Services (Vision & Demo) from @Amir Samary and during that discussion, we started wondering what kind of feature would be nice to have on a future IRIS solution. 

One of the desired features is to have an IRIS iPaaS solution as I questioned here in this comment.

These last months gave me the opportunity to work with different projects and technologies, and put me in touch with applications like Tray.io or Workato, and now I can see how great an IRIS iPaaS solution could be.

In a Business Process (Ens.BusinessProcessBPL), how can you correctly call a classMethod?
I know we can call it in a block <code>  :

Or in a <assign>

Are there other ways and/or good practices?
Thanks
Corentin

There has been some confusion about how to edit Business Process Language (BPL) and Data Transformation Language (DTL) files in Atelier using the graphical editor. The following steps describe how to do this with Atelier version 1.0:

Copy the file you want to edit from the server to an Ensemble-enabled project in your Atelier workspace. To do this, find the file in the Server Explorer, right click and select Copy to project.

Open the file in the Atelier class editor just as you would any other class file.

Right-click in the class editor window and select Open diagram editor from the context menu.

Productions often need to receive REST requests.

Here's how to do that.

1. Create proxy Service:

/// Empty BS we would use to send Produciton requests
Class production.ProxyService Extends Ens.BusinessService
{
}

2. Add it to production as RESTService (or any other name).

3. Write your rest broker (docs, more docs)

4. In your handler method create the message and call target BP/BO like this

Include Ensemble
Class test.REST Extends %CSP.REST
{

XData UrlMap [ XMLNamespace = "http://www.intersystems.com/urlmap" ]
{
<Routes>
<Route Url="/launchProcess/:processName" Method="POST" Call="launchProcess"/>
</Routes>
}

ClassMethod launchProcess(processName As %String) As %Status
{
    #dim sc As %Status = $$$OK
    
    // BS from which we would call BP
    #dim serviceName As %String = "RESTService"
    
    #dim message = ##class(Ens.StringContainer).%New(%request.Content.Read($$$MaxStringLength))
    
    set sc = ..invokeHostAsync(processName, message, serviceName)

    quit sc
}

/// Call production host in async mode
/// Thirs arg is BS caller, testing service by default - testing must be enabled in that case
ClassMethod invokeHostAsync(targetHostName As %String, message As %Persistent, serviceName As %String = "EnsLib.Testing.Service", sessionId As %Integer = "") As %Status
{
    #dim sc As %Status
    
    #dim prod As Ens.Config.Production = ..getCurrentProduction()
    if '$isObject(prod) quit $$$ERROR($$$GeneralError, "Produciton is not running")
        
    #dim item As Ens.Config.Item = ..findConfigItem(targetHostName)
    if '$isObject(item) quit $$$ERROR($$$GeneralError, "Host " _ targetHostName _ " not found")
    
    #dim service As Ens.BusinessService
    set sc = ##class(Ens.Director).CreateBusinessService(serviceName, .service)
    if $$$ISERR(sc) quit sc
    
    if (sessionId '= "") set service.%SessionId = sessionId
    
    set sc = service.SendRequestAsync(targetHostName, message)
    
    quit sc
}

/// Get current production
ClassMethod getCurrentProduction() As Ens.Config.Production
{
    #dim sc As %Status
    #dim prodName As %String
    #dim prodState As %Integer
    
    // Get produciton name
    if '##class(Ens.Director).IsProductionRunning(.prodName) quit ""
    
    
    // Open produciton by name
    #dim prod As Ens.Config.Production = ##class(Ens.Config.Production).%OpenId(prodName, , .sc)
    if $$$ISERR(sc)
    {
        $$$LOGERROR($System.Status.GetErrorText(sc))
        quit ""
    }
    
    quit prod
}

/// Find host by name
ClassMethod findConfigItem(name As %String, businessType As %String = "", enabledOnly As %Boolean = 0) As Ens.Config.Item
{
    #dim sc As %Status
    
    // Get current production
    #dim prod As Ens.Config.Production = ..getCurrentProduction()
    if '$isObject(prod) quit ""

    // Search for our target
    #dim item As Ens.Config.Item
    #dim result As Ens.Config.Item = ""
    for i = prod.Items.Count():-1:1
    {
        set item = prod.Items.GetAt(i)
        
        if '$isObject(item) continue
        if ((businessType '= "") && (item.BusinessType() '= businessType)) || (item.Name '= name) || (enabledOnly && 'item.Enabled) continue
                        
        set result = item
        quit
    }
    quit result
}

}

Hi all,

When making a Business Process reusable, I needed to make the target of a <call> configurable as a business host setting. This can be done through indirection. Here's how:

Hi Community,

Here we have requirement to process messages min 10 sec delay. Current time it is taking my businessProcess is less than 1 sec.

To implement this requirement , I need to sleep 10 sec in business process custom code.

Could somebody help me to implement delay in BusinessProcess.

Thanks,

Prashanth

Welcome to the next chapter of my CI/CD series, where we discuss possible approaches toward software development with InterSystems technologies and GitLab.

Today, let's talk about interoperability.

Issue

When you have an active interoperability production, you have two separate process flows: a working production that processes messages and a CI/CD process flow that updates code, production configuration and system default settings.

Clearly, CI/CD process affects interoperability. But questions are:

• What exactly happens during an update?
• What do we need to do to minimize or eliminate production downtime during an update?

In 2017, Forbes published an article talking about API Economy (see: https://www.forbes.com/sites/louiscolumbus/2017/01/29/2017-is-quickly-becoming-the-year-of-the-api-economy/). This article was the trigger to popularize the use of API and API Management by large companies. The article published a maturity model. My understanding is that Intersystems IRIS allows you to reach the top of the pyramid with your current technologies. See the figure above.
For this it is important to combine % CSP.

I usually receive complains from our customers about the BPL and DTL web pages automatic refreshes, it's a common problem among newbies users but for veteran developers too, they forget to save the changes regularly and automatically the web page is reloaded, losing all the work done.

Maybe an autosave would fix this problem that produces a deep feeling of hate and resentment against InterSystems technology among our customers. I've added an idea in our portal, so feel free to vote it!

https://ideas.intersystems.com/ideas/DPI-I-452

Hi Community,

New video, recorded by @Eduard Lebedyuk, is available on InterSystems Developers YouTube:

⏯ Python Gateway: Jupyter Support - extended

Introduction

HL7 messages often contain multiple repeating segments such as NTE, AL1, OBX, ZTX, DG1, and others. These segments sometimes require individual processing and routing to different downstream systems. This technical paper introduces a configurable template designed to automate the splitting of these repeating HL7 segments, improving message handling and integration efficiency.

In this article I'd like to share with you a phenomena that is best you avoid - something you should be aware of when designing your data model (or building your Business Processes) in Caché or in Ensemble (or older HealthShare Health Connect Ensemble-based versions).

Introduction

Hi Community,

This article is aimed at developers implementing DICOM productions, specifically for cases with third-party endpoints that cannot handle the DIMSE timeout themselves.

For DICOM applications, the DIMSE timeout is a maximum time to wait for the next DICOM request (-RQ) or a response to a request (-RSP), after an association has been established. Unlike the ARTIM (association establishment) and TXTIM (data transfer) timeouts, the DIMSE timeout lives at a higher level than individual PDUs, with the application-level request/response logic.

We're back with more AI, more ML and more presenters!

We are pleased to invite you to the upcoming webinar in English: AI Robotization (Python, R, Interoperability) for InterSystems IRIS on November 7 at 11:00 EST!

Preface

Before we begin, I'd like to mention that I am by no means an Ensemble expert, so take this with a grain of salt and please feel free to offer any suggestions for improvement. That being said, I have enjoyed working with Ensemble and wanted to share the approach I took to poll an external REST API for patient data in the hopes that it might help others with a similar goal.

If you get bored easily and just want to see some code, feel free to jump straight to the example on github. It uses dummy data (for obvious reasons) but the core principles should be the same.

I am still trying to understand and come up with a use case to use FHIR as an enhancement to our existing HL7 messages. Does anyone have an example of taking a FHIR response and transforming it into a SDA?

How does the workflow go? Does it go through 1 BP? 

Thanks

Scott

<> <> # IRIS-API-Template

This is a REST template that can send REST messages to production and control interfaces through Servicer, processes, and operations

How to use it

zpm "install iris-rest-template"

Prerequisites

Make sure you have git and Docker desktop installed.

Installation

1.Clone/git pull the repo into any local directory

git clone https://github.com/samuelxabc/IRIS-API-Template.git

Open the terminal in this directory and run

docker-compose build

Run the IRIS container

This article is a continuation of this post.

In the previous article, we discussed business operations' creation from the components required for system integration.

In this article, you will learn how to create a business process that calls the two business operations you have defined in the sequence order.

• Production
• Message
• Components
  • Business Services
  • Business Processes
  • Business Operations (previous post)

The business process acts as the coordinator (command center) of the process.

This series of articles would cover Python Gateway for InterSystems Data Platforms. Execute Python code and more from InterSystems IRIS. This project brings you the power of Python right into your InterSystems IRIS environment:

• Execute arbitrary Python code
• Seamlessly transfer data from InterSystems IRIS into Python
• Build intelligent Interoperability business processes with Python Interoperability Adapter
• Save, examine, modify and restore Python context from InterSystems IRIS

Other articles

The plan for the series so far (subject to change).

Hi Interoperability experts!

Recently noticed an interesting conceptual discussion in our Interoperability Discord channel to which I want to give more exposure.

All we know that typical InterSystems Interoperability production consists of the following chain:

Inbound adapter->Business Service->Business Process->Business Operation->Outbound adapter.

And Business Process (BO) here is always considered as a passive "listener" either on port/folder/rest API for an incoming data.

Hi community.

I have an API that is deployed in my production (business service) and it calls to a business process to retrieve the information that is requested.

The problem that I have is that the calls are queued and it's creating a bottleneck 

The business process is taking more time than needed.

Is possible to configure the BP to process parallely the requests?

I'm thinking to increase the pool parameter, but I'm not sure if it's a good idea.

Best regards 

Some of you might not be aware of this "Known Issue/Limitation" when defining a BPL-based Business Process.

And those who are not might have encountered this (somewhat "unpleasant" error):