Redis 8's AI Overhaul: Vector Search, Vector Sets, Semantic Cache & Iris Context Engine

Why Redis for AI?

Redis is evolving from a cache middleware into a real-time data infrastructure for AI applications. Traditional business only needed speed, which Redis achieved with in-memory storage. AI applications require storing vectors, similarity search, managing conversation context, and caching inference results—all aligning with Redis's strengths: memory-first, sub-millisecond latency, and rich data structures. The Redis team's 2026 prediction states: "AI applications without a context engine are destined to fail."

Vector Search: Query Engine Internals

AI queries are often fuzzy; e.g., "how to return" and "refund process" share semantics. Exact matching fails, so vector similarity is needed. Redis Query Engine (formerly RediSearch) builds vector indexes on Hash/JSON with three algorithms: FLAT (brute-force), HNSW (approximate nearest neighbor), and SVS-VAMANA (for large-scale datasets).

HNSW recall comes with trade-offs: M controls graph density, EF_CONSTRUCTION controls index-time candidate set, EF_RUNTIME controls query-time search width. Larger values increase recall but also latency—a typical precision-vs-latency trade-off.

FT.CREATE idx ON HASH PREFIX 1 doc:
  SCHEMA title TEXT category TAG
  embedding VECTOR HNSW 6 TYPE FLOAT32 DIM 768
  DISTANCE_METRIC_COSINE

Hybrid queries combine vector similarity with traditional filters. In RAG, filter by category and permissions first, then sort by vector similarity to avoid irrelevant results:

FT.SEARCH idx "(@category:{database})=>[KNN 5 @embedding $vec AS score]"
  PARAMS 2 vec <query_vector> SORTBY score DIALECT 2

Redis 8 supports int8 quantization, compressing float32 to 8-bit integers. This saves 75% memory and cost, improves speed by 30%, with only 0.01% precision drop. Testing shows recall barely changes while memory bills drop significantly.

Vector Sets: antirez's Native Type

Redis 8 introduces Vector Sets, a new native data type developed by antirez. Inspired by sorted sets, but elements are associated with vectors instead of scores. No index creation needed; two commands suffice:

VADD songs ELEMENTS 4 0.5 1.2 0.75 3.8 "song:1"
VSIM songs ELE "song:1" WITHSCORES COUNT 3

VSIM uses HNSW internally, vectors default to 8-bit quantization, and can attach JSON attributes for expression-based filtering.

Comparison with Query Engine:

Positioning : Query Engine builds indexes on Hash/JSON; Vector Sets is a native vector data type.

Usage : Query Engine requires index creation before querying; Vector Sets uses VADD/VSIM directly.

Use Cases : Query Engine for complex hybrid queries (full-text, numeric, vector); Vector Sets for pure similarity search.

Recommendation: Use Vector Sets for pure similarity retrieval—no index management needed. For combined full-text, numeric, and vector queries, Query Engine is required.

Semantic Caching: How LangCache Reduces Costs

LLMs struggle with synonyms, causing repeated reasoning. Semantic caching converts queries to vectors, computes cosine similarity against historical queries, and returns cached answers when similarity exceeds a threshold—bypassing the model. LangCache is a managed semantic cache service on Redis, accessed via REST API. Official claims: 70% cache hit rate, reducing LLM costs by 70% and improving response speed 4x.

Implementation is straightforward: vector retrieval + threshold check + TTL. The managed service handles embedding generation, threshold tuning, and cache expiration. Simply create a Redis 8 vector set to use it.

Agent Context Engine: Redis Iris

Agents lack memory: they forget after a chat and lose context across sessions. In May 2026, Redis released Iris—a real-time context engine with three components:

Context Retriever : Models business entities, auto-generates MCP tools, lets agents navigate data via schema.

Agent Memory : Manages short-term session and long-term persistent memory.

RDI (Real-time Data Ingestion) : Continuously syncs data from relational databases and data warehouses into Redis, ensuring agents have the freshest context.

The strategy is clear: Redis doesn't build models or compete for frameworks; it applies its memory speed to where AI needs it most—context and data freshness.

Conclusion

From vector search in 7.4 to Vector Sets in 8, and now Iris context engine, Redis reassembles its core strengths—memory, sub-millisecond latency, diverse data structures—into an AI data foundation. Building RAG or Agent applications using the vector and semantic cache layers incurs low upfront cost and yields significant savings later.