Redis Feature Trails

RedisVL MCP provides a standardized interface for AI agents to interact with Redis Search indexes, enabling retrieval and upsert operations with configurable search behavior, schema-aware filters, and runtime governance. It simplifies integration by abstracting framework-specific details and offers server-side embedding capabilities. Future plans include support for multiple indexes within a single MCP server instance.

This post introduces the Agent-to-Agent (A2A) protocol, an open standard for communication between independent agents. It details the core primitives (Agent Card, Task, Message, Part, Artifact) and explains that A2A is a wire protocol, not an agent framework or a tool-calling protocol. The primary use case for A2A is when independently deployed agents, especially those owned by different teams or vendors, need a shared communication contract. The post emphasizes that A2A is not necessary for agents within a single trust boundary, where orchestration frameworks suffice. It highlights the importance of explicit identity and authorization at trust boundaries for security, detailing A2A's transport-layer security model, mandatory HTTPS, and reliance on external identity providers for authentication and authorization. The post also touches on the challenges of delegated permissions and the ongoing development of related standards like identity chaining and delegated-scope rules. It notes that while A2A has reported production use, its prevalence is still unclear due to architectural complexities and the need for robust delegation mechanisms.

This post details Redis's response to the Kimi K3 vulnerability claims, outlining the specific vulnerabilities identified (Redis Streams shared-NACK use-after-free, RedisBloom TDigest out-of-bounds write, RedisBloom TopK RDB loader wild-free), the remediation efforts (expedited open-source fixes, security releases for Redis and RedisBloom), and the ongoing process for addressing undisclosed claims. It also reiterates best practices for securing Redis instances, including strong authentication, access control, and network isolation, emphasizing the importance of timely patching.

Redis Data Integration (RDI) is now generally available in Redis Cloud on AWS, simplifying data syncing from operational systems into Redis for applications and AI workloads. RDI enhances AI agents by keeping operational context up-to-date, enabling better decision-making. The GA release includes faster provisioning, improved visibility, better error reporting, higher sync performance, advanced source configuration, and management via the Redis Cloud REST API. New integrations include MongoDB for application acceleration and Snowflake for real-time decisioning. Flex subscriptions now offer tunable RAM-to-Flash ratios (10-50% RAM) for cost and performance optimization, with Flex pricing extended to BYOC deployments.

This post provides a practical guide to model quantization for AI inference. It explains what quantization is, how it speeds up inference by reducing data movement and computation, and when it is most effective. The post details different quantization formats (FP32, FP16, INT8, INT4), their impact on accuracy and performance, and discusses scenarios where quantization might not be beneficial. It also contrasts quantization with other inference optimization techniques like batching and caching, highlighting that quantization makes individual inferences cheaper, while caching can skip the model entirely.

This post introduces the concept of tail latency, explaining why the slowest requests (tail latency) are critical for user experience, especially in high-fan-out systems. It details common causes like queueing, GC pauses, disk I/O, lock contention, and noisy neighbors. The post highlights how an in-memory architecture, like Redis, inherently reduces tail latency by eliminating disk I/O and managed-runtime GC. It also discusses the impact of tail latency on AI workloads, particularly in RAG pipelines, and how semantic caching with Redis Iris can mitigate these issues by providing faster cache hits.

This post introduces and explains dynamic batching as a server-side mechanism to improve GPU utilization in inference servers. It details how dynamic batching combines individual requests into batches at runtime, trading increased latency for higher throughput. The post contrasts dynamic batching with static batching, explains the role of timeout windows, and discusses the limitations of dynamic batching for autoregressive LLMs, leading into the concept of continuous batching. It also highlights the role of semantic caching in reducing the number of requests that need to be batched.

This post provides a detailed comparison between Redis and Google Cloud's Memorystore, highlighting key differences in engine versions, feature sets (vector search, hybrid search, semantic caching, context engine), data structures, persistence, deployment options, and operational control. It aims to guide engineers in choosing the appropriate solution based on their specific needs, particularly for AI workloads, mixed workloads, or multi-cloud environments.

This post details the architecture and techniques for building a real-time fraud detection system, emphasizing latency constraints, feature stores, and the use of specific data structures for velocity calculations. It highlights how Redis can serve as the low-latency inference layer, supporting both exact and probabilistic counting methods for various fraud signals. The discussion covers scaling challenges, the importance of separating training and inference data stores to avoid training-serving skew, and the benefits of using sliding-window data structures like sorted sets, Bloom filters, HyperLogLog, and Count-Min Sketch for efficient feature computation.

This post details the comparison between AWS PrivateLink and VPC peering for connecting to Redis Cloud. It highlights PrivateLink as the recommended default for most deployments due to its enhanced security isolation, operational simplicity across accounts and CIDR ranges, and scoped connectivity. VPC peering is suggested for extremely latency-sensitive workloads where minimal network overhead is critical and network isolation is not a primary concern. Benchmarks indicate a small, measurable latency increase (under 50 µs) with PrivateLink, with no significant throughput impact for workloads below saturation. The post provides guidance on choosing between the two based on latency requirements, network isolation needs, and compliance mandates.

Redis 8.8 introduces a new general-purpose array data structure, offering index-addressable collections of string values. Arrays are dynamic, sparse-friendly, and compute-aware, supporting ring buffer semantics, server-side aggregation (SUM, MIN, MAX, AND, OR, XOR), and search capabilities. Benchmarks show arrays offer significantly better random element access performance compared to lists and competitive performance with hashes, with a moderate increase in memory usage. They are ideal for use cases like document line indexing, stack trace analysis, and workflow tracking. This post elaborates on the array's design, its performance characteristics, and provides practical examples for network port allocation, fixed-size event logs using ring buffers, and pattern searching across sparse data. It also details specific commands like ARGETRANGE, ARSCAN, ARCOUNT, ARLEN, ARING, and ARLASTITEMS, highlighting their use cases and nuances.

This post introduces Conflict-free Replicated Data Types (CRDTs) as a mechanism to enable safer active-active database replication. It explains the challenges of active-active replication, such as write conflicts and data loss, and contrasts CRDTs with traditional approaches like Last Write Wins (LWW) and synchronous consensus protocols. CRDTs are presented as data structures with built-in merge rules that allow concurrent updates to converge to a consistent state without application-level reconciliation. The post uses an inventory counter example to illustrate how CRDTs can signal inconsistencies rather than silently losing data. It highlights that Redis Cloud and Redis Software leverage CRDT semantics for various data types (strings, hashes, lists, sets, sorted sets, streams, JSON, HyperLogLog) to provide multi-region writes with automatic conflict resolution.