Infinispan

Infinispan 16.2

2026-06-03T00:00:00+00:00

"Arctic Panzer Wolf"

Infinispan 16.2 is here, and it is codenamed "Arctic Panzer Wolf". Like the beer, this release packs a punch: it’s bold, it’s fierce, and there’s a lot of it.

RESP endpoint

This release is a huge step forward for our Redis-compatible RESP endpoint. So many new things that it deserves its own section!

Probabilistic data structures

We’ve implemented a whole family of probabilistic data structures:

Bloom Filters (BF.*): space-efficient probabilistic membership testing. Add items and check whether they might be in the set — with a configurable false positive rate.
Cuckoo Filters (CF.*): like Bloom Filters, but they also support deletion. Handy when your data is more dynamic.
Count-Min Sketch (CMS.*): estimate the frequency of items in a stream without storing all the data. Perfect for anomaly detection and traffic analysis.
Top-K (TOPK.*): maintain a list of the K most frequent items in a stream. While CMS can tell you how many times an item has appeared, Top-K tells you which items appear most often — it tracks the heavy hitters so you don’t have to query every item individually.
HyperLogLog (PFCOUNT, PFMERGE): estimate the cardinality of large datasets using very little memory. Count unique visitors, unique events, unique everything.

All of these work in clustered mode too!

New BITOP operations from Redis 8.2

Keeping up with the latest from Redis, we’ve added the four new bitwise operations introduced in Redis 8.2: These give you finer-grained control over bitwise set operations across keys.

GEOSEARCH commands

The GEOSEARCH family of commands is now fully implemented, letting you perform radius and bounding-box queries on geospatial data.

COPY, DELEX, DIGEST, and more

COPY: copy a key to another key, optionally replacing the destination.
DELEX: delete a key only if it exists (returning whether it was actually deleted).
DIGEST: return a hash digest of a key’s value.
SET conditional options: additional flags for conditional set operations.
PSUBSCRIBE / PUNSUBSCRIBE: pattern-based Pub/Sub subscriptions.
AGGREGATE COUNT option for ZUNION, ZINTER, ZUNIONSTORE, and ZINTERSTORE.
BITFIELD / BITOP: implemented all operations.

Local RESP caches in clustered mode

You can now use local RESP caches in a clustered server. Previously, a local RESP cache created on an unclustered server would prevent the server from starting in clustered mode. No more!

Infinispan Server

Granular JVM options

The server startup scripts now split JAVA_OPTS into independently overridable categories:

JAVA_OPTS_BASE — essential JVM flags (headless, ExitOnOutOfMemoryError, incubator modules)
JAVA_OPTS_NETWORK — network settings (IPv4/IPv6 stack preference)
JAVA_OPTS_MEMORY — heap, metaspace, and RAM percentage configuration
JAVA_OPTS_DEBUG — JPDA debug settings

Want to tweak just the memory settings? Set JAVA_OPTS_MEMORY and leave the rest alone. Setting JAVA_OPTS directly still overrides everything for backward compatibility.

ECS logging support

The server now bundles log4j-layout-template-json, enabling native Elastic Common Schema (ECS) formatted logging out of the box. Just point your Log4j2 config at the built-in ECS template:

No more custom images or runtime library hacking to get structured JSON logs into your Elasticsearch/Kibana stack.

Simplified PEM certificate configuration

TLS configuration with PEM certificates has been unified and simplified. The server now auto-detects keystore types, so you no longer need to juggle different property names for PEM vs PKCS#12 certificates.

Minimal boot logging

The server now uses minimal logging until the classpath is fully configured, preventing noisy or misleading log messages during early startup.

Configurable backpressure for Hot Rod client listeners

The server now supports configurable backpressure for Hot Rod client event listeners. When a client cannot consume events fast enough, the server buffers them up to a configurable limit instead of dropping events or blocking the originating cache operation. This gives operators control over the trade-off between memory usage and event delivery reliability for slow consumers.

Backup support for multimaps, RESP, and Memcached caches

Server backups now include multimap caches as well as caches created via the RESP and Memcached endpoints. Previously, these were silently skipped during backup and restore operations.

RocksDB cache store removed from the server distribution

The RocksDB cache store has been moved out of the server distribution. It is still available as a separate module if you need it, but the server image is now lighter. The bundled SIFS store is the recommended persistence option.

CLI

Suggestions

The CLI now provides suggestions based on your command history and command syntax.

Connection bookmarks

Tired of typing long connection URLs and credentials every time? The new bookmark command lets you save named connection bookmarks:

bookmark set prod -u https://prod-server:11222 --username admin --password secret
connect prod

Passwords are stored encrypted in a PKCS12 credential store. Bookmarks are also used by the new mcp CLI command for a seamless AI integration experience.

Core

JSON configuration schemas

Infinispan now provides JSON schemas that mirror the existing XSD schemas, making it easier to author and validate configuration in JSON and YAML formats with full editor support and autocompletion.

Pull-based state transfer

State transfer has been reworked to use a pull-based approach instead of the previous push model. This gives the receiving node much better control over backpressure and memory consumption during rebalancing. Previously, all existing owners would push data simultaneously, making memory pressure scale linearly with cluster size. The new approach is smarter and more efficient.

Memory monitor

A new MemoryMonitor component tracks JVM memory and GC health with configurable thresholds:

Memory threshold alerts when old generation heap usage exceeds a percentage (default 85%)
GC duration alerts when a single GC pause is too long (default 5 seconds)
GC pressure tracking alerts when too much time is spent in GC over a rolling window

All thresholds are tunable at runtime and configurable via a new element.

Dynamic eviction based on memory pressure

Eviction can now be driven by actual JVM memory pressure instead of relying solely on static entry counts or fixed memory sizes. When enabled, Infinispan monitors old generation heap usage and dynamically adjusts eviction thresholds to keep the JVM healthy. This means caches can make the most of available memory without the guesswork of manually sizing max-count or max-size — the system responds to real conditions, evicting more aggressively when memory is tight and relaxing when there is headroom.

