Announcing Hazelcast Platform 5.5 Release

The latest release, Hazelcast Platform 5.5, strengthens Hazelcast’s role as a key architecture for AI and critical applications for leading enterprises. This version combines distributed computing, in-memory data storage, intelligent integration, and vector search. Whether modernizing existing applications, starting AI projects, or accelerating next-generation systems, Hazelcast Platform adapts to evolving business needs. Known for its success in financial services technology, Hazelcast Platform benefits any business that prioritizes performance, resilience, and scalability, both now and as they grow.

Advanced AI initiatives require increased processing power and data, particularly those involving large language models. However, there are more cost-effective solutions than expanding the technology stack. Instead, modern, scalable, and highly efficient software-based technologies like Hazelcast Platform are necessary to maximize hardware performance. This approach helps overcome the cost and complexity challenges associated with advancing existing architectures.

Hazelcast Platform 5.5 introduces several new features, including:

• Vector Search: Hazelcast Platform is the first to integrate distributed computing, stream processing, and in-memory data storage into a single architecture and now offers further enhancement by adding vector search. This unified architecture runs within a single runtime environment, eliminating the need for multiple disparate software tools. [Documentation]
• Jet Job Placement Control: Enhances versatility and resilience for compute-intensive workloads by allowing jet jobs to be run on compute-only nodes (i.e., lite members). [Documentation]
• Client Multi-Member Routing: Optimizes performance and stability for client applications connecting to geographically dispersed clusters (stretched clusters). [Documentation]
• Long-Term Support (LTS): Ensures minimal disruption during upgrades by offering 3-year contracted LTS agreements, surpassing industry standards, and reinforcing Hazelcast’s commitment to future-proofing and supporting application development. [Documentation]
• Dynamic Configuration using the REST API: Hazelcast offers a REST API that enables access to your data structures and cluster via HTTP/HTTPS protocols. It includes an integrated Swagger UI for exploring the API and testing API calls. [Documentation]
• Feast Feature Store Integration: The Hazelcast online store supports materializing feature values into a Hazelcast cluster for serving real-time online features. To use Hazelcast as an online store, ensure you have a running Hazelcast cluster. [Documentation]

Vector Search

A Hazelcast Platform vector database engine is a specialized database optimized for storing, searching, and managing vector embeddings and their associated metadata. The metadata can include values that enable filtering, additional processing, or analysis of the vectors.

The Pipeline API now supports similarity search and ingesting unstructured data. This makes it simple to construct scalable, robust pipelines that compute and store embeddings.

Like maps, vector collections are partitioned and can have one or more indices. You can configure a new collection and index using static configuration or code, as shown below.

hazelcast: 

vector-collection:
   image-collection:
      indexes:
          - name: main-index
            dimension: 512
            metric: COSINE

Or programmatically:

Config config = new Config();
VectorCollectionConfig collectionConfig = new VectorCollectionConfig("books")
    .addVectorIndexConfig(
      new VectorIndexConfig()
        .setName("word2vec-index")
        .setDimension(6)
        .setMetric(Metric.COSINE)
    )
    .addVectorIndexConfig(
      new VectorIndexConfig()
        .setName("glove-index")
        .setDimension(10)
        .setMetric(Metric.DOT)
        .setMaxDegree(32)
        .setEfConstruction(256)
        .setUseDeduplication(false)
    );
config.addVectorCollectionConfig(collectionConfig);
HazelcastInstance hz = Hazelcast.newHazelcastInstance(config);

Vector collections hold instances of VectorDocument. A VectorDocument consists of an array of floats (the actual vector), and metadata. The metadata can be of any type. The example below shows creating a vector with a JSON String for metadata, and adding it to a vector collection. Similar to maps, vector collection entries consist of a key and a VectorDocument value.

// create the document
VectorDocument<string> document = VectorDocument.of(
    "{'genre': 'novel', 'year': 1976}",
    VectorValues.of(
      new float[]{0.2f, 0.9f, -1.2f, 2.2f, 2.2f, 3.0f}
    )
);

 // insert the document with a key value of "1"
CompletionStage&lt;VectorDocument<string>&gt; result =
    vectorCollection.putAsync("1", document)
; 
// a VectorDocument can also be retrieved by key
CompletionStage&lt;VectorDocument<string>&gt; result =
    vectorCollection.getAsync("1")
; 

To perform a similarity search, supply a query vector and SearchOptions. The search options allow you to specify the number of matches to retrieve as well as what should be included with the result. Note that if you have more than one index, you need to specify the name of the index to search in the VectorValues.of() method as shown below.

VectorValues queryVector = VectorValues.of("main-index",
    new float[]{0f, 0f, 0.2f, -0.3f, 1.2f, -0.5f});
CompletionStage<SearchResults<String, String>> results = vectorCollection.searchAsync(
    queryVector,
    SearchOptions.builder()
      .limit(5)
      .includeVectors()
      .includeValue()
      .build()
);

Jet Job Placement Control

This feature enables the user to designate, at deployment time, which cluster members an event processing pipeline can use. The primary use case is to restrict the execution of event processing pipelines to lite members.

Restricting pipeline execution to lite members enables the available compute capacity to be scaled independently of the data capacity. This is important because adding members that hold data necessarily involves data movement. If the need is only to add compute capacity then moving the data is unnecessary and slow. In short, this approach enables rapid flexing of the compute capacity for pipelines.

