I am regularly contacted by customers about memory sizing when they get alerts that free memory is below a threshold, or they observe that free memory has dropped suddenly. Is there a problem? Will their application stop working because it has run out of memory for running system and application processes? Nearly always, the answer is no, there is nothing to worry about. But that simple answer is usually not enough. What's going on?

Consider the chart below. It is showing the output of the free metric in vmstat. There are other ways to display a system's free memory, for example, the free -m command. Sometimes, free memory will gradually disappear over time. However, the chart below is an extreme example, but it is a good example to illustrate what's going on.

As you can see, at around 2 am, some memory is freed, then suddenly drops close to zero. This system is running the IntelliCare EHR application on the InterSystems IRIS database. The vmstat information came from a ^SystemPerformance HTML file that collects vmstat, iostat and many other system metrics. What else is going on on this system? It is the middle of the night, so I don't expect much is happening in the hospital. Let's look at iostat for the database volumes.

There is a burst of reads at the same time as the free memory drops. The drop in reported free memory aligns with a spike in large block-sized reads (2048 KB request size) shown in iostat for the database disk. This is very likely a backup process or file copy operation. Ok, so correlation isn't causation, but this is worth looking at, and it turns out, explains what's going on.

Let's look at some other output from ^SystemPerformance. The command free -m is run at the same rate as vmstat (for example, every 5 seconds), and is output with a date and time stamp, so we can also chart the counters in free -m.

The counters are:

• Memtotal – Total physical RAM.
• used – RAM in active use (apps + OS + cache).
• free – Completely unused RAM.
• shared – Memory shared between processes.
• buf/cache – RAM used for buffers & cache, reclaimable if needed.
• available – RAM still usable without swapping.
• swaptotal – Total swap space on disk.
• swapused – Swap space currently in use.
• swapfree – Unused swap space.

Why does free memory drop at 2 am?

• The large sequential reads fill the filesystem page cache, temporarily consuming memory that appears as "used" in free -m.
• Linux aggressively uses otherwise idle memory for caching I/O to improve performance.
• Once the backup ends (≈ 03:00), memory is gradually reclaimed as processes need it.
• Around 6 am, the hospital starts to get active, and memory is used for IRIS and other processes.

Low free memory is not a shortage, but rather the system utilising "free" memory for caching. This is normal Linux behaviour! The backup process is reading large amounts of data, which Linux aggressively caches in the buffer/cache memory. The Linux kernel converts "free" memory into "cache" memory to speed up I/O operations.

Summary

The filesystem cache is designed to be dynamic. If a process requires memory, it will be immediately reclaimed. This is a normal part of Linux memory management.

Does Huge Pages have an impact?

For performance and to reserve memory for IRIS shared memory, the best practice for production IRIS deployments on servers with large memory is to use Linux Huge Pages. For IntelliCare, a rule of thumb I use is to use 8 GB memory per core and around 75% of memory for IRIS shared memory -- Routine and Global buffers, GMHEAP, and other shared memory structures. How shared memory is divided up depends on application requirements. Your requirements could be completely different. For example, using that CPU to memory ratio, is 25% enough for your application IRIS processes and OS processes?

InterSystems IRIS uses direct I/O for database and journal files, which bypasses the filesystem cache. Its shared memory segments (globals, routines, gmheap, etc.) are allocated from Huge Pages.

• These huge pages are dedicated to IRIS shared memory and do not appear as "free" or "cache" in free -m.
• Once allocated, huge pages are not available for filesystem cache or user processes.

This explains why the free -m metrics look "low" even though the IRIS database itself is not starved of memory.

How is the free memory for a process calculated?

From above, in free -m, the relevant lines are:

• free – Completely unused RAM.
• available – RAM still usable without swapping.

Available is a good indicator — it includes reclaimable cache and buffers, showing what’s actually available for new processes without swapping. What processes? For a review, have a look at InterSystems Data Platforms and Performance Part 4 - Looking at Memory . A simple list is: Operating system, other non-IRIS application processes, and IRIS processes.

Let's look at a chart of the free -m output.

Although free drops near zero during the backup, available remains much higher (tens of GB). That means the system could provide that memory to processes if needed.

Where do huge pages appear in free?

By default, free -m does not show huge pages directly. To see them, you need /proc/meminfo entries like HugePages_Total, HugePages_Free, and Hugepagesize.