Serialized cache entries on heap

You can now store cache entries in their serialized form even when using heap storage. This is particularly useful for entries with many fields where the serialized byte representation is more memory-efficient than the full Java object graph.

Graceful shutdown and network partitions

The graceful shutdown procedure has been hardened to handle network partitions correctly. Previously, star-shaped partitions (where the coordinator could see all nodes, but nodes couldn’t see each other) during restart could lead to data loss. This has been fixed.

Orderly cache scale-down

Stopping a cache or (concurrently) scaling down a cluster node while state transfer is in progress could previously result in data loss: the departing node would leave before its data had been fully redistributed to the remaining members. New overloads on Cache.stop(timeout, TimeUnit), EmbeddedCacheManager.stop(timeout, TimeUnit), and EmbeddedCacheManager.stopCache(cacheName, timeout, TimeUnit) let you specify how long to wait for any in-flight state transfer to complete before leaving. If the timeout elapses, the method returns false so you can decide what to do next. The existing no-arg stop() methods continue to work as before.

Generic Micrometer MeterRegistry support

Infinispan now supports any Micrometer MeterRegistry, not just Prometheus. This means you can use OTLP, Simple, or any other Micrometer registry implementation without needing a Prometheus dependency on the classpath.

Counter configuration events

Counter configuration changes (add/modify/remove) now generate container events and are streamed via the REST SSE listeners. This enables the Infinispan Operator to implement Counter custom resources.

SIFS persistence store improvements

The Soft-Index File Store (SIFS) has received several reliability and performance improvements:

Buffered index updates: index writes are now batched in memory before being flushed to disk, reducing the number of I/O operations and improving write throughput.
B+ tree refactoring: the internal B+ tree used for the SIFS index has been extracted into a standalone, independently testable class, resolving a number of hard-to-reproduce corruption issues related to soft reference reclamation and concurrent access.
Segment lifecycle fixes: fixed a race condition where rapid segment removal and re-addition could corrupt the index, and ensured that segment removal completes fully before the segment can be reused.
Persistence timeout support: persistence operations now have configurable timeouts, preventing the system from hanging indefinitely when a store operation stalls or a lock is never released.

ProtoStream

The ProtoStream serialization library has seen major improvements across performance, usability, and JSON support:

ASCII string optimizations: writing ASCII strings now takes advantage of the JVM’s internal String coder and value fields, and uses VarHandle for fixed-width writes, reducing encoding overhead.
Kotlin support: the annotation processor now supports Kotlin classes and data class types.
Copy-on-write serialization context: the serialization context state is now copy-on-write, improving thread safety when schemas are registered concurrently as well as improving performance.
JPMS support: ProtoStream is now fully modularized with proper module-info descriptors.

Query

ANTLR 4

The Ickle query parser has been migrated from the unmaintained ANTLR 3 to ANTLR 4, improving reproducible builds and eliminating a stale runtime dependency.

Spring Boot

Automatic schema registration

The Spring Boot integration now automatically registers Protobuf schemas, matching the behavior that was already available in the Quarkus integration.

Console

The web console has received a batch of usability improvements:

User permissions page: a new page to display current user permissions, making it easier to understand who can do what.

Schema editor with syntax highlighting: the schema editor now uses the Monaco code editor with Protobuf syntax highlighting and code assistance.

Manage columns in cache detail: customize which columns are displayed in the cache entries view.

Query history: your recent queries are now remembered, so you can quickly re-run them.

Swagger UI and metrics links: direct links to the Swagger UI and metrics endpoints from the console.
Truncate result values: a checkbox to truncate long values in query results for better readability.
Persistent pagination settings: pagination preferences are now remembered across sessions.
Cache deletion from detail view: delete a cache directly from its detail page.
Internationalization: updated translations for French, Spanish, Italian, and Brazilian Portuguese.

MCP

CLI stdio transport

Connecting your AI tools to Infinispan just got a whole lot easier. We’ve added an mcp command to the CLI that acts as a stdio transport bridge for the Model Context Protocol.

This means you can now use Infinispan as an MCP server from Claude Desktop, Claude Code, VS Code, or any other MCP client:

{
  "mcpServers": {
    "infinispan": {
      "command": "infinispan",
      "args": ["mcp", "--bookmark", "prod-cluster"]
    }
  }
}

The CLI command connects to the server’s /v3/mcp HTTP endpoint and proxies JSON-RPC messages via stdin/stdout. Use it with CLI bookmarks (we mentioned those above!) for a seamless, secure connection.

GC log as MCP resource

The server’s GC log is now exposed as an MCP resource, so your AI tools can inspect garbage collection behavior directly.

Backwards compatibility

Infinispan 16.2 is fully backwards compatible with 16.1 deployments.

The next release

According to our roadmap, our next release will be 16.3, and it will happen on 2026-10-07.

Release notes

You can look at the release notes to see what was changed since our previous release.

Get them from our download page.

Infinispan Hot Rod JS Client 0.14.0: Near Feature Parity with Java

2026-05-06T00:00:00+00:00

We are happy to announce the release of the Infinispan Hot Rod JS Client 0.14.0. This release brings the JavaScript client very close to feature parity with the Java Hot Rod client, with support for near caching, distributed counters, admin operations, and protocol auto-negotiation.

Protocol auto-negotiation

The client can now automatically negotiate the highest mutually-supported protocol version with the server. No more guessing which version to use: just set version: 'auto' and the client will pick the best available.

var infinispan = require('infinispan');

var client = await infinispan.client(
  {port: 11222, host: 'localhost'},
  {
    version: 'auto',
    authentication: {
      enabled: true,
      saslMechanism: 'DIGEST-MD5',
      userName: 'admin',
      password: 'changeit'
    }
  }
);

// Check which version was negotiated
console.log('Protocol:', client.getProtocolVersion());  // e.g. '4.1'