Examples of compute-intensive workloads that may benefit from this architecture include pipelines that ingest unstructured data because calculating embeddings is compute-intensive and ML inference pipelines.

The diagram below illustrates how Jet jobs can be deployed to lite-members only.

To restrict pipeline execution to lite-members, use the new JobBuilder API, as shown below.

// create the pipeline
Pipeline myPipeline = createPipeline();

 // submit the job, restricting execution to lite members
Job job = hz.getJet()
    .newJobBuilder(myPipeline)
    .withMemberSelector(JetMemberSelector.ALL_LITE_MEMBERS)
    .start();

Cluster Multi-Member Routing

In earlier releases of Hazelcast, clients could either connect to one member (unisocket mode) or all members (smart mode). This release enables multi-member mode, which works with the partition groups mechanism [Documentation]. In multi-member mode, the client connects to all members of a single partition group. Since each partition group contains all the data, read operations can be routed directly to the member that contains the data, improving overall throughput. In this way, it behaves similarly to clients in smart mode and provides many of the same benefits. As with unisocket mode, if access to a member in a different partition group is required, any of the members to which the client is already connected can act as a proxy.

The primary use case for this feature is with geographically distributed clusters. In these clusters, partition groups are equated with geographic locations. From a networking perspective, clients may be closest to one location. Multi-member mode allows clients to preferentially connect to the closest set of members (i.e., partition group).

The diagram below shows the 3 possible client routing strategies and how they work in a geographically distributed cluster.

A Java client can be configured to use multi-member mode programmatically or via static configuration as shown below.

ClientConfig clientConfig = new ClientConfig();
clientConfig.getNetworkConfig()
    .getClusterRoutingConfig()
    .setRoutingMode(RoutingMode.MULTI_MEMBER);
// configure other options as desired, then create the client 
HazelcastInstance hz =
    HazelcastClient.newHazelcastClient(clientConfig);

hazelcast-client:
  network:
    cluster-routing:
      mode: MULTI_MEMBER
      # PARTITION_GROUPS is currently the only strategy
      grouping-strategy: PARTITION_GROUPS

Long-Term Support (LTS)

Hazelcast has introduced long-term support (LTS) releases to streamline your upgrade process. You can upgrade directly from a supported previous version to an LTS release or between LTS releases using a rolling upgrade.

Starting with Hazelcast Platform 5.5, LTS releases allow you to upgrade directly from version 5.2.x or later to 5.5, skipping intermediate versions. We recommend upgrading to 5.5 from the latest patch available for your current version.

High-level process

The process for upgrading to an LTS release is the same as for a rolling upgrade. To summarize, the process involves the following steps:

1. For each member in the cluster:
   • Shut down the member and wait for all partitions to migrate to the rest of the cluster
   • Upgrade the member’s codebase
   • Start the member and wait for it to join the cluster
2. Trigger the rolling upgrade on the cluster

Between long-term support (LTS) releases, Hazelcast will offer short-term support (STS) releases. You have two upgrade options: either upgrade directly from one LTS to the next LTS, or upgrade incrementally from one LTS through each STS release until reaching the next LTS. Before choosing the approach that best suits your needs, consider the following:

Dynamic Configuration Using the REST API

Hazelcast offers a REST API that enables access to your data structures and clusters via HTTP/HTTPS protocols. It includes an integrated Swagger UI for exploring the API and testing API calls.

To use the REST API, ensure you have at least one running server instance with REST enabled. Enabling the REST API grants access to various endpoints, allowing you to perform data retrieval, cluster and member actions, CP operations, configuration updates, and more by calling the appropriate endpoints.

Access the Swagger UI:

The REST API’s Swagger UI offers detailed information about each endpoint, such as required parameters, request and response structures and types, possible response codes, and example responses. This UI allows you to easily navigate and test different API calls directly from the interface. To access the Swagger UI:

1. Enable the REST API
2. Start a Hazelcast member
3. Go to http://<host>:<port>/swagger-ui/index.html, replacing <host> and <port> with the running member’s IP address/hostname and port.

You can use the /hazelcast/rest/api/v1/config/update REST endpoint to modify dynamic server configurations. This feature lets you dynamically change existing configurations or add new configurations for Hazelcast data structures

Feast Feature Store Integration

The Hazelcast online store supports materializing feature values into a Hazelcast cluster for serving real-time online features. To use Hazelcast Platform as an online store, ensure you have a running Hazelcast cluster.

• Each feature view is mapped one-to-one to a specific Hazelcast Platform IMap.
• This implementation inherits all of Hazelcast’s strengths, including high availability, fault tolerance, and data distribution.
• The Hazelcast online store supports secure TLS/SSL connections.
• You can set the TTL (Time-To-Live) for your features in the Hazelcast cluster.
• Each feature view corresponds to an IMap in the Hazelcast cluster, with each entry representing the features of entities. Each feature value is stored separately and can be retrieved individually.

In order to use Hazelcast Platform online store, you’ll need to run pip install 'feast[hazelcast]'. You can then get started with the command feast init REPO_NAME -t hazelcast.

feature_store.yaml

project: my_feature_repo
registry: data/registry.db
provider: local
online_store:
  type: hazelcast
  cluster_name: dev
  cluster_members: ["localhost:5701"]
  key_ttl_seconds: 36000

Getting Started

Hazelcast Platform 5.5 is available today and several resources can help you get started:

• Request a Hazelcast Platform trial license key
• What’s New in Hazelcast Platform 5.5 (Documentation)
• Learn more about Hazelcast Platform