Because the OS reserves huge pages at startup, they are effectively invisible to free -m. They are locked away from the general memory pool.

Summary

• The low "free memory" seen around 02:00 is caused by the Linux page cache being filled by backup reads. This is expected behaviour and does not indicate a memory shortage.
• Huge pages reserved for IRIS are unaffected and continue serving the database efficiently.
• The actual memory available to applications is best measured by the available column, which shows the system still has sufficient headroom.

But wait, what about if I don't use Huge Pages?

It is common not to use Huge Pages on non-production or systems with limited memory -- performance gains of Huge Pages are usually not significant under 64 GB, although it is still best practice to use Huge Pages to protect IRIS shared memory.

Sidebar. I have seen sites get into trouble by allocating Huge Pages smaller than shared memory, which causes IRIS to try and start with very small global buffers or fail to start if memlock is used (consider memlock=192 for production systems).

Without Huge Pages, IRIS shared memory segments (globals, routines, gmheap, etc.) are allocated from normal OS memory pages. This would show up under “used” memory in free -m. It would also contribute to “available” going lower, because that memory can’t easily be reclaimed.

• used – Much higher, reflecting IRIS shared memory + kernel + other processes.
• free – Likely lower, because more RAM is permanently allocated to IRIS in the regular pool.
• buf/cache – Would still rise during backups, but the apparent headroom for processes would look tighter because IRIS memory is in the same pool.
• available – Closer to the true “free + reclaimable cache” minus IRIS memory. This would look smaller than in your Huge Pages setup.

So, should you use Huge Pages on production systems?

YES!

For memory protection. IRIS shared memory is protected from:

• Swap out during memory pressure.
• Competition with filesystem operations like backups and file copies, as we have seen in this example.

Other notes - into the weeds...

How is the data collected?

The command used in ^SystemPerformance for a 24-hour collection (17280 seconds) with 5 second tick is:

free -m -s 5 -c 17280 | awk '{now=strftime(""%m/%d/%y %T""); print now "" "" $0; fflush()}' > ","/filepath/logs/20250315_000100_24hours_5sec_12.log

The 2025.1.2 and 2024.1.5 maintenance releases of InterSystems IRIS^® data platform, InterSystems IRIS^® for Health^TM, and HealthShare^® Health Connect are now Generally Available (GA). These releases include the fixes for a number of recently issued alerts and advisories, including the following: 

One of the recommendations when deploying InterSystems Technologies for production is to set up High Availability. The recommended API Manager for these InterSystems Technologies is the InterSystems API Manager (IAM). IAM (essentially Kong Gateway) has multiple deployment topologies.

If you are looking for high availability you could use:

a) Kong Traditional Mode: Multiple Node Clusters

b) Hybrid Mode

c) DB-less Mode

Before we break them down let's first understand the out of the box deployment that is provided by InterSystems: Installing IAM Version 3.10.

Kong Traditional Mode

I joined InterSystems less than a year ago. Diving into ObjectScript and IRIS was exciting, but also full of small surprises that tripped me up at the beginning. In this article I collect the most common mistakes I, and many new colleagues, make, explain why they happen, and show concrete examples and practical fixes. My goal is to help other new developers save time and avoid the same bumps in the road.

1. Getting lost among system classes and where to start

A benefit of using Doxygenerate is that Doxygen does more than just HTML output. Tweak the Doxyfile that tells Doxygen what to do and you can easily create a PDF. Our example MARINA application yielded a 524-page PDF. Here's what page 94 looks like:

You can browse the whole file here.

In the screenshot above, notice how we only get details of the superclass that is part of the app (AuditHistory). The primary superclass, %Library.SerialObject, is shown faded and with no details of what BankDetails inherits from it.

IAM - InterSystems API Manager is a great tool for monitoring your traffic. If you are trying to use it in your Kubernetes cluster you may have tried doing a deployment similar to this one:

Hi, I'm wondering what are the diferences between a method or classmethod with the language set at tsql and a querry writen in sql.
If anyone know if there is some difference and what they are, I would be glad to learn. 😊

The 2025.1.1 maintenance releases of InterSystems IRIS^® data platform, InterSystems IRIS^® for Health^TM, and HealthShare^® Health Connect are now Generally Available (GA). Please share your feedback through the Developer Community so we can build a better product together.