Near caching

Near caching stores recently accessed entries on the client side, dramatically reducing latency for read-heavy workloads. The cache uses LRU eviction and is automatically invalidated when entries are modified.

var client = await infinispan.client(
  {port: 11222, host: 'localhost'},
  {
    version: 'auto',
    nearCache: { maxEntries: 16 },
    authentication: { /* ... */ }
  }
);

await client.put('key', 'value');

// First get: fetches from server and populates the near cache
var v1 = await client.get('key');

// Second get: served from the local near cache, no server roundtrip
var v2 = await client.get('key');

// Writes automatically invalidate the near cache
await client.put('key', 'new-value');

Distributed counters

Distributed counters are cluster-wide atomic counters, available in two flavors: strong (linearizable, optionally bounded) and weak (higher concurrency, eventually consistent).

// Strong unbounded counter
await client.counterCreate('page-views', {
  type: 'strong',
  initialValue: 0
});

// Strong bounded counter
await client.counterCreate('stock', {
  type: 'strong',
  initialValue: 50,
  lowerBound: 0,
  upperBound: 1000,
  storage: 'persistent'
});

// Weak counter for high-throughput scenarios
await client.counterCreate('impressions', {
  type: 'weak',
  initialValue: 0,
  concurrencyLevel: 4
});

// Atomic operations
var current = await client.counterGet('page-views');
var updated = await client.counterAddAndGet('page-views', 1);
var swapped = await client.counterCompareAndSwap('stock', 50, 49);
await client.counterReset('page-views');

Admin operations

The client.admin namespace provides cache lifecycle management and Protobuf schema administration, enabling full cluster management directly from JavaScript.

// Create a cache from XML configuration
await client.admin.createCache('sessions',
  ''
);

// Idempotent create: no error if it already exists
await client.admin.getOrCreateCache('sessions',
  ''
);

// List all caches
var names = await client.admin.cacheNames();

// Remove a cache
await client.admin.removeCache('sessions');

// Register a Protobuf schema
await client.admin.registerSchema('person.proto', `
  package example;
  message Person {
    required string name = 1;
    optional int32 age = 2;
  }
`);

Protocol 3.1, 4.0, and 4.1 support

This release adds support for Hot Rod protocol versions 3.1, 4.0, and 4.1, each bringing new capabilities:

Protocol 3.1 — Distributed counter operations
Protocol 4.0 — Previous value with metadata in mutation responses
Protocol 4.1 — JSON data format support

// Protocol 4.0+: mutation operations can return previous values
var client = await infinispan.client(
  {port: 11222, host: 'localhost'},
  { version: '4.0', authentication: { /* ... */ } }
);

await client.put('key', 'original');
var prev = await client.put('key', 'updated', { previous: true });
console.log(prev);  // 'original'

Get started

Install the client via npm:

npm install infinispan

Check out the full source code and documentation on GitHub.

Vector search quickstart with Infinispan

2026-04-30T00:00:00+00:00

Vector databases have become essential building blocks for AI-powered applications. They let you store unstructured data — text, images, audio — as numerical embeddings that capture semantic meaning, and then find similar items using nearest-neighbour search.

Infinispan has supported vector search since version 15, and it does so with a distinctive approach: your data model is defined through ProtoStream annotations that generate Protobuf schemas automatically, your queries use the Ickle query language that seamlessly combines relational filters, full-text search, and kNN vector predicates, and your schemas can evolve over time without breaking existing clients.

This quickstart walks through a complete example — from defining a data model to running hybrid vector+metadata queries — using a catalogue of beers as our dataset. If the beer names look familiar, that’s because every Infinispan release is named after a beer.

Defining the data model

In Infinispan, entity classes are plain Java records (or POJOs) annotated with ProtoStream and indexing annotations. These annotations serve double duty: they define the Protobuf serialization schema and the search index mapping in a single place.

Here is our Beer entity:

@Proto
@Indexed
public record Beer(
   @Keyword(projectable = true, sortable = true)
   String name,

   @Keyword(projectable = true, normalizer = "lowercase")
   String style,

   @Keyword(projectable = true, sortable = true, normalizer = "lowercase")
   String brewery,

   @Keyword(projectable = true, normalizer = "lowercase")
   String country,

   @Basic(projectable = true, sortable = true)
   Double abv,

   @Text
   String description,

   @Vector(dimension = 3, similarity = VectorSimilarity.COSINE)
   float[] descriptionEmbedding
) {
}

A few things to note:

@Proto generates the Protobuf schema from the record fields — no separate .proto file to maintain.
@Indexed enables search indexing for the entity.
@Keyword fields are stored as exact tokens — ideal for beer names, styles, and brewery names. The normalizer option allows case-insensitive matching.
@Text fields are analyzed with a full-text tokenizer, enabling natural language search across tasting notes and descriptions.
@Vector(dimension = 3, similarity = VectorSimilarity.COSINE) marks the embedding field for kNN search. The dimension must match your vector size — here we use 3 for illustration, but a real embedding model would produce 384 or more dimensions.
@Basic handles numeric fields like ABV with support for range queries and sorting.

Generating the Protobuf schema

ProtoStream generates the schema and the marshaller at compile time. All you need is an interface:

@ProtoSchema(includeClasses = Beer.class, schemaPackageName = "quickstart")
public interface BeerSchema extends GeneratedSchema {
   BeerSchema INSTANCE = new BeerSchemaImpl();
}

The generated .proto schema is automatically registered with the server when your client connects. This schema can evolve — you can add new fields, deprecate old ones — without breaking clients that are still using the previous version. This is a direct benefit of Protobuf’s forwards and backwards compatibility guarantees.

Imagine you later want to add food pairing suggestions or IBU ratings: just add the field to the record, and older clients that don’t know about it will continue to work.

Connecting and storing data

