Adding changes to the structure

Author: ViktarStarastsenka

content/develop/feature-sets/6-2

@@ -11,39 +11,45 @@ linkTitle: Redis 6.2
 weight: 8
 ---
 
-This page highlights the new features and changes introduced in Redis feature set 6.2.
+Redis version 6.2 introduces new capabilities designed to improve data indexing, querying, and analytics. This update brings multi-value indexing, expanded wildcard query support, and a new probabilistic data structure for quantile estimation. Additionally, significant enhancements to Redis Streams and time series data processing offer greater flexibility for developers working with real-time and historical datasets. Over 25 new commands have been added, addressing key feature requests and further extending Redis' functionality.
+Below is a detailed breakdown of these improvements.
 
 ## New features
 
 ### Multi-value indexing and querying
-Developers can now index and query multi-value attributes across all field types, including TEXT, TAG, NUMERIC, GEO, and VECTOR. This enhancement allows indexing attributes defined by a JSONPath that leads to an array or multiple scalar values, eliminating the previous limitation of indexing only single scalar attributes.
+Redis now supports indexing and querying multi-value attributes across all field types, including `TEXT`, `TAG`, `NUMERIC`, `GEO`, and `VECTOR`. Developers can define JSONPath expressions leading to arrays or multiple scalar values, overcoming the previous limitation of indexing only single scalar attributes.
 
 ### Wildcard query support
-Redis Query Engine now supports suffix and infix wildcard search queries for TEXT and TAG fields, improving flexibility in searching and filtering data.
+The Redis Query Engine now enables suffix and infix wildcard searches for `TEXT` and `TAG` fields. This enhancement provides greater flexibility in data retrieval and filtering.
 
 ### t-digest: a new probabilistic data structure for quantile estimation
-Redis introduces t-digest, a probabilistic data structure designed to estimate quantiles from large datasets or continuous data streams. This is particularly useful for analytics and monitoring applications that require approximate quantile calculations.
+Redis introduces t-digest, an advanced probabilistic data structure that efficiently estimates quantiles in large datasets or continuous data streams. This is particularly beneficial for analytics and monitoring applications where precise quantile calculations are required.
 
 ### Retrieve aggregation results for ongoing time series buckets
-A new option allows retrieving the latest, still-open time series bucket of compactions. This is useful for scenarios where data retention policies limit access to historical raw data, such as tracking event counts over extended periods. By specifying the `LATEST` option, users can now retrieve partially completed buckets.
+A new feature allows users to retrieve the latest, still-open time series buckets during compaction. This is particularly useful when dealing with retention policies that limit access to raw historical data, enabling real-time insights into event counts over extended periods.
 
 ### Time-weighted average aggregator for time series
-A new time-weighted average aggregator has been added to provide more accurate average-over-time calculations. This is particularly useful when dealing with time series data with irregular sampling intervals.
+Redis now includes a time-weighted average aggregator, improving accuracy in average-over-time calculations. This feature is especially valuable for time series data with irregular sampling intervals.
 
 ### Gap-filling for time series data
-Redis now supports gap-filling in time series data, allowing to interpolate missing values or repeat the last known value for empty time buckets. This feature enhances the continuity of time series analytics.
+To improve time series analytics, Redis introduces gap-filling capabilities. This feature allows interpolation of missing values or repetition of the last known value for empty time buckets, ensuring continuity in time series analysis.
 
-## Changes
-Redis introduces over 25 new commands, addressing long-standing feature requests. Among the most notable additions, the long-awaited `ZUNION` and `ZINTER` commands now allow direct result retrieval, unlike their counterparts, ZUNIONSTORE and ZINTERSTORE, which only store results.
+## Improvements
+### Existing data structures
+Redis 6.2 introduces over 25 new commands, fulfilling long-standing community requests. Notably:
 
-Redis streams have also been significantly enhanced. Exclusive range queries are now supported, giving users more precise control over data retrieval. The ability to filter pending messages by idle time improves message management, while a new mechanism simplifies message recovery in consumer groups, making it easier to reclaim lost messages.
+- The long-awaited `ZUNION` and `ZINTER` commands now allow direct retrieval of results, unlike `ZUNIONSTORE` and `ZINTERSTORE`, which store results in a key.
+- Redis Streams enhancements include:
+  - Support for exclusive range queries, providing finer control over data retrieval.
+  - The ability to filter pending messages based on idle time, improving message management.
+  - A simplified mechanism for recovering lost messages in consumer groups, making message reclamation more efficient.
 
 ## Component versions