Documentation

You can find the detailed change lists & upgrade checklists on these pages:

• InterSystems IRIS
• InterSystems IRIS for Health
• HealthShare Health Connect

Early Access Programs (EAPs)

There are many EAPs available now. Check out this page and register to those you are interested.

How to get the software?

InterSystems is pleased to announce the General Availability (GA) of the 2025.2 release of InterSystems IRIS® data platform. This is a Continuous Delivery (CD) release. Please note that the GA versions of InterSystems IRIS for Health™ and HealthShare® Health Connect™ 2025.2 are currently withheld due to mirroring limitations introduced by security updates (details below).

Release Highlights

This release introduces impactful enhancements across security, developer experience, operations, and interoperability. Notable new features include:

I was wondering what best practice was for using macros in Embedded Python, i.e. iris.execute('$$$MACRO()') or something else. Does anyone have insight into this?

Hi everyone,

It's me again😁. As usual I would like to share something I study recently, and today, I would like to share about the document DB😁.

1st of all, let's go to the documentation https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=GDOCDB_intro
Well, I must say, this one is much better to follow than the others, which I read before. 😭 Finally😭😭

Ok, let's start walking through it together

Here we go😀, we start a terminal from VSCode to connect to our IRIS

We are going to created Document DB demo.docpatient
 

1.1 Check the Document DB exist or not

The 2024.1.4 and 2023.1.6 maintenance releases of InterSystems IRIS^® data platform, InterSystems IRIS^® for Health^TM, and HealthShare^® Health Connect are now Generally Available (GA). These releases include the fixes for the following alert recently issued - Alert: SQL Queries Returning Wrong Results | InterSystems. Please share your feedback through the Developer Community so we can build a better product together.

Documentation

You can find the detailed change lists & upgrade checklists on these pages:

• InterSystems IRIS
• InterSystems IRIS for Health
• HealthShare Health Connect

Hi Community,

We’re excited to introduce the AskMe assistant—try it out for yourself!

If you look at the values.yaml of the IKO's Helm chart you'll find:

useIrisFsGroup:false

Let's break down what it is and in what situations you may want to set it to true.

FsGroup refers to the file system group.

By default, Kubernetes volumes are owned by root, but we need IRIS to own its files (IRIS in containers is installed under irisowner user). To get around this we employ one of two methods:

1) initContainers

InterSystems Announces General Availability of InterSystems IRIS, InterSystems IRIS for Health, and HealthShare Health Connect 2025.1

The 2025.1 release of InterSystems IRIS® data platform, InterSystems IRIS^® for Health^TM, and HealthShare^® Health Connect is now Generally Available (GA). This is an Extended Maintenance (EM) release.

Release Highlights

In this exciting release, users can expect several new features and enhancements, including:

Are you a developer, data engineer, integration engineer, or data scientist who works hands-on with InterSystems products? 

We are conducting 30-45 minute interviews to understand your experience — how you started with InterSystems products, where you find helpful code samples, and how we can improve our products to better support your journey. 

✅ If you’re interested, fill out a quick survey to share your contact info and experience.

If you're selected, we will schedule a session at your convenience between April 2 and May 8 for an interview based on the information you provide.

🎁 As a thank-you, interview participants will receive 10,000 Global Masters points!

Your feedback will directly help us improve your experience using InterSystems products and services.

Kindly note that the spots are limited. 

Intro

In the process of trying to get more familiar with Objectscript I decided to try to build a general priority queue since I wasn't able to find an implementation anywhere. My though process for implementing this followed this general path.

Binary Heap

My first though to try to make this work quickly was to implement a binary heap and my first attempt at this used a multidimensional to build it. This version was relatively efficient, worked for strings/numbers natively, and worked for objects be letting the user override the comparitor.