ConfigurationBuilder builder = new ConfigurationBuilder();
builder.addServer().host("localhost").port(11222)
   .security().authentication().username("admin").password("secret");

RemoteCacheManager cacheManager = new RemoteCacheManager(builder.build());

RemoteCache cache = cacheManager.administration()
   .getOrCreateCache("beers", new XMLStringConfiguration(
      "" +
      "  " +
      "    " +
      "      quickstart.Beer" +
      "    " +
      "  " +
      ""));

Now let’s populate the cache with some beers — all named after Infinispan releases.

In a production application you would generate embeddings from a model such as all-MiniLM-L6-v2 (384 dimensions). For this quickstart we use hand-crafted 3-dimensional vectors where each axis captures a flavour profile: dark/roasty, light/crisp, and hoppy/craft. Beers of similar style naturally cluster together in this space — stouts near [1, 0, 0], lagers near [0, 1, 0], IPAs near [0, 0, 1] — so kNN queries return intuitive results.

cache.put("beer:1", new Beer(
   "Guinness", "Stout", "Guinness Brewery", "Ireland", 4.2,
   "A rich, creamy stout with deep roasted barley flavours, hints of coffee and chocolate, and a velvety smooth finish.",
   new float[]{0.95f, 0.05f, 0.10f}
));

cache.put("beer:2", new Beer(
   "Delirium", "Belgian Strong Ale", "Brouwerij Huyghe", "Belgium", 8.5,
   "A complex strong blonde ale with fruity esters, spicy phenols, and a warming alcohol presence balanced by a dry finish.",
   new float[]{0.30f, 0.30f, 0.70f}
));

cache.put("beer:3", new Beer(
   "Estrella Galicia", "Lager", "Hijos de Rivera", "Spain", 5.5,
   "A crisp European lager with a balanced malt backbone, mild hop bitterness, and a clean refreshing finish.",
   new float[]{0.10f, 0.90f, 0.15f}
));

cache.put("beer:4", new Beer(
   "Mahou", "Pilsner", "Mahou San Miguel", "Spain", 5.5,
   "A golden pilsner with delicate floral hop aromas, light biscuity malt, and a bright effervescent character.",
   new float[]{0.05f, 0.85f, 0.25f}
));

cache.put("beer:5", new Beer(
   "Corona Extra", "Pale Lager", "Grupo Modelo", "Mexico", 4.5,
   "A light, easy-drinking pale lager with subtle sweetness, a hint of citrus, and a crisp dry finish best enjoyed ice-cold.",
   new float[]{0.05f, 0.95f, 0.10f}
));

cache.put("beer:6", new Beer(
   "Tactical Nuclear Penguin", "Imperial Stout", "BrewDog", "Scotland", 32.0,
   "An extreme imperial stout aged in whisky casks, intensely smoky with dark chocolate, coffee, and dried fruit notes.",
   new float[]{0.98f, 0.02f, 0.20f}
));

cache.put("beer:7", new Beer(
   "Brahma", "Lager", "Ambev", "Brazil", 4.3,
   "A light Brazilian lager, smooth and mildly sweet, brewed for easy drinking in warm weather.",
   new float[]{0.05f, 0.92f, 0.05f}
));

cache.put("beer:8", new Beer(
   "Radegast", "Czech Lager", "Radegast Brewery", "Czech Republic", 5.0,
   "A traditional Czech lager with a prominent Saaz hop aroma, bready malt character, and a crisp bitter finish.",
   new float[]{0.15f, 0.80f, 0.30f}
));

cache.put("beer:9", new Beer(
   "Turia", "Märzen", "Turia Brewery", "Spain", 5.4,
   "A toasted amber märzen from Valencia with caramel malt sweetness, a nutty aroma, and a smooth medium body.",
   new float[]{0.60f, 0.40f, 0.15f}
));

cache.put("beer:10", new Beer(
   "Hoptimus Prime", "IPA", "Hoptimus Brewing", "USA", 7.5,
   "An aggressively hopped American IPA bursting with tropical fruit, pine resin, and grapefruit citrus over a sturdy malt backbone.",
   new float[]{0.10f, 0.15f, 0.95f}
));

cache.put("beer:11", new Beer(
   "Pagoa", "Basque Ale", "Pagoa Brewery", "Spain", 5.0,
   "A craft ale from the Basque Country with earthy hops, a light fruity character, and a balanced malty sweetness.",
   new float[]{0.25f, 0.35f, 0.60f}
));

Querying with Ickle

Before we get to vector search, let’s look at what Ickle can do with traditional queries. This is where Infinispan stands out: you don’t need to learn a separate query syntax for metadata filters and vector search — Ickle handles both.

Full-text search

Find beers whose description mentions "chocolate":

Query query = cache.query(
   "from quickstart.Beer b where b.description : 'chocolate'");
List results = query.list();
// Returns: Guinness, Tactical Nuclear Penguin

Keyword and range filters

Find session beers (under 5% ABV) from Spain:

Query query = cache.query(
   "from quickstart.Beer b where b.country = 'Spain' and b.abv < 5.0");
List results = query.list();

Projections and sorting

Select specific fields and sort by ABV — a good way to build a menu card:

Query query = cache.query(
   "select b.name, b.style, b.brewery, b.abv from quickstart.Beer b " +
   "where b.country = 'Spain' order by b.abv");
List results = query.list();
// Turia (5.4), Estrella Galicia (5.5), Mahou (5.5), Pagoa (5.0)

Vector search (kNN)

Now for the main event. Vector search in Ickle uses the <-> operator to express a kNN predicate: find the k nearest neighbours of a given vector.

Basic kNN query

Find the 3 beers closest to the "dark roasty" end of our flavour space:

Query query = cache.query(
   "from quickstart.Beer b where b.descriptionEmbedding <-> [:v]~:k");
query.setParameter("v", new float[]{0.9f, 0.1f, 0.1f});
query.setParameter("k", 3);

List results = query.list();
// Returns: Guinness, Tactical Nuclear Penguin, Turia