-The Redis feature set 6.2 includes the following components:
+The Redis version 6.2 is built upon the following component versions:
 
 - [Redis 6.2](https://github.com/redis/redis/blob/6.2/00-RELEASENOTES)
 - [Search 2.6](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes/)
 - [JSON 2.4](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes/)
 - [Time series 1.8](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes/)
 - [Bloom 2.4](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes/)
-- [Graph 2.10](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes/)
+- [Graph 2.10](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes/)

content/develop/feature-sets/7-2

@@ -11,58 +11,56 @@ linkTitle: Redis 7.2
 weight: 9
 ---
 
-This page highlights the new features and changes introduced in Redis feature set 7.2.
+Redis version 7.2 introduces new capabilities, including improved geospatial queries, streamlined JSON data manipulation, and the public preview of Triggers and Functions for event-driven processing. Performance optimizations, client-side enhancements, and behavioral refinements further improve Redis' efficiency, security, and usability.
+Below is a detailed breakdown of these updates.
 
 ## New features
 
 ### Geospatial queries with polygon search
-Redis Query Engine now provides improved support for querying geospatial data using polygon search. This enhancement allows developers to efficiently filter and retrieve data within complex geographic boundaries.
+Redis Query Engine now supports querying geospatial data using polygon search, enabling developers to efficiently filter and retrieve data within complex geographic boundaries.
 
 For example, in a weather monitoring system, Redis can store geospatial data for extreme weather events such as hurricanes, wildfires, or thunderstorms. When a user defines a geographic area of interest, Redis Query Engine quickly retrieves relevant weather alerts within that region, enabling real-time notifications and faster emergency response.
 
 ### Streamlined data manipulation in JSON
-JSON now includes two new commands designed to simplify data manipulation. The `JSON.MERGE` command allows merging a given JSON value into matching paths, enabling more flexible updates. The `JSON.MSET` command provides a way to set or update multiple JSON values simultaneously based on specified key-path-value triplets, improving efficiency when handling structured data.
+JSON now includes two new commands for improved data handling:
+
+- `JSON.MERGE`: Merges a given JSON value into matching paths, allowing more flexible updates.
+- `JSON.MSET`: Sets or updates multiple JSON values simultaneously based on specified key-path-value triplets, improving efficiency when handling structured data.
 
 ### Public preview: Triggers and Functions
-Redis introduces the public preview of Triggers and Functions, an event-driven engine for executing TypeScript/JavaScript code within Redis. This enables efficient in-database data processing, reducing the need for external computation. It also supports cross-shard read operations, which were not available with Lua scripts.
+Redis introduces the public preview of Triggers and Functions, an event-driven engine for executing TypeScript/JavaScript code within Redis. This feature enables efficient in-database data processing, reducing reliance on external computation. It also supports cross-shard read operations, which were previously unavailable with Lua scripts.
 
-## Changes
+## Improvements
+### Existing data structures
+Significant performance improvements have been made across Redis data types. Sorted sets, commonly used for gaming leaderboards, now see performance improvements ranging from [30% to 100%](https://redis.io/blog/introducing-redis-7-2/#:~:text=We%20made%20Redis%20more%20powerful%20for%20developers).
 
-### Memory and speed optimizations
-Redis includes significant performance improvements across Redis data types. For example, sorted sets, commonly used for gaming leaderboards, now see performance gains between [30% and 100%](https://redis.io/blog/introducing-redis-7-2/#:~:text=We%20made%20Redis%20more%20powerful%20for%20developers) due to optimizations in processing and memory efficiency.
+Additionally, Redis stream consumer tracking has been enhanced to provide better visibility into consumer activity, and blocked stream commands now return a distinct error when the target key no longer exists.
 
-Redis Query Engine has also been enhanced with optimized `SORT BY` operations and a new response `FORMAT` in RESP3, improving efficiency and readability.
+### Redis Query Engine improvements
+The Redis Query Engine has received several updates, including optimized `SORT BY` operations and the addition of a new `FORMAT` response in RESP3, improving both efficiency and readability.
 
-### Behavior changes
+### Script execution enhancemets
+Client-side tracking now monitors actual keys read during script execution, improving key usage tracking accuracy. Additionally, blocked commands will re-evaluate security checks before execution, ensuring compliance with updated permissions. Standardized ACL failure messages and error codes now provide clearer error handling.
 
-#### Script execution enhancemets
-Client-side tracking now monitors the actual keys read during script execution rather than relying on declared keys, improving accuracy in key usage tracking.
-Blocked commands now re-evaluate security checks before execution, ensuring compliance with updated permissions.
-Additionally, ACL failure messages and error codes have been standardized, providing clearer and more consistent error handling.
+### Client and replication enhancements
+TLS-based replication now supports Server Name Indication (SNI) to improve compatibility with secure deployments. The `HELLO` command behavior has also been refined to modify client state only upon successful execution, ensuring more predictable client behavior.
 
-#### Client & replication enhancements
-TLS-based replication now supports Server Name Indication (SNI), improving compatibility with secure deployments.
-Additionally, the `HELLO` command has been refined to modify client state only upon successful execution, ensuring more predictable behavior.
 
-#### Streams improvements
-Consumer tracking has been enhanced with seen-time and active-time metrics, providing better visibility into consumer activity. 
-The XREADGROUP and X[AUTO]CLAIM commands now create consumers even when no data is read, ensuring consistency in consumer group management.
-Additionally, blocked stream commands now return a distinct error when the target key no longer exists, improving error clarity.
+## Changes
+
+### Backward-incompatible changes
+Redis 7.2 introduces several backward-incompatible changes. Lua scripts no longer support the print() function, blocking of `PFCOUNT` and `PUBLISH` in read-only scripts, and time sampling freezing during command execution. Error handling updates include case changes in error responses, new behavior for `ZPOPMIN/ZPOPMAX` with count 0, and adjustments to `XCLAIM/XAUTOCLAIM`. ACL changes affect command categorization and key access permissions, while command introspection now includes per-subcommand stats. Redis now allows certain CONFIG commands during loading and tracks stats only when commands execute.
 
-#### Module API changes (potentially breaking)
-The `RM_Call` function now enforces out-of-memory (OOM) checks for scripts only when the 'M' flag is set, refining memory management behavior.
-Module command names now restrict the use of certain special characters to prevent conflicts.
-Replication consistency has been improved for modules utilizing keyspace notifications, ensuring more reliable data synchronization.
-Additionally, commands, configurations, and data types can no longer be registered after the `onload` handler has executed. This change enforces a stricter initialization process, ensuring that all module definitions are finalized before execution begins.
+For more details, see [Redis 7.2 Breaking Changes](https://redis.io/docs/latest/embeds/r7.2-breaking-changes/).
 
-#### Expired keys are now deleted from replica indexes
-Expired keys are now deleted from Redis Query Engine replica indexes, ensuring queries return an empty array instead of nil.
+### Expired keys are now deleted from replica indexes
+Expired keys are now deleted from Redis Query Engine replica indexes, ensuring that queries return an empty array rather than nil when the data no longer exists.
 
 ### Other changes
 Redis Stack 7.2 no longer includes Graph capabilities. For more details, refer to the [RedisGraph End-of-Life Announcement](https://redis.io/blog/redisgraph-eol/#:~:text=After%20January%2031%2C%202025%2C%20RedisGraph,subscriptions%20until%20January%2031%2C%202024.).
 
 ## Component versions
-The Redis feature set 7.2 includes the following components:
+The Redis version 7.2 includes the following components:
 
 - [Redis 7.2](https://github.com/redis/redis/blob/7.2/00-RELEASENOTES)
 - [Search 2.8](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes/)

content/develop/feature-sets/7-4

@@ -11,40 +11,35 @@ linkTitle: Redis 7.4
 weight: 10
 ---
 
-This page highlights the new features and changes introduced in Redis feature set 7.4.
+Redis 7.4 introduces several new features and improvements aimed at enhancing memory efficiency, performance, and ease of use for various applications. These updates include support for hash field expiration, new memory-efficient data types for AI workloads, simplified secondary indexing, and time series optimizations. Additionally, Redis 7.4 brings several behavior and component changes.
 
 ## New features
 
-### Support for hash field expiration
-Redis 7.4 introduces the ability to set expiration times or adjust the remaining TTL for individual hash fields. This long-requested feature enhances memory efficiency and performance for use cases like caching and session storage.
+### Hash field expiration support
 
-### New data types formemory-efficient vector databases 
-To support AI applications and Retrieval Augmented Generation (RAG), Redis 7.4 adds `bfloat16` and `float16` data types, reducing memory usage by up to 47% and latency under load by up to 59%. These optimizations help maximize performance when working with vector data and AI workloads.
+Redis 7.4 adds the ability to set expiration times for individual hash fields or adjust their remaining TTL. This feature, long-requested by users, improves memory efficiency and performance, especially in caching and session storage scenarios.
 
-### Simplified secondary indexing
-Redis Query Engine now offers easier-to-use secondary indexing with the TAG index type:
+### New memory-efficient data types for AI workloads
+With the growing demand for AI applications, Redis 7.4 introduces `bfloat16` and `float16` data types. These new types reduce memory usage by up to 47% and lower latency by as much as 59% under load, making them ideal for vector databases and Retrieval Augmented Generation (RAG) applications.
 
-- Querying tags with special characters (e.g., @, .) no longer requires escaping. Simply wrap query terms in double quotes.
-- Improved handling of empty and missing fields supports more dynamic data models.
-- Additional geospatial search capabilities include [INTERSECT](https://redis.io/docs/latest/develop/interact/search-and-query/query/geo-spatial/) and [DISJOIN](https://redis.io/docs/latest/develop/interact/search-and-query/query/geo-spatial/) operators, as well as better memory usage reporting for indexes.
+### Time series optimization with insertion filters
+Redis 7.4 introduces insertion filters for time series data, allowing sensors to ignore new measurements when the differences in time or value are minimal. This feature helps reduce the size of time series data and boosts efficiency.
 
-Check the [release notes](https://github.com/redis-stack/redis-stack/releases/tag/v7.4.0-v0) for more details.
+## Improvements
 
-### Time series optimization with insertion filters
-Sensors can now use insertion filters to ignore new measurements when differences between time or value are minimal. This reduces time series data size and improves efficiency.
+### Simplified secondary indexing
+The Redis Query Engine now offers a more straightforward approach to secondary indexing with the addition of the `TAG` index type. Querying tags with special characters (like `@` and `.`) is easier, as it no longer requires escaping; simply wrap query terms in double quotes. The update also includes improved handling of empty and missing fields, making the data model more flexible. Geospatial search has been enhanced with new operators, such as `INTERSECT` and `DISJOIN`, and memory usage reporting for indexes has been improved.
 
 ## Changes
 
 ### Behavior changes
-Behavior adjustments in Redis 7.4 include the use of jemalloc instead of libc for allocating Lua VM code, which optimizes memory fragmentation and enhances speed.
-
-Additionally, changes to the ACL LOAD command now ensure that only clients with affected user configurations are disconnected, minimizing unnecessary disruptions.
+Redis 7.4 includes behavior changes such as using jemalloc instead of libc for allocating Lua VM code. This adjustment reduces memory fragmentation and improves performance. Additionally, the `ACL LOAD` command has been modified to ensure that only clients with affected user configurations are disconnected, reducing unnecessary disruptions.
 
 ### Other changes
-Redis Stack 7.4 no longer includes Triggers and Functions due to low adoption during public preview. We removed these to make Redis simpler.
+Redis Stack 7.4 no longer includes Triggers and Functions due to low adoption during its public preview. This removal simplifies Redis and ensures that resources are focused on the most widely used features.
 
 ## Component versions
-The Redis feature set 7.4 includes the following components:
+The Redis version 7.4 includes the following components:
 
 - [Redis 7.4](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redisce/redisce-7.4-release-notes/)
 - [Search 2.10](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.10-release-notes/)