Class pqueue.Queue Extends %RegisteredObject
{

Property Data As %Any [ MultiDimensional ];

Property Size As %Integer [ InitialExpression = 0 ];

Property Comparitor As %String [ InitialExpression = "(a,b) return a < b" ];

Method Swap(i As %Integer, j As %Integer) As %Status [ Private ]
{
set temp = ..Data(i)
set ..Data(i) = ..Data(j)
set ..Data(j) = temp
}

Method Comp(x As %Any, y As %Any) As %Boolean [ Private ]
{
return $XECUTE(..Comparitor, x, y)
}

Method PercolateUp(idx As %Integer) [ Private ]
{
while idx > 0 {
    set newidx = (idx-1)\2

    if ..Comp( ..Data(idx), ..Data(newidx) ) do ..Swap( idx, newidx )
    else                                     Quit

    set idx = newidx
}
}

Method PercolateDown() [ Private ]
{
set idx = 0

while ((idx+1)*2) < ..Size {
    if ..Comp( ..Data(idx*2+2), ..Data(idx*2+1) ) set newidx = idx*2+2
    else                                          set newidx = idx*2+1

    if ..Comp( ..Data(idx), ..Data(newidx) ) Quit

    do ..Swap( idx, newidx )
    set idx = newidx
}

if ( (idx*2+1 < ..Size) && ..Comp( ..Data(idx*2+1), ..Data(idx) ) ) do ..Swap( idx, idx*2+1 )
}

Method IsEmpty() As %Boolean
{
return ..Size = 0
}

Method Top() As %Any
{
if ..IsEmpty() return ""
return ..Data(0)
}

Method Put(inp As %Any) As %Status
{
set sts = $$$OK

set ..Data( ..Size ) = inp
do ..PercolateUp( ..Size )
set ..Size = ..Size + 1

return sts
}

Method Get(Output obj As %Any) As %Status
{
set sts = $$$OK
if ..IsEmpty() {
    set obj = ""
    return $$$ERROR( "Cannot Get() from empty Queue" )
}

set obj = ..Data( 0 )
set ..Size = ..Size - 1
set ..Data( 0 ) = ..Data( ..Size )
do ..PercolateDown()
kill ..Data( ..Size )
return sts
}

Method GenerateComparitor(operator As %String = "<", transform As %String = "") As %Status
{
set ..Comparitor = "(a,b) return a" _ transform _ " " _ operator _ " b" _ transform
return $$$OK
}

}

After getting this working I wanted to try out different internal arrays since I assumed multidimensional arrays must be slower than a simple integer indexed array. So I modified the above code to use

• Property Data As list Of %Any; : This works OK but it is about 3-4 times slower than using a multidimensional making it pointless.
• Property Data As %DynamicArray; : I assumed this would be relatively fast but proved to be slow to the point of absurdity. When the amount of data stored in the queue is small it is around as fast as the list of %Any, but as the data grows the time it takes to make inserts and gets grows linearly which makes it pointless to build a heap on top of.

Using the Multidimensional Array's Self-sorting

On its face this idea seems pretty simple, use the fact that the multidimensional array is always sorted to grab the lowest cost (highest priority) item. A problem with this are that indexing by an object simply uses the string representation of that object which isn't useful. To handle this a customer evaluator function is needed to return the integer or string evaluation of an object which is then sorted, it is then stored as data( evaluation, obj_str_rep ) = object which ensures that objects are correctly sorted even when two objects evaluate to the same value.

Class pqueue.SparseQueue Extends %RegisteredObject
{

// Parameter Comp(a,b) As $XECUTE(..Comparitor, a, b);

Property Data As %Any [ MultiDimensional ];

Property Size As %Integer [ InitialExpression = 0 ];

Property Evaluator As %String [ InitialExpression = "(a) return a" ];

Method IsEmpty() As %Boolean
{
    return ..Size = 0
}

Method Top() As %Any
{
    if ..IsEmpty() return ""
    return $Order( ..Data("") )
}

Method Put(inp As %Any) As %Status
{
    set sts = $$$OK

    set ..Data( $XECUTE(..Evaluator, inp), inp ) = inp
    set ..Size = ..Size + 1

    return sts
}

Method Get(Output obj As %Any) As %Status
{
    set sts = $$$OK
    if ..IsEmpty() {
        set obj = ""
        return $$$ERROR( "Cannot Get() from empty Queue" )
    }

    set loc = $ORDER( ..Data("") )
    set obj = ..Data(loc, $ORDER( ..Data(loc, "")))

    set ..Size = ..Size - 1
    kill ..Data( loc, obj )
    return sts
}

Method GenerateEvaluator(transform As %String = "") As %Status
{
    set ..Evaluator = "(a) return a" _ transform
    return $$$OK
}

}