Both the vector and k are parameterised — you don’t need to interpolate values into the query string.

Score projection

To see how close each result is to the query vector, project the score:

Query query = cache.query(
   "select b.name, b.style, score(b) from quickstart.Beer b " +
   "where b.descriptionEmbedding <-> [:v]~:k");
query.setParameter("v", new float[]{0.05f, 0.9f, 0.1f});
query.setParameter("k", 3);

List results = query.list();
for (Object[] row : results) {
   System.out.printf("%-30s %-20s score=%.4f%n", row[0], row[1], row[2]);
}
// Corona Extra  score=1.0000
// Brahma        score=0.9992
// Estrella      score=0.9985

Hybrid queries: vector + metadata

This is where Ickle really shines. You can combine kNN search with any classic predicate — keyword matches, range filters, full-text search — using a filtering clause.

"Something like a lager, but not too strong"

Find the 3 beers closest to the "light crisp" vector, but only lagers under 5% ABV:

Query query = cache.query(
   "select score(b), b.name, b.style, b.abv from quickstart.Beer b " +
   "where b.descriptionEmbedding <-> [:v]~:k " +
   "filtering (b.style = 'Lager' and b.abv < 5.0)");
query.setParameter("v", new float[]{0.05f, 0.95f, 0.05f});
query.setParameter("k", 3);

List results = query.list();
// Returns: Brahma (4.3%)

Vector search filtered by country

Find beers from Spain closest to a "toasted malty" profile:

Query query = cache.query(
   "select score(b), b.name, b.style, b.abv from quickstart.Beer b " +
   "where b.descriptionEmbedding <-> [:v]~:k filtering b.country = 'Spain'");
query.setParameter("v", new float[]{0.7f, 0.3f, 0.1f});
query.setParameter("k", 3);

List results = query.list();
// Returns: Turia (0.99), Pagoa (0.80), Estrella Galicia (0.75)

Combining full-text and vector search

Find beers whose descriptions mention "citrus" and are closest to the "hoppy craft" vector:

Query query = cache.query(
   "select score(b), b.name, b.brewery, b.abv from quickstart.Beer b " +
   "where b.descriptionEmbedding <-> [:v]~:k " +
   "filtering b.description : 'citrus'");
query.setParameter("v", new float[]{0.1f, 0.1f, 0.95f});
query.setParameter("k", 5);

List results = query.list();
// Returns: Hoptimus Prime (0.9993), Corona Extra (0.6061)

The filtering clause accepts any valid Ickle predicate — including boolean combinations with and / or — so you can build arbitrarily complex filters. The filter is applied before the kNN search, narrowing the candidate set.

Why Infinispan for vector search?

If you’re evaluating vector databases, here is what sets Infinispan apart:

Unified query language. Ickle gives you relational queries, full-text search, and vector kNN search in a single language. No need for a separate "search module" with its own syntax — the same cache.query(…) call handles everything.

Type-safe data modelling. ProtoStream annotations let you define your schema, serialization, and index mappings in one place. The Protobuf schema is generated at compile time, so schema mismatches are caught before they reach production.

Schema evolution. Protobuf’s compatibility guarantees mean you can add new fields (like a vector embedding column) to an existing entity without breaking older clients. Roll out vector search incrementally — existing applications keep working while new ones start populating and querying the embedding field.

Distributed by design. kNN queries work across a distributed cluster. Infinispan scatters data across nodes and fans out vector searches in parallel, merging results transparently.