This method proved to be by far the fastest. It has some slight disadvantages in that it can be harder to write an evaluator than a comparitor and, in the form given above, it cannot hold the same object at the same value twice (this is a rare case but could theoretically be a problem or a benefit).

Speed Test

To test these out I wrote a simple script that generates a large randomized weighted directed graph and runs Dijkstra's shortest path algorithm using a given queue object. Using a graph with 150000 vertices where each has 10 neighbors, the output is printed below. Here while the algorithm is running an update is printed every 10000 edges checked, where the time since the last 10 thousand and size of the priority queue is printed, with some final stats at the end. The order they are run in is

• Self-sorting Multidimensional

• Heap Multidimensional

• Heap Dynamic Array

• Heap List of Object

Generated Random Graph

Running 1664388@pqueue.SparseQueue Done Initial Step Checking edges

10000 - 3.1151779 - 86709 20000 - 3.6075209 - 166999 30000 - 2.9923264 - 241546 40000 - 3.4856531 - 310390 50000 - 3.1714395 - 374396 60000 - 4.9496489 - 433555 70000 - 2.3947319 - 489044 80000 - 3.2073625 - 539410 90000 - 3.5492076 - 586065 100000 - 3.8483492 - 629463 110000 - 1.9906381 - 669002 120000 - 2.4800312 - 705165 130000 - 3.2020008 - 738792

Found path of distance 134.957 after checking 138752 edges

Running 1664178@pqueue.Queue Done Initial Step Checking edges 10000 - 29.0445107 - 86709 20000 - 28.278281 - 166999 30000 - 27.2860397 - 241546 40000 - 26.6431472 - 310390 50000 - 26.2807624 - 374396 60000 - 28.1151768 - 433555 70000 - 27.5075059 - 489044 80000 - 29.4012881 - 539410 90000 - 27.4369653 - 586065 100000 - 26.743563 - 629453 110000 - 27.0132265 - 669002 120000 - 26.9039187 - 705175 130000 - 26.8454762 - 738782

Found path of distance 134.957 after checking 138753 edges

Running 1664308@pqueue.DynamicQueue Done Initial Step Checking edges 10000 - 83.6996966 - 86709 20000 - 136.8056452 - 166999 30000 - 176.4097968 - 241546 40000 - 228.9383939 - 310390 50000 - 250.5338934 - 374396 60000 - 268.3424439 - 433555 70000 - 279.7747292 - 489044 80000 - 290.0156605 - 539410 90000 - 295.9455988 - 586065 100000 - 282.0121209 - 629453 110000 - 306.5787604 - 669002 120000 - 302.9471951 - 705175 130000 - 299.4361629 - 738782

Found path of distance 134.957 after checking 138753 edges

Running 1664237@pqueue.ListOfQueue Done Initial Step Checking edges 10000 - 127.688423 - 86709 20000 - 140.2352706 - 166999 30000 - 131.0675351 - 241546 40000 - 137.0392259 - 310390 50000 - 129.6285655 - 374396 60000 - 133.0306415 - 433555 70000 - 138.8908825 - 489044 80000 - 136.6955307 - 539410 90000 - 136.6123544 - 586065 100000 - 126.6696681 - 629453 110000 - 131.6500795 - 669002 120000 - 126.1802136 - 705175 130000 - 133.6258408 - 738782

Found path of distance 134.957 after checking 138753 edges

Found path that takes 134.957 in 45.157 (1664388@pqueue.SparseQueue) Found path that takes 134.957 in 381.095 (1664178@pqueue.Queue) Found path that takes 134.957 in 3466.382 (1664308@pqueue.DynamicQueue) Found path that takes 134.957 in 1839.445 (1664237@pqueue.ListOfQueue)

Here we can see that the dynamic array is the only one that has significant growth as its size gets bigger (this growth doesn't continue since, as more of the graph has been checked, the odds that any node has already been visited and gets skipped would grow letting more of the work get skipped). We can also see that the self-sort method checks one less edge (in other trials I've seen this number be 0 and 10+), this is a result of two paths to the same node taking the same amount of time and therefore not being able to be stored separately, which is convenient in this case.

As of InterSystems IRIS® data platform version 2025.1, InterSystems is officially deprecating MultiValue and including it in the Deprecated and Discontinued Features list. While InterSystems will continue to support existing customers using MultiValue, it is not recommended for new applications.

What This Means for You:

The first developer previews of InterSystems IRIS^® data platform, InterSystems IRIS^® for Health, and HealthShare^® Health Connect 2025.1 have been posted to the WRC developer preview site.  Containers can be found on our container registry and are tagged latest-preview.

These developer previews include the feature to migrate to IBM "Open XL C/C++ for AIX" 17.x compiler ensuring compatibility with future AIX builds as older compilers approach end-of-support. This migration focuses on the aixopenssl30 target, supporting SSL3 on AIX 7.2 and 7.3.

The IKO will dynamically provision storage in the form of persistent volumes and pods will claim them via persistent volume claims.

But storage can come in different shapes and sizes. The blueprint to the details about the persistent volumes comes in the form of the storage class.

This raises the question: we've deployed the IrisCluster, and haven't specified a storage class yet. So what's going on?

You'll notice that with a simple

kubectl get storageclass

February 19, 2025 – Alert: SQL Queries Returning Wrong Results

InterSystems has corrected two issues that can cause a small number of SQL queries to return incorrect results. In addition, InterSystems has corrected an inconsistency in date/time datatype handling that may lead to different, unexpected – yet correct – results for existing applications that rely on the earlier, inconsistent behavior.

DP-436825: SQL Queries with Lateral Join May Return Wrong Results

Hi Community,

We're pleased to invite you to the upcoming webinar in Hebrew:

👉 Hebrew Webinar: GenAI + RAG - Leveraging Intersystems IRIS as your Vector DB👈

📅 Date & time: February 26th, 3:00 PM IDT

The IKO allows for sidecars. The idea behind them is to have direct access to a specific instance of IRIS. If we have mirrored data nodes, the web gateway will (correctly) only give us access to the primary node. But perhaps we need access to a specific instance. The sidecar is the solution.

Building on the example from the previous article, we introduce the sidecar by using a mirrored data node and of course arbiter.

All pods are assigned a Quality of Service (QoS). These are 3 levels of priority pods are assigned within a node.

The levels are as following:

1) Guaranteed: High Priority

2) Burstable: Medium Priority

3) BestEffort: Low Priority

It is a way of telling the kubelet what your priorities are on a certain node if resources need to be reclaimed. This great GIF below by Anvesh Muppeda explains it.

We now get to make use of the IKO.

Below we define the environment we will be creating via a Custom Resource Definition (CRD). It lets us define something outside the realm of what the Kubernetes standard knows (this is objects such as your pods, services, persistent volumes (and claims), configmaps, secrets, and lots more). We are building a new kind of object, an IrisCluster object.

The latest extended maintenance releases of InterSystems IRIS, InterSystems IRIS for Health, and HealthShare Health Connect are now available.

✅ 2024.1.3

Release 2024.1.3 provides bug fixes for any of the previous 2024.1.x releases, including the fix for the following alert recently issued - Alert: Invalid Data Introduced to Database and Journal files with Specific....

You can find the detailed change lists & upgrade checklists on these pages:

• InterSystems IRIS
• InterSystems IRIS for Health
• HealthShare Health Connect

How to get the software

InterSystems has corrected a defect that causes invalid database and journal records to be introduced when using a specific $LIST syntax. The likelihood of encountering this defect is very low but the operational impacts can be significant.

Products Affected

The InterSystems platforms have always offered dynamic documentation of the packages and classes in a namespace, a feature known informally as Documatic. But what if you need to publish this class reference information on a website without requiring the site to be connected to an IRIS server containing the actual classes?

Who do we report Documentation issues to?

Since moving to the new format, when searching for things within the documentation I get a blank screen with no results.

When I type in my search criteria, I can see it trying to find results but does not return results.

This does not seem like it is limited to a certain Web Browser, as I have seen this happen in Chrome and Edge

Thanks

Scott

InterSystems announces General Availability of InterSystems IRIS, InterSystems IRIS for Health, and HealthShare Health Connect 2024.3

The 2024.3 release of InterSystems IRIS^® data platform, InterSystems IRIS^® for Health, and HealthShare^® Health Connect is now Generally Available (GA).

Release Highlights

In this release, you can expect a host of exciting updates, including:

1. Much faster extension of database and WIJ files
2. Ability to resend messages from Visual Trace
3. Enhanced Rule Editor capabilities
4. Vector search enhancements
5. and more.