Multiple access protocols. The same indexed cache is accessible via Hot Rod (Java, C#, JS, Python), REST, and the RESP (Redis-compatible) protocol. Your vector search investment is not locked into a single client ecosystem.

Tuning vector indexing

The @Vector annotation exposes HNSW graph parameters that let you trade indexing speed for search accuracy. These become important with real embedding models where the dimension is much larger (e.g. 384 or 768):

@Vector(
   dimension = 384,                         // match your embedding model
   similarity = VectorSimilarity.COSINE,
   beamWidth = 512,                         // graph construction quality (default: 512)
   maxConnections = 16                      // neighbours per node (default: 16, range: 2-100)
)
float[] descriptionEmbedding;

beamWidth (efConstruction): higher values build a more accurate graph at the cost of slower indexing.
maxConnections (m): controls memory consumption and search precision. Stay in the 2–100 range.
similarity: choose from L2 (default, euclidean), COSINE, INNER_PRODUCT, or MAX_INNER_PRODUCT depending on your embedding model’s recommendations.

Run it yourself

A complete runnable version of this quickstart is available in the infinispan-simple-tutorials repository. It uses Testcontainers to start an Infinispan server automatically — all you need is Docker and Maven:

git clone https://github.com/infinispan/infinispan-simple-tutorials.git
cd infinispan-simple-tutorials
mvn -pl infinispan-remote/vector-search compile exec:exec

The tutorial uses the same 3-dimensional hand-crafted vectors shown in this post. To move to a real embedding model, change the dimension in @Vector and replace the float[] literals with vectors from your model — the query patterns stay identical.

Next steps

Read the full Query guide for Ickle syntax details.
Explore ProtoStream encoding to learn about schema evolution and custom marshallers.
Check out the tutorials for more runnable examples.
Join the conversation on Zulip or GitHub Discussions.

Infinispan Joins the OGX Ecosystem as a Vector IO Provider

2026-04-17T10:00:00+00:00

Infinispan has been integrated into the OGX (Open GenAI Stack), formerly known as Llama Stack, as a vector IO provider, enabling developers to build RAG (Retrieval-Augmented Generation) applications with distributed vector search.

What is OGX?

OGX (Open GenAI Stack) is an open-source agentic API server that composes inference providers, vector stores, safety backends, tool runtimes, and file storage into a single deployable server for building complete AI applications. It serves as a drop-in replacement for the OpenAI API and can run anywhere with any model and infrastructure.

Infinispan’s Vector Capabilities

The integration brings Infinispan’s distributed caching architecture to RAG applications with three powerful search modes:

Vector Search: Embedding-based similarity search using cosine similarity
Keyword Search: Full-text search via Infinispan Query DSL or Ickle
Hybrid Search: Combined vector and keyword search with configurable reranking (RRF or weighted)

Additional features include HTTPS/TLS support, Basic and Digest authentication, and seamless REST API integration.

Try the Demo

Check out our demo project at https://github.com/rigazilla/infinispan-llama-stack-rag-demo that shows how to configure Infinispan as the vector IO backend for OGX RAG workflows, with examples demonstrating document upload, vector embedding storage, and semantic search. As a bonus, you’ll also learn about the fascinating pataphysical science of Chelonofelodynamics!

Learn More

Try it out and let us know what you build!

Exploring the New OpenAPI-Compliant REST API v3 in Infinispan 16.1

2026-04-02T18:00:00+00:00

Exploring the New OpenAPI-Compliant REST API v3 in Infinispan 16.1

With Infinispan 16.1 "Polly Want a Pilsner", we introduce the OpenAPI-compliant v3 REST API, bringing modern API standards to Infinispan.

The Evolution

Infinispan now embraces OpenAPI standards with the new v3 REST API, enabling better tooling, documentation, and developer experience through standardized API descriptions.

What’s New in v3?

Full OpenAPI 3.0 compliance
Interactive Swagger UI at /swagger-ui
Improved endpoint organization and type safety

Getting Started

Start an Infinispan Server 16.1+ and visit http://127.0.0.1:11222/swagger-ui/ to explore and test the API. The OpenAPI schema is available at http://127.0.0.1:11222/rest/v3/openapi.

OpenAPI Benefits

A standardized, rich API description like OpenAPI brings numerous advantages for developers:

Enhanced Documentation: Interactive, always-up-to-date API docs via Swagger UI
Automated Tooling: Generate client libraries in multiple languages automatically
Improved Testing: Built-in API testing interfaces
Polyglot Support: OpenAPI works across programming languages, enabling seamless integration regardless of your tech stack
AI-Assisted Development: AI code assistants can generate accurate client code from the OpenAPI spec, reducing development time and errors

Check out our demo at https://github.com/rigazilla/infinispan-sqlstore-demo/tree/openapi-demo, which demonstrates a live coding session where AI code assistants generate accurate Infinispan client code from the OpenAPI spec, showcasing rapid development and error reduction.

Conclusion

The v3 API brings modern API standards to Infinispan, enhancing developer productivity. Download 16.1, try the new OpenAPI v3 REST interface, and let us know your feedback!

For details, see REST API docs.

Infinispan 16.1

2026-02-04T00:00:00+00:00

"Polly Want a Pilsner"

Infinispan 16.1 is here, and it is codenamed "Polly Want a Pilsner".

It is the first release that follows our time-boxed plan.

Container-based eviction

Prior to this release, it was only possible to configure memory bounds for individual caches.

Infinispan 16.1 introduces the concept of bounded memory containers: configure a global container (you can have more than one), and whether you want it to be bound by count or by memory and reference that container name in the cache configuration.

The following diagram shows the difference between per-cache and container eviction

In the example below, the memory configuration for caches a and b combined will be bounded at 100MB:

OpenAPI / Swagger

Infinispan 10 introduced the v2 REST endpoint which aimed to improve the original API and expand it with all the requirements we added for data and system management. Unfortunately that API was designed in a way that made it impossible to represent via an OpenAPI descriptor.

Infinispan 16.1 introduces a new v3 REST API which is OpenAPI-compliant.

To try it out, start an Infinispan Server and point to http://127.0.0.1:11222/swagger-ui/

Query and Lucene 10

Thanks to the work done by our friends over at Hibernate Search, Infinispan now supports both Lucene 9 and 10.

Infinispan Server

Server now requires Java 25

Our server image has already included Java 25 since 16.0, but we’ve now made this a hard requirement for bare metal deployments too. Don’t worry: the clients can continue running with ye olde legacy Java versions of choice.

Lucene 10.3

By requiring Java 25, the server can now include Lucene 10.3, which can leverage SIMD to increase performance in several areas.

Pre-start batch scripts

The server can now automatically execute batch scripts before start. This feature is primarily intended for our operator in order to prepare the server according to its configuration, but it may also be useful for your own use-cases.

AOT cache in the container image

The server image now includes an AOT cache to reduce startup and warmup time.

CLI batch error handling

The CLI has been enhanced to better report errors during batch execution: you can now decide to fail-fast, fail-at-end or ignore batch errors altogether.

Default mechanisms

Infinispan Server no longer enables weak/vulnerable authentication mechanisms by default: algorithms which use MD5 and SHA-1 must be explicitly enabled if you want to keep using them.

Backwards compatibility

Infinispan 16.1 is fully backwards compatible with 16.0 deployments.

The next release

According to our roadmap, our next release will be 16.2, and it will happen on 2026-06-03.

Release notes

You can look at the release notes to see what was changed since our previous release.

Get them from our download page.

Infinispan Insights: Supporting Redis JSON and Scripting features with Infinispan

2026-01-14T00:00:00+00:00

In Infinispan 15, we added a variety of commands to help replace your Redis server without changing your code. The 15.2 release also included Lua Scripting and Redis JSON APIs. Key takeaways:

Understanding Redis JSON commands
The benefits of Lua scripting
How and why transition applications from Redis to Infinispan, or use Infinispan as a backend while working with Redis clients.

This article follows up on supporting multiple Redis databases with Infinispan. For more details, check out the full article.

Redis drop-in replacement with Infinispan

A drop-in replacement means you can substitute one technology for another without changing application code. This is valuable because:

Minimizes migration effort: You avoid rewriting logic or changing client libraries significantly.
Reduces downtime and risk: You can swap the backend and test incrementally.
Retains existing usage patterns: Developers can continue using the familiar APIs and data models.

Replacing open-source Redis with Infinispan offers several key benefits, especially for Java-based or enterprise-grade systems. Infinispan is fully open source under Apache 2.0, avoiding the licensing limitations of Redis modules. It provides advanced clustering, built-in high availability (Active-Active cross site replication), and better support for distributed and geo-replicated setups. It supports multiple databases even in clustered mode and it offers flexible persistence options like write-through and write-behind. Additionally, it includes robust security features such as fine-grained access control and encryption, and supports multiple deployment modes including embedded, server, and Kubernetes-native.

Let’s test how this works, now also with JSON commands and Lua scripts.

Running Infinispan as usual

Get started tutorial is the best place to start. Just run the following command with docker or podman.

podman/docker run -it -p 11222:11222 -e USER="admin" -e PASS="password" quay.io/infinispan/server:latest

Running Infinispan with the Redis default port

For those want to keep using the 6379 port, run Infinispan providing the following configuration file:

podman/docker run -it -p 6379:6379 -p 11222:11222 -e USER="admin" -e PASS="password" quay.io/infinispan/server:latest -c infinispan-resp.xml

Map -p 6379:6379 -p 11222:11222 (you keep the access to the console)
Provide -c infinispan-resp.xml configuration file
-e USER="admin" -e PASS="password will be used for 11222 port security

Using a Redis client

Once the server is running, connect to Infinispan using Redis-CLI. Use port 11222 instead of the default 6379 if you are running Infinispan as usual. Since Infinispan is secured by default, make sure to provide the admin credentials.

> redis-cli -3 -p 11222 --raw
127.0.0.1:11222> AUTH admin password
OK

Connect using Protocol 3
Use -p 11222 (Infinispan single port)
Add --raw option to allow formatting
Authenticate with admin/password

You can access the Infinispan Server Console as usual in http://localhost:11222, with admin/password credentials. Check the (cache aliases tutorial to learn more about respCache and how it connects to Redis Databases and cache aliases.

Redis JSON Feature

RedisJSON is a powerful extension for managing JSON data directly in Redis. If you’re working with JSON-like data and need fast, efficient access and manipulation, RedisJSON is a great tool to use. This is part of the RedisStack or Redis Enterprise, and works with the JSON Query engine (which is not supported by Infinispan for now).

127.0.0.1:11222> JSON.SET doc $ '{"project":"infinispan", "details": {"latest": "16.0", "year": 2025}}'
OK
127.0.0.1:11222> JSON.GET doc INDENT "\t" NEWLINE "\n" SPACE " " $
[
	{
		"project": "infinispan",
		"details": {
			"latest": "16.0",
			"year": 2025
		}
	}
]
127.0.0.1:11222> JSON.OBJKEYS doc $
project
details

In the console, the REST API currently shows the key, and the value is only displayed as the JSON.Bucket. Additional support for displaying more data is planned for future Infinispan releases, so we just need to wait a bit for the ability to show more content through the REST API.

All JSON commands are implemented for the RESP 3 responses.

Scripting Feature

Lua scripting in Redis lets you write small programs in the Lua language that run directly on the Redis server. This helps you perform multiple actions in one go, saving time and making things faster. You can use it to do complex tasks without sending many commands back and forth between the client and server.

Since Infinispan 16.0, you can now use Lua Scripting to perform these operations.

127.0.0.1:11222> EVAL "return 'Hello, scripting!'" 0
Hello, scripting!
127.0.0.1:11222> EVAL "return ARGV[1]" 0 Hello
Hello
127.0.0.1:11222> EVAL "return ARGV[1]" 0 Parameterization!
Parameterization!
127.0.0.1:11222> EVAL "redis.call('SET', KEYS[1], ARGV[1]) redis.call('SET', KEYS[2], ARGV[2]) redis.call('SET', KEYS[3], ARGV[3]) return 'SET commands executed'" 3 key1 key2 key3 value1 value2 value3
SET commands executed
127.0.0.1:11222> KEYS "*"
key2
key3
key1
doc

Technically speaking, when using Infinispan, scripts are stored in an internal cache ___script_cache. This cache is handled by Infinispan and manipulating it requires admin permissions.

Conclusions

In this tutorial, you’ve learned how to use Infinispan for JSON commands and Scripting from version 16.0. Redis Hot Replacement is gaining attention, especially with the concerns about Redis' licensing changes in 2024. Infinispan, an open-source solution under the Apache 2.0 license, is part of the Commonhaus foundation, allowing free use in your products. If you need official support, you can get it through supported versions of Infinispan.

Infinispan 16.0.5

2025-12-18T00:00:00+00:00

We don’t usually blog about micros… but this is the second time in as many days that I have to break with tradition.

Serious ProtoStream bug with Latin1 strings

If you were using strings that could be represented as Latin1/ISO-8859-1 in your protocol buffer payloads, ProtoStream was corrupting them. ASCII and full UTF-8 were fine. We’ve now fixed this bug. Thanks Sergey Filipkov for reporting this.

Java serialization failure to serialize some collections

Another marshalling bug was affecting Java serialization of some collection types. Thanks Rato for reporting this

Release notes

You can look at the release notes to see what was changed since our previous release.

Get them from our download page.

Infinispan 16.0.4

2025-12-17T00:00:00+00:00

We don’t usually blog about micros, unless there are important things to mention, and in this case we have a couple of significant changes to share with you.

Spring Framework 7 and Spring Boot 4 support

Spring Framework 7 and Spring Boot 4 were released just after we tagged 16.0.0. We were planning on releasing support for these with the 16.1 release at the beginning of February, but we decided it was too important to wait until then. 16.0.4 includes artifacts for both Spring 7 / Boot 4 and Spring 6 / Boot 3. See the documentation for details

Metrics changes

We forgot to make some changes to the default metrics configuration attributes during the 16.0 development cycle, even though that was our intention all along.

JVM metrics are no longer registered by default in embedded mode, as that should be the job of the application and not the library.
Cache names are now included in metrics as tags as opposed to names, which should make querying and charting easier
Legacy metrics name prefixes (base and vendor) have been replaced with more appropriate library names.

All these can be reverted to their old configuration if needed, but trust us: the new defaults are better.

Release notes

You can look at the release notes to see what was changed since our previous release.

Get them from our download page.

Infinispan 16.0 is out!

2025-11-10T00:00:00+00:00

"Keep Rollin'"

Infinispan 16.0 is here, and it is codenamed "Keep Rollin'".

This is a very significant release, as it introduces zero-downtime in-place rolling upgrades: the capability of incrementally upgrading individual nodes in a cluster without having to stop operations.

Final not .Final

Starting with this release, we will no longer be appending .Final to the version number. This release is therefore just 16.0.1. Why not 16.0.0 ? Don’t ask 😀.

In-place rolling upgrades

Starting with Infinispan 16.0, we guarantee that it will be possible to upgrade the nodes of a live Infinispan cluster to a newer version with zero downtime. This guarantee will initially cover point releases (16.0.x → 16.0.y), but we will strive to also maintain it across minor releases (16.x → 16.y): for every new release, we will be providing a table of supported upgrade paths to help you plan your upgrade strategies.

Clustering

The clustering messages, that Infinispan nodes use to communicate with each other, have been rewritten to use Protocol Buffers, via the ProtoStream serialization library. By adopting ProtoBuf’s best practices for schema evolution and a number of supporting tools, we can guarantee that incompatibilities cannot be introduced into these messages without breaking our builds and tests.

Upgrade test harness

We have implemented an extensive test harness, integrated into our CI pipelines, that validates that every change that is made to Infinispan does not break backwards compatibility. This harness exercises every command, supported by coverage reports that help us identify untested code paths.

Console

Since Infinispan 15.2, the console has used PatternFly 6 for its interface. With this major update, we also added new features for users starting from version 16.0.

Update at runtime cache configuration

We have allowed mutating some cache configuration attributes at runtime for a while, and, starting with this release, this can also be done from the Web Console.

A new menu option is now available for administrators:

The runtime properties that can be updated will be listed:

Rolling Upgrade detection

From version 16.0 onward, when a rolling upgrade is in progress, the Console will display a warning to inform users that the operation is underway.

Working behind a Reverse Proxy

Previously, the console URL could not be configured to work behind a reverse proxy. Starting with version 16.0, you can set up Infinispan and the console to run behind one, such as NGINX. The X-Forwarded-Prefix header is now supported by both Infinispan and the console to correctly serve the console and the REST API.

 location /infinispan/console/ {
            proxy_pass http://infinispan:11222/console/;
            proxy_set_header X-Forwarded-Prefix /infinispan;
}

See the Reverse Proxy Simple Tutorial in the Infinispan Simple Tutorials repository for more details.

Schemas Management Client API

Users can now manage ProtoStream Schemas with a dedicated administration API.

RemoteSchemasAdmin admin = remoteCacheManager.administration().schemas(); Optional = admin.get("schemaName");

See the Schemas Simple Tutorial in the Infinispan Simple Tutorials repository for more details.

Query

Refactoring

The various query modules have all been aggregated into the single infinispan-query JAR, greatly simplifying our dependency tree and paving the way for JPMS encapsulation.

Aggregations

Previously, only the count aggregation query could be executed in an indexed clustered query, providing excellent performance. Now, all other aggregation types (such as sum, avg, and others) work in the same way. This improvement comes from the new capabilities in Hibernate Search 8.1, which has been integrated into Infinispan’s internal engine.

Server

We have introduced several fixes and enhancements to the Infinispan Server.

Server container image

The Infinispan Server container image is now built using the bare minimum required components, aiming to provide a significantly reduced attack surface.

Server startup

We have decoupled the server and the cache container start procedure, where they can start concurrently. This provides a faster startup time for the server, that can start replying to requests earlier. This helps in scenarios where the server receive probe requests for liveness and readiness. Also, this allows for better handling when a cache may fail to start allowing other caches to continue operating.

On-demand caches

The caches associated with dedicated connectors, such as Memcached and RESP, do not create the caches at start. These caches are now created on demand at the first access. In case these endpoints are not accessed, the caches are never created.

Updated Lua engine

We are shipping an updated Lua 5.1 engine, for Redis scripting, that includes a number of CVE fixes that have not been applied to the upstream Lua repository. Also, a number of dangerous Lua scripting operations have been disabled. The security of your servers is of the highest priority to us.

JDK improvements

While Infinispan still requires at least JDK 17, we have made several changes to take advantage of the features introduced in newer JDKs, including support for the recently released JDK 25.

Virtual threads

Infinispan by default not utilized Virtual Threads in both Embedded and Server modes. This includes Infinispan enabling virtual threads in JGroups by default. Virtual threads are used by the non-blocking and blocking thread pools in Embedded mode and the blocking thread pool in Server mode. The latter utilizes Netty event loop for its non-blocking thread pool which does not yet support virtual threads.

If necessary is possible to disable by setting the org.infinispan.threads.virtual system property to false.

AOT

Infinispan Server (and the CLI) can leverage OpenJDK’s Ahead-of-Time features introduced in JEP 483 to decrease startup time and initial memory usage.

Fixes

Lots of these. However, should you find something that doesn’t work, head over to our issues and provide any details that help us debug and solve problems.

Deprecations and removals

The old Single File Store has now been completely replaced by the more scalable Soft-Index File Store and cannot be configured declaratively any longer.

Documentation

As usual, many improvements, updates and fixes.

What’s next?

Infinispan is adopting timeboxed releases starting with our next release (16.1). See our roadmap for information. We will soon be blogging more about it.

Release notes

You can look at the release notes to see what was changed since our last development build.

Get them from our